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