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