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