projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'wm8974-upstream' into for-2.6.32
[linux-2.6-block.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);
ecd2ebde 90again:
1da177e4
LT		 91 ax25_for_each(s, node, &ax25_list) {
92 if (s->ax25_dev == ax25_dev) {
93 s->ax25_dev = NULL;
ecd2ebde 94 spin_unlock_bh(&ax25_list_lock);
1da177e4 95 ax25_disconnect(s, ENETUNREACH);
ecd2ebde
JP		 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;
1da177e4
LT		 106 }
107 }
108 spin_unlock_bh(&ax25_list_lock);
109}
110
111/*
112 * Handle device status changes.
113 */
114static int ax25_device_event(struct notifier_block *this, unsigned long event,
115 void *ptr)
116{
117 struct net_device *dev = (struct net_device *)ptr;
118
721499e8 119 if (!net_eq(dev_net(dev), &init_net))
e9dc8653
EB		 120 return NOTIFY_DONE;
121
1da177e4
LT		 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 */
145void ax25_cb_add(ax25_cb *ax25)
146{
147 spin_lock_bh(&ax25_list_lock);
148 ax25_cb_hold(ax25);
149 hlist_add_head(&ax25->ax25_node, &ax25_list);
150 spin_unlock_bh(&ax25_list_lock);
151}
152
153/*
154 * Find a socket that wants to accept the SABM we have just
155 * received.
156 */
157struct sock *ax25_find_listener(ax25_address *addr, int digi,
158 struct net_device *dev, int type)
159{
160 ax25_cb *s;
161 struct hlist_node *node;
162
c19c4b9c 163 spin_lock(&ax25_list_lock);
1da177e4
LT		 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);
c19c4b9c 172 spin_unlock(&ax25_list_lock);
1da177e4
LT		 173 return s->sk;
174 }
175 }
176 }
c19c4b9c 177 spin_unlock(&ax25_list_lock);
1da177e4
LT		 178
179 return NULL;
180}
181
182/*
183 * Find an AX.25 socket given both ends.
184 */
185struct sock *ax25_get_socket(ax25_address *my_addr, ax25_address *dest_addr,
186 int type)
187{
188 struct sock *sk = NULL;
189 ax25_cb *s;
190 struct hlist_node *node;
191
c19c4b9c 192 spin_lock(&ax25_list_lock);
1da177e4
LT		 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
c19c4b9c 203 spin_unlock(&ax25_list_lock);
1da177e4
LT		 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 */
212ax25_cb *ax25_find_cb(ax25_address *src_addr, ax25_address *dest_addr,
213 ax25_digi *digi, struct net_device *dev)
214{
215 ax25_cb *s;
216 struct hlist_node *node;
217
218 spin_lock_bh(&ax25_list_lock);
219 ax25_for_each(s, node, &ax25_list) {
220 if (s->sk && s->sk->sk_type != SOCK_SEQPACKET)
221 continue;
222 if (s->ax25_dev == NULL)
223 continue;
224 if (ax25cmp(&s->source_addr, src_addr) == 0 && ax25cmp(&s->dest_addr, dest_addr) == 0 && s->ax25_dev->dev == dev) {
225 if (digi != NULL && digi->ndigi != 0) {
226 if (s->digipeat == NULL)
227 continue;
228 if (ax25digicmp(s->digipeat, digi) != 0)
229 continue;
230 } else {
231 if (s->digipeat != NULL && s->digipeat->ndigi != 0)
232 continue;
233 }
234 ax25_cb_hold(s);
235 spin_unlock_bh(&ax25_list_lock);
236
237 return s;
238 }
239 }
240 spin_unlock_bh(&ax25_list_lock);
241
242 return NULL;
243}
244
70868eac
RB		 245EXPORT_SYMBOL(ax25_find_cb);
246
1da177e4
LT		 247void ax25_send_to_raw(ax25_address *addr, struct sk_buff *skb, int proto)
248{
249 ax25_cb *s;
250 struct sk_buff *copy;
251 struct hlist_node *node;
252
c19c4b9c 253 spin_lock(&ax25_list_lock);
1da177e4
LT		 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 }
c19c4b9c 266 spin_unlock(&ax25_list_lock);
1da177e4
LT		 267}
268
269/*
270 * Deferred destroy.
271 */
272void ax25_destroy_socket(ax25_cb *);
273
274/*
275 * Handler for deferred kills.
276 */
277static void ax25_destroy_timer(unsigned long data)
278{
279 ax25_cb *ax25=(ax25_cb *)data;
280 struct sock *sk;
528930b9 281
1da177e4 282 sk=ax25->sk;
528930b9 283
1da177e4
LT		 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 */
297void ax25_destroy_socket(ax25_cb *ax25)
298{
299 struct sk_buff *skb;
300
301 ax25_cb_del(ax25);
302
303 ax25_stop_heartbeat(ax25);
304 ax25_stop_t1timer(ax25);
305 ax25_stop_t2timer(ax25);
306 ax25_stop_t3timer(ax25);
307 ax25_stop_idletimer(ax25);
308
309 ax25_clear_queues(ax25); /* 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
33d1d2c5
DM		 320 /* 9A4GL: hack to release unaccepted sockets */
321 skb->sk->sk_state = TCP_LISTEN;
322
1da177e4
LT		 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) {
c564039f 333 if (sk_has_allocations(ax25->sk)) {
1da177e4 334 /* Defer: outstanding buffers */
b24b8a24
PE		 335 setup_timer(&ax25->dtimer, ax25_destroy_timer,
336 (unsigned long)ax25);
1da177e4 337 ax25->dtimer.expires = jiffies + 2 * HZ;
1da177e4
LT		 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 */
354static 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
362 if (copy_from_user(&ax25_ctl, arg, sizeof(ax25_ctl)))
363 return -EFAULT;
364
365 if ((ax25_dev = ax25_addr_ax25dev(&ax25_ctl.port_addr)) == NULL)
366 return -ENODEV;
367
368 if (ax25_ctl.digi_count > AX25_MAX_DIGIS)
369 return -EINVAL;
370
371 digi.ndigi = ax25_ctl.digi_count;
372 for (k = 0; k < digi.ndigi; k++)
373 digi.calls[k] = ax25_ctl.digi_addr[k];
374
375 if ((ax25 = ax25_find_cb(&ax25_ctl.source_addr, &ax25_ctl.dest_addr, &digi, ax25_dev->dev)) == NULL)
376 return -ENOTCONN;
377
378 switch (ax25_ctl.cmd) {
379 case AX25_KILL:
380 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
381#ifdef CONFIG_AX25_DAMA_SLAVE
382 if (ax25_dev->dama.slave && ax25->ax25_dev->values[AX25_VALUES_PROTOCOL] == AX25_PROTO_DAMA_SLAVE)
383 ax25_dama_off(ax25);
384#endif
385 ax25_disconnect(ax25, ENETRESET);
386 break;
387
528930b9
YH		 388 case AX25_WINDOW:
389 if (ax25->modulus == AX25_MODULUS) {
390 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 7)
391 return -EINVAL;
392 } else {
393 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 63)
394 return -EINVAL;
395 }
396 ax25->window = ax25_ctl.arg;
397 break;
398
399 case AX25_T1:
1da177e4 400 if (ax25_ctl.arg < 1)
1da177e4 401 return -EINVAL;
528930b9
YH		 402 ax25->rtt = (ax25_ctl.arg * HZ) / 2;
403 ax25->t1 = ax25_ctl.arg * HZ;
404 break;
405
406 case AX25_T2:
407 if (ax25_ctl.arg < 1)
408 return -EINVAL;
409 ax25->t2 = ax25_ctl.arg * HZ;
410 break;
411
412 case AX25_N2:
413 if (ax25_ctl.arg < 1 || ax25_ctl.arg > 31)
414 return -EINVAL;
415 ax25->n2count = 0;
416 ax25->n2 = ax25_ctl.arg;
417 break;
418
419 case AX25_T3:
420 if (ax25_ctl.arg < 0)
421 return -EINVAL;
422 ax25->t3 = ax25_ctl.arg * HZ;
423 break;
424
425 case AX25_IDLE:
426 if (ax25_ctl.arg < 0)
427 return -EINVAL;
428 ax25->idle = ax25_ctl.arg * 60 * HZ;
429 break;
430
431 case AX25_PACLEN:
432 if (ax25_ctl.arg < 16 || ax25_ctl.arg > 65535)
433 return -EINVAL;
434 ax25->paclen = ax25_ctl.arg;
435 break;
436
437 default:
438 return -EINVAL;
1da177e4
LT		 439 }
440
441 return 0;
442}
443
e1fdb5b3
RB		 444static void ax25_fillin_cb_from_dev(ax25_cb *ax25, ax25_dev *ax25_dev)
445{
446 ax25->rtt = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]) / 2;
447 ax25->t1 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T1]);
448 ax25->t2 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T2]);
449 ax25->t3 = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_T3]);
450 ax25->n2 = ax25_dev->values[AX25_VALUES_N2];
451 ax25->paclen = ax25_dev->values[AX25_VALUES_PACLEN];
452 ax25->idle = msecs_to_jiffies(ax25_dev->values[AX25_VALUES_IDLE]);
453 ax25->backoff = ax25_dev->values[AX25_VALUES_BACKOFF];
454
455 if (ax25_dev->values[AX25_VALUES_AXDEFMODE]) {
456 ax25->modulus = AX25_EMODULUS;
457 ax25->window = ax25_dev->values[AX25_VALUES_EWINDOW];
458 } else {
459 ax25->modulus = AX25_MODULUS;
460 ax25->window = ax25_dev->values[AX25_VALUES_WINDOW];
461 }
462}
463
1da177e4
LT		 464/*
465 * Fill in a created AX.25 created control block with the default
466 * values for a particular device.
467 */
468void ax25_fillin_cb(ax25_cb *ax25, ax25_dev *ax25_dev)
469{
470 ax25->ax25_dev = ax25_dev;
471
472 if (ax25->ax25_dev != NULL) {
e1fdb5b3
RB		 473 ax25_fillin_cb_from_dev(ax25, ax25_dev);
474 return;
475 }
476
477 /*
478 * No device, use kernel / AX.25 spec default values
479 */
480 ax25->rtt = msecs_to_jiffies(AX25_DEF_T1) / 2;
481 ax25->t1 = msecs_to_jiffies(AX25_DEF_T1);
482 ax25->t2 = msecs_to_jiffies(AX25_DEF_T2);
483 ax25->t3 = msecs_to_jiffies(AX25_DEF_T3);
484 ax25->n2 = AX25_DEF_N2;
485 ax25->paclen = AX25_DEF_PACLEN;
486 ax25->idle = msecs_to_jiffies(AX25_DEF_IDLE);
487 ax25->backoff = AX25_DEF_BACKOFF;
488
489 if (AX25_DEF_AXDEFMODE) {
490 ax25->modulus = AX25_EMODULUS;
491 ax25->window = AX25_DEF_EWINDOW;
1da177e4 492 } else {
e1fdb5b3
RB		 493 ax25->modulus = AX25_MODULUS;
494 ax25->window = AX25_DEF_WINDOW;
1da177e4
LT		 495 }
496}
497
498/*
499 * Create an empty AX.25 control block.
500 */
501ax25_cb *ax25_create_cb(void)
502{
503 ax25_cb *ax25;
504
1b30dd35 505 if ((ax25 = kzalloc(sizeof(*ax25), GFP_ATOMIC)) == NULL)
1da177e4
LT		 506 return NULL;
507
1da177e4
LT		 508 atomic_set(&ax25->refcount, 1);
509
510 skb_queue_head_init(&ax25->write_queue);
511 skb_queue_head_init(&ax25->frag_queue);
512 skb_queue_head_init(&ax25->ack_queue);
513 skb_queue_head_init(&ax25->reseq_queue);
514
21fab4a8 515 ax25_setup_timers(ax25);
1da177e4
LT		 516
517 ax25_fillin_cb(ax25, NULL);
518
519 ax25->state = AX25_STATE_0;
520
521 return ax25;
522}
523
524/*
525 * Handling for system calls applied via the various interfaces to an
526 * AX25 socket object
527 */
528
529static int ax25_setsockopt(struct socket *sock, int level, int optname,
530 char __user *optval, int optlen)
531{
532 struct sock *sk = sock->sk;
533 ax25_cb *ax25;
534 struct net_device *dev;
535 char devname[IFNAMSIZ];
536 int opt, res = 0;
537
538 if (level != SOL_AX25)
539 return -ENOPROTOOPT;
540
541 if (optlen < sizeof(int))
542 return -EINVAL;
543
544 if (get_user(opt, (int __user *)optval))
545 return -EFAULT;
546
547 lock_sock(sk);
548 ax25 = ax25_sk(sk);
549
550 switch (optname) {
551 case AX25_WINDOW:
552 if (ax25->modulus == AX25_MODULUS) {
553 if (opt < 1 || opt > 7) {
554 res = -EINVAL;
555 break;
556 }
557 } else {
558 if (opt < 1 || opt > 63) {
559 res = -EINVAL;
560 break;
561 }
562 }
563 ax25->window = opt;
564 break;
565
566 case AX25_T1:
567 if (opt < 1) {
568 res = -EINVAL;
569 break;
570 }
f16f3026 571 ax25->rtt = (opt * HZ) >> 1;
1da177e4
LT		 572 ax25->t1 = opt * HZ;
573 break;
574
575 case AX25_T2:
576 if (opt < 1) {
577 res = -EINVAL;
578 break;
579 }
580 ax25->t2 = opt * HZ;
581 break;
582
583 case AX25_N2:
584 if (opt < 1 || opt > 31) {
585 res = -EINVAL;
586 break;
587 }
588 ax25->n2 = opt;
589 break;
590
591 case AX25_T3:
592 if (opt < 1) {
593 res = -EINVAL;
594 break;
595 }
596 ax25->t3 = opt * HZ;
597 break;
598
599 case AX25_IDLE:
600 if (opt < 0) {
601 res = -EINVAL;
602 break;
603 }
604 ax25->idle = opt * 60 * HZ;
605 break;
606
607 case AX25_BACKOFF:
608 if (opt < 0 || opt > 2) {
609 res = -EINVAL;
610 break;
611 }
612 ax25->backoff = opt;
613 break;
614
615 case AX25_EXTSEQ:
616 ax25->modulus = opt ? AX25_EMODULUS : AX25_MODULUS;
617 break;
618
619 case AX25_PIDINCL:
620 ax25->pidincl = opt ? 1 : 0;
621 break;
622
623 case AX25_IAMDIGI:
624 ax25->iamdigi = opt ? 1 : 0;
625 break;
626
627 case AX25_PACLEN:
628 if (opt < 16 || opt > 65535) {
629 res = -EINVAL;
630 break;
631 }
632 ax25->paclen = opt;
633 break;
634
635 case SO_BINDTODEVICE:
636 if (optlen > IFNAMSIZ)
637 optlen=IFNAMSIZ;
638 if (copy_from_user(devname, optval, optlen)) {
639 res = -EFAULT;
640 break;
641 }
642
881d966b 643 dev = dev_get_by_name(&init_net, devname);
1da177e4
LT		 644 if (dev == NULL) {
645 res = -ENODEV;
646 break;
647 }
648
649 if (sk->sk_type == SOCK_SEQPACKET &&
650 (sock->state != SS_UNCONNECTED ||
651 sk->sk_state == TCP_LISTEN)) {
652 res = -EADDRNOTAVAIL;
653 dev_put(dev);
654 break;
655 }
656
657 ax25->ax25_dev = ax25_dev_ax25dev(dev);
658 ax25_fillin_cb(ax25, ax25->ax25_dev);
659 break;
660
661 default:
662 res = -ENOPROTOOPT;
663 }
664 release_sock(sk);
665
666 return res;
667}
668
669static int ax25_getsockopt(struct socket *sock, int level, int optname,
670 char __user *optval, int __user *optlen)
671{
672 struct sock *sk = sock->sk;
673 ax25_cb *ax25;
674 struct ax25_dev *ax25_dev;
675 char devname[IFNAMSIZ];
676 void *valptr;
677 int val = 0;
678 int maxlen, length;
679
680 if (level != SOL_AX25)
681 return -ENOPROTOOPT;
682
683 if (get_user(maxlen, optlen))
684 return -EFAULT;
685
686 if (maxlen < 1)
687 return -EFAULT;
688
689 valptr = (void *) &val;
690 length = min_t(unsigned int, maxlen, sizeof(int));
691
692 lock_sock(sk);
693 ax25 = ax25_sk(sk);
694
695 switch (optname) {
696 case AX25_WINDOW:
697 val = ax25->window;
698 break;
699
700 case AX25_T1:
701 val = ax25->t1 / HZ;
702 break;
703
704 case AX25_T2:
705 val = ax25->t2 / HZ;
706 break;
707
708 case AX25_N2:
709 val = ax25->n2;
710 break;
711
712 case AX25_T3:
713 val = ax25->t3 / HZ;
714 break;
715
716 case AX25_IDLE:
717 val = ax25->idle / (60 * HZ);
718 break;
719
720 case AX25_BACKOFF:
721 val = ax25->backoff;
722 break;
723
724 case AX25_EXTSEQ:
725 val = (ax25->modulus == AX25_EMODULUS);
726 break;
727
728 case AX25_PIDINCL:
729 val = ax25->pidincl;
730 break;
731
732 case AX25_IAMDIGI:
733 val = ax25->iamdigi;
734 break;
735
736 case AX25_PACLEN:
737 val = ax25->paclen;
738 break;
739
740 case SO_BINDTODEVICE:
741 ax25_dev = ax25->ax25_dev;
742
743 if (ax25_dev != NULL && ax25_dev->dev != NULL) {
744 strlcpy(devname, ax25_dev->dev->name, sizeof(devname));
745 length = strlen(devname) + 1;
746 } else {
747 *devname = '\0';
748 length = 1;
749 }
750
751 valptr = (void *) devname;
752 break;
753
754 default:
755 release_sock(sk);
756 return -ENOPROTOOPT;
757 }
758 release_sock(sk);
759
760 if (put_user(length, optlen))
761 return -EFAULT;
762
763 return copy_to_user(optval, valptr, length) ? -EFAULT : 0;
764}
765
766static int ax25_listen(struct socket *sock, int backlog)
767{
768 struct sock *sk = sock->sk;
769 int res = 0;
770
771 lock_sock(sk);
772 if (sk->sk_type == SOCK_SEQPACKET && sk->sk_state != TCP_LISTEN) {
773 sk->sk_max_ack_backlog = backlog;
774 sk->sk_state = TCP_LISTEN;
775 goto out;
776 }
777 res = -EOPNOTSUPP;
778
779out:
780 release_sock(sk);
781
782 return res;
783}
784
785/*
786 * XXX: when creating ax25_sock we should update the .obj_size setting
787 * below.
788 */
789static struct proto ax25_proto = {
790 .name = "AX25",
791 .owner = THIS_MODULE,
792 .obj_size = sizeof(struct sock),
793};
794
1b8d7ae4 795static int ax25_create(struct net *net, struct socket *sock, int protocol)
1da177e4
LT		 796{
797 struct sock *sk;
798 ax25_cb *ax25;
799
1b8d7ae4
EB		 800 if (net != &init_net)
801 return -EAFNOSUPPORT;
802
1da177e4
LT		 803 switch (sock->type) {
804 case SOCK_DGRAM:
805 if (protocol == 0 || protocol == PF_AX25)
806 protocol = AX25_P_TEXT;
807 break;
808
809 case SOCK_SEQPACKET:
810 switch (protocol) {
811 case 0:
812 case PF_AX25: /* For CLX */
813 protocol = AX25_P_TEXT;
814 break;
815 case AX25_P_SEGMENT:
816#ifdef CONFIG_INET
817 case AX25_P_ARP:
818 case AX25_P_IP:
819#endif
820#ifdef CONFIG_NETROM
821 case AX25_P_NETROM:
822#endif
823#ifdef CONFIG_ROSE
824 case AX25_P_ROSE:
825#endif
826 return -ESOCKTNOSUPPORT;
827#ifdef CONFIG_NETROM_MODULE
828 case AX25_P_NETROM:
829 if (ax25_protocol_is_registered(AX25_P_NETROM))
830 return -ESOCKTNOSUPPORT;
831#endif
832#ifdef CONFIG_ROSE_MODULE
833 case AX25_P_ROSE:
834 if (ax25_protocol_is_registered(AX25_P_ROSE))
835 return -ESOCKTNOSUPPORT;
836#endif
837 default:
838 break;
839 }
840 break;
841
842 case SOCK_RAW:
843 break;
844 default:
845 return -ESOCKTNOSUPPORT;
846 }
847
6257ff21
PE		 848 sk = sk_alloc(net, PF_AX25, GFP_ATOMIC, &ax25_proto);
849 if (sk == NULL)
1da177e4
LT		 850 return -ENOMEM;
851
852 ax25 = sk->sk_protinfo = ax25_create_cb();
853 if (!ax25) {
854 sk_free(sk);
855 return -ENOMEM;
856 }
857
858 sock_init_data(sock, sk);
859
860 sk->sk_destruct = ax25_free_sock;
861 sock->ops = &ax25_proto_ops;
862 sk->sk_protocol = protocol;
863
864 ax25->sk = sk;
865
866 return 0;
867}
868
869struct sock *ax25_make_new(struct sock *osk, struct ax25_dev *ax25_dev)
870{
871 struct sock *sk;
872 ax25_cb *ax25, *oax25;
873
3b1e0a65 874 sk = sk_alloc(sock_net(osk), PF_AX25, GFP_ATOMIC, osk->sk_prot);
6257ff21 875 if (sk == NULL)
1da177e4
LT		 876 return NULL;
877
878 if ((ax25 = ax25_create_cb()) == NULL) {
879 sk_free(sk);
880 return NULL;
881 }
882
883 switch (osk->sk_type) {
884 case SOCK_DGRAM:
885 break;
886 case SOCK_SEQPACKET:
887 break;
888 default:
889 sk_free(sk);
890 ax25_cb_put(ax25);
891 return NULL;
892 }
893
894 sock_init_data(NULL, sk);
895
896 sk->sk_destruct = ax25_free_sock;
897 sk->sk_type = osk->sk_type;
1da177e4
LT		 898 sk->sk_priority = osk->sk_priority;
899 sk->sk_protocol = osk->sk_protocol;
900 sk->sk_rcvbuf = osk->sk_rcvbuf;
901 sk->sk_sndbuf = osk->sk_sndbuf;
902 sk->sk_state = TCP_ESTABLISHED;
53b924b3 903 sock_copy_flags(sk, osk);
1da177e4
LT		 904
905 oax25 = ax25_sk(osk);
906
907 ax25->modulus = oax25->modulus;
908 ax25->backoff = oax25->backoff;
909 ax25->pidincl = oax25->pidincl;
910 ax25->iamdigi = oax25->iamdigi;
911 ax25->rtt = oax25->rtt;
912 ax25->t1 = oax25->t1;
913 ax25->t2 = oax25->t2;
914 ax25->t3 = oax25->t3;
915 ax25->n2 = oax25->n2;
916 ax25->idle = oax25->idle;
917 ax25->paclen = oax25->paclen;
918 ax25->window = oax25->window;
919
920 ax25->ax25_dev = ax25_dev;
921 ax25->source_addr = oax25->source_addr;
922
923 if (oax25->digipeat != NULL) {
0459d70a
ACM		 924 ax25->digipeat = kmemdup(oax25->digipeat, sizeof(ax25_digi),
925 GFP_ATOMIC);
926 if (ax25->digipeat == NULL) {
1da177e4
LT		 927 sk_free(sk);
928 ax25_cb_put(ax25);
929 return NULL;
930 }
1da177e4
LT		 931 }
932
933 sk->sk_protinfo = ax25;
934 ax25->sk = sk;
935
936 return sk;
937}
938
939static int ax25_release(struct socket *sock)
940{
941 struct sock *sk = sock->sk;
942 ax25_cb *ax25;
943
944 if (sk == NULL)
945 return 0;
946
947 sock_hold(sk);
948 sock_orphan(sk);
949 lock_sock(sk);
950 ax25 = ax25_sk(sk);
951
952 if (sk->sk_type == SOCK_SEQPACKET) {
953 switch (ax25->state) {
954 case AX25_STATE_0:
955 release_sock(sk);
956 ax25_disconnect(ax25, 0);
957 lock_sock(sk);
958 ax25_destroy_socket(ax25);
959 break;
960
961 case AX25_STATE_1:
962 case AX25_STATE_2:
963 ax25_send_control(ax25, AX25_DISC, AX25_POLLON, AX25_COMMAND);
964 release_sock(sk);
965 ax25_disconnect(ax25, 0);
966 lock_sock(sk);
967 ax25_destroy_socket(ax25);
968 break;
969
970 case AX25_STATE_3:
971 case AX25_STATE_4:
972 ax25_clear_queues(ax25);
973 ax25->n2count = 0;
974
975 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
976 case AX25_PROTO_STD_SIMPLEX:
977 case AX25_PROTO_STD_DUPLEX:
978 ax25_send_control(ax25,
979 AX25_DISC,
980 AX25_POLLON,
981 AX25_COMMAND);
982 ax25_stop_t2timer(ax25);
983 ax25_stop_t3timer(ax25);
984 ax25_stop_idletimer(ax25);
985 break;
986#ifdef CONFIG_AX25_DAMA_SLAVE
987 case AX25_PROTO_DAMA_SLAVE:
988 ax25_stop_t3timer(ax25);
989 ax25_stop_idletimer(ax25);
990 break;
991#endif
992 }
993 ax25_calculate_t1(ax25);
994 ax25_start_t1timer(ax25);
995 ax25->state = AX25_STATE_2;
996 sk->sk_state = TCP_CLOSE;
997 sk->sk_shutdown |= SEND_SHUTDOWN;
998 sk->sk_state_change(sk);
999 sock_set_flag(sk, SOCK_DESTROY);
1000 break;
1001
1002 default:
1003 break;
1004 }
1005 } else {
1006 sk->sk_state = TCP_CLOSE;
1007 sk->sk_shutdown |= SEND_SHUTDOWN;
1008 sk->sk_state_change(sk);
1009 ax25_destroy_socket(ax25);
1010 }
1011
1012 sock->sk = NULL;
1013 release_sock(sk);
1014 sock_put(sk);
1015
1016 return 0;
1017}
1018
1019/*
1020 * We support a funny extension here so you can (as root) give any callsign
1021 * digipeated via a local address as source. This hack is obsolete now
1022 * that we've implemented support for SO_BINDTODEVICE. It is however small
1023 * and trivially backward compatible.
1024 */
1025static int ax25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
1026{
1027 struct sock *sk = sock->sk;
1028 struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
1029 ax25_dev *ax25_dev = NULL;
01d7dd0e
RB		 1030 ax25_uid_assoc *user;
1031 ax25_address call;
1da177e4
LT		 1032 ax25_cb *ax25;
1033 int err = 0;
1034
1035 if (addr_len != sizeof(struct sockaddr_ax25) &&
1987e7b4 1036 addr_len != sizeof(struct full_sockaddr_ax25))
1037 /* support for old structure may go away some time
1038 * ax25_bind(): uses old (6 digipeater) socket structure.
1039 */
1da177e4 1040 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
1987e7b4 1041 (addr_len > sizeof(struct full_sockaddr_ax25)))
1da177e4 1042 return -EINVAL;
1da177e4
LT		 1043
1044 if (addr->fsa_ax25.sax25_family != AF_AX25)
1045 return -EINVAL;
1046
73400407 1047 user = ax25_findbyuid(current_euid());
01d7dd0e
RB		 1048 if (user) {
1049 call = user->call;
1050 ax25_uid_put(user);
1051 } else {
1052 if (ax25_uid_policy && !capable(CAP_NET_ADMIN))
1053 return -EACCES;
1054
1055 call = addr->fsa_ax25.sax25_call;
1da177e4
LT		 1056 }
1057
1058 lock_sock(sk);
1059
1060 ax25 = ax25_sk(sk);
1061 if (!sock_flag(sk, SOCK_ZAPPED)) {
1062 err = -EINVAL;
1063 goto out;
1064 }
1065
01d7dd0e 1066 ax25->source_addr = call;
1da177e4
LT		 1067
1068 /*
1069 * User already set interface with SO_BINDTODEVICE
1070 */
1071 if (ax25->ax25_dev != NULL)
1072 goto done;
1073
1074 if (addr_len > sizeof(struct sockaddr_ax25) && addr->fsa_ax25.sax25_ndigis == 1) {
1075 if (ax25cmp(&addr->fsa_digipeater[0], &null_ax25_address) != 0 &&
1076 (ax25_dev = ax25_addr_ax25dev(&addr->fsa_digipeater[0])) == NULL) {
1077 err = -EADDRNOTAVAIL;
1078 goto out;
1079 }
1080 } else {
1081 if ((ax25_dev = ax25_addr_ax25dev(&addr->fsa_ax25.sax25_call)) == NULL) {
1082 err = -EADDRNOTAVAIL;
1083 goto out;
1084 }
1085 }
1086
1087 if (ax25_dev != NULL)
1088 ax25_fillin_cb(ax25, ax25_dev);
1089
1090done:
1091 ax25_cb_add(ax25);
1092 sock_reset_flag(sk, SOCK_ZAPPED);
1093
1094out:
1095 release_sock(sk);
1096
1097 return 0;
1098}
1099
1100/*
1101 * FIXME: nonblock behaviour looks like it may have a bug.
1102 */
c9266b99
RB		 1103static int __must_check ax25_connect(struct socket *sock,
1104 struct sockaddr *uaddr, int addr_len, int flags)
1da177e4
LT		 1105{
1106 struct sock *sk = sock->sk;
1107 ax25_cb *ax25 = ax25_sk(sk), *ax25t;
1108 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1109 ax25_digi *digi = NULL;
1110 int ct = 0, err = 0;
1111
1112 /*
1113 * some sanity checks. code further down depends on this
1114 */
1115
27d1cba2 1116 if (addr_len == sizeof(struct sockaddr_ax25))
1117 /* support for this will go away in early 2.5.x
1118 * ax25_connect(): uses obsolete socket structure
1119 */
1120 ;
1121 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1122 /* support for old structure may go away some time
1123 * ax25_connect(): uses old (6 digipeater) socket structure.
1124 */
1da177e4 1125 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
27d1cba2 1126 (addr_len > sizeof(struct full_sockaddr_ax25)))
1da177e4 1127 return -EINVAL;
1da177e4 1128
1da177e4
LT		 1129
1130 if (fsa->fsa_ax25.sax25_family != AF_AX25)
1131 return -EINVAL;
1132
1133 lock_sock(sk);
1134
1135 /* deal with restarts */
1136 if (sock->state == SS_CONNECTING) {
1137 switch (sk->sk_state) {
1138 case TCP_SYN_SENT: /* still trying */
1139 err = -EINPROGRESS;
75606dc6 1140 goto out_release;
1da177e4
LT		 1141
1142 case TCP_ESTABLISHED: /* connection established */
1143 sock->state = SS_CONNECTED;
75606dc6 1144 goto out_release;
1da177e4
LT		 1145
1146 case TCP_CLOSE: /* connection refused */
1147 sock->state = SS_UNCONNECTED;
1148 err = -ECONNREFUSED;
75606dc6 1149 goto out_release;
1da177e4
LT		 1150 }
1151 }
1152
1153 if (sk->sk_state == TCP_ESTABLISHED && sk->sk_type == SOCK_SEQPACKET) {
1154 err = -EISCONN; /* No reconnect on a seqpacket socket */
75606dc6 1155 goto out_release;
1da177e4
LT		 1156 }
1157
1158 sk->sk_state = TCP_CLOSE;
1159 sock->state = SS_UNCONNECTED;
1160
a51482bd
JJ		 1161 kfree(ax25->digipeat);
1162 ax25->digipeat = NULL;
1da177e4
LT		 1163
1164 /*
1165 * Handle digi-peaters to be used.
1166 */
1167 if (addr_len > sizeof(struct sockaddr_ax25) &&
1168 fsa->fsa_ax25.sax25_ndigis != 0) {
1169 /* Valid number of digipeaters ? */
1170 if (fsa->fsa_ax25.sax25_ndigis < 1 || fsa->fsa_ax25.sax25_ndigis > AX25_MAX_DIGIS) {
1171 err = -EINVAL;
75606dc6 1172 goto out_release;
1da177e4
LT		 1173 }
1174
1175 if ((digi = kmalloc(sizeof(ax25_digi), GFP_KERNEL)) == NULL) {
1176 err = -ENOBUFS;
75606dc6 1177 goto out_release;
1da177e4
LT		 1178 }
1179
1180 digi->ndigi = fsa->fsa_ax25.sax25_ndigis;
1181 digi->lastrepeat = -1;
1182
1183 while (ct < fsa->fsa_ax25.sax25_ndigis) {
1184 if ((fsa->fsa_digipeater[ct].ax25_call[6] &
1185 AX25_HBIT) && ax25->iamdigi) {
1186 digi->repeated[ct] = 1;
1187 digi->lastrepeat = ct;
1188 } else {
1189 digi->repeated[ct] = 0;
1190 }
1191 digi->calls[ct] = fsa->fsa_digipeater[ct];
1192 ct++;
1193 }
1194 }
1195
1196 /*
1197 * Must bind first - autobinding in this may or may not work. If
1198 * the socket is already bound, check to see if the device has
1199 * been filled in, error if it hasn't.
1200 */
1201 if (sock_flag(sk, SOCK_ZAPPED)) {
1202 /* check if we can remove this feature. It is broken. */
1203 printk(KERN_WARNING "ax25_connect(): %s uses autobind, please contact jreuter@yaina.de\n",
1204 current->comm);
1205 if ((err = ax25_rt_autobind(ax25, &fsa->fsa_ax25.sax25_call)) < 0) {
1206 kfree(digi);
75606dc6 1207 goto out_release;
1da177e4
LT		 1208 }
1209
1210 ax25_fillin_cb(ax25, ax25->ax25_dev);
1211 ax25_cb_add(ax25);
1212 } else {
1213 if (ax25->ax25_dev == NULL) {
1214 kfree(digi);
1215 err = -EHOSTUNREACH;
75606dc6 1216 goto out_release;
1da177e4
LT		 1217 }
1218 }
1219
1220 if (sk->sk_type == SOCK_SEQPACKET &&
1221 (ax25t=ax25_find_cb(&ax25->source_addr, &fsa->fsa_ax25.sax25_call, digi,
528930b9 1222 ax25->ax25_dev->dev))) {
1da177e4
LT		 1223 kfree(digi);
1224 err = -EADDRINUSE; /* Already such a connection */
1225 ax25_cb_put(ax25t);
75606dc6 1226 goto out_release;
1da177e4
LT		 1227 }
1228
1229 ax25->dest_addr = fsa->fsa_ax25.sax25_call;
1230 ax25->digipeat = digi;
1231
1232 /* First the easy one */
1233 if (sk->sk_type != SOCK_SEQPACKET) {
1234 sock->state = SS_CONNECTED;
1235 sk->sk_state = TCP_ESTABLISHED;
75606dc6 1236 goto out_release;
1da177e4
LT		 1237 }
1238
1239 /* Move to connecting socket, ax.25 lapb WAIT_UA.. */
1240 sock->state = SS_CONNECTING;
1241 sk->sk_state = TCP_SYN_SENT;
1242
1243 switch (ax25->ax25_dev->values[AX25_VALUES_PROTOCOL]) {
1244 case AX25_PROTO_STD_SIMPLEX:
1245 case AX25_PROTO_STD_DUPLEX:
1246 ax25_std_establish_data_link(ax25);
1247 break;
1248
1249#ifdef CONFIG_AX25_DAMA_SLAVE
1250 case AX25_PROTO_DAMA_SLAVE:
1251 ax25->modulus = AX25_MODULUS;
1252 ax25->window = ax25->ax25_dev->values[AX25_VALUES_WINDOW];
1253 if (ax25->ax25_dev->dama.slave)
1254 ax25_ds_establish_data_link(ax25);
1255 else
1256 ax25_std_establish_data_link(ax25);
1257 break;
1258#endif
1259 }
1260
1261 ax25->state = AX25_STATE_1;
1262
1263 ax25_start_heartbeat(ax25);
1264
1265 /* Now the loop */
1266 if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
1267 err = -EINPROGRESS;
75606dc6 1268 goto out_release;
1da177e4
LT		 1269 }
1270
1271 if (sk->sk_state == TCP_SYN_SENT) {
75606dc6 1272 DEFINE_WAIT(wait);
1da177e4 1273
1da177e4 1274 for (;;) {
75606dc6 1275 prepare_to_wait(sk->sk_sleep, &wait,
bd3b071b 1276 TASK_INTERRUPTIBLE);
1da177e4
LT		 1277 if (sk->sk_state != TCP_SYN_SENT)
1278 break;
75606dc6
RB		 1279 if (!signal_pending(current)) {
1280 release_sock(sk);
1da177e4
LT		 1281 schedule();
1282 lock_sock(sk);
1283 continue;
1284 }
75606dc6
RB		 1285 err = -ERESTARTSYS;
1286 break;
1da177e4 1287 }
75606dc6
RB		 1288 finish_wait(sk->sk_sleep, &wait);
1289
1290 if (err)
1291 goto out_release;
1da177e4
LT		 1292 }
1293
1294 if (sk->sk_state != TCP_ESTABLISHED) {
1295 /* Not in ABM, not in WAIT_UA -> failed */
1296 sock->state = SS_UNCONNECTED;
1297 err = sock_error(sk); /* Always set at this point */
75606dc6 1298 goto out_release;
1da177e4
LT		 1299 }
1300
1301 sock->state = SS_CONNECTED;
1302
75606dc6
RB		 1303 err = 0;
1304out_release:
1da177e4
LT		 1305 release_sock(sk);
1306
1307 return err;
1308}
1309
1da177e4
LT		 1310static int ax25_accept(struct socket *sock, struct socket *newsock, int flags)
1311{
1da177e4
LT		 1312 struct sk_buff *skb;
1313 struct sock *newsk;
75606dc6 1314 DEFINE_WAIT(wait);
1da177e4
LT		 1315 struct sock *sk;
1316 int err = 0;
1317
1318 if (sock->state != SS_UNCONNECTED)
1319 return -EINVAL;
1320
1321 if ((sk = sock->sk) == NULL)
1322 return -EINVAL;
1323
1324 lock_sock(sk);
1325 if (sk->sk_type != SOCK_SEQPACKET) {
1326 err = -EOPNOTSUPP;
1327 goto out;
1328 }
1329
1330 if (sk->sk_state != TCP_LISTEN) {
1331 err = -EINVAL;
1332 goto out;
1333 }
1334
1335 /*
1336 * The read queue this time is holding sockets ready to use
1337 * hooked into the SABM we saved
1338 */
1da177e4 1339 for (;;) {
75606dc6 1340 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1da177e4
LT		 1341 skb = skb_dequeue(&sk->sk_receive_queue);
1342 if (skb)
1343 break;
1344
1da177e4 1345 if (flags & O_NONBLOCK) {
75606dc6
RB		 1346 err = -EWOULDBLOCK;
1347 break;
1da177e4 1348 }
75606dc6
RB		 1349 if (!signal_pending(current)) {
1350 release_sock(sk);
1da177e4
LT		 1351 schedule();
1352 lock_sock(sk);
1353 continue;
1354 }
75606dc6
RB		 1355 err = -ERESTARTSYS;
1356 break;
1da177e4 1357 }
75606dc6
RB		 1358 finish_wait(sk->sk_sleep, &wait);
1359
1360 if (err)
1361 goto out;
1da177e4
LT		 1362
1363 newsk = skb->sk;
9375cb8a 1364 sock_graft(newsk, newsock);
1da177e4
LT		 1365
1366 /* Now attach up the new socket */
1367 kfree_skb(skb);
1368 sk->sk_ack_backlog--;
1da177e4
LT		 1369 newsock->state = SS_CONNECTED;
1370
1371out:
1372 release_sock(sk);
1373
1374 return err;
1375}
1376
1377static int ax25_getname(struct socket *sock, struct sockaddr *uaddr,
1378 int *uaddr_len, int peer)
1379{
1380 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)uaddr;
1381 struct sock *sk = sock->sk;
1382 unsigned char ndigi, i;
1383 ax25_cb *ax25;
1384 int err = 0;
1385
1386 lock_sock(sk);
1387 ax25 = ax25_sk(sk);
1388
1389 if (peer != 0) {
1390 if (sk->sk_state != TCP_ESTABLISHED) {
1391 err = -ENOTCONN;
1392 goto out;
1393 }
1394
1395 fsa->fsa_ax25.sax25_family = AF_AX25;
1396 fsa->fsa_ax25.sax25_call = ax25->dest_addr;
1397 fsa->fsa_ax25.sax25_ndigis = 0;
1398
1399 if (ax25->digipeat != NULL) {
1400 ndigi = ax25->digipeat->ndigi;
1401 fsa->fsa_ax25.sax25_ndigis = ndigi;
1402 for (i = 0; i < ndigi; i++)
1403 fsa->fsa_digipeater[i] =
1404 ax25->digipeat->calls[i];
1405 }
1406 } else {
1407 fsa->fsa_ax25.sax25_family = AF_AX25;
1408 fsa->fsa_ax25.sax25_call = ax25->source_addr;
1409 fsa->fsa_ax25.sax25_ndigis = 1;
1410 if (ax25->ax25_dev != NULL) {
1411 memcpy(&fsa->fsa_digipeater[0],
1412 ax25->ax25_dev->dev->dev_addr, AX25_ADDR_LEN);
1413 } else {
1414 fsa->fsa_digipeater[0] = null_ax25_address;
1415 }
1416 }
1417 *uaddr_len = sizeof (struct full_sockaddr_ax25);
1418
1419out:
1420 release_sock(sk);
1421
1422 return err;
1423}
1424
1425static int ax25_sendmsg(struct kiocb *iocb, struct socket *sock,
1426 struct msghdr *msg, size_t len)
1427{
1428 struct sockaddr_ax25 *usax = (struct sockaddr_ax25 *)msg->msg_name;
1429 struct sock *sk = sock->sk;
1430 struct sockaddr_ax25 sax;
1431 struct sk_buff *skb;
1432 ax25_digi dtmp, *dp;
1da177e4
LT		 1433 ax25_cb *ax25;
1434 size_t size;
1435 int lv, err, addr_len = msg->msg_namelen;
1436
1437 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1438 return -EINVAL;
1439
1440 lock_sock(sk);
1441 ax25 = ax25_sk(sk);
1442
1443 if (sock_flag(sk, SOCK_ZAPPED)) {
1444 err = -EADDRNOTAVAIL;
1445 goto out;
1446 }
1447
1448 if (sk->sk_shutdown & SEND_SHUTDOWN) {
1449 send_sig(SIGPIPE, current, 0);
1450 err = -EPIPE;
1451 goto out;
1452 }
1453
1454 if (ax25->ax25_dev == NULL) {
1455 err = -ENETUNREACH;
1456 goto out;
1457 }
1458
1459 if (len > ax25->ax25_dev->dev->mtu) {
1460 err = -EMSGSIZE;
1461 goto out;
1462 }
528930b9 1463
1da177e4
LT		 1464 if (usax != NULL) {
1465 if (usax->sax25_family != AF_AX25) {
1466 err = -EINVAL;
1467 goto out;
1468 }
1469
27d1cba2 1470 if (addr_len == sizeof(struct sockaddr_ax25))
1471 /* ax25_sendmsg(): uses obsolete socket structure */
1472 ;
1473 else if (addr_len != sizeof(struct full_sockaddr_ax25))
1474 /* support for old structure may go away some time
1475 * ax25_sendmsg(): uses old (6 digipeater)
1476 * socket structure.
1477 */
1da177e4 1478 if ((addr_len < sizeof(struct sockaddr_ax25) + sizeof(ax25_address) * 6) ||
528930b9
YH		 1479 (addr_len > sizeof(struct full_sockaddr_ax25))) {
1480 err = -EINVAL;
1da177e4
LT		 1481 goto out;
1482 }
1483
1da177e4
LT		 1484
1485 if (addr_len > sizeof(struct sockaddr_ax25) && usax->sax25_ndigis != 0) {
1486 int ct = 0;
1487 struct full_sockaddr_ax25 *fsa = (struct full_sockaddr_ax25 *)usax;
1488
1489 /* Valid number of digipeaters ? */
1490 if (usax->sax25_ndigis < 1 || usax->sax25_ndigis > AX25_MAX_DIGIS) {
1491 err = -EINVAL;
1492 goto out;
1493 }
1494
1495 dtmp.ndigi = usax->sax25_ndigis;
1496
1497 while (ct < usax->sax25_ndigis) {
1498 dtmp.repeated[ct] = 0;
1499 dtmp.calls[ct] = fsa->fsa_digipeater[ct];
1500 ct++;
1501 }
1502
1503 dtmp.lastrepeat = 0;
1504 }
1505
1506 sax = *usax;
1507 if (sk->sk_type == SOCK_SEQPACKET &&
1508 ax25cmp(&ax25->dest_addr, &sax.sax25_call)) {
1509 err = -EISCONN;
1510 goto out;
1511 }
1512 if (usax->sax25_ndigis == 0)
1513 dp = NULL;
1514 else
1515 dp = &dtmp;
1516 } else {
1517 /*
1518 * FIXME: 1003.1g - if the socket is like this because
1519 * it has become closed (not started closed) and is VC
1520 * we ought to SIGPIPE, EPIPE
1521 */
1522 if (sk->sk_state != TCP_ESTABLISHED) {
1523 err = -ENOTCONN;
1524 goto out;
1525 }
1526 sax.sax25_family = AF_AX25;
1527 sax.sax25_call = ax25->dest_addr;
1528 dp = ax25->digipeat;
1529 }
1530
1da177e4 1531 /* Build a packet */
60784427 1532 SOCK_DEBUG(sk, "AX.25: sendto: Addresses built. Building packet.\n");
1da177e4
LT		 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;
31e6d363
ED		 1693
1694 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1da177e4
LT		 1695 if (amount < 0)
1696 amount = 0;
1697 res = put_user(amount, (int __user *)argp);
1698 break;
1699 }
1700
1701 case TIOCINQ: {
1702 struct sk_buff *skb;
1703 long amount = 0L;
1704 /* These two are safe on a single CPU system as only user tasks fiddle here */
1705 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1706 amount = skb->len;
20b7d10a 1707 res = put_user(amount, (int __user *) argp);
1da177e4
LT		 1708 break;
1709 }
1710
1711 case SIOCGSTAMP:
9b37ee75 1712 res = sock_get_timestamp(sk, argp);
1da177e4
LT		 1713 break;
1714
ae40eb1e
ED		 1715 case SIOCGSTAMPNS:
1716 res = sock_get_timestampns(sk, argp);
1717 break;
1718
1da177e4
LT		 1719 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
1720 case SIOCAX25DELUID: /* Delete a uid from the uid/call map table */
1721 case SIOCAX25GETUID: {
1722 struct sockaddr_ax25 sax25;
1723 if (copy_from_user(&sax25, argp, sizeof(sax25))) {
1724 res = -EFAULT;
1725 break;
1726 }
1727 res = ax25_uid_ioctl(cmd, &sax25);
1728 break;
1729 }
1730
1731 case SIOCAX25NOUID: { /* Set the default policy (default/bar) */
1732 long amount;
1733 if (!capable(CAP_NET_ADMIN)) {
1734 res = -EPERM;
1735 break;
1736 }
1737 if (get_user(amount, (long __user *)argp)) {
1738 res = -EFAULT;
1739 break;
1740 }
1741 if (amount > AX25_NOUID_BLOCK) {
1742 res = -EINVAL;
1743 break;
1744 }
1745 ax25_uid_policy = amount;
1746 res = 0;
1747 break;
1748 }
1749
1750 case SIOCADDRT:
1751 case SIOCDELRT:
1752 case SIOCAX25OPTRT:
1753 if (!capable(CAP_NET_ADMIN)) {
1754 res = -EPERM;
1755 break;
1756 }
1757 res = ax25_rt_ioctl(cmd, argp);
1758 break;
1759
1760 case SIOCAX25CTLCON:
1761 if (!capable(CAP_NET_ADMIN)) {
1762 res = -EPERM;
1763 break;
1764 }
1765 res = ax25_ctl_ioctl(cmd, argp);
1766 break;
1767
1768 case SIOCAX25GETINFO:
1769 case SIOCAX25GETINFOOLD: {
1770 ax25_cb *ax25 = ax25_sk(sk);
1771 struct ax25_info_struct ax25_info;
1772
1773 ax25_info.t1 = ax25->t1 / HZ;
1774 ax25_info.t2 = ax25->t2 / HZ;
1775 ax25_info.t3 = ax25->t3 / HZ;
1776 ax25_info.idle = ax25->idle / (60 * HZ);
1777 ax25_info.n2 = ax25->n2;
1778 ax25_info.t1timer = ax25_display_timer(&ax25->t1timer) / HZ;
1779 ax25_info.t2timer = ax25_display_timer(&ax25->t2timer) / HZ;
1780 ax25_info.t3timer = ax25_display_timer(&ax25->t3timer) / HZ;
1781 ax25_info.idletimer = ax25_display_timer(&ax25->idletimer) / (60 * HZ);
1782 ax25_info.n2count = ax25->n2count;
1783 ax25_info.state = ax25->state;
31e6d363
ED		 1784 ax25_info.rcv_q = sk_wmem_alloc_get(sk);
1785 ax25_info.snd_q = sk_rmem_alloc_get(sk);
1da177e4
LT		 1786 ax25_info.vs = ax25->vs;
1787 ax25_info.vr = ax25->vr;
1788 ax25_info.va = ax25->va;
1789 ax25_info.vs_max = ax25->vs; /* reserved */
1790 ax25_info.paclen = ax25->paclen;
1791 ax25_info.window = ax25->window;
1792
1793 /* old structure? */
1794 if (cmd == SIOCAX25GETINFOOLD) {
1795 static int warned = 0;
1796 if (!warned) {
1797 printk(KERN_INFO "%s uses old SIOCAX25GETINFO\n",
1798 current->comm);
1799 warned=1;
1800 }
1801
1802 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct_deprecated))) {
1803 res = -EFAULT;
1804 break;
1805 }
1806 } else {
1807 if (copy_to_user(argp, &ax25_info, sizeof(struct ax25_info_struct))) {
1808 res = -EINVAL;
1809 break;
1810 }
1811 }
1812 res = 0;
1813 break;
1814 }
1815
1816 case SIOCAX25ADDFWD:
1817 case SIOCAX25DELFWD: {
1818 struct ax25_fwd_struct ax25_fwd;
1819 if (!capable(CAP_NET_ADMIN)) {
1820 res = -EPERM;
1821 break;
1822 }
1823 if (copy_from_user(&ax25_fwd, argp, sizeof(ax25_fwd))) {
1824 res = -EFAULT;
1825 break;
1826 }
1827 res = ax25_fwd_ioctl(cmd, &ax25_fwd);
1828 break;
1829 }
1830
1831 case SIOCGIFADDR:
1832 case SIOCSIFADDR:
1833 case SIOCGIFDSTADDR:
1834 case SIOCSIFDSTADDR:
1835 case SIOCGIFBRDADDR:
1836 case SIOCSIFBRDADDR:
1837 case SIOCGIFNETMASK:
1838 case SIOCSIFNETMASK:
1839 case SIOCGIFMETRIC:
1840 case SIOCSIFMETRIC:
1841 res = -EINVAL;
1842 break;
1843
1844 default:
b5e5fa5e 1845 res = -ENOIOCTLCMD;
1da177e4
LT		 1846 break;
1847 }
1848 release_sock(sk);
1849
1850 return res;
1851}
1852
1853#ifdef CONFIG_PROC_FS
1854
1855static void *ax25_info_start(struct seq_file *seq, loff_t *pos)
f16f3026 1856 __acquires(ax25_list_lock)
1da177e4
LT		 1857{
1858 struct ax25_cb *ax25;
1859 struct hlist_node *node;
1860 int i = 0;
1861
1862 spin_lock_bh(&ax25_list_lock);
1863 ax25_for_each(ax25, node, &ax25_list) {
1864 if (i == *pos)
1865 return ax25;
1866 ++i;
1867 }
1868 return NULL;
1869}
1870
1871static void *ax25_info_next(struct seq_file *seq, void *v, loff_t *pos)
1872{
1873 ++*pos;
1874
1875 return hlist_entry( ((struct ax25_cb *)v)->ax25_node.next,
1876 struct ax25_cb, ax25_node);
1877}
528930b9 1878
1da177e4 1879static void ax25_info_stop(struct seq_file *seq, void *v)
f16f3026 1880 __releases(ax25_list_lock)
1da177e4
LT		 1881{
1882 spin_unlock_bh(&ax25_list_lock);
1883}
1884
1885static int ax25_info_show(struct seq_file *seq, void *v)
1886{
1887 ax25_cb *ax25 = v;
f75268cd 1888 char buf[11];
1da177e4
LT		 1889 int k;
1890
1891
1892 /*
1893 * New format:
1894 * 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
1895 */
1896
1897 seq_printf(seq, "%8.8lx %s %s%s ",
1898 (long) ax25,
1899 ax25->ax25_dev == NULL? "???" : ax25->ax25_dev->dev->name,
f75268cd 1900 ax2asc(buf, &ax25->source_addr),
1da177e4 1901 ax25->iamdigi? "*":"");
f75268cd 1902 seq_printf(seq, "%s", ax2asc(buf, &ax25->dest_addr));
1da177e4
LT		 1903
1904 for (k=0; (ax25->digipeat != NULL) && (k < ax25->digipeat->ndigi); k++) {
1905 seq_printf(seq, ",%s%s",
f75268cd 1906 ax2asc(buf, &ax25->digipeat->calls[k]),
1da177e4
LT		 1907 ax25->digipeat->repeated[k]? "*":"");
1908 }
1909
1910 seq_printf(seq, " %d %d %d %d %lu %lu %lu %lu %lu %lu %lu %lu %d %d %lu %d %d",
1911 ax25->state,
1912 ax25->vs, ax25->vr, ax25->va,
1913 ax25_display_timer(&ax25->t1timer) / HZ, ax25->t1 / HZ,
1914 ax25_display_timer(&ax25->t2timer) / HZ, ax25->t2 / HZ,
1915 ax25_display_timer(&ax25->t3timer) / HZ, ax25->t3 / HZ,
1916 ax25_display_timer(&ax25->idletimer) / (60 * HZ),
1917 ax25->idle / (60 * HZ),
1918 ax25->n2count, ax25->n2,
1919 ax25->rtt / HZ,
1920 ax25->window,
1921 ax25->paclen);
1922
1923 if (ax25->sk != NULL) {
1105b5d1 1924 seq_printf(seq, " %d %d %lu\n",
31e6d363
ED		 1925 sk_wmem_alloc_get(ax25->sk),
1926 sk_rmem_alloc_get(ax25->sk),
1105b5d1 1927 sock_i_ino(ax25->sk));
1da177e4
LT		 1928 } else {
1929 seq_puts(seq, " * * *\n");
1930 }
1931 return 0;
1932}
1933
56b3d975 1934static const struct seq_operations ax25_info_seqops = {
1da177e4
LT		 1935 .start = ax25_info_start,
1936 .next = ax25_info_next,
1937 .stop = ax25_info_stop,
1938 .show = ax25_info_show,
1939};
1940
1941static int ax25_info_open(struct inode *inode, struct file *file)
1942{
1943 return seq_open(file, &ax25_info_seqops);
1944}
1945
9a32144e 1946static const struct file_operations ax25_info_fops = {
1da177e4
LT		 1947 .owner = THIS_MODULE,
1948 .open = ax25_info_open,
1949 .read = seq_read,
1950 .llseek = seq_lseek,
1951 .release = seq_release,
1952};
1953
1954#endif
1955
1956static struct net_proto_family ax25_family_ops = {
1957 .family = PF_AX25,
1958 .create = ax25_create,
1959 .owner = THIS_MODULE,
1960};
1961
90ddc4f0 1962static const struct proto_ops ax25_proto_ops = {
4676356b
RB		 1963 .family = PF_AX25,
1964 .owner = THIS_MODULE,
1965 .release = ax25_release,
1966 .bind = ax25_bind,
1967 .connect = ax25_connect,
1968 .socketpair = sock_no_socketpair,
1969 .accept = ax25_accept,
1970 .getname = ax25_getname,
1971 .poll = datagram_poll,
1972 .ioctl = ax25_ioctl,
1973 .listen = ax25_listen,
1974 .shutdown = ax25_shutdown,
1975 .setsockopt = ax25_setsockopt,
1976 .getsockopt = ax25_getsockopt,
1977 .sendmsg = ax25_sendmsg,
1978 .recvmsg = ax25_recvmsg,
1979 .mmap = sock_no_mmap,
1980 .sendpage = sock_no_sendpage,
1da177e4
LT		 1981};
1982
1983/*
1984 * Called by socket.c on kernel start up
1985 */
7546dd97 1986static struct packet_type ax25_packet_type __read_mostly = {
09640e63 1987 .type = cpu_to_be16(ETH_P_AX25),
1da177e4
LT		 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);
Linux 6.x block layer and io_uring tree(s)