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