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