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