xref: /openbmc/linux/net/x25/af_x25.c (revision 95777591)
1 /*
2  *	X.25 Packet Layer release 002
3  *
4  *	This is ALPHA test software. This code may break your machine,
5  *	randomly fail to work with new releases, misbehave and/or generally
6  *	screw up. It might even work.
7  *
8  *	This code REQUIRES 2.1.15 or higher
9  *
10  *	This module:
11  *		This module is free software; you can redistribute it and/or
12  *		modify it under the terms of the GNU General Public License
13  *		as published by the Free Software Foundation; either version
14  *		2 of the License, or (at your option) any later version.
15  *
16  *	History
17  *	X.25 001	Jonathan Naylor	Started coding.
18  *	X.25 002	Jonathan Naylor	Centralised disconnect handling.
19  *					New timer architecture.
20  *	2000-03-11	Henner Eisen	MSG_EOR handling more POSIX compliant.
21  *	2000-03-22	Daniela Squassoni Allowed disabling/enabling of
22  *					  facilities negotiation and increased
23  *					  the throughput upper limit.
24  *	2000-08-27	Arnaldo C. Melo s/suser/capable/ + micro cleanups
25  *	2000-09-04	Henner Eisen	Set sock->state in x25_accept().
26  *					Fixed x25_output() related skb leakage.
27  *	2000-10-02	Henner Eisen	Made x25_kick() single threaded per socket.
28  *	2000-10-27	Henner Eisen    MSG_DONTWAIT for fragment allocation.
29  *	2000-11-14	Henner Eisen    Closing datalink from NETDEV_GOING_DOWN
30  *	2002-10-06	Arnaldo C. Melo Get rid of cli/sti, move proc stuff to
31  *					x25_proc.c, using seq_file
32  *	2005-04-02	Shaun Pereira	Selective sub address matching
33  *					with call user data
34  *	2005-04-15	Shaun Pereira	Fast select with no restriction on
35  *					response
36  */
37 
38 #define pr_fmt(fmt) "X25: " fmt
39 
40 #include <linux/module.h>
41 #include <linux/capability.h>
42 #include <linux/errno.h>
43 #include <linux/kernel.h>
44 #include <linux/sched/signal.h>
45 #include <linux/timer.h>
46 #include <linux/string.h>
47 #include <linux/net.h>
48 #include <linux/netdevice.h>
49 #include <linux/if_arp.h>
50 #include <linux/skbuff.h>
51 #include <linux/slab.h>
52 #include <net/sock.h>
53 #include <net/tcp_states.h>
54 #include <linux/uaccess.h>
55 #include <linux/fcntl.h>
56 #include <linux/termios.h>	/* For TIOCINQ/OUTQ */
57 #include <linux/notifier.h>
58 #include <linux/init.h>
59 #include <linux/compat.h>
60 #include <linux/ctype.h>
61 
62 #include <net/x25.h>
63 #include <net/compat.h>
64 
65 int sysctl_x25_restart_request_timeout = X25_DEFAULT_T20;
66 int sysctl_x25_call_request_timeout    = X25_DEFAULT_T21;
67 int sysctl_x25_reset_request_timeout   = X25_DEFAULT_T22;
68 int sysctl_x25_clear_request_timeout   = X25_DEFAULT_T23;
69 int sysctl_x25_ack_holdback_timeout    = X25_DEFAULT_T2;
70 int sysctl_x25_forward                 = 0;
71 
72 HLIST_HEAD(x25_list);
73 DEFINE_RWLOCK(x25_list_lock);
74 
75 static const struct proto_ops x25_proto_ops;
76 
77 static const struct x25_address null_x25_address = {"               "};
78 
79 #ifdef CONFIG_COMPAT
80 struct compat_x25_subscrip_struct {
81 	char device[200-sizeof(compat_ulong_t)];
82 	compat_ulong_t global_facil_mask;
83 	compat_uint_t extended;
84 };
85 #endif
86 
87 
88 int x25_parse_address_block(struct sk_buff *skb,
89 		struct x25_address *called_addr,
90 		struct x25_address *calling_addr)
91 {
92 	unsigned char len;
93 	int needed;
94 	int rc;
95 
96 	if (!pskb_may_pull(skb, 1)) {
97 		/* packet has no address block */
98 		rc = 0;
99 		goto empty;
100 	}
101 
102 	len = *skb->data;
103 	needed = 1 + ((len >> 4) + (len & 0x0f) + 1) / 2;
104 
105 	if (!pskb_may_pull(skb, needed)) {
106 		/* packet is too short to hold the addresses it claims
107 		   to hold */
108 		rc = -1;
109 		goto empty;
110 	}
111 
112 	return x25_addr_ntoa(skb->data, called_addr, calling_addr);
113 
114 empty:
115 	*called_addr->x25_addr = 0;
116 	*calling_addr->x25_addr = 0;
117 
118 	return rc;
119 }
120 
121 
122 int x25_addr_ntoa(unsigned char *p, struct x25_address *called_addr,
123 		  struct x25_address *calling_addr)
124 {
125 	unsigned int called_len, calling_len;
126 	char *called, *calling;
127 	unsigned int i;
128 
129 	called_len  = (*p >> 0) & 0x0F;
130 	calling_len = (*p >> 4) & 0x0F;
131 
132 	called  = called_addr->x25_addr;
133 	calling = calling_addr->x25_addr;
134 	p++;
135 
136 	for (i = 0; i < (called_len + calling_len); i++) {
137 		if (i < called_len) {
138 			if (i % 2 != 0) {
139 				*called++ = ((*p >> 0) & 0x0F) + '0';
140 				p++;
141 			} else {
142 				*called++ = ((*p >> 4) & 0x0F) + '0';
143 			}
144 		} else {
145 			if (i % 2 != 0) {
146 				*calling++ = ((*p >> 0) & 0x0F) + '0';
147 				p++;
148 			} else {
149 				*calling++ = ((*p >> 4) & 0x0F) + '0';
150 			}
151 		}
152 	}
153 
154 	*called = *calling = '\0';
155 
156 	return 1 + (called_len + calling_len + 1) / 2;
157 }
158 
159 int x25_addr_aton(unsigned char *p, struct x25_address *called_addr,
160 		  struct x25_address *calling_addr)
161 {
162 	unsigned int called_len, calling_len;
163 	char *called, *calling;
164 	int i;
165 
166 	called  = called_addr->x25_addr;
167 	calling = calling_addr->x25_addr;
168 
169 	called_len  = strlen(called);
170 	calling_len = strlen(calling);
171 
172 	*p++ = (calling_len << 4) | (called_len << 0);
173 
174 	for (i = 0; i < (called_len + calling_len); i++) {
175 		if (i < called_len) {
176 			if (i % 2 != 0) {
177 				*p |= (*called++ - '0') << 0;
178 				p++;
179 			} else {
180 				*p = 0x00;
181 				*p |= (*called++ - '0') << 4;
182 			}
183 		} else {
184 			if (i % 2 != 0) {
185 				*p |= (*calling++ - '0') << 0;
186 				p++;
187 			} else {
188 				*p = 0x00;
189 				*p |= (*calling++ - '0') << 4;
190 			}
191 		}
192 	}
193 
194 	return 1 + (called_len + calling_len + 1) / 2;
195 }
196 
197 /*
198  *	Socket removal during an interrupt is now safe.
199  */
200 static void x25_remove_socket(struct sock *sk)
201 {
202 	write_lock_bh(&x25_list_lock);
203 	sk_del_node_init(sk);
204 	write_unlock_bh(&x25_list_lock);
205 }
206 
207 /*
208  *	Kill all bound sockets on a dropped device.
209  */
210 static void x25_kill_by_device(struct net_device *dev)
211 {
212 	struct sock *s;
213 
214 	write_lock_bh(&x25_list_lock);
215 
216 	sk_for_each(s, &x25_list)
217 		if (x25_sk(s)->neighbour && x25_sk(s)->neighbour->dev == dev)
218 			x25_disconnect(s, ENETUNREACH, 0, 0);
219 
220 	write_unlock_bh(&x25_list_lock);
221 }
222 
223 /*
224  *	Handle device status changes.
225  */
226 static int x25_device_event(struct notifier_block *this, unsigned long event,
227 			    void *ptr)
228 {
229 	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
230 	struct x25_neigh *nb;
231 
232 	if (!net_eq(dev_net(dev), &init_net))
233 		return NOTIFY_DONE;
234 
235 	if (dev->type == ARPHRD_X25
236 #if IS_ENABLED(CONFIG_LLC)
237 	 || dev->type == ARPHRD_ETHER
238 #endif
239 	 ) {
240 		switch (event) {
241 		case NETDEV_UP:
242 			x25_link_device_up(dev);
243 			break;
244 		case NETDEV_GOING_DOWN:
245 			nb = x25_get_neigh(dev);
246 			if (nb) {
247 				x25_terminate_link(nb);
248 				x25_neigh_put(nb);
249 			}
250 			break;
251 		case NETDEV_DOWN:
252 			x25_kill_by_device(dev);
253 			x25_route_device_down(dev);
254 			x25_link_device_down(dev);
255 			break;
256 		}
257 	}
258 
259 	return NOTIFY_DONE;
260 }
261 
262 /*
263  *	Add a socket to the bound sockets list.
264  */
265 static void x25_insert_socket(struct sock *sk)
266 {
267 	write_lock_bh(&x25_list_lock);
268 	sk_add_node(sk, &x25_list);
269 	write_unlock_bh(&x25_list_lock);
270 }
271 
272 /*
273  *	Find a socket that wants to accept the Call Request we just
274  *	received. Check the full list for an address/cud match.
275  *	If no cuds match return the next_best thing, an address match.
276  *	Note: if a listening socket has cud set it must only get calls
277  *	with matching cud.
278  */
279 static struct sock *x25_find_listener(struct x25_address *addr,
280 					struct sk_buff *skb)
281 {
282 	struct sock *s;
283 	struct sock *next_best;
284 
285 	read_lock_bh(&x25_list_lock);
286 	next_best = NULL;
287 
288 	sk_for_each(s, &x25_list)
289 		if ((!strcmp(addr->x25_addr,
290 			x25_sk(s)->source_addr.x25_addr) ||
291 				!strcmp(x25_sk(s)->source_addr.x25_addr,
292 					null_x25_address.x25_addr)) &&
293 					s->sk_state == TCP_LISTEN) {
294 			/*
295 			 * Found a listening socket, now check the incoming
296 			 * call user data vs this sockets call user data
297 			 */
298 			if (x25_sk(s)->cudmatchlength > 0 &&
299 				skb->len >= x25_sk(s)->cudmatchlength) {
300 				if((memcmp(x25_sk(s)->calluserdata.cuddata,
301 					skb->data,
302 					x25_sk(s)->cudmatchlength)) == 0) {
303 					sock_hold(s);
304 					goto found;
305 				 }
306 			} else
307 				next_best = s;
308 		}
309 	if (next_best) {
310 		s = next_best;
311 		sock_hold(s);
312 		goto found;
313 	}
314 	s = NULL;
315 found:
316 	read_unlock_bh(&x25_list_lock);
317 	return s;
318 }
319 
320 /*
321  *	Find a connected X.25 socket given my LCI and neighbour.
322  */
323 static struct sock *__x25_find_socket(unsigned int lci, struct x25_neigh *nb)
324 {
325 	struct sock *s;
326 
327 	sk_for_each(s, &x25_list)
328 		if (x25_sk(s)->lci == lci && x25_sk(s)->neighbour == nb) {
329 			sock_hold(s);
330 			goto found;
331 		}
332 	s = NULL;
333 found:
334 	return s;
335 }
336 
337 struct sock *x25_find_socket(unsigned int lci, struct x25_neigh *nb)
338 {
339 	struct sock *s;
340 
341 	read_lock_bh(&x25_list_lock);
342 	s = __x25_find_socket(lci, nb);
343 	read_unlock_bh(&x25_list_lock);
344 	return s;
345 }
346 
347 /*
348  *	Find a unique LCI for a given device.
349  */
350 static unsigned int x25_new_lci(struct x25_neigh *nb)
351 {
352 	unsigned int lci = 1;
353 	struct sock *sk;
354 
355 	while ((sk = x25_find_socket(lci, nb)) != NULL) {
356 		sock_put(sk);
357 		if (++lci == 4096) {
358 			lci = 0;
359 			break;
360 		}
361 		cond_resched();
362 	}
363 
364 	return lci;
365 }
366 
367 /*
368  *	Deferred destroy.
369  */
370 static void __x25_destroy_socket(struct sock *);
371 
372 /*
373  *	handler for deferred kills.
374  */
375 static void x25_destroy_timer(struct timer_list *t)
376 {
377 	struct sock *sk = from_timer(sk, t, sk_timer);
378 
379 	x25_destroy_socket_from_timer(sk);
380 }
381 
382 /*
383  *	This is called from user mode and the timers. Thus it protects itself
384  *	against interrupt users but doesn't worry about being called during
385  *	work. Once it is removed from the queue no interrupt or bottom half
386  *	will touch it and we are (fairly 8-) ) safe.
387  *	Not static as it's used by the timer
388  */
389 static void __x25_destroy_socket(struct sock *sk)
390 {
391 	struct sk_buff *skb;
392 
393 	x25_stop_heartbeat(sk);
394 	x25_stop_timer(sk);
395 
396 	x25_remove_socket(sk);
397 	x25_clear_queues(sk);		/* Flush the queues */
398 
399 	while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
400 		if (skb->sk != sk) {		/* A pending connection */
401 			/*
402 			 * Queue the unaccepted socket for death
403 			 */
404 			skb->sk->sk_state = TCP_LISTEN;
405 			sock_set_flag(skb->sk, SOCK_DEAD);
406 			x25_start_heartbeat(skb->sk);
407 			x25_sk(skb->sk)->state = X25_STATE_0;
408 		}
409 
410 		kfree_skb(skb);
411 	}
412 
413 	if (sk_has_allocations(sk)) {
414 		/* Defer: outstanding buffers */
415 		sk->sk_timer.expires  = jiffies + 10 * HZ;
416 		sk->sk_timer.function = x25_destroy_timer;
417 		add_timer(&sk->sk_timer);
418 	} else {
419 		/* drop last reference so sock_put will free */
420 		__sock_put(sk);
421 	}
422 }
423 
424 void x25_destroy_socket_from_timer(struct sock *sk)
425 {
426 	sock_hold(sk);
427 	bh_lock_sock(sk);
428 	__x25_destroy_socket(sk);
429 	bh_unlock_sock(sk);
430 	sock_put(sk);
431 }
432 
433 /*
434  *	Handling for system calls applied via the various interfaces to a
435  *	X.25 socket object.
436  */
437 
438 static int x25_setsockopt(struct socket *sock, int level, int optname,
439 			  char __user *optval, unsigned int optlen)
440 {
441 	int opt;
442 	struct sock *sk = sock->sk;
443 	int rc = -ENOPROTOOPT;
444 
445 	if (level != SOL_X25 || optname != X25_QBITINCL)
446 		goto out;
447 
448 	rc = -EINVAL;
449 	if (optlen < sizeof(int))
450 		goto out;
451 
452 	rc = -EFAULT;
453 	if (get_user(opt, (int __user *)optval))
454 		goto out;
455 
456 	if (opt)
457 		set_bit(X25_Q_BIT_FLAG, &x25_sk(sk)->flags);
458 	else
459 		clear_bit(X25_Q_BIT_FLAG, &x25_sk(sk)->flags);
460 	rc = 0;
461 out:
462 	return rc;
463 }
464 
465 static int x25_getsockopt(struct socket *sock, int level, int optname,
466 			  char __user *optval, int __user *optlen)
467 {
468 	struct sock *sk = sock->sk;
469 	int val, len, rc = -ENOPROTOOPT;
470 
471 	if (level != SOL_X25 || optname != X25_QBITINCL)
472 		goto out;
473 
474 	rc = -EFAULT;
475 	if (get_user(len, optlen))
476 		goto out;
477 
478 	len = min_t(unsigned int, len, sizeof(int));
479 
480 	rc = -EINVAL;
481 	if (len < 0)
482 		goto out;
483 
484 	rc = -EFAULT;
485 	if (put_user(len, optlen))
486 		goto out;
487 
488 	val = test_bit(X25_Q_BIT_FLAG, &x25_sk(sk)->flags);
489 	rc = copy_to_user(optval, &val, len) ? -EFAULT : 0;
490 out:
491 	return rc;
492 }
493 
494 static int x25_listen(struct socket *sock, int backlog)
495 {
496 	struct sock *sk = sock->sk;
497 	int rc = -EOPNOTSUPP;
498 
499 	lock_sock(sk);
500 	if (sk->sk_state != TCP_LISTEN) {
501 		memset(&x25_sk(sk)->dest_addr, 0, X25_ADDR_LEN);
502 		sk->sk_max_ack_backlog = backlog;
503 		sk->sk_state           = TCP_LISTEN;
504 		rc = 0;
505 	}
506 	release_sock(sk);
507 
508 	return rc;
509 }
510 
511 static struct proto x25_proto = {
512 	.name	  = "X25",
513 	.owner	  = THIS_MODULE,
514 	.obj_size = sizeof(struct x25_sock),
515 };
516 
517 static struct sock *x25_alloc_socket(struct net *net, int kern)
518 {
519 	struct x25_sock *x25;
520 	struct sock *sk = sk_alloc(net, AF_X25, GFP_ATOMIC, &x25_proto, kern);
521 
522 	if (!sk)
523 		goto out;
524 
525 	sock_init_data(NULL, sk);
526 
527 	x25 = x25_sk(sk);
528 	skb_queue_head_init(&x25->ack_queue);
529 	skb_queue_head_init(&x25->fragment_queue);
530 	skb_queue_head_init(&x25->interrupt_in_queue);
531 	skb_queue_head_init(&x25->interrupt_out_queue);
532 out:
533 	return sk;
534 }
535 
536 static int x25_create(struct net *net, struct socket *sock, int protocol,
537 		      int kern)
538 {
539 	struct sock *sk;
540 	struct x25_sock *x25;
541 	int rc = -EAFNOSUPPORT;
542 
543 	if (!net_eq(net, &init_net))
544 		goto out;
545 
546 	rc = -ESOCKTNOSUPPORT;
547 	if (sock->type != SOCK_SEQPACKET)
548 		goto out;
549 
550 	rc = -EINVAL;
551 	if (protocol)
552 		goto out;
553 
554 	rc = -ENOBUFS;
555 	if ((sk = x25_alloc_socket(net, kern)) == NULL)
556 		goto out;
557 
558 	x25 = x25_sk(sk);
559 
560 	sock_init_data(sock, sk);
561 
562 	x25_init_timers(sk);
563 
564 	sock->ops    = &x25_proto_ops;
565 	sk->sk_protocol = protocol;
566 	sk->sk_backlog_rcv = x25_backlog_rcv;
567 
568 	x25->t21   = sysctl_x25_call_request_timeout;
569 	x25->t22   = sysctl_x25_reset_request_timeout;
570 	x25->t23   = sysctl_x25_clear_request_timeout;
571 	x25->t2    = sysctl_x25_ack_holdback_timeout;
572 	x25->state = X25_STATE_0;
573 	x25->cudmatchlength = 0;
574 	set_bit(X25_ACCPT_APPRV_FLAG, &x25->flags);	/* normally no cud  */
575 							/* on call accept   */
576 
577 	x25->facilities.winsize_in  = X25_DEFAULT_WINDOW_SIZE;
578 	x25->facilities.winsize_out = X25_DEFAULT_WINDOW_SIZE;
579 	x25->facilities.pacsize_in  = X25_DEFAULT_PACKET_SIZE;
580 	x25->facilities.pacsize_out = X25_DEFAULT_PACKET_SIZE;
581 	x25->facilities.throughput  = 0;	/* by default don't negotiate
582 						   throughput */
583 	x25->facilities.reverse     = X25_DEFAULT_REVERSE;
584 	x25->dte_facilities.calling_len = 0;
585 	x25->dte_facilities.called_len = 0;
586 	memset(x25->dte_facilities.called_ae, '\0',
587 			sizeof(x25->dte_facilities.called_ae));
588 	memset(x25->dte_facilities.calling_ae, '\0',
589 			sizeof(x25->dte_facilities.calling_ae));
590 
591 	rc = 0;
592 out:
593 	return rc;
594 }
595 
596 static struct sock *x25_make_new(struct sock *osk)
597 {
598 	struct sock *sk = NULL;
599 	struct x25_sock *x25, *ox25;
600 
601 	if (osk->sk_type != SOCK_SEQPACKET)
602 		goto out;
603 
604 	if ((sk = x25_alloc_socket(sock_net(osk), 0)) == NULL)
605 		goto out;
606 
607 	x25 = x25_sk(sk);
608 
609 	sk->sk_type        = osk->sk_type;
610 	sk->sk_priority    = osk->sk_priority;
611 	sk->sk_protocol    = osk->sk_protocol;
612 	sk->sk_rcvbuf      = osk->sk_rcvbuf;
613 	sk->sk_sndbuf      = osk->sk_sndbuf;
614 	sk->sk_state       = TCP_ESTABLISHED;
615 	sk->sk_backlog_rcv = osk->sk_backlog_rcv;
616 	sock_copy_flags(sk, osk);
617 
618 	ox25 = x25_sk(osk);
619 	x25->t21        = ox25->t21;
620 	x25->t22        = ox25->t22;
621 	x25->t23        = ox25->t23;
622 	x25->t2         = ox25->t2;
623 	x25->flags	= ox25->flags;
624 	x25->facilities = ox25->facilities;
625 	x25->dte_facilities = ox25->dte_facilities;
626 	x25->cudmatchlength = ox25->cudmatchlength;
627 
628 	clear_bit(X25_INTERRUPT_FLAG, &x25->flags);
629 	x25_init_timers(sk);
630 out:
631 	return sk;
632 }
633 
634 static int x25_release(struct socket *sock)
635 {
636 	struct sock *sk = sock->sk;
637 	struct x25_sock *x25;
638 
639 	if (!sk)
640 		return 0;
641 
642 	x25 = x25_sk(sk);
643 
644 	sock_hold(sk);
645 	lock_sock(sk);
646 	switch (x25->state) {
647 
648 		case X25_STATE_0:
649 		case X25_STATE_2:
650 			x25_disconnect(sk, 0, 0, 0);
651 			__x25_destroy_socket(sk);
652 			goto out;
653 
654 		case X25_STATE_1:
655 		case X25_STATE_3:
656 		case X25_STATE_4:
657 			x25_clear_queues(sk);
658 			x25_write_internal(sk, X25_CLEAR_REQUEST);
659 			x25_start_t23timer(sk);
660 			x25->state = X25_STATE_2;
661 			sk->sk_state	= TCP_CLOSE;
662 			sk->sk_shutdown	|= SEND_SHUTDOWN;
663 			sk->sk_state_change(sk);
664 			sock_set_flag(sk, SOCK_DEAD);
665 			sock_set_flag(sk, SOCK_DESTROY);
666 			break;
667 	}
668 
669 	sock_orphan(sk);
670 out:
671 	release_sock(sk);
672 	sock_put(sk);
673 	return 0;
674 }
675 
676 static int x25_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
677 {
678 	struct sock *sk = sock->sk;
679 	struct sockaddr_x25 *addr = (struct sockaddr_x25 *)uaddr;
680 	int len, i, rc = 0;
681 
682 	if (addr_len != sizeof(struct sockaddr_x25) ||
683 	    addr->sx25_family != AF_X25) {
684 		rc = -EINVAL;
685 		goto out;
686 	}
687 
688 	/* check for the null_x25_address */
689 	if (strcmp(addr->sx25_addr.x25_addr, null_x25_address.x25_addr)) {
690 
691 		len = strlen(addr->sx25_addr.x25_addr);
692 		for (i = 0; i < len; i++) {
693 			if (!isdigit(addr->sx25_addr.x25_addr[i])) {
694 				rc = -EINVAL;
695 				goto out;
696 			}
697 		}
698 	}
699 
700 	lock_sock(sk);
701 	if (sock_flag(sk, SOCK_ZAPPED)) {
702 		x25_sk(sk)->source_addr = addr->sx25_addr;
703 		x25_insert_socket(sk);
704 		sock_reset_flag(sk, SOCK_ZAPPED);
705 	} else {
706 		rc = -EINVAL;
707 	}
708 	release_sock(sk);
709 	SOCK_DEBUG(sk, "x25_bind: socket is bound\n");
710 out:
711 	return rc;
712 }
713 
714 static int x25_wait_for_connection_establishment(struct sock *sk)
715 {
716 	DECLARE_WAITQUEUE(wait, current);
717 	int rc;
718 
719 	add_wait_queue_exclusive(sk_sleep(sk), &wait);
720 	for (;;) {
721 		__set_current_state(TASK_INTERRUPTIBLE);
722 		rc = -ERESTARTSYS;
723 		if (signal_pending(current))
724 			break;
725 		rc = sock_error(sk);
726 		if (rc) {
727 			sk->sk_socket->state = SS_UNCONNECTED;
728 			break;
729 		}
730 		rc = 0;
731 		if (sk->sk_state != TCP_ESTABLISHED) {
732 			release_sock(sk);
733 			schedule();
734 			lock_sock(sk);
735 		} else
736 			break;
737 	}
738 	__set_current_state(TASK_RUNNING);
739 	remove_wait_queue(sk_sleep(sk), &wait);
740 	return rc;
741 }
742 
743 static int x25_connect(struct socket *sock, struct sockaddr *uaddr,
744 		       int addr_len, int flags)
745 {
746 	struct sock *sk = sock->sk;
747 	struct x25_sock *x25 = x25_sk(sk);
748 	struct sockaddr_x25 *addr = (struct sockaddr_x25 *)uaddr;
749 	struct x25_route *rt;
750 	int rc = 0;
751 
752 	lock_sock(sk);
753 	if (sk->sk_state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
754 		sock->state = SS_CONNECTED;
755 		goto out; /* Connect completed during a ERESTARTSYS event */
756 	}
757 
758 	rc = -ECONNREFUSED;
759 	if (sk->sk_state == TCP_CLOSE && sock->state == SS_CONNECTING) {
760 		sock->state = SS_UNCONNECTED;
761 		goto out;
762 	}
763 
764 	rc = -EISCONN;	/* No reconnect on a seqpacket socket */
765 	if (sk->sk_state == TCP_ESTABLISHED)
766 		goto out;
767 
768 	sk->sk_state   = TCP_CLOSE;
769 	sock->state = SS_UNCONNECTED;
770 
771 	rc = -EINVAL;
772 	if (addr_len != sizeof(struct sockaddr_x25) ||
773 	    addr->sx25_family != AF_X25)
774 		goto out;
775 
776 	rc = -ENETUNREACH;
777 	rt = x25_get_route(&addr->sx25_addr);
778 	if (!rt)
779 		goto out;
780 
781 	x25->neighbour = x25_get_neigh(rt->dev);
782 	if (!x25->neighbour)
783 		goto out_put_route;
784 
785 	x25_limit_facilities(&x25->facilities, x25->neighbour);
786 
787 	x25->lci = x25_new_lci(x25->neighbour);
788 	if (!x25->lci)
789 		goto out_put_neigh;
790 
791 	rc = -EINVAL;
792 	if (sock_flag(sk, SOCK_ZAPPED)) /* Must bind first - autobinding does not work */
793 		goto out_put_neigh;
794 
795 	if (!strcmp(x25->source_addr.x25_addr, null_x25_address.x25_addr))
796 		memset(&x25->source_addr, '\0', X25_ADDR_LEN);
797 
798 	x25->dest_addr = addr->sx25_addr;
799 
800 	/* Move to connecting socket, start sending Connect Requests */
801 	sock->state   = SS_CONNECTING;
802 	sk->sk_state  = TCP_SYN_SENT;
803 
804 	x25->state = X25_STATE_1;
805 
806 	x25_write_internal(sk, X25_CALL_REQUEST);
807 
808 	x25_start_heartbeat(sk);
809 	x25_start_t21timer(sk);
810 
811 	/* Now the loop */
812 	rc = -EINPROGRESS;
813 	if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK))
814 		goto out_put_neigh;
815 
816 	rc = x25_wait_for_connection_establishment(sk);
817 	if (rc)
818 		goto out_put_neigh;
819 
820 	sock->state = SS_CONNECTED;
821 	rc = 0;
822 out_put_neigh:
823 	if (rc)
824 		x25_neigh_put(x25->neighbour);
825 out_put_route:
826 	x25_route_put(rt);
827 out:
828 	release_sock(sk);
829 	return rc;
830 }
831 
832 static int x25_wait_for_data(struct sock *sk, long timeout)
833 {
834 	DECLARE_WAITQUEUE(wait, current);
835 	int rc = 0;
836 
837 	add_wait_queue_exclusive(sk_sleep(sk), &wait);
838 	for (;;) {
839 		__set_current_state(TASK_INTERRUPTIBLE);
840 		if (sk->sk_shutdown & RCV_SHUTDOWN)
841 			break;
842 		rc = -ERESTARTSYS;
843 		if (signal_pending(current))
844 			break;
845 		rc = -EAGAIN;
846 		if (!timeout)
847 			break;
848 		rc = 0;
849 		if (skb_queue_empty(&sk->sk_receive_queue)) {
850 			release_sock(sk);
851 			timeout = schedule_timeout(timeout);
852 			lock_sock(sk);
853 		} else
854 			break;
855 	}
856 	__set_current_state(TASK_RUNNING);
857 	remove_wait_queue(sk_sleep(sk), &wait);
858 	return rc;
859 }
860 
861 static int x25_accept(struct socket *sock, struct socket *newsock, int flags,
862 		      bool kern)
863 {
864 	struct sock *sk = sock->sk;
865 	struct sock *newsk;
866 	struct sk_buff *skb;
867 	int rc = -EINVAL;
868 
869 	if (!sk)
870 		goto out;
871 
872 	rc = -EOPNOTSUPP;
873 	if (sk->sk_type != SOCK_SEQPACKET)
874 		goto out;
875 
876 	lock_sock(sk);
877 	rc = -EINVAL;
878 	if (sk->sk_state != TCP_LISTEN)
879 		goto out2;
880 
881 	rc = x25_wait_for_data(sk, sk->sk_rcvtimeo);
882 	if (rc)
883 		goto out2;
884 	skb = skb_dequeue(&sk->sk_receive_queue);
885 	rc = -EINVAL;
886 	if (!skb->sk)
887 		goto out2;
888 	newsk		 = skb->sk;
889 	sock_graft(newsk, newsock);
890 
891 	/* Now attach up the new socket */
892 	skb->sk = NULL;
893 	kfree_skb(skb);
894 	sk->sk_ack_backlog--;
895 	newsock->state = SS_CONNECTED;
896 	rc = 0;
897 out2:
898 	release_sock(sk);
899 out:
900 	return rc;
901 }
902 
903 static int x25_getname(struct socket *sock, struct sockaddr *uaddr,
904 		       int peer)
905 {
906 	struct sockaddr_x25 *sx25 = (struct sockaddr_x25 *)uaddr;
907 	struct sock *sk = sock->sk;
908 	struct x25_sock *x25 = x25_sk(sk);
909 	int rc = 0;
910 
911 	if (peer) {
912 		if (sk->sk_state != TCP_ESTABLISHED) {
913 			rc = -ENOTCONN;
914 			goto out;
915 		}
916 		sx25->sx25_addr = x25->dest_addr;
917 	} else
918 		sx25->sx25_addr = x25->source_addr;
919 
920 	sx25->sx25_family = AF_X25;
921 	rc = sizeof(*sx25);
922 
923 out:
924 	return rc;
925 }
926 
927 int x25_rx_call_request(struct sk_buff *skb, struct x25_neigh *nb,
928 			unsigned int lci)
929 {
930 	struct sock *sk;
931 	struct sock *make;
932 	struct x25_sock *makex25;
933 	struct x25_address source_addr, dest_addr;
934 	struct x25_facilities facilities;
935 	struct x25_dte_facilities dte_facilities;
936 	int len, addr_len, rc;
937 
938 	/*
939 	 *	Remove the LCI and frame type.
940 	 */
941 	skb_pull(skb, X25_STD_MIN_LEN);
942 
943 	/*
944 	 *	Extract the X.25 addresses and convert them to ASCII strings,
945 	 *	and remove them.
946 	 *
947 	 *	Address block is mandatory in call request packets
948 	 */
949 	addr_len = x25_parse_address_block(skb, &source_addr, &dest_addr);
950 	if (addr_len <= 0)
951 		goto out_clear_request;
952 	skb_pull(skb, addr_len);
953 
954 	/*
955 	 *	Get the length of the facilities, skip past them for the moment
956 	 *	get the call user data because this is needed to determine
957 	 *	the correct listener
958 	 *
959 	 *	Facilities length is mandatory in call request packets
960 	 */
961 	if (!pskb_may_pull(skb, 1))
962 		goto out_clear_request;
963 	len = skb->data[0] + 1;
964 	if (!pskb_may_pull(skb, len))
965 		goto out_clear_request;
966 	skb_pull(skb,len);
967 
968 	/*
969 	 *	Ensure that the amount of call user data is valid.
970 	 */
971 	if (skb->len > X25_MAX_CUD_LEN)
972 		goto out_clear_request;
973 
974 	/*
975 	 *	Get all the call user data so it can be used in
976 	 *	x25_find_listener and skb_copy_from_linear_data up ahead.
977 	 */
978 	if (!pskb_may_pull(skb, skb->len))
979 		goto out_clear_request;
980 
981 	/*
982 	 *	Find a listener for the particular address/cud pair.
983 	 */
984 	sk = x25_find_listener(&source_addr,skb);
985 	skb_push(skb,len);
986 
987 	if (sk != NULL && sk_acceptq_is_full(sk)) {
988 		goto out_sock_put;
989 	}
990 
991 	/*
992 	 *	We dont have any listeners for this incoming call.
993 	 *	Try forwarding it.
994 	 */
995 	if (sk == NULL) {
996 		skb_push(skb, addr_len + X25_STD_MIN_LEN);
997 		if (sysctl_x25_forward &&
998 				x25_forward_call(&dest_addr, nb, skb, lci) > 0)
999 		{
1000 			/* Call was forwarded, dont process it any more */
1001 			kfree_skb(skb);
1002 			rc = 1;
1003 			goto out;
1004 		} else {
1005 			/* No listeners, can't forward, clear the call */
1006 			goto out_clear_request;
1007 		}
1008 	}
1009 
1010 	/*
1011 	 *	Try to reach a compromise on the requested facilities.
1012 	 */
1013 	len = x25_negotiate_facilities(skb, sk, &facilities, &dte_facilities);
1014 	if (len == -1)
1015 		goto out_sock_put;
1016 
1017 	/*
1018 	 * current neighbour/link might impose additional limits
1019 	 * on certain facilties
1020 	 */
1021 
1022 	x25_limit_facilities(&facilities, nb);
1023 
1024 	/*
1025 	 *	Try to create a new socket.
1026 	 */
1027 	make = x25_make_new(sk);
1028 	if (!make)
1029 		goto out_sock_put;
1030 
1031 	/*
1032 	 *	Remove the facilities
1033 	 */
1034 	skb_pull(skb, len);
1035 
1036 	skb->sk     = make;
1037 	make->sk_state = TCP_ESTABLISHED;
1038 
1039 	makex25 = x25_sk(make);
1040 	makex25->lci           = lci;
1041 	makex25->dest_addr     = dest_addr;
1042 	makex25->source_addr   = source_addr;
1043 	makex25->neighbour     = nb;
1044 	makex25->facilities    = facilities;
1045 	makex25->dte_facilities= dte_facilities;
1046 	makex25->vc_facil_mask = x25_sk(sk)->vc_facil_mask;
1047 	/* ensure no reverse facil on accept */
1048 	makex25->vc_facil_mask &= ~X25_MASK_REVERSE;
1049 	/* ensure no calling address extension on accept */
1050 	makex25->vc_facil_mask &= ~X25_MASK_CALLING_AE;
1051 	makex25->cudmatchlength = x25_sk(sk)->cudmatchlength;
1052 
1053 	/* Normally all calls are accepted immediately */
1054 	if (test_bit(X25_ACCPT_APPRV_FLAG, &makex25->flags)) {
1055 		x25_write_internal(make, X25_CALL_ACCEPTED);
1056 		makex25->state = X25_STATE_3;
1057 	}
1058 
1059 	/*
1060 	 *	Incoming Call User Data.
1061 	 */
1062 	skb_copy_from_linear_data(skb, makex25->calluserdata.cuddata, skb->len);
1063 	makex25->calluserdata.cudlength = skb->len;
1064 
1065 	sk->sk_ack_backlog++;
1066 
1067 	x25_insert_socket(make);
1068 
1069 	skb_queue_head(&sk->sk_receive_queue, skb);
1070 
1071 	x25_start_heartbeat(make);
1072 
1073 	if (!sock_flag(sk, SOCK_DEAD))
1074 		sk->sk_data_ready(sk);
1075 	rc = 1;
1076 	sock_put(sk);
1077 out:
1078 	return rc;
1079 out_sock_put:
1080 	sock_put(sk);
1081 out_clear_request:
1082 	rc = 0;
1083 	x25_transmit_clear_request(nb, lci, 0x01);
1084 	goto out;
1085 }
1086 
1087 static int x25_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
1088 {
1089 	struct sock *sk = sock->sk;
1090 	struct x25_sock *x25 = x25_sk(sk);
1091 	DECLARE_SOCKADDR(struct sockaddr_x25 *, usx25, msg->msg_name);
1092 	struct sockaddr_x25 sx25;
1093 	struct sk_buff *skb;
1094 	unsigned char *asmptr;
1095 	int noblock = msg->msg_flags & MSG_DONTWAIT;
1096 	size_t size;
1097 	int qbit = 0, rc = -EINVAL;
1098 
1099 	lock_sock(sk);
1100 	if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_OOB|MSG_EOR|MSG_CMSG_COMPAT))
1101 		goto out;
1102 
1103 	/* we currently don't support segmented records at the user interface */
1104 	if (!(msg->msg_flags & (MSG_EOR|MSG_OOB)))
1105 		goto out;
1106 
1107 	rc = -EADDRNOTAVAIL;
1108 	if (sock_flag(sk, SOCK_ZAPPED))
1109 		goto out;
1110 
1111 	rc = -EPIPE;
1112 	if (sk->sk_shutdown & SEND_SHUTDOWN) {
1113 		send_sig(SIGPIPE, current, 0);
1114 		goto out;
1115 	}
1116 
1117 	rc = -ENETUNREACH;
1118 	if (!x25->neighbour)
1119 		goto out;
1120 
1121 	if (usx25) {
1122 		rc = -EINVAL;
1123 		if (msg->msg_namelen < sizeof(sx25))
1124 			goto out;
1125 		memcpy(&sx25, usx25, sizeof(sx25));
1126 		rc = -EISCONN;
1127 		if (strcmp(x25->dest_addr.x25_addr, sx25.sx25_addr.x25_addr))
1128 			goto out;
1129 		rc = -EINVAL;
1130 		if (sx25.sx25_family != AF_X25)
1131 			goto out;
1132 	} else {
1133 		/*
1134 		 *	FIXME 1003.1g - if the socket is like this because
1135 		 *	it has become closed (not started closed) we ought
1136 		 *	to SIGPIPE, EPIPE;
1137 		 */
1138 		rc = -ENOTCONN;
1139 		if (sk->sk_state != TCP_ESTABLISHED)
1140 			goto out;
1141 
1142 		sx25.sx25_family = AF_X25;
1143 		sx25.sx25_addr   = x25->dest_addr;
1144 	}
1145 
1146 	/* Sanity check the packet size */
1147 	if (len > 65535) {
1148 		rc = -EMSGSIZE;
1149 		goto out;
1150 	}
1151 
1152 	SOCK_DEBUG(sk, "x25_sendmsg: sendto: Addresses built.\n");
1153 
1154 	/* Build a packet */
1155 	SOCK_DEBUG(sk, "x25_sendmsg: sendto: building packet.\n");
1156 
1157 	if ((msg->msg_flags & MSG_OOB) && len > 32)
1158 		len = 32;
1159 
1160 	size = len + X25_MAX_L2_LEN + X25_EXT_MIN_LEN;
1161 
1162 	release_sock(sk);
1163 	skb = sock_alloc_send_skb(sk, size, noblock, &rc);
1164 	lock_sock(sk);
1165 	if (!skb)
1166 		goto out;
1167 	X25_SKB_CB(skb)->flags = msg->msg_flags;
1168 
1169 	skb_reserve(skb, X25_MAX_L2_LEN + X25_EXT_MIN_LEN);
1170 
1171 	/*
1172 	 *	Put the data on the end
1173 	 */
1174 	SOCK_DEBUG(sk, "x25_sendmsg: Copying user data\n");
1175 
1176 	skb_reset_transport_header(skb);
1177 	skb_put(skb, len);
1178 
1179 	rc = memcpy_from_msg(skb_transport_header(skb), msg, len);
1180 	if (rc)
1181 		goto out_kfree_skb;
1182 
1183 	/*
1184 	 *	If the Q BIT Include socket option is in force, the first
1185 	 *	byte of the user data is the logical value of the Q Bit.
1186 	 */
1187 	if (test_bit(X25_Q_BIT_FLAG, &x25->flags)) {
1188 		if (!pskb_may_pull(skb, 1))
1189 			goto out_kfree_skb;
1190 
1191 		qbit = skb->data[0];
1192 		skb_pull(skb, 1);
1193 	}
1194 
1195 	/*
1196 	 *	Push down the X.25 header
1197 	 */
1198 	SOCK_DEBUG(sk, "x25_sendmsg: Building X.25 Header.\n");
1199 
1200 	if (msg->msg_flags & MSG_OOB) {
1201 		if (x25->neighbour->extended) {
1202 			asmptr    = skb_push(skb, X25_STD_MIN_LEN);
1203 			*asmptr++ = ((x25->lci >> 8) & 0x0F) | X25_GFI_EXTSEQ;
1204 			*asmptr++ = (x25->lci >> 0) & 0xFF;
1205 			*asmptr++ = X25_INTERRUPT;
1206 		} else {
1207 			asmptr    = skb_push(skb, X25_STD_MIN_LEN);
1208 			*asmptr++ = ((x25->lci >> 8) & 0x0F) | X25_GFI_STDSEQ;
1209 			*asmptr++ = (x25->lci >> 0) & 0xFF;
1210 			*asmptr++ = X25_INTERRUPT;
1211 		}
1212 	} else {
1213 		if (x25->neighbour->extended) {
1214 			/* Build an Extended X.25 header */
1215 			asmptr    = skb_push(skb, X25_EXT_MIN_LEN);
1216 			*asmptr++ = ((x25->lci >> 8) & 0x0F) | X25_GFI_EXTSEQ;
1217 			*asmptr++ = (x25->lci >> 0) & 0xFF;
1218 			*asmptr++ = X25_DATA;
1219 			*asmptr++ = X25_DATA;
1220 		} else {
1221 			/* Build an Standard X.25 header */
1222 			asmptr    = skb_push(skb, X25_STD_MIN_LEN);
1223 			*asmptr++ = ((x25->lci >> 8) & 0x0F) | X25_GFI_STDSEQ;
1224 			*asmptr++ = (x25->lci >> 0) & 0xFF;
1225 			*asmptr++ = X25_DATA;
1226 		}
1227 
1228 		if (qbit)
1229 			skb->data[0] |= X25_Q_BIT;
1230 	}
1231 
1232 	SOCK_DEBUG(sk, "x25_sendmsg: Built header.\n");
1233 	SOCK_DEBUG(sk, "x25_sendmsg: Transmitting buffer\n");
1234 
1235 	rc = -ENOTCONN;
1236 	if (sk->sk_state != TCP_ESTABLISHED)
1237 		goto out_kfree_skb;
1238 
1239 	if (msg->msg_flags & MSG_OOB)
1240 		skb_queue_tail(&x25->interrupt_out_queue, skb);
1241 	else {
1242 		rc = x25_output(sk, skb);
1243 		len = rc;
1244 		if (rc < 0)
1245 			kfree_skb(skb);
1246 		else if (test_bit(X25_Q_BIT_FLAG, &x25->flags))
1247 			len++;
1248 	}
1249 
1250 	x25_kick(sk);
1251 	rc = len;
1252 out:
1253 	release_sock(sk);
1254 	return rc;
1255 out_kfree_skb:
1256 	kfree_skb(skb);
1257 	goto out;
1258 }
1259 
1260 
1261 static int x25_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1262 		       int flags)
1263 {
1264 	struct sock *sk = sock->sk;
1265 	struct x25_sock *x25 = x25_sk(sk);
1266 	DECLARE_SOCKADDR(struct sockaddr_x25 *, sx25, msg->msg_name);
1267 	size_t copied;
1268 	int qbit, header_len;
1269 	struct sk_buff *skb;
1270 	unsigned char *asmptr;
1271 	int rc = -ENOTCONN;
1272 
1273 	lock_sock(sk);
1274 
1275 	if (x25->neighbour == NULL)
1276 		goto out;
1277 
1278 	header_len = x25->neighbour->extended ?
1279 		X25_EXT_MIN_LEN : X25_STD_MIN_LEN;
1280 
1281 	/*
1282 	 * This works for seqpacket too. The receiver has ordered the queue for
1283 	 * us! We do one quick check first though
1284 	 */
1285 	if (sk->sk_state != TCP_ESTABLISHED)
1286 		goto out;
1287 
1288 	if (flags & MSG_OOB) {
1289 		rc = -EINVAL;
1290 		if (sock_flag(sk, SOCK_URGINLINE) ||
1291 		    !skb_peek(&x25->interrupt_in_queue))
1292 			goto out;
1293 
1294 		skb = skb_dequeue(&x25->interrupt_in_queue);
1295 
1296 		if (!pskb_may_pull(skb, X25_STD_MIN_LEN))
1297 			goto out_free_dgram;
1298 
1299 		skb_pull(skb, X25_STD_MIN_LEN);
1300 
1301 		/*
1302 		 *	No Q bit information on Interrupt data.
1303 		 */
1304 		if (test_bit(X25_Q_BIT_FLAG, &x25->flags)) {
1305 			asmptr  = skb_push(skb, 1);
1306 			*asmptr = 0x00;
1307 		}
1308 
1309 		msg->msg_flags |= MSG_OOB;
1310 	} else {
1311 		/* Now we can treat all alike */
1312 		release_sock(sk);
1313 		skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
1314 					flags & MSG_DONTWAIT, &rc);
1315 		lock_sock(sk);
1316 		if (!skb)
1317 			goto out;
1318 
1319 		if (!pskb_may_pull(skb, header_len))
1320 			goto out_free_dgram;
1321 
1322 		qbit = (skb->data[0] & X25_Q_BIT) == X25_Q_BIT;
1323 
1324 		skb_pull(skb, header_len);
1325 
1326 		if (test_bit(X25_Q_BIT_FLAG, &x25->flags)) {
1327 			asmptr  = skb_push(skb, 1);
1328 			*asmptr = qbit;
1329 		}
1330 	}
1331 
1332 	skb_reset_transport_header(skb);
1333 	copied = skb->len;
1334 
1335 	if (copied > size) {
1336 		copied = size;
1337 		msg->msg_flags |= MSG_TRUNC;
1338 	}
1339 
1340 	/* Currently, each datagram always contains a complete record */
1341 	msg->msg_flags |= MSG_EOR;
1342 
1343 	rc = skb_copy_datagram_msg(skb, 0, msg, copied);
1344 	if (rc)
1345 		goto out_free_dgram;
1346 
1347 	if (sx25) {
1348 		sx25->sx25_family = AF_X25;
1349 		sx25->sx25_addr   = x25->dest_addr;
1350 		msg->msg_namelen = sizeof(*sx25);
1351 	}
1352 
1353 	x25_check_rbuf(sk);
1354 	rc = copied;
1355 out_free_dgram:
1356 	skb_free_datagram(sk, skb);
1357 out:
1358 	release_sock(sk);
1359 	return rc;
1360 }
1361 
1362 
1363 static int x25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1364 {
1365 	struct sock *sk = sock->sk;
1366 	struct x25_sock *x25 = x25_sk(sk);
1367 	void __user *argp = (void __user *)arg;
1368 	int rc;
1369 
1370 	switch (cmd) {
1371 	case TIOCOUTQ: {
1372 		int amount;
1373 
1374 		amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1375 		if (amount < 0)
1376 			amount = 0;
1377 		rc = put_user(amount, (unsigned int __user *)argp);
1378 		break;
1379 	}
1380 
1381 	case TIOCINQ: {
1382 		struct sk_buff *skb;
1383 		int amount = 0;
1384 		/*
1385 		 * These two are safe on a single CPU system as
1386 		 * only user tasks fiddle here
1387 		 */
1388 		lock_sock(sk);
1389 		if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1390 			amount = skb->len;
1391 		release_sock(sk);
1392 		rc = put_user(amount, (unsigned int __user *)argp);
1393 		break;
1394 	}
1395 
1396 	case SIOCGSTAMP:
1397 		rc = -EINVAL;
1398 		if (sk)
1399 			rc = sock_get_timestamp(sk,
1400 						(struct timeval __user *)argp);
1401 		break;
1402 	case SIOCGSTAMPNS:
1403 		rc = -EINVAL;
1404 		if (sk)
1405 			rc = sock_get_timestampns(sk,
1406 					(struct timespec __user *)argp);
1407 		break;
1408 	case SIOCGIFADDR:
1409 	case SIOCSIFADDR:
1410 	case SIOCGIFDSTADDR:
1411 	case SIOCSIFDSTADDR:
1412 	case SIOCGIFBRDADDR:
1413 	case SIOCSIFBRDADDR:
1414 	case SIOCGIFNETMASK:
1415 	case SIOCSIFNETMASK:
1416 	case SIOCGIFMETRIC:
1417 	case SIOCSIFMETRIC:
1418 		rc = -EINVAL;
1419 		break;
1420 	case SIOCADDRT:
1421 	case SIOCDELRT:
1422 		rc = -EPERM;
1423 		if (!capable(CAP_NET_ADMIN))
1424 			break;
1425 		rc = x25_route_ioctl(cmd, argp);
1426 		break;
1427 	case SIOCX25GSUBSCRIP:
1428 		rc = x25_subscr_ioctl(cmd, argp);
1429 		break;
1430 	case SIOCX25SSUBSCRIP:
1431 		rc = -EPERM;
1432 		if (!capable(CAP_NET_ADMIN))
1433 			break;
1434 		rc = x25_subscr_ioctl(cmd, argp);
1435 		break;
1436 	case SIOCX25GFACILITIES: {
1437 		lock_sock(sk);
1438 		rc = copy_to_user(argp, &x25->facilities,
1439 				  sizeof(x25->facilities))
1440 			? -EFAULT : 0;
1441 		release_sock(sk);
1442 		break;
1443 	}
1444 
1445 	case SIOCX25SFACILITIES: {
1446 		struct x25_facilities facilities;
1447 		rc = -EFAULT;
1448 		if (copy_from_user(&facilities, argp, sizeof(facilities)))
1449 			break;
1450 		rc = -EINVAL;
1451 		lock_sock(sk);
1452 		if (sk->sk_state != TCP_LISTEN &&
1453 		    sk->sk_state != TCP_CLOSE)
1454 			goto out_fac_release;
1455 		if (facilities.pacsize_in < X25_PS16 ||
1456 		    facilities.pacsize_in > X25_PS4096)
1457 			goto out_fac_release;
1458 		if (facilities.pacsize_out < X25_PS16 ||
1459 		    facilities.pacsize_out > X25_PS4096)
1460 			goto out_fac_release;
1461 		if (facilities.winsize_in < 1 ||
1462 		    facilities.winsize_in > 127)
1463 			goto out_fac_release;
1464 		if (facilities.throughput) {
1465 			int out = facilities.throughput & 0xf0;
1466 			int in  = facilities.throughput & 0x0f;
1467 			if (!out)
1468 				facilities.throughput |=
1469 					X25_DEFAULT_THROUGHPUT << 4;
1470 			else if (out < 0x30 || out > 0xD0)
1471 				goto out_fac_release;
1472 			if (!in)
1473 				facilities.throughput |=
1474 					X25_DEFAULT_THROUGHPUT;
1475 			else if (in < 0x03 || in > 0x0D)
1476 				goto out_fac_release;
1477 		}
1478 		if (facilities.reverse &&
1479 		    (facilities.reverse & 0x81) != 0x81)
1480 			goto out_fac_release;
1481 		x25->facilities = facilities;
1482 		rc = 0;
1483 out_fac_release:
1484 		release_sock(sk);
1485 		break;
1486 	}
1487 
1488 	case SIOCX25GDTEFACILITIES: {
1489 		lock_sock(sk);
1490 		rc = copy_to_user(argp, &x25->dte_facilities,
1491 				  sizeof(x25->dte_facilities));
1492 		release_sock(sk);
1493 		if (rc)
1494 			rc = -EFAULT;
1495 		break;
1496 	}
1497 
1498 	case SIOCX25SDTEFACILITIES: {
1499 		struct x25_dte_facilities dtefacs;
1500 		rc = -EFAULT;
1501 		if (copy_from_user(&dtefacs, argp, sizeof(dtefacs)))
1502 			break;
1503 		rc = -EINVAL;
1504 		lock_sock(sk);
1505 		if (sk->sk_state != TCP_LISTEN &&
1506 		    sk->sk_state != TCP_CLOSE)
1507 			goto out_dtefac_release;
1508 		if (dtefacs.calling_len > X25_MAX_AE_LEN)
1509 			goto out_dtefac_release;
1510 		if (dtefacs.called_len > X25_MAX_AE_LEN)
1511 			goto out_dtefac_release;
1512 		x25->dte_facilities = dtefacs;
1513 		rc = 0;
1514 out_dtefac_release:
1515 		release_sock(sk);
1516 		break;
1517 	}
1518 
1519 	case SIOCX25GCALLUSERDATA: {
1520 		lock_sock(sk);
1521 		rc = copy_to_user(argp, &x25->calluserdata,
1522 				  sizeof(x25->calluserdata))
1523 			? -EFAULT : 0;
1524 		release_sock(sk);
1525 		break;
1526 	}
1527 
1528 	case SIOCX25SCALLUSERDATA: {
1529 		struct x25_calluserdata calluserdata;
1530 
1531 		rc = -EFAULT;
1532 		if (copy_from_user(&calluserdata, argp, sizeof(calluserdata)))
1533 			break;
1534 		rc = -EINVAL;
1535 		if (calluserdata.cudlength > X25_MAX_CUD_LEN)
1536 			break;
1537 		lock_sock(sk);
1538 		x25->calluserdata = calluserdata;
1539 		release_sock(sk);
1540 		rc = 0;
1541 		break;
1542 	}
1543 
1544 	case SIOCX25GCAUSEDIAG: {
1545 		lock_sock(sk);
1546 		rc = copy_to_user(argp, &x25->causediag, sizeof(x25->causediag))
1547 			? -EFAULT : 0;
1548 		release_sock(sk);
1549 		break;
1550 	}
1551 
1552 	case SIOCX25SCAUSEDIAG: {
1553 		struct x25_causediag causediag;
1554 		rc = -EFAULT;
1555 		if (copy_from_user(&causediag, argp, sizeof(causediag)))
1556 			break;
1557 		lock_sock(sk);
1558 		x25->causediag = causediag;
1559 		release_sock(sk);
1560 		rc = 0;
1561 		break;
1562 
1563 	}
1564 
1565 	case SIOCX25SCUDMATCHLEN: {
1566 		struct x25_subaddr sub_addr;
1567 		rc = -EINVAL;
1568 		lock_sock(sk);
1569 		if(sk->sk_state != TCP_CLOSE)
1570 			goto out_cud_release;
1571 		rc = -EFAULT;
1572 		if (copy_from_user(&sub_addr, argp,
1573 				   sizeof(sub_addr)))
1574 			goto out_cud_release;
1575 		rc = -EINVAL;
1576 		if (sub_addr.cudmatchlength > X25_MAX_CUD_LEN)
1577 			goto out_cud_release;
1578 		x25->cudmatchlength = sub_addr.cudmatchlength;
1579 		rc = 0;
1580 out_cud_release:
1581 		release_sock(sk);
1582 		break;
1583 	}
1584 
1585 	case SIOCX25CALLACCPTAPPRV: {
1586 		rc = -EINVAL;
1587 		lock_sock(sk);
1588 		if (sk->sk_state == TCP_CLOSE) {
1589 			clear_bit(X25_ACCPT_APPRV_FLAG, &x25->flags);
1590 			rc = 0;
1591 		}
1592 		release_sock(sk);
1593 		break;
1594 	}
1595 
1596 	case SIOCX25SENDCALLACCPT:  {
1597 		rc = -EINVAL;
1598 		lock_sock(sk);
1599 		if (sk->sk_state != TCP_ESTABLISHED)
1600 			goto out_sendcallaccpt_release;
1601 		/* must call accptapprv above */
1602 		if (test_bit(X25_ACCPT_APPRV_FLAG, &x25->flags))
1603 			goto out_sendcallaccpt_release;
1604 		x25_write_internal(sk, X25_CALL_ACCEPTED);
1605 		x25->state = X25_STATE_3;
1606 		rc = 0;
1607 out_sendcallaccpt_release:
1608 		release_sock(sk);
1609 		break;
1610 	}
1611 
1612 	default:
1613 		rc = -ENOIOCTLCMD;
1614 		break;
1615 	}
1616 
1617 	return rc;
1618 }
1619 
1620 static const struct net_proto_family x25_family_ops = {
1621 	.family =	AF_X25,
1622 	.create =	x25_create,
1623 	.owner	=	THIS_MODULE,
1624 };
1625 
1626 #ifdef CONFIG_COMPAT
1627 static int compat_x25_subscr_ioctl(unsigned int cmd,
1628 		struct compat_x25_subscrip_struct __user *x25_subscr32)
1629 {
1630 	struct compat_x25_subscrip_struct x25_subscr;
1631 	struct x25_neigh *nb;
1632 	struct net_device *dev;
1633 	int rc = -EINVAL;
1634 
1635 	rc = -EFAULT;
1636 	if (copy_from_user(&x25_subscr, x25_subscr32, sizeof(*x25_subscr32)))
1637 		goto out;
1638 
1639 	rc = -EINVAL;
1640 	dev = x25_dev_get(x25_subscr.device);
1641 	if (dev == NULL)
1642 		goto out;
1643 
1644 	nb = x25_get_neigh(dev);
1645 	if (nb == NULL)
1646 		goto out_dev_put;
1647 
1648 	dev_put(dev);
1649 
1650 	if (cmd == SIOCX25GSUBSCRIP) {
1651 		read_lock_bh(&x25_neigh_list_lock);
1652 		x25_subscr.extended = nb->extended;
1653 		x25_subscr.global_facil_mask = nb->global_facil_mask;
1654 		read_unlock_bh(&x25_neigh_list_lock);
1655 		rc = copy_to_user(x25_subscr32, &x25_subscr,
1656 				sizeof(*x25_subscr32)) ? -EFAULT : 0;
1657 	} else {
1658 		rc = -EINVAL;
1659 		if (x25_subscr.extended == 0 || x25_subscr.extended == 1) {
1660 			rc = 0;
1661 			write_lock_bh(&x25_neigh_list_lock);
1662 			nb->extended = x25_subscr.extended;
1663 			nb->global_facil_mask = x25_subscr.global_facil_mask;
1664 			write_unlock_bh(&x25_neigh_list_lock);
1665 		}
1666 	}
1667 	x25_neigh_put(nb);
1668 out:
1669 	return rc;
1670 out_dev_put:
1671 	dev_put(dev);
1672 	goto out;
1673 }
1674 
1675 static int compat_x25_ioctl(struct socket *sock, unsigned int cmd,
1676 				unsigned long arg)
1677 {
1678 	void __user *argp = compat_ptr(arg);
1679 	struct sock *sk = sock->sk;
1680 
1681 	int rc = -ENOIOCTLCMD;
1682 
1683 	switch(cmd) {
1684 	case TIOCOUTQ:
1685 	case TIOCINQ:
1686 		rc = x25_ioctl(sock, cmd, (unsigned long)argp);
1687 		break;
1688 	case SIOCGSTAMP:
1689 		rc = -EINVAL;
1690 		if (sk)
1691 			rc = compat_sock_get_timestamp(sk,
1692 					(struct timeval __user*)argp);
1693 		break;
1694 	case SIOCGSTAMPNS:
1695 		rc = -EINVAL;
1696 		if (sk)
1697 			rc = compat_sock_get_timestampns(sk,
1698 					(struct timespec __user*)argp);
1699 		break;
1700 	case SIOCGIFADDR:
1701 	case SIOCSIFADDR:
1702 	case SIOCGIFDSTADDR:
1703 	case SIOCSIFDSTADDR:
1704 	case SIOCGIFBRDADDR:
1705 	case SIOCSIFBRDADDR:
1706 	case SIOCGIFNETMASK:
1707 	case SIOCSIFNETMASK:
1708 	case SIOCGIFMETRIC:
1709 	case SIOCSIFMETRIC:
1710 		rc = -EINVAL;
1711 		break;
1712 	case SIOCADDRT:
1713 	case SIOCDELRT:
1714 		rc = -EPERM;
1715 		if (!capable(CAP_NET_ADMIN))
1716 			break;
1717 		rc = x25_route_ioctl(cmd, argp);
1718 		break;
1719 	case SIOCX25GSUBSCRIP:
1720 		rc = compat_x25_subscr_ioctl(cmd, argp);
1721 		break;
1722 	case SIOCX25SSUBSCRIP:
1723 		rc = -EPERM;
1724 		if (!capable(CAP_NET_ADMIN))
1725 			break;
1726 		rc = compat_x25_subscr_ioctl(cmd, argp);
1727 		break;
1728 	case SIOCX25GFACILITIES:
1729 	case SIOCX25SFACILITIES:
1730 	case SIOCX25GDTEFACILITIES:
1731 	case SIOCX25SDTEFACILITIES:
1732 	case SIOCX25GCALLUSERDATA:
1733 	case SIOCX25SCALLUSERDATA:
1734 	case SIOCX25GCAUSEDIAG:
1735 	case SIOCX25SCAUSEDIAG:
1736 	case SIOCX25SCUDMATCHLEN:
1737 	case SIOCX25CALLACCPTAPPRV:
1738 	case SIOCX25SENDCALLACCPT:
1739 		rc = x25_ioctl(sock, cmd, (unsigned long)argp);
1740 		break;
1741 	default:
1742 		rc = -ENOIOCTLCMD;
1743 		break;
1744 	}
1745 	return rc;
1746 }
1747 #endif
1748 
1749 static const struct proto_ops x25_proto_ops = {
1750 	.family =	AF_X25,
1751 	.owner =	THIS_MODULE,
1752 	.release =	x25_release,
1753 	.bind =		x25_bind,
1754 	.connect =	x25_connect,
1755 	.socketpair =	sock_no_socketpair,
1756 	.accept =	x25_accept,
1757 	.getname =	x25_getname,
1758 	.poll =		datagram_poll,
1759 	.ioctl =	x25_ioctl,
1760 #ifdef CONFIG_COMPAT
1761 	.compat_ioctl = compat_x25_ioctl,
1762 #endif
1763 	.listen =	x25_listen,
1764 	.shutdown =	sock_no_shutdown,
1765 	.setsockopt =	x25_setsockopt,
1766 	.getsockopt =	x25_getsockopt,
1767 	.sendmsg =	x25_sendmsg,
1768 	.recvmsg =	x25_recvmsg,
1769 	.mmap =		sock_no_mmap,
1770 	.sendpage =	sock_no_sendpage,
1771 };
1772 
1773 static struct packet_type x25_packet_type __read_mostly = {
1774 	.type =	cpu_to_be16(ETH_P_X25),
1775 	.func =	x25_lapb_receive_frame,
1776 };
1777 
1778 static struct notifier_block x25_dev_notifier = {
1779 	.notifier_call = x25_device_event,
1780 };
1781 
1782 void x25_kill_by_neigh(struct x25_neigh *nb)
1783 {
1784 	struct sock *s;
1785 
1786 	write_lock_bh(&x25_list_lock);
1787 
1788 	sk_for_each(s, &x25_list)
1789 		if (x25_sk(s)->neighbour == nb)
1790 			x25_disconnect(s, ENETUNREACH, 0, 0);
1791 
1792 	write_unlock_bh(&x25_list_lock);
1793 
1794 	/* Remove any related forwards */
1795 	x25_clear_forward_by_dev(nb->dev);
1796 }
1797 
1798 static int __init x25_init(void)
1799 {
1800 	int rc;
1801 
1802 	rc = proto_register(&x25_proto, 0);
1803 	if (rc)
1804 		goto out;
1805 
1806 	rc = sock_register(&x25_family_ops);
1807 	if (rc)
1808 		goto out_proto;
1809 
1810 	dev_add_pack(&x25_packet_type);
1811 
1812 	rc = register_netdevice_notifier(&x25_dev_notifier);
1813 	if (rc)
1814 		goto out_sock;
1815 
1816 	rc = x25_register_sysctl();
1817 	if (rc)
1818 		goto out_dev;
1819 
1820 	rc = x25_proc_init();
1821 	if (rc)
1822 		goto out_sysctl;
1823 
1824 	pr_info("Linux Version 0.2\n");
1825 
1826 out:
1827 	return rc;
1828 out_sysctl:
1829 	x25_unregister_sysctl();
1830 out_dev:
1831 	unregister_netdevice_notifier(&x25_dev_notifier);
1832 out_sock:
1833 	dev_remove_pack(&x25_packet_type);
1834 	sock_unregister(AF_X25);
1835 out_proto:
1836 	proto_unregister(&x25_proto);
1837 	goto out;
1838 }
1839 module_init(x25_init);
1840 
1841 static void __exit x25_exit(void)
1842 {
1843 	x25_proc_exit();
1844 	x25_link_free();
1845 	x25_route_free();
1846 
1847 	x25_unregister_sysctl();
1848 
1849 	unregister_netdevice_notifier(&x25_dev_notifier);
1850 
1851 	dev_remove_pack(&x25_packet_type);
1852 
1853 	sock_unregister(AF_X25);
1854 	proto_unregister(&x25_proto);
1855 }
1856 module_exit(x25_exit);
1857 
1858 MODULE_AUTHOR("Jonathan Naylor <g4klx@g4klx.demon.co.uk>");
1859 MODULE_DESCRIPTION("The X.25 Packet Layer network layer protocol");
1860 MODULE_LICENSE("GPL");
1861 MODULE_ALIAS_NETPROTO(PF_X25);
1862