1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *
   4 * Copyright Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
   5 * Copyright Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
   6 * Copyright Darryl Miles G7LED (dlm@g7led.demon.co.uk)
   7 */
   8#include <linux/module.h>
   9#include <linux/moduleparam.h>
  10#include <linux/capability.h>
  11#include <linux/errno.h>
  12#include <linux/types.h>
  13#include <linux/socket.h>
  14#include <linux/in.h>
  15#include <linux/slab.h>
  16#include <linux/kernel.h>
  17#include <linux/sched/signal.h>
  18#include <linux/timer.h>
  19#include <linux/string.h>
  20#include <linux/sockios.h>
  21#include <linux/net.h>
  22#include <linux/stat.h>
  23#include <net/ax25.h>
  24#include <linux/inet.h>
  25#include <linux/netdevice.h>
  26#include <linux/if_arp.h>
  27#include <linux/skbuff.h>
  28#include <net/net_namespace.h>
  29#include <net/sock.h>
  30#include <linux/uaccess.h>
  31#include <linux/fcntl.h>
  32#include <linux/termios.h>	/* For TIOCINQ/OUTQ */
  33#include <linux/mm.h>
  34#include <linux/interrupt.h>
  35#include <linux/notifier.h>
  36#include <net/netrom.h>
  37#include <linux/proc_fs.h>
  38#include <linux/seq_file.h>
  39#include <net/ip.h>
  40#include <net/tcp_states.h>
  41#include <net/arp.h>
  42#include <linux/init.h>
  43
  44static int nr_ndevs = 4;
  45
  46int sysctl_netrom_default_path_quality            = NR_DEFAULT_QUAL;
  47int sysctl_netrom_obsolescence_count_initialiser  = NR_DEFAULT_OBS;
  48int sysctl_netrom_network_ttl_initialiser         = NR_DEFAULT_TTL;
  49int sysctl_netrom_transport_timeout               = NR_DEFAULT_T1;
  50int sysctl_netrom_transport_maximum_tries         = NR_DEFAULT_N2;
  51int sysctl_netrom_transport_acknowledge_delay     = NR_DEFAULT_T2;
  52int sysctl_netrom_transport_busy_delay            = NR_DEFAULT_T4;
  53int sysctl_netrom_transport_requested_window_size = NR_DEFAULT_WINDOW;
  54int sysctl_netrom_transport_no_activity_timeout   = NR_DEFAULT_IDLE;
  55int sysctl_netrom_routing_control                 = NR_DEFAULT_ROUTING;
  56int sysctl_netrom_link_fails_count                = NR_DEFAULT_FAILS;
  57int sysctl_netrom_reset_circuit                   = NR_DEFAULT_RESET;
  58
  59static unsigned short circuit = 0x101;
  60
  61static HLIST_HEAD(nr_list);
  62static DEFINE_SPINLOCK(nr_list_lock);
  63
  64static const struct proto_ops nr_proto_ops;
  65
  66/*
  67 * NETROM network devices are virtual network devices encapsulating NETROM
  68 * frames into AX.25 which will be sent through an AX.25 device, so form a
  69 * special "super class" of normal net devices; split their locks off into a
  70 * separate class since they always nest.
  71 */
  72static struct lock_class_key nr_netdev_xmit_lock_key;
  73static struct lock_class_key nr_netdev_addr_lock_key;
  74
  75static void nr_set_lockdep_one(struct net_device *dev,
  76			       struct netdev_queue *txq,
  77			       void *_unused)
  78{
  79	lockdep_set_class(&txq->_xmit_lock, &nr_netdev_xmit_lock_key);
  80}
  81
  82static void nr_set_lockdep_key(struct net_device *dev)
  83{
  84	lockdep_set_class(&dev->addr_list_lock, &nr_netdev_addr_lock_key);
  85	netdev_for_each_tx_queue(dev, nr_set_lockdep_one, NULL);
  86}
  87
  88/*
  89 *	Socket removal during an interrupt is now safe.
  90 */
  91static void nr_remove_socket(struct sock *sk)
  92{
  93	spin_lock_bh(&nr_list_lock);
  94	sk_del_node_init(sk);
  95	spin_unlock_bh(&nr_list_lock);
  96}
  97
  98/*
  99 *	Kill all bound sockets on a dropped device.
 100 */
 101static void nr_kill_by_device(struct net_device *dev)
 102{
 103	struct sock *s;
 104
 105	spin_lock_bh(&nr_list_lock);
 106	sk_for_each(s, &nr_list)
 107		if (nr_sk(s)->device == dev)
 108			nr_disconnect(s, ENETUNREACH);
 109	spin_unlock_bh(&nr_list_lock);
 110}
 111
 112/*
 113 *	Handle device status changes.
 114 */
 115static int nr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
 116{
 117	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 118
 119	if (!net_eq(dev_net(dev), &init_net))
 120		return NOTIFY_DONE;
 121
 122	if (event != NETDEV_DOWN)
 123		return NOTIFY_DONE;
 124
 125	nr_kill_by_device(dev);
 126	nr_rt_device_down(dev);
 127
 128	return NOTIFY_DONE;
 129}
 130
 131/*
 132 *	Add a socket to the bound sockets list.
 133 */
 134static void nr_insert_socket(struct sock *sk)
 135{
 136	spin_lock_bh(&nr_list_lock);
 137	sk_add_node(sk, &nr_list);
 138	spin_unlock_bh(&nr_list_lock);
 139}
 140
 141/*
 142 *	Find a socket that wants to accept the Connect Request we just
 143 *	received.
 144 */
 145static struct sock *nr_find_listener(ax25_address *addr)
 146{
 147	struct sock *s;
 148
 149	spin_lock_bh(&nr_list_lock);
 150	sk_for_each(s, &nr_list)
 151		if (!ax25cmp(&nr_sk(s)->source_addr, addr) &&
 152		    s->sk_state == TCP_LISTEN) {
 153			sock_hold(s);
 154			goto found;
 155		}
 156	s = NULL;
 157found:
 158	spin_unlock_bh(&nr_list_lock);
 159	return s;
 160}
 161
 162/*
 163 *	Find a connected NET/ROM socket given my circuit IDs.
 164 */
 165static struct sock *nr_find_socket(unsigned char index, unsigned char id)
 166{
 167	struct sock *s;
 168
 169	spin_lock_bh(&nr_list_lock);
 170	sk_for_each(s, &nr_list) {
 171		struct nr_sock *nr = nr_sk(s);
 172
 173		if (nr->my_index == index && nr->my_id == id) {
 174			sock_hold(s);
 175			goto found;
 176		}
 177	}
 178	s = NULL;
 179found:
 180	spin_unlock_bh(&nr_list_lock);
 181	return s;
 182}
 183
 184/*
 185 *	Find a connected NET/ROM socket given their circuit IDs.
 186 */
 187static struct sock *nr_find_peer(unsigned char index, unsigned char id,
 188	ax25_address *dest)
 189{
 190	struct sock *s;
 191
 192	spin_lock_bh(&nr_list_lock);
 193	sk_for_each(s, &nr_list) {
 194		struct nr_sock *nr = nr_sk(s);
 195
 196		if (nr->your_index == index && nr->your_id == id &&
 197		    !ax25cmp(&nr->dest_addr, dest)) {
 198			sock_hold(s);
 199			goto found;
 200		}
 201	}
 202	s = NULL;
 203found:
 204	spin_unlock_bh(&nr_list_lock);
 205	return s;
 206}
 207
 208/*
 209 *	Find next free circuit ID.
 210 */
 211static unsigned short nr_find_next_circuit(void)
 212{
 213	unsigned short id = circuit;
 214	unsigned char i, j;
 215	struct sock *sk;
 216
 217	for (;;) {
 218		i = id / 256;
 219		j = id % 256;
 220
 221		if (i != 0 && j != 0) {
 222			if ((sk=nr_find_socket(i, j)) == NULL)
 223				break;
 224			sock_put(sk);
 225		}
 226
 227		id++;
 228	}
 229
 230	return id;
 231}
 232
 233/*
 234 *	Deferred destroy.
 235 */
 236void nr_destroy_socket(struct sock *);
 237
 238/*
 239 *	Handler for deferred kills.
 240 */
 241static void nr_destroy_timer(struct timer_list *t)
 242{
 243	struct sock *sk = from_timer(sk, t, sk_timer);
 244	bh_lock_sock(sk);
 245	sock_hold(sk);
 246	nr_destroy_socket(sk);
 247	bh_unlock_sock(sk);
 248	sock_put(sk);
 249}
 250
 251/*
 252 *	This is called from user mode and the timers. Thus it protects itself
 253 *	against interrupt users but doesn't worry about being called during
 254 *	work. Once it is removed from the queue no interrupt or bottom half
 255 *	will touch it and we are (fairly 8-) ) safe.
 256 */
 257void nr_destroy_socket(struct sock *sk)
 258{
 259	struct sk_buff *skb;
 260
 261	nr_remove_socket(sk);
 262
 263	nr_stop_heartbeat(sk);
 264	nr_stop_t1timer(sk);
 265	nr_stop_t2timer(sk);
 266	nr_stop_t4timer(sk);
 267	nr_stop_idletimer(sk);
 268
 269	nr_clear_queues(sk);		/* Flush the queues */
 270
 271	while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
 272		if (skb->sk != sk) { /* A pending connection */
 273			/* Queue the unaccepted socket for death */
 274			sock_set_flag(skb->sk, SOCK_DEAD);
 275			nr_start_heartbeat(skb->sk);
 276			nr_sk(skb->sk)->state = NR_STATE_0;
 277		}
 278
 279		kfree_skb(skb);
 280	}
 281
 282	if (sk_has_allocations(sk)) {
 283		/* Defer: outstanding buffers */
 284		sk->sk_timer.function = nr_destroy_timer;
 285		sk->sk_timer.expires  = jiffies + 2 * HZ;
 286		add_timer(&sk->sk_timer);
 287	} else
 288		sock_put(sk);
 289}
 290
 291/*
 292 *	Handling for system calls applied via the various interfaces to a
 293 *	NET/ROM socket object.
 294 */
 295
 296static int nr_setsockopt(struct socket *sock, int level, int optname,
 297		sockptr_t optval, unsigned int optlen)
 298{
 299	struct sock *sk = sock->sk;
 300	struct nr_sock *nr = nr_sk(sk);
 301	unsigned long opt;
 302
 303	if (level != SOL_NETROM)
 304		return -ENOPROTOOPT;
 305
 306	if (optlen < sizeof(unsigned int))
 307		return -EINVAL;
 308
 309	if (copy_from_sockptr(&opt, optval, sizeof(unsigned int)))
 310		return -EFAULT;
 311
 312	switch (optname) {
 313	case NETROM_T1:
 314		if (opt < 1 || opt > ULONG_MAX / HZ)
 315			return -EINVAL;
 316		nr->t1 = opt * HZ;
 317		return 0;
 318
 319	case NETROM_T2:
 320		if (opt < 1 || opt > ULONG_MAX / HZ)
 321			return -EINVAL;
 322		nr->t2 = opt * HZ;
 323		return 0;
 324
 325	case NETROM_N2:
 326		if (opt < 1 || opt > 31)
 327			return -EINVAL;
 328		nr->n2 = opt;
 329		return 0;
 330
 331	case NETROM_T4:
 332		if (opt < 1 || opt > ULONG_MAX / HZ)
 333			return -EINVAL;
 334		nr->t4 = opt * HZ;
 335		return 0;
 336
 337	case NETROM_IDLE:
 338		if (opt > ULONG_MAX / (60 * HZ))
 339			return -EINVAL;
 340		nr->idle = opt * 60 * HZ;
 341		return 0;
 342
 343	default:
 344		return -ENOPROTOOPT;
 345	}
 346}
 347
 348static int nr_getsockopt(struct socket *sock, int level, int optname,
 349	char __user *optval, int __user *optlen)
 350{
 351	struct sock *sk = sock->sk;
 352	struct nr_sock *nr = nr_sk(sk);
 353	int val = 0;
 354	int len;
 355
 356	if (level != SOL_NETROM)
 357		return -ENOPROTOOPT;
 358
 359	if (get_user(len, optlen))
 360		return -EFAULT;
 361
 362	if (len < 0)
 363		return -EINVAL;
 364
 365	switch (optname) {
 366	case NETROM_T1:
 367		val = nr->t1 / HZ;
 368		break;
 369
 370	case NETROM_T2:
 371		val = nr->t2 / HZ;
 372		break;
 373
 374	case NETROM_N2:
 375		val = nr->n2;
 376		break;
 377
 378	case NETROM_T4:
 379		val = nr->t4 / HZ;
 380		break;
 381
 382	case NETROM_IDLE:
 383		val = nr->idle / (60 * HZ);
 384		break;
 385
 386	default:
 387		return -ENOPROTOOPT;
 388	}
 389
 390	len = min_t(unsigned int, len, sizeof(int));
 391
 392	if (put_user(len, optlen))
 393		return -EFAULT;
 394
 395	return copy_to_user(optval, &val, len) ? -EFAULT : 0;
 396}
 397
 398static int nr_listen(struct socket *sock, int backlog)
 399{
 400	struct sock *sk = sock->sk;
 401
 402	lock_sock(sk);
 403	if (sk->sk_state != TCP_LISTEN) {
 404		memset(&nr_sk(sk)->user_addr, 0, AX25_ADDR_LEN);
 405		sk->sk_max_ack_backlog = backlog;
 406		sk->sk_state           = TCP_LISTEN;
 407		release_sock(sk);
 408		return 0;
 409	}
 410	release_sock(sk);
 411
 412	return -EOPNOTSUPP;
 413}
 414
 415static struct proto nr_proto = {
 416	.name	  = "NETROM",
 417	.owner	  = THIS_MODULE,
 418	.obj_size = sizeof(struct nr_sock),
 419};
 420
 421static int nr_create(struct net *net, struct socket *sock, int protocol,
 422		     int kern)
 423{
 424	struct sock *sk;
 425	struct nr_sock *nr;
 426
 427	if (!net_eq(net, &init_net))
 428		return -EAFNOSUPPORT;
 429
 430	if (sock->type != SOCK_SEQPACKET || protocol != 0)
 431		return -ESOCKTNOSUPPORT;
 432
 433	sk = sk_alloc(net, PF_NETROM, GFP_ATOMIC, &nr_proto, kern);
 434	if (sk  == NULL)
 435		return -ENOMEM;
 436
 437	nr = nr_sk(sk);
 438
 439	sock_init_data(sock, sk);
 440
 441	sock->ops    = &nr_proto_ops;
 442	sk->sk_protocol = protocol;
 443
 444	skb_queue_head_init(&nr->ack_queue);
 445	skb_queue_head_init(&nr->reseq_queue);
 446	skb_queue_head_init(&nr->frag_queue);
 447
 448	nr_init_timers(sk);
 449
 450	nr->t1     =
 451		msecs_to_jiffies(sysctl_netrom_transport_timeout);
 452	nr->t2     =
 453		msecs_to_jiffies(sysctl_netrom_transport_acknowledge_delay);
 454	nr->n2     =
 455		msecs_to_jiffies(sysctl_netrom_transport_maximum_tries);
 456	nr->t4     =
 457		msecs_to_jiffies(sysctl_netrom_transport_busy_delay);
 458	nr->idle   =
 459		msecs_to_jiffies(sysctl_netrom_transport_no_activity_timeout);
 460	nr->window = sysctl_netrom_transport_requested_window_size;
 461
 462	nr->bpqext = 1;
 463	nr->state  = NR_STATE_0;
 464
 465	return 0;
 466}
 467
 468static struct sock *nr_make_new(struct sock *osk)
 469{
 470	struct sock *sk;
 471	struct nr_sock *nr, *onr;
 472
 473	if (osk->sk_type != SOCK_SEQPACKET)
 474		return NULL;
 475
 476	sk = sk_alloc(sock_net(osk), PF_NETROM, GFP_ATOMIC, osk->sk_prot, 0);
 477	if (sk == NULL)
 478		return NULL;
 479
 480	nr = nr_sk(sk);
 481
 482	sock_init_data(NULL, sk);
 483
 484	sk->sk_type     = osk->sk_type;
 485	sk->sk_priority = osk->sk_priority;
 486	sk->sk_protocol = osk->sk_protocol;
 487	sk->sk_rcvbuf   = osk->sk_rcvbuf;
 488	sk->sk_sndbuf   = osk->sk_sndbuf;
 489	sk->sk_state    = TCP_ESTABLISHED;
 490	sock_copy_flags(sk, osk);
 491
 492	skb_queue_head_init(&nr->ack_queue);
 493	skb_queue_head_init(&nr->reseq_queue);
 494	skb_queue_head_init(&nr->frag_queue);
 495
 496	nr_init_timers(sk);
 497
 498	onr = nr_sk(osk);
 499
 500	nr->t1      = onr->t1;
 501	nr->t2      = onr->t2;
 502	nr->n2      = onr->n2;
 503	nr->t4      = onr->t4;
 504	nr->idle    = onr->idle;
 505	nr->window  = onr->window;
 506
 507	nr->device  = onr->device;
 508	nr->bpqext  = onr->bpqext;
 509
 510	return sk;
 511}
 512
 513static int nr_release(struct socket *sock)
 514{
 515	struct sock *sk = sock->sk;
 516	struct nr_sock *nr;
 517
 518	if (sk == NULL) return 0;
 519
 520	sock_hold(sk);
 521	sock_orphan(sk);
 522	lock_sock(sk);
 523	nr = nr_sk(sk);
 524
 525	switch (nr->state) {
 526	case NR_STATE_0:
 527	case NR_STATE_1:
 528	case NR_STATE_2:
 529		nr_disconnect(sk, 0);
 530		nr_destroy_socket(sk);
 531		break;
 532
 533	case NR_STATE_3:
 534		nr_clear_queues(sk);
 535		nr->n2count = 0;
 536		nr_write_internal(sk, NR_DISCREQ);
 537		nr_start_t1timer(sk);
 538		nr_stop_t2timer(sk);
 539		nr_stop_t4timer(sk);
 540		nr_stop_idletimer(sk);
 541		nr->state    = NR_STATE_2;
 542		sk->sk_state    = TCP_CLOSE;
 543		sk->sk_shutdown |= SEND_SHUTDOWN;
 544		sk->sk_state_change(sk);
 545		sock_set_flag(sk, SOCK_DESTROY);
 546		break;
 547
 548	default:
 549		break;
 550	}
 551
 552	sock->sk   = NULL;
 553	release_sock(sk);
 554	sock_put(sk);
 555
 556	return 0;
 557}
 558
 559static int nr_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
 560{
 561	struct sock *sk = sock->sk;
 562	struct nr_sock *nr = nr_sk(sk);
 563	struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
 564	struct net_device *dev;
 565	ax25_uid_assoc *user;
 566	ax25_address *source;
 567
 568	lock_sock(sk);
 569	if (!sock_flag(sk, SOCK_ZAPPED)) {
 570		release_sock(sk);
 571		return -EINVAL;
 572	}
 573	if (addr_len < sizeof(struct sockaddr_ax25) || addr_len > sizeof(struct full_sockaddr_ax25)) {
 574		release_sock(sk);
 575		return -EINVAL;
 576	}
 577	if (addr_len < (addr->fsa_ax25.sax25_ndigis * sizeof(ax25_address) + sizeof(struct sockaddr_ax25))) {
 578		release_sock(sk);
 579		return -EINVAL;
 580	}
 581	if (addr->fsa_ax25.sax25_family != AF_NETROM) {
 582		release_sock(sk);
 583		return -EINVAL;
 584	}
 585	if ((dev = nr_dev_get(&addr->fsa_ax25.sax25_call)) == NULL) {
 586		release_sock(sk);
 587		return -EADDRNOTAVAIL;
 588	}
 589
 590	/*
 591	 * Only the super user can set an arbitrary user callsign.
 592	 */
 593	if (addr->fsa_ax25.sax25_ndigis == 1) {
 594		if (!capable(CAP_NET_BIND_SERVICE)) {
 595			dev_put(dev);
 596			release_sock(sk);
 597			return -EPERM;
 598		}
 599		nr->user_addr   = addr->fsa_digipeater[0];
 600		nr->source_addr = addr->fsa_ax25.sax25_call;
 601	} else {
 602		source = &addr->fsa_ax25.sax25_call;
 603
 604		user = ax25_findbyuid(current_euid());
 605		if (user) {
 606			nr->user_addr   = user->call;
 607			ax25_uid_put(user);
 608		} else {
 609			if (ax25_uid_policy && !capable(CAP_NET_BIND_SERVICE)) {
 610				release_sock(sk);
 611				dev_put(dev);
 612				return -EPERM;
 613			}
 614			nr->user_addr   = *source;
 615		}
 616
 617		nr->source_addr = *source;
 618	}
 619
 620	nr->device = dev;
 621	nr_insert_socket(sk);
 622
 623	sock_reset_flag(sk, SOCK_ZAPPED);
 624	dev_put(dev);
 625	release_sock(sk);
 626
 627	return 0;
 628}
 629
 630static int nr_connect(struct socket *sock, struct sockaddr *uaddr,
 631	int addr_len, int flags)
 632{
 633	struct sock *sk = sock->sk;
 634	struct nr_sock *nr = nr_sk(sk);
 635	struct sockaddr_ax25 *addr = (struct sockaddr_ax25 *)uaddr;
 636	ax25_address *source = NULL;
 637	ax25_uid_assoc *user;
 638	struct net_device *dev;
 639	int err = 0;
 640
 641	lock_sock(sk);
 642	if (sk->sk_state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
 643		sock->state = SS_CONNECTED;
 644		goto out_release;	/* Connect completed during a ERESTARTSYS event */
 645	}
 646
 647	if (sk->sk_state == TCP_CLOSE && sock->state == SS_CONNECTING) {
 648		sock->state = SS_UNCONNECTED;
 649		err = -ECONNREFUSED;
 650		goto out_release;
 651	}
 652
 653	if (sk->sk_state == TCP_ESTABLISHED) {
 654		err = -EISCONN;	/* No reconnect on a seqpacket socket */
 655		goto out_release;
 656	}
 657
 658	sk->sk_state   = TCP_CLOSE;
 659	sock->state = SS_UNCONNECTED;
 660
 661	if (addr_len != sizeof(struct sockaddr_ax25) && addr_len != sizeof(struct full_sockaddr_ax25)) {
 662		err = -EINVAL;
 663		goto out_release;
 664	}
 665	if (addr->sax25_family != AF_NETROM) {
 666		err = -EINVAL;
 667		goto out_release;
 668	}
 669	if (sock_flag(sk, SOCK_ZAPPED)) {	/* Must bind first - autobinding in this may or may not work */
 670		sock_reset_flag(sk, SOCK_ZAPPED);
 671
 672		if ((dev = nr_dev_first()) == NULL) {
 673			err = -ENETUNREACH;
 674			goto out_release;
 675		}
 676		source = (ax25_address *)dev->dev_addr;
 677
 678		user = ax25_findbyuid(current_euid());
 679		if (user) {
 680			nr->user_addr   = user->call;
 681			ax25_uid_put(user);
 682		} else {
 683			if (ax25_uid_policy && !capable(CAP_NET_ADMIN)) {
 684				dev_put(dev);
 685				err = -EPERM;
 686				goto out_release;
 687			}
 688			nr->user_addr   = *source;
 689		}
 690
 691		nr->source_addr = *source;
 692		nr->device      = dev;
 693
 694		dev_put(dev);
 695		nr_insert_socket(sk);		/* Finish the bind */
 696	}
 697
 698	nr->dest_addr = addr->sax25_call;
 699
 700	release_sock(sk);
 701	circuit = nr_find_next_circuit();
 702	lock_sock(sk);
 703
 704	nr->my_index = circuit / 256;
 705	nr->my_id    = circuit % 256;
 706
 707	circuit++;
 708
 709	/* Move to connecting socket, start sending Connect Requests */
 710	sock->state  = SS_CONNECTING;
 711	sk->sk_state = TCP_SYN_SENT;
 712
 713	nr_establish_data_link(sk);
 714
 715	nr->state = NR_STATE_1;
 716
 717	nr_start_heartbeat(sk);
 718
 719	/* Now the loop */
 720	if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
 721		err = -EINPROGRESS;
 722		goto out_release;
 723	}
 724
 725	/*
 726	 * A Connect Ack with Choke or timeout or failed routing will go to
 727	 * closed.
 728	 */
 729	if (sk->sk_state == TCP_SYN_SENT) {
 730		DEFINE_WAIT(wait);
 731
 732		for (;;) {
 733			prepare_to_wait(sk_sleep(sk), &wait,
 734					TASK_INTERRUPTIBLE);
 735			if (sk->sk_state != TCP_SYN_SENT)
 736				break;
 737			if (!signal_pending(current)) {
 738				release_sock(sk);
 739				schedule();
 740				lock_sock(sk);
 741				continue;
 742			}
 743			err = -ERESTARTSYS;
 744			break;
 745		}
 746		finish_wait(sk_sleep(sk), &wait);
 747		if (err)
 748			goto out_release;
 749	}
 750
 751	if (sk->sk_state != TCP_ESTABLISHED) {
 752		sock->state = SS_UNCONNECTED;
 753		err = sock_error(sk);	/* Always set at this point */
 754		goto out_release;
 755	}
 756
 757	sock->state = SS_CONNECTED;
 758
 759out_release:
 760	release_sock(sk);
 761
 762	return err;
 763}
 764
 765static int nr_accept(struct socket *sock, struct socket *newsock, int flags,
 766		     bool kern)
 767{
 768	struct sk_buff *skb;
 769	struct sock *newsk;
 770	DEFINE_WAIT(wait);
 771	struct sock *sk;
 772	int err = 0;
 773
 774	if ((sk = sock->sk) == NULL)
 775		return -EINVAL;
 776
 777	lock_sock(sk);
 778	if (sk->sk_type != SOCK_SEQPACKET) {
 779		err = -EOPNOTSUPP;
 780		goto out_release;
 781	}
 782
 783	if (sk->sk_state != TCP_LISTEN) {
 784		err = -EINVAL;
 785		goto out_release;
 786	}
 787
 788	/*
 789	 *	The write queue this time is holding sockets ready to use
 790	 *	hooked into the SABM we saved
 791	 */
 792	for (;;) {
 793		prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
 794		skb = skb_dequeue(&sk->sk_receive_queue);
 795		if (skb)
 796			break;
 797
 798		if (flags & O_NONBLOCK) {
 799			err = -EWOULDBLOCK;
 800			break;
 801		}
 802		if (!signal_pending(current)) {
 803			release_sock(sk);
 804			schedule();
 805			lock_sock(sk);
 806			continue;
 807		}
 808		err = -ERESTARTSYS;
 809		break;
 810	}
 811	finish_wait(sk_sleep(sk), &wait);
 812	if (err)
 813		goto out_release;
 814
 815	newsk = skb->sk;
 816	sock_graft(newsk, newsock);
 817
 818	/* Now attach up the new socket */
 819	kfree_skb(skb);
 820	sk_acceptq_removed(sk);
 821
 822out_release:
 823	release_sock(sk);
 824
 825	return err;
 826}
 827
 828static int nr_getname(struct socket *sock, struct sockaddr *uaddr,
 829	int peer)
 830{
 831	struct full_sockaddr_ax25 *sax = (struct full_sockaddr_ax25 *)uaddr;
 832	struct sock *sk = sock->sk;
 833	struct nr_sock *nr = nr_sk(sk);
 834	int uaddr_len;
 835
 836	memset(&sax->fsa_ax25, 0, sizeof(struct sockaddr_ax25));
 837
 838	lock_sock(sk);
 839	if (peer != 0) {
 840		if (sk->sk_state != TCP_ESTABLISHED) {
 841			release_sock(sk);
 842			return -ENOTCONN;
 843		}
 844		sax->fsa_ax25.sax25_family = AF_NETROM;
 845		sax->fsa_ax25.sax25_ndigis = 1;
 846		sax->fsa_ax25.sax25_call   = nr->user_addr;
 847		memset(sax->fsa_digipeater, 0, sizeof(sax->fsa_digipeater));
 848		sax->fsa_digipeater[0]     = nr->dest_addr;
 849		uaddr_len = sizeof(struct full_sockaddr_ax25);
 850	} else {
 851		sax->fsa_ax25.sax25_family = AF_NETROM;
 852		sax->fsa_ax25.sax25_ndigis = 0;
 853		sax->fsa_ax25.sax25_call   = nr->source_addr;
 854		uaddr_len = sizeof(struct sockaddr_ax25);
 855	}
 856	release_sock(sk);
 857
 858	return uaddr_len;
 859}
 860
 861int nr_rx_frame(struct sk_buff *skb, struct net_device *dev)
 862{
 863	struct sock *sk;
 864	struct sock *make;
 865	struct nr_sock *nr_make;
 866	ax25_address *src, *dest, *user;
 867	unsigned short circuit_index, circuit_id;
 868	unsigned short peer_circuit_index, peer_circuit_id;
 869	unsigned short frametype, flags, window, timeout;
 870	int ret;
 871
 872	skb_orphan(skb);
 873
 874	/*
 875	 *	skb->data points to the netrom frame start
 876	 */
 877
 878	src  = (ax25_address *)(skb->data + 0);
 879	dest = (ax25_address *)(skb->data + 7);
 880
 881	circuit_index      = skb->data[15];
 882	circuit_id         = skb->data[16];
 883	peer_circuit_index = skb->data[17];
 884	peer_circuit_id    = skb->data[18];
 885	frametype          = skb->data[19] & 0x0F;
 886	flags              = skb->data[19] & 0xF0;
 887
 888	/*
 889	 * Check for an incoming IP over NET/ROM frame.
 890	 */
 891	if (frametype == NR_PROTOEXT &&
 892	    circuit_index == NR_PROTO_IP && circuit_id == NR_PROTO_IP) {
 893		skb_pull(skb, NR_NETWORK_LEN + NR_TRANSPORT_LEN);
 894		skb_reset_transport_header(skb);
 895
 896		return nr_rx_ip(skb, dev);
 897	}
 898
 899	/*
 900	 * Find an existing socket connection, based on circuit ID, if it's
 901	 * a Connect Request base it on their circuit ID.
 902	 *
 903	 * Circuit ID 0/0 is not valid but it could still be a "reset" for a
 904	 * circuit that no longer exists at the other end ...
 905	 */
 906
 907	sk = NULL;
 908
 909	if (circuit_index == 0 && circuit_id == 0) {
 910		if (frametype == NR_CONNACK && flags == NR_CHOKE_FLAG)
 911			sk = nr_find_peer(peer_circuit_index, peer_circuit_id, src);
 912	} else {
 913		if (frametype == NR_CONNREQ)
 914			sk = nr_find_peer(circuit_index, circuit_id, src);
 915		else
 916			sk = nr_find_socket(circuit_index, circuit_id);
 917	}
 918
 919	if (sk != NULL) {
 920		bh_lock_sock(sk);
 921		skb_reset_transport_header(skb);
 922
 923		if (frametype == NR_CONNACK && skb->len == 22)
 924			nr_sk(sk)->bpqext = 1;
 925		else
 926			nr_sk(sk)->bpqext = 0;
 927
 928		ret = nr_process_rx_frame(sk, skb);
 929		bh_unlock_sock(sk);
 930		sock_put(sk);
 931		return ret;
 932	}
 933
 934	/*
 935	 * Now it should be a CONNREQ.
 936	 */
 937	if (frametype != NR_CONNREQ) {
 938		/*
 939		 * Here it would be nice to be able to send a reset but
 940		 * NET/ROM doesn't have one.  We've tried to extend the protocol
 941		 * by sending NR_CONNACK | NR_CHOKE_FLAGS replies but that
 942		 * apparently kills BPQ boxes... :-(
 943		 * So now we try to follow the established behaviour of
 944		 * G8PZT's Xrouter which is sending packets with command type 7
 945		 * as an extension of the protocol.
 946		 */
 947		if (sysctl_netrom_reset_circuit &&
 948		    (frametype != NR_RESET || flags != 0))
 949			nr_transmit_reset(skb, 1);
 950
 951		return 0;
 952	}
 953
 954	sk = nr_find_listener(dest);
 955
 956	user = (ax25_address *)(skb->data + 21);
 957
 958	if (sk == NULL || sk_acceptq_is_full(sk) ||
 959	    (make = nr_make_new(sk)) == NULL) {
 960		nr_transmit_refusal(skb, 0);
 961		if (sk)
 962			sock_put(sk);
 963		return 0;
 964	}
 965
 966	bh_lock_sock(sk);
 967
 968	window = skb->data[20];
 969
 970	sock_hold(make);
 971	skb->sk             = make;
 972	skb->destructor     = sock_efree;
 973	make->sk_state	    = TCP_ESTABLISHED;
 974
 975	/* Fill in his circuit details */
 976	nr_make = nr_sk(make);
 977	nr_make->source_addr = *dest;
 978	nr_make->dest_addr   = *src;
 979	nr_make->user_addr   = *user;
 980
 981	nr_make->your_index  = circuit_index;
 982	nr_make->your_id     = circuit_id;
 983
 984	bh_unlock_sock(sk);
 985	circuit = nr_find_next_circuit();
 986	bh_lock_sock(sk);
 987
 988	nr_make->my_index    = circuit / 256;
 989	nr_make->my_id       = circuit % 256;
 990
 991	circuit++;
 992
 993	/* Window negotiation */
 994	if (window < nr_make->window)
 995		nr_make->window = window;
 996
 997	/* L4 timeout negotiation */
 998	if (skb->len == 37) {
 999		timeout = skb->data[36] * 256 + skb->data[35];
1000		if (timeout * HZ < nr_make->t1)
1001			nr_make->t1 = timeout * HZ;
1002		nr_make->bpqext = 1;
1003	} else {
1004		nr_make->bpqext = 0;
1005	}
1006
1007	nr_write_internal(make, NR_CONNACK);
1008
1009	nr_make->condition = 0x00;
1010	nr_make->vs        = 0;
1011	nr_make->va        = 0;
1012	nr_make->vr        = 0;
1013	nr_make->vl        = 0;
1014	nr_make->state     = NR_STATE_3;
1015	sk_acceptq_added(sk);
1016	skb_queue_head(&sk->sk_receive_queue, skb);
1017
1018	if (!sock_flag(sk, SOCK_DEAD))
1019		sk->sk_data_ready(sk);
1020
1021	bh_unlock_sock(sk);
1022	sock_put(sk);
1023
1024	nr_insert_socket(make);
1025
1026	nr_start_heartbeat(make);
1027	nr_start_idletimer(make);
1028
1029	return 1;
1030}
1031
1032static int nr_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
1033{
1034	struct sock *sk = sock->sk;
1035	struct nr_sock *nr = nr_sk(sk);
1036	DECLARE_SOCKADDR(struct sockaddr_ax25 *, usax, msg->msg_name);
1037	int err;
1038	struct sockaddr_ax25 sax;
1039	struct sk_buff *skb;
1040	unsigned char *asmptr;
1041	int size;
1042
1043	if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_EOR|MSG_CMSG_COMPAT))
1044		return -EINVAL;
1045
1046	lock_sock(sk);
1047	if (sock_flag(sk, SOCK_ZAPPED)) {
1048		err = -EADDRNOTAVAIL;
1049		goto out;
1050	}
1051
1052	if (sk->sk_shutdown & SEND_SHUTDOWN) {
1053		send_sig(SIGPIPE, current, 0);
1054		err = -EPIPE;
1055		goto out;
1056	}
1057
1058	if (nr->device == NULL) {
1059		err = -ENETUNREACH;
1060		goto out;
1061	}
1062
1063	if (usax) {
1064		if (msg->msg_namelen < sizeof(sax)) {
1065			err = -EINVAL;
1066			goto out;
1067		}
1068		sax = *usax;
1069		if (ax25cmp(&nr->dest_addr, &sax.sax25_call) != 0) {
1070			err = -EISCONN;
1071			goto out;
1072		}
1073		if (sax.sax25_family != AF_NETROM) {
1074			err = -EINVAL;
1075			goto out;
1076		}
1077	} else {
1078		if (sk->sk_state != TCP_ESTABLISHED) {
1079			err = -ENOTCONN;
1080			goto out;
1081		}
1082		sax.sax25_family = AF_NETROM;
1083		sax.sax25_call   = nr->dest_addr;
1084	}
1085
1086	/* Build a packet - the conventional user limit is 236 bytes. We can
1087	   do ludicrously large NetROM frames but must not overflow */
1088	if (len > 65536) {
1089		err = -EMSGSIZE;
1090		goto out;
1091	}
1092
1093	size = len + NR_NETWORK_LEN + NR_TRANSPORT_LEN;
1094
1095	if ((skb = sock_alloc_send_skb(sk, size, msg->msg_flags & MSG_DONTWAIT, &err)) == NULL)
1096		goto out;
1097
1098	skb_reserve(skb, size - len);
1099	skb_reset_transport_header(skb);
1100
1101	/*
1102	 *	Push down the NET/ROM header
1103	 */
1104
1105	asmptr = skb_push(skb, NR_TRANSPORT_LEN);
1106
1107	/* Build a NET/ROM Transport header */
1108
1109	*asmptr++ = nr->your_index;
1110	*asmptr++ = nr->your_id;
1111	*asmptr++ = 0;		/* To be filled in later */
1112	*asmptr++ = 0;		/*      Ditto            */
1113	*asmptr++ = NR_INFO;
1114
1115	/*
1116	 *	Put the data on the end
1117	 */
1118	skb_put(skb, len);
1119
1120	/* User data follows immediately after the NET/ROM transport header */
1121	if (memcpy_from_msg(skb_transport_header(skb), msg, len)) {
1122		kfree_skb(skb);
1123		err = -EFAULT;
1124		goto out;
1125	}
1126
1127	if (sk->sk_state != TCP_ESTABLISHED) {
1128		kfree_skb(skb);
1129		err = -ENOTCONN;
1130		goto out;
1131	}
1132
1133	nr_output(sk, skb);	/* Shove it onto the queue */
1134
1135	err = len;
1136out:
1137	release_sock(sk);
1138	return err;
1139}
1140
1141static int nr_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1142		      int flags)
1143{
1144	struct sock *sk = sock->sk;
1145	DECLARE_SOCKADDR(struct sockaddr_ax25 *, sax, msg->msg_name);
1146	size_t copied;
1147	struct sk_buff *skb;
1148	int er;
1149
1150	/*
1151	 * This works for seqpacket too. The receiver has ordered the queue for
1152	 * us! We do one quick check first though
1153	 */
1154
1155	lock_sock(sk);
1156	if (sk->sk_state != TCP_ESTABLISHED) {
1157		release_sock(sk);
1158		return -ENOTCONN;
1159	}
1160
1161	/* Now we can treat all alike */
1162	if ((skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT, flags & MSG_DONTWAIT, &er)) == NULL) {
1163		release_sock(sk);
1164		return er;
1165	}
1166
1167	skb_reset_transport_header(skb);
1168	copied     = skb->len;
1169
1170	if (copied > size) {
1171		copied = size;
1172		msg->msg_flags |= MSG_TRUNC;
1173	}
1174
1175	er = skb_copy_datagram_msg(skb, 0, msg, copied);
1176	if (er < 0) {
1177		skb_free_datagram(sk, skb);
1178		release_sock(sk);
1179		return er;
1180	}
1181
1182	if (sax != NULL) {
1183		memset(sax, 0, sizeof(*sax));
1184		sax->sax25_family = AF_NETROM;
1185		skb_copy_from_linear_data_offset(skb, 7, sax->sax25_call.ax25_call,
1186			      AX25_ADDR_LEN);
1187		msg->msg_namelen = sizeof(*sax);
1188	}
1189
1190	skb_free_datagram(sk, skb);
1191
1192	release_sock(sk);
1193	return copied;
1194}
1195
1196
1197static int nr_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1198{
1199	struct sock *sk = sock->sk;
1200	void __user *argp = (void __user *)arg;
1201
1202	switch (cmd) {
1203	case TIOCOUTQ: {
1204		long amount;
1205
1206		lock_sock(sk);
1207		amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1208		if (amount < 0)
1209			amount = 0;
1210		release_sock(sk);
1211		return put_user(amount, (int __user *)argp);
1212	}
1213
1214	case TIOCINQ: {
1215		struct sk_buff *skb;
1216		long amount = 0L;
1217
1218		lock_sock(sk);
1219		/* These two are safe on a single CPU system as only user tasks fiddle here */
1220		if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1221			amount = skb->len;
1222		release_sock(sk);
1223		return put_user(amount, (int __user *)argp);
1224	}
1225
1226	case SIOCGIFADDR:
1227	case SIOCSIFADDR:
1228	case SIOCGIFDSTADDR:
1229	case SIOCSIFDSTADDR:
1230	case SIOCGIFBRDADDR:
1231	case SIOCSIFBRDADDR:
1232	case SIOCGIFNETMASK:
1233	case SIOCSIFNETMASK:
1234	case SIOCGIFMETRIC:
1235	case SIOCSIFMETRIC:
1236		return -EINVAL;
1237
1238	case SIOCADDRT:
1239	case SIOCDELRT:
1240	case SIOCNRDECOBS:
1241		if (!capable(CAP_NET_ADMIN))
1242			return -EPERM;
1243		return nr_rt_ioctl(cmd, argp);
1244
1245	default:
1246		return -ENOIOCTLCMD;
1247	}
1248
1249	return 0;
1250}
1251
1252#ifdef CONFIG_PROC_FS
1253
1254static void *nr_info_start(struct seq_file *seq, loff_t *pos)
1255	__acquires(&nr_list_lock)
1256{
1257	spin_lock_bh(&nr_list_lock);
1258	return seq_hlist_start_head(&nr_list, *pos);
1259}
1260
1261static void *nr_info_next(struct seq_file *seq, void *v, loff_t *pos)
1262{
1263	return seq_hlist_next(v, &nr_list, pos);
1264}
1265
1266static void nr_info_stop(struct seq_file *seq, void *v)
1267	__releases(&nr_list_lock)
1268{
1269	spin_unlock_bh(&nr_list_lock);
1270}
1271
1272static int nr_info_show(struct seq_file *seq, void *v)
1273{
1274	struct sock *s = sk_entry(v);
1275	struct net_device *dev;
1276	struct nr_sock *nr;
1277	const char *devname;
1278	char buf[11];
1279
1280	if (v == SEQ_START_TOKEN)
1281		seq_puts(seq,
1282"user_addr dest_node src_node  dev    my  your  st  vs  vr  va    t1     t2     t4      idle   n2  wnd Snd-Q Rcv-Q inode\n");
1283
1284	else {
1285
1286		bh_lock_sock(s);
1287		nr = nr_sk(s);
1288
1289		if ((dev = nr->device) == NULL)
1290			devname = "???";
1291		else
1292			devname = dev->name;
1293
1294		seq_printf(seq, "%-9s ", ax2asc(buf, &nr->user_addr));
1295		seq_printf(seq, "%-9s ", ax2asc(buf, &nr->dest_addr));
1296		seq_printf(seq,
1297"%-9s %-3s  %02X/%02X %02X/%02X %2d %3d %3d %3d %3lu/%03lu %2lu/%02lu %3lu/%03lu %3lu/%03lu %2d/%02d %3d %5d %5d %ld\n",
1298			ax2asc(buf, &nr->source_addr),
1299			devname,
1300			nr->my_index,
1301			nr->my_id,
1302			nr->your_index,
1303			nr->your_id,
1304			nr->state,
1305			nr->vs,
1306			nr->vr,
1307			nr->va,
1308			ax25_display_timer(&nr->t1timer) / HZ,
1309			nr->t1 / HZ,
1310			ax25_display_timer(&nr->t2timer) / HZ,
1311			nr->t2 / HZ,
1312			ax25_display_timer(&nr->t4timer) / HZ,
1313			nr->t4 / HZ,
1314			ax25_display_timer(&nr->idletimer) / (60 * HZ),
1315			nr->idle / (60 * HZ),
1316			nr->n2count,
1317			nr->n2,
1318			nr->window,
1319			sk_wmem_alloc_get(s),
1320			sk_rmem_alloc_get(s),
1321			s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : 0L);
1322
1323		bh_unlock_sock(s);
1324	}
1325	return 0;
1326}
1327
1328static const struct seq_operations nr_info_seqops = {
1329	.start = nr_info_start,
1330	.next = nr_info_next,
1331	.stop = nr_info_stop,
1332	.show = nr_info_show,
1333};
1334#endif	/* CONFIG_PROC_FS */
1335
1336static const struct net_proto_family nr_family_ops = {
1337	.family		=	PF_NETROM,
1338	.create		=	nr_create,
1339	.owner		=	THIS_MODULE,
1340};
1341
1342static const struct proto_ops nr_proto_ops = {
1343	.family		=	PF_NETROM,
1344	.owner		=	THIS_MODULE,
1345	.release	=	nr_release,
1346	.bind		=	nr_bind,
1347	.connect	=	nr_connect,
1348	.socketpair	=	sock_no_socketpair,
1349	.accept		=	nr_accept,
1350	.getname	=	nr_getname,
1351	.poll		=	datagram_poll,
1352	.ioctl		=	nr_ioctl,
1353	.gettstamp	=	sock_gettstamp,
1354	.listen		=	nr_listen,
1355	.shutdown	=	sock_no_shutdown,
1356	.setsockopt	=	nr_setsockopt,
1357	.getsockopt	=	nr_getsockopt,
1358	.sendmsg	=	nr_sendmsg,
1359	.recvmsg	=	nr_recvmsg,
1360	.mmap		=	sock_no_mmap,
1361	.sendpage	=	sock_no_sendpage,
1362};
1363
1364static struct notifier_block nr_dev_notifier = {
1365	.notifier_call	=	nr_device_event,
1366};
1367
1368static struct net_device **dev_nr;
1369
1370static struct ax25_protocol nr_pid = {
1371	.pid	= AX25_P_NETROM,
1372	.func	= nr_route_frame
1373};
1374
1375static struct ax25_linkfail nr_linkfail_notifier = {
1376	.func	= nr_link_failed,
1377};
1378
1379static int __init nr_proto_init(void)
1380{
1381	int i;
1382	int rc = proto_register(&nr_proto, 0);
1383
1384	if (rc)
1385		return rc;
1386
1387	if (nr_ndevs > 0x7fffffff/sizeof(struct net_device *)) {
1388		pr_err("NET/ROM: %s - nr_ndevs parameter too large\n",
1389		       __func__);
1390		rc = -EINVAL;
1391		goto unregister_proto;
1392	}
1393
1394	dev_nr = kcalloc(nr_ndevs, sizeof(struct net_device *), GFP_KERNEL);
1395	if (!dev_nr) {
1396		pr_err("NET/ROM: %s - unable to allocate device array\n",
1397		       __func__);
1398		rc = -ENOMEM;
1399		goto unregister_proto;
1400	}
1401
1402	for (i = 0; i < nr_ndevs; i++) {
1403		char name[IFNAMSIZ];
1404		struct net_device *dev;
1405
1406		sprintf(name, "nr%d", i);
1407		dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, nr_setup);
1408		if (!dev) {
1409			rc = -ENOMEM;
1410			goto fail;
1411		}
1412
1413		dev->base_addr = i;
1414		rc = register_netdev(dev);
1415		if (rc) {
1416			free_netdev(dev);
1417			goto fail;
1418		}
1419		nr_set_lockdep_key(dev);
1420		dev_nr[i] = dev;
1421	}
1422
1423	rc = sock_register(&nr_family_ops);
1424	if (rc)
1425		goto fail;
1426
1427	rc = register_netdevice_notifier(&nr_dev_notifier);
1428	if (rc)
1429		goto out_sock;
1430
1431	ax25_register_pid(&nr_pid);
1432	ax25_linkfail_register(&nr_linkfail_notifier);
1433
1434#ifdef CONFIG_SYSCTL
1435	rc = nr_register_sysctl();
1436	if (rc)
1437		goto out_sysctl;
1438#endif
1439
1440	nr_loopback_init();
1441
1442	rc = -ENOMEM;
1443	if (!proc_create_seq("nr", 0444, init_net.proc_net, &nr_info_seqops))
1444		goto proc_remove1;
1445	if (!proc_create_seq("nr_neigh", 0444, init_net.proc_net,
1446			     &nr_neigh_seqops))
1447		goto proc_remove2;
1448	if (!proc_create_seq("nr_nodes", 0444, init_net.proc_net,
1449			     &nr_node_seqops))
1450		goto proc_remove3;
1451
1452	return 0;
1453
1454proc_remove3:
1455	remove_proc_entry("nr_neigh", init_net.proc_net);
1456proc_remove2:
1457	remove_proc_entry("nr", init_net.proc_net);
1458proc_remove1:
1459
1460	nr_loopback_clear();
1461	nr_rt_free();
1462
1463#ifdef CONFIG_SYSCTL
1464	nr_unregister_sysctl();
1465out_sysctl:
1466#endif
1467	ax25_linkfail_release(&nr_linkfail_notifier);
1468	ax25_protocol_release(AX25_P_NETROM);
1469	unregister_netdevice_notifier(&nr_dev_notifier);
1470out_sock:
1471	sock_unregister(PF_NETROM);
1472fail:
1473	while (--i >= 0) {
1474		unregister_netdev(dev_nr[i]);
1475		free_netdev(dev_nr[i]);
1476	}
1477	kfree(dev_nr);
1478unregister_proto:
1479	proto_unregister(&nr_proto);
1480	return rc;
1481}
1482
1483module_init(nr_proto_init);
1484
1485module_param(nr_ndevs, int, 0);
1486MODULE_PARM_DESC(nr_ndevs, "number of NET/ROM devices");
1487
1488MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
1489MODULE_DESCRIPTION("The amateur radio NET/ROM network and transport layer protocol");
1490MODULE_LICENSE("GPL");
1491MODULE_ALIAS_NETPROTO(PF_NETROM);
1492
1493static void __exit nr_exit(void)
1494{
1495	int i;
1496
1497	remove_proc_entry("nr", init_net.proc_net);
1498	remove_proc_entry("nr_neigh", init_net.proc_net);
1499	remove_proc_entry("nr_nodes", init_net.proc_net);
1500	nr_loopback_clear();
1501
1502	nr_rt_free();
1503
1504#ifdef CONFIG_SYSCTL
1505	nr_unregister_sysctl();
1506#endif
1507
1508	ax25_linkfail_release(&nr_linkfail_notifier);
1509	ax25_protocol_release(AX25_P_NETROM);
1510
1511	unregister_netdevice_notifier(&nr_dev_notifier);
1512
1513	sock_unregister(PF_NETROM);
1514
1515	for (i = 0; i < nr_ndevs; i++) {
1516		struct net_device *dev = dev_nr[i];
1517		if (dev) {
1518			unregister_netdev(dev);
1519			free_netdev(dev);
1520		}
1521	}
1522
1523	kfree(dev_nr);
1524	proto_unregister(&nr_proto);
1525}
1526module_exit(nr_exit);