net/netrom/af_netrom.c

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