This source file includes following definitions.
- ax2asc
- ax25cmp
- ax25_remove_socket
- ax25_kill_by_device
- ax25_device_event
- ax25_insert_socket
- ax25_find_listener
- ax25_find_socket
- ax25_find_cb
- ax25_addr_match
- ax25_send_to_raw
- ax25_destroy_timer
- ax25_destroy_socket
- ax25_findbyuid
- ax25_uid_ioctl
- ax25_create_cb
- ax25_fillin_cb
- ax25_send_frame
- ax25rtr_get_dev
- ax25_fcntl
- ax25_setsockopt
- ax25_getsockopt
- ax25_listen
- def_callback1
- def_callback2
- ax25_create
- ax25_make_new
- ax25_dup
- ax25_release
- ax25_bind
- ax25_connect
- ax25_socketpair
- ax25_accept
- ax25_getname
- ax25_rcv
- kiss_rcv
- bpq_rcv
- ax25_sendmsg
- ax25_recvmsg
- ax25_shutdown
- ax25_select
- ax25_ioctl
- ax25_get_info
- ax25_proto_init
- ax25_queue_xmit
- ax25_encapsulate
- ax25_rebuild_header
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78 #include <linux/config.h>
79 #ifdef CONFIG_AX25
80 #include <linux/errno.h>
81 #include <linux/types.h>
82 #include <linux/socket.h>
83 #include <linux/in.h>
84 #include <linux/kernel.h>
85 #include <linux/sched.h>
86 #include <linux/timer.h>
87 #include <linux/string.h>
88 #include <linux/sockios.h>
89 #include <linux/net.h>
90 #include <net/ax25.h>
91 #include <linux/inet.h>
92 #include <linux/netdevice.h>
93 #include <linux/if_arp.h>
94 #include <linux/skbuff.h>
95 #include <net/sock.h>
96 #include <asm/segment.h>
97 #include <asm/system.h>
98 #include <linux/fcntl.h>
99 #include <linux/termios.h>
100 #include <linux/mm.h>
101 #include <linux/interrupt.h>
102 #include <linux/notifier.h>
103 #include <linux/proc_fs.h>
104 #include <linux/stat.h>
105 #include <linux/firewall.h>
106
107 #include <net/ip.h>
108 #include <net/arp.h>
109
110
111
112
113
114
115
116
117 static ax25_cb *volatile ax25_list = NULL;
118
119
120
121
122 char *ax2asc(ax25_address *a)
123 {
124 static char buf[11];
125 char c, *s;
126 int n;
127
128 for (n = 0, s = buf; n < 6; n++)
129 {
130 c = (a->ax25_call[n] >> 1) & 0x7F;
131
132 if (c != ' ') *s++ = c;
133 }
134
135 *s++ = '-';
136
137 if ((n = ((a->ax25_call[6] >> 1) & 0x0F)) > 9)
138 {
139 *s++ = '1';
140 n -= 10;
141 }
142
143 *s++ = n + '0';
144 *s++ = '\0';
145
146 if (*buf == '\0' || *buf == '-')
147 return "*";
148
149 return buf;
150
151 }
152
153
154
155
156 int ax25cmp(ax25_address *a, ax25_address *b)
157 {
158 int ct = 0;
159
160 while (ct < 6) {
161 if ((a->ax25_call[ct] & 0xFE) != (b->ax25_call[ct] & 0xFE))
162 return 1;
163 ct++;
164 }
165
166 if ((a->ax25_call[ct] & 0x1E) == (b->ax25_call[ct] & 0x1E))
167 return 0;
168
169 return 2;
170 }
171
172
173
174
175 static void ax25_remove_socket(ax25_cb *ax25)
176 {
177 ax25_cb *s;
178 unsigned long flags;
179
180 save_flags(flags);
181 cli();
182
183 if ((s = ax25_list) == ax25) {
184 ax25_list = s->next;
185 restore_flags(flags);
186 return;
187 }
188
189 while (s != NULL && s->next != NULL) {
190 if (s->next == ax25) {
191 s->next = ax25->next;
192 restore_flags(flags);
193 return;
194 }
195
196 s = s->next;
197 }
198
199 restore_flags(flags);
200 }
201
202
203
204
205 static void ax25_kill_by_device(struct device *dev)
206 {
207 ax25_cb *s;
208
209 for (s = ax25_list; s != NULL; s = s->next) {
210 if (s->device == dev) {
211 s->state = AX25_STATE_0;
212 s->device = NULL;
213 if (s->sk != NULL) {
214 s->sk->state = TCP_CLOSE;
215 s->sk->err = ENETUNREACH;
216 if (!s->sk->dead)
217 s->sk->state_change(s->sk);
218 s->sk->dead = 1;
219 }
220 }
221 }
222 }
223
224
225
226
227 static int ax25_device_event(struct notifier_block *this,unsigned long event, void *ptr)
228 {
229 struct device *dev = (struct device *)ptr;
230
231 switch (event) {
232 case NETDEV_UP:
233 ax25_dev_device_up(dev);
234 break;
235 case NETDEV_DOWN:
236 ax25_kill_by_device(dev);
237 ax25_rt_device_down(dev);
238 ax25_dev_device_down(dev);
239 break;
240 default:
241 break;
242 }
243
244 return NOTIFY_DONE;
245 }
246
247
248
249
250 static void ax25_insert_socket(ax25_cb *ax25)
251 {
252 unsigned long flags;
253
254 save_flags(flags);
255 cli();
256
257 ax25->next = ax25_list;
258 ax25_list = ax25;
259
260 restore_flags(flags);
261 }
262
263
264
265
266
267 static struct sock *ax25_find_listener(ax25_address *addr, struct device *dev, int type)
268 {
269 unsigned long flags;
270 ax25_cb *s;
271
272 save_flags(flags);
273 cli();
274
275 for (s = ax25_list; s != NULL; s = s->next) {
276 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 && s->sk->type == type && s->sk->state == TCP_LISTEN) {
277
278 if (s->device == NULL || s->device == dev) {
279 restore_flags(flags);
280 return s->sk;
281 }
282 }
283 }
284
285 restore_flags(flags);
286 return NULL;
287 }
288
289
290
291
292 static struct sock *ax25_find_socket(ax25_address *my_addr, ax25_address *dest_addr, int type)
293 {
294 ax25_cb *s;
295 unsigned long flags;
296
297 save_flags(flags);
298 cli();
299
300 for (s = ax25_list; s != NULL; s = s->next) {
301 if (s->sk != NULL && ax25cmp(&s->source_addr, my_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->sk->type == type) {
302 restore_flags(flags);
303 return s->sk;
304 }
305 }
306
307 restore_flags(flags);
308
309 return NULL;
310 }
311
312
313
314
315
316 static ax25_cb *ax25_find_cb(ax25_address *my_addr, ax25_address *dest_addr, struct device *dev)
317 {
318 ax25_cb *s;
319 unsigned long flags;
320
321 save_flags(flags);
322 cli();
323
324 for (s = ax25_list; s != NULL; s = s->next) {
325 if (s->sk != NULL && s->sk->type != SOCK_SEQPACKET)
326 continue;
327 if (ax25cmp(&s->source_addr, my_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->device == dev) {
328 restore_flags(flags);
329 return s;
330 }
331 }
332
333 restore_flags(flags);
334
335 return NULL;
336 }
337
338
339
340
341 static struct sock *ax25_addr_match(ax25_address *addr)
342 {
343 unsigned long flags;
344 ax25_cb *s;
345
346 save_flags(flags);
347 cli();
348
349 for (s = ax25_list; s != NULL; s = s->next) {
350 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 && s->sk->type == SOCK_RAW) {
351 restore_flags(flags);
352 return s->sk;
353 }
354 }
355
356 restore_flags(flags);
357
358 return NULL;
359 }
360
361 static void ax25_send_to_raw(struct sock *sk, struct sk_buff *skb, int proto)
362 {
363 struct sk_buff *copy;
364
365 while (sk != NULL) {
366 if (sk->type == SOCK_RAW && sk->protocol == proto && sk->rmem_alloc <= sk->rcvbuf) {
367 if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
368 return;
369
370 copy->sk = sk;
371 sk->rmem_alloc += copy->truesize;
372 skb_queue_tail(&sk->receive_queue, copy);
373 if (!sk->dead)
374 sk->data_ready(sk, skb->len);
375 }
376
377 sk = sk->next;
378 }
379 }
380
381
382
383
384 void ax25_destory_socket(ax25_cb *);
385
386
387
388
389 static void ax25_destroy_timer(unsigned long data)
390 {
391 ax25_destroy_socket((ax25_cb *)data);
392 }
393
394
395
396
397
398
399
400 void ax25_destroy_socket(ax25_cb *ax25)
401 {
402 struct sk_buff *skb;
403 unsigned long flags;
404
405 save_flags(flags);
406 cli();
407
408 del_timer(&ax25->timer);
409
410 ax25_remove_socket(ax25);
411 ax25_clear_queues(ax25);
412
413 if (ax25->sk != NULL) {
414 while ((skb = skb_dequeue(&ax25->sk->receive_queue)) != NULL) {
415 if (skb->sk != ax25->sk) {
416 skb->sk->dead = 1;
417 ax25_set_timer(skb->sk->ax25);
418 skb->sk->ax25->state = AX25_STATE_0;
419 }
420
421 kfree_skb(skb, FREE_READ);
422 }
423 }
424
425 if (ax25->digipeat != NULL) {
426 kfree_s(ax25->digipeat, sizeof(ax25_digi));
427 ax25->digipeat = NULL;
428 }
429
430 if (ax25->sk != NULL) {
431 if (ax25->sk->wmem_alloc || ax25->sk->rmem_alloc) {
432 init_timer(&ax25->timer);
433 ax25->timer.expires = jiffies + 10 * HZ;
434 ax25->timer.function = ax25_destroy_timer;
435 ax25->timer.data = (unsigned long)ax25;
436 add_timer(&ax25->timer);
437 } else {
438 kfree_s(ax25->sk, sizeof(*ax25->sk));
439 kfree_s(ax25, sizeof(*ax25));
440 }
441 } else {
442 kfree_s(ax25, sizeof(*ax25));
443 }
444
445 restore_flags(flags);
446 }
447
448
449
450
451
452 ax25_uid_assoc *ax25_uid_list;
453
454 int ax25_uid_policy = 0;
455
456 ax25_address *ax25_findbyuid(uid_t uid)
457 {
458 ax25_uid_assoc *a;
459
460 for (a = ax25_uid_list; a != NULL; a = a->next) {
461 if (a->uid == uid)
462 return &a->call;
463 }
464
465 return NULL;
466 }
467
468 static int ax25_uid_ioctl(int cmd, struct sockaddr_ax25 *sax)
469 {
470 ax25_uid_assoc *a;
471
472 switch (cmd) {
473 case SIOCAX25GETUID:
474 for (a = ax25_uid_list; a != NULL; a = a->next) {
475 if (ax25cmp(&sax->sax25_call, &a->call) == 0)
476 return a->uid;
477 }
478 return -ENOENT;
479 case SIOCAX25ADDUID:
480 if(!suser())
481 return -EPERM;
482 if (ax25_findbyuid(sax->sax25_uid))
483 return -EEXIST;
484 a = (ax25_uid_assoc *)kmalloc(sizeof(*a), GFP_KERNEL);
485 if (a == NULL)
486 return -ENOMEM;
487 a->uid = sax->sax25_uid;
488 a->call = sax->sax25_call;
489 a->next = ax25_uid_list;
490 ax25_uid_list = a;
491 return 0;
492 case SIOCAX25DELUID:
493 {
494 ax25_uid_assoc **l;
495
496 if(!suser())
497 return -EPERM;
498 l = &ax25_uid_list;
499 while ((*l) != NULL) {
500 if (ax25cmp(&((*l)->call), &(sax->sax25_call)) == 0) {
501 a = *l;
502 *l = (*l)->next;
503 kfree_s(a, sizeof(*a));
504 return 0;
505 }
506
507 l = &((*l)->next);
508 }
509 return -ENOENT;
510 }
511 }
512
513 return -EINVAL;
514 }
515
516
517
518
519 static ax25_cb *ax25_create_cb(void)
520 {
521 ax25_cb *ax25;
522
523 if ((ax25 = (ax25_cb *)kmalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
524 return NULL;
525
526 skb_queue_head_init(&ax25->write_queue);
527 skb_queue_head_init(&ax25->frag_queue);
528 skb_queue_head_init(&ax25->ack_queue);
529 skb_queue_head_init(&ax25->reseq_queue);
530
531 init_timer(&ax25->timer);
532
533 ax25->rtt = (AX25_DEF_T1 * PR_SLOWHZ) / 2;
534 ax25->t1 = AX25_DEF_T1 * PR_SLOWHZ;
535 ax25->t2 = AX25_DEF_T2 * PR_SLOWHZ;
536 ax25->t3 = AX25_DEF_T3 * PR_SLOWHZ;
537 ax25->n2 = AX25_DEF_N2;
538
539 ax25->modulus = AX25_DEF_AXDEFMODE;
540 ax25->fragno = 0;
541 ax25->fraglen = 0;
542 ax25->hdrincl = 0;
543 ax25->backoff = AX25_DEF_BACKOFF == 'E';
544 ax25->condition = 0x00;
545 ax25->t1timer = 0;
546 ax25->t2timer = 0;
547 ax25->t3timer = 0;
548 ax25->n2count = 0;
549
550 ax25->va = 0;
551 ax25->vr = 0;
552 ax25->vs = 0;
553
554 if (AX25_DEF_AXDEFMODE == EMODULUS) {
555 ax25->window = AX25_DEF_EWINDOW;
556 } else {
557 ax25->window = AX25_DEF_WINDOW;
558 }
559 ax25->device = NULL;
560 ax25->digipeat = NULL;
561 ax25->sk = NULL;
562
563 ax25->state = AX25_STATE_0;
564
565 memset(&ax25->dest_addr, '\0', sizeof(ax25_address));
566 memset(&ax25->source_addr, '\0', sizeof(ax25_address));
567
568 return ax25;
569 }
570
571
572
573
574
575 static void ax25_fillin_cb(ax25_cb *ax25, struct device *dev)
576 {
577 ax25->device = dev;
578
579 ax25->rtt = ax25_dev_get_value(dev, AX25_VALUES_T1);
580 ax25->t1 = ax25_dev_get_value(dev, AX25_VALUES_T1);
581 ax25->t2 = ax25_dev_get_value(dev, AX25_VALUES_T2);
582 ax25->t3 = ax25_dev_get_value(dev, AX25_VALUES_T3);
583 ax25->n2 = ax25_dev_get_value(dev, AX25_VALUES_N2);
584
585 ax25->modulus = ax25_dev_get_value(dev, AX25_VALUES_AXDEFMODE);
586
587 if (ax25->modulus == MODULUS) {
588 ax25->window = ax25_dev_get_value(dev, AX25_VALUES_WINDOW);
589 } else {
590 ax25->window = ax25_dev_get_value(dev, AX25_VALUES_EWINDOW);
591 }
592
593 ax25->backoff = ax25_dev_get_value(dev, AX25_VALUES_BACKOFF) == 'E';
594 }
595
596 int ax25_send_frame(struct sk_buff *skb, ax25_address *src, ax25_address *dest,
597 ax25_digi *digi, struct device *dev)
598 {
599 ax25_cb *ax25;
600
601 if (skb == NULL)
602 return 0;
603
604
605
606
607 for (ax25 = ax25_list; ax25 != NULL; ax25 = ax25->next) {
608 if (ax25->sk != NULL && ax25->sk->type != SOCK_SEQPACKET)
609 continue;
610
611 if (ax25cmp(&ax25->source_addr, src) == 0 && ax25cmp(&ax25->dest_addr, dest) == 0 && ax25->device == dev) {
612 ax25_output(ax25, skb);
613 return 1;
614 }
615 }
616
617 if ((ax25 = ax25_create_cb()) == NULL)
618 return 0;
619
620 ax25_fillin_cb(ax25, dev);
621
622 memcpy(&ax25->source_addr, src, sizeof(ax25_address));
623 memcpy(&ax25->dest_addr, dest, sizeof(ax25_address));
624
625 if (digi != NULL) {
626 if ((ax25->digipeat = kmalloc(sizeof(ax25_digi), GFP_ATOMIC)) == NULL) {
627 kfree_s(ax25, sizeof(ax25));
628 return 0;
629 }
630 memcpy(ax25->digipeat, digi, sizeof(ax25_digi));
631 }
632
633 ax25_establish_data_link(ax25);
634 ax25_insert_socket(ax25);
635
636 ax25->state = AX25_STATE_1;
637
638 ax25_set_timer(ax25);
639
640 ax25_output(ax25, skb);
641
642 return 1;
643 }
644
645
646
647
648
649
650
651 struct device *ax25rtr_get_dev(ax25_address *addr)
652 {
653 struct device *dev;
654 ax25_address dev_addr;
655
656 for (dev = dev_base; dev != NULL; dev = dev->next) {
657 if (dev->flags & IFF_UP) {
658 switch (dev->type) {
659 case ARPHRD_AX25:
660 if (ax25cmp(addr, (ax25_address *)dev->dev_addr) == 0)
661 return dev;
662 break;
663 case ARPHRD_ETHER:
664 if (arp_query((unsigned char *)&dev_addr, dev->pa_addr, dev))
665 if (ax25cmp(addr, &dev_addr) == 0)
666 return dev;
667 break;
668 default:
669 break;
670 }
671 }
672 }
673
674 return NULL;
675 }
676
677
678
679
680
681
682
683 static int ax25_fcntl(struct socket *sock, unsigned int cmd, unsigned long arg)
684 {
685 switch(cmd)
686 {
687 default:
688 return(-EINVAL);
689 }
690 }
691
692 static int ax25_setsockopt(struct socket *sock, int level, int optname,
693 char *optval, int optlen)
694 {
695 struct sock *sk;
696 int err, opt;
697
698 sk = (struct sock *)sock->data;
699
700 if (level == SOL_SOCKET)
701 return sock_setsockopt(sk, level, optname, optval, optlen);
702
703 if (level != SOL_AX25)
704 return -EOPNOTSUPP;
705
706 if (optval == NULL)
707 return -EINVAL;
708
709 if ((err = verify_area(VERIFY_READ, optval, sizeof(int))) != 0)
710 return err;
711
712 opt = get_fs_long((unsigned long *)optval);
713
714 switch (optname) {
715 case AX25_WINDOW:
716 if (sk->ax25->modulus == MODULUS) {
717 if (opt < 1 || opt > 7)
718 return -EINVAL;
719 } else {
720 if (opt < 1 || opt > 63)
721 return -EINVAL;
722 }
723 sk->ax25->window = opt;
724 return 0;
725
726 case AX25_T1:
727 if (opt < 1)
728 return -EINVAL;
729 sk->ax25->rtt = (opt * PR_SLOWHZ) / 2;
730 return 0;
731
732 case AX25_T2:
733 if (opt < 1)
734 return -EINVAL;
735 sk->ax25->t2 = opt * PR_SLOWHZ;
736 return 0;
737
738 case AX25_N2:
739 if (opt < 1 || opt > 31)
740 return -EINVAL;
741 sk->ax25->n2 = opt;
742 return 0;
743
744 case AX25_T3:
745 if (opt < 1)
746 return -EINVAL;
747 sk->ax25->t3 = opt * PR_SLOWHZ;
748 return 0;
749
750 case AX25_BACKOFF:
751 sk->ax25->backoff = opt ? 1 : 0;
752 return 0;
753
754 case AX25_EXTSEQ:
755 sk->ax25->modulus = opt ? EMODULUS : MODULUS;
756 return 0;
757
758 case AX25_HDRINCL:
759 sk->ax25->hdrincl = opt ? 1 : 0;
760 return 0;
761
762 default:
763 return -ENOPROTOOPT;
764 }
765 }
766
767 static int ax25_getsockopt(struct socket *sock, int level, int optname,
768 char *optval, int *optlen)
769 {
770 struct sock *sk;
771 int val = 0;
772 int err;
773
774 sk = (struct sock *)sock->data;
775
776 if (level == SOL_SOCKET)
777 return sock_getsockopt(sk, level, optname, optval, optlen);
778
779 if (level != SOL_AX25)
780 return -EOPNOTSUPP;
781
782 switch (optname) {
783 case AX25_WINDOW:
784 val = sk->ax25->window;
785 break;
786
787 case AX25_T1:
788 val = (sk->ax25->t1 * 2) / PR_SLOWHZ;
789 break;
790
791 case AX25_T2:
792 val = sk->ax25->t2 / PR_SLOWHZ;
793 break;
794
795 case AX25_N2:
796 val = sk->ax25->n2;
797 break;
798
799 case AX25_T3:
800 val = sk->ax25->t3 / PR_SLOWHZ;
801 break;
802
803 case AX25_BACKOFF:
804 val = sk->ax25->backoff;
805 break;
806
807 case AX25_EXTSEQ:
808 val = (sk->ax25->modulus == EMODULUS);
809 break;
810
811 case AX25_HDRINCL:
812 val = sk->ax25->hdrincl;
813 break;
814
815 default:
816 return -ENOPROTOOPT;
817 }
818
819 if ((err = verify_area(VERIFY_WRITE, optlen, sizeof(int))) != 0)
820 return err;
821
822 put_user(sizeof(int), optlen);
823
824 if ((err = verify_area(VERIFY_WRITE, optval, sizeof(int))) != 0)
825 return err;
826
827 put_user(val, optval);
828
829 return 0;
830 }
831
832 static int ax25_listen(struct socket *sock, int backlog)
833 {
834 struct sock *sk = (struct sock *)sock->data;
835
836 if (sk->type == SOCK_SEQPACKET && sk->state != TCP_LISTEN) {
837 sk->max_ack_backlog = backlog;
838 sk->state = TCP_LISTEN;
839 return 0;
840 }
841
842 return -EOPNOTSUPP;
843 }
844
845 static void def_callback1(struct sock *sk)
846 {
847 if (!sk->dead)
848 wake_up_interruptible(sk->sleep);
849 }
850
851 static void def_callback2(struct sock *sk, int len)
852 {
853 if (!sk->dead)
854 wake_up_interruptible(sk->sleep);
855 }
856
857 static int ax25_create(struct socket *sock, int protocol)
858 {
859 struct sock *sk;
860 ax25_cb *ax25;
861
862 switch (sock->type) {
863 case SOCK_DGRAM:
864 if (protocol == 0 || protocol == AF_AX25)
865 protocol = AX25_P_TEXT;
866 break;
867 case SOCK_SEQPACKET:
868 switch (protocol) {
869 case 0:
870 case AF_AX25:
871 protocol = AX25_P_TEXT;
872 break;
873 case AX25_P_SEGMENT:
874 #ifdef CONFIG_INET
875 case AX25_P_ARP:
876 case AX25_P_IP:
877 #endif
878 #ifdef CONFIG_NETROM
879 case AX25_P_NETROM:
880 #endif
881 return -ESOCKTNOSUPPORT;
882 default:
883 break;
884 }
885 break;
886 case SOCK_RAW:
887 break;
888 default:
889 return -ESOCKTNOSUPPORT;
890 }
891
892 if ((sk = (struct sock *)kmalloc(sizeof(*sk), GFP_ATOMIC)) == NULL)
893 return -ENOMEM;
894
895 if ((ax25 = ax25_create_cb()) == NULL) {
896 kfree_s(sk, sizeof(*sk));
897 return -ENOMEM;
898 }
899
900 skb_queue_head_init(&sk->receive_queue);
901 skb_queue_head_init(&sk->write_queue);
902 skb_queue_head_init(&sk->back_log);
903
904 sk->socket = sock;
905 sk->type = sock->type;
906 sk->protocol = protocol;
907 sk->dead = 0;
908 sk->next = NULL;
909 sk->broadcast = 0;
910 sk->allocation = GFP_KERNEL;
911 sk->rcvbuf = SK_RMEM_MAX;
912 sk->sndbuf = SK_WMEM_MAX;
913 sk->wmem_alloc = 0;
914 sk->rmem_alloc = 0;
915 sk->inuse = 0;
916 sk->debug = 0;
917 sk->destroy = 0;
918 sk->prot = NULL;
919 sk->err = 0;
920 sk->localroute = 0;
921 sk->send_head = NULL;
922 sk->state = TCP_CLOSE;
923 sk->shutdown = 0;
924 sk->priority = SOPRI_NORMAL;
925 sk->ack_backlog = 0;
926 sk->mtu = AX25_MTU;
927 sk->zapped = 1;
928
929 sk->state_change = def_callback1;
930 sk->data_ready = def_callback2;
931 sk->write_space = def_callback1;
932 sk->error_report = def_callback1;
933
934 if (sock != NULL) {
935 sock->data = (void *)sk;
936 sk->sleep = sock->wait;
937 }
938
939 ax25->sk = sk;
940 sk->ax25 = ax25;
941
942 return 0;
943 }
944
945 static struct sock *ax25_make_new(struct sock *osk, struct device *dev)
946 {
947 struct sock *sk;
948 ax25_cb *ax25;
949
950 if ((sk = (struct sock *)kmalloc(sizeof(*sk), GFP_ATOMIC)) == NULL)
951 return NULL;
952
953 if ((ax25 = ax25_create_cb()) == NULL) {
954 kfree_s(sk, sizeof(*sk));
955 return NULL;
956 }
957
958 ax25_fillin_cb(ax25, dev);
959
960 sk->type = osk->type;
961 sk->socket = osk->socket;
962
963 switch(osk->type)
964 {
965 case SOCK_DGRAM:
966 break;
967 case SOCK_SEQPACKET:
968 break;
969 default:
970 kfree_s((void *)sk, sizeof(*sk));
971 kfree_s((void *)ax25, sizeof(*ax25));
972 return NULL;
973 }
974
975 skb_queue_head_init(&sk->receive_queue);
976 skb_queue_head_init(&sk->write_queue);
977 skb_queue_head_init(&sk->back_log);
978
979 sk->dead = 0;
980 sk->next = NULL;
981 sk->priority = osk->priority;
982 sk->broadcast = 0;
983 sk->protocol = osk->protocol;
984 sk->rcvbuf = osk->rcvbuf;
985 sk->sndbuf = osk->sndbuf;
986 sk->wmem_alloc = 0;
987 sk->rmem_alloc = 0;
988 sk->inuse = 0;
989 sk->ack_backlog = 0;
990 sk->destroy = 0;
991 sk->prot = NULL;
992 sk->err = 0;
993 sk->localroute = 0;
994 sk->send_head = NULL;
995 sk->debug = osk->debug;
996 sk->state = TCP_ESTABLISHED;
997 sk->window = osk->window;
998 sk->shutdown = 0;
999 sk->mtu = osk->mtu;
1000 sk->sleep = osk->sleep;
1001 sk->zapped = osk->zapped;
1002
1003 sk->state_change = def_callback1;
1004 sk->data_ready = def_callback2;
1005 sk->write_space = def_callback1;
1006 sk->error_report = def_callback1;
1007
1008 ax25->modulus = osk->ax25->modulus;
1009 ax25->backoff = osk->ax25->backoff;
1010 ax25->hdrincl = osk->ax25->hdrincl;
1011 ax25->rtt = osk->ax25->rtt;
1012 ax25->t1 = osk->ax25->t1;
1013 ax25->t2 = osk->ax25->t2;
1014 ax25->t3 = osk->ax25->t3;
1015 ax25->n2 = osk->ax25->n2;
1016
1017 ax25->window = osk->ax25->window;
1018
1019 memcpy(&ax25->source_addr, &osk->ax25->source_addr, sizeof(ax25_address));
1020
1021 if (osk->ax25->digipeat != NULL) {
1022 if ((ax25->digipeat = (ax25_digi *)kmalloc(sizeof(ax25_digi), GFP_ATOMIC)) == NULL) {
1023 kfree_s(sk, sizeof(*sk));
1024 kfree_s(ax25, sizeof(*ax25));
1025 return NULL;
1026 }
1027 }
1028
1029 sk->ax25 = ax25;
1030 ax25->sk = sk;
1031
1032 return sk;
1033 }
1034
1035 static int ax25_dup(struct socket *newsock, struct socket *oldsock)
1036 {
1037 struct sock *sk = (struct sock *)oldsock->data;
1038
1039 return ax25_create(newsock, sk->protocol);
1040 }
1041
1042 static int ax25_release(struct socket *sock, struct socket *peer)
1043 {
1044 struct sock *sk = (struct sock *)sock->data;
1045
1046 if (sk == NULL) return 0;
1047
1048 if (sk->type == SOCK_SEQPACKET) {
1049 switch (sk->ax25->state) {
1050 case AX25_STATE_0:
1051 sk->state = TCP_CLOSE;
1052 sk->state_change(sk);
1053 sk->dead = 1;
1054 ax25_destroy_socket(sk->ax25);
1055 break;
1056
1057 case AX25_STATE_1:
1058 ax25_send_control(sk->ax25, DISC, POLLON, C_COMMAND);
1059 sk->ax25->state = AX25_STATE_0;
1060 sk->state = TCP_CLOSE;
1061 sk->state_change(sk);
1062 sk->dead = 1;
1063 ax25_destroy_socket(sk->ax25);
1064 break;
1065
1066 case AX25_STATE_2:
1067 ax25_send_control(sk->ax25, DM, POLLON, C_RESPONSE);
1068 sk->ax25->state = AX25_STATE_0;
1069 sk->state = TCP_CLOSE;
1070 sk->state_change(sk);
1071 sk->dead = 1;
1072 ax25_destroy_socket(sk->ax25);
1073 break;
1074
1075 case AX25_STATE_3:
1076 case AX25_STATE_4:
1077 ax25_clear_queues(sk->ax25);
1078 sk->ax25->n2count = 0;
1079 ax25_send_control(sk->ax25, DISC, POLLON, C_COMMAND);
1080 sk->ax25->t3timer = 0;
1081 sk->ax25->t1timer = sk->ax25->t1 = ax25_calculate_t1(sk->ax25);
1082 sk->ax25->state = AX25_STATE_2;
1083 sk->state = TCP_CLOSE;
1084 sk->state_change(sk);
1085 sk->dead = 1;
1086 sk->destroy = 1;
1087 break;
1088
1089 default:
1090 break;
1091 }
1092 } else {
1093 sk->state = TCP_CLOSE;
1094 sk->state_change(sk);
1095 sk->dead = 1;
1096 ax25_destroy_socket(sk->ax25);
1097 }
1098
1099 sock->data = NULL;
1100 sk->socket = NULL;
1101
1102 return 0;
1103 }
1104
1105
1106
1107
1108
1109
1110
1111 static int ax25_bind(struct socket *sock, struct sockaddr *uaddr,int addr_len)
1112 {
1113 struct sock *sk;
1114 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1115 struct device *dev;
1116 ax25_address *call;
1117
1118 sk = (struct sock *)sock->data;
1119
1120 if (sk->zapped == 0)
1121 return -EIO;
1122
1123 if (addr_len != sizeof(struct sockaddr_ax25) && addr_len != sizeof(struct full_sockaddr_ax25))
1124 return -EINVAL;
1125
1126 #ifdef DONTDO
1127 if (ax25_find_socket(&addr->fsa_ax25.sax25_call, sk->type) != NULL) {
1128 if (sk->debug)
1129 printk("AX25: bind failed: in use\n");
1130 return -EADDRINUSE;
1131 }
1132 #endif
1133
1134 call = ax25_findbyuid(current->euid);
1135 if (call == NULL && ax25_uid_policy && !suser())
1136 return -EPERM;
1137
1138 if (call == NULL)
1139 memcpy(&sk->ax25->source_addr, &addr->fsa_ax25.sax25_call, sizeof(ax25_address));
1140 else
1141 memcpy(&sk->ax25->source_addr, call, sizeof(ax25_address));
1142
1143 if (addr_len == sizeof(struct full_sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1144 if (!suser())
1145 return -EPERM;
1146 call = &addr->fsa_digipeater[0];
1147 } else {
1148 call = &addr->fsa_ax25.sax25_call;
1149 }
1150
1151 if ((dev = ax25rtr_get_dev(call)) == NULL) {
1152 if (sk->debug)
1153 printk("AX25 bind failed: no device\n");
1154 return -EADDRNOTAVAIL;
1155 }
1156
1157 ax25_fillin_cb(sk->ax25, dev);
1158 ax25_insert_socket(sk->ax25);
1159
1160 sk->zapped = 0;
1161
1162 if (sk->debug)
1163 printk("AX25: socket is bound\n");
1164
1165 return 0;
1166 }
1167
1168 static int ax25_connect(struct socket *sock, struct sockaddr *uaddr,
1169 int addr_len, int flags)
1170 {
1171 struct sock *sk = (struct sock *)sock->data;
1172 struct sockaddr_ax25 *addr = (struct sockaddr_ax25 *)uaddr;
1173 int err;
1174
1175 if (sk->state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
1176 sock->state = SS_CONNECTED;
1177 return 0;
1178 }
1179
1180 if (sk->state == TCP_CLOSE && sock->state == SS_CONNECTING) {
1181 sock->state = SS_UNCONNECTED;
1182 return -ECONNREFUSED;
1183 }
1184
1185 if (sk->state == TCP_ESTABLISHED && sk->type == SOCK_SEQPACKET)
1186 return -EISCONN;
1187
1188 sk->state = TCP_CLOSE;
1189 sock->state = SS_UNCONNECTED;
1190
1191 if (addr_len != sizeof(struct sockaddr_ax25) && addr_len != sizeof(struct full_sockaddr_ax25))
1192 return -EINVAL;
1193 if (addr_len == sizeof(struct full_sockaddr_ax25) && addr->sax25_ndigis != 0) {
1194 int ct = 0;
1195 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)addr;
1196
1197
1198 if (addr->sax25_ndigis < 1 || addr->sax25_ndigis > AX25_MAX_DIGIS)
1199 return -EINVAL;
1200
1201 if (sk->ax25->digipeat == NULL) {
1202 if ((sk->ax25->digipeat = (ax25_digi *)kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL)
1203 return -ENOMEM;
1204 }
1205
1206 sk->ax25->digipeat->ndigi = addr->sax25_ndigis;
1207
1208 while (ct < addr->sax25_ndigis) {
1209 sk->ax25->digipeat->repeated[ct] = 0;
1210 memcpy(&sk->ax25->digipeat->calls[ct], &fsa->fsa_digipeater[ct], sizeof(ax25_address));
1211 ct++;
1212 }
1213
1214 sk->ax25->digipeat->lastrepeat = 0;
1215 }
1216
1217 if (sk->zapped) {
1218 if ((err = ax25_rt_autobind(sk->ax25, &addr->sax25_call)) < 0)
1219 return err;
1220 ax25_insert_socket(sk->ax25);
1221 }
1222
1223 if (sk->type == SOCK_SEQPACKET && ax25_find_cb(&sk->ax25->source_addr, &addr->sax25_call, sk->ax25->device) != NULL)
1224 return -EBUSY;
1225
1226 memcpy(&sk->ax25->dest_addr, &addr->sax25_call, sizeof(ax25_address));
1227
1228
1229 if (sk->type != SOCK_SEQPACKET) {
1230 sock->state = SS_CONNECTED;
1231 sk->state = TCP_ESTABLISHED;
1232 return 0;
1233 }
1234
1235
1236 sock->state = SS_CONNECTING;
1237 sk->state = TCP_SYN_SENT;
1238 ax25_establish_data_link(sk->ax25);
1239 sk->ax25->state = AX25_STATE_1;
1240 ax25_set_timer(sk->ax25);
1241
1242
1243 if (sk->state != TCP_ESTABLISHED && (flags & O_NONBLOCK))
1244 return -EINPROGRESS;
1245
1246 cli();
1247
1248
1249 while (sk->state == TCP_SYN_SENT) {
1250 interruptible_sleep_on(sk->sleep);
1251 if (current->signal & ~current->blocked) {
1252 sti();
1253 return -ERESTARTSYS;
1254 }
1255 }
1256
1257 if (sk->state != TCP_ESTABLISHED)
1258 {
1259
1260 sti();
1261 sock->state = SS_UNCONNECTED;
1262 return sock_error(sk);
1263 }
1264
1265 sock->state = SS_CONNECTED;
1266
1267 sti();
1268
1269 return 0;
1270 }
1271
1272 static int ax25_socketpair(struct socket *sock1, struct socket *sock2)
1273 {
1274 return -EOPNOTSUPP;
1275 }
1276
1277 static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1278 {
1279 struct sock *sk;
1280 struct sock *newsk;
1281 struct sk_buff *skb;
1282
1283 if (newsock->data)
1284 kfree_s(newsock->data, sizeof(struct sock));
1285
1286 newsock->data = NULL;
1287
1288 sk = (struct sock *)sock->data;
1289
1290 if (sk->type != SOCK_SEQPACKET)
1291 return -EOPNOTSUPP;
1292
1293 if (sk->state != TCP_LISTEN)
1294 return -EINVAL;
1295
1296
1297
1298 do {
1299 cli();
1300 if ((skb = skb_dequeue(&sk->receive_queue)) == NULL) {
1301 if (flags & O_NONBLOCK) {
1302 sti();
1303 return 0;
1304 }
1305 interruptible_sleep_on(sk->sleep);
1306 if (current->signal & ~current->blocked) {
1307 sti();
1308 return -ERESTARTSYS;
1309 }
1310 }
1311 } while (skb == NULL);
1312
1313 newsk = skb->sk;
1314 newsk->pair = NULL;
1315 sti();
1316
1317
1318 skb->sk = NULL;
1319 kfree_skb(skb, FREE_READ);
1320 sk->ack_backlog--;
1321 newsock->data = newsk;
1322
1323 return 0;
1324 }
1325
1326 static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1327 int *uaddr_len, int peer)
1328 {
1329 ax25_address *addr;
1330 struct full_sockaddr_ax25 *sax = (struct full_sockaddr_ax25 *)uaddr;
1331 struct sock *sk;
1332 unsigned char ndigi, i;
1333
1334 sk = (struct sock *)sock->data;
1335
1336 if (peer != 0) {
1337 if (sk->state != TCP_ESTABLISHED)
1338 return -ENOTCONN;
1339 addr = &sk->ax25->dest_addr;
1340 } else {
1341 addr = &sk->ax25->source_addr;
1342 }
1343
1344 sax->fsa_ax25.sax25_family = AF_AX25;
1345 memcpy(&sax->fsa_ax25.sax25_call, addr, sizeof(ax25_address));
1346 sax->fsa_ax25.sax25_ndigis = 0;
1347 *uaddr_len = sizeof(struct sockaddr_ax25);
1348
1349
1350 if (sk->ax25->digipeat != NULL) {
1351 ndigi = sk->ax25->digipeat->ndigi;
1352 sax->fsa_ax25.sax25_ndigis = ndigi;
1353 *uaddr_len += sizeof(ax25_address) * ndigi;
1354 for (i = 0; i < ndigi; i++)
1355 memcpy(&sax->fsa_digipeater[i], &sk->ax25->digipeat->calls[i], sizeof(ax25_address));
1356 }
1357
1358 return 0;
1359 }
1360
1361 static int ax25_rcv(struct sk_buff *skb, struct device *dev, ax25_address *dev_addr, struct packet_type *ptype)
1362 {
1363 struct sock *make;
1364 struct sock *sk;
1365 int type = 0;
1366 ax25_digi dp;
1367 ax25_cb *ax25;
1368 ax25_address src, dest;
1369 struct sock *raw;
1370 int mine = 0;
1371
1372
1373
1374
1375
1376 skb->h.raw = skb->data;
1377
1378 #ifdef CONFIG_FIREWALL
1379
1380 if(call_in_firewall(PF_AX25, skb, skb->h.raw)!=FW_ACCEPT)
1381 {
1382 kfree_skb(skb, FREE_READ);
1383 return 0;
1384 }
1385 #endif
1386
1387
1388
1389
1390
1391 if (ax25_parse_addr(skb->data, skb->len, &src, &dest, &dp, &type) == NULL) {
1392 kfree_skb(skb, FREE_READ);
1393 return 0;
1394 }
1395
1396
1397
1398
1399 ax25_rt_rx_frame(&src, dev, &dp);
1400
1401
1402
1403
1404 if (dp.lastrepeat + 1 < dp.ndigi) {
1405 if (ax25cmp(&dp.calls[dp.lastrepeat + 1], dev_addr) == 0)
1406 {
1407 struct device *dev_out = dev;
1408
1409
1410
1411 dp.lastrepeat++;
1412 dp.repeated[(int)dp.lastrepeat] = 1;
1413
1414 if (ax25_dev_get_value(dev, AX25_VALUES_DIGI) & AX25_DIGI_XBAND)
1415 {
1416 while (dp.lastrepeat + 1 < dp.ndigi)
1417 {
1418 struct device *dev_scan;
1419 if ((dev_scan = ax25rtr_get_dev(&dp.calls[dp.lastrepeat + 1])) == NULL)
1420 break;
1421 dp.lastrepeat++;
1422 dp.repeated[(int)dp.lastrepeat] = 1;
1423 dev_out = dev_scan;
1424 }
1425 if (dev != dev_out && (ax25_dev_get_value(dev_out, AX25_VALUES_DIGI) & AX25_DIGI_XBAND) == 0)
1426 kfree_skb(skb, FREE_READ);
1427 }
1428
1429 if (dev == dev_out && (ax25_dev_get_value(dev, AX25_VALUES_DIGI) & AX25_DIGI_INBAND) == 0)
1430 kfree_skb(skb, FREE_READ);
1431
1432 build_ax25_addr(skb->data, &src, &dest, &dp, type, MODULUS);
1433 #ifdef CONFIG_FIREWALL
1434 if(call_fw_firewall(PF_AX25, skb,skb->data)!=FW_ACCEPT)
1435 {
1436 kfree_skb(skb, FREE_READ);
1437 return 0;
1438 }
1439 #endif
1440 skb->arp = 1;
1441 ax25_queue_xmit(skb, dev_out, SOPRI_NORMAL);
1442 } else {
1443 kfree_skb(skb, FREE_READ);
1444 }
1445
1446 return 0;
1447 }
1448
1449
1450
1451
1452 skb_pull(skb, size_ax25_addr(&dp));
1453
1454
1455 if (ax25cmp(&dest, dev_addr) == 0)
1456 mine = 1;
1457
1458 #ifdef CONFIG_NETROM
1459
1460 if (!mine && nr_dev_get(&dest) != NULL)
1461 mine = 1;
1462 #endif
1463
1464 if ((*skb->data & ~0x10) == LAPB_UI) {
1465 skb->h.raw = skb->data + 2;
1466
1467 if ((raw = ax25_addr_match(&dest)) != NULL)
1468 ax25_send_to_raw(raw, skb, skb->data[1]);
1469
1470 if (!mine && ax25cmp(&dest, (ax25_address *)dev->broadcast) != 0) {
1471 kfree_skb(skb, FREE_READ);
1472 return 0;
1473 }
1474
1475
1476 switch (skb->data[1]) {
1477 #ifdef CONFIG_INET
1478 case AX25_P_IP:
1479 skb_pull(skb,2);
1480 ax25_ip_mode_set(&src, dev, 'D');
1481 ip_rcv(skb, dev, ptype);
1482 break;
1483
1484 case AX25_P_ARP:
1485 skb_pull(skb,2);
1486 arp_rcv(skb, dev, ptype);
1487 break;
1488 #endif
1489 case AX25_P_TEXT:
1490
1491 if ((sk = ax25_find_socket(&dest, &src, SOCK_DGRAM)) != NULL) {
1492 if (sk->rmem_alloc >= sk->rcvbuf) {
1493 kfree_skb(skb, FREE_READ);
1494 } else {
1495
1496
1497
1498 skb_pull(skb, 2);
1499 skb_queue_tail(&sk->receive_queue, skb);
1500 skb->sk = sk;
1501 sk->rmem_alloc += skb->truesize;
1502 if (!sk->dead)
1503 sk->data_ready(sk, skb->len);
1504 }
1505 } else {
1506 kfree_skb(skb, FREE_READ);
1507 }
1508 break;
1509
1510 default:
1511 kfree_skb(skb, FREE_READ);
1512 break;
1513 }
1514
1515 return 0;
1516 }
1517
1518
1519
1520
1521
1522
1523 if (!ax25_dev_get_value(dev, AX25_VALUES_CONMODE)) {
1524 kfree_skb(skb, FREE_READ);
1525 return 0;
1526 }
1527
1528
1529 if ((ax25 = ax25_find_cb(&dest, &src, dev)) != NULL) {
1530
1531
1532
1533
1534
1535 if (ax25_process_rx_frame(ax25, skb, type) == 0)
1536 kfree_skb(skb, FREE_READ);
1537
1538 return 0;
1539 }
1540
1541 if ((*skb->data & ~PF) != SABM && (*skb->data & ~PF) != SABME) {
1542
1543
1544
1545
1546 if ((*skb->data & ~PF) != DM && mine)
1547 ax25_return_dm(dev, &src, &dest, &dp);
1548
1549 kfree_skb(skb, FREE_READ);
1550 return 0;
1551 }
1552
1553 if ((sk = ax25_find_listener(&dest, dev, SOCK_SEQPACKET)) != NULL) {
1554 if (sk->ack_backlog == sk->max_ack_backlog || (make = ax25_make_new(sk, dev)) == NULL) {
1555 if (mine)
1556 ax25_return_dm(dev, &src, &dest, &dp);
1557
1558 kfree_skb(skb, FREE_READ);
1559 return 0;
1560 }
1561
1562 ax25 = make->ax25;
1563
1564 skb_queue_head(&sk->receive_queue, skb);
1565
1566 skb->sk = make;
1567 make->state = TCP_ESTABLISHED;
1568 make->pair = sk;
1569
1570 sk->ack_backlog++;
1571 } else {
1572 #ifdef CONFIG_NETROM
1573 if (!mine) {
1574 kfree_skb(skb, FREE_READ);
1575 return 0;
1576 }
1577
1578 if ((ax25 = ax25_create_cb()) == NULL) {
1579 ax25_return_dm(dev, &src, &dest, &dp);
1580 kfree_skb(skb, FREE_READ);
1581 return 0;
1582 }
1583
1584 ax25_fillin_cb(ax25, dev);
1585 #else
1586 if (mine)
1587 ax25_return_dm(dev, &src, &dest, &dp);
1588
1589 kfree_skb(skb, FREE_READ);
1590 return 0;
1591 #endif
1592 }
1593
1594 memcpy(&ax25->source_addr, &dest, sizeof(ax25_address));
1595 memcpy(&ax25->dest_addr, &src, sizeof(ax25_address));
1596
1597
1598
1599
1600 if (dp.ndigi != 0 && ax25->digipeat == NULL && (ax25->digipeat = kmalloc(sizeof(ax25_digi), GFP_ATOMIC)) == NULL) {
1601 kfree_skb(skb, FREE_READ);
1602 ax25_destroy_socket(ax25);
1603 return 0;
1604 }
1605
1606 if (dp.ndigi == 0) {
1607 if (ax25->digipeat != NULL) {
1608 kfree_s(ax25->digipeat, sizeof(ax25_digi));
1609 ax25->digipeat = NULL;
1610 }
1611 } else {
1612
1613 ax25_digi_invert(&dp, ax25->digipeat);
1614 }
1615
1616 if ((*skb->data & ~PF) == SABME) {
1617 ax25->modulus = EMODULUS;
1618 ax25->window = ax25_dev_get_value(dev, AX25_VALUES_EWINDOW);
1619 } else {
1620 ax25->modulus = MODULUS;
1621 ax25->window = ax25_dev_get_value(dev, AX25_VALUES_WINDOW);
1622 }
1623
1624 ax25->device = dev;
1625
1626 ax25_send_control(ax25, UA, POLLON, C_RESPONSE);
1627
1628 ax25->t3timer = ax25->t3;
1629 ax25->state = AX25_STATE_3;
1630
1631 ax25_insert_socket(ax25);
1632
1633 ax25_set_timer(ax25);
1634
1635 if (sk != NULL) {
1636 if (!sk->dead)
1637 sk->data_ready(sk, skb->len );
1638 } else {
1639 kfree_skb(skb, FREE_READ);
1640 }
1641
1642 return 0;
1643 }
1644
1645
1646
1647
1648 static int kiss_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *ptype)
1649 {
1650 skb->sk = NULL;
1651
1652 if ((*skb->data & 0x0F) != 0) {
1653 kfree_skb(skb, FREE_READ);
1654 return 0;
1655 }
1656
1657 skb_pull(skb, AX25_KISS_HEADER_LEN);
1658
1659 return ax25_rcv(skb, dev, (ax25_address *)dev->dev_addr, ptype);
1660 }
1661
1662
1663
1664
1665 static int bpq_rcv(struct sk_buff *skb, struct device *dev, struct packet_type *ptype)
1666 {
1667 ax25_address port_call;
1668 int len;
1669
1670 skb->sk = NULL;
1671
1672 if (!arp_query((unsigned char *)&port_call, dev->pa_addr, dev)) {
1673 kfree_skb(skb, FREE_READ);
1674 return 0;
1675 }
1676
1677 len = skb->data[0] + skb->data[1] * 256 - 5;
1678
1679 skb_pull(skb, 2);
1680 skb_trim(skb, len);
1681
1682 return ax25_rcv(skb, dev, &port_call, ptype);
1683 }
1684
1685 static int ax25_sendmsg(struct socket *sock, struct msghdr *msg, int len, int noblock, int flags)
1686 {
1687 struct sock *sk = (struct sock *)sock->data;
1688 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1689 int err;
1690 struct sockaddr_ax25 sax;
1691 struct sk_buff *skb;
1692 unsigned char *asmptr;
1693 int size;
1694 ax25_digi *dp;
1695 ax25_digi dtmp;
1696 int lv;
1697 int addr_len=msg->msg_namelen;
1698
1699 if (sk->err) {
1700 return sock_error(sk);
1701 }
1702
1703 if (flags|| msg->msg_accrights)
1704 return -EINVAL;
1705
1706 if (sk->zapped)
1707 return -EADDRNOTAVAIL;
1708
1709 if (sk->ax25->device == NULL)
1710 return -ENETUNREACH;
1711
1712 if (usax) {
1713 if (addr_len != sizeof(struct sockaddr_ax25) && addr_len != sizeof(struct full_sockaddr_ax25))
1714 return -EINVAL;
1715 if (usax->sax25_family != AF_AX25)
1716 return -EINVAL;
1717 if (addr_len == sizeof(struct full_sockaddr_ax25) && usax->sax25_ndigis != 0) {
1718 int ct = 0;
1719 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1720
1721
1722 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS)
1723 return -EINVAL;
1724
1725 dtmp.ndigi = usax->sax25_ndigis;
1726
1727 while (ct < usax->sax25_ndigis) {
1728 dtmp.repeated[ct] = 0;
1729 memcpy(&dtmp.calls[ct], &fsa->fsa_digipeater[ct], sizeof(ax25_address));
1730 ct++;
1731 }
1732
1733 dtmp.lastrepeat = 0;
1734 }
1735
1736 memcpy(&sax, usax, sizeof(sax));
1737 if (sk->type == SOCK_SEQPACKET && memcmp(&sk->ax25->dest_addr, &sax.sax25_call, sizeof(ax25_address)) != 0)
1738 return -EISCONN;
1739 if (usax->sax25_ndigis == 0)
1740 dp = NULL;
1741 else
1742 dp = &dtmp;
1743 } else {
1744 if (sk->state != TCP_ESTABLISHED)
1745 return -ENOTCONN;
1746 sax.sax25_family = AF_AX25;
1747 memcpy(&sax.sax25_call, &sk->ax25->dest_addr, sizeof(ax25_address));
1748 dp = sk->ax25->digipeat;
1749 }
1750
1751 if (sk->debug)
1752 printk("AX.25: sendto: Addresses built.\n");
1753
1754
1755 if (sk->debug)
1756 printk("AX.25: sendto: building packet.\n");
1757
1758
1759 size = len + 3 + size_ax25_addr(dp) + AX25_BPQ_HEADER_LEN;
1760
1761 if ((skb = sock_alloc_send_skb(sk, size, 0, 0, &err)) == NULL)
1762 return err;
1763
1764 skb->sk = sk;
1765 skb->free = 1;
1766 skb->arp = 1;
1767
1768 skb_reserve(skb, size - len);
1769
1770 if (sk->debug)
1771 printk("AX.25: Appending user data\n");
1772
1773
1774 memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len);
1775
1776
1777 asmptr = skb_push(skb, 1);
1778 *asmptr = sk->protocol;
1779
1780 if (sk->debug)
1781 printk("AX.25: Transmitting buffer\n");
1782
1783 if (sk->type == SOCK_SEQPACKET) {
1784
1785 if (sk->state != TCP_ESTABLISHED) {
1786 kfree_skb(skb, FREE_WRITE);
1787 return -ENOTCONN;
1788 }
1789
1790 ax25_output(sk->ax25, skb);
1791
1792 return len;
1793 } else {
1794 asmptr = skb_push(skb, 1 + size_ax25_addr(dp));
1795
1796 if (sk->debug) {
1797 printk("Building AX.25 Header (dp=%p).\n", dp);
1798 if (dp != 0)
1799 printk("Num digipeaters=%d\n", dp->ndigi);
1800 }
1801
1802
1803 asmptr += (lv = build_ax25_addr(asmptr, &sk->ax25->source_addr, &sax.sax25_call, dp, C_COMMAND, MODULUS));
1804
1805 if (sk->debug)
1806 printk("Built header (%d bytes)\n",lv);
1807
1808 skb->h.raw = asmptr;
1809
1810 if (sk->debug)
1811 printk("base=%p pos=%p\n", skb->data, asmptr);
1812
1813 *asmptr = LAPB_UI;
1814
1815
1816 ax25_queue_xmit(skb, sk->ax25->device, SOPRI_NORMAL);
1817
1818 return len;
1819 }
1820
1821 }
1822
1823 static int ax25_recvmsg(struct socket *sock, struct msghdr *msg, int size, int noblock, int flags, int *addr_len)
1824 {
1825 struct sock *sk = (struct sock *)sock->data;
1826 struct sockaddr_ax25 *sax = (struct sockaddr_ax25 *)msg->msg_name;
1827 int copied, length;
1828 struct sk_buff *skb;
1829 int er;
1830
1831 if (sk->err) {
1832 return sock_error(sk);
1833 }
1834
1835 if (addr_len != NULL)
1836 *addr_len = sizeof(*sax);
1837
1838
1839
1840
1841
1842 if (sk->type == SOCK_SEQPACKET && sk->state != TCP_ESTABLISHED)
1843 return -ENOTCONN;
1844
1845
1846 if ((skb = skb_recv_datagram(sk, flags, noblock, &er)) == NULL)
1847 return er;
1848
1849 if (sk->ax25->hdrincl) {
1850 length = skb->len + (skb->data - skb->h.raw);
1851 } else {
1852 if (sk->type == SOCK_SEQPACKET)
1853 skb_pull(skb, 1);
1854 length = skb->len;
1855 skb->h.raw = skb->data;
1856 }
1857
1858 copied = (size < length) ? size : length;
1859 skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
1860
1861 if (sax) {
1862 ax25_digi digi;
1863 ax25_address dest;
1864
1865 if (addr_len == (int *)0)
1866 return -EINVAL;
1867 if (*addr_len != sizeof(struct sockaddr_ax25) && *addr_len != sizeof(struct full_sockaddr_ax25))
1868 return -EINVAL;
1869
1870 ax25_parse_addr(skb->data, skb->len, NULL, &dest, &digi, NULL);
1871
1872 sax->sax25_family = AF_AX25;
1873
1874
1875
1876 sax->sax25_ndigis = digi.ndigi;
1877 memcpy(&sax->sax25_call, &dest, sizeof(ax25_address));
1878
1879 *addr_len = sizeof(struct sockaddr_ax25);
1880
1881 if (*addr_len == sizeof(struct full_sockaddr_ax25) && sax->sax25_ndigis != 0) {
1882 int ct = 0;
1883 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1884
1885 while (ct < digi.ndigi) {
1886 memcpy(&fsa->fsa_digipeater[ct], &digi.calls[ct], sizeof(ax25_address));
1887 ct++;
1888 }
1889
1890 *addr_len = sizeof(struct full_sockaddr_ax25);
1891 }
1892 }
1893
1894 skb_free_datagram(skb);
1895
1896 return copied;
1897 }
1898
1899 static int ax25_shutdown(struct socket *sk, int how)
1900 {
1901
1902 return -EOPNOTSUPP;
1903 }
1904
1905 static int ax25_select(struct socket *sock , int sel_type, select_table *wait)
1906 {
1907 struct sock *sk = (struct sock *)sock->data;
1908
1909 return datagram_select(sk, sel_type, wait);
1910 }
1911
1912 static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1913 {
1914 struct sock *sk = (struct sock *)sock->data;
1915 int err;
1916 long amount = 0;
1917
1918 switch (cmd) {
1919 case TIOCOUTQ:
1920 if ((err = verify_area(VERIFY_WRITE, (void *)arg, sizeof(unsigned long))) != 0)
1921 return err;
1922 amount = sk->sndbuf - sk->wmem_alloc;
1923 if (amount < 0)
1924 amount = 0;
1925 put_fs_long(amount, (unsigned long *)arg);
1926 return 0;
1927
1928 case TIOCINQ:
1929 {
1930 struct sk_buff *skb;
1931
1932 if ((skb = skb_peek(&sk->receive_queue)) != NULL)
1933 amount = skb->len;
1934 if ((err = verify_area(VERIFY_WRITE, (void *)arg, sizeof(unsigned long))) != 0)
1935 return err;
1936 put_fs_long(amount, (unsigned long *)arg);
1937 return 0;
1938 }
1939
1940 case SIOCGSTAMP:
1941 if (sk != NULL) {
1942 if (sk->stamp.tv_sec==0)
1943 return -ENOENT;
1944 if ((err = verify_area(VERIFY_WRITE,(void *)arg,sizeof(struct timeval))) != 0)
1945 return err;
1946 memcpy_tofs((void *)arg, &sk->stamp, sizeof(struct timeval));
1947 return 0;
1948 }
1949 return -EINVAL;
1950
1951 case SIOCAX25ADDUID:
1952 case SIOCAX25DELUID:
1953 case SIOCAX25GETUID:
1954 {
1955 struct sockaddr_ax25 sax25;
1956 if ((err = verify_area(VERIFY_READ, (void *)arg, sizeof(struct sockaddr_ax25))) != 0)
1957 return err;
1958 memcpy_fromfs(&sax25, (void *)arg, sizeof(sax25));
1959 return ax25_uid_ioctl(cmd, &sax25);
1960 }
1961
1962 case SIOCAX25NOUID:
1963 if ((err = verify_area(VERIFY_READ, (void *)arg, sizeof(unsigned long))) != 0)
1964 return err;
1965 if(!suser())
1966 return -EPERM;
1967 amount = get_fs_long((void *)arg);
1968 if (amount > AX25_NOUID_BLOCK)
1969 return -EINVAL;
1970 ax25_uid_policy = amount;
1971 return 0;
1972
1973 case SIOCAX25GETPARMS:
1974 case SIOCAX25SETPARMS:
1975 return ax25_dev_ioctl(cmd, (void *)arg);
1976
1977 case SIOCADDRT:
1978 case SIOCDELRT:
1979 if (!suser())
1980 return -EPERM;
1981 return ax25_rt_ioctl(cmd, (void *)arg);
1982
1983 case SIOCGIFADDR:
1984 case SIOCSIFADDR:
1985 case SIOCGIFDSTADDR:
1986 case SIOCSIFDSTADDR:
1987 case SIOCGIFBRDADDR:
1988 case SIOCSIFBRDADDR:
1989 case SIOCGIFNETMASK:
1990 case SIOCSIFNETMASK:
1991 case SIOCGIFMETRIC:
1992 case SIOCSIFMETRIC:
1993 return -EINVAL;
1994
1995 default:
1996 return(dev_ioctl(cmd, (void *)arg));
1997 }
1998
1999
2000 return(0);
2001 }
2002
2003 static int ax25_get_info(char *buffer, char **start, off_t offset, int length, int dummy)
2004 {
2005 ax25_cb *ax25;
2006 struct device *dev;
2007 const char *devname;
2008 int len = 0;
2009 off_t pos = 0;
2010 off_t begin = 0;
2011
2012 cli();
2013
2014 len += sprintf(buffer, "dest_addr src_addr dev st vs vr va t1 t2 t3 n2 rtt wnd Snd-Q Rcv-Q\n");
2015
2016 for (ax25 = ax25_list; ax25 != NULL; ax25 = ax25->next) {
2017 if ((dev = ax25->device) == NULL)
2018 devname = "???";
2019 else
2020 devname = dev->name;
2021
2022 len += sprintf(buffer + len, "%-9s ",
2023 ax2asc(&ax25->dest_addr));
2024 len += sprintf(buffer + len, "%-9s %-4s %2d %3d %3d %3d %3d/%03d %2d/%02d %3d/%03d %2d/%02d %3d %3d",
2025 ax2asc(&ax25->source_addr), devname,
2026 ax25->state,
2027 ax25->vs, ax25->vr, ax25->va,
2028 ax25->t1timer / PR_SLOWHZ,
2029 ax25->t1 / PR_SLOWHZ,
2030 ax25->t2timer / PR_SLOWHZ,
2031 ax25->t2 / PR_SLOWHZ,
2032 ax25->t3timer / PR_SLOWHZ,
2033 ax25->t3 / PR_SLOWHZ,
2034 ax25->n2count, ax25->n2,
2035 ax25->rtt / PR_SLOWHZ,
2036 ax25->window);
2037
2038 if (ax25->sk != NULL) {
2039 len += sprintf(buffer + len, " %5ld %5ld\n",
2040 ax25->sk->wmem_alloc,
2041 ax25->sk->rmem_alloc);
2042 } else {
2043 len += sprintf(buffer + len, "\n");
2044 }
2045
2046 pos = begin + len;
2047
2048 if (pos < offset) {
2049 len = 0;
2050 begin = pos;
2051 }
2052
2053 if (pos > offset + length)
2054 break;
2055 }
2056
2057 sti();
2058
2059 *start = buffer + (offset - begin);
2060 len -= (offset - begin);
2061
2062 if (len > length) len = length;
2063
2064 return(len);
2065 }
2066
2067 static struct proto_ops ax25_proto_ops = {
2068 AF_AX25,
2069
2070 ax25_create,
2071 ax25_dup,
2072 ax25_release,
2073 ax25_bind,
2074 ax25_connect,
2075 ax25_socketpair,
2076 ax25_accept,
2077 ax25_getname,
2078 ax25_select,
2079 ax25_ioctl,
2080 ax25_listen,
2081 ax25_shutdown,
2082 ax25_setsockopt,
2083 ax25_getsockopt,
2084 ax25_fcntl,
2085 ax25_sendmsg,
2086 ax25_recvmsg
2087 };
2088
2089
2090
2091 static struct packet_type ax25_packet_type =
2092 {
2093 0,
2094 0,
2095 kiss_rcv,
2096 NULL,
2097 NULL,
2098 };
2099
2100 static struct packet_type bpq_packet_type =
2101 {
2102 0,
2103 0,
2104 bpq_rcv,
2105 NULL,
2106 NULL,
2107 };
2108
2109 static struct notifier_block ax25_dev_notifier = {
2110 ax25_device_event,
2111 0
2112 };
2113
2114 void ax25_proto_init(struct net_proto *pro)
2115 {
2116 sock_register(ax25_proto_ops.family, &ax25_proto_ops);
2117 ax25_packet_type.type = htons(ETH_P_AX25);
2118 dev_add_pack(&ax25_packet_type);
2119 bpq_packet_type.type = htons(ETH_P_BPQ);
2120 dev_add_pack(&bpq_packet_type);
2121 register_netdevice_notifier(&ax25_dev_notifier);
2122
2123 proc_net_register(&(struct proc_dir_entry) {
2124 PROC_NET_AX25_ROUTE, 10, "ax25_route",
2125 S_IFREG | S_IRUGO, 1, 0, 0,
2126 0, &proc_net_inode_operations,
2127 ax25_rt_get_info
2128 });
2129 proc_net_register(&(struct proc_dir_entry) {
2130 PROC_NET_AX25, 4, "ax25",
2131 S_IFREG | S_IRUGO, 1, 0, 0,
2132 0, &proc_net_inode_operations,
2133 ax25_get_info
2134 });
2135 proc_net_register(&(struct proc_dir_entry) {
2136 PROC_NET_AX25_CALLS, 10, "ax25_calls",
2137 S_IFREG | S_IRUGO, 1, 0, 0,
2138 0, &proc_net_inode_operations,
2139 ax25_cs_get_info
2140 });
2141
2142 printk("G4KLX/GW4PTS AX.25 for Linux. Version 0.30 BETA for Linux NET3.032 (Linux 1.3.35)\n");
2143 }
2144
2145
2146
2147
2148
2149
2150 void ax25_queue_xmit(struct sk_buff *skb, struct device *dev, int pri)
2151 {
2152 static char bcast_addr[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
2153 unsigned char *ptr;
2154 int size;
2155
2156 #ifdef CONFIG_FIREWALL
2157
2158 if(call_out_firewall(PF_AX25, skb, skb->data)!=FW_ACCEPT)
2159 {
2160 kfree_skb(skb, FREE_WRITE);
2161 return;
2162 }
2163
2164 #endif
2165
2166 if (dev->type == ARPHRD_ETHER)
2167 {
2168 if (skb_headroom(skb) < AX25_BPQ_HEADER_LEN)
2169 {
2170 printk("ax25_queue_xmit: not enough space to add BPQ Ether header\n");
2171 skb->free = 1;
2172 kfree_skb(skb, FREE_WRITE);
2173 return;
2174 }
2175
2176 size = skb->len;
2177
2178 ptr = skb_push(skb, 2);
2179
2180 *ptr++ = (size + 5) % 256;
2181 *ptr++ = (size + 5) / 256;
2182
2183 dev->hard_header(skb, dev, ETH_P_BPQ, bcast_addr, NULL, 0);
2184 }
2185 else
2186 {
2187 ptr = skb_push(skb, 1);
2188 *ptr++ = 0;
2189 }
2190
2191 dev_queue_xmit(skb, dev, pri);
2192 }
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205 #ifdef CONFIG_INET
2206
2207 int ax25_encapsulate(struct sk_buff *skb, struct device *dev, unsigned short type, void *daddr,
2208 void *saddr, unsigned len)
2209 {
2210
2211 unsigned char *buff = skb_push(skb, AX25_HEADER_LEN);
2212
2213 *buff++ = 0;
2214
2215 if (daddr != NULL)
2216 memcpy(buff, daddr, dev->addr_len);
2217
2218 buff[6] &= ~LAPB_C;
2219 buff[6] &= ~LAPB_E;
2220 buff[6] |= SSSID_SPARE;
2221 buff += AX25_ADDR_LEN;
2222
2223 if (saddr != NULL)
2224 memcpy(buff, saddr, dev->addr_len);
2225 else
2226 memcpy(buff, dev->dev_addr, dev->addr_len);
2227
2228 buff[6] &= ~LAPB_C;
2229 buff[6] |= LAPB_E;
2230 buff[6] |= SSSID_SPARE;
2231 buff += AX25_ADDR_LEN;
2232
2233 *buff++ = LAPB_UI;
2234
2235
2236 switch (type) {
2237 case ETH_P_IP:
2238 *buff++ = AX25_P_IP;
2239 break;
2240
2241 case ETH_P_ARP:
2242 *buff++ = AX25_P_ARP;
2243 break;
2244 default:
2245 *buff++ = 0;
2246 break;
2247 }
2248
2249 if (daddr != NULL)
2250 return AX25_HEADER_LEN;
2251
2252 return -AX25_HEADER_LEN;
2253 }
2254
2255 int ax25_rebuild_header(unsigned char *bp, struct device *dev, unsigned long dest, struct sk_buff *skb)
2256 {
2257 int mode;
2258
2259 if (arp_find(bp + 1, dest, dev, dev->pa_addr, skb))
2260 return 1;
2261
2262 if (bp[16] == AX25_P_IP)
2263 {
2264 mode = ax25_ip_mode_get((ax25_address *)(bp + 1), dev);
2265 if (mode == 'V' || mode == 'v' || (mode == ' ' && ax25_dev_get_value(dev, AX25_VALUES_IPDEFMODE) == 'V'))
2266 {
2267 skb_device_unlock(skb);
2268 skb_pull(skb, AX25_HEADER_LEN - 1);
2269 ax25_send_frame(skb, (ax25_address *)(bp + 8), (ax25_address *)(bp + 1), NULL, dev);
2270 return 1;
2271 }
2272 }
2273
2274 bp[7] &= ~LAPB_C;
2275 bp[7] &= ~LAPB_E;
2276 bp[7] |= SSSID_SPARE;
2277
2278 bp[14] &= ~LAPB_C;
2279 bp[14] |= LAPB_E;
2280 bp[14] |= SSSID_SPARE;
2281
2282 return 0;
2283 }
2284
2285 #endif
2286
2287 #endif