]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - net/ax25/af_ax25.c
projects / mirror_ubuntu-jammy-kernel.git / blob
? search:


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