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