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