1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *
4  * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
5  * Copyright (C) Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
6  * Copyright (C) Terry Dawson VK2KTJ (terry@animats.net)
7  * Copyright (C) Tomi Manninen OH2BNS (oh2bns@sral.fi)
8  */
9 
10 #include <linux/capability.h>
11 #include <linux/module.h>
12 #include <linux/moduleparam.h>
13 #include <linux/init.h>
14 #include <linux/errno.h>
15 #include <linux/types.h>
16 #include <linux/socket.h>
17 #include <linux/in.h>
18 #include <linux/slab.h>
19 #include <linux/kernel.h>
20 #include <linux/sched/signal.h>
21 #include <linux/spinlock.h>
22 #include <linux/timer.h>
23 #include <linux/string.h>
24 #include <linux/sockios.h>
25 #include <linux/net.h>
26 #include <linux/stat.h>
27 #include <net/net_namespace.h>
28 #include <net/ax25.h>
29 #include <linux/inet.h>
30 #include <linux/netdevice.h>
31 #include <linux/if_arp.h>
32 #include <linux/skbuff.h>
33 #include <net/sock.h>
34 #include <linux/uaccess.h>
35 #include <linux/fcntl.h>
36 #include <linux/termios.h>
37 #include <linux/mm.h>
38 #include <linux/interrupt.h>
39 #include <linux/notifier.h>
40 #include <net/rose.h>
41 #include <linux/proc_fs.h>
42 #include <linux/seq_file.h>
43 #include <net/tcp_states.h>
44 #include <net/ip.h>
45 #include <net/arp.h>
46 
47 static int rose_ndevs = 10;
48 
49 int sysctl_rose_restart_request_timeout = ROSE_DEFAULT_T0;
50 int sysctl_rose_call_request_timeout    = ROSE_DEFAULT_T1;
51 int sysctl_rose_reset_request_timeout   = ROSE_DEFAULT_T2;
52 int sysctl_rose_clear_request_timeout   = ROSE_DEFAULT_T3;
53 int sysctl_rose_no_activity_timeout     = ROSE_DEFAULT_IDLE;
54 int sysctl_rose_ack_hold_back_timeout   = ROSE_DEFAULT_HB;
55 int sysctl_rose_routing_control         = ROSE_DEFAULT_ROUTING;
56 int sysctl_rose_link_fail_timeout       = ROSE_DEFAULT_FAIL_TIMEOUT;
57 int sysctl_rose_maximum_vcs             = ROSE_DEFAULT_MAXVC;
58 int sysctl_rose_window_size             = ROSE_DEFAULT_WINDOW_SIZE;
59 
60 static HLIST_HEAD(rose_list);
61 static DEFINE_SPINLOCK(rose_list_lock);
62 
63 static const struct proto_ops rose_proto_ops;
64 
65 ax25_address rose_callsign;
66 
67 /*
68  * ROSE network devices are virtual network devices encapsulating ROSE
69  * frames into AX.25 which will be sent through an AX.25 device, so form a
70  * special "super class" of normal net devices; split their locks off into a
71  * separate class since they always nest.
72  */
73 static struct lock_class_key rose_netdev_xmit_lock_key;
74 static struct lock_class_key rose_netdev_addr_lock_key;
75 
rose_set_lockdep_one(struct net_device * dev,struct netdev_queue * txq,void * _unused)76 static void rose_set_lockdep_one(struct net_device *dev,
77 				 struct netdev_queue *txq,
78 				 void *_unused)
79 {
80 	lockdep_set_class(&txq->_xmit_lock, &rose_netdev_xmit_lock_key);
81 }
82 
rose_set_lockdep_key(struct net_device * dev)83 static void rose_set_lockdep_key(struct net_device *dev)
84 {
85 	lockdep_set_class(&dev->addr_list_lock, &rose_netdev_addr_lock_key);
86 	netdev_for_each_tx_queue(dev, rose_set_lockdep_one, NULL);
87 }
88 
89 /*
90  *	Convert a ROSE address into text.
91  */
rose2asc(char * buf,const rose_address * addr)92 char *rose2asc(char *buf, const rose_address *addr)
93 {
94 	if (addr->rose_addr[0] == 0x00 && addr->rose_addr[1] == 0x00 &&
95 	    addr->rose_addr[2] == 0x00 && addr->rose_addr[3] == 0x00 &&
96 	    addr->rose_addr[4] == 0x00) {
97 		strcpy(buf, "*");
98 	} else {
99 		sprintf(buf, "%02X%02X%02X%02X%02X", addr->rose_addr[0] & 0xFF,
100 						addr->rose_addr[1] & 0xFF,
101 						addr->rose_addr[2] & 0xFF,
102 						addr->rose_addr[3] & 0xFF,
103 						addr->rose_addr[4] & 0xFF);
104 	}
105 
106 	return buf;
107 }
108 
109 /*
110  *	Compare two ROSE addresses, 0 == equal.
111  */
rosecmp(const rose_address * addr1,const rose_address * addr2)112 int rosecmp(const rose_address *addr1, const rose_address *addr2)
113 {
114 	int i;
115 
116 	for (i = 0; i < 5; i++)
117 		if (addr1->rose_addr[i] != addr2->rose_addr[i])
118 			return 1;
119 
120 	return 0;
121 }
122 
123 /*
124  *	Compare two ROSE addresses for only mask digits, 0 == equal.
125  */
rosecmpm(const rose_address * addr1,const rose_address * addr2,unsigned short mask)126 int rosecmpm(const rose_address *addr1, const rose_address *addr2,
127 	     unsigned short mask)
128 {
129 	unsigned int i, j;
130 
131 	if (mask > 10)
132 		return 1;
133 
134 	for (i = 0; i < mask; i++) {
135 		j = i / 2;
136 
137 		if ((i % 2) != 0) {
138 			if ((addr1->rose_addr[j] & 0x0F) != (addr2->rose_addr[j] & 0x0F))
139 				return 1;
140 		} else {
141 			if ((addr1->rose_addr[j] & 0xF0) != (addr2->rose_addr[j] & 0xF0))
142 				return 1;
143 		}
144 	}
145 
146 	return 0;
147 }
148 
149 /*
150  *	Socket removal during an interrupt is now safe.
151  */
rose_remove_socket(struct sock * sk)152 static void rose_remove_socket(struct sock *sk)
153 {
154 	spin_lock_bh(&rose_list_lock);
155 	sk_del_node_init(sk);
156 	spin_unlock_bh(&rose_list_lock);
157 }
158 
159 /*
160  *	Kill all bound sockets on a broken link layer connection to a
161  *	particular neighbour.
162  */
rose_kill_by_neigh(struct rose_neigh * neigh)163 void rose_kill_by_neigh(struct rose_neigh *neigh)
164 {
165 	struct sock *s;
166 
167 	spin_lock_bh(&rose_list_lock);
168 	sk_for_each(s, &rose_list) {
169 		struct rose_sock *rose = rose_sk(s);
170 
171 		if (rose->neighbour == neigh) {
172 			rose_disconnect(s, ENETUNREACH, ROSE_OUT_OF_ORDER, 0);
173 			rose->neighbour->use--;
174 			rose->neighbour = NULL;
175 		}
176 	}
177 	spin_unlock_bh(&rose_list_lock);
178 }
179 
180 /*
181  *	Kill all bound sockets on a dropped device.
182  */
rose_kill_by_device(struct net_device * dev)183 static void rose_kill_by_device(struct net_device *dev)
184 {
185 	struct sock *s;
186 
187 	spin_lock_bh(&rose_list_lock);
188 	sk_for_each(s, &rose_list) {
189 		struct rose_sock *rose = rose_sk(s);
190 
191 		if (rose->device == dev) {
192 			rose_disconnect(s, ENETUNREACH, ROSE_OUT_OF_ORDER, 0);
193 			if (rose->neighbour)
194 				rose->neighbour->use--;
195 			netdev_put(rose->device, &rose->dev_tracker);
196 			rose->device = NULL;
197 		}
198 	}
199 	spin_unlock_bh(&rose_list_lock);
200 }
201 
202 /*
203  *	Handle device status changes.
204  */
rose_device_event(struct notifier_block * this,unsigned long event,void * ptr)205 static int rose_device_event(struct notifier_block *this,
206 			     unsigned long event, void *ptr)
207 {
208 	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
209 
210 	if (!net_eq(dev_net(dev), &init_net))
211 		return NOTIFY_DONE;
212 
213 	if (event != NETDEV_DOWN)
214 		return NOTIFY_DONE;
215 
216 	switch (dev->type) {
217 	case ARPHRD_ROSE:
218 		rose_kill_by_device(dev);
219 		break;
220 	case ARPHRD_AX25:
221 		rose_link_device_down(dev);
222 		rose_rt_device_down(dev);
223 		break;
224 	}
225 
226 	return NOTIFY_DONE;
227 }
228 
229 /*
230  *	Add a socket to the bound sockets list.
231  */
rose_insert_socket(struct sock * sk)232 static void rose_insert_socket(struct sock *sk)
233 {
234 
235 	spin_lock_bh(&rose_list_lock);
236 	sk_add_node(sk, &rose_list);
237 	spin_unlock_bh(&rose_list_lock);
238 }
239 
240 /*
241  *	Find a socket that wants to accept the Call Request we just
242  *	received.
243  */
rose_find_listener(rose_address * addr,ax25_address * call)244 static struct sock *rose_find_listener(rose_address *addr, ax25_address *call)
245 {
246 	struct sock *s;
247 
248 	spin_lock_bh(&rose_list_lock);
249 	sk_for_each(s, &rose_list) {
250 		struct rose_sock *rose = rose_sk(s);
251 
252 		if (!rosecmp(&rose->source_addr, addr) &&
253 		    !ax25cmp(&rose->source_call, call) &&
254 		    !rose->source_ndigis && s->sk_state == TCP_LISTEN)
255 			goto found;
256 	}
257 
258 	sk_for_each(s, &rose_list) {
259 		struct rose_sock *rose = rose_sk(s);
260 
261 		if (!rosecmp(&rose->source_addr, addr) &&
262 		    !ax25cmp(&rose->source_call, &null_ax25_address) &&
263 		    s->sk_state == TCP_LISTEN)
264 			goto found;
265 	}
266 	s = NULL;
267 found:
268 	spin_unlock_bh(&rose_list_lock);
269 	return s;
270 }
271 
272 /*
273  *	Find a connected ROSE socket given my LCI and device.
274  */
rose_find_socket(unsigned int lci,struct rose_neigh * neigh)275 struct sock *rose_find_socket(unsigned int lci, struct rose_neigh *neigh)
276 {
277 	struct sock *s;
278 
279 	spin_lock_bh(&rose_list_lock);
280 	sk_for_each(s, &rose_list) {
281 		struct rose_sock *rose = rose_sk(s);
282 
283 		if (rose->lci == lci && rose->neighbour == neigh)
284 			goto found;
285 	}
286 	s = NULL;
287 found:
288 	spin_unlock_bh(&rose_list_lock);
289 	return s;
290 }
291 
292 /*
293  *	Find a unique LCI for a given device.
294  */
rose_new_lci(struct rose_neigh * neigh)295 unsigned int rose_new_lci(struct rose_neigh *neigh)
296 {
297 	int lci;
298 
299 	if (neigh->dce_mode) {
300 		for (lci = 1; lci <= sysctl_rose_maximum_vcs; lci++)
301 			if (rose_find_socket(lci, neigh) == NULL && rose_route_free_lci(lci, neigh) == NULL)
302 				return lci;
303 	} else {
304 		for (lci = sysctl_rose_maximum_vcs; lci > 0; lci--)
305 			if (rose_find_socket(lci, neigh) == NULL && rose_route_free_lci(lci, neigh) == NULL)
306 				return lci;
307 	}
308 
309 	return 0;
310 }
311 
312 /*
313  *	Deferred destroy.
314  */
315 void rose_destroy_socket(struct sock *);
316 
317 /*
318  *	Handler for deferred kills.
319  */
rose_destroy_timer(struct timer_list * t)320 static void rose_destroy_timer(struct timer_list *t)
321 {
322 	struct sock *sk = from_timer(sk, t, sk_timer);
323 
324 	rose_destroy_socket(sk);
325 }
326 
327 /*
328  *	This is called from user mode and the timers. Thus it protects itself
329  *	against interrupt users but doesn't worry about being called during
330  *	work.  Once it is removed from the queue no interrupt or bottom half
331  *	will touch it and we are (fairly 8-) ) safe.
332  */
rose_destroy_socket(struct sock * sk)333 void rose_destroy_socket(struct sock *sk)
334 {
335 	struct sk_buff *skb;
336 
337 	rose_remove_socket(sk);
338 	rose_stop_heartbeat(sk);
339 	rose_stop_idletimer(sk);
340 	rose_stop_timer(sk);
341 
342 	rose_clear_queues(sk);		/* Flush the queues */
343 
344 	while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
345 		if (skb->sk != sk) {	/* A pending connection */
346 			/* Queue the unaccepted socket for death */
347 			sock_set_flag(skb->sk, SOCK_DEAD);
348 			rose_start_heartbeat(skb->sk);
349 			rose_sk(skb->sk)->state = ROSE_STATE_0;
350 		}
351 
352 		kfree_skb(skb);
353 	}
354 
355 	if (sk_has_allocations(sk)) {
356 		/* Defer: outstanding buffers */
357 		timer_setup(&sk->sk_timer, rose_destroy_timer, 0);
358 		sk->sk_timer.expires  = jiffies + 10 * HZ;
359 		add_timer(&sk->sk_timer);
360 	} else
361 		sock_put(sk);
362 }
363 
364 /*
365  *	Handling for system calls applied via the various interfaces to a
366  *	ROSE socket object.
367  */
368 
rose_setsockopt(struct socket * sock,int level,int optname,sockptr_t optval,unsigned int optlen)369 static int rose_setsockopt(struct socket *sock, int level, int optname,
370 		sockptr_t optval, unsigned int optlen)
371 {
372 	struct sock *sk = sock->sk;
373 	struct rose_sock *rose = rose_sk(sk);
374 	int opt;
375 
376 	if (level != SOL_ROSE)
377 		return -ENOPROTOOPT;
378 
379 	if (optlen < sizeof(int))
380 		return -EINVAL;
381 
382 	if (copy_from_sockptr(&opt, optval, sizeof(int)))
383 		return -EFAULT;
384 
385 	switch (optname) {
386 	case ROSE_DEFER:
387 		rose->defer = opt ? 1 : 0;
388 		return 0;
389 
390 	case ROSE_T1:
391 		if (opt < 1)
392 			return -EINVAL;
393 		rose->t1 = opt * HZ;
394 		return 0;
395 
396 	case ROSE_T2:
397 		if (opt < 1)
398 			return -EINVAL;
399 		rose->t2 = opt * HZ;
400 		return 0;
401 
402 	case ROSE_T3:
403 		if (opt < 1)
404 			return -EINVAL;
405 		rose->t3 = opt * HZ;
406 		return 0;
407 
408 	case ROSE_HOLDBACK:
409 		if (opt < 1)
410 			return -EINVAL;
411 		rose->hb = opt * HZ;
412 		return 0;
413 
414 	case ROSE_IDLE:
415 		if (opt < 0)
416 			return -EINVAL;
417 		rose->idle = opt * 60 * HZ;
418 		return 0;
419 
420 	case ROSE_QBITINCL:
421 		rose->qbitincl = opt ? 1 : 0;
422 		return 0;
423 
424 	default:
425 		return -ENOPROTOOPT;
426 	}
427 }
428 
rose_getsockopt(struct socket * sock,int level,int optname,char __user * optval,int __user * optlen)429 static int rose_getsockopt(struct socket *sock, int level, int optname,
430 	char __user *optval, int __user *optlen)
431 {
432 	struct sock *sk = sock->sk;
433 	struct rose_sock *rose = rose_sk(sk);
434 	int val = 0;
435 	int len;
436 
437 	if (level != SOL_ROSE)
438 		return -ENOPROTOOPT;
439 
440 	if (get_user(len, optlen))
441 		return -EFAULT;
442 
443 	if (len < 0)
444 		return -EINVAL;
445 
446 	switch (optname) {
447 	case ROSE_DEFER:
448 		val = rose->defer;
449 		break;
450 
451 	case ROSE_T1:
452 		val = rose->t1 / HZ;
453 		break;
454 
455 	case ROSE_T2:
456 		val = rose->t2 / HZ;
457 		break;
458 
459 	case ROSE_T3:
460 		val = rose->t3 / HZ;
461 		break;
462 
463 	case ROSE_HOLDBACK:
464 		val = rose->hb / HZ;
465 		break;
466 
467 	case ROSE_IDLE:
468 		val = rose->idle / (60 * HZ);
469 		break;
470 
471 	case ROSE_QBITINCL:
472 		val = rose->qbitincl;
473 		break;
474 
475 	default:
476 		return -ENOPROTOOPT;
477 	}
478 
479 	len = min_t(unsigned int, len, sizeof(int));
480 
481 	if (put_user(len, optlen))
482 		return -EFAULT;
483 
484 	return copy_to_user(optval, &val, len) ? -EFAULT : 0;
485 }
486 
rose_listen(struct socket * sock,int backlog)487 static int rose_listen(struct socket *sock, int backlog)
488 {
489 	struct sock *sk = sock->sk;
490 
491 	if (sk->sk_state != TCP_LISTEN) {
492 		struct rose_sock *rose = rose_sk(sk);
493 
494 		rose->dest_ndigis = 0;
495 		memset(&rose->dest_addr, 0, ROSE_ADDR_LEN);
496 		memset(&rose->dest_call, 0, AX25_ADDR_LEN);
497 		memset(rose->dest_digis, 0, AX25_ADDR_LEN * ROSE_MAX_DIGIS);
498 		sk->sk_max_ack_backlog = backlog;
499 		sk->sk_state           = TCP_LISTEN;
500 		return 0;
501 	}
502 
503 	return -EOPNOTSUPP;
504 }
505 
506 static struct proto rose_proto = {
507 	.name	  = "ROSE",
508 	.owner	  = THIS_MODULE,
509 	.obj_size = sizeof(struct rose_sock),
510 };
511 
rose_create(struct net * net,struct socket * sock,int protocol,int kern)512 static int rose_create(struct net *net, struct socket *sock, int protocol,
513 		       int kern)
514 {
515 	struct sock *sk;
516 	struct rose_sock *rose;
517 
518 	if (!net_eq(net, &init_net))
519 		return -EAFNOSUPPORT;
520 
521 	if (sock->type != SOCK_SEQPACKET || protocol != 0)
522 		return -ESOCKTNOSUPPORT;
523 
524 	sk = sk_alloc(net, PF_ROSE, GFP_ATOMIC, &rose_proto, kern);
525 	if (sk == NULL)
526 		return -ENOMEM;
527 
528 	rose = rose_sk(sk);
529 
530 	sock_init_data(sock, sk);
531 
532 	skb_queue_head_init(&rose->ack_queue);
533 #ifdef M_BIT
534 	skb_queue_head_init(&rose->frag_queue);
535 	rose->fraglen    = 0;
536 #endif
537 
538 	sock->ops    = &rose_proto_ops;
539 	sk->sk_protocol = protocol;
540 
541 	timer_setup(&rose->timer, NULL, 0);
542 	timer_setup(&rose->idletimer, NULL, 0);
543 
544 	rose->t1   = msecs_to_jiffies(sysctl_rose_call_request_timeout);
545 	rose->t2   = msecs_to_jiffies(sysctl_rose_reset_request_timeout);
546 	rose->t3   = msecs_to_jiffies(sysctl_rose_clear_request_timeout);
547 	rose->hb   = msecs_to_jiffies(sysctl_rose_ack_hold_back_timeout);
548 	rose->idle = msecs_to_jiffies(sysctl_rose_no_activity_timeout);
549 
550 	rose->state = ROSE_STATE_0;
551 
552 	return 0;
553 }
554 
rose_make_new(struct sock * osk)555 static struct sock *rose_make_new(struct sock *osk)
556 {
557 	struct sock *sk;
558 	struct rose_sock *rose, *orose;
559 
560 	if (osk->sk_type != SOCK_SEQPACKET)
561 		return NULL;
562 
563 	sk = sk_alloc(sock_net(osk), PF_ROSE, GFP_ATOMIC, &rose_proto, 0);
564 	if (sk == NULL)
565 		return NULL;
566 
567 	rose = rose_sk(sk);
568 
569 	sock_init_data(NULL, sk);
570 
571 	skb_queue_head_init(&rose->ack_queue);
572 #ifdef M_BIT
573 	skb_queue_head_init(&rose->frag_queue);
574 	rose->fraglen  = 0;
575 #endif
576 
577 	sk->sk_type     = osk->sk_type;
578 	sk->sk_priority = osk->sk_priority;
579 	sk->sk_protocol = osk->sk_protocol;
580 	sk->sk_rcvbuf   = osk->sk_rcvbuf;
581 	sk->sk_sndbuf   = osk->sk_sndbuf;
582 	sk->sk_state    = TCP_ESTABLISHED;
583 	sock_copy_flags(sk, osk);
584 
585 	timer_setup(&rose->timer, NULL, 0);
586 	timer_setup(&rose->idletimer, NULL, 0);
587 
588 	orose		= rose_sk(osk);
589 	rose->t1	= orose->t1;
590 	rose->t2	= orose->t2;
591 	rose->t3	= orose->t3;
592 	rose->hb	= orose->hb;
593 	rose->idle	= orose->idle;
594 	rose->defer	= orose->defer;
595 	rose->device	= orose->device;
596 	if (rose->device)
597 		netdev_hold(rose->device, &rose->dev_tracker, GFP_ATOMIC);
598 	rose->qbitincl	= orose->qbitincl;
599 
600 	return sk;
601 }
602 
rose_release(struct socket * sock)603 static int rose_release(struct socket *sock)
604 {
605 	struct sock *sk = sock->sk;
606 	struct rose_sock *rose;
607 
608 	if (sk == NULL) return 0;
609 
610 	sock_hold(sk);
611 	sock_orphan(sk);
612 	lock_sock(sk);
613 	rose = rose_sk(sk);
614 
615 	switch (rose->state) {
616 	case ROSE_STATE_0:
617 		release_sock(sk);
618 		rose_disconnect(sk, 0, -1, -1);
619 		lock_sock(sk);
620 		rose_destroy_socket(sk);
621 		break;
622 
623 	case ROSE_STATE_2:
624 		rose->neighbour->use--;
625 		release_sock(sk);
626 		rose_disconnect(sk, 0, -1, -1);
627 		lock_sock(sk);
628 		rose_destroy_socket(sk);
629 		break;
630 
631 	case ROSE_STATE_1:
632 	case ROSE_STATE_3:
633 	case ROSE_STATE_4:
634 	case ROSE_STATE_5:
635 		rose_clear_queues(sk);
636 		rose_stop_idletimer(sk);
637 		rose_write_internal(sk, ROSE_CLEAR_REQUEST);
638 		rose_start_t3timer(sk);
639 		rose->state  = ROSE_STATE_2;
640 		sk->sk_state    = TCP_CLOSE;
641 		sk->sk_shutdown |= SEND_SHUTDOWN;
642 		sk->sk_state_change(sk);
643 		sock_set_flag(sk, SOCK_DEAD);
644 		sock_set_flag(sk, SOCK_DESTROY);
645 		break;
646 
647 	default:
648 		break;
649 	}
650 
651 	netdev_put(rose->device, &rose->dev_tracker);
652 	sock->sk = NULL;
653 	release_sock(sk);
654 	sock_put(sk);
655 
656 	return 0;
657 }
658 
rose_bind(struct socket * sock,struct sockaddr * uaddr,int addr_len)659 static int rose_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
660 {
661 	struct sock *sk = sock->sk;
662 	struct rose_sock *rose = rose_sk(sk);
663 	struct sockaddr_rose *addr = (struct sockaddr_rose *)uaddr;
664 	struct net_device *dev;
665 	ax25_address *source;
666 	ax25_uid_assoc *user;
667 	int n;
668 
669 	if (!sock_flag(sk, SOCK_ZAPPED))
670 		return -EINVAL;
671 
672 	if (addr_len != sizeof(struct sockaddr_rose) && addr_len != sizeof(struct full_sockaddr_rose))
673 		return -EINVAL;
674 
675 	if (addr->srose_family != AF_ROSE)
676 		return -EINVAL;
677 
678 	if (addr_len == sizeof(struct sockaddr_rose) && addr->srose_ndigis > 1)
679 		return -EINVAL;
680 
681 	if ((unsigned int) addr->srose_ndigis > ROSE_MAX_DIGIS)
682 		return -EINVAL;
683 
684 	if ((dev = rose_dev_get(&addr->srose_addr)) == NULL)
685 		return -EADDRNOTAVAIL;
686 
687 	source = &addr->srose_call;
688 
689 	user = ax25_findbyuid(current_euid());
690 	if (user) {
691 		rose->source_call = user->call;
692 		ax25_uid_put(user);
693 	} else {
694 		if (ax25_uid_policy && !capable(CAP_NET_BIND_SERVICE)) {
695 			dev_put(dev);
696 			return -EACCES;
697 		}
698 		rose->source_call   = *source;
699 	}
700 
701 	rose->source_addr   = addr->srose_addr;
702 	rose->device        = dev;
703 	netdev_tracker_alloc(rose->device, &rose->dev_tracker, GFP_KERNEL);
704 	rose->source_ndigis = addr->srose_ndigis;
705 
706 	if (addr_len == sizeof(struct full_sockaddr_rose)) {
707 		struct full_sockaddr_rose *full_addr = (struct full_sockaddr_rose *)uaddr;
708 		for (n = 0 ; n < addr->srose_ndigis ; n++)
709 			rose->source_digis[n] = full_addr->srose_digis[n];
710 	} else {
711 		if (rose->source_ndigis == 1) {
712 			rose->source_digis[0] = addr->srose_digi;
713 		}
714 	}
715 
716 	rose_insert_socket(sk);
717 
718 	sock_reset_flag(sk, SOCK_ZAPPED);
719 
720 	return 0;
721 }
722 
rose_connect(struct socket * sock,struct sockaddr * uaddr,int addr_len,int flags)723 static int rose_connect(struct socket *sock, struct sockaddr *uaddr, int addr_len, int flags)
724 {
725 	struct sock *sk = sock->sk;
726 	struct rose_sock *rose = rose_sk(sk);
727 	struct sockaddr_rose *addr = (struct sockaddr_rose *)uaddr;
728 	unsigned char cause, diagnostic;
729 	ax25_uid_assoc *user;
730 	int n, err = 0;
731 
732 	if (addr_len != sizeof(struct sockaddr_rose) && addr_len != sizeof(struct full_sockaddr_rose))
733 		return -EINVAL;
734 
735 	if (addr->srose_family != AF_ROSE)
736 		return -EINVAL;
737 
738 	if (addr_len == sizeof(struct sockaddr_rose) && addr->srose_ndigis > 1)
739 		return -EINVAL;
740 
741 	if ((unsigned int) addr->srose_ndigis > ROSE_MAX_DIGIS)
742 		return -EINVAL;
743 
744 	/* Source + Destination digis should not exceed ROSE_MAX_DIGIS */
745 	if ((rose->source_ndigis + addr->srose_ndigis) > ROSE_MAX_DIGIS)
746 		return -EINVAL;
747 
748 	lock_sock(sk);
749 
750 	if (sk->sk_state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
751 		/* Connect completed during a ERESTARTSYS event */
752 		sock->state = SS_CONNECTED;
753 		goto out_release;
754 	}
755 
756 	if (sk->sk_state == TCP_CLOSE && sock->state == SS_CONNECTING) {
757 		sock->state = SS_UNCONNECTED;
758 		err = -ECONNREFUSED;
759 		goto out_release;
760 	}
761 
762 	if (sk->sk_state == TCP_ESTABLISHED) {
763 		/* No reconnect on a seqpacket socket */
764 		err = -EISCONN;
765 		goto out_release;
766 	}
767 
768 	sk->sk_state   = TCP_CLOSE;
769 	sock->state = SS_UNCONNECTED;
770 
771 	rose->neighbour = rose_get_neigh(&addr->srose_addr, &cause,
772 					 &diagnostic, 0);
773 	if (!rose->neighbour) {
774 		err = -ENETUNREACH;
775 		goto out_release;
776 	}
777 
778 	rose->lci = rose_new_lci(rose->neighbour);
779 	if (!rose->lci) {
780 		err = -ENETUNREACH;
781 		goto out_release;
782 	}
783 
784 	if (sock_flag(sk, SOCK_ZAPPED)) {	/* Must bind first - autobinding in this may or may not work */
785 		struct net_device *dev;
786 
787 		sock_reset_flag(sk, SOCK_ZAPPED);
788 
789 		dev = rose_dev_first();
790 		if (!dev) {
791 			err = -ENETUNREACH;
792 			goto out_release;
793 		}
794 
795 		user = ax25_findbyuid(current_euid());
796 		if (!user) {
797 			err = -EINVAL;
798 			dev_put(dev);
799 			goto out_release;
800 		}
801 
802 		memcpy(&rose->source_addr, dev->dev_addr, ROSE_ADDR_LEN);
803 		rose->source_call = user->call;
804 		rose->device      = dev;
805 		netdev_tracker_alloc(rose->device, &rose->dev_tracker,
806 				     GFP_KERNEL);
807 		ax25_uid_put(user);
808 
809 		rose_insert_socket(sk);		/* Finish the bind */
810 	}
811 	rose->dest_addr   = addr->srose_addr;
812 	rose->dest_call   = addr->srose_call;
813 	rose->rand        = ((long)rose & 0xFFFF) + rose->lci;
814 	rose->dest_ndigis = addr->srose_ndigis;
815 
816 	if (addr_len == sizeof(struct full_sockaddr_rose)) {
817 		struct full_sockaddr_rose *full_addr = (struct full_sockaddr_rose *)uaddr;
818 		for (n = 0 ; n < addr->srose_ndigis ; n++)
819 			rose->dest_digis[n] = full_addr->srose_digis[n];
820 	} else {
821 		if (rose->dest_ndigis == 1) {
822 			rose->dest_digis[0] = addr->srose_digi;
823 		}
824 	}
825 
826 	/* Move to connecting socket, start sending Connect Requests */
827 	sock->state   = SS_CONNECTING;
828 	sk->sk_state     = TCP_SYN_SENT;
829 
830 	rose->state = ROSE_STATE_1;
831 
832 	rose->neighbour->use++;
833 
834 	rose_write_internal(sk, ROSE_CALL_REQUEST);
835 	rose_start_heartbeat(sk);
836 	rose_start_t1timer(sk);
837 
838 	/* Now the loop */
839 	if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
840 		err = -EINPROGRESS;
841 		goto out_release;
842 	}
843 
844 	/*
845 	 * A Connect Ack with Choke or timeout or failed routing will go to
846 	 * closed.
847 	 */
848 	if (sk->sk_state == TCP_SYN_SENT) {
849 		DEFINE_WAIT(wait);
850 
851 		for (;;) {
852 			prepare_to_wait(sk_sleep(sk), &wait,
853 					TASK_INTERRUPTIBLE);
854 			if (sk->sk_state != TCP_SYN_SENT)
855 				break;
856 			if (!signal_pending(current)) {
857 				release_sock(sk);
858 				schedule();
859 				lock_sock(sk);
860 				continue;
861 			}
862 			err = -ERESTARTSYS;
863 			break;
864 		}
865 		finish_wait(sk_sleep(sk), &wait);
866 
867 		if (err)
868 			goto out_release;
869 	}
870 
871 	if (sk->sk_state != TCP_ESTABLISHED) {
872 		sock->state = SS_UNCONNECTED;
873 		err = sock_error(sk);	/* Always set at this point */
874 		goto out_release;
875 	}
876 
877 	sock->state = SS_CONNECTED;
878 
879 out_release:
880 	release_sock(sk);
881 
882 	return err;
883 }
884 
rose_accept(struct socket * sock,struct socket * newsock,int flags,bool kern)885 static int rose_accept(struct socket *sock, struct socket *newsock, int flags,
886 		       bool kern)
887 {
888 	struct sk_buff *skb;
889 	struct sock *newsk;
890 	DEFINE_WAIT(wait);
891 	struct sock *sk;
892 	int err = 0;
893 
894 	if ((sk = sock->sk) == NULL)
895 		return -EINVAL;
896 
897 	lock_sock(sk);
898 	if (sk->sk_type != SOCK_SEQPACKET) {
899 		err = -EOPNOTSUPP;
900 		goto out_release;
901 	}
902 
903 	if (sk->sk_state != TCP_LISTEN) {
904 		err = -EINVAL;
905 		goto out_release;
906 	}
907 
908 	/*
909 	 *	The write queue this time is holding sockets ready to use
910 	 *	hooked into the SABM we saved
911 	 */
912 	for (;;) {
913 		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
914 
915 		skb = skb_dequeue(&sk->sk_receive_queue);
916 		if (skb)
917 			break;
918 
919 		if (flags & O_NONBLOCK) {
920 			err = -EWOULDBLOCK;
921 			break;
922 		}
923 		if (!signal_pending(current)) {
924 			release_sock(sk);
925 			schedule();
926 			lock_sock(sk);
927 			continue;
928 		}
929 		err = -ERESTARTSYS;
930 		break;
931 	}
932 	finish_wait(sk_sleep(sk), &wait);
933 	if (err)
934 		goto out_release;
935 
936 	newsk = skb->sk;
937 	sock_graft(newsk, newsock);
938 
939 	/* Now attach up the new socket */
940 	skb->sk = NULL;
941 	kfree_skb(skb);
942 	sk_acceptq_removed(sk);
943 
944 out_release:
945 	release_sock(sk);
946 
947 	return err;
948 }
949 
rose_getname(struct socket * sock,struct sockaddr * uaddr,int peer)950 static int rose_getname(struct socket *sock, struct sockaddr *uaddr,
951 	int peer)
952 {
953 	struct full_sockaddr_rose *srose = (struct full_sockaddr_rose *)uaddr;
954 	struct sock *sk = sock->sk;
955 	struct rose_sock *rose = rose_sk(sk);
956 	int n;
957 
958 	memset(srose, 0, sizeof(*srose));
959 	if (peer != 0) {
960 		if (sk->sk_state != TCP_ESTABLISHED)
961 			return -ENOTCONN;
962 		srose->srose_family = AF_ROSE;
963 		srose->srose_addr   = rose->dest_addr;
964 		srose->srose_call   = rose->dest_call;
965 		srose->srose_ndigis = rose->dest_ndigis;
966 		for (n = 0; n < rose->dest_ndigis; n++)
967 			srose->srose_digis[n] = rose->dest_digis[n];
968 	} else {
969 		srose->srose_family = AF_ROSE;
970 		srose->srose_addr   = rose->source_addr;
971 		srose->srose_call   = rose->source_call;
972 		srose->srose_ndigis = rose->source_ndigis;
973 		for (n = 0; n < rose->source_ndigis; n++)
974 			srose->srose_digis[n] = rose->source_digis[n];
975 	}
976 
977 	return sizeof(struct full_sockaddr_rose);
978 }
979 
rose_rx_call_request(struct sk_buff * skb,struct net_device * dev,struct rose_neigh * neigh,unsigned int lci)980 int rose_rx_call_request(struct sk_buff *skb, struct net_device *dev, struct rose_neigh *neigh, unsigned int lci)
981 {
982 	struct sock *sk;
983 	struct sock *make;
984 	struct rose_sock *make_rose;
985 	struct rose_facilities_struct facilities;
986 	int n;
987 
988 	skb->sk = NULL;		/* Initially we don't know who it's for */
989 
990 	/*
991 	 *	skb->data points to the rose frame start
992 	 */
993 	memset(&facilities, 0x00, sizeof(struct rose_facilities_struct));
994 
995 	if (!rose_parse_facilities(skb->data + ROSE_CALL_REQ_FACILITIES_OFF,
996 				   skb->len - ROSE_CALL_REQ_FACILITIES_OFF,
997 				   &facilities)) {
998 		rose_transmit_clear_request(neigh, lci, ROSE_INVALID_FACILITY, 76);
999 		return 0;
1000 	}
1001 
1002 	sk = rose_find_listener(&facilities.source_addr, &facilities.source_call);
1003 
1004 	/*
1005 	 * We can't accept the Call Request.
1006 	 */
1007 	if (sk == NULL || sk_acceptq_is_full(sk) ||
1008 	    (make = rose_make_new(sk)) == NULL) {
1009 		rose_transmit_clear_request(neigh, lci, ROSE_NETWORK_CONGESTION, 120);
1010 		return 0;
1011 	}
1012 
1013 	skb->sk     = make;
1014 	make->sk_state = TCP_ESTABLISHED;
1015 	make_rose = rose_sk(make);
1016 
1017 	make_rose->lci           = lci;
1018 	make_rose->dest_addr     = facilities.dest_addr;
1019 	make_rose->dest_call     = facilities.dest_call;
1020 	make_rose->dest_ndigis   = facilities.dest_ndigis;
1021 	for (n = 0 ; n < facilities.dest_ndigis ; n++)
1022 		make_rose->dest_digis[n] = facilities.dest_digis[n];
1023 	make_rose->source_addr   = facilities.source_addr;
1024 	make_rose->source_call   = facilities.source_call;
1025 	make_rose->source_ndigis = facilities.source_ndigis;
1026 	for (n = 0 ; n < facilities.source_ndigis ; n++)
1027 		make_rose->source_digis[n] = facilities.source_digis[n];
1028 	make_rose->neighbour     = neigh;
1029 	make_rose->device        = dev;
1030 	/* Caller got a reference for us. */
1031 	netdev_tracker_alloc(make_rose->device, &make_rose->dev_tracker,
1032 			     GFP_ATOMIC);
1033 	make_rose->facilities    = facilities;
1034 
1035 	make_rose->neighbour->use++;
1036 
1037 	if (rose_sk(sk)->defer) {
1038 		make_rose->state = ROSE_STATE_5;
1039 	} else {
1040 		rose_write_internal(make, ROSE_CALL_ACCEPTED);
1041 		make_rose->state = ROSE_STATE_3;
1042 		rose_start_idletimer(make);
1043 	}
1044 
1045 	make_rose->condition = 0x00;
1046 	make_rose->vs        = 0;
1047 	make_rose->va        = 0;
1048 	make_rose->vr        = 0;
1049 	make_rose->vl        = 0;
1050 	sk_acceptq_added(sk);
1051 
1052 	rose_insert_socket(make);
1053 
1054 	skb_queue_head(&sk->sk_receive_queue, skb);
1055 
1056 	rose_start_heartbeat(make);
1057 
1058 	if (!sock_flag(sk, SOCK_DEAD))
1059 		sk->sk_data_ready(sk);
1060 
1061 	return 1;
1062 }
1063 
rose_sendmsg(struct socket * sock,struct msghdr * msg,size_t len)1064 static int rose_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
1065 {
1066 	struct sock *sk = sock->sk;
1067 	struct rose_sock *rose = rose_sk(sk);
1068 	DECLARE_SOCKADDR(struct sockaddr_rose *, usrose, msg->msg_name);
1069 	int err;
1070 	struct full_sockaddr_rose srose;
1071 	struct sk_buff *skb;
1072 	unsigned char *asmptr;
1073 	int n, size, qbit = 0;
1074 
1075 	if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1076 		return -EINVAL;
1077 
1078 	if (sock_flag(sk, SOCK_ZAPPED))
1079 		return -EADDRNOTAVAIL;
1080 
1081 	if (sk->sk_shutdown & SEND_SHUTDOWN) {
1082 		send_sig(SIGPIPE, current, 0);
1083 		return -EPIPE;
1084 	}
1085 
1086 	if (rose->neighbour == NULL || rose->device == NULL)
1087 		return -ENETUNREACH;
1088 
1089 	if (usrose != NULL) {
1090 		if (msg->msg_namelen != sizeof(struct sockaddr_rose) && msg->msg_namelen != sizeof(struct full_sockaddr_rose))
1091 			return -EINVAL;
1092 		memset(&srose, 0, sizeof(struct full_sockaddr_rose));
1093 		memcpy(&srose, usrose, msg->msg_namelen);
1094 		if (rosecmp(&rose->dest_addr, &srose.srose_addr) != 0 ||
1095 		    ax25cmp(&rose->dest_call, &srose.srose_call) != 0)
1096 			return -EISCONN;
1097 		if (srose.srose_ndigis != rose->dest_ndigis)
1098 			return -EISCONN;
1099 		if (srose.srose_ndigis == rose->dest_ndigis) {
1100 			for (n = 0 ; n < srose.srose_ndigis ; n++)
1101 				if (ax25cmp(&rose->dest_digis[n],
1102 					    &srose.srose_digis[n]))
1103 					return -EISCONN;
1104 		}
1105 		if (srose.srose_family != AF_ROSE)
1106 			return -EINVAL;
1107 	} else {
1108 		if (sk->sk_state != TCP_ESTABLISHED)
1109 			return -ENOTCONN;
1110 
1111 		srose.srose_family = AF_ROSE;
1112 		srose.srose_addr   = rose->dest_addr;
1113 		srose.srose_call   = rose->dest_call;
1114 		srose.srose_ndigis = rose->dest_ndigis;
1115 		for (n = 0 ; n < rose->dest_ndigis ; n++)
1116 			srose.srose_digis[n] = rose->dest_digis[n];
1117 	}
1118 
1119 	/* Build a packet */
1120 	/* Sanity check the packet size */
1121 	if (len > 65535)
1122 		return -EMSGSIZE;
1123 
1124 	size = len + AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + ROSE_MIN_LEN;
1125 
1126 	if ((skb = sock_alloc_send_skb(sk, size, msg->msg_flags & MSG_DONTWAIT, &err)) == NULL)
1127 		return err;
1128 
1129 	skb_reserve(skb, AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + ROSE_MIN_LEN);
1130 
1131 	/*
1132 	 *	Put the data on the end
1133 	 */
1134 
1135 	skb_reset_transport_header(skb);
1136 	skb_put(skb, len);
1137 
1138 	err = memcpy_from_msg(skb_transport_header(skb), msg, len);
1139 	if (err) {
1140 		kfree_skb(skb);
1141 		return err;
1142 	}
1143 
1144 	/*
1145 	 *	If the Q BIT Include socket option is in force, the first
1146 	 *	byte of the user data is the logical value of the Q Bit.
1147 	 */
1148 	if (rose->qbitincl) {
1149 		qbit = skb->data[0];
1150 		skb_pull(skb, 1);
1151 	}
1152 
1153 	/*
1154 	 *	Push down the ROSE header
1155 	 */
1156 	asmptr = skb_push(skb, ROSE_MIN_LEN);
1157 
1158 	/* Build a ROSE Network header */
1159 	asmptr[0] = ((rose->lci >> 8) & 0x0F) | ROSE_GFI;
1160 	asmptr[1] = (rose->lci >> 0) & 0xFF;
1161 	asmptr[2] = ROSE_DATA;
1162 
1163 	if (qbit)
1164 		asmptr[0] |= ROSE_Q_BIT;
1165 
1166 	if (sk->sk_state != TCP_ESTABLISHED) {
1167 		kfree_skb(skb);
1168 		return -ENOTCONN;
1169 	}
1170 
1171 #ifdef M_BIT
1172 #define ROSE_PACLEN (256-ROSE_MIN_LEN)
1173 	if (skb->len - ROSE_MIN_LEN > ROSE_PACLEN) {
1174 		unsigned char header[ROSE_MIN_LEN];
1175 		struct sk_buff *skbn;
1176 		int frontlen;
1177 		int lg;
1178 
1179 		/* Save a copy of the Header */
1180 		skb_copy_from_linear_data(skb, header, ROSE_MIN_LEN);
1181 		skb_pull(skb, ROSE_MIN_LEN);
1182 
1183 		frontlen = skb_headroom(skb);
1184 
1185 		while (skb->len > 0) {
1186 			if ((skbn = sock_alloc_send_skb(sk, frontlen + ROSE_PACLEN, 0, &err)) == NULL) {
1187 				kfree_skb(skb);
1188 				return err;
1189 			}
1190 
1191 			skbn->sk   = sk;
1192 			skbn->free = 1;
1193 			skbn->arp  = 1;
1194 
1195 			skb_reserve(skbn, frontlen);
1196 
1197 			lg = (ROSE_PACLEN > skb->len) ? skb->len : ROSE_PACLEN;
1198 
1199 			/* Copy the user data */
1200 			skb_copy_from_linear_data(skb, skb_put(skbn, lg), lg);
1201 			skb_pull(skb, lg);
1202 
1203 			/* Duplicate the Header */
1204 			skb_push(skbn, ROSE_MIN_LEN);
1205 			skb_copy_to_linear_data(skbn, header, ROSE_MIN_LEN);
1206 
1207 			if (skb->len > 0)
1208 				skbn->data[2] |= M_BIT;
1209 
1210 			skb_queue_tail(&sk->sk_write_queue, skbn); /* Throw it on the queue */
1211 		}
1212 
1213 		skb->free = 1;
1214 		kfree_skb(skb);
1215 	} else {
1216 		skb_queue_tail(&sk->sk_write_queue, skb);		/* Throw it on the queue */
1217 	}
1218 #else
1219 	skb_queue_tail(&sk->sk_write_queue, skb);	/* Shove it onto the queue */
1220 #endif
1221 
1222 	rose_kick(sk);
1223 
1224 	return len;
1225 }
1226 
1227 
rose_recvmsg(struct socket * sock,struct msghdr * msg,size_t size,int flags)1228 static int rose_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1229 			int flags)
1230 {
1231 	struct sock *sk = sock->sk;
1232 	struct rose_sock *rose = rose_sk(sk);
1233 	size_t copied;
1234 	unsigned char *asmptr;
1235 	struct sk_buff *skb;
1236 	int n, er, qbit;
1237 
1238 	/*
1239 	 * This works for seqpacket too. The receiver has ordered the queue for
1240 	 * us! We do one quick check first though
1241 	 */
1242 	if (sk->sk_state != TCP_ESTABLISHED)
1243 		return -ENOTCONN;
1244 
1245 	/* Now we can treat all alike */
1246 	skb = skb_recv_datagram(sk, flags, &er);
1247 	if (!skb)
1248 		return er;
1249 
1250 	qbit = (skb->data[0] & ROSE_Q_BIT) == ROSE_Q_BIT;
1251 
1252 	skb_pull(skb, ROSE_MIN_LEN);
1253 
1254 	if (rose->qbitincl) {
1255 		asmptr  = skb_push(skb, 1);
1256 		*asmptr = qbit;
1257 	}
1258 
1259 	skb_reset_transport_header(skb);
1260 	copied     = skb->len;
1261 
1262 	if (copied > size) {
1263 		copied = size;
1264 		msg->msg_flags |= MSG_TRUNC;
1265 	}
1266 
1267 	skb_copy_datagram_msg(skb, 0, msg, copied);
1268 
1269 	if (msg->msg_name) {
1270 		struct sockaddr_rose *srose;
1271 		DECLARE_SOCKADDR(struct full_sockaddr_rose *, full_srose,
1272 				 msg->msg_name);
1273 
1274 		memset(msg->msg_name, 0, sizeof(struct full_sockaddr_rose));
1275 		srose = msg->msg_name;
1276 		srose->srose_family = AF_ROSE;
1277 		srose->srose_addr   = rose->dest_addr;
1278 		srose->srose_call   = rose->dest_call;
1279 		srose->srose_ndigis = rose->dest_ndigis;
1280 		for (n = 0 ; n < rose->dest_ndigis ; n++)
1281 			full_srose->srose_digis[n] = rose->dest_digis[n];
1282 		msg->msg_namelen = sizeof(struct full_sockaddr_rose);
1283 	}
1284 
1285 	skb_free_datagram(sk, skb);
1286 
1287 	return copied;
1288 }
1289 
1290 
rose_ioctl(struct socket * sock,unsigned int cmd,unsigned long arg)1291 static int rose_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1292 {
1293 	struct sock *sk = sock->sk;
1294 	struct rose_sock *rose = rose_sk(sk);
1295 	void __user *argp = (void __user *)arg;
1296 
1297 	switch (cmd) {
1298 	case TIOCOUTQ: {
1299 		long amount;
1300 
1301 		amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1302 		if (amount < 0)
1303 			amount = 0;
1304 		return put_user(amount, (unsigned int __user *) argp);
1305 	}
1306 
1307 	case TIOCINQ: {
1308 		struct sk_buff *skb;
1309 		long amount = 0L;
1310 		/* These two are safe on a single CPU system as only user tasks fiddle here */
1311 		if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1312 			amount = skb->len;
1313 		return put_user(amount, (unsigned int __user *) argp);
1314 	}
1315 
1316 	case SIOCGIFADDR:
1317 	case SIOCSIFADDR:
1318 	case SIOCGIFDSTADDR:
1319 	case SIOCSIFDSTADDR:
1320 	case SIOCGIFBRDADDR:
1321 	case SIOCSIFBRDADDR:
1322 	case SIOCGIFNETMASK:
1323 	case SIOCSIFNETMASK:
1324 	case SIOCGIFMETRIC:
1325 	case SIOCSIFMETRIC:
1326 		return -EINVAL;
1327 
1328 	case SIOCADDRT:
1329 	case SIOCDELRT:
1330 	case SIOCRSCLRRT:
1331 		if (!capable(CAP_NET_ADMIN))
1332 			return -EPERM;
1333 		return rose_rt_ioctl(cmd, argp);
1334 
1335 	case SIOCRSGCAUSE: {
1336 		struct rose_cause_struct rose_cause;
1337 		rose_cause.cause      = rose->cause;
1338 		rose_cause.diagnostic = rose->diagnostic;
1339 		return copy_to_user(argp, &rose_cause, sizeof(struct rose_cause_struct)) ? -EFAULT : 0;
1340 	}
1341 
1342 	case SIOCRSSCAUSE: {
1343 		struct rose_cause_struct rose_cause;
1344 		if (copy_from_user(&rose_cause, argp, sizeof(struct rose_cause_struct)))
1345 			return -EFAULT;
1346 		rose->cause      = rose_cause.cause;
1347 		rose->diagnostic = rose_cause.diagnostic;
1348 		return 0;
1349 	}
1350 
1351 	case SIOCRSSL2CALL:
1352 		if (!capable(CAP_NET_ADMIN)) return -EPERM;
1353 		if (ax25cmp(&rose_callsign, &null_ax25_address) != 0)
1354 			ax25_listen_release(&rose_callsign, NULL);
1355 		if (copy_from_user(&rose_callsign, argp, sizeof(ax25_address)))
1356 			return -EFAULT;
1357 		if (ax25cmp(&rose_callsign, &null_ax25_address) != 0)
1358 			return ax25_listen_register(&rose_callsign, NULL);
1359 
1360 		return 0;
1361 
1362 	case SIOCRSGL2CALL:
1363 		return copy_to_user(argp, &rose_callsign, sizeof(ax25_address)) ? -EFAULT : 0;
1364 
1365 	case SIOCRSACCEPT:
1366 		if (rose->state == ROSE_STATE_5) {
1367 			rose_write_internal(sk, ROSE_CALL_ACCEPTED);
1368 			rose_start_idletimer(sk);
1369 			rose->condition = 0x00;
1370 			rose->vs        = 0;
1371 			rose->va        = 0;
1372 			rose->vr        = 0;
1373 			rose->vl        = 0;
1374 			rose->state     = ROSE_STATE_3;
1375 		}
1376 		return 0;
1377 
1378 	default:
1379 		return -ENOIOCTLCMD;
1380 	}
1381 
1382 	return 0;
1383 }
1384 
1385 #ifdef CONFIG_PROC_FS
rose_info_start(struct seq_file * seq,loff_t * pos)1386 static void *rose_info_start(struct seq_file *seq, loff_t *pos)
1387 	__acquires(rose_list_lock)
1388 {
1389 	spin_lock_bh(&rose_list_lock);
1390 	return seq_hlist_start_head(&rose_list, *pos);
1391 }
1392 
rose_info_next(struct seq_file * seq,void * v,loff_t * pos)1393 static void *rose_info_next(struct seq_file *seq, void *v, loff_t *pos)
1394 {
1395 	return seq_hlist_next(v, &rose_list, pos);
1396 }
1397 
rose_info_stop(struct seq_file * seq,void * v)1398 static void rose_info_stop(struct seq_file *seq, void *v)
1399 	__releases(rose_list_lock)
1400 {
1401 	spin_unlock_bh(&rose_list_lock);
1402 }
1403 
rose_info_show(struct seq_file * seq,void * v)1404 static int rose_info_show(struct seq_file *seq, void *v)
1405 {
1406 	char buf[11], rsbuf[11];
1407 
1408 	if (v == SEQ_START_TOKEN)
1409 		seq_puts(seq,
1410 			 "dest_addr  dest_call src_addr   src_call  dev   lci neigh st vs vr va   t  t1  t2  t3  hb    idle Snd-Q Rcv-Q inode\n");
1411 
1412 	else {
1413 		struct sock *s = sk_entry(v);
1414 		struct rose_sock *rose = rose_sk(s);
1415 		const char *devname, *callsign;
1416 		const struct net_device *dev = rose->device;
1417 
1418 		if (!dev)
1419 			devname = "???";
1420 		else
1421 			devname = dev->name;
1422 
1423 		seq_printf(seq, "%-10s %-9s ",
1424 			   rose2asc(rsbuf, &rose->dest_addr),
1425 			   ax2asc(buf, &rose->dest_call));
1426 
1427 		if (ax25cmp(&rose->source_call, &null_ax25_address) == 0)
1428 			callsign = "??????-?";
1429 		else
1430 			callsign = ax2asc(buf, &rose->source_call);
1431 
1432 		seq_printf(seq,
1433 			   "%-10s %-9s %-5s %3.3X %05d  %d  %d  %d  %d %3lu %3lu %3lu %3lu %3lu %3lu/%03lu %5d %5d %ld\n",
1434 			rose2asc(rsbuf, &rose->source_addr),
1435 			callsign,
1436 			devname,
1437 			rose->lci & 0x0FFF,
1438 			(rose->neighbour) ? rose->neighbour->number : 0,
1439 			rose->state,
1440 			rose->vs,
1441 			rose->vr,
1442 			rose->va,
1443 			ax25_display_timer(&rose->timer) / HZ,
1444 			rose->t1 / HZ,
1445 			rose->t2 / HZ,
1446 			rose->t3 / HZ,
1447 			rose->hb / HZ,
1448 			ax25_display_timer(&rose->idletimer) / (60 * HZ),
1449 			rose->idle / (60 * HZ),
1450 			sk_wmem_alloc_get(s),
1451 			sk_rmem_alloc_get(s),
1452 			s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : 0L);
1453 	}
1454 
1455 	return 0;
1456 }
1457 
1458 static const struct seq_operations rose_info_seqops = {
1459 	.start = rose_info_start,
1460 	.next = rose_info_next,
1461 	.stop = rose_info_stop,
1462 	.show = rose_info_show,
1463 };
1464 #endif	/* CONFIG_PROC_FS */
1465 
1466 static const struct net_proto_family rose_family_ops = {
1467 	.family		=	PF_ROSE,
1468 	.create		=	rose_create,
1469 	.owner		=	THIS_MODULE,
1470 };
1471 
1472 static const struct proto_ops rose_proto_ops = {
1473 	.family		=	PF_ROSE,
1474 	.owner		=	THIS_MODULE,
1475 	.release	=	rose_release,
1476 	.bind		=	rose_bind,
1477 	.connect	=	rose_connect,
1478 	.socketpair	=	sock_no_socketpair,
1479 	.accept		=	rose_accept,
1480 	.getname	=	rose_getname,
1481 	.poll		=	datagram_poll,
1482 	.ioctl		=	rose_ioctl,
1483 	.gettstamp	=	sock_gettstamp,
1484 	.listen		=	rose_listen,
1485 	.shutdown	=	sock_no_shutdown,
1486 	.setsockopt	=	rose_setsockopt,
1487 	.getsockopt	=	rose_getsockopt,
1488 	.sendmsg	=	rose_sendmsg,
1489 	.recvmsg	=	rose_recvmsg,
1490 	.mmap		=	sock_no_mmap,
1491 	.sendpage	=	sock_no_sendpage,
1492 };
1493 
1494 static struct notifier_block rose_dev_notifier = {
1495 	.notifier_call	=	rose_device_event,
1496 };
1497 
1498 static struct net_device **dev_rose;
1499 
1500 static struct ax25_protocol rose_pid = {
1501 	.pid	= AX25_P_ROSE,
1502 	.func	= rose_route_frame
1503 };
1504 
1505 static struct ax25_linkfail rose_linkfail_notifier = {
1506 	.func	= rose_link_failed
1507 };
1508 
rose_proto_init(void)1509 static int __init rose_proto_init(void)
1510 {
1511 	int i;
1512 	int rc;
1513 
1514 	if (rose_ndevs > 0x7FFFFFFF/sizeof(struct net_device *)) {
1515 		printk(KERN_ERR "ROSE: rose_proto_init - rose_ndevs parameter too large\n");
1516 		rc = -EINVAL;
1517 		goto out;
1518 	}
1519 
1520 	rc = proto_register(&rose_proto, 0);
1521 	if (rc != 0)
1522 		goto out;
1523 
1524 	rose_callsign = null_ax25_address;
1525 
1526 	dev_rose = kcalloc(rose_ndevs, sizeof(struct net_device *),
1527 			   GFP_KERNEL);
1528 	if (dev_rose == NULL) {
1529 		printk(KERN_ERR "ROSE: rose_proto_init - unable to allocate device structure\n");
1530 		rc = -ENOMEM;
1531 		goto out_proto_unregister;
1532 	}
1533 
1534 	for (i = 0; i < rose_ndevs; i++) {
1535 		struct net_device *dev;
1536 		char name[IFNAMSIZ];
1537 
1538 		sprintf(name, "rose%d", i);
1539 		dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, rose_setup);
1540 		if (!dev) {
1541 			printk(KERN_ERR "ROSE: rose_proto_init - unable to allocate memory\n");
1542 			rc = -ENOMEM;
1543 			goto fail;
1544 		}
1545 		rc = register_netdev(dev);
1546 		if (rc) {
1547 			printk(KERN_ERR "ROSE: netdevice registration failed\n");
1548 			free_netdev(dev);
1549 			goto fail;
1550 		}
1551 		rose_set_lockdep_key(dev);
1552 		dev_rose[i] = dev;
1553 	}
1554 
1555 	sock_register(&rose_family_ops);
1556 	register_netdevice_notifier(&rose_dev_notifier);
1557 
1558 	ax25_register_pid(&rose_pid);
1559 	ax25_linkfail_register(&rose_linkfail_notifier);
1560 
1561 #ifdef CONFIG_SYSCTL
1562 	rose_register_sysctl();
1563 #endif
1564 	rose_loopback_init();
1565 
1566 	rose_add_loopback_neigh();
1567 
1568 	proc_create_seq("rose", 0444, init_net.proc_net, &rose_info_seqops);
1569 	proc_create_seq("rose_neigh", 0444, init_net.proc_net,
1570 		    &rose_neigh_seqops);
1571 	proc_create_seq("rose_nodes", 0444, init_net.proc_net,
1572 		    &rose_node_seqops);
1573 	proc_create_seq("rose_routes", 0444, init_net.proc_net,
1574 		    &rose_route_seqops);
1575 out:
1576 	return rc;
1577 fail:
1578 	while (--i >= 0) {
1579 		unregister_netdev(dev_rose[i]);
1580 		free_netdev(dev_rose[i]);
1581 	}
1582 	kfree(dev_rose);
1583 out_proto_unregister:
1584 	proto_unregister(&rose_proto);
1585 	goto out;
1586 }
1587 module_init(rose_proto_init);
1588 
1589 module_param(rose_ndevs, int, 0);
1590 MODULE_PARM_DESC(rose_ndevs, "number of ROSE devices");
1591 
1592 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
1593 MODULE_DESCRIPTION("The amateur radio ROSE network layer protocol");
1594 MODULE_LICENSE("GPL");
1595 MODULE_ALIAS_NETPROTO(PF_ROSE);
1596 
rose_exit(void)1597 static void __exit rose_exit(void)
1598 {
1599 	int i;
1600 
1601 	remove_proc_entry("rose", init_net.proc_net);
1602 	remove_proc_entry("rose_neigh", init_net.proc_net);
1603 	remove_proc_entry("rose_nodes", init_net.proc_net);
1604 	remove_proc_entry("rose_routes", init_net.proc_net);
1605 	rose_loopback_clear();
1606 
1607 	rose_rt_free();
1608 
1609 	ax25_protocol_release(AX25_P_ROSE);
1610 	ax25_linkfail_release(&rose_linkfail_notifier);
1611 
1612 	if (ax25cmp(&rose_callsign, &null_ax25_address) != 0)
1613 		ax25_listen_release(&rose_callsign, NULL);
1614 
1615 #ifdef CONFIG_SYSCTL
1616 	rose_unregister_sysctl();
1617 #endif
1618 	unregister_netdevice_notifier(&rose_dev_notifier);
1619 
1620 	sock_unregister(PF_ROSE);
1621 
1622 	for (i = 0; i < rose_ndevs; i++) {
1623 		struct net_device *dev = dev_rose[i];
1624 
1625 		if (dev) {
1626 			unregister_netdev(dev);
1627 			free_netdev(dev);
1628 		}
1629 	}
1630 
1631 	kfree(dev_rose);
1632 	proto_unregister(&rose_proto);
1633 }
1634 
1635 module_exit(rose_exit);
1636