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 <linux/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 if (!sock_flag(ax25->sk, SOCK_DESTROY))
980 ax25_destroy_socket(ax25);
981 break;
982
983 case AX25_STATE_3:
984 case AX25_STATE_4:
985 ax25_clear_queues(ax25);
986 ax25->n2count = 0;
987
988 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
989 case AX25_PROTO_STD_SIMPLEX:
990 case AX25_PROTO_STD_DUPLEX:
991 ax25_send_control(ax25,
992 AX25_DISC,
993 AX25_POLLON,
994 AX25_COMMAND);
995 ax25_stop_t2timer(ax25);
996 ax25_stop_t3timer(ax25);
997 ax25_stop_idletimer(ax25);
998 break;
999#ifdef CONFIG_AX25_DAMA_SLAVE
1000 case AX25_PROTO_DAMA_SLAVE:
1001 ax25_stop_t3timer(ax25);
1002 ax25_stop_idletimer(ax25);
1003 break;
1004#endif
1005 }
1006 ax25_calculate_t1(ax25);
1007 ax25_start_t1timer(ax25);
1008 ax25->state = AX25_STATE_2;
1009 sk->sk_state = TCP_CLOSE;
1010 sk->sk_shutdown |= SEND_SHUTDOWN;
1011 sk->sk_state_change(sk);
1012 sock_set_flag(sk, SOCK_DESTROY);
1013 break;
1014
1015 default:
1016 break;
1017 }
1018 } else {
1019 sk->sk_state = TCP_CLOSE;
1020 sk->sk_shutdown |= SEND_SHUTDOWN;
1021 sk->sk_state_change(sk);
1022 ax25_destroy_socket(ax25);
1023 }
1024
1025 sock->sk = NULL;
1026 release_sock(sk);
1027 sock_put(sk);
1028
1029 return 0;
1030}
1031
1032
1033
1034
1035
1036
1037
1038static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1039{
1040 struct sock *sk = sock->sk;
1041 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1042 ax25_dev *ax25_dev = NULL;
1043 ax25_uid_assoc *user;
1044 ax25_address call;
1045 ax25_cb *ax25;
1046 int err = 0;
1047
1048 if (addr_len != sizeof(struct sockaddr_ax25) &&
1049 addr_len != sizeof(struct full_sockaddr_ax25))
1050
1051
1052
1053 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1054 (addr_len > sizeof(struct full_sockaddr_ax25)))
1055 return -EINVAL;
1056
1057 if (addr->fsa_ax25.sax25_family != AF_AX25)
1058 return -EINVAL;
1059
1060 user = ax25_findbyuid(current_euid());
1061 if (user) {
1062 call = user->call;
1063 ax25_uid_put(user);
1064 } else {
1065 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1066 return -EACCES;
1067
1068 call = addr->fsa_ax25.sax25_call;
1069 }
1070
1071 lock_sock(sk);
1072
1073 ax25 = sk_to_ax25(sk);
1074 if (!sock_flag(sk, SOCK_ZAPPED)) {
1075 err = -EINVAL;
1076 goto out;
1077 }
1078
1079 ax25->source_addr = call;
1080
1081
1082
1083
1084 if (ax25->ax25_dev != NULL)
1085 goto done;
1086
1087 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1088 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1089 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1090 err = -EADDRNOTAVAIL;
1091 goto out;
1092 }
1093 } else {
1094 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1095 err = -EADDRNOTAVAIL;
1096 goto out;
1097 }
1098 }
1099
1100 if (ax25_dev != NULL)
1101 ax25_fillin_cb(ax25, ax25_dev);
1102
1103done:
1104 ax25_cb_add(ax25);
1105 sock_reset_flag(sk, SOCK_ZAPPED);
1106
1107out:
1108 release_sock(sk);
1109
1110 return err;
1111}
1112
1113
1114
1115
1116static int __must_check ax25_connect(struct socket *sock,
1117 struct sockaddr *uaddr, int addr_len, int flags)
1118{
1119 struct sock *sk = sock->sk;
1120 ax25_cb *ax25 = sk_to_ax25(sk), *ax25t;
1121 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1122 ax25_digi *digi = NULL;
1123 int ct = 0, err = 0;
1124
1125
1126
1127
1128
1129 if (addr_len == sizeof(struct sockaddr_ax25))
1130
1131
1132
1133 ;
1134 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1135
1136
1137
1138 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1139 (addr_len > sizeof(struct full_sockaddr_ax25)))
1140 return -EINVAL;
1141
1142
1143 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1144 return -EINVAL;
1145
1146 lock_sock(sk);
1147
1148
1149 if (sock->state == SS_CONNECTING) {
1150 switch (sk->sk_state) {
1151 case TCP_SYN_SENT:
1152 err = -EINPROGRESS;
1153 goto out_release;
1154
1155 case TCP_ESTABLISHED:
1156 sock->state = SS_CONNECTED;
1157 goto out_release;
1158
1159 case TCP_CLOSE:
1160 sock->state = SS_UNCONNECTED;
1161 err = -ECONNREFUSED;
1162 goto out_release;
1163 }
1164 }
1165
1166 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1167 err = -EISCONN;
1168 goto out_release;
1169 }
1170
1171 sk->sk_state = TCP_CLOSE;
1172 sock->state = SS_UNCONNECTED;
1173
1174 kfree(ax25->digipeat);
1175 ax25->digipeat = NULL;
1176
1177
1178
1179
1180 if (addr_len > sizeof(struct sockaddr_ax25) &&
1181 fsa->fsa_ax25.sax25_ndigis != 0) {
1182
1183 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1184 err = -EINVAL;
1185 goto out_release;
1186 }
1187
1188 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1189 err = -ENOBUFS;
1190 goto out_release;
1191 }
1192
1193 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1194 digi->lastrepeat = -1;
1195
1196 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1197 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1198 AX25_HBIT) && ax25->iamdigi) {
1199 digi->repeated[ct] = 1;
1200 digi->lastrepeat = ct;
1201 } else {
1202 digi->repeated[ct] = 0;
1203 }
1204 digi->calls[ct] = fsa->fsa_digipeater[ct];
1205 ct++;
1206 }
1207 }
1208
1209
1210
1211
1212
1213
1214 if (sock_flag(sk, SOCK_ZAPPED)) {
1215
1216 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1217 current->comm);
1218 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1219 kfree(digi);
1220 goto out_release;
1221 }
1222
1223 ax25_fillin_cb(ax25, ax25->ax25_dev);
1224 ax25_cb_add(ax25);
1225 } else {
1226 if (ax25->ax25_dev == NULL) {
1227 kfree(digi);
1228 err = -EHOSTUNREACH;
1229 goto out_release;
1230 }
1231 }
1232
1233 if (sk->sk_type == SOCK_SEQPACKET &&
1234 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
1235 ax25->ax25_dev->dev))) {
1236 kfree(digi);
1237 err = -EADDRINUSE;
1238 ax25_cb_put(ax25t);
1239 goto out_release;
1240 }
1241
1242 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1243 ax25->digipeat = digi;
1244
1245
1246 if (sk->sk_type != SOCK_SEQPACKET) {
1247 sock->state = SS_CONNECTED;
1248 sk->sk_state = TCP_ESTABLISHED;
1249 goto out_release;
1250 }
1251
1252
1253 sock->state = SS_CONNECTING;
1254 sk->sk_state = TCP_SYN_SENT;
1255
1256 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1257 case AX25_PROTO_STD_SIMPLEX:
1258 case AX25_PROTO_STD_DUPLEX:
1259 ax25_std_establish_data_link(ax25);
1260 break;
1261
1262#ifdef CONFIG_AX25_DAMA_SLAVE
1263 case AX25_PROTO_DAMA_SLAVE:
1264 ax25->modulus = AX25_MODULUS;
1265 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1266 if (ax25->ax25_dev->dama.slave)
1267 ax25_ds_establish_data_link(ax25);
1268 else
1269 ax25_std_establish_data_link(ax25);
1270 break;
1271#endif
1272 }
1273
1274 ax25->state = AX25_STATE_1;
1275
1276 ax25_start_heartbeat(ax25);
1277
1278
1279 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1280 err = -EINPROGRESS;
1281 goto out_release;
1282 }
1283
1284 if (sk->sk_state == TCP_SYN_SENT) {
1285 DEFINE_WAIT(wait);
1286
1287 for (;;) {
1288 prepare_to_wait(sk_sleep(sk), &wait,
1289 TASK_INTERRUPTIBLE);
1290 if (sk->sk_state != TCP_SYN_SENT)
1291 break;
1292 if (!signal_pending(current)) {
1293 release_sock(sk);
1294 schedule();
1295 lock_sock(sk);
1296 continue;
1297 }
1298 err = -ERESTARTSYS;
1299 break;
1300 }
1301 finish_wait(sk_sleep(sk), &wait);
1302
1303 if (err)
1304 goto out_release;
1305 }
1306
1307 if (sk->sk_state != TCP_ESTABLISHED) {
1308
1309 sock->state = SS_UNCONNECTED;
1310 err = sock_error(sk);
1311 goto out_release;
1312 }
1313
1314 sock->state = SS_CONNECTED;
1315
1316 err = 0;
1317out_release:
1318 release_sock(sk);
1319
1320 return err;
1321}
1322
1323static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1324{
1325 struct sk_buff *skb;
1326 struct sock *newsk;
1327 DEFINE_WAIT(wait);
1328 struct sock *sk;
1329 int err = 0;
1330
1331 if (sock->state != SS_UNCONNECTED)
1332 return -EINVAL;
1333
1334 if ((sk = sock->sk) == NULL)
1335 return -EINVAL;
1336
1337 lock_sock(sk);
1338 if (sk->sk_type != SOCK_SEQPACKET) {
1339 err = -EOPNOTSUPP;
1340 goto out;
1341 }
1342
1343 if (sk->sk_state != TCP_LISTEN) {
1344 err = -EINVAL;
1345 goto out;
1346 }
1347
1348
1349
1350
1351
1352 for (;;) {
1353 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1354 skb = skb_dequeue(&sk->sk_receive_queue);
1355 if (skb)
1356 break;
1357
1358 if (flags & O_NONBLOCK) {
1359 err = -EWOULDBLOCK;
1360 break;
1361 }
1362 if (!signal_pending(current)) {
1363 release_sock(sk);
1364 schedule();
1365 lock_sock(sk);
1366 continue;
1367 }
1368 err = -ERESTARTSYS;
1369 break;
1370 }
1371 finish_wait(sk_sleep(sk), &wait);
1372
1373 if (err)
1374 goto out;
1375
1376 newsk = skb->sk;
1377 sock_graft(newsk, newsock);
1378
1379
1380 kfree_skb(skb);
1381 sk->sk_ack_backlog--;
1382 newsock->state = SS_CONNECTED;
1383
1384out:
1385 release_sock(sk);
1386
1387 return err;
1388}
1389
1390static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1391 int *uaddr_len, int peer)
1392{
1393 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1394 struct sock *sk = sock->sk;
1395 unsigned char ndigi, i;
1396 ax25_cb *ax25;
1397 int err = 0;
1398
1399 memset(fsa, 0, sizeof(*fsa));
1400 lock_sock(sk);
1401 ax25 = sk_to_ax25(sk);
1402
1403 if (peer != 0) {
1404 if (sk->sk_state != TCP_ESTABLISHED) {
1405 err = -ENOTCONN;
1406 goto out;
1407 }
1408
1409 fsa->fsa_ax25.sax25_family = AF_AX25;
1410 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1411
1412 if (ax25->digipeat != NULL) {
1413 ndigi = ax25->digipeat->ndigi;
1414 fsa->fsa_ax25.sax25_ndigis = ndigi;
1415 for (i = 0; i < ndigi; i++)
1416 fsa->fsa_digipeater[i] =
1417 ax25->digipeat->calls[i];
1418 }
1419 } else {
1420 fsa->fsa_ax25.sax25_family = AF_AX25;
1421 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1422 fsa->fsa_ax25.sax25_ndigis = 1;
1423 if (ax25->ax25_dev != NULL) {
1424 memcpy(&fsa->fsa_digipeater[0],
1425 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1426 } else {
1427 fsa->fsa_digipeater[0] = null_ax25_address;
1428 }
1429 }
1430 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1431
1432out:
1433 release_sock(sk);
1434
1435 return err;
1436}
1437
1438static int ax25_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
1439{
1440 DECLARE_SOCKADDR(struct sockaddr_ax25 *, usax, msg->msg_name);
1441 struct sock *sk = sock->sk;
1442 struct sockaddr_ax25 sax;
1443 struct sk_buff *skb;
1444 ax25_digi dtmp, *dp;
1445 ax25_cb *ax25;
1446 size_t size;
1447 int lv, err, addr_len = msg->msg_namelen;
1448
1449 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1450 return -EINVAL;
1451
1452 lock_sock(sk);
1453 ax25 = sk_to_ax25(sk);
1454
1455 if (sock_flag(sk, SOCK_ZAPPED)) {
1456 err = -EADDRNOTAVAIL;
1457 goto out;
1458 }
1459
1460 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1461 send_sig(SIGPIPE, current, 0);
1462 err = -EPIPE;
1463 goto out;
1464 }
1465
1466 if (ax25->ax25_dev == NULL) {
1467 err = -ENETUNREACH;
1468 goto out;
1469 }
1470
1471 if (len > ax25->ax25_dev->dev->mtu) {
1472 err = -EMSGSIZE;
1473 goto out;
1474 }
1475
1476 if (usax != NULL) {
1477 if (usax->sax25_family != AF_AX25) {
1478 err = -EINVAL;
1479 goto out;
1480 }
1481
1482 if (addr_len == sizeof(struct sockaddr_ax25))
1483
1484 ;
1485 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1486
1487
1488
1489
1490 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1491 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1492 err = -EINVAL;
1493 goto out;
1494 }
1495
1496
1497 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1498 int ct = 0;
1499 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1500
1501
1502 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1503 err = -EINVAL;
1504 goto out;
1505 }
1506
1507 dtmp.ndigi = usax->sax25_ndigis;
1508
1509 while (ct < usax->sax25_ndigis) {
1510 dtmp.repeated[ct] = 0;
1511 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1512 ct++;
1513 }
1514
1515 dtmp.lastrepeat = 0;
1516 }
1517
1518 sax = *usax;
1519 if (sk->sk_type == SOCK_SEQPACKET &&
1520 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1521 err = -EISCONN;
1522 goto out;
1523 }
1524 if (usax->sax25_ndigis == 0)
1525 dp = NULL;
1526 else
1527 dp = &dtmp;
1528 } else {
1529
1530
1531
1532
1533
1534 if (sk->sk_state != TCP_ESTABLISHED) {
1535 err = -ENOTCONN;
1536 goto out;
1537 }
1538 sax.sax25_family = AF_AX25;
1539 sax.sax25_call = ax25->dest_addr;
1540 dp = ax25->digipeat;
1541 }
1542
1543
1544
1545 size = len + ax25->ax25_dev->dev->hard_header_len;
1546
1547 skb = sock_alloc_send_skb(sk, size, msg->msg_flags&MSG_DONTWAIT, &err);
1548 if (skb == NULL)
1549 goto out;
1550
1551 skb_reserve(skb, size - len);
1552
1553
1554 if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
1555 err = -EFAULT;
1556 kfree_skb(skb);
1557 goto out;
1558 }
1559
1560 skb_reset_network_header(skb);
1561
1562
1563 if (!ax25->pidincl)
1564 *skb_push(skb, 1) = sk->sk_protocol;
1565
1566 if (sk->sk_type == SOCK_SEQPACKET) {
1567
1568 if (sk->sk_state != TCP_ESTABLISHED) {
1569 kfree_skb(skb);
1570 err = -ENOTCONN;
1571 goto out;
1572 }
1573
1574
1575 ax25_output(ax25, ax25->paclen, skb);
1576
1577 err = len;
1578 goto out;
1579 }
1580
1581 skb_push(skb, 1 + ax25_addr_size(dp));
1582
1583
1584
1585
1586 lv = ax25_addr_build(skb->data, &ax25->source_addr, &sax.sax25_call,
1587 dp, AX25_COMMAND, AX25_MODULUS);
1588
1589 skb_set_transport_header(skb, lv);
1590
1591 *skb_transport_header(skb) = AX25_UI;
1592
1593
1594 ax25_queue_xmit(skb, ax25->ax25_dev->dev);
1595
1596 err = len;
1597
1598out:
1599 release_sock(sk);
1600
1601 return err;
1602}
1603
1604static int ax25_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1605 int flags)
1606{
1607 struct sock *sk = sock->sk;
1608 struct sk_buff *skb;
1609 int copied;
1610 int err = 0;
1611
1612 lock_sock(sk);
1613
1614
1615
1616
1617 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_ESTABLISHED) {
1618 err = -ENOTCONN;
1619 goto out;
1620 }
1621
1622
1623 skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1624 flags & MSG_DONTWAIT, &err);
1625 if (skb == NULL)
1626 goto out;
1627
1628 if (!sk_to_ax25(sk)->pidincl)
1629 skb_pull(skb, 1);
1630
1631 skb_reset_transport_header(skb);
1632 copied = skb->len;
1633
1634 if (copied > size) {
1635 copied = size;
1636 msg->msg_flags |= MSG_TRUNC;
1637 }
1638
1639 skb_copy_datagram_msg(skb, 0, msg, copied);
1640
1641 if (msg->msg_name) {
1642 ax25_digi digi;
1643 ax25_address src;
1644 const unsigned char *mac = skb_mac_header(skb);
1645 DECLARE_SOCKADDR(struct sockaddr_ax25 *, sax, msg->msg_name);
1646
1647 memset(sax, 0, sizeof(struct full_sockaddr_ax25));
1648 ax25_addr_parse(mac + 1, skb->data - mac - 1, &src, NULL,
1649 &digi, NULL, NULL);
1650 sax->sax25_family = AF_AX25;
1651
1652
1653
1654 sax->sax25_ndigis = digi.ndigi;
1655 sax->sax25_call = src;
1656
1657 if (sax->sax25_ndigis != 0) {
1658 int ct;
1659 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)sax;
1660
1661 for (ct = 0; ct < digi.ndigi; ct++)
1662 fsa->fsa_digipeater[ct] = digi.calls[ct];
1663 }
1664 msg->msg_namelen = sizeof(struct full_sockaddr_ax25);
1665 }
1666
1667 skb_free_datagram(sk, skb);
1668 err = copied;
1669
1670out:
1671 release_sock(sk);
1672
1673 return err;
1674}
1675
1676static int ax25_shutdown(struct socket *sk, int how)
1677{
1678
1679 return -EOPNOTSUPP;
1680}
1681
1682static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1683{
1684 struct sock *sk = sock->sk;
1685 void __user *argp = (void __user *)arg;
1686 int res = 0;
1687
1688 lock_sock(sk);
1689 switch (cmd) {
1690 case TIOCOUTQ: {
1691 long amount;
1692
1693 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1694 if (amount < 0)
1695 amount = 0;
1696 res = put_user(amount, (int __user *)argp);
1697 break;
1698 }
1699
1700 case TIOCINQ: {
1701 struct sk_buff *skb;
1702 long amount = 0L;
1703
1704 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1705 amount = skb->len;
1706 res = put_user(amount, (int __user *) argp);
1707 break;
1708 }
1709
1710 case SIOCGSTAMP:
1711 res = sock_get_timestamp(sk, argp);
1712 break;
1713
1714 case SIOCGSTAMPNS:
1715 res = sock_get_timestampns(sk, argp);
1716 break;
1717
1718 case SIOCAX25ADDUID:
1719 case SIOCAX25DELUID:
1720 case SIOCAX25GETUID: {
1721 struct sockaddr_ax25 sax25;
1722 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1723 res = -EFAULT;
1724 break;
1725 }
1726 res = ax25_uid_ioctl(cmd, &sax25);
1727 break;
1728 }
1729
1730 case SIOCAX25NOUID: {
1731 long amount;
1732 if (!capable(CAP_NET_ADMIN)) {
1733 res = -EPERM;
1734 break;
1735 }
1736 if (get_user(amount, (long __user *)argp)) {
1737 res = -EFAULT;
1738 break;
1739 }
1740 if (amount < 0 || amount > AX25_NOUID_BLOCK) {
1741 res = -EINVAL;
1742 break;
1743 }
1744 ax25_uid_policy = amount;
1745 res = 0;
1746 break;
1747 }
1748
1749 case SIOCADDRT:
1750 case SIOCDELRT:
1751 case SIOCAX25OPTRT:
1752 if (!capable(CAP_NET_ADMIN)) {
1753 res = -EPERM;
1754 break;
1755 }
1756 res = ax25_rt_ioctl(cmd, argp);
1757 break;
1758
1759 case SIOCAX25CTLCON:
1760 if (!capable(CAP_NET_ADMIN)) {
1761 res = -EPERM;
1762 break;
1763 }
1764 res = ax25_ctl_ioctl(cmd, argp);
1765 break;
1766
1767 case SIOCAX25GETINFO:
1768 case SIOCAX25GETINFOOLD: {
1769 ax25_cb *ax25 = sk_to_ax25(sk);
1770 struct ax25_info_struct ax25_info;
1771
1772 ax25_info.t1 = ax25->t1 / HZ;
1773 ax25_info.t2 = ax25->t2 / HZ;
1774 ax25_info.t3 = ax25->t3 / HZ;
1775 ax25_info.idle = ax25->idle / (60 * HZ);
1776 ax25_info.n2 = ax25->n2;
1777 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1778 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1779 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1780 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1781 ax25_info.n2count = ax25->n2count;
1782 ax25_info.state = ax25->state;
1783 ax25_info.rcv_q = sk_rmem_alloc_get(sk);
1784 ax25_info.snd_q = sk_wmem_alloc_get(sk);
1785 ax25_info.vs = ax25->vs;
1786 ax25_info.vr = ax25->vr;
1787 ax25_info.va = ax25->va;
1788 ax25_info.vs_max = ax25->vs;
1789 ax25_info.paclen = ax25->paclen;
1790 ax25_info.window = ax25->window;
1791
1792
1793 if (cmd == SIOCAX25GETINFOOLD) {
1794 static int warned = 0;
1795 if (!warned) {
1796 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1797 current->comm);
1798 warned=1;
1799 }
1800
1801 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1802 res = -EFAULT;
1803 break;
1804 }
1805 } else {
1806 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1807 res = -EINVAL;
1808 break;
1809 }
1810 }
1811 res = 0;
1812 break;
1813 }
1814
1815 case SIOCAX25ADDFWD:
1816 case SIOCAX25DELFWD: {
1817 struct ax25_fwd_struct ax25_fwd;
1818 if (!capable(CAP_NET_ADMIN)) {
1819 res = -EPERM;
1820 break;
1821 }
1822 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1823 res = -EFAULT;
1824 break;
1825 }
1826 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1827 break;
1828 }
1829
1830 case SIOCGIFADDR:
1831 case SIOCSIFADDR:
1832 case SIOCGIFDSTADDR:
1833 case SIOCSIFDSTADDR:
1834 case SIOCGIFBRDADDR:
1835 case SIOCSIFBRDADDR:
1836 case SIOCGIFNETMASK:
1837 case SIOCSIFNETMASK:
1838 case SIOCGIFMETRIC:
1839 case SIOCSIFMETRIC:
1840 res = -EINVAL;
1841 break;
1842
1843 default:
1844 res = -ENOIOCTLCMD;
1845 break;
1846 }
1847 release_sock(sk);
1848
1849 return res;
1850}
1851
1852#ifdef CONFIG_PROC_FS
1853
1854static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
1855 __acquires(ax25_list_lock)
1856{
1857 spin_lock_bh(&ax25_list_lock);
1858 return seq_hlist_start(&ax25_list, *pos);
1859}
1860
1861static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1862{
1863 return seq_hlist_next(v, &ax25_list, pos);
1864}
1865
1866static void ax25_info_stop(struct seq_file *seq, void *v)
1867 __releases(ax25_list_lock)
1868{
1869 spin_unlock_bh(&ax25_list_lock);
1870}
1871
1872static int ax25_info_show(struct seq_file *seq, void *v)
1873{
1874 ax25_cb *ax25 = hlist_entry(v, struct ax25_cb, ax25_node);
1875 char buf[11];
1876 int k;
1877
1878
1879
1880
1881
1882
1883
1884 seq_printf(seq, "%8.8lx %s %s%s ",
1885 (long) ax25,
1886 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
1887 ax2asc(buf, &ax25->source_addr),
1888 ax25->iamdigi? "*":"");
1889 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1890
1891 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1892 seq_printf(seq, ",%s%s",
1893 ax2asc(buf, &ax25->digipeat->calls[k]),
1894 ax25->digipeat->repeated[k]? "*":"");
1895 }
1896
1897 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1898 ax25->state,
1899 ax25->vs, ax25->vr, ax25->va,
1900 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1901 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1902 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1903 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1904 ax25->idle / (60 * HZ),
1905 ax25->n2count, ax25->n2,
1906 ax25->rtt / HZ,
1907 ax25->window,
1908 ax25->paclen);
1909
1910 if (ax25->sk != NULL) {
1911 seq_printf(seq, " %d %d %lu\n",
1912 sk_wmem_alloc_get(ax25->sk),
1913 sk_rmem_alloc_get(ax25->sk),
1914 sock_i_ino(ax25->sk));
1915 } else {
1916 seq_puts(seq, " * * *\n");
1917 }
1918 return 0;
1919}
1920
1921static const struct seq_operations ax25_info_seqops = {
1922 .start = ax25_info_start,
1923 .next = ax25_info_next,
1924 .stop = ax25_info_stop,
1925 .show = ax25_info_show,
1926};
1927
1928static int ax25_info_open(struct inode *inode, struct file *file)
1929{
1930 return seq_open(file, &ax25_info_seqops);
1931}
1932
1933static const struct file_operations ax25_info_fops = {
1934 .owner = THIS_MODULE,
1935 .open = ax25_info_open,
1936 .read = seq_read,
1937 .llseek = seq_lseek,
1938 .release = seq_release,
1939};
1940
1941#endif
1942
1943static const struct net_proto_family ax25_family_ops = {
1944 .family = PF_AX25,
1945 .create = ax25_create,
1946 .owner = THIS_MODULE,
1947};
1948
1949static const struct proto_ops ax25_proto_ops = {
1950 .family = PF_AX25,
1951 .owner = THIS_MODULE,
1952 .release = ax25_release,
1953 .bind = ax25_bind,
1954 .connect = ax25_connect,
1955 .socketpair = sock_no_socketpair,
1956 .accept = ax25_accept,
1957 .getname = ax25_getname,
1958 .poll = datagram_poll,
1959 .ioctl = ax25_ioctl,
1960 .listen = ax25_listen,
1961 .shutdown = ax25_shutdown,
1962 .setsockopt = ax25_setsockopt,
1963 .getsockopt = ax25_getsockopt,
1964 .sendmsg = ax25_sendmsg,
1965 .recvmsg = ax25_recvmsg,
1966 .mmap = sock_no_mmap,
1967 .sendpage = sock_no_sendpage,
1968};
1969
1970
1971
1972
1973static struct packet_type ax25_packet_type __read_mostly = {
1974 .type = cpu_to_be16(ETH_P_AX25),
1975 .func = ax25_kiss_rcv,
1976};
1977
1978static struct notifier_block ax25_dev_notifier = {
1979 .notifier_call = ax25_device_event,
1980};
1981
1982static int __init ax25_init(void)
1983{
1984 int rc = proto_register(&ax25_proto, 0);
1985
1986 if (rc != 0)
1987 goto out;
1988
1989 sock_register(&ax25_family_ops);
1990 dev_add_pack(&ax25_packet_type);
1991 register_netdevice_notifier(&ax25_dev_notifier);
1992
1993 proc_create("ax25_route", S_IRUGO, init_net.proc_net,
1994 &ax25_route_fops);
1995 proc_create("ax25", S_IRUGO, init_net.proc_net, &ax25_info_fops);
1996 proc_create("ax25_calls", S_IRUGO, init_net.proc_net, &ax25_uid_fops);
1997out:
1998 return rc;
1999}
2000module_init(ax25_init);
2001
2002
2003MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
2004MODULE_DESCRIPTION("The amateur radio AX.25 link layer protocol");
2005MODULE_LICENSE("GPL");
2006MODULE_ALIAS_NETPROTO(PF_AX25);
2007
2008static void __exit ax25_exit(void)
2009{
2010 remove_proc_entry("ax25_route", init_net.proc_net);
2011 remove_proc_entry("ax25", init_net.proc_net);
2012 remove_proc_entry("ax25_calls", init_net.proc_net);
2013
2014 unregister_netdevice_notifier(&ax25_dev_notifier);
2015
2016 dev_remove_pack(&ax25_packet_type);
2017
2018 sock_unregister(PF_AX25);
2019 proto_unregister(&ax25_proto);
2020
2021 ax25_rt_free();
2022 ax25_uid_free();
2023 ax25_dev_free();
2024}
2025module_exit(ax25_exit);
2026
