1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#include <linux/capability.h>
17#include <linux/module.h>
18#include <linux/errno.h>
19#include <linux/types.h>
20#include <linux/socket.h>
21#include <linux/in.h>
22#include <linux/kernel.h>
23#include <linux/sched.h>
24#include <linux/timer.h>
25#include <linux/string.h>
26#include <linux/sockios.h>
27#include <linux/net.h>
28#include <linux/slab.h>
29#include <net/ax25.h>
30#include <linux/inet.h>
31#include <linux/netdevice.h>
32#include <linux/if_arp.h>
33#include <linux/skbuff.h>
34#include <net/sock.h>
35#include <asm/uaccess.h>
36#include <linux/fcntl.h>
37#include <linux/termios.h>
38#include <linux/mm.h>
39#include <linux/interrupt.h>
40#include <linux/notifier.h>
41#include <linux/proc_fs.h>
42#include <linux/stat.h>
43#include <linux/sysctl.h>
44#include <linux/init.h>
45#include <linux/spinlock.h>
46#include <net/net_namespace.h>
47#include <net/tcp_states.h>
48#include <net/ip.h>
49#include <net/arp.h>
50
51
52
53HLIST_HEAD(ax25_list);
54DEFINE_SPINLOCK(ax25_list_lock);
55
56static const struct proto_ops ax25_proto_ops;
57
58static void ax25_free_sock(struct sock *sk)
59{
60 ax25_cb_put(sk_to_ax25(sk));
61}
62
63
64
65
66static void ax25_cb_del(ax25_cb *ax25)
67{
68 if (!hlist_unhashed(&ax25->ax25_node)) {
69 spin_lock_bh(&ax25_list_lock);
70 hlist_del_init(&ax25->ax25_node);
71 spin_unlock_bh(&ax25_list_lock);
72 ax25_cb_put(ax25);
73 }
74}
75
76
77
78
79static void ax25_kill_by_device(struct net_device *dev)
80{
81 ax25_dev *ax25_dev;
82 ax25_cb *s;
83
84 if ((ax25_dev = ax25_dev_ax25dev(dev)) == NULL)
85 return;
86
87 spin_lock_bh(&ax25_list_lock);
88again:
89 ax25_for_each(s, &ax25_list) {
90 if (s->ax25_dev == ax25_dev) {
91 s->ax25_dev = NULL;
92 spin_unlock_bh(&ax25_list_lock);
93 ax25_disconnect(s, ENETUNREACH);
94 spin_lock_bh(&ax25_list_lock);
95
96
97
98
99
100
101
102
103 goto again;
104 }
105 }
106 spin_unlock_bh(&ax25_list_lock);
107}
108
109
110
111
112static int ax25_device_event(struct notifier_block *this, unsigned long event,
113 void *ptr)
114{
115 struct net_device *dev = netdev_notifier_info_to_dev(ptr);
116
117 if (!net_eq(dev_net(dev), &init_net))
118 return NOTIFY_DONE;
119
120
121 if (dev->type != ARPHRD_AX25)
122 return NOTIFY_DONE;
123
124 switch (event) {
125 case NETDEV_UP:
126 ax25_dev_device_up(dev);
127 break;
128 case NETDEV_DOWN:
129 ax25_kill_by_device(dev);
130 ax25_rt_device_down(dev);
131 ax25_dev_device_down(dev);
132 break;
133 default:
134 break;
135 }
136
137 return NOTIFY_DONE;
138}
139
140
141
142
143void ax25_cb_add(ax25_cb *ax25)
144{
145 spin_lock_bh(&ax25_list_lock);
146 ax25_cb_hold(ax25);
147 hlist_add_head(&ax25->ax25_node, &ax25_list);
148 spin_unlock_bh(&ax25_list_lock);
149}
150
151
152
153
154
155struct sock *ax25_find_listener(ax25_address *addr, int digi,
156 struct net_device *dev, int type)
157{
158 ax25_cb *s;
159
160 spin_lock(&ax25_list_lock);
161 ax25_for_each(s, &ax25_list) {
162 if ((s->iamdigi && !digi) || (!s->iamdigi && digi))
163 continue;
164 if (s->sk && !ax25cmp(&s->source_addr, addr) &&
165 s->sk->sk_type == type && s->sk->sk_state == TCP_LISTEN) {
166
167 if (s->ax25_dev == NULL || s->ax25_dev->dev == dev) {
168 sock_hold(s->sk);
169 spin_unlock(&ax25_list_lock);
170 return s->sk;
171 }
172 }
173 }
174 spin_unlock(&ax25_list_lock);
175
176 return NULL;
177}
178
179
180
181
182struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
183 int type)
184{
185 struct sock *sk = NULL;
186 ax25_cb *s;
187
188 spin_lock(&ax25_list_lock);
189 ax25_for_each(s, &ax25_list) {
190 if (s->sk && !ax25cmp(&s->source_addr, my_addr) &&
191 !ax25cmp(&s->dest_addr, dest_addr) &&
192 s->sk->sk_type == type) {
193 sk = s->sk;
194 sock_hold(sk);
195 break;
196 }
197 }
198
199 spin_unlock(&ax25_list_lock);
200
201 return sk;
202}
203
204
205
206
207
208ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
209 ax25_digi *digi, struct net_device *dev)
210{
211 ax25_cb *s;
212
213 spin_lock_bh(&ax25_list_lock);
214 ax25_for_each(s, &ax25_list) {
215 if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
216 continue;
217 if (s->ax25_dev == NULL)
218 continue;
219 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
220 if (digi != NULL && digi->ndigi != 0) {
221 if (s->digipeat == NULL)
222 continue;
223 if (ax25digicmp(s->digipeat, digi) != 0)
224 continue;
225 } else {
226 if (s->digipeat != NULL && s->digipeat->ndigi != 0)
227 continue;
228 }
229 ax25_cb_hold(s);
230 spin_unlock_bh(&ax25_list_lock);
231
232 return s;
233 }
234 }
235 spin_unlock_bh(&ax25_list_lock);
236
237 return NULL;
238}
239
240EXPORT_SYMBOL(ax25_find_cb);
241
242void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
243{
244 ax25_cb *s;
245 struct sk_buff *copy;
246
247 spin_lock(&ax25_list_lock);
248 ax25_for_each(s, &ax25_list) {
249 if (s->sk != NULL && ax25cmp(&s->source_addr, addr) == 0 &&
250 s->sk->sk_type == SOCK_RAW &&
251 s->sk->sk_protocol == proto &&
252 s->ax25_dev->dev == skb->dev &&
253 atomic_read(&s->sk->sk_rmem_alloc) <= s->sk->sk_rcvbuf) {
254 if ((copy = skb_clone(skb, GFP_ATOMIC)) == NULL)
255 continue;
256 if (sock_queue_rcv_skb(s->sk, copy) != 0)
257 kfree_skb(copy);
258 }
259 }
260 spin_unlock(&ax25_list_lock);
261}
262
263
264
265
266void ax25_destroy_socket(ax25_cb *);
267
268
269
270
271static void ax25_destroy_timer(unsigned long data)
272{
273 ax25_cb *ax25=(ax25_cb *)data;
274 struct sock *sk;
275
276 sk=ax25->sk;
277
278 bh_lock_sock(sk);
279 sock_hold(sk);
280 ax25_destroy_socket(ax25);
281 bh_unlock_sock(sk);
282 sock_put(sk);
283}
284
285
286
287
288
289
290
291void ax25_destroy_socket(ax25_cb *ax25)
292{
293 struct sk_buff *skb;
294
295 ax25_cb_del(ax25);
296
297 ax25_stop_heartbeat(ax25);
298 ax25_stop_t1timer(ax25);
299 ax25_stop_t2timer(ax25);
300 ax25_stop_t3timer(ax25);
301 ax25_stop_idletimer(ax25);
302
303 ax25_clear_queues(ax25);
304
305 if (ax25->sk != NULL) {
306 while ((skb = skb_dequeue(&ax25->sk->sk_receive_queue)) != NULL) {
307 if (skb->sk != ax25->sk) {
308
309 ax25_cb *sax25 = sk_to_ax25(skb->sk);
310
311
312 sock_orphan(skb->sk);
313
314
315 skb->sk->sk_state = TCP_LISTEN;
316
317 ax25_start_heartbeat(sax25);
318 sax25->state = AX25_STATE_0;
319 }
320
321 kfree_skb(skb);
322 }
323 skb_queue_purge(&ax25->sk->sk_write_queue);
324 }
325
326 if (ax25->sk != NULL) {
327 if (sk_has_allocations(ax25->sk)) {
328
329 setup_timer(&ax25->dtimer, ax25_destroy_timer,
330 (unsigned long)ax25);
331 ax25->dtimer.expires = jiffies + 2 * HZ;
332 add_timer(&ax25->dtimer);
333 } else {
334 struct sock *sk=ax25->sk;
335 ax25->sk=NULL;
336 sock_put(sk);
337 }
338 } else {
339 ax25_cb_put(ax25);
340 }
341}
342
343
344
345
346
347
348static int ax25_ctl_ioctl(const unsigned int cmd, void __user *arg)
349{
350 struct ax25_ctl_struct ax25_ctl;
351 ax25_digi digi;
352 ax25_dev *ax25_dev;
353 ax25_cb *ax25;
354 unsigned int k;
355 int ret = 0;
356
357 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
358 return -EFAULT;
359
360 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
361 return -ENODEV;
362
363 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
364 return -EINVAL;
365
366 if (ax25_ctl.arg > ULONG_MAX / HZ && ax25_ctl.cmd != AX25_KILL)
367 return -EINVAL;
368
369 digi.ndigi = ax25_ctl.digi_count;
370 for (k = 0; k < digi.ndigi; k++)
371 digi.calls[k] = ax25_ctl.digi_addr[k];
372
373 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
374 return -ENOTCONN;
375
376 switch (ax25_ctl.cmd) {
377 case AX25_KILL:
378 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
379#ifdef CONFIG_AX25_DAMA_SLAVE
380 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
381 ax25_dama_off(ax25);
382#endif
383 ax25_disconnect(ax25, ENETRESET);
384 break;
385
386 case AX25_WINDOW:
387 if (ax25->modulus == AX25_MODULUS) {
388 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
389 goto einval_put;
390 } else {
391 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
392 goto einval_put;
393 }
394 ax25->window = ax25_ctl.arg;
395 break;
396
397 case AX25_T1:
398 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
399 goto einval_put;
400 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
401 ax25->t1 = ax25_ctl.arg * HZ;
402 break;
403
404 case AX25_T2:
405 if (ax25_ctl.arg < 1 || ax25_ctl.arg > ULONG_MAX / HZ)
406 goto einval_put;
407 ax25->t2 = ax25_ctl.arg * HZ;
408 break;
409
410 case AX25_N2:
411 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
412 goto einval_put;
413 ax25->n2count = 0;
414 ax25->n2 = ax25_ctl.arg;
415 break;
416
417 case AX25_T3:
418 if (ax25_ctl.arg > ULONG_MAX / HZ)
419 goto einval_put;
420 ax25->t3 = ax25_ctl.arg * HZ;
421 break;
422
423 case AX25_IDLE:
424 if (ax25_ctl.arg > ULONG_MAX / (60 * HZ))
425 goto einval_put;
426
427 ax25->idle = ax25_ctl.arg * 60 * HZ;
428 break;
429
430 case AX25_PACLEN:
431 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
432 goto einval_put;
433 ax25->paclen = ax25_ctl.arg;
434 break;
435
436 default:
437 goto einval_put;
438 }
439
440out_put:
441 ax25_cb_put(ax25);
442 return ret;
443
444einval_put:
445 ret = -EINVAL;
446 goto out_put;
447}
448
449static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
450{
451 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
452 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
453 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
454 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
455 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
456 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
457 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
458 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
459
460 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
461 ax25->modulus = AX25_EMODULUS;
462 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
463 } else {
464 ax25->modulus = AX25_MODULUS;
465 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
466 }
467}
468
469
470
471
472
473void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
474{
475 ax25->ax25_dev = ax25_dev;
476
477 if (ax25->ax25_dev != NULL) {
478 ax25_fillin_cb_from_dev(ax25, ax25_dev);
479 return;
480 }
481
482
483
484
485 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
486 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
487 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
488 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
489 ax25->n2 = AX25_DEF_N2;
490 ax25->paclen = AX25_DEF_PACLEN;
491 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
492 ax25->backoff = AX25_DEF_BACKOFF;
493
494 if (AX25_DEF_AXDEFMODE) {
495 ax25->modulus = AX25_EMODULUS;
496 ax25->window = AX25_DEF_EWINDOW;
497 } else {
498 ax25->modulus = AX25_MODULUS;
499 ax25->window = AX25_DEF_WINDOW;
500 }
501}
502
503
504
505
506ax25_cb *ax25_create_cb(void)
507{
508 ax25_cb *ax25;
509
510 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
511 return NULL;
512
513 atomic_set(&ax25->refcount, 1);
514
515 skb_queue_head_init(&ax25->write_queue);
516 skb_queue_head_init(&ax25->frag_queue);
517 skb_queue_head_init(&ax25->ack_queue);
518 skb_queue_head_init(&ax25->reseq_queue);
519
520 ax25_setup_timers(ax25);
521
522 ax25_fillin_cb(ax25, NULL);
523
524 ax25->state = AX25_STATE_0;
525
526 return ax25;
527}
528
529
530
531
532
533
534static int ax25_setsockopt(struct socket *sock, int level, int optname,
535 char __user *optval, unsigned int optlen)
536{
537 struct sock *sk = sock->sk;
538 ax25_cb *ax25;
539 struct net_device *dev;
540 char devname[IFNAMSIZ];
541 unsigned long opt;
542 int res = 0;
543
544 if (level != SOL_AX25)
545 return -ENOPROTOOPT;
546
547 if (optlen < sizeof(unsigned int))
548 return -EINVAL;
549
550 if (get_user(opt, (unsigned int __user *)optval))
551 return -EFAULT;
552
553 lock_sock(sk);
554 ax25 = sk_to_ax25(sk);
555
556 switch (optname) {
557 case AX25_WINDOW:
558 if (ax25->modulus == AX25_MODULUS) {
559 if (opt < 1 || opt > 7) {
560 res = -EINVAL;
561 break;
562 }
563 } else {
564 if (opt < 1 || opt > 63) {
565 res = -EINVAL;
566 break;
567 }
568 }
569 ax25->window = opt;
570 break;
571
572 case AX25_T1:
573 if (opt < 1 || opt > ULONG_MAX / HZ) {
574 res = -EINVAL;
575 break;
576 }
577 ax25->rtt = (opt * HZ) >> 1;
578 ax25->t1 = opt * HZ;
579 break;
580
581 case AX25_T2:
582 if (opt < 1 || opt > ULONG_MAX / HZ) {
583 res = -EINVAL;
584 break;
585 }
586 ax25->t2 = opt * HZ;
587 break;
588
589 case AX25_N2:
590 if (opt < 1 || opt > 31) {
591 res = -EINVAL;
592 break;
593 }
594 ax25->n2 = opt;
595 break;
596
597 case AX25_T3:
598 if (opt < 1 || opt > ULONG_MAX / HZ) {
599 res = -EINVAL;
600 break;
601 }
602 ax25->t3 = opt * HZ;
603 break;
604
605 case AX25_IDLE:
606 if (opt > ULONG_MAX / (60 * HZ)) {
607 res = -EINVAL;
608 break;
609 }
610 ax25->idle = opt * 60 * HZ;
611 break;
612
613 case AX25_BACKOFF:
614 if (opt > 2) {
615 res = -EINVAL;
616 break;
617 }
618 ax25->backoff = opt;
619 break;
620
621 case AX25_EXTSEQ:
622 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
623 break;
624
625 case AX25_PIDINCL:
626 ax25->pidincl = opt ? 1 : 0;
627 break;
628
629 case AX25_IAMDIGI:
630 ax25->iamdigi = opt ? 1 : 0;
631 break;
632
633 case AX25_PACLEN:
634 if (opt < 16 || opt > 65535) {
635 res = -EINVAL;
636 break;
637 }
638 ax25->paclen = opt;
639 break;
640
641 case SO_BINDTODEVICE:
642 if (optlen > IFNAMSIZ)
643 optlen = IFNAMSIZ;
644
645 if (copy_from_user(devname, optval, optlen)) {
646 res = -EFAULT;
647 break;
648 }
649
650 if (sk->sk_type == SOCK_SEQPACKET &&
651 (sock->state != SS_UNCONNECTED ||
652 sk->sk_state == TCP_LISTEN)) {
653 res = -EADDRNOTAVAIL;
654 break;
655 }
656
657 dev = dev_get_by_name(&init_net, devname);
658 if (!dev) {
659 res = -ENODEV;
660 break;
661 }
662
663 ax25->ax25_dev = ax25_dev_ax25dev(dev);
664 ax25_fillin_cb(ax25, ax25->ax25_dev);
665 dev_put(dev);
666 break;
667
668 default:
669 res = -ENOPROTOOPT;
670 }
671 release_sock(sk);
672
673 return res;
674}
675
676static int ax25_getsockopt(struct socket *sock, int level, int optname,
677 char __user *optval, int __user *optlen)
678{
679 struct sock *sk = sock->sk;
680 ax25_cb *ax25;
681 struct ax25_dev *ax25_dev;
682 char devname[IFNAMSIZ];
683 void *valptr;
684 int val = 0;
685 int maxlen, length;
686
687 if (level != SOL_AX25)
688 return -ENOPROTOOPT;
689
690 if (get_user(maxlen, optlen))
691 return -EFAULT;
692
693 if (maxlen < 1)
694 return -EFAULT;
695
696 valptr = (void *) &val;
697 length = min_t(unsigned int, maxlen, sizeof(int));
698
699 lock_sock(sk);
700 ax25 = sk_to_ax25(sk);
701
702 switch (optname) {
703 case AX25_WINDOW:
704 val = ax25->window;
705 break;
706
707 case AX25_T1:
708 val = ax25->t1 / HZ;
709 break;
710
711 case AX25_T2:
712 val = ax25->t2 / HZ;
713 break;
714
715 case AX25_N2:
716 val = ax25->n2;
717 break;
718
719 case AX25_T3:
720 val = ax25->t3 / HZ;
721 break;
722
723 case AX25_IDLE:
724 val = ax25->idle / (60 * HZ);
725 break;
726
727 case AX25_BACKOFF:
728 val = ax25->backoff;
729 break;
730
731 case AX25_EXTSEQ:
732 val = (ax25->modulus == AX25_EMODULUS);
733 break;
734
735 case AX25_PIDINCL:
736 val = ax25->pidincl;
737 break;
738
739 case AX25_IAMDIGI:
740 val = ax25->iamdigi;
741 break;
742
743 case AX25_PACLEN:
744 val = ax25->paclen;
745 break;
746
747 case SO_BINDTODEVICE:
748 ax25_dev = ax25->ax25_dev;
749
750 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
751 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
752 length = strlen(devname) + 1;
753 } else {
754 *devname = '\0';
755 length = 1;
756 }
757
758 valptr = (void *) devname;
759 break;
760
761 default:
762 release_sock(sk);
763 return -ENOPROTOOPT;
764 }
765 release_sock(sk);
766
767 if (put_user(length, optlen))
768 return -EFAULT;
769
770 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
771}
772
773static int ax25_listen(struct socket *sock, int backlog)
774{
775 struct sock *sk = sock->sk;
776 int res = 0;
777
778 lock_sock(sk);
779 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
780 sk->sk_max_ack_backlog = backlog;
781 sk->sk_state = TCP_LISTEN;
782 goto out;
783 }
784 res = -EOPNOTSUPP;
785
786out:
787 release_sock(sk);
788
789 return res;
790}
791
792
793
794
795
796static struct proto ax25_proto = {
797 .name = "AX25",
798 .owner = THIS_MODULE,
799 .obj_size = sizeof(struct ax25_sock),
800};
801
802static int ax25_create(struct net *net, struct socket *sock, int protocol,
803 int kern)
804{
805 struct sock *sk;
806 ax25_cb *ax25;
807
808 if (protocol < 0 || protocol > SK_PROTOCOL_MAX)
809 return -EINVAL;
810
811 if (!net_eq(net, &init_net))
812 return -EAFNOSUPPORT;
813
814 switch (sock->type) {
815 case SOCK_DGRAM:
816 if (protocol == 0 || protocol == PF_AX25)
817 protocol = AX25_P_TEXT;
818 break;
819
820 case SOCK_SEQPACKET:
821 switch (protocol) {
822 case 0:
823 case PF_AX25:
824 protocol = AX25_P_TEXT;
825 break;
826 case AX25_P_SEGMENT:
827#ifdef CONFIG_INET
828 case AX25_P_ARP:
829 case AX25_P_IP:
830#endif
831#ifdef CONFIG_NETROM
832 case AX25_P_NETROM:
833#endif
834#ifdef CONFIG_ROSE
835 case AX25_P_ROSE:
836#endif
837 return -ESOCKTNOSUPPORT;
838#ifdef CONFIG_NETROM_MODULE
839 case AX25_P_NETROM:
840 if (ax25_protocol_is_registered(AX25_P_NETROM))
841 return -ESOCKTNOSUPPORT;
842 break;
843#endif
844#ifdef CONFIG_ROSE_MODULE
845 case AX25_P_ROSE:
846 if (ax25_protocol_is_registered(AX25_P_ROSE))
847 return -ESOCKTNOSUPPORT;
848#endif
849 default:
850 break;
851 }
852 break;
853
854 case SOCK_RAW:
855 break;
856 default:
857 return -ESOCKTNOSUPPORT;
858 }
859
860 sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto, kern);
861 if (sk == NULL)
862 return -ENOMEM;
863
864 ax25 = ax25_sk(sk)->cb = ax25_create_cb();
865 if (!ax25) {
866 sk_free(sk);
867 return -ENOMEM;
868 }
869
870 sock_init_data(sock, sk);
871
872 sk->sk_destruct = ax25_free_sock;
873 sock->ops = &ax25_proto_ops;
874 sk->sk_protocol = protocol;
875
876 ax25->sk = sk;
877
878 return 0;
879}
880
881struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
882{
883 struct sock *sk;
884 ax25_cb *ax25, *oax25;
885
886 sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot, 0);
887 if (sk == NULL)
888 return NULL;
889
890 if ((ax25 = ax25_create_cb()) == NULL) {
891 sk_free(sk);
892 return NULL;
893 }
894
895 switch (osk->sk_type) {
896 case SOCK_DGRAM:
897 break;
898 case SOCK_SEQPACKET:
899 break;
900 default:
901 sk_free(sk);
902 ax25_cb_put(ax25);
903 return NULL;
904 }
905
906 sock_init_data(NULL, sk);
907
908 sk->sk_type = osk->sk_type;
909 sk->sk_priority = osk->sk_priority;
910 sk->sk_protocol = osk->sk_protocol;
911 sk->sk_rcvbuf = osk->sk_rcvbuf;
912 sk->sk_sndbuf = osk->sk_sndbuf;
913 sk->sk_state = TCP_ESTABLISHED;
914 sock_copy_flags(sk, osk);
915
916 oax25 = sk_to_ax25(osk);
917
918 ax25->modulus = oax25->modulus;
919 ax25->backoff = oax25->backoff;
920 ax25->pidincl = oax25->pidincl;
921 ax25->iamdigi = oax25->iamdigi;
922 ax25->rtt = oax25->rtt;
923 ax25->t1 = oax25->t1;
924 ax25->t2 = oax25->t2;
925 ax25->t3 = oax25->t3;
926 ax25->n2 = oax25->n2;
927 ax25->idle = oax25->idle;
928 ax25->paclen = oax25->paclen;
929 ax25->window = oax25->window;
930
931 ax25->ax25_dev = ax25_dev;
932 ax25->source_addr = oax25->source_addr;
933
934 if (oax25->digipeat != NULL) {
935 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
936 GFP_ATOMIC);
937 if (ax25->digipeat == NULL) {
938 sk_free(sk);
939 ax25_cb_put(ax25);
940 return NULL;
941 }
942 }
943
944 ax25_sk(sk)->cb = ax25;
945 sk->sk_destruct = ax25_free_sock;
946 ax25->sk = sk;
947
948 return sk;
949}
950
951static int ax25_release(struct socket *sock)
952{
953 struct sock *sk = sock->sk;
954 ax25_cb *ax25;
955
956 if (sk == NULL)
957 return 0;
958
959 sock_hold(sk);
960 sock_orphan(sk);
961 lock_sock(sk);
962 ax25 = sk_to_ax25(sk);
963
964 if (sk->sk_type == SOCK_SEQPACKET) {
965 switch (ax25->state) {
966 case AX25_STATE_0:
967 release_sock(sk);
968 ax25_disconnect(ax25, 0);
969 lock_sock(sk);
970 ax25_destroy_socket(ax25);
971 break;
972
973 case AX25_STATE_1:
974 case AX25_STATE_2:
975 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
976 release_sock(sk);
977 ax25_disconnect(ax25, 0);
978 lock_sock(sk);
979 ax25_destroy_socket(ax25);
980 break;
981
982 case AX25_STATE_3:
983 case AX25_STATE_4:
984 ax25_clear_queues(ax25);
985 ax25->n2count = 0;
986
987 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
988 case AX25_PROTO_STD_SIMPLEX:
989 case AX25_PROTO_STD_DUPLEX:
990 ax25_send_control(ax25,
991 AX25_DISC,
992 AX25_POLLON,
993 AX25_COMMAND);
994 ax25_stop_t2timer(ax25);
995 ax25_stop_t3timer(ax25);
996 ax25_stop_idletimer(ax25);
997 break;
998#ifdef CONFIG_AX25_DAMA_SLAVE
999 case AX25_PROTO_DAMA_SLAVE:
1000 ax25_stop_t3timer(ax25);
1001 ax25_stop_idletimer(ax25);
1002 break;
1003#endif
1004 }
1005 ax25_calculate_t1(ax25);
1006 ax25_start_t1timer(ax25);
1007 ax25->state = AX25_STATE_2;
1008 sk->sk_state = TCP_CLOSE;
1009 sk->sk_shutdown |= SEND_SHUTDOWN;
1010 sk->sk_state_change(sk);
1011 sock_set_flag(sk, SOCK_DESTROY);
1012 break;
1013
1014 default:
1015 break;
1016 }
1017 } else {
1018 sk->sk_state = TCP_CLOSE;
1019 sk->sk_shutdown |= SEND_SHUTDOWN;
1020 sk->sk_state_change(sk);
1021 ax25_destroy_socket(ax25);
1022 }
1023
1024 sock->sk = NULL;
1025 release_sock(sk);
1026 sock_put(sk);
1027
1028 return 0;
1029}
1030
1031
1032
1033
1034
1035
1036
1037static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1038{
1039 struct sock *sk = sock->sk;
1040 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1041 ax25_dev *ax25_dev = NULL;
1042 ax25_uid_assoc *user;
1043 ax25_address call;
1044 ax25_cb *ax25;
1045 int err = 0;
1046
1047 if (addr_len != sizeof(struct sockaddr_ax25) &&
1048 addr_len != sizeof(struct full_sockaddr_ax25))
1049
1050
1051
1052 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1053 (addr_len > sizeof(struct full_sockaddr_ax25)))
1054 return -EINVAL;
1055
1056 if (addr->fsa_ax25.sax25_family != AF_AX25)
1057 return -EINVAL;
1058
1059 user = ax25_findbyuid(current_euid());
1060 if (user) {
1061 call = user->call;
1062 ax25_uid_put(user);
1063 } else {
1064 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1065 return -EACCES;
1066
1067 call = addr->fsa_ax25.sax25_call;
1068 }
1069
1070 lock_sock(sk);
1071
1072 ax25 = sk_to_ax25(sk);
1073 if (!sock_flag(sk, SOCK_ZAPPED)) {
1074 err = -EINVAL;
1075 goto out;
1076 }
1077
1078 ax25->source_addr = call;
1079
1080
1081
1082
1083 if (ax25->ax25_dev != NULL)
1084 goto done;
1085
1086 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1087 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1088 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1089 err = -EADDRNOTAVAIL;
1090 goto out;
1091 }
1092 } else {
1093 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1094 err = -EADDRNOTAVAIL;
1095 goto out;
1096 }
1097 }
1098
1099 if (ax25_dev != NULL)
1100 ax25_fillin_cb(ax25, ax25_dev);
1101
1102done:
1103 ax25_cb_add(ax25);
1104 sock_reset_flag(sk, SOCK_ZAPPED);
1105
1106out:
1107 release_sock(sk);
1108
1109 return err;
1110}
1111
1112
1113
1114
1115static int __must_check ax25_connect(struct socket *sock,
1116 struct sockaddr *uaddr, int addr_len, int flags)
1117{
1118 struct sock *sk = sock->sk;
1119 ax25_cb *ax25 = sk_to_ax25(sk), *ax25t;
1120 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1121 ax25_digi *digi = NULL;
1122 int ct = 0, err = 0;
1123
1124
1125
1126
1127
1128 if (addr_len == sizeof(struct sockaddr_ax25))
1129
1130
1131
1132 ;
1133 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1134
1135
1136
1137 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1138 (addr_len > sizeof(struct full_sockaddr_ax25)))
1139 return -EINVAL;
1140
1141
1142 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1143 return -EINVAL;
1144
1145 lock_sock(sk);
1146
1147
1148 if (sock->state == SS_CONNECTING) {
1149 switch (sk->sk_state) {
1150 case TCP_SYN_SENT:
1151 err = -EINPROGRESS;
1152 goto out_release;
1153
1154 case TCP_ESTABLISHED:
1155 sock->state = SS_CONNECTED;
1156 goto out_release;
1157
1158 case TCP_CLOSE:
1159 sock->state = SS_UNCONNECTED;
1160 err = -ECONNREFUSED;
1161 goto out_release;
1162 }
1163 }
1164
1165 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1166 err = -EISCONN;
1167 goto out_release;
1168 }
1169
1170 sk->sk_state = TCP_CLOSE;
1171 sock->state = SS_UNCONNECTED;
1172
1173 kfree(ax25->digipeat);
1174 ax25->digipeat = NULL;
1175
1176
1177
1178
1179 if (addr_len > sizeof(struct sockaddr_ax25) &&
1180 fsa->fsa_ax25.sax25_ndigis != 0) {
1181
1182 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1183 err = -EINVAL;
1184 goto out_release;
1185 }
1186
1187 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1188 err = -ENOBUFS;
1189 goto out_release;
1190 }
1191
1192 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1193 digi->lastrepeat = -1;
1194
1195 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1196 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1197 AX25_HBIT) && ax25->iamdigi) {
1198 digi->repeated[ct] = 1;
1199 digi->lastrepeat = ct;
1200 } else {
1201 digi->repeated[ct] = 0;
1202 }
1203 digi->calls[ct] = fsa->fsa_digipeater[ct];
1204 ct++;
1205 }
1206 }
1207
1208
1209
1210
1211
1212
1213 if (sock_flag(sk, SOCK_ZAPPED)) {
1214
1215 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1216 current->comm);
1217 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1218 kfree(digi);
1219 goto out_release;
1220 }
1221
1222 ax25_fillin_cb(ax25, ax25->ax25_dev);
1223 ax25_cb_add(ax25);
1224 } else {
1225 if (ax25->ax25_dev == NULL) {
1226 kfree(digi);
1227 err = -EHOSTUNREACH;
1228 goto out_release;
1229 }
1230 }
1231
1232 if (sk->sk_type == SOCK_SEQPACKET &&
1233 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1234 ax25->ax25_dev->dev))) {
1235 kfree(digi);
1236 err = -EADDRINUSE;
1237 ax25_cb_put(ax25t);
1238 goto out_release;
1239 }
1240
1241 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1242 ax25->digipeat = digi;
1243
1244
1245 if (sk->sk_type != SOCK_SEQPACKET) {
1246 sock->state = SS_CONNECTED;
1247 sk->sk_state = TCP_ESTABLISHED;
1248 goto out_release;
1249 }
1250
1251
1252 sock->state = SS_CONNECTING;
1253 sk->sk_state = TCP_SYN_SENT;
1254
1255 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1256 case AX25_PROTO_STD_SIMPLEX:
1257 case AX25_PROTO_STD_DUPLEX:
1258 ax25_std_establish_data_link(ax25);
1259 break;
1260
1261#ifdef CONFIG_AX25_DAMA_SLAVE
1262 case AX25_PROTO_DAMA_SLAVE:
1263 ax25->modulus = AX25_MODULUS;
1264 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1265 if (ax25->ax25_dev->dama.slave)
1266 ax25_ds_establish_data_link(ax25);
1267 else
1268 ax25_std_establish_data_link(ax25);
1269 break;
1270#endif
1271 }
1272
1273 ax25->state = AX25_STATE_1;
1274
1275 ax25_start_heartbeat(ax25);
1276
1277
1278 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1279 err = -EINPROGRESS;
1280 goto out_release;
1281 }
1282
1283 if (sk->sk_state == TCP_SYN_SENT) {
1284 DEFINE_WAIT(wait);
1285
1286 for (;;) {
1287 prepare_to_wait(sk_sleep(sk), &wait,
1288 TASK_INTERRUPTIBLE);
1289 if (sk->sk_state != TCP_SYN_SENT)
1290 break;
1291 if (!signal_pending(current)) {
1292 release_sock(sk);
1293 schedule();
1294 lock_sock(sk);
1295 continue;
1296 }
1297 err = -ERESTARTSYS;
1298 break;
1299 }
1300 finish_wait(sk_sleep(sk), &wait);
1301
1302 if (err)
1303 goto out_release;
1304 }
1305
1306 if (sk->sk_state != TCP_ESTABLISHED) {
1307
1308 sock->state = SS_UNCONNECTED;
1309 err = sock_error(sk);
1310 goto out_release;
1311 }
1312
1313 sock->state = SS_CONNECTED;
1314
1315 err = 0;
1316out_release:
1317 release_sock(sk);
1318
1319 return err;
1320}
1321
1322static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1323{
1324 struct sk_buff *skb;
1325 struct sock *newsk;
1326 DEFINE_WAIT(wait);
1327 struct sock *sk;
1328 int err = 0;
1329
1330 if (sock->state != SS_UNCONNECTED)
1331 return -EINVAL;
1332
1333 if ((sk = sock->sk) == NULL)
1334 return -EINVAL;
1335
1336 lock_sock(sk);
1337 if (sk->sk_type != SOCK_SEQPACKET) {
1338 err = -EOPNOTSUPP;
1339 goto out;
1340 }
1341
1342 if (sk->sk_state != TCP_LISTEN) {
1343 err = -EINVAL;
1344 goto out;
1345 }
1346
1347
1348
1349
1350
1351 for (;;) {
1352 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1353 skb = skb_dequeue(&sk->sk_receive_queue);
1354 if (skb)
1355 break;
1356
1357 if (flags & O_NONBLOCK) {
1358 err = -EWOULDBLOCK;
1359 break;
1360 }
1361 if (!signal_pending(current)) {
1362 release_sock(sk);
1363 schedule();
1364 lock_sock(sk);
1365 continue;
1366 }
1367 err = -ERESTARTSYS;
1368 break;
1369 }
1370 finish_wait(sk_sleep(sk), &wait);
1371
1372 if (err)
1373 goto out;
1374
1375 newsk = skb->sk;
1376 sock_graft(newsk, newsock);
1377
1378
1379 kfree_skb(skb);
1380 sk->sk_ack_backlog--;
1381 newsock->state = SS_CONNECTED;
1382
1383out:
1384 release_sock(sk);
1385
1386 return err;
1387}
1388
1389static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1390 int *uaddr_len, int peer)
1391{
1392 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1393 struct sock *sk = sock->sk;
1394 unsigned char ndigi, i;
1395 ax25_cb *ax25;
1396 int err = 0;
1397
1398 memset(fsa, 0, sizeof(*fsa));
1399 lock_sock(sk);
1400 ax25 = sk_to_ax25(sk);
1401
1402 if (peer != 0) {
1403 if (sk->sk_state != TCP_ESTABLISHED) {
1404 err = -ENOTCONN;
1405 goto out;
1406 }
1407
1408 fsa->fsa_ax25.sax25_family = AF_AX25;
1409 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1410
1411 if (ax25->digipeat != NULL) {
1412 ndigi = ax25->digipeat->ndigi;
1413 fsa->fsa_ax25.sax25_ndigis = ndigi;
1414 for (i = 0; i < ndigi; i++)
1415 fsa->fsa_digipeater[i] =
1416 ax25->digipeat->calls[i];
1417 }
1418 } else {
1419 fsa->fsa_ax25.sax25_family = AF_AX25;
1420 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1421 fsa->fsa_ax25.sax25_ndigis = 1;
1422 if (ax25->ax25_dev != NULL) {
1423 memcpy(&fsa->fsa_digipeater[0],
1424 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1425 } else {
1426 fsa->fsa_digipeater[0] = null_ax25_address;
1427 }
1428 }
1429 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1430
1431out:
1432 release_sock(sk);
1433
1434 return err;
1435}
1436
1437static int ax25_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
1438{
1439 DECLARE_SOCKADDR(struct sockaddr_ax25 *, usax, msg->msg_name);
1440 struct sock *sk = sock->sk;
1441 struct sockaddr_ax25 sax;
1442 struct sk_buff *skb;
1443 ax25_digi dtmp, *dp;
1444 ax25_cb *ax25;
1445 size_t size;
1446 int lv, err, addr_len = msg->msg_namelen;
1447
1448 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1449 return -EINVAL;
1450
1451 lock_sock(sk);
1452 ax25 = sk_to_ax25(sk);
1453
1454 if (sock_flag(sk, SOCK_ZAPPED)) {
1455 err = -EADDRNOTAVAIL;
1456 goto out;
1457 }
1458
1459 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1460 send_sig(SIGPIPE, current, 0);
1461 err = -EPIPE;
1462 goto out;
1463 }
1464
1465 if (ax25->ax25_dev == NULL) {
1466 err = -ENETUNREACH;
1467 goto out;
1468 }
1469
1470 if (len > ax25->ax25_dev->dev->mtu) {
1471 err = -EMSGSIZE;
1472 goto out;
1473 }
1474
1475 if (usax != NULL) {
1476 if (usax->sax25_family != AF_AX25) {
1477 err = -EINVAL;
1478 goto out;
1479 }
1480
1481 if (addr_len == sizeof(struct sockaddr_ax25))
1482
1483 ;
1484 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1485
1486
1487
1488
1489 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1490 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1491 err = -EINVAL;
1492 goto out;
1493 }
1494
1495
1496 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1497 int ct = 0;
1498 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1499
1500
1501 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1502 err = -EINVAL;
1503 goto out;
1504 }
1505
1506 dtmp.ndigi = usax->sax25_ndigis;
1507
1508 while (ct < usax->sax25_ndigis) {
1509 dtmp.repeated[ct] = 0;
1510 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1511 ct++;
1512 }
1513
1514 dtmp.lastrepeat = 0;
1515 }
1516
1517 sax = *usax;
1518 if (sk->sk_type == SOCK_SEQPACKET &&
1519 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1520 err = -EISCONN;
1521 goto out;
1522 }
1523 if (usax->sax25_ndigis == 0)
1524 dp = NULL;
1525 else
1526 dp = &dtmp;
1527 } else {
1528
1529
1530
1531
1532
1533 if (sk->sk_state != TCP_ESTABLISHED) {
1534 err = -ENOTCONN;
1535 goto out;
1536 }
1537 sax.sax25_family = AF_AX25;
1538 sax.sax25_call = ax25->dest_addr;
1539 dp = ax25->digipeat;
1540 }
1541
1542
1543
1544 size = len + ax25->ax25_dev->dev->hard_header_len;
1545
1546 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1547 if (skb == NULL)
1548 goto out;
1549
1550 skb_reserve(skb, size - len);
1551
1552
1553 if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
1554 err = -EFAULT;
1555 kfree_skb(skb);
1556 goto out;
1557 }
1558
1559 skb_reset_network_header(skb);
1560
1561
1562 if (!ax25->pidincl)
1563 *skb_push(skb, 1) = sk->sk_protocol;
1564
1565 if (sk->sk_type == SOCK_SEQPACKET) {
1566
1567 if (sk->sk_state != TCP_ESTABLISHED) {
1568 kfree_skb(skb);
1569 err = -ENOTCONN;
1570 goto out;
1571 }
1572
1573
1574 ax25_output(ax25, ax25->paclen, skb);
1575
1576 err = len;
1577 goto out;
1578 }
1579
1580 skb_push(skb, 1 + ax25_addr_size(dp));
1581
1582
1583
1584
1585 lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1586 dp, AX25_COMMAND, AX25_MODULUS);
1587
1588 skb_set_transport_header(skb, lv);
1589
1590 *skb_transport_header(skb) = AX25_UI;
1591
1592
1593 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1594
1595 err = len;
1596
1597out:
1598 release_sock(sk);
1599
1600 return err;
1601}
1602
1603static int ax25_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1604 int flags)
1605{
1606 struct sock *sk = sock->sk;
1607 struct sk_buff *skb;
1608 int copied;
1609 int err = 0;
1610
1611 lock_sock(sk);
1612
1613
1614
1615
1616 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1617 err = -ENOTCONN;
1618 goto out;
1619 }
1620
1621
1622 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1623 flags & MSG_DONTWAIT, &err);
1624 if (skb == NULL)
1625 goto out;
1626
1627 if (!sk_to_ax25(sk)->pidincl)
1628 skb_pull(skb, 1);
1629
1630 skb_reset_transport_header(skb);
1631 copied = skb->len;
1632
1633 if (copied > size) {
1634 copied = size;
1635 msg->msg_flags |= MSG_TRUNC;
1636 }
1637
1638 skb_copy_datagram_msg(skb, 0, msg, copied);
1639
1640 if (msg->msg_name) {
1641 ax25_digi digi;
1642 ax25_address src;
1643 const unsigned char *mac = skb_mac_header(skb);
1644 DECLARE_SOCKADDR(struct sockaddr_ax25 *, sax, msg->msg_name);
1645
1646 memset(sax, 0, sizeof(struct full_sockaddr_ax25));
1647 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1648 &digi, NULL, NULL);
1649 sax->sax25_family = AF_AX25;
1650
1651
1652
1653 sax->sax25_ndigis = digi.ndigi;
1654 sax->sax25_call = src;
1655
1656 if (sax->sax25_ndigis != 0) {
1657 int ct;
1658 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1659
1660 for (ct = 0; ct < digi.ndigi; ct++)
1661 fsa->fsa_digipeater[ct] = digi.calls[ct];
1662 }
1663 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1664 }
1665
1666 skb_free_datagram(sk, skb);
1667 err = copied;
1668
1669out:
1670 release_sock(sk);
1671
1672 return err;
1673}
1674
1675static int ax25_shutdown(struct socket *sk, int how)
1676{
1677
1678 return -EOPNOTSUPP;
1679}
1680
1681static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1682{
1683 struct sock *sk = sock->sk;
1684 void __user *argp = (void __user *)arg;
1685 int res = 0;
1686
1687 lock_sock(sk);
1688 switch (cmd) {
1689 case TIOCOUTQ: {
1690 long amount;
1691
1692 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1693 if (amount < 0)
1694 amount = 0;
1695 res = put_user(amount, (int __user *)argp);
1696 break;
1697 }
1698
1699 case TIOCINQ: {
1700 struct sk_buff *skb;
1701 long amount = 0L;
1702
1703 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1704 amount = skb->len;
1705 res = put_user(amount, (int __user *) argp);
1706 break;
1707 }
1708
1709 case SIOCGSTAMP:
1710 res = sock_get_timestamp(sk, argp);
1711 break;
1712
1713 case SIOCGSTAMPNS:
1714 res = sock_get_timestampns(sk, argp);
1715 break;
1716
1717 case SIOCAX25ADDUID:
1718 case SIOCAX25DELUID:
1719 case SIOCAX25GETUID: {
1720 struct sockaddr_ax25 sax25;
1721 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1722 res = -EFAULT;
1723 break;
1724 }
1725 res = ax25_uid_ioctl(cmd, &sax25);
1726 break;
1727 }
1728
1729 case SIOCAX25NOUID: {
1730 long amount;
1731 if (!capable(CAP_NET_ADMIN)) {
1732 res = -EPERM;
1733 break;
1734 }
1735 if (get_user(amount, (long __user *)argp)) {
1736 res = -EFAULT;
1737 break;
1738 }
1739 if (amount < 0 || amount > AX25_NOUID_BLOCK) {
1740 res = -EINVAL;
1741 break;
1742 }
1743 ax25_uid_policy = amount;
1744 res = 0;
1745 break;
1746 }
1747
1748 case SIOCADDRT:
1749 case SIOCDELRT:
1750 case SIOCAX25OPTRT:
1751 if (!capable(CAP_NET_ADMIN)) {
1752 res = -EPERM;
1753 break;
1754 }
1755 res = ax25_rt_ioctl(cmd, argp);
1756 break;
1757
1758 case SIOCAX25CTLCON:
1759 if (!capable(CAP_NET_ADMIN)) {
1760 res = -EPERM;
1761 break;
1762 }
1763 res = ax25_ctl_ioctl(cmd, argp);
1764 break;
1765
1766 case SIOCAX25GETINFO:
1767 case SIOCAX25GETINFOOLD: {
1768 ax25_cb *ax25 = sk_to_ax25(sk);
1769 struct ax25_info_struct ax25_info;
1770
1771 ax25_info.t1 = ax25->t1 / HZ;
1772 ax25_info.t2 = ax25->t2 / HZ;
1773 ax25_info.t3 = ax25->t3 / HZ;
1774 ax25_info.idle = ax25->idle / (60 * HZ);
1775 ax25_info.n2 = ax25->n2;
1776 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1777 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1778 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1779 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1780 ax25_info.n2count = ax25->n2count;
1781 ax25_info.state = ax25->state;
1782 ax25_info.rcv_q = sk_rmem_alloc_get(sk);
1783 ax25_info.snd_q = sk_wmem_alloc_get(sk);
1784 ax25_info.vs = ax25->vs;
1785 ax25_info.vr = ax25->vr;
1786 ax25_info.va = ax25->va;
1787 ax25_info.vs_max = ax25->vs;
1788 ax25_info.paclen = ax25->paclen;
1789 ax25_info.window = ax25->window;
1790
1791
1792 if (cmd == SIOCAX25GETINFOOLD) {
1793 static int warned = 0;
1794 if (!warned) {
1795 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1796 current->comm);
1797 warned=1;
1798 }
1799
1800 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1801 res = -EFAULT;
1802 break;
1803 }
1804 } else {
1805 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1806 res = -EINVAL;
1807 break;
1808 }
1809 }
1810 res = 0;
1811 break;
1812 }
1813
1814 case SIOCAX25ADDFWD:
1815 case SIOCAX25DELFWD: {
1816 struct ax25_fwd_struct ax25_fwd;
1817 if (!capable(CAP_NET_ADMIN)) {
1818 res = -EPERM;
1819 break;
1820 }
1821 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1822 res = -EFAULT;
1823 break;
1824 }
1825 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1826 break;
1827 }
1828
1829 case SIOCGIFADDR:
1830 case SIOCSIFADDR:
1831 case SIOCGIFDSTADDR:
1832 case SIOCSIFDSTADDR:
1833 case SIOCGIFBRDADDR:
1834 case SIOCSIFBRDADDR:
1835 case SIOCGIFNETMASK:
1836 case SIOCSIFNETMASK:
1837 case SIOCGIFMETRIC:
1838 case SIOCSIFMETRIC:
1839 res = -EINVAL;
1840 break;
1841
1842 default:
1843 res = -ENOIOCTLCMD;
1844 break;
1845 }
1846 release_sock(sk);
1847
1848 return res;
1849}
1850
1851#ifdef CONFIG_PROC_FS
1852
1853static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1854 __acquires(ax25_list_lock)
1855{
1856 spin_lock_bh(&ax25_list_lock);
1857 return seq_hlist_start(&ax25_list, *pos);
1858}
1859
1860static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1861{
1862 return seq_hlist_next(v, &ax25_list, pos);
1863}
1864
1865static void ax25_info_stop(struct seq_file *seq, void *v)
1866 __releases(ax25_list_lock)
1867{
1868 spin_unlock_bh(&ax25_list_lock);
1869}
1870
1871static int ax25_info_show(struct seq_file *seq, void *v)
1872{
1873 ax25_cb *ax25 = hlist_entry(v, struct ax25_cb, ax25_node);
1874 char buf[11];
1875 int k;
1876
1877
1878
1879
1880
1881
1882
1883 seq_printf(seq, "%8.8lx %s %s%s ",
1884 (long) ax25,
1885 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1886 ax2asc(buf, &ax25->source_addr),
1887 ax25->iamdigi? "*":"");
1888 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1889
1890 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1891 seq_printf(seq, ",%s%s",
1892 ax2asc(buf, &ax25->digipeat->calls[k]),
1893 ax25->digipeat->repeated[k]? "*":"");
1894 }
1895
1896 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1897 ax25->state,
1898 ax25->vs, ax25->vr, ax25->va,
1899 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1900 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1901 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1902 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1903 ax25->idle / (60 * HZ),
1904 ax25->n2count, ax25->n2,
1905 ax25->rtt / HZ,
1906 ax25->window,
1907 ax25->paclen);
1908
1909 if (ax25->sk != NULL) {
1910 seq_printf(seq, " %d %d %lu\n",
1911 sk_wmem_alloc_get(ax25->sk),
1912 sk_rmem_alloc_get(ax25->sk),
1913 sock_i_ino(ax25->sk));
1914 } else {
1915 seq_puts(seq, " * * *\n");
1916 }
1917 return 0;
1918}
1919
1920static const struct seq_operations ax25_info_seqops = {
1921 .start = ax25_info_start,
1922 .next = ax25_info_next,
1923 .stop = ax25_info_stop,
1924 .show = ax25_info_show,
1925};
1926
1927static int ax25_info_open(struct inode *inode, struct file *file)
1928{
1929 return seq_open(file, &ax25_info_seqops);
1930}
1931
1932static const struct file_operations ax25_info_fops = {
1933 .owner = THIS_MODULE,
1934 .open = ax25_info_open,
1935 .read = seq_read,
1936 .llseek = seq_lseek,
1937 .release = seq_release,
1938};
1939
1940#endif
1941
1942static const struct net_proto_family ax25_family_ops = {
1943 .family = PF_AX25,
1944 .create = ax25_create,
1945 .owner = THIS_MODULE,
1946};
1947
1948static const struct proto_ops ax25_proto_ops = {
1949 .family = PF_AX25,
1950 .owner = THIS_MODULE,
1951 .release = ax25_release,
1952 .bind = ax25_bind,
1953 .connect = ax25_connect,
1954 .socketpair = sock_no_socketpair,
1955 .accept = ax25_accept,
1956 .getname = ax25_getname,
1957 .poll = datagram_poll,
1958 .ioctl = ax25_ioctl,
1959 .listen = ax25_listen,
1960 .shutdown = ax25_shutdown,
1961 .setsockopt = ax25_setsockopt,
1962 .getsockopt = ax25_getsockopt,
1963 .sendmsg = ax25_sendmsg,
1964 .recvmsg = ax25_recvmsg,
1965 .mmap = sock_no_mmap,
1966 .sendpage = sock_no_sendpage,
1967};
1968
1969
1970
1971
1972static struct packet_type ax25_packet_type __read_mostly = {
1973 .type = cpu_to_be16(ETH_P_AX25),
1974 .func = ax25_kiss_rcv,
1975};
1976
1977static struct notifier_block ax25_dev_notifier = {
1978 .notifier_call = ax25_device_event,
1979};
1980
1981static int __init ax25_init(void)
1982{
1983 int rc = proto_register(&ax25_proto, 0);
1984
1985 if (rc != 0)
1986 goto out;
1987
1988 sock_register(&ax25_family_ops);
1989 dev_add_pack(&ax25_packet_type);
1990 register_netdevice_notifier(&ax25_dev_notifier);
1991
1992 proc_create("ax25_route", S_IRUGO, init_net.proc_net,
1993 &ax25_route_fops);
1994 proc_create("ax25", S_IRUGO, init_net.proc_net, &ax25_info_fops);
1995 proc_create("ax25_calls", S_IRUGO, init_net.proc_net, &ax25_uid_fops);
1996out:
1997 return rc;
1998}
1999module_init(ax25_init);
2000
2001
2002MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2003MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2004MODULE_LICENSE("GPL");
2005MODULE_ALIAS_NETPROTO(PF_AX25);
2006
2007static void __exit ax25_exit(void)
2008{
2009 remove_proc_entry("ax25_route", init_net.proc_net);
2010 remove_proc_entry("ax25", init_net.proc_net);
2011 remove_proc_entry("ax25_calls", init_net.proc_net);
2012
2013 unregister_netdevice_notifier(&ax25_dev_notifier);
2014
2015 dev_remove_pack(&ax25_packet_type);
2016
2017 sock_unregister(PF_AX25);
2018 proto_unregister(&ax25_proto);
2019
2020 ax25_rt_free();
2021 ax25_uid_free();
2022 ax25_dev_free();
2023}
2024module_exit(ax25_exit);
2025
