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  * 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  */
  72 static struct lock_class_key nr_netdev_xmit_lock_key;
  73 static struct lock_class_key nr_netdev_addr_lock_key;
  74
  75 static 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
  82 static 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  */
  91 static 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  */
 101 static 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  */
 115 static 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  */
 134 static 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  */
 145 static 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;
 157 found:
 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  */
 165 static 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;
 179 found:
 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  */
 187 static 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;
 203 found:
 204         spin_unlock_bh(&nr_list_lock);
 205         return s;
 206 }
 207
 208 /*
 209  *      Find next free circuit ID.
 210  */
 211 static 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  */
 236 void nr_destroy_socket(struct sock *);
 237
 238 /*
 239  *      Handler for deferred kills.
 240  */
 241 static 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  */
 257 void 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
 296 static int nr_setsockopt(struct socket *sock, int level, int optname,
 297         char __user *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 (get_user(opt, (unsigned int __user *)optval))
 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
 348 static 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
 398 static 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
 415 static struct proto nr_proto = {
 416         .name     = "NETROM",
 417         .owner    = THIS_MODULE,
 418         .obj_size = sizeof(struct nr_sock),
 419 };
 420
 421 static 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
 468 static 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
 513 static 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
 559 static 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
 630 static 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
 759 out_release:
 760         release_sock(sk);
 761
 762         return err;
 763 }
 764
 765 static 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
 822 out_release:
 823         release_sock(sk);
 824
 825         return err;
 826 }
 827
 828 static 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
 861 int 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
