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