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