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