Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  *
0004  * Copyright Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
0005  * Copyright Alan Cox GW4PTS (alan@lxorguk.ukuu.org.uk)
0006  * Copyright Darryl Miles G7LED (dlm@g7led.demon.co.uk)
0007  */
0008 #include <linux/module.h>
0009 #include <linux/moduleparam.h>
0010 #include <linux/capability.h>
0011 #include <linux/errno.h>
0012 #include <linux/types.h>
0013 #include <linux/socket.h>
0014 #include <linux/in.h>
0015 #include <linux/slab.h>
0016 #include <linux/kernel.h>
0017 #include <linux/sched/signal.h>
0018 #include <linux/timer.h>
0019 #include <linux/string.h>
0020 #include <linux/sockios.h>
0021 #include <linux/net.h>
0022 #include <linux/stat.h>
0023 #include <net/ax25.h>
0024 #include <linux/inet.h>
0025 #include <linux/netdevice.h>
0026 #include <linux/if_arp.h>
0027 #include <linux/skbuff.h>
0028 #include <net/net_namespace.h>
0029 #include <net/sock.h>
0030 #include <linux/uaccess.h>
0031 #include <linux/fcntl.h>
0032 #include <linux/termios.h>  /* For TIOCINQ/OUTQ */
0033 #include <linux/mm.h>
0034 #include <linux/interrupt.h>
0035 #include <linux/notifier.h>
0036 #include <net/netrom.h>
0037 #include <linux/proc_fs.h>
0038 #include <linux/seq_file.h>
0039 #include <net/ip.h>
0040 #include <net/tcp_states.h>
0041 #include <net/arp.h>
0042 #include <linux/init.h>
0043 
0044 static int nr_ndevs = 4;
0045 
0046 int sysctl_netrom_default_path_quality            = NR_DEFAULT_QUAL;
0047 int sysctl_netrom_obsolescence_count_initialiser  = NR_DEFAULT_OBS;
0048 int sysctl_netrom_network_ttl_initialiser         = NR_DEFAULT_TTL;
0049 int sysctl_netrom_transport_timeout               = NR_DEFAULT_T1;
0050 int sysctl_netrom_transport_maximum_tries         = NR_DEFAULT_N2;
0051 int sysctl_netrom_transport_acknowledge_delay     = NR_DEFAULT_T2;
0052 int sysctl_netrom_transport_busy_delay            = NR_DEFAULT_T4;
0053 int sysctl_netrom_transport_requested_window_size = NR_DEFAULT_WINDOW;
0054 int sysctl_netrom_transport_no_activity_timeout   = NR_DEFAULT_IDLE;
0055 int sysctl_netrom_routing_control                 = NR_DEFAULT_ROUTING;
0056 int sysctl_netrom_link_fails_count                = NR_DEFAULT_FAILS;
0057 int sysctl_netrom_reset_circuit                   = NR_DEFAULT_RESET;
0058 
0059 static unsigned short circuit = 0x101;
0060 
0061 static HLIST_HEAD(nr_list);
0062 static DEFINE_SPINLOCK(nr_list_lock);
0063 
0064 static const struct proto_ops nr_proto_ops;
0065 
0066 /*
0067  * NETROM network devices are virtual network devices encapsulating NETROM
0068  * frames into AX.25 which will be sent through an AX.25 device, so form a
0069  * special "super class" of normal net devices; split their locks off into a
0070  * separate class since they always nest.
0071  */
0072 static struct lock_class_key nr_netdev_xmit_lock_key;
0073 static struct lock_class_key nr_netdev_addr_lock_key;
0074 
0075 static void nr_set_lockdep_one(struct net_device *dev,
0076                    struct netdev_queue *txq,
0077                    void *_unused)
0078 {
0079     lockdep_set_class(&txq->_xmit_lock, &nr_netdev_xmit_lock_key);
0080 }
0081 
0082 static void nr_set_lockdep_key(struct net_device *dev)
0083 {
0084     lockdep_set_class(&dev->addr_list_lock, &nr_netdev_addr_lock_key);
0085     netdev_for_each_tx_queue(dev, nr_set_lockdep_one, NULL);
0086 }
0087 
0088 /*
0089  *  Socket removal during an interrupt is now safe.
0090  */
0091 static void nr_remove_socket(struct sock *sk)
0092 {
0093     spin_lock_bh(&nr_list_lock);
0094     sk_del_node_init(sk);
0095     spin_unlock_bh(&nr_list_lock);
0096 }
0097 
0098 /*
0099  *  Kill all bound sockets on a dropped device.
0100  */
0101 static void nr_kill_by_device(struct net_device *dev)
0102 {
0103     struct sock *s;
0104 
0105     spin_lock_bh(&nr_list_lock);
0106     sk_for_each(s, &nr_list)
0107         if (nr_sk(s)->device == dev)
0108             nr_disconnect(s, ENETUNREACH);
0109     spin_unlock_bh(&nr_list_lock);
0110 }
0111 
0112 /*
0113  *  Handle device status changes.
0114  */
0115 static int nr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
0116 {
0117     struct net_device *dev = netdev_notifier_info_to_dev(ptr);
0118 
0119     if (!net_eq(dev_net(dev), &init_net))
0120         return NOTIFY_DONE;
0121 
0122     if (event != NETDEV_DOWN)
0123         return NOTIFY_DONE;
0124 
0125     nr_kill_by_device(dev);
0126     nr_rt_device_down(dev);
0127 
0128     return NOTIFY_DONE;
0129 }
0130 
0131 /*
0132  *  Add a socket to the bound sockets list.
0133  */
0134 static void nr_insert_socket(struct sock *sk)
0135 {
0136     spin_lock_bh(&nr_list_lock);
0137     sk_add_node(sk, &nr_list);
0138     spin_unlock_bh(&nr_list_lock);
0139 }
0140 
0141 /*
0142  *  Find a socket that wants to accept the Connect Request we just
0143  *  received.
0144  */
0145 static struct sock *nr_find_listener(ax25_address *addr)
0146 {
0147     struct sock *s;
0148 
0149     spin_lock_bh(&nr_list_lock);
0150     sk_for_each(s, &nr_list)
0151         if (!ax25cmp(&nr_sk(s)->source_addr, addr) &&
0152             s->sk_state == TCP_LISTEN) {
0153             sock_hold(s);
0154             goto found;
0155         }
0156     s = NULL;
0157 found:
0158     spin_unlock_bh(&nr_list_lock);
0159     return s;
0160 }
0161 
0162 /*
0163  *  Find a connected NET/ROM socket given my circuit IDs.
0164  */
0165 static struct sock *nr_find_socket(unsigned char index, unsigned char id)
0166 {
0167     struct sock *s;
0168 
0169     spin_lock_bh(&nr_list_lock);
0170     sk_for_each(s, &nr_list) {
0171         struct nr_sock *nr = nr_sk(s);
0172 
0173         if (nr->my_index == index && nr->my_id == id) {
0174             sock_hold(s);
0175             goto found;
0176         }
0177     }
0178     s = NULL;
0179 found:
0180     spin_unlock_bh(&nr_list_lock);
0181     return s;
0182 }
0183 
0184 /*
0185  *  Find a connected NET/ROM socket given their circuit IDs.
0186  */
0187 static struct sock *nr_find_peer(unsigned char index, unsigned char id,
0188     ax25_address *dest)
0189 {
0190     struct sock *s;
0191 
0192     spin_lock_bh(&nr_list_lock);
0193     sk_for_each(s, &nr_list) {
0194         struct nr_sock *nr = nr_sk(s);
0195 
0196         if (nr->your_index == index && nr->your_id == id &&
0197             !ax25cmp(&nr->dest_addr, dest)) {
0198             sock_hold(s);
0199             goto found;
0200         }
0201     }
0202     s = NULL;
0203 found:
0204     spin_unlock_bh(&nr_list_lock);
0205     return s;
0206 }
0207 
0208 /*
0209  *  Find next free circuit ID.
0210  */
0211 static unsigned short nr_find_next_circuit(void)
0212 {
0213     unsigned short id = circuit;
0214     unsigned char i, j;
0215     struct sock *sk;
0216 
0217     for (;;) {
0218         i = id / 256;
0219         j = id % 256;
0220 
0221         if (i != 0 && j != 0) {
0222             if ((sk=nr_find_socket(i, j)) == NULL)
0223                 break;
0224             sock_put(sk);
0225         }
0226 
0227         id++;
0228     }
0229 
0230     return id;
0231 }
0232 
0233 /*
0234  *  Deferred destroy.
0235  */
0236 void nr_destroy_socket(struct sock *);
0237 
0238 /*
0239  *  Handler for deferred kills.
0240  */
0241 static void nr_destroy_timer(struct timer_list *t)
0242 {
0243     struct sock *sk = from_timer(sk, t, sk_timer);
0244     bh_lock_sock(sk);
0245     sock_hold(sk);
0246     nr_destroy_socket(sk);
0247     bh_unlock_sock(sk);
0248     sock_put(sk);
0249 }
0250 
0251 /*
0252  *  This is called from user mode and the timers. Thus it protects itself
0253  *  against interrupt users but doesn't worry about being called during
0254  *  work. Once it is removed from the queue no interrupt or bottom half
0255  *  will touch it and we are (fairly 8-) ) safe.
0256  */
0257 void nr_destroy_socket(struct sock *sk)
0258 {
0259     struct sk_buff *skb;
0260 
0261     nr_remove_socket(sk);
0262 
0263     nr_stop_heartbeat(sk);
0264     nr_stop_t1timer(sk);
0265     nr_stop_t2timer(sk);
0266     nr_stop_t4timer(sk);
0267     nr_stop_idletimer(sk);
0268 
0269     nr_clear_queues(sk);        /* Flush the queues */
0270 
0271     while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL) {
0272         if (skb->sk != sk) { /* A pending connection */
0273             /* Queue the unaccepted socket for death */
0274             sock_set_flag(skb->sk, SOCK_DEAD);
0275             nr_start_heartbeat(skb->sk);
0276             nr_sk(skb->sk)->state = NR_STATE_0;
0277         }
0278 
0279         kfree_skb(skb);
0280     }
0281 
0282     if (sk_has_allocations(sk)) {
0283         /* Defer: outstanding buffers */
0284         sk->sk_timer.function = nr_destroy_timer;
0285         sk->sk_timer.expires  = jiffies + 2 * HZ;
0286         add_timer(&sk->sk_timer);
0287     } else
0288         sock_put(sk);
0289 }
0290 
0291 /*
0292  *  Handling for system calls applied via the various interfaces to a
0293  *  NET/ROM socket object.
0294  */
0295 
0296 static int nr_setsockopt(struct socket *sock, int level, int optname,
0297         sockptr_t optval, unsigned int optlen)
0298 {
0299     struct sock *sk = sock->sk;
0300     struct nr_sock *nr = nr_sk(sk);
0301     unsigned int opt;
0302 
0303     if (level != SOL_NETROM)
0304         return -ENOPROTOOPT;
0305 
0306     if (optlen < sizeof(unsigned int))
0307         return -EINVAL;
0308 
0309     if (copy_from_sockptr(&opt, optval, sizeof(opt)))
0310         return -EFAULT;
0311 
0312     switch (optname) {
0313     case NETROM_T1:
0314         if (opt < 1 || opt > UINT_MAX / HZ)
0315             return -EINVAL;
0316         nr->t1 = opt * HZ;
0317         return 0;
0318 
0319     case NETROM_T2:
0320         if (opt < 1 || opt > UINT_MAX / HZ)
0321             return -EINVAL;
0322         nr->t2 = opt * HZ;
0323         return 0;
0324 
0325     case NETROM_N2:
0326         if (opt < 1 || opt > 31)
0327             return -EINVAL;
0328         nr->n2 = opt;
0329         return 0;
0330 
0331     case NETROM_T4:
0332         if (opt < 1 || opt > UINT_MAX / HZ)
0333             return -EINVAL;
0334         nr->t4 = opt * HZ;
0335         return 0;
0336 
0337     case NETROM_IDLE:
0338         if (opt > UINT_MAX / (60 * HZ))
0339             return -EINVAL;
0340         nr->idle = opt * 60 * HZ;
0341         return 0;
0342 
0343     default:
0344         return -ENOPROTOOPT;
0345     }
0346 }
0347 
0348 static int nr_getsockopt(struct socket *sock, int level, int optname,
0349     char __user *optval, int __user *optlen)
0350 {
0351     struct sock *sk = sock->sk;
0352     struct nr_sock *nr = nr_sk(sk);
0353     int val = 0;
0354     int len;
0355 
0356     if (level != SOL_NETROM)
0357         return -ENOPROTOOPT;
0358 
0359     if (get_user(len, optlen))
0360         return -EFAULT;
0361 
0362     if (len < 0)
0363         return -EINVAL;
0364 
0365     switch (optname) {
0366     case NETROM_T1:
0367         val = nr->t1 / HZ;
0368         break;
0369 
0370     case NETROM_T2:
0371         val = nr->t2 / HZ;
0372         break;
0373 
0374     case NETROM_N2:
0375         val = nr->n2;
0376         break;
0377 
0378     case NETROM_T4:
0379         val = nr->t4 / HZ;
0380         break;
0381 
0382     case NETROM_IDLE:
0383         val = nr->idle / (60 * HZ);
0384         break;
0385 
0386     default:
0387         return -ENOPROTOOPT;
0388     }
0389 
0390     len = min_t(unsigned int, len, sizeof(int));
0391 
0392     if (put_user(len, optlen))
0393         return -EFAULT;
0394 
0395     return copy_to_user(optval, &val, len) ? -EFAULT : 0;
0396 }
0397 
0398 static int nr_listen(struct socket *sock, int backlog)
0399 {
0400     struct sock *sk = sock->sk;
0401 
0402     lock_sock(sk);
0403     if (sk->sk_state != TCP_LISTEN) {
0404         memset(&nr_sk(sk)->user_addr, 0, AX25_ADDR_LEN);
0405         sk->sk_max_ack_backlog = backlog;
0406         sk->sk_state           = TCP_LISTEN;
0407         release_sock(sk);
0408         return 0;
0409     }
0410     release_sock(sk);
0411 
0412     return -EOPNOTSUPP;
0413 }
0414 
0415 static struct proto nr_proto = {
0416     .name     = "NETROM",
0417     .owner    = THIS_MODULE,
0418     .obj_size = sizeof(struct nr_sock),
0419 };
0420 
0421 static int nr_create(struct net *net, struct socket *sock, int protocol,
0422              int kern)
0423 {
0424     struct sock *sk;
0425     struct nr_sock *nr;
0426 
0427     if (!net_eq(net, &init_net))
0428         return -EAFNOSUPPORT;
0429 
0430     if (sock->type != SOCK_SEQPACKET || protocol != 0)
0431         return -ESOCKTNOSUPPORT;
0432 
0433     sk = sk_alloc(net, PF_NETROM, GFP_ATOMIC, &nr_proto, kern);
0434     if (sk  == NULL)
0435         return -ENOMEM;
0436 
0437     nr = nr_sk(sk);
0438 
0439     sock_init_data(sock, sk);
0440 
0441     sock->ops    = &nr_proto_ops;
0442     sk->sk_protocol = protocol;
0443 
0444     skb_queue_head_init(&nr->ack_queue);
0445     skb_queue_head_init(&nr->reseq_queue);
0446     skb_queue_head_init(&nr->frag_queue);
0447 
0448     nr_init_timers(sk);
0449 
0450     nr->t1     =
0451         msecs_to_jiffies(sysctl_netrom_transport_timeout);
0452     nr->t2     =
0453         msecs_to_jiffies(sysctl_netrom_transport_acknowledge_delay);
0454     nr->n2     =
0455         msecs_to_jiffies(sysctl_netrom_transport_maximum_tries);
0456     nr->t4     =
0457         msecs_to_jiffies(sysctl_netrom_transport_busy_delay);
0458     nr->idle   =
0459         msecs_to_jiffies(sysctl_netrom_transport_no_activity_timeout);
0460     nr->window = sysctl_netrom_transport_requested_window_size;
0461 
0462     nr->bpqext = 1;
0463     nr->state  = NR_STATE_0;
0464 
0465     return 0;
0466 }
0467 
0468 static struct sock *nr_make_new(struct sock *osk)
0469 {
0470     struct sock *sk;
0471     struct nr_sock *nr, *onr;
0472 
0473     if (osk->sk_type != SOCK_SEQPACKET)
0474         return NULL;
0475 
0476     sk = sk_alloc(sock_net(osk), PF_NETROM, GFP_ATOMIC, osk->sk_prot, 0);
0477     if (sk == NULL)
0478         return NULL;
0479 
0480     nr = nr_sk(sk);
0481 
0482     sock_init_data(NULL, sk);
0483 
0484     sk->sk_type     = osk->sk_type;
0485     sk->sk_priority = osk->sk_priority;
0486     sk->sk_protocol = osk->sk_protocol;
0487     sk->sk_rcvbuf   = osk->sk_rcvbuf;
0488     sk->sk_sndbuf   = osk->sk_sndbuf;
0489     sk->sk_state    = TCP_ESTABLISHED;
0490     sock_copy_flags(sk, osk);
0491 
0492     skb_queue_head_init(&nr->ack_queue);
0493     skb_queue_head_init(&nr->reseq_queue);
0494     skb_queue_head_init(&nr->frag_queue);
0495 
0496     nr_init_timers(sk);
0497 
0498     onr = nr_sk(osk);
0499 
0500     nr->t1      = onr->t1;
0501     nr->t2      = onr->t2;
0502     nr->n2      = onr->n2;
0503     nr->t4      = onr->t4;
0504     nr->idle    = onr->idle;
0505     nr->window  = onr->window;
0506 
0507     nr->device  = onr->device;
0508     nr->bpqext  = onr->bpqext;
0509 
0510     return sk;
0511 }
0512 
0513 static int nr_release(struct socket *sock)
0514 {
0515     struct sock *sk = sock->sk;
0516     struct nr_sock *nr;
0517 
0518     if (sk == NULL) return 0;
0519 
0520     sock_hold(sk);
0521     sock_orphan(sk);
0522     lock_sock(sk);
0523     nr = nr_sk(sk);
0524 
0525     switch (nr->state) {
0526     case NR_STATE_0:
0527     case NR_STATE_1:
0528     case NR_STATE_2:
0529         nr_disconnect(sk, 0);
0530         nr_destroy_socket(sk);
0531         break;
0532 
0533     case NR_STATE_3:
0534         nr_clear_queues(sk);
0535         nr->n2count = 0;
0536         nr_write_internal(sk, NR_DISCREQ);
0537         nr_start_t1timer(sk);
0538         nr_stop_t2timer(sk);
0539         nr_stop_t4timer(sk);
0540         nr_stop_idletimer(sk);
0541         nr->state    = NR_STATE_2;
0542         sk->sk_state    = TCP_CLOSE;
0543         sk->sk_shutdown |= SEND_SHUTDOWN;
0544         sk->sk_state_change(sk);
0545         sock_set_flag(sk, SOCK_DESTROY);
0546         break;
0547 
0548     default:
0549         break;
0550     }
0551 
0552     sock->sk   = NULL;
0553     release_sock(sk);
0554     sock_put(sk);
0555 
0556     return 0;
0557 }
0558 
0559 static int nr_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
0560 {
0561     struct sock *sk = sock->sk;
0562     struct nr_sock *nr = nr_sk(sk);
0563     struct full_sockaddr_ax25 *addr = (struct full_sockaddr_ax25 *)uaddr;
0564     struct net_device *dev;
0565     ax25_uid_assoc *user;
0566     ax25_address *source;
0567 
0568     lock_sock(sk);
0569     if (!sock_flag(sk, SOCK_ZAPPED)) {
0570         release_sock(sk);
0571         return -EINVAL;
0572     }
0573     if (addr_len < sizeof(struct sockaddr_ax25) || addr_len > sizeof(struct full_sockaddr_ax25)) {
0574         release_sock(sk);
0575         return -EINVAL;
0576     }
0577     if (addr_len < (addr->fsa_ax25.sax25_ndigis * sizeof(ax25_address) + sizeof(struct sockaddr_ax25))) {
0578         release_sock(sk);
0579         return -EINVAL;
0580     }
0581     if (addr->fsa_ax25.sax25_family != AF_NETROM) {
0582         release_sock(sk);
0583         return -EINVAL;
0584     }
0585     if ((dev = nr_dev_get(&addr->fsa_ax25.sax25_call)) == NULL) {
0586         release_sock(sk);
0587         return -EADDRNOTAVAIL;
0588     }
0589 
0590     /*
0591      * Only the super user can set an arbitrary user callsign.
0592      */
0593     if (addr->fsa_ax25.sax25_ndigis == 1) {
0594         if (!capable(CAP_NET_BIND_SERVICE)) {
0595             dev_put(dev);
0596             release_sock(sk);
0597             return -EPERM;
0598         }
0599         nr->user_addr   = addr->fsa_digipeater[0];
0600         nr->source_addr = addr->fsa_ax25.sax25_call;
0601     } else {
0602         source = &addr->fsa_ax25.sax25_call;
0603 
0604         user = ax25_findbyuid(current_euid());
0605         if (user) {
0606             nr->user_addr   = user->call;
0607             ax25_uid_put(user);
0608         } else {
0609             if (ax25_uid_policy && !capable(CAP_NET_BIND_SERVICE)) {
0610                 release_sock(sk);
0611                 dev_put(dev);
0612                 return -EPERM;
0613             }
0614             nr->user_addr   = *source;
0615         }
0616 
0617         nr->source_addr = *source;
0618     }
0619 
0620     nr->device = dev;
0621     nr_insert_socket(sk);
0622 
0623     sock_reset_flag(sk, SOCK_ZAPPED);
0624     dev_put(dev);
0625     release_sock(sk);
0626 
0627     return 0;
0628 }
0629 
0630 static int nr_connect(struct socket *sock, struct sockaddr *uaddr,
0631     int addr_len, int flags)
0632 {
0633     struct sock *sk = sock->sk;
0634     struct nr_sock *nr = nr_sk(sk);
0635     struct sockaddr_ax25 *addr = (struct sockaddr_ax25 *)uaddr;
0636     const ax25_address *source = NULL;
0637     ax25_uid_assoc *user;
0638     struct net_device *dev;
0639     int err = 0;
0640 
0641     lock_sock(sk);
0642     if (sk->sk_state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
0643         sock->state = SS_CONNECTED;
0644         goto out_release;   /* Connect completed during a ERESTARTSYS event */
0645     }
0646 
0647     if (sk->sk_state == TCP_CLOSE && sock->state == SS_CONNECTING) {
0648         sock->state = SS_UNCONNECTED;
0649         err = -ECONNREFUSED;
0650         goto out_release;
0651     }
0652 
0653     if (sk->sk_state == TCP_ESTABLISHED) {
0654         err = -EISCONN; /* No reconnect on a seqpacket socket */
0655         goto out_release;
0656     }
0657 
0658     sk->sk_state   = TCP_CLOSE;
0659     sock->state = SS_UNCONNECTED;
0660 
0661     if (addr_len != sizeof(struct sockaddr_ax25) && addr_len != sizeof(struct full_sockaddr_ax25)) {
0662         err = -EINVAL;
0663         goto out_release;
0664     }
0665     if (addr->sax25_family != AF_NETROM) {
0666         err = -EINVAL;
0667         goto out_release;
0668     }
0669     if (sock_flag(sk, SOCK_ZAPPED)) {   /* Must bind first - autobinding in this may or may not work */
0670         sock_reset_flag(sk, SOCK_ZAPPED);
0671 
0672         if ((dev = nr_dev_first()) == NULL) {
0673             err = -ENETUNREACH;
0674             goto out_release;
0675         }
0676         source = (const ax25_address *)dev->dev_addr;
0677 
0678         user = ax25_findbyuid(current_euid());
0679         if (user) {
0680             nr->user_addr   = user->call;
0681             ax25_uid_put(user);
0682         } else {
0683             if (ax25_uid_policy && !capable(CAP_NET_ADMIN)) {
0684                 dev_put(dev);
0685                 err = -EPERM;
0686                 goto out_release;
0687             }
0688             nr->user_addr   = *source;
0689         }
0690 
0691         nr->source_addr = *source;
0692         nr->device      = dev;
0693 
0694         dev_put(dev);
0695         nr_insert_socket(sk);       /* Finish the bind */
0696     }
0697 
0698     nr->dest_addr = addr->sax25_call;
0699 
0700     release_sock(sk);
0701     circuit = nr_find_next_circuit();
0702     lock_sock(sk);
0703 
0704     nr->my_index = circuit / 256;
0705     nr->my_id    = circuit % 256;
0706 
0707     circuit++;
0708 
0709     /* Move to connecting socket, start sending Connect Requests */
0710     sock->state  = SS_CONNECTING;
0711     sk->sk_state = TCP_SYN_SENT;
0712 
0713     nr_establish_data_link(sk);
0714 
0715     nr->state = NR_STATE_1;
0716 
0717     nr_start_heartbeat(sk);
0718 
0719     /* Now the loop */
0720     if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK)) {
0721         err = -EINPROGRESS;
0722         goto out_release;
0723     }
0724 
0725     /*
0726      * A Connect Ack with Choke or timeout or failed routing will go to
0727      * closed.
0728      */
0729     if (sk->sk_state == TCP_SYN_SENT) {
0730         DEFINE_WAIT(wait);
0731 
0732         for (;;) {
0733             prepare_to_wait(sk_sleep(sk), &wait,
0734                     TASK_INTERRUPTIBLE);
0735             if (sk->sk_state != TCP_SYN_SENT)
0736                 break;
0737             if (!signal_pending(current)) {
0738                 release_sock(sk);
0739                 schedule();
0740                 lock_sock(sk);
0741                 continue;
0742             }
0743             err = -ERESTARTSYS;
0744             break;
0745         }
0746         finish_wait(sk_sleep(sk), &wait);
0747         if (err)
0748             goto out_release;
0749     }
0750 
0751     if (sk->sk_state != TCP_ESTABLISHED) {
0752         sock->state = SS_UNCONNECTED;
0753         err = sock_error(sk);   /* Always set at this point */
0754         goto out_release;
0755     }
0756 
0757     sock->state = SS_CONNECTED;
0758 
0759 out_release:
0760     release_sock(sk);
0761 
0762     return err;
0763 }
0764 
0765 static int nr_accept(struct socket *sock, struct socket *newsock, int flags,
0766              bool kern)
0767 {
0768     struct sk_buff *skb;
0769     struct sock *newsk;
0770     DEFINE_WAIT(wait);
0771     struct sock *sk;
0772     int err = 0;
0773 
0774     if ((sk = sock->sk) == NULL)
0775         return -EINVAL;
0776 
0777     lock_sock(sk);
0778     if (sk->sk_type != SOCK_SEQPACKET) {
0779         err = -EOPNOTSUPP;
0780         goto out_release;
0781     }
0782 
0783     if (sk->sk_state != TCP_LISTEN) {
0784         err = -EINVAL;
0785         goto out_release;
0786     }
0787 
0788     /*
0789      *  The write queue this time is holding sockets ready to use
0790      *  hooked into the SABM we saved
0791      */
0792     for (;;) {
0793         prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
0794         skb = skb_dequeue(&sk->sk_receive_queue);
0795         if (skb)
0796             break;
0797 
0798         if (flags & O_NONBLOCK) {
0799             err = -EWOULDBLOCK;
0800             break;
0801         }
0802         if (!signal_pending(current)) {
0803             release_sock(sk);
0804             schedule();
0805             lock_sock(sk);
0806             continue;
0807         }
0808         err = -ERESTARTSYS;
0809         break;
0810     }
0811     finish_wait(sk_sleep(sk), &wait);
0812     if (err)
0813         goto out_release;
0814 
0815     newsk = skb->sk;
0816     sock_graft(newsk, newsock);
0817 
0818     /* Now attach up the new socket */
0819     kfree_skb(skb);
0820     sk_acceptq_removed(sk);
0821 
0822 out_release:
0823     release_sock(sk);
0824 
0825     return err;
0826 }
0827 
0828 static int nr_getname(struct socket *sock, struct sockaddr *uaddr,
0829     int peer)
0830 {
0831     struct full_sockaddr_ax25 *sax = (struct full_sockaddr_ax25 *)uaddr;
0832     struct sock *sk = sock->sk;
0833     struct nr_sock *nr = nr_sk(sk);
0834     int uaddr_len;
0835 
0836     memset(&sax->fsa_ax25, 0, sizeof(struct sockaddr_ax25));
0837 
0838     lock_sock(sk);
0839     if (peer != 0) {
0840         if (sk->sk_state != TCP_ESTABLISHED) {
0841             release_sock(sk);
0842             return -ENOTCONN;
0843         }
0844         sax->fsa_ax25.sax25_family = AF_NETROM;
0845         sax->fsa_ax25.sax25_ndigis = 1;
0846         sax->fsa_ax25.sax25_call   = nr->user_addr;
0847         memset(sax->fsa_digipeater, 0, sizeof(sax->fsa_digipeater));
0848         sax->fsa_digipeater[0]     = nr->dest_addr;
0849         uaddr_len = sizeof(struct full_sockaddr_ax25);
0850     } else {
0851         sax->fsa_ax25.sax25_family = AF_NETROM;
0852         sax->fsa_ax25.sax25_ndigis = 0;
0853         sax->fsa_ax25.sax25_call   = nr->source_addr;
0854         uaddr_len = sizeof(struct sockaddr_ax25);
0855     }
0856     release_sock(sk);
0857 
0858     return uaddr_len;
0859 }
0860 
0861 int nr_rx_frame(struct sk_buff *skb, struct net_device *dev)
0862 {
0863     struct sock *sk;
0864     struct sock *make;
0865     struct nr_sock *nr_make;
0866     ax25_address *src, *dest, *user;
0867     unsigned short circuit_index, circuit_id;
0868     unsigned short peer_circuit_index, peer_circuit_id;
0869     unsigned short frametype, flags, window, timeout;
0870     int ret;
0871 
0872     skb_orphan(skb);
0873 
0874     /*
0875      *  skb->data points to the netrom frame start
0876      */
0877 
0878     src  = (ax25_address *)(skb->data + 0);
0879     dest = (ax25_address *)(skb->data + 7);
0880 
0881     circuit_index      = skb->data[15];
0882     circuit_id         = skb->data[16];
0883     peer_circuit_index = skb->data[17];
0884     peer_circuit_id    = skb->data[18];
0885     frametype          = skb->data[19] & 0x0F;
0886     flags              = skb->data[19] & 0xF0;
0887 
0888     /*
0889      * Check for an incoming IP over NET/ROM frame.
0890      */
0891     if (frametype == NR_PROTOEXT &&
0892         circuit_index == NR_PROTO_IP && circuit_id == NR_PROTO_IP) {
0893         skb_pull(skb, NR_NETWORK_LEN + NR_TRANSPORT_LEN);
0894         skb_reset_transport_header(skb);
0895 
0896         return nr_rx_ip(skb, dev);
0897     }
0898 
0899     /*
0900      * Find an existing socket connection, based on circuit ID, if it's
0901      * a Connect Request base it on their circuit ID.
0902      *
0903      * Circuit ID 0/0 is not valid but it could still be a "reset" for a
0904      * circuit that no longer exists at the other end ...
0905      */
0906 
0907     sk = NULL;
0908 
0909     if (circuit_index == 0 && circuit_id == 0) {
0910         if (frametype == NR_CONNACK && flags == NR_CHOKE_FLAG)
0911             sk = nr_find_peer(peer_circuit_index, peer_circuit_id, src);
0912     } else {
0913         if (frametype == NR_CONNREQ)
0914             sk = nr_find_peer(circuit_index, circuit_id, src);
0915         else
0916             sk = nr_find_socket(circuit_index, circuit_id);
0917     }
0918 
0919     if (sk != NULL) {
0920         bh_lock_sock(sk);
0921         skb_reset_transport_header(skb);
0922 
0923         if (frametype == NR_CONNACK && skb->len == 22)
0924             nr_sk(sk)->bpqext = 1;
0925         else
0926             nr_sk(sk)->bpqext = 0;
0927 
0928         ret = nr_process_rx_frame(sk, skb);
0929         bh_unlock_sock(sk);
0930         sock_put(sk);
0931         return ret;
0932     }
0933 
0934     /*
0935      * Now it should be a CONNREQ.
0936      */
0937     if (frametype != NR_CONNREQ) {
0938         /*
0939          * Here it would be nice to be able to send a reset but
0940          * NET/ROM doesn't have one.  We've tried to extend the protocol
0941          * by sending NR_CONNACK | NR_CHOKE_FLAGS replies but that
0942          * apparently kills BPQ boxes... :-(
0943          * So now we try to follow the established behaviour of
0944          * G8PZT's Xrouter which is sending packets with command type 7
0945          * as an extension of the protocol.
0946          */
0947         if (sysctl_netrom_reset_circuit &&
0948             (frametype != NR_RESET || flags != 0))
0949             nr_transmit_reset(skb, 1);
0950 
0951         return 0;
0952     }
0953 
0954     sk = nr_find_listener(dest);
0955 
0956     user = (ax25_address *)(skb->data + 21);
0957 
0958     if (sk == NULL || sk_acceptq_is_full(sk) ||
0959         (make = nr_make_new(sk)) == NULL) {
0960         nr_transmit_refusal(skb, 0);
0961         if (sk)
0962             sock_put(sk);
0963         return 0;
0964     }
0965 
0966     bh_lock_sock(sk);
0967 
0968     window = skb->data[20];
0969 
0970     sock_hold(make);
0971     skb->sk             = make;
0972     skb->destructor     = sock_efree;
0973     make->sk_state      = TCP_ESTABLISHED;
0974 
0975     /* Fill in his circuit details */
0976     nr_make = nr_sk(make);
0977     nr_make->source_addr = *dest;
0978     nr_make->dest_addr   = *src;
0979     nr_make->user_addr   = *user;
0980 
0981     nr_make->your_index  = circuit_index;
0982     nr_make->your_id     = circuit_id;
0983 
0984     bh_unlock_sock(sk);
0985     circuit = nr_find_next_circuit();
0986     bh_lock_sock(sk);
0987 
0988     nr_make->my_index    = circuit / 256;
0989     nr_make->my_id       = circuit % 256;
0990 
0991     circuit++;
0992 
0993     /* Window negotiation */
0994     if (window < nr_make->window)
0995         nr_make->window = window;
0996 
0997     /* L4 timeout negotiation */
0998     if (skb->len == 37) {
0999         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     skb = skb_recv_datagram(sk, flags, &er);
1163     if (!skb) {
1164         release_sock(sk);
1165         return er;
1166     }
1167 
1168     skb_reset_transport_header(skb);
1169     copied     = skb->len;
1170 
1171     if (copied > size) {
1172         copied = size;
1173         msg->msg_flags |= MSG_TRUNC;
1174     }
1175 
1176     er = skb_copy_datagram_msg(skb, 0, msg, copied);
1177     if (er < 0) {
1178         skb_free_datagram(sk, skb);
1179         release_sock(sk);
1180         return er;
1181     }
1182 
1183     if (sax != NULL) {
1184         memset(sax, 0, sizeof(*sax));
1185         sax->sax25_family = AF_NETROM;
1186         skb_copy_from_linear_data_offset(skb, 7, sax->sax25_call.ax25_call,
1187                   AX25_ADDR_LEN);
1188         msg->msg_namelen = sizeof(*sax);
1189     }
1190 
1191     skb_free_datagram(sk, skb);
1192 
1193     release_sock(sk);
1194     return copied;
1195 }
1196 
1197 
1198 static int nr_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1199 {
1200     struct sock *sk = sock->sk;
1201     void __user *argp = (void __user *)arg;
1202 
1203     switch (cmd) {
1204     case TIOCOUTQ: {
1205         long amount;
1206 
1207         lock_sock(sk);
1208         amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1209         if (amount < 0)
1210             amount = 0;
1211         release_sock(sk);
1212         return put_user(amount, (int __user *)argp);
1213     }
1214 
1215     case TIOCINQ: {
1216         struct sk_buff *skb;
1217         long amount = 0L;
1218 
1219         lock_sock(sk);
1220         /* These two are safe on a single CPU system as only user tasks fiddle here */
1221         if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1222             amount = skb->len;
1223         release_sock(sk);
1224         return put_user(amount, (int __user *)argp);
1225     }
1226 
1227     case SIOCGIFADDR:
1228     case SIOCSIFADDR:
1229     case SIOCGIFDSTADDR:
1230     case SIOCSIFDSTADDR:
1231     case SIOCGIFBRDADDR:
1232     case SIOCSIFBRDADDR:
1233     case SIOCGIFNETMASK:
1234     case SIOCSIFNETMASK:
1235     case SIOCGIFMETRIC:
1236     case SIOCSIFMETRIC:
1237         return -EINVAL;
1238 
1239     case SIOCADDRT:
1240     case SIOCDELRT:
1241     case SIOCNRDECOBS:
1242         if (!capable(CAP_NET_ADMIN))
1243             return -EPERM;
1244         return nr_rt_ioctl(cmd, argp);
1245 
1246     default:
1247         return -ENOIOCTLCMD;
1248     }
1249 
1250     return 0;
1251 }
1252 
1253 #ifdef CONFIG_PROC_FS
1254 
1255 static void *nr_info_start(struct seq_file *seq, loff_t *pos)
1256     __acquires(&nr_list_lock)
1257 {
1258     spin_lock_bh(&nr_list_lock);
1259     return seq_hlist_start_head(&nr_list, *pos);
1260 }
1261 
1262 static void *nr_info_next(struct seq_file *seq, void *v, loff_t *pos)
1263 {
1264     return seq_hlist_next(v, &nr_list, pos);
1265 }
1266 
1267 static void nr_info_stop(struct seq_file *seq, void *v)
1268     __releases(&nr_list_lock)
1269 {
1270     spin_unlock_bh(&nr_list_lock);
1271 }
1272 
1273 static int nr_info_show(struct seq_file *seq, void *v)
1274 {
1275     struct sock *s = sk_entry(v);
1276     struct net_device *dev;
1277     struct nr_sock *nr;
1278     const char *devname;
1279     char buf[11];
1280 
1281     if (v == SEQ_START_TOKEN)
1282         seq_puts(seq,
1283 "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");
1284 
1285     else {
1286 
1287         bh_lock_sock(s);
1288         nr = nr_sk(s);
1289 
1290         if ((dev = nr->device) == NULL)
1291             devname = "???";
1292         else
1293             devname = dev->name;
1294 
1295         seq_printf(seq, "%-9s ", ax2asc(buf, &nr->user_addr));
1296         seq_printf(seq, "%-9s ", ax2asc(buf, &nr->dest_addr));
1297         seq_printf(seq,
1298 "%-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",
1299             ax2asc(buf, &nr->source_addr),
1300             devname,
1301             nr->my_index,
1302             nr->my_id,
1303             nr->your_index,
1304             nr->your_id,
1305             nr->state,
1306             nr->vs,
1307             nr->vr,
1308             nr->va,
1309             ax25_display_timer(&nr->t1timer) / HZ,
1310             nr->t1 / HZ,
1311             ax25_display_timer(&nr->t2timer) / HZ,
1312             nr->t2 / HZ,
1313             ax25_display_timer(&nr->t4timer) / HZ,
1314             nr->t4 / HZ,
1315             ax25_display_timer(&nr->idletimer) / (60 * HZ),
1316             nr->idle / (60 * HZ),
1317             nr->n2count,
1318             nr->n2,
1319             nr->window,
1320             sk_wmem_alloc_get(s),
1321             sk_rmem_alloc_get(s),
1322             s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : 0L);
1323 
1324         bh_unlock_sock(s);
1325     }
1326     return 0;
1327 }
1328 
1329 static const struct seq_operations nr_info_seqops = {
1330     .start = nr_info_start,
1331     .next = nr_info_next,
1332     .stop = nr_info_stop,
1333     .show = nr_info_show,
1334 };
1335 #endif  /* CONFIG_PROC_FS */
1336 
1337 static const struct net_proto_family nr_family_ops = {
1338     .family     =   PF_NETROM,
1339     .create     =   nr_create,
1340     .owner      =   THIS_MODULE,
1341 };
1342 
1343 static const struct proto_ops nr_proto_ops = {
1344     .family     =   PF_NETROM,
1345     .owner      =   THIS_MODULE,
1346     .release    =   nr_release,
1347     .bind       =   nr_bind,
1348     .connect    =   nr_connect,
1349     .socketpair =   sock_no_socketpair,
1350     .accept     =   nr_accept,
1351     .getname    =   nr_getname,
1352     .poll       =   datagram_poll,
1353     .ioctl      =   nr_ioctl,
1354     .gettstamp  =   sock_gettstamp,
1355     .listen     =   nr_listen,
1356     .shutdown   =   sock_no_shutdown,
1357     .setsockopt =   nr_setsockopt,
1358     .getsockopt =   nr_getsockopt,
1359     .sendmsg    =   nr_sendmsg,
1360     .recvmsg    =   nr_recvmsg,
1361     .mmap       =   sock_no_mmap,
1362     .sendpage   =   sock_no_sendpage,
1363 };
1364 
1365 static struct notifier_block nr_dev_notifier = {
1366     .notifier_call  =   nr_device_event,
1367 };
1368 
1369 static struct net_device **dev_nr;
1370 
1371 static struct ax25_protocol nr_pid = {
1372     .pid    = AX25_P_NETROM,
1373     .func   = nr_route_frame
1374 };
1375 
1376 static struct ax25_linkfail nr_linkfail_notifier = {
1377     .func   = nr_link_failed,
1378 };
1379 
1380 static int __init nr_proto_init(void)
1381 {
1382     int i;
1383     int rc = proto_register(&nr_proto, 0);
1384 
1385     if (rc)
1386         return rc;
1387 
1388     if (nr_ndevs > 0x7fffffff/sizeof(struct net_device *)) {
1389         pr_err("NET/ROM: %s - nr_ndevs parameter too large\n",
1390                __func__);
1391         rc = -EINVAL;
1392         goto unregister_proto;
1393     }
1394 
1395     dev_nr = kcalloc(nr_ndevs, sizeof(struct net_device *), GFP_KERNEL);
1396     if (!dev_nr) {
1397         pr_err("NET/ROM: %s - unable to allocate device array\n",
1398                __func__);
1399         rc = -ENOMEM;
1400         goto unregister_proto;
1401     }
1402 
1403     for (i = 0; i < nr_ndevs; i++) {
1404         char name[IFNAMSIZ];
1405         struct net_device *dev;
1406 
1407         sprintf(name, "nr%d", i);
1408         dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, nr_setup);
1409         if (!dev) {
1410             rc = -ENOMEM;
1411             goto fail;
1412         }
1413 
1414         dev->base_addr = i;
1415         rc = register_netdev(dev);
1416         if (rc) {
1417             free_netdev(dev);
1418             goto fail;
1419         }
1420         nr_set_lockdep_key(dev);
1421         dev_nr[i] = dev;
1422     }
1423 
1424     rc = sock_register(&nr_family_ops);
1425     if (rc)
1426         goto fail;
1427 
1428     rc = register_netdevice_notifier(&nr_dev_notifier);
1429     if (rc)
1430         goto out_sock;
1431 
1432     ax25_register_pid(&nr_pid);
1433     ax25_linkfail_register(&nr_linkfail_notifier);
1434 
1435 #ifdef CONFIG_SYSCTL
1436     rc = nr_register_sysctl();
1437     if (rc)
1438         goto out_sysctl;
1439 #endif
1440 
1441     nr_loopback_init();
1442 
1443     rc = -ENOMEM;
1444     if (!proc_create_seq("nr", 0444, init_net.proc_net, &nr_info_seqops))
1445         goto proc_remove1;
1446     if (!proc_create_seq("nr_neigh", 0444, init_net.proc_net,
1447                  &nr_neigh_seqops))
1448         goto proc_remove2;
1449     if (!proc_create_seq("nr_nodes", 0444, init_net.proc_net,
1450                  &nr_node_seqops))
1451         goto proc_remove3;
1452 
1453     return 0;
1454 
1455 proc_remove3:
1456     remove_proc_entry("nr_neigh", init_net.proc_net);
1457 proc_remove2:
1458     remove_proc_entry("nr", init_net.proc_net);
1459 proc_remove1:
1460 
1461     nr_loopback_clear();
1462     nr_rt_free();
1463 
1464 #ifdef CONFIG_SYSCTL
1465     nr_unregister_sysctl();
1466 out_sysctl:
1467 #endif
1468     ax25_linkfail_release(&nr_linkfail_notifier);
1469     ax25_protocol_release(AX25_P_NETROM);
1470     unregister_netdevice_notifier(&nr_dev_notifier);
1471 out_sock:
1472     sock_unregister(PF_NETROM);
1473 fail:
1474     while (--i >= 0) {
1475         unregister_netdev(dev_nr[i]);
1476         free_netdev(dev_nr[i]);
1477     }
1478     kfree(dev_nr);
1479 unregister_proto:
1480     proto_unregister(&nr_proto);
1481     return rc;
1482 }
1483 
1484 module_init(nr_proto_init);
1485 
1486 module_param(nr_ndevs, int, 0);
1487 MODULE_PARM_DESC(nr_ndevs, "number of NET/ROM devices");
1488 
1489 MODULE_AUTHOR("Jonathan Naylor G4KLX <g4klx@g4klx.demon.co.uk>");
1490 MODULE_DESCRIPTION("The amateur radio NET/ROM network and transport layer protocol");
1491 MODULE_LICENSE("GPL");
1492 MODULE_ALIAS_NETPROTO(PF_NETROM);
1493 
1494 static void __exit nr_exit(void)
1495 {
1496     int i;
1497 
1498     remove_proc_entry("nr", init_net.proc_net);
1499     remove_proc_entry("nr_neigh", init_net.proc_net);
1500     remove_proc_entry("nr_nodes", init_net.proc_net);
1501     nr_loopback_clear();
1502 
1503     nr_rt_free();
1504 
1505 #ifdef CONFIG_SYSCTL
1506     nr_unregister_sysctl();
1507 #endif
1508 
1509     ax25_linkfail_release(&nr_linkfail_notifier);
1510     ax25_protocol_release(AX25_P_NETROM);
1511 
1512     unregister_netdevice_notifier(&nr_dev_notifier);
1513 
1514     sock_unregister(PF_NETROM);
1515 
1516     for (i = 0; i < nr_ndevs; i++) {
1517         struct net_device *dev = dev_nr[i];
1518         if (dev) {
1519             unregister_netdev(dev);
1520             free_netdev(dev);
1521         }
1522     }
1523 
1524     kfree(dev_nr);
1525     proto_unregister(&nr_proto);
1526 }
1527 module_exit(nr_exit);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!