1032 static 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;
1136 out:
1137         release_sock(sk);
1138         return err;
1139 }
1140
1141 static 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
1197 static 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
1254 static void *nr_info_start(struct seq_file *seq, loff_t *pos)
1255 {
1256         spin_lock_bh(&nr_list_lock);
1257         return seq_hlist_start_head(&nr_list, *pos);
1258 }
1259
1260 static void *nr_info_next(struct seq_file *seq, void *v, loff_t *pos)
1261 {
1262         return seq_hlist_next(v, &nr_list, pos);
1263 }
1264
1265 static void nr_info_stop(struct seq_file *seq, void *v)
1266 {
1267         spin_unlock_bh(&nr_list_lock);
1268 }
1269
1270 static int nr_info_show(struct seq_file *seq, void *v)
1271 {
1272         struct sock *s = sk_entry(v);
1273         struct net_device *dev;
1274         struct nr_sock *nr;
1275         const char *devname;
1276         char buf[11];
1277
1278         if (v == SEQ_START_TOKEN)
1279                 seq_puts(seq,
1280 "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");
1281
1282         else {
1283
1284                 bh_lock_sock(s);
1285                 nr = nr_sk(s);
1286
1287                 if ((dev = nr->device) == NULL)
1288                         devname = "???";
1289                 else
1290                         devname = dev->name;
1291
1292                 seq_printf(seq, "%-9s ", ax2asc(buf, &nr->user_addr));
1293                 seq_printf(seq, "%-9s ", ax2asc(buf, &nr->dest_addr));
1294                 seq_printf(seq,
1295 "%-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",
1296                         ax2asc(buf, &nr->source_addr),
1297                         devname,
1298                         nr->my_index,
1299                         nr->my_id,
1300                         nr->your_index,
1301                         nr->your_id,
1302                         nr->state,
1303                         nr->vs,
1304                         nr->vr,
1305                         nr->va,
1306                         ax25_display_timer(&nr->t1timer) / HZ,
1307                         nr->t1 / HZ,
1308                         ax25_display_timer(&nr->t2timer) / HZ,
1309                         nr->t2 / HZ,
1310                         ax25_display_timer(&nr->t4timer) / HZ,
1311                         nr->t4 / HZ,
1312                         ax25_display_timer(&nr->idletimer) / (60 * HZ),
1313                         nr->idle / (60 * HZ),
1314                         nr->n2count,
1315                         nr->n2,
1316                         nr->window,
1317                         sk_wmem_alloc_get(s),
1318                         sk_rmem_alloc_get(s),
1319                         s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : 0L);
1320
1321                 bh_unlock_sock(s);
1322         }
1323         return 0;
1324 }
1325
1326 static const struct seq_operations nr_info_seqops = {
1327         .start = nr_info_start,
1328         .next = nr_info_next,
1329         .stop = nr_info_stop,
1330         .show = nr_info_show,
1331 };
1332 #endif  /* CONFIG_PROC_FS */
1333
1334 static const struct net_proto_family nr_family_ops = {
1335         .family         =       PF_NETROM,
1336         .create         =       nr_create,
1337         .owner          =       THIS_MODULE,
1338 };
1339
1340 static const struct proto_ops nr_proto_ops = {
1341         .family         =       PF_NETROM,
1342         .owner          =       THIS_MODULE,
1343         .release        =       nr_release,
1344         .bind           =       nr_bind,
1345         .connect        =       nr_connect,
1346         .socketpair     =       sock_no_socketpair,
1347         .accept         =       nr_accept,
1348         .getname        =       nr_getname,
1349         .poll           =       datagram_poll,
1350         .ioctl          =       nr_ioctl,
1351         .gettstamp      =       sock_gettstamp,
1352         .listen         =       nr_listen,
1353         .shutdown       =       sock_no_shutdown,
1354         .setsockopt     =       nr_setsockopt,
1355         .getsockopt     =       nr_getsockopt,
1356         .sendmsg        =       nr_sendmsg,
1357         .recvmsg        =       nr_recvmsg,
1358         .mmap           =       sock_no_mmap,
1359         .sendpage       =       sock_no_sendpage,
1360 };
1361
1362 static struct notifier_block nr_dev_notifier = {
1363         .notifier_call  =       nr_device_event,
1364 };
1365
1366 static struct net_device **dev_nr;
1367
1368 static struct ax25_protocol nr_pid = {
1369         .pid    = AX25_P_NETROM,
1370         .func   = nr_route_frame
1371 };
1372
1373 static struct ax25_linkfail nr_linkfail_notifier = {
1374         .func   = nr_link_failed,
1375 };
1376
1377 static int __init nr_proto_init(void)
1378 {
1379         int i;
1380         int rc = proto_register(&nr_proto, 0);
1381
1382         if (rc)
1383                 return rc;
1384
1385         if (nr_ndevs > 0x7fffffff/sizeof(struct net_device *)) {
1386                 pr_err("NET/ROM: %s - nr_ndevs parameter too large\n",
1387                        __func__);
1388                 rc = -EINVAL;
1389                 goto unregister_proto;
1390         }
1391
1392         dev_nr = kcalloc(nr_ndevs, sizeof(struct net_device *), GFP_KERNEL);
1393         if (!dev_nr) {
1394                 pr_err("NET/ROM: %s - unable to allocate device array\n",
1395                        __func__);
1396                 rc = -ENOMEM;
1397                 goto unregister_proto;
1398         }
1399
1400         for (i = 0; i < nr_ndevs; i++) {
1401                 char name[IFNAMSIZ];
1402                 struct net_device *dev;
1403
1404                 sprintf(name, "nr%d", i);
1405                 dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, nr_setup);
1406                 if (!dev) {
1407                         rc = -ENOMEM;
1408                         goto fail;
1409                 }
1410
1411                 dev->base_addr = i;
1412                 rc = register_netdev(dev);
1413                 if (rc) {
1414                         free_netdev(dev);
1415                         goto fail;
1416                 }
1417                 nr_set_lockdep_key(dev);
1418                 dev_nr[i] = dev;
1419         }
1420
1421         rc = sock_register(&nr_family_ops);
1422         if (rc)
1423                 goto fail;
1424
1425         rc = register_netdevice_notifier(&nr_dev_notifier);
1426         if (rc)
1427                 goto out_sock;
1428
1429         ax25_register_pid(&nr_pid);
1430         ax25_linkfail_register(&nr_linkfail_notifier);
1431
1432 #ifdef CONFIG_SYSCTL
1433         rc = nr_register_sysctl();
1434         if (rc)
1435                 goto out_sysctl;
1436 #endif
1437
1438         nr_loopback_init();
1439
1440         rc = -ENOMEM;
1441         if (!proc_create_seq("nr", 0444, init_net.proc_net, &nr_info_seqops))
1442                 goto proc_remove1;
1443         if (!proc_create_seq("nr_neigh", 0444, init_net.proc_net,
1444                              &nr_neigh_seqops))
1445                 goto proc_remove2;
1446         if (!proc_create_seq("nr_nodes", 0444, init_net.proc_net,
1447                              &nr_node_seqops))
1448                 goto proc_remove3;
1449
1450         return 0;
1451
1452 proc_remove3:
1453         remove_proc_entry("nr_neigh", init_net.proc_net);
1454 proc_remove2:
1455         remove_proc_entry("nr", init_net.proc_net);
1456 proc_remove1:
1457
1458         nr_loopback_clear();
1459         nr_rt_free();
1460
1461 #ifdef CONFIG_SYSCTL
1462         nr_unregister_sysctl();
1463 out_sysctl:
1464 #endif
1465         ax25_linkfail_release(&nr_linkfail_notifier);
1466         ax25_protocol_release(AX25_P_NETROM);
1467         unregister_netdevice_notifier(&nr_dev_notifier);
1468 out_sock:
1469         sock_unregister(PF_NETROM);
1470 fail:
1471         while (--i >= 0) {
1472                 unregister_netdev(dev_nr[i]);
1473                 free_netdev(dev_nr[i]);
1474         }
1475         kfree(dev_nr);
1476 unregister_proto:
1477         proto_unregister(&nr_proto);
1478         return rc;
1479 }
1480
1481 module_init(nr_proto_init);
1482
1483 module_param(nr_ndevs, int, 0);
1484 MODULE_PARM_DESC(nr_ndevs, "number of NET/ROM devices");
1485
1486 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
1487 MODULE_DESCRIPTION("The amateur radio NET/ROM network and transport layer protocol");
1488 MODULE_LICENSE("GPL");
1489 MODULE_ALIAS_NETPROTO(PF_NETROM);
1490
1491 static void __exit nr_exit(void)
1492 {
1493         int i;
1494
1495         remove_proc_entry("nr", init_net.proc_net);
1496         remove_proc_entry("nr_neigh", init_net.proc_net);
1497         remove_proc_entry("nr_nodes", init_net.proc_net);
1498         nr_loopback_clear();
1499
1500         nr_rt_free();
1501
1502 #ifdef CONFIG_SYSCTL
1503         nr_unregister_sysctl();
1504 #endif
1505
1506         ax25_linkfail_release(&nr_linkfail_notifier);
1507         ax25_protocol_release(AX25_P_NETROM);
1508
1509         unregister_netdevice_notifier(&nr_dev_notifier);
1510
1511         sock_unregister(PF_NETROM);
1512
1513         for (i = 0; i < nr_ndevs; i++) {
1514                 struct net_device *dev = dev_nr[i];
1515                 if (dev) {
1516                         unregister_netdev(dev);
1517                         free_netdev(dev);
1518                 }
1519         }
1520
1521         kfree(dev_nr);
1522         proto_unregister(&nr_proto);
1523 }
1524 module_exit(nr_exit);