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