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