Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 
0003 /*
0004  * DECnet       An implementation of the DECnet protocol suite for the LINUX
0005  *              operating system.  DECnet is implemented using the  BSD Socket
0006  *              interface as the means of communication with the user level.
0007  *
0008  *              DECnet Socket Layer Interface
0009  *
0010  * Authors:     Eduardo Marcelo Serrat <emserrat@geocities.com>
0011  *              Patrick Caulfield <patrick@pandh.demon.co.uk>
0012  *
0013  * Changes:
0014  *        Steve Whitehouse: Copied from Eduardo Serrat and Patrick Caulfield's
0015  *                          version of the code. Original copyright preserved
0016  *                          below.
0017  *        Steve Whitehouse: Some bug fixes, cleaning up some code to make it
0018  *                          compatible with my routing layer.
0019  *        Steve Whitehouse: Merging changes from Eduardo Serrat and Patrick
0020  *                          Caulfield.
0021  *        Steve Whitehouse: Further bug fixes, checking module code still works
0022  *                          with new routing layer.
0023  *        Steve Whitehouse: Additional set/get_sockopt() calls.
0024  *        Steve Whitehouse: Fixed TIOCINQ ioctl to be same as Eduardo's new
0025  *                          code.
0026  *        Steve Whitehouse: recvmsg() changed to try and behave in a POSIX like
0027  *                          way. Didn't manage it entirely, but its better.
0028  *        Steve Whitehouse: ditto for sendmsg().
0029  *        Steve Whitehouse: A selection of bug fixes to various things.
0030  *        Steve Whitehouse: Added TIOCOUTQ ioctl.
0031  *        Steve Whitehouse: Fixes to username2sockaddr & sockaddr2username.
0032  *        Steve Whitehouse: Fixes to connect() error returns.
0033  *       Patrick Caulfield: Fixes to delayed acceptance logic.
0034  *         David S. Miller: New socket locking
0035  *        Steve Whitehouse: Socket list hashing/locking
0036  *         Arnaldo C. Melo: use capable, not suser
0037  *        Steve Whitehouse: Removed unused code. Fix to use sk->allocation
0038  *                          when required.
0039  *       Patrick Caulfield: /proc/net/decnet now has object name/number
0040  *        Steve Whitehouse: Fixed local port allocation, hashed sk list
0041  *          Matthew Wilcox: Fixes for dn_ioctl()
0042  *        Steve Whitehouse: New connect/accept logic to allow timeouts and
0043  *                          prepare for sendpage etc.
0044  */
0045 
0046 
0047 /******************************************************************************
0048     (c) 1995-1998 E.M. Serrat       emserrat@geocities.com
0049 
0050 
0051 HISTORY:
0052 
0053 Version           Kernel     Date       Author/Comments
0054 -------           ------     ----       ---------------
0055 Version 0.0.1     2.0.30    01-dic-97   Eduardo Marcelo Serrat
0056                     (emserrat@geocities.com)
0057 
0058                     First Development of DECnet Socket La-
0059                     yer for Linux. Only supports outgoing
0060                     connections.
0061 
0062 Version 0.0.2     2.1.105   20-jun-98   Patrick J. Caulfield
0063                     (patrick@pandh.demon.co.uk)
0064 
0065                     Port to new kernel development version.
0066 
0067 Version 0.0.3     2.1.106   25-jun-98   Eduardo Marcelo Serrat
0068                     (emserrat@geocities.com)
0069                     _
0070                     Added support for incoming connections
0071                     so we can start developing server apps
0072                     on Linux.
0073                     -
0074                     Module Support
0075 Version 0.0.4     2.1.109   21-jul-98   Eduardo Marcelo Serrat
0076                        (emserrat@geocities.com)
0077                        _
0078                     Added support for X11R6.4. Now we can
0079                     use DECnet transport for X on Linux!!!
0080                        -
0081 Version 0.0.5    2.1.110   01-aug-98   Eduardo Marcelo Serrat
0082                        (emserrat@geocities.com)
0083                        Removed bugs on flow control
0084                        Removed bugs on incoming accessdata
0085                        order
0086                        -
0087 Version 0.0.6    2.1.110   07-aug-98   Eduardo Marcelo Serrat
0088                        dn_recvmsg fixes
0089 
0090                     Patrick J. Caulfield
0091                        dn_bind fixes
0092 *******************************************************************************/
0093 
0094 #include <linux/module.h>
0095 #include <linux/errno.h>
0096 #include <linux/types.h>
0097 #include <linux/slab.h>
0098 #include <linux/socket.h>
0099 #include <linux/in.h>
0100 #include <linux/kernel.h>
0101 #include <linux/sched/signal.h>
0102 #include <linux/timer.h>
0103 #include <linux/string.h>
0104 #include <linux/sockios.h>
0105 #include <linux/net.h>
0106 #include <linux/netdevice.h>
0107 #include <linux/inet.h>
0108 #include <linux/route.h>
0109 #include <linux/netfilter.h>
0110 #include <linux/seq_file.h>
0111 #include <net/sock.h>
0112 #include <net/tcp_states.h>
0113 #include <net/flow.h>
0114 #include <asm/ioctls.h>
0115 #include <linux/capability.h>
0116 #include <linux/mm.h>
0117 #include <linux/interrupt.h>
0118 #include <linux/proc_fs.h>
0119 #include <linux/stat.h>
0120 #include <linux/init.h>
0121 #include <linux/poll.h>
0122 #include <linux/jiffies.h>
0123 #include <net/net_namespace.h>
0124 #include <net/neighbour.h>
0125 #include <net/dst.h>
0126 #include <net/fib_rules.h>
0127 #include <net/tcp.h>
0128 #include <net/dn.h>
0129 #include <net/dn_nsp.h>
0130 #include <net/dn_dev.h>
0131 #include <net/dn_route.h>
0132 #include <net/dn_fib.h>
0133 #include <net/dn_neigh.h>
0134 
0135 struct dn_sock {
0136     struct sock sk;
0137     struct dn_scp scp;
0138 };
0139 
0140 static void dn_keepalive(struct sock *sk);
0141 
0142 #define DN_SK_HASH_SHIFT 8
0143 #define DN_SK_HASH_SIZE (1 << DN_SK_HASH_SHIFT)
0144 #define DN_SK_HASH_MASK (DN_SK_HASH_SIZE - 1)
0145 
0146 
0147 static const struct proto_ops dn_proto_ops;
0148 static DEFINE_RWLOCK(dn_hash_lock);
0149 static struct hlist_head dn_sk_hash[DN_SK_HASH_SIZE];
0150 static struct hlist_head dn_wild_sk;
0151 static atomic_long_t decnet_memory_allocated;
0152 static DEFINE_PER_CPU(int, decnet_memory_per_cpu_fw_alloc);
0153 
0154 static int __dn_setsockopt(struct socket *sock, int level, int optname,
0155         sockptr_t optval, unsigned int optlen, int flags);
0156 static int __dn_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen, int flags);
0157 
0158 static struct hlist_head *dn_find_list(struct sock *sk)
0159 {
0160     struct dn_scp *scp = DN_SK(sk);
0161 
0162     if (scp->addr.sdn_flags & SDF_WILD)
0163         return hlist_empty(&dn_wild_sk) ? &dn_wild_sk : NULL;
0164 
0165     return &dn_sk_hash[le16_to_cpu(scp->addrloc) & DN_SK_HASH_MASK];
0166 }
0167 
0168 /*
0169  * Valid ports are those greater than zero and not already in use.
0170  */
0171 static int check_port(__le16 port)
0172 {
0173     struct sock *sk;
0174 
0175     if (port == 0)
0176         return -1;
0177 
0178     sk_for_each(sk, &dn_sk_hash[le16_to_cpu(port) & DN_SK_HASH_MASK]) {
0179         struct dn_scp *scp = DN_SK(sk);
0180         if (scp->addrloc == port)
0181             return -1;
0182     }
0183     return 0;
0184 }
0185 
0186 static unsigned short port_alloc(struct sock *sk)
0187 {
0188     struct dn_scp *scp = DN_SK(sk);
0189     static unsigned short port = 0x2000;
0190     unsigned short i_port = port;
0191 
0192     while(check_port(cpu_to_le16(++port)) != 0) {
0193         if (port == i_port)
0194             return 0;
0195     }
0196 
0197     scp->addrloc = cpu_to_le16(port);
0198 
0199     return 1;
0200 }
0201 
0202 /*
0203  * Since this is only ever called from user
0204  * level, we don't need a write_lock() version
0205  * of this.
0206  */
0207 static int dn_hash_sock(struct sock *sk)
0208 {
0209     struct dn_scp *scp = DN_SK(sk);
0210     struct hlist_head *list;
0211     int rv = -EUSERS;
0212 
0213     BUG_ON(sk_hashed(sk));
0214 
0215     write_lock_bh(&dn_hash_lock);
0216 
0217     if (!scp->addrloc && !port_alloc(sk))
0218         goto out;
0219 
0220     rv = -EADDRINUSE;
0221     if ((list = dn_find_list(sk)) == NULL)
0222         goto out;
0223 
0224     sk_add_node(sk, list);
0225     rv = 0;
0226 out:
0227     write_unlock_bh(&dn_hash_lock);
0228     return rv;
0229 }
0230 
0231 static void dn_unhash_sock(struct sock *sk)
0232 {
0233     write_lock(&dn_hash_lock);
0234     sk_del_node_init(sk);
0235     write_unlock(&dn_hash_lock);
0236 }
0237 
0238 static void dn_unhash_sock_bh(struct sock *sk)
0239 {
0240     write_lock_bh(&dn_hash_lock);
0241     sk_del_node_init(sk);
0242     write_unlock_bh(&dn_hash_lock);
0243 }
0244 
0245 static struct hlist_head *listen_hash(struct sockaddr_dn *addr)
0246 {
0247     int i;
0248     unsigned int hash = addr->sdn_objnum;
0249 
0250     if (hash == 0) {
0251         hash = addr->sdn_objnamel;
0252         for(i = 0; i < le16_to_cpu(addr->sdn_objnamel); i++) {
0253             hash ^= addr->sdn_objname[i];
0254             hash ^= (hash << 3);
0255         }
0256     }
0257 
0258     return &dn_sk_hash[hash & DN_SK_HASH_MASK];
0259 }
0260 
0261 /*
0262  * Called to transform a socket from bound (i.e. with a local address)
0263  * into a listening socket (doesn't need a local port number) and rehashes
0264  * based upon the object name/number.
0265  */
0266 static void dn_rehash_sock(struct sock *sk)
0267 {
0268     struct hlist_head *list;
0269     struct dn_scp *scp = DN_SK(sk);
0270 
0271     if (scp->addr.sdn_flags & SDF_WILD)
0272         return;
0273 
0274     write_lock_bh(&dn_hash_lock);
0275     sk_del_node_init(sk);
0276     DN_SK(sk)->addrloc = 0;
0277     list = listen_hash(&DN_SK(sk)->addr);
0278     sk_add_node(sk, list);
0279     write_unlock_bh(&dn_hash_lock);
0280 }
0281 
0282 int dn_sockaddr2username(struct sockaddr_dn *sdn, unsigned char *buf, unsigned char type)
0283 {
0284     int len = 2;
0285 
0286     *buf++ = type;
0287 
0288     switch (type) {
0289     case 0:
0290         *buf++ = sdn->sdn_objnum;
0291         break;
0292     case 1:
0293         *buf++ = 0;
0294         *buf++ = le16_to_cpu(sdn->sdn_objnamel);
0295         memcpy(buf, sdn->sdn_objname, le16_to_cpu(sdn->sdn_objnamel));
0296         len = 3 + le16_to_cpu(sdn->sdn_objnamel);
0297         break;
0298     case 2:
0299         memset(buf, 0, 5);
0300         buf += 5;
0301         *buf++ = le16_to_cpu(sdn->sdn_objnamel);
0302         memcpy(buf, sdn->sdn_objname, le16_to_cpu(sdn->sdn_objnamel));
0303         len = 7 + le16_to_cpu(sdn->sdn_objnamel);
0304         break;
0305     }
0306 
0307     return len;
0308 }
0309 
0310 /*
0311  * On reception of usernames, we handle types 1 and 0 for destination
0312  * addresses only. Types 2 and 4 are used for source addresses, but the
0313  * UIC, GIC are ignored and they are both treated the same way. Type 3
0314  * is never used as I've no idea what its purpose might be or what its
0315  * format is.
0316  */
0317 int dn_username2sockaddr(unsigned char *data, int len, struct sockaddr_dn *sdn, unsigned char *fmt)
0318 {
0319     unsigned char type;
0320     int size = len;
0321     int namel = 12;
0322 
0323     sdn->sdn_objnum = 0;
0324     sdn->sdn_objnamel = cpu_to_le16(0);
0325     memset(sdn->sdn_objname, 0, DN_MAXOBJL);
0326 
0327     if (len < 2)
0328         return -1;
0329 
0330     len -= 2;
0331     *fmt = *data++;
0332     type = *data++;
0333 
0334     switch (*fmt) {
0335     case 0:
0336         sdn->sdn_objnum = type;
0337         return 2;
0338     case 1:
0339         namel = 16;
0340         break;
0341     case 2:
0342         len  -= 4;
0343         data += 4;
0344         break;
0345     case 4:
0346         len  -= 8;
0347         data += 8;
0348         break;
0349     default:
0350         return -1;
0351     }
0352 
0353     len -= 1;
0354 
0355     if (len < 0)
0356         return -1;
0357 
0358     sdn->sdn_objnamel = cpu_to_le16(*data++);
0359     len -= le16_to_cpu(sdn->sdn_objnamel);
0360 
0361     if ((len < 0) || (le16_to_cpu(sdn->sdn_objnamel) > namel))
0362         return -1;
0363 
0364     memcpy(sdn->sdn_objname, data, le16_to_cpu(sdn->sdn_objnamel));
0365 
0366     return size - len;
0367 }
0368 
0369 struct sock *dn_sklist_find_listener(struct sockaddr_dn *addr)
0370 {
0371     struct hlist_head *list = listen_hash(addr);
0372     struct sock *sk;
0373 
0374     read_lock(&dn_hash_lock);
0375     sk_for_each(sk, list) {
0376         struct dn_scp *scp = DN_SK(sk);
0377         if (sk->sk_state != TCP_LISTEN)
0378             continue;
0379         if (scp->addr.sdn_objnum) {
0380             if (scp->addr.sdn_objnum != addr->sdn_objnum)
0381                 continue;
0382         } else {
0383             if (addr->sdn_objnum)
0384                 continue;
0385             if (scp->addr.sdn_objnamel != addr->sdn_objnamel)
0386                 continue;
0387             if (memcmp(scp->addr.sdn_objname, addr->sdn_objname, le16_to_cpu(addr->sdn_objnamel)) != 0)
0388                 continue;
0389         }
0390         sock_hold(sk);
0391         read_unlock(&dn_hash_lock);
0392         return sk;
0393     }
0394 
0395     sk = sk_head(&dn_wild_sk);
0396     if (sk) {
0397         if (sk->sk_state == TCP_LISTEN)
0398             sock_hold(sk);
0399         else
0400             sk = NULL;
0401     }
0402 
0403     read_unlock(&dn_hash_lock);
0404     return sk;
0405 }
0406 
0407 struct sock *dn_find_by_skb(struct sk_buff *skb)
0408 {
0409     struct dn_skb_cb *cb = DN_SKB_CB(skb);
0410     struct sock *sk;
0411     struct dn_scp *scp;
0412 
0413     read_lock(&dn_hash_lock);
0414     sk_for_each(sk, &dn_sk_hash[le16_to_cpu(cb->dst_port) & DN_SK_HASH_MASK]) {
0415         scp = DN_SK(sk);
0416         if (cb->src != dn_saddr2dn(&scp->peer))
0417             continue;
0418         if (cb->dst_port != scp->addrloc)
0419             continue;
0420         if (scp->addrrem && (cb->src_port != scp->addrrem))
0421             continue;
0422         sock_hold(sk);
0423         goto found;
0424     }
0425     sk = NULL;
0426 found:
0427     read_unlock(&dn_hash_lock);
0428     return sk;
0429 }
0430 
0431 
0432 
0433 static void dn_destruct(struct sock *sk)
0434 {
0435     struct dn_scp *scp = DN_SK(sk);
0436 
0437     skb_queue_purge(&scp->data_xmit_queue);
0438     skb_queue_purge(&scp->other_xmit_queue);
0439     skb_queue_purge(&scp->other_receive_queue);
0440 
0441     dst_release(rcu_dereference_protected(sk->sk_dst_cache, 1));
0442 }
0443 
0444 static unsigned long dn_memory_pressure;
0445 
0446 static void dn_enter_memory_pressure(struct sock *sk)
0447 {
0448     if (!dn_memory_pressure) {
0449         dn_memory_pressure = 1;
0450     }
0451 }
0452 
0453 static struct proto dn_proto = {
0454     .name           = "NSP",
0455     .owner          = THIS_MODULE,
0456     .enter_memory_pressure  = dn_enter_memory_pressure,
0457     .memory_pressure    = &dn_memory_pressure,
0458 
0459     .memory_allocated   = &decnet_memory_allocated,
0460     .per_cpu_fw_alloc   = &decnet_memory_per_cpu_fw_alloc,
0461 
0462     .sysctl_mem     = sysctl_decnet_mem,
0463     .sysctl_wmem        = sysctl_decnet_wmem,
0464     .sysctl_rmem        = sysctl_decnet_rmem,
0465     .max_header     = DN_MAX_NSP_DATA_HEADER + 64,
0466     .obj_size       = sizeof(struct dn_sock),
0467 };
0468 
0469 static struct sock *dn_alloc_sock(struct net *net, struct socket *sock, gfp_t gfp, int kern)
0470 {
0471     struct dn_scp *scp;
0472     struct sock *sk = sk_alloc(net, PF_DECnet, gfp, &dn_proto, kern);
0473 
0474     if  (!sk)
0475         goto out;
0476 
0477     if (sock)
0478         sock->ops = &dn_proto_ops;
0479     sock_init_data(sock, sk);
0480 
0481     sk->sk_backlog_rcv = dn_nsp_backlog_rcv;
0482     sk->sk_destruct    = dn_destruct;
0483     sk->sk_no_check_tx = 1;
0484     sk->sk_family      = PF_DECnet;
0485     sk->sk_protocol    = 0;
0486     sk->sk_allocation  = gfp;
0487     sk->sk_sndbuf      = READ_ONCE(sysctl_decnet_wmem[1]);
0488     sk->sk_rcvbuf      = READ_ONCE(sysctl_decnet_rmem[1]);
0489 
0490     /* Initialization of DECnet Session Control Port        */
0491     scp = DN_SK(sk);
0492     scp->state  = DN_O;     /* Open         */
0493     scp->numdat = 1;        /* Next data seg to tx  */
0494     scp->numoth = 1;        /* Next oth data to tx  */
0495     scp->ackxmt_dat = 0;        /* Last data seg ack'ed */
0496     scp->ackxmt_oth = 0;        /* Last oth data ack'ed */
0497     scp->ackrcv_dat = 0;        /* Highest data ack recv*/
0498     scp->ackrcv_oth = 0;        /* Last oth data ack rec*/
0499     scp->flowrem_sw = DN_SEND;
0500     scp->flowloc_sw = DN_SEND;
0501     scp->flowrem_dat = 0;
0502     scp->flowrem_oth = 1;
0503     scp->flowloc_dat = 0;
0504     scp->flowloc_oth = 1;
0505     scp->services_rem = 0;
0506     scp->services_loc = 1 | NSP_FC_NONE;
0507     scp->info_rem = 0;
0508     scp->info_loc = 0x03; /* NSP version 4.1 */
0509     scp->segsize_rem = 230 - DN_MAX_NSP_DATA_HEADER; /* Default: Updated by remote segsize */
0510     scp->nonagle = 0;
0511     scp->multi_ireq = 1;
0512     scp->accept_mode = ACC_IMMED;
0513     scp->addr.sdn_family    = AF_DECnet;
0514     scp->peer.sdn_family    = AF_DECnet;
0515     scp->accessdata.acc_accl = 5;
0516     memcpy(scp->accessdata.acc_acc, "LINUX", 5);
0517 
0518     scp->max_window   = NSP_MAX_WINDOW;
0519     scp->snd_window   = NSP_MIN_WINDOW;
0520     scp->nsp_srtt     = NSP_INITIAL_SRTT;
0521     scp->nsp_rttvar   = NSP_INITIAL_RTTVAR;
0522     scp->nsp_rxtshift = 0;
0523 
0524     skb_queue_head_init(&scp->data_xmit_queue);
0525     skb_queue_head_init(&scp->other_xmit_queue);
0526     skb_queue_head_init(&scp->other_receive_queue);
0527 
0528     scp->persist = 0;
0529     scp->persist_fxn = NULL;
0530     scp->keepalive = 10 * HZ;
0531     scp->keepalive_fxn = dn_keepalive;
0532 
0533     dn_start_slow_timer(sk);
0534 out:
0535     return sk;
0536 }
0537 
0538 /*
0539  * Keepalive timer.
0540  * FIXME: Should respond to SO_KEEPALIVE etc.
0541  */
0542 static void dn_keepalive(struct sock *sk)
0543 {
0544     struct dn_scp *scp = DN_SK(sk);
0545 
0546     /*
0547      * By checking the other_data transmit queue is empty
0548      * we are double checking that we are not sending too
0549      * many of these keepalive frames.
0550      */
0551     if (skb_queue_empty(&scp->other_xmit_queue))
0552         dn_nsp_send_link(sk, DN_NOCHANGE, 0);
0553 }
0554 
0555 
0556 /*
0557  * Timer for shutdown/destroyed sockets.
0558  * When socket is dead & no packets have been sent for a
0559  * certain amount of time, they are removed by this
0560  * routine. Also takes care of sending out DI & DC
0561  * frames at correct times.
0562  */
0563 int dn_destroy_timer(struct sock *sk)
0564 {
0565     struct dn_scp *scp = DN_SK(sk);
0566 
0567     scp->persist = dn_nsp_persist(sk);
0568 
0569     switch (scp->state) {
0570     case DN_DI:
0571         dn_nsp_send_disc(sk, NSP_DISCINIT, 0, GFP_ATOMIC);
0572         if (scp->nsp_rxtshift >= decnet_di_count)
0573             scp->state = DN_CN;
0574         return 0;
0575 
0576     case DN_DR:
0577         dn_nsp_send_disc(sk, NSP_DISCINIT, 0, GFP_ATOMIC);
0578         if (scp->nsp_rxtshift >= decnet_dr_count)
0579             scp->state = DN_DRC;
0580         return 0;
0581 
0582     case DN_DN:
0583         if (scp->nsp_rxtshift < decnet_dn_count) {
0584             /* printk(KERN_DEBUG "dn_destroy_timer: DN\n"); */
0585             dn_nsp_send_disc(sk, NSP_DISCCONF, NSP_REASON_DC,
0586                      GFP_ATOMIC);
0587             return 0;
0588         }
0589     }
0590 
0591     scp->persist = (HZ * decnet_time_wait);
0592 
0593     if (sk->sk_socket)
0594         return 0;
0595 
0596     if (time_after_eq(jiffies, scp->stamp + HZ * decnet_time_wait)) {
0597         dn_unhash_sock(sk);
0598         sock_put(sk);
0599         return 1;
0600     }
0601 
0602     return 0;
0603 }
0604 
0605 static void dn_destroy_sock(struct sock *sk)
0606 {
0607     struct dn_scp *scp = DN_SK(sk);
0608 
0609     scp->nsp_rxtshift = 0; /* reset back off */
0610 
0611     if (sk->sk_socket) {
0612         if (sk->sk_socket->state != SS_UNCONNECTED)
0613             sk->sk_socket->state = SS_DISCONNECTING;
0614     }
0615 
0616     sk->sk_state = TCP_CLOSE;
0617 
0618     switch (scp->state) {
0619     case DN_DN:
0620         dn_nsp_send_disc(sk, NSP_DISCCONF, NSP_REASON_DC,
0621                  sk->sk_allocation);
0622         scp->persist_fxn = dn_destroy_timer;
0623         scp->persist = dn_nsp_persist(sk);
0624         break;
0625     case DN_CR:
0626         scp->state = DN_DR;
0627         goto disc_reject;
0628     case DN_RUN:
0629         scp->state = DN_DI;
0630         fallthrough;
0631     case DN_DI:
0632     case DN_DR:
0633 disc_reject:
0634         dn_nsp_send_disc(sk, NSP_DISCINIT, 0, sk->sk_allocation);
0635         fallthrough;
0636     case DN_NC:
0637     case DN_NR:
0638     case DN_RJ:
0639     case DN_DIC:
0640     case DN_CN:
0641     case DN_DRC:
0642     case DN_CI:
0643     case DN_CD:
0644         scp->persist_fxn = dn_destroy_timer;
0645         scp->persist = dn_nsp_persist(sk);
0646         break;
0647     default:
0648         printk(KERN_DEBUG "DECnet: dn_destroy_sock passed socket in invalid state\n");
0649         fallthrough;
0650     case DN_O:
0651         dn_stop_slow_timer(sk);
0652 
0653         dn_unhash_sock_bh(sk);
0654         sock_put(sk);
0655 
0656         break;
0657     }
0658 }
0659 
0660 char *dn_addr2asc(__u16 addr, char *buf)
0661 {
0662     unsigned short node, area;
0663 
0664     node = addr & 0x03ff;
0665     area = addr >> 10;
0666     sprintf(buf, "%hd.%hd", area, node);
0667 
0668     return buf;
0669 }
0670 
0671 
0672 
0673 static int dn_create(struct net *net, struct socket *sock, int protocol,
0674              int kern)
0675 {
0676     struct sock *sk;
0677 
0678     if (protocol < 0 || protocol > U8_MAX)
0679         return -EINVAL;
0680 
0681     if (!net_eq(net, &init_net))
0682         return -EAFNOSUPPORT;
0683 
0684     switch (sock->type) {
0685     case SOCK_SEQPACKET:
0686         if (protocol != DNPROTO_NSP)
0687             return -EPROTONOSUPPORT;
0688         break;
0689     case SOCK_STREAM:
0690         break;
0691     default:
0692         return -ESOCKTNOSUPPORT;
0693     }
0694 
0695 
0696     if ((sk = dn_alloc_sock(net, sock, GFP_KERNEL, kern)) == NULL)
0697         return -ENOBUFS;
0698 
0699     sk->sk_protocol = protocol;
0700 
0701     return 0;
0702 }
0703 
0704 
0705 static int
0706 dn_release(struct socket *sock)
0707 {
0708     struct sock *sk = sock->sk;
0709 
0710     if (sk) {
0711         sock_orphan(sk);
0712         sock_hold(sk);
0713         lock_sock(sk);
0714         dn_destroy_sock(sk);
0715         release_sock(sk);
0716         sock_put(sk);
0717     }
0718 
0719     return 0;
0720 }
0721 
0722 static int dn_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
0723 {
0724     struct sock *sk = sock->sk;
0725     struct dn_scp *scp = DN_SK(sk);
0726     struct sockaddr_dn *saddr = (struct sockaddr_dn *)uaddr;
0727     struct net_device *dev, *ldev;
0728     int rv;
0729 
0730     if (addr_len != sizeof(struct sockaddr_dn))
0731         return -EINVAL;
0732 
0733     if (saddr->sdn_family != AF_DECnet)
0734         return -EINVAL;
0735 
0736     if (le16_to_cpu(saddr->sdn_nodeaddrl) && (le16_to_cpu(saddr->sdn_nodeaddrl) != 2))
0737         return -EINVAL;
0738 
0739     if (le16_to_cpu(saddr->sdn_objnamel) > DN_MAXOBJL)
0740         return -EINVAL;
0741 
0742     if (saddr->sdn_flags & ~SDF_WILD)
0743         return -EINVAL;
0744 
0745     if (!capable(CAP_NET_BIND_SERVICE) && (saddr->sdn_objnum ||
0746         (saddr->sdn_flags & SDF_WILD)))
0747         return -EACCES;
0748 
0749     if (!(saddr->sdn_flags & SDF_WILD)) {
0750         if (le16_to_cpu(saddr->sdn_nodeaddrl)) {
0751             rcu_read_lock();
0752             ldev = NULL;
0753             for_each_netdev_rcu(&init_net, dev) {
0754                 if (!dev->dn_ptr)
0755                     continue;
0756                 if (dn_dev_islocal(dev, dn_saddr2dn(saddr))) {
0757                     ldev = dev;
0758                     break;
0759                 }
0760             }
0761             rcu_read_unlock();
0762             if (ldev == NULL)
0763                 return -EADDRNOTAVAIL;
0764         }
0765     }
0766 
0767     rv = -EINVAL;
0768     lock_sock(sk);
0769     if (sock_flag(sk, SOCK_ZAPPED)) {
0770         memcpy(&scp->addr, saddr, addr_len);
0771         sock_reset_flag(sk, SOCK_ZAPPED);
0772 
0773         rv = dn_hash_sock(sk);
0774         if (rv)
0775             sock_set_flag(sk, SOCK_ZAPPED);
0776     }
0777     release_sock(sk);
0778 
0779     return rv;
0780 }
0781 
0782 
0783 static int dn_auto_bind(struct socket *sock)
0784 {
0785     struct sock *sk = sock->sk;
0786     struct dn_scp *scp = DN_SK(sk);
0787     int rv;
0788 
0789     sock_reset_flag(sk, SOCK_ZAPPED);
0790 
0791     scp->addr.sdn_flags  = 0;
0792     scp->addr.sdn_objnum = 0;
0793 
0794     /*
0795      * This stuff is to keep compatibility with Eduardo's
0796      * patch. I hope I can dispense with it shortly...
0797      */
0798     if ((scp->accessdata.acc_accl != 0) &&
0799         (scp->accessdata.acc_accl <= 12)) {
0800 
0801         scp->addr.sdn_objnamel = cpu_to_le16(scp->accessdata.acc_accl);
0802         memcpy(scp->addr.sdn_objname, scp->accessdata.acc_acc, le16_to_cpu(scp->addr.sdn_objnamel));
0803 
0804         scp->accessdata.acc_accl = 0;
0805         memset(scp->accessdata.acc_acc, 0, 40);
0806     }
0807     /* End of compatibility stuff */
0808 
0809     scp->addr.sdn_add.a_len = cpu_to_le16(2);
0810     rv = dn_dev_bind_default((__le16 *)scp->addr.sdn_add.a_addr);
0811     if (rv == 0) {
0812         rv = dn_hash_sock(sk);
0813         if (rv)
0814             sock_set_flag(sk, SOCK_ZAPPED);
0815     }
0816 
0817     return rv;
0818 }
0819 
0820 static int dn_confirm_accept(struct sock *sk, long *timeo, gfp_t allocation)
0821 {
0822     struct dn_scp *scp = DN_SK(sk);
0823     DEFINE_WAIT_FUNC(wait, woken_wake_function);
0824     int err;
0825 
0826     if (scp->state != DN_CR)
0827         return -EINVAL;
0828 
0829     scp->state = DN_CC;
0830     scp->segsize_loc = dst_metric_advmss(__sk_dst_get(sk));
0831     dn_send_conn_conf(sk, allocation);
0832 
0833     add_wait_queue(sk_sleep(sk), &wait);
0834     for(;;) {
0835         release_sock(sk);
0836         if (scp->state == DN_CC)
0837             *timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, *timeo);
0838         lock_sock(sk);
0839         err = 0;
0840         if (scp->state == DN_RUN)
0841             break;
0842         err = sock_error(sk);
0843         if (err)
0844             break;
0845         err = sock_intr_errno(*timeo);
0846         if (signal_pending(current))
0847             break;
0848         err = -EAGAIN;
0849         if (!*timeo)
0850             break;
0851     }
0852     remove_wait_queue(sk_sleep(sk), &wait);
0853     if (err == 0) {
0854         sk->sk_socket->state = SS_CONNECTED;
0855     } else if (scp->state != DN_CC) {
0856         sk->sk_socket->state = SS_UNCONNECTED;
0857     }
0858     return err;
0859 }
0860 
0861 static int dn_wait_run(struct sock *sk, long *timeo)
0862 {
0863     struct dn_scp *scp = DN_SK(sk);
0864     DEFINE_WAIT_FUNC(wait, woken_wake_function);
0865     int err = 0;
0866 
0867     if (scp->state == DN_RUN)
0868         goto out;
0869 
0870     if (!*timeo)
0871         return -EALREADY;
0872 
0873     add_wait_queue(sk_sleep(sk), &wait);
0874     for(;;) {
0875         release_sock(sk);
0876         if (scp->state == DN_CI || scp->state == DN_CC)
0877             *timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, *timeo);
0878         lock_sock(sk);
0879         err = 0;
0880         if (scp->state == DN_RUN)
0881             break;
0882         err = sock_error(sk);
0883         if (err)
0884             break;
0885         err = sock_intr_errno(*timeo);
0886         if (signal_pending(current))
0887             break;
0888         err = -ETIMEDOUT;
0889         if (!*timeo)
0890             break;
0891     }
0892     remove_wait_queue(sk_sleep(sk), &wait);
0893 out:
0894     if (err == 0) {
0895         sk->sk_socket->state = SS_CONNECTED;
0896     } else if (scp->state != DN_CI && scp->state != DN_CC) {
0897         sk->sk_socket->state = SS_UNCONNECTED;
0898     }
0899     return err;
0900 }
0901 
0902 static int __dn_connect(struct sock *sk, struct sockaddr_dn *addr, int addrlen, long *timeo, int flags)
0903 {
0904     struct socket *sock = sk->sk_socket;
0905     struct dn_scp *scp = DN_SK(sk);
0906     int err = -EISCONN;
0907     struct flowidn fld;
0908     struct dst_entry *dst;
0909 
0910     if (sock->state == SS_CONNECTED)
0911         goto out;
0912 
0913     if (sock->state == SS_CONNECTING) {
0914         err = 0;
0915         if (scp->state == DN_RUN) {
0916             sock->state = SS_CONNECTED;
0917             goto out;
0918         }
0919         err = -ECONNREFUSED;
0920         if (scp->state != DN_CI && scp->state != DN_CC) {
0921             sock->state = SS_UNCONNECTED;
0922             goto out;
0923         }
0924         return dn_wait_run(sk, timeo);
0925     }
0926 
0927     err = -EINVAL;
0928     if (scp->state != DN_O)
0929         goto out;
0930 
0931     if (addr == NULL || addrlen != sizeof(struct sockaddr_dn))
0932         goto out;
0933     if (addr->sdn_family != AF_DECnet)
0934         goto out;
0935     if (addr->sdn_flags & SDF_WILD)
0936         goto out;
0937 
0938     if (sock_flag(sk, SOCK_ZAPPED)) {
0939         err = dn_auto_bind(sk->sk_socket);
0940         if (err)
0941             goto out;
0942     }
0943 
0944     memcpy(&scp->peer, addr, sizeof(struct sockaddr_dn));
0945 
0946     err = -EHOSTUNREACH;
0947     memset(&fld, 0, sizeof(fld));
0948     fld.flowidn_oif = sk->sk_bound_dev_if;
0949     fld.daddr = dn_saddr2dn(&scp->peer);
0950     fld.saddr = dn_saddr2dn(&scp->addr);
0951     dn_sk_ports_copy(&fld, scp);
0952     fld.flowidn_proto = DNPROTO_NSP;
0953     if (dn_route_output_sock(&sk->sk_dst_cache, &fld, sk, flags) < 0)
0954         goto out;
0955     dst = __sk_dst_get(sk);
0956     sk->sk_route_caps = dst->dev->features;
0957     sock->state = SS_CONNECTING;
0958     scp->state = DN_CI;
0959     scp->segsize_loc = dst_metric_advmss(dst);
0960 
0961     dn_nsp_send_conninit(sk, NSP_CI);
0962     err = -EINPROGRESS;
0963     if (*timeo) {
0964         err = dn_wait_run(sk, timeo);
0965     }
0966 out:
0967     return err;
0968 }
0969 
0970 static int dn_connect(struct socket *sock, struct sockaddr *uaddr, int addrlen, int flags)
0971 {
0972     struct sockaddr_dn *addr = (struct sockaddr_dn *)uaddr;
0973     struct sock *sk = sock->sk;
0974     int err;
0975     long timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
0976 
0977     lock_sock(sk);
0978     err = __dn_connect(sk, addr, addrlen, &timeo, 0);
0979     release_sock(sk);
0980 
0981     return err;
0982 }
0983 
0984 static inline int dn_check_state(struct sock *sk, struct sockaddr_dn *addr, int addrlen, long *timeo, int flags)
0985 {
0986     struct dn_scp *scp = DN_SK(sk);
0987 
0988     switch (scp->state) {
0989     case DN_RUN:
0990         return 0;
0991     case DN_CR:
0992         return dn_confirm_accept(sk, timeo, sk->sk_allocation);
0993     case DN_CI:
0994     case DN_CC:
0995         return dn_wait_run(sk, timeo);
0996     case DN_O:
0997         return __dn_connect(sk, addr, addrlen, timeo, flags);
0998     }
0999 
1000     return -EINVAL;
1001 }
1002 
1003 
1004 static void dn_access_copy(struct sk_buff *skb, struct accessdata_dn *acc)
1005 {
1006     unsigned char *ptr = skb->data;
1007 
1008     acc->acc_userl = *ptr++;
1009     memcpy(&acc->acc_user, ptr, acc->acc_userl);
1010     ptr += acc->acc_userl;
1011 
1012     acc->acc_passl = *ptr++;
1013     memcpy(&acc->acc_pass, ptr, acc->acc_passl);
1014     ptr += acc->acc_passl;
1015 
1016     acc->acc_accl = *ptr++;
1017     memcpy(&acc->acc_acc, ptr, acc->acc_accl);
1018 
1019     skb_pull(skb, acc->acc_accl + acc->acc_passl + acc->acc_userl + 3);
1020 
1021 }
1022 
1023 static void dn_user_copy(struct sk_buff *skb, struct optdata_dn *opt)
1024 {
1025     unsigned char *ptr = skb->data;
1026     u16 len = *ptr++; /* yes, it's 8bit on the wire */
1027 
1028     BUG_ON(len > 16); /* we've checked the contents earlier */
1029     opt->opt_optl   = cpu_to_le16(len);
1030     opt->opt_status = 0;
1031     memcpy(opt->opt_data, ptr, len);
1032     skb_pull(skb, len + 1);
1033 }
1034 
1035 static struct sk_buff *dn_wait_for_connect(struct sock *sk, long *timeo)
1036 {
1037     DEFINE_WAIT_FUNC(wait, woken_wake_function);
1038     struct sk_buff *skb = NULL;
1039     int err = 0;
1040 
1041     add_wait_queue(sk_sleep(sk), &wait);
1042     for(;;) {
1043         release_sock(sk);
1044         skb = skb_dequeue(&sk->sk_receive_queue);
1045         if (skb == NULL) {
1046             *timeo = wait_woken(&wait, TASK_INTERRUPTIBLE, *timeo);
1047             skb = skb_dequeue(&sk->sk_receive_queue);
1048         }
1049         lock_sock(sk);
1050         if (skb != NULL)
1051             break;
1052         err = -EINVAL;
1053         if (sk->sk_state != TCP_LISTEN)
1054             break;
1055         err = sock_intr_errno(*timeo);
1056         if (signal_pending(current))
1057             break;
1058         err = -EAGAIN;
1059         if (!*timeo)
1060             break;
1061     }
1062     remove_wait_queue(sk_sleep(sk), &wait);
1063 
1064     return skb == NULL ? ERR_PTR(err) : skb;
1065 }
1066 
1067 static int dn_accept(struct socket *sock, struct socket *newsock, int flags,
1068              bool kern)
1069 {
1070     struct sock *sk = sock->sk, *newsk;
1071     struct sk_buff *skb = NULL;
1072     struct dn_skb_cb *cb;
1073     unsigned char menuver;
1074     int err = 0;
1075     unsigned char type;
1076     long timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
1077     struct dst_entry *dst;
1078 
1079     lock_sock(sk);
1080 
1081     if (sk->sk_state != TCP_LISTEN || DN_SK(sk)->state != DN_O) {
1082         release_sock(sk);
1083         return -EINVAL;
1084     }
1085 
1086     skb = skb_dequeue(&sk->sk_receive_queue);
1087     if (skb == NULL) {
1088         skb = dn_wait_for_connect(sk, &timeo);
1089         if (IS_ERR(skb)) {
1090             release_sock(sk);
1091             return PTR_ERR(skb);
1092         }
1093     }
1094 
1095     cb = DN_SKB_CB(skb);
1096     sk_acceptq_removed(sk);
1097     newsk = dn_alloc_sock(sock_net(sk), newsock, sk->sk_allocation, kern);
1098     if (newsk == NULL) {
1099         release_sock(sk);
1100         kfree_skb(skb);
1101         return -ENOBUFS;
1102     }
1103     release_sock(sk);
1104 
1105     dst = skb_dst(skb);
1106     sk_dst_set(newsk, dst);
1107     skb_dst_set(skb, NULL);
1108 
1109     DN_SK(newsk)->state        = DN_CR;
1110     DN_SK(newsk)->addrrem      = cb->src_port;
1111     DN_SK(newsk)->services_rem = cb->services;
1112     DN_SK(newsk)->info_rem     = cb->info;
1113     DN_SK(newsk)->segsize_rem  = cb->segsize;
1114     DN_SK(newsk)->accept_mode  = DN_SK(sk)->accept_mode;
1115 
1116     if (DN_SK(newsk)->segsize_rem < 230)
1117         DN_SK(newsk)->segsize_rem = 230;
1118 
1119     if ((DN_SK(newsk)->services_rem & NSP_FC_MASK) == NSP_FC_NONE)
1120         DN_SK(newsk)->max_window = decnet_no_fc_max_cwnd;
1121 
1122     newsk->sk_state  = TCP_LISTEN;
1123     memcpy(&(DN_SK(newsk)->addr), &(DN_SK(sk)->addr), sizeof(struct sockaddr_dn));
1124 
1125     /*
1126      * If we are listening on a wild socket, we don't want
1127      * the newly created socket on the wrong hash queue.
1128      */
1129     DN_SK(newsk)->addr.sdn_flags &= ~SDF_WILD;
1130 
1131     skb_pull(skb, dn_username2sockaddr(skb->data, skb->len, &(DN_SK(newsk)->addr), &type));
1132     skb_pull(skb, dn_username2sockaddr(skb->data, skb->len, &(DN_SK(newsk)->peer), &type));
1133     *(__le16 *)(DN_SK(newsk)->peer.sdn_add.a_addr) = cb->src;
1134     *(__le16 *)(DN_SK(newsk)->addr.sdn_add.a_addr) = cb->dst;
1135 
1136     menuver = *skb->data;
1137     skb_pull(skb, 1);
1138 
1139     if (menuver & DN_MENUVER_ACC)
1140         dn_access_copy(skb, &(DN_SK(newsk)->accessdata));
1141 
1142     if (menuver & DN_MENUVER_USR)
1143         dn_user_copy(skb, &(DN_SK(newsk)->conndata_in));
1144 
1145     if (menuver & DN_MENUVER_PRX)
1146         DN_SK(newsk)->peer.sdn_flags |= SDF_PROXY;
1147 
1148     if (menuver & DN_MENUVER_UIC)
1149         DN_SK(newsk)->peer.sdn_flags |= SDF_UICPROXY;
1150 
1151     kfree_skb(skb);
1152 
1153     memcpy(&(DN_SK(newsk)->conndata_out), &(DN_SK(sk)->conndata_out),
1154         sizeof(struct optdata_dn));
1155     memcpy(&(DN_SK(newsk)->discdata_out), &(DN_SK(sk)->discdata_out),
1156         sizeof(struct optdata_dn));
1157 
1158     lock_sock(newsk);
1159     err = dn_hash_sock(newsk);
1160     if (err == 0) {
1161         sock_reset_flag(newsk, SOCK_ZAPPED);
1162         dn_send_conn_ack(newsk);
1163 
1164         /*
1165          * Here we use sk->sk_allocation since although the conn conf is
1166          * for the newsk, the context is the old socket.
1167          */
1168         if (DN_SK(newsk)->accept_mode == ACC_IMMED)
1169             err = dn_confirm_accept(newsk, &timeo,
1170                         sk->sk_allocation);
1171     }
1172     release_sock(newsk);
1173     return err;
1174 }
1175 
1176 
1177 static int dn_getname(struct socket *sock, struct sockaddr *uaddr,int peer)
1178 {
1179     struct sockaddr_dn *sa = (struct sockaddr_dn *)uaddr;
1180     struct sock *sk = sock->sk;
1181     struct dn_scp *scp = DN_SK(sk);
1182 
1183     lock_sock(sk);
1184 
1185     if (peer) {
1186         if ((sock->state != SS_CONNECTED &&
1187              sock->state != SS_CONNECTING) &&
1188             scp->accept_mode == ACC_IMMED) {
1189             release_sock(sk);
1190             return -ENOTCONN;
1191         }
1192 
1193         memcpy(sa, &scp->peer, sizeof(struct sockaddr_dn));
1194     } else {
1195         memcpy(sa, &scp->addr, sizeof(struct sockaddr_dn));
1196     }
1197 
1198     release_sock(sk);
1199 
1200     return sizeof(struct sockaddr_dn);
1201 }
1202 
1203 
1204 static __poll_t dn_poll(struct file *file, struct socket *sock, poll_table  *wait)
1205 {
1206     struct sock *sk = sock->sk;
1207     struct dn_scp *scp = DN_SK(sk);
1208     __poll_t mask = datagram_poll(file, sock, wait);
1209 
1210     if (!skb_queue_empty_lockless(&scp->other_receive_queue))
1211         mask |= EPOLLRDBAND;
1212 
1213     return mask;
1214 }
1215 
1216 static int dn_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1217 {
1218     struct sock *sk = sock->sk;
1219     struct dn_scp *scp = DN_SK(sk);
1220     int err = -EOPNOTSUPP;
1221     long amount = 0;
1222     struct sk_buff *skb;
1223     int val;
1224 
1225     switch(cmd)
1226     {
1227     case SIOCGIFADDR:
1228     case SIOCSIFADDR:
1229         return dn_dev_ioctl(cmd, (void __user *)arg);
1230 
1231     case SIOCATMARK:
1232         lock_sock(sk);
1233         val = !skb_queue_empty(&scp->other_receive_queue);
1234         if (scp->state != DN_RUN)
1235             val = -ENOTCONN;
1236         release_sock(sk);
1237         return val;
1238 
1239     case TIOCOUTQ:
1240         amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
1241         if (amount < 0)
1242             amount = 0;
1243         err = put_user(amount, (int __user *)arg);
1244         break;
1245 
1246     case TIOCINQ:
1247         lock_sock(sk);
1248         skb = skb_peek(&scp->other_receive_queue);
1249         if (skb) {
1250             amount = skb->len;
1251         } else {
1252             skb_queue_walk(&sk->sk_receive_queue, skb)
1253                 amount += skb->len;
1254         }
1255         release_sock(sk);
1256         err = put_user(amount, (int __user *)arg);
1257         break;
1258 
1259     default:
1260         err = -ENOIOCTLCMD;
1261         break;
1262     }
1263 
1264     return err;
1265 }
1266 
1267 static int dn_listen(struct socket *sock, int backlog)
1268 {
1269     struct sock *sk = sock->sk;
1270     int err = -EINVAL;
1271 
1272     lock_sock(sk);
1273 
1274     if (sock_flag(sk, SOCK_ZAPPED))
1275         goto out;
1276 
1277     if ((DN_SK(sk)->state != DN_O) || (sk->sk_state == TCP_LISTEN))
1278         goto out;
1279 
1280     sk->sk_max_ack_backlog = backlog;
1281     sk->sk_ack_backlog     = 0;
1282     sk->sk_state           = TCP_LISTEN;
1283     err                 = 0;
1284     dn_rehash_sock(sk);
1285 
1286 out:
1287     release_sock(sk);
1288 
1289     return err;
1290 }
1291 
1292 
1293 static int dn_shutdown(struct socket *sock, int how)
1294 {
1295     struct sock *sk = sock->sk;
1296     struct dn_scp *scp = DN_SK(sk);
1297     int err = -ENOTCONN;
1298 
1299     lock_sock(sk);
1300 
1301     if (sock->state == SS_UNCONNECTED)
1302         goto out;
1303 
1304     err = 0;
1305     if (sock->state == SS_DISCONNECTING)
1306         goto out;
1307 
1308     err = -EINVAL;
1309     if (scp->state == DN_O)
1310         goto out;
1311 
1312     if (how != SHUT_RDWR)
1313         goto out;
1314 
1315     sk->sk_shutdown = SHUTDOWN_MASK;
1316     dn_destroy_sock(sk);
1317     err = 0;
1318 
1319 out:
1320     release_sock(sk);
1321 
1322     return err;
1323 }
1324 
1325 static int dn_setsockopt(struct socket *sock, int level, int optname,
1326         sockptr_t optval, unsigned int optlen)
1327 {
1328     struct sock *sk = sock->sk;
1329     int err;
1330 
1331     lock_sock(sk);
1332     err = __dn_setsockopt(sock, level, optname, optval, optlen, 0);
1333     release_sock(sk);
1334 #ifdef CONFIG_NETFILTER
1335     /* we need to exclude all possible ENOPROTOOPTs except default case */
1336     if (err == -ENOPROTOOPT && optname != DSO_LINKINFO &&
1337         optname != DSO_STREAM && optname != DSO_SEQPACKET)
1338         err = nf_setsockopt(sk, PF_DECnet, optname, optval, optlen);
1339 #endif
1340 
1341     return err;
1342 }
1343 
1344 static int __dn_setsockopt(struct socket *sock, int level, int optname,
1345         sockptr_t optval, unsigned int optlen, int flags)
1346 {
1347     struct  sock *sk = sock->sk;
1348     struct dn_scp *scp = DN_SK(sk);
1349     long timeo;
1350     union {
1351         struct optdata_dn opt;
1352         struct accessdata_dn acc;
1353         int mode;
1354         unsigned long win;
1355         int val;
1356         unsigned char services;
1357         unsigned char info;
1358     } u;
1359     int err;
1360 
1361     if (optlen && sockptr_is_null(optval))
1362         return -EINVAL;
1363 
1364     if (optlen > sizeof(u))
1365         return -EINVAL;
1366 
1367     if (copy_from_sockptr(&u, optval, optlen))
1368         return -EFAULT;
1369 
1370     switch (optname) {
1371     case DSO_CONDATA:
1372         if (sock->state == SS_CONNECTED)
1373             return -EISCONN;
1374         if ((scp->state != DN_O) && (scp->state != DN_CR))
1375             return -EINVAL;
1376 
1377         if (optlen != sizeof(struct optdata_dn))
1378             return -EINVAL;
1379 
1380         if (le16_to_cpu(u.opt.opt_optl) > 16)
1381             return -EINVAL;
1382 
1383         memcpy(&scp->conndata_out, &u.opt, optlen);
1384         break;
1385 
1386     case DSO_DISDATA:
1387         if (sock->state != SS_CONNECTED &&
1388             scp->accept_mode == ACC_IMMED)
1389             return -ENOTCONN;
1390 
1391         if (optlen != sizeof(struct optdata_dn))
1392             return -EINVAL;
1393 
1394         if (le16_to_cpu(u.opt.opt_optl) > 16)
1395             return -EINVAL;
1396 
1397         memcpy(&scp->discdata_out, &u.opt, optlen);
1398         break;
1399 
1400     case DSO_CONACCESS:
1401         if (sock->state == SS_CONNECTED)
1402             return -EISCONN;
1403         if (scp->state != DN_O)
1404             return -EINVAL;
1405 
1406         if (optlen != sizeof(struct accessdata_dn))
1407             return -EINVAL;
1408 
1409         if ((u.acc.acc_accl > DN_MAXACCL) ||
1410             (u.acc.acc_passl > DN_MAXACCL) ||
1411             (u.acc.acc_userl > DN_MAXACCL))
1412             return -EINVAL;
1413 
1414         memcpy(&scp->accessdata, &u.acc, optlen);
1415         break;
1416 
1417     case DSO_ACCEPTMODE:
1418         if (sock->state == SS_CONNECTED)
1419             return -EISCONN;
1420         if (scp->state != DN_O)
1421             return -EINVAL;
1422 
1423         if (optlen != sizeof(int))
1424             return -EINVAL;
1425 
1426         if ((u.mode != ACC_IMMED) && (u.mode != ACC_DEFER))
1427             return -EINVAL;
1428 
1429         scp->accept_mode = (unsigned char)u.mode;
1430         break;
1431 
1432     case DSO_CONACCEPT:
1433         if (scp->state != DN_CR)
1434             return -EINVAL;
1435         timeo = sock_rcvtimeo(sk, 0);
1436         err = dn_confirm_accept(sk, &timeo, sk->sk_allocation);
1437         return err;
1438 
1439     case DSO_CONREJECT:
1440         if (scp->state != DN_CR)
1441             return -EINVAL;
1442 
1443         scp->state = DN_DR;
1444         sk->sk_shutdown = SHUTDOWN_MASK;
1445         dn_nsp_send_disc(sk, 0x38, 0, sk->sk_allocation);
1446         break;
1447 
1448     case DSO_MAXWINDOW:
1449         if (optlen != sizeof(unsigned long))
1450             return -EINVAL;
1451         if (u.win > NSP_MAX_WINDOW)
1452             u.win = NSP_MAX_WINDOW;
1453         if (u.win == 0)
1454             return -EINVAL;
1455         scp->max_window = u.win;
1456         if (scp->snd_window > u.win)
1457             scp->snd_window = u.win;
1458         break;
1459 
1460     case DSO_NODELAY:
1461         if (optlen != sizeof(int))
1462             return -EINVAL;
1463         if (scp->nonagle == TCP_NAGLE_CORK)
1464             return -EINVAL;
1465         scp->nonagle = (u.val == 0) ? 0 : TCP_NAGLE_OFF;
1466         /* if (scp->nonagle == 1) { Push pending frames } */
1467         break;
1468 
1469     case DSO_CORK:
1470         if (optlen != sizeof(int))
1471             return -EINVAL;
1472         if (scp->nonagle == TCP_NAGLE_OFF)
1473             return -EINVAL;
1474         scp->nonagle = (u.val == 0) ? 0 : TCP_NAGLE_CORK;
1475         /* if (scp->nonagle == 0) { Push pending frames } */
1476         break;
1477 
1478     case DSO_SERVICES:
1479         if (optlen != sizeof(unsigned char))
1480             return -EINVAL;
1481         if ((u.services & ~NSP_FC_MASK) != 0x01)
1482             return -EINVAL;
1483         if ((u.services & NSP_FC_MASK) == NSP_FC_MASK)
1484             return -EINVAL;
1485         scp->services_loc = u.services;
1486         break;
1487 
1488     case DSO_INFO:
1489         if (optlen != sizeof(unsigned char))
1490             return -EINVAL;
1491         if (u.info & 0xfc)
1492             return -EINVAL;
1493         scp->info_loc = u.info;
1494         break;
1495 
1496     case DSO_LINKINFO:
1497     case DSO_STREAM:
1498     case DSO_SEQPACKET:
1499     default:
1500         return -ENOPROTOOPT;
1501     }
1502 
1503     return 0;
1504 }
1505 
1506 static int dn_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
1507 {
1508     struct sock *sk = sock->sk;
1509     int err;
1510 
1511     lock_sock(sk);
1512     err = __dn_getsockopt(sock, level, optname, optval, optlen, 0);
1513     release_sock(sk);
1514 #ifdef CONFIG_NETFILTER
1515     if (err == -ENOPROTOOPT && optname != DSO_STREAM &&
1516         optname != DSO_SEQPACKET && optname != DSO_CONACCEPT &&
1517         optname != DSO_CONREJECT) {
1518         int len;
1519 
1520         if (get_user(len, optlen))
1521             return -EFAULT;
1522 
1523         err = nf_getsockopt(sk, PF_DECnet, optname, optval, &len);
1524         if (err >= 0)
1525             err = put_user(len, optlen);
1526     }
1527 #endif
1528 
1529     return err;
1530 }
1531 
1532 static int __dn_getsockopt(struct socket *sock, int level,int optname, char __user *optval,int __user *optlen, int flags)
1533 {
1534     struct  sock *sk = sock->sk;
1535     struct dn_scp *scp = DN_SK(sk);
1536     struct linkinfo_dn link;
1537     unsigned int r_len;
1538     void *r_data = NULL;
1539     unsigned int val;
1540 
1541     if(get_user(r_len , optlen))
1542         return -EFAULT;
1543 
1544     switch (optname) {
1545     case DSO_CONDATA:
1546         if (r_len > sizeof(struct optdata_dn))
1547             r_len = sizeof(struct optdata_dn);
1548         r_data = &scp->conndata_in;
1549         break;
1550 
1551     case DSO_DISDATA:
1552         if (r_len > sizeof(struct optdata_dn))
1553             r_len = sizeof(struct optdata_dn);
1554         r_data = &scp->discdata_in;
1555         break;
1556 
1557     case DSO_CONACCESS:
1558         if (r_len > sizeof(struct accessdata_dn))
1559             r_len = sizeof(struct accessdata_dn);
1560         r_data = &scp->accessdata;
1561         break;
1562 
1563     case DSO_ACCEPTMODE:
1564         if (r_len > sizeof(unsigned char))
1565             r_len = sizeof(unsigned char);
1566         r_data = &scp->accept_mode;
1567         break;
1568 
1569     case DSO_LINKINFO:
1570         if (r_len > sizeof(struct linkinfo_dn))
1571             r_len = sizeof(struct linkinfo_dn);
1572 
1573         memset(&link, 0, sizeof(link));
1574 
1575         switch (sock->state) {
1576         case SS_CONNECTING:
1577             link.idn_linkstate = LL_CONNECTING;
1578             break;
1579         case SS_DISCONNECTING:
1580             link.idn_linkstate = LL_DISCONNECTING;
1581             break;
1582         case SS_CONNECTED:
1583             link.idn_linkstate = LL_RUNNING;
1584             break;
1585         default:
1586             link.idn_linkstate = LL_INACTIVE;
1587         }
1588 
1589         link.idn_segsize = scp->segsize_rem;
1590         r_data = &link;
1591         break;
1592 
1593     case DSO_MAXWINDOW:
1594         if (r_len > sizeof(unsigned long))
1595             r_len = sizeof(unsigned long);
1596         r_data = &scp->max_window;
1597         break;
1598 
1599     case DSO_NODELAY:
1600         if (r_len > sizeof(int))
1601             r_len = sizeof(int);
1602         val = (scp->nonagle == TCP_NAGLE_OFF);
1603         r_data = &val;
1604         break;
1605 
1606     case DSO_CORK:
1607         if (r_len > sizeof(int))
1608             r_len = sizeof(int);
1609         val = (scp->nonagle == TCP_NAGLE_CORK);
1610         r_data = &val;
1611         break;
1612 
1613     case DSO_SERVICES:
1614         if (r_len > sizeof(unsigned char))
1615             r_len = sizeof(unsigned char);
1616         r_data = &scp->services_rem;
1617         break;
1618 
1619     case DSO_INFO:
1620         if (r_len > sizeof(unsigned char))
1621             r_len = sizeof(unsigned char);
1622         r_data = &scp->info_rem;
1623         break;
1624 
1625     case DSO_STREAM:
1626     case DSO_SEQPACKET:
1627     case DSO_CONACCEPT:
1628     case DSO_CONREJECT:
1629     default:
1630         return -ENOPROTOOPT;
1631     }
1632 
1633     if (r_data) {
1634         if (copy_to_user(optval, r_data, r_len))
1635             return -EFAULT;
1636         if (put_user(r_len, optlen))
1637             return -EFAULT;
1638     }
1639 
1640     return 0;
1641 }
1642 
1643 
1644 static int dn_data_ready(struct sock *sk, struct sk_buff_head *q, int flags, int target)
1645 {
1646     struct sk_buff *skb;
1647     int len = 0;
1648 
1649     if (flags & MSG_OOB)
1650         return !skb_queue_empty(q) ? 1 : 0;
1651 
1652     skb_queue_walk(q, skb) {
1653         struct dn_skb_cb *cb = DN_SKB_CB(skb);
1654         len += skb->len;
1655 
1656         if (cb->nsp_flags & 0x40) {
1657             /* SOCK_SEQPACKET reads to EOM */
1658             if (sk->sk_type == SOCK_SEQPACKET)
1659                 return 1;
1660             /* so does SOCK_STREAM unless WAITALL is specified */
1661             if (!(flags & MSG_WAITALL))
1662                 return 1;
1663         }
1664 
1665         /* minimum data length for read exceeded */
1666         if (len >= target)
1667             return 1;
1668     }
1669 
1670     return 0;
1671 }
1672 
1673 
1674 static int dn_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
1675               int flags)
1676 {
1677     struct sock *sk = sock->sk;
1678     struct dn_scp *scp = DN_SK(sk);
1679     struct sk_buff_head *queue = &sk->sk_receive_queue;
1680     size_t target = size > 1 ? 1 : 0;
1681     size_t copied = 0;
1682     int rv = 0;
1683     struct sk_buff *skb, *n;
1684     struct dn_skb_cb *cb = NULL;
1685     unsigned char eor = 0;
1686     long timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
1687 
1688     lock_sock(sk);
1689 
1690     if (sock_flag(sk, SOCK_ZAPPED)) {
1691         rv = -EADDRNOTAVAIL;
1692         goto out;
1693     }
1694 
1695     if (sk->sk_shutdown & RCV_SHUTDOWN) {
1696         rv = 0;
1697         goto out;
1698     }
1699 
1700     rv = dn_check_state(sk, NULL, 0, &timeo, flags);
1701     if (rv)
1702         goto out;
1703 
1704     if (flags & ~(MSG_CMSG_COMPAT|MSG_PEEK|MSG_OOB|MSG_WAITALL|MSG_DONTWAIT|MSG_NOSIGNAL)) {
1705         rv = -EOPNOTSUPP;
1706         goto out;
1707     }
1708 
1709     if (flags & MSG_OOB)
1710         queue = &scp->other_receive_queue;
1711 
1712     if (flags & MSG_WAITALL)
1713         target = size;
1714 
1715 
1716     /*
1717      * See if there is data ready to read, sleep if there isn't
1718      */
1719     for(;;) {
1720         DEFINE_WAIT_FUNC(wait, woken_wake_function);
1721 
1722         if (sk->sk_err)
1723             goto out;
1724 
1725         if (!skb_queue_empty(&scp->other_receive_queue)) {
1726             if (!(flags & MSG_OOB)) {
1727                 msg->msg_flags |= MSG_OOB;
1728                 if (!scp->other_report) {
1729                     scp->other_report = 1;
1730                     goto out;
1731                 }
1732             }
1733         }
1734 
1735         if (scp->state != DN_RUN)
1736             goto out;
1737 
1738         if (signal_pending(current)) {
1739             rv = sock_intr_errno(timeo);
1740             goto out;
1741         }
1742 
1743         if (dn_data_ready(sk, queue, flags, target))
1744             break;
1745 
1746         if (flags & MSG_DONTWAIT) {
1747             rv = -EWOULDBLOCK;
1748             goto out;
1749         }
1750 
1751         add_wait_queue(sk_sleep(sk), &wait);
1752         sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
1753         sk_wait_event(sk, &timeo, dn_data_ready(sk, queue, flags, target), &wait);
1754         sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
1755         remove_wait_queue(sk_sleep(sk), &wait);
1756     }
1757 
1758     skb_queue_walk_safe(queue, skb, n) {
1759         unsigned int chunk = skb->len;
1760         cb = DN_SKB_CB(skb);
1761 
1762         if ((chunk + copied) > size)
1763             chunk = size - copied;
1764 
1765         if (memcpy_to_msg(msg, skb->data, chunk)) {
1766             rv = -EFAULT;
1767             break;
1768         }
1769         copied += chunk;
1770 
1771         if (!(flags & MSG_PEEK))
1772             skb_pull(skb, chunk);
1773 
1774         eor = cb->nsp_flags & 0x40;
1775 
1776         if (skb->len == 0) {
1777             skb_unlink(skb, queue);
1778             kfree_skb(skb);
1779             /*
1780              * N.B. Don't refer to skb or cb after this point
1781              * in loop.
1782              */
1783             if ((scp->flowloc_sw == DN_DONTSEND) && !dn_congested(sk)) {
1784                 scp->flowloc_sw = DN_SEND;
1785                 dn_nsp_send_link(sk, DN_SEND, 0);
1786             }
1787         }
1788 
1789         if (eor) {
1790             if (sk->sk_type == SOCK_SEQPACKET)
1791                 break;
1792             if (!(flags & MSG_WAITALL))
1793                 break;
1794         }
1795 
1796         if (flags & MSG_OOB)
1797             break;
1798 
1799         if (copied >= target)
1800             break;
1801     }
1802 
1803     rv = copied;
1804 
1805 
1806     if (eor && (sk->sk_type == SOCK_SEQPACKET))
1807         msg->msg_flags |= MSG_EOR;
1808 
1809 out:
1810     if (rv == 0)
1811         rv = (flags & MSG_PEEK) ? -sk->sk_err : sock_error(sk);
1812 
1813     if ((rv >= 0) && msg->msg_name) {
1814         __sockaddr_check_size(sizeof(struct sockaddr_dn));
1815         memcpy(msg->msg_name, &scp->peer, sizeof(struct sockaddr_dn));
1816         msg->msg_namelen = sizeof(struct sockaddr_dn);
1817     }
1818 
1819     release_sock(sk);
1820 
1821     return rv;
1822 }
1823 
1824 
1825 static inline int dn_queue_too_long(struct dn_scp *scp, struct sk_buff_head *queue, int flags)
1826 {
1827     unsigned char fctype = scp->services_rem & NSP_FC_MASK;
1828     if (skb_queue_len(queue) >= scp->snd_window)
1829         return 1;
1830     if (fctype != NSP_FC_NONE) {
1831         if (flags & MSG_OOB) {
1832             if (scp->flowrem_oth == 0)
1833                 return 1;
1834         } else {
1835             if (scp->flowrem_dat == 0)
1836                 return 1;
1837         }
1838     }
1839     return 0;
1840 }
1841 
1842 /*
1843  * The DECnet spec requires that the "routing layer" accepts packets which
1844  * are at least 230 bytes in size. This excludes any headers which the NSP
1845  * layer might add, so we always assume that we'll be using the maximal
1846  * length header on data packets. The variation in length is due to the
1847  * inclusion (or not) of the two 16 bit acknowledgement fields so it doesn't
1848  * make much practical difference.
1849  */
1850 unsigned int dn_mss_from_pmtu(struct net_device *dev, int mtu)
1851 {
1852     unsigned int mss = 230 - DN_MAX_NSP_DATA_HEADER;
1853     if (dev) {
1854         struct dn_dev *dn_db = rcu_dereference_raw(dev->dn_ptr);
1855         mtu -= LL_RESERVED_SPACE(dev);
1856         if (dn_db->use_long)
1857             mtu -= 21;
1858         else
1859             mtu -= 6;
1860         mtu -= DN_MAX_NSP_DATA_HEADER;
1861     } else {
1862         /*
1863          * 21 = long header, 16 = guess at MAC header length
1864          */
1865         mtu -= (21 + DN_MAX_NSP_DATA_HEADER + 16);
1866     }
1867     if (mtu > mss)
1868         mss = mtu;
1869     return mss;
1870 }
1871 
1872 static inline unsigned int dn_current_mss(struct sock *sk, int flags)
1873 {
1874     struct dst_entry *dst = __sk_dst_get(sk);
1875     struct dn_scp *scp = DN_SK(sk);
1876     int mss_now = min_t(int, scp->segsize_loc, scp->segsize_rem);
1877 
1878     /* Other data messages are limited to 16 bytes per packet */
1879     if (flags & MSG_OOB)
1880         return 16;
1881 
1882     /* This works out the maximum size of segment we can send out */
1883     if (dst) {
1884         u32 mtu = dst_mtu(dst);
1885         mss_now = min_t(int, dn_mss_from_pmtu(dst->dev, mtu), mss_now);
1886     }
1887 
1888     return mss_now;
1889 }
1890 
1891 /*
1892  * N.B. We get the timeout wrong here, but then we always did get it
1893  * wrong before and this is another step along the road to correcting
1894  * it. It ought to get updated each time we pass through the routine,
1895  * but in practise it probably doesn't matter too much for now.
1896  */
1897 static inline struct sk_buff *dn_alloc_send_pskb(struct sock *sk,
1898                   unsigned long datalen, int noblock,
1899                   int *errcode)
1900 {
1901     struct sk_buff *skb = sock_alloc_send_skb(sk, datalen,
1902                            noblock, errcode);
1903     if (skb) {
1904         skb->protocol = htons(ETH_P_DNA_RT);
1905         skb->pkt_type = PACKET_OUTGOING;
1906     }
1907     return skb;
1908 }
1909 
1910 static int dn_sendmsg(struct socket *sock, struct msghdr *msg, size_t size)
1911 {
1912     struct sock *sk = sock->sk;
1913     struct dn_scp *scp = DN_SK(sk);
1914     size_t mss;
1915     struct sk_buff_head *queue = &scp->data_xmit_queue;
1916     int flags = msg->msg_flags;
1917     int err = 0;
1918     size_t sent = 0;
1919     int addr_len = msg->msg_namelen;
1920     DECLARE_SOCKADDR(struct sockaddr_dn *, addr, msg->msg_name);
1921     struct sk_buff *skb = NULL;
1922     struct dn_skb_cb *cb;
1923     size_t len;
1924     unsigned char fctype;
1925     long timeo;
1926 
1927     if (flags & ~(MSG_TRYHARD|MSG_OOB|MSG_DONTWAIT|MSG_EOR|MSG_NOSIGNAL|MSG_MORE|MSG_CMSG_COMPAT))
1928         return -EOPNOTSUPP;
1929 
1930     if (addr_len && (addr_len != sizeof(struct sockaddr_dn)))
1931         return -EINVAL;
1932 
1933     lock_sock(sk);
1934     timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT);
1935     /*
1936      * The only difference between stream sockets and sequenced packet
1937      * sockets is that the stream sockets always behave as if MSG_EOR
1938      * has been set.
1939      */
1940     if (sock->type == SOCK_STREAM) {
1941         if (flags & MSG_EOR) {
1942             err = -EINVAL;
1943             goto out;
1944         }
1945         flags |= MSG_EOR;
1946     }
1947 
1948 
1949     err = dn_check_state(sk, addr, addr_len, &timeo, flags);
1950     if (err)
1951         goto out_err;
1952 
1953     if (sk->sk_shutdown & SEND_SHUTDOWN) {
1954         err = -EPIPE;
1955         if (!(flags & MSG_NOSIGNAL))
1956             send_sig(SIGPIPE, current, 0);
1957         goto out_err;
1958     }
1959 
1960     if ((flags & MSG_TRYHARD) && sk->sk_dst_cache)
1961         dst_negative_advice(sk);
1962 
1963     mss = scp->segsize_rem;
1964     fctype = scp->services_rem & NSP_FC_MASK;
1965 
1966     mss = dn_current_mss(sk, flags);
1967 
1968     if (flags & MSG_OOB) {
1969         queue = &scp->other_xmit_queue;
1970         if (size > mss) {
1971             err = -EMSGSIZE;
1972             goto out;
1973         }
1974     }
1975 
1976     scp->persist_fxn = dn_nsp_xmit_timeout;
1977 
1978     while(sent < size) {
1979         err = sock_error(sk);
1980         if (err)
1981             goto out;
1982 
1983         if (signal_pending(current)) {
1984             err = sock_intr_errno(timeo);
1985             goto out;
1986         }
1987 
1988         /*
1989          * Calculate size that we wish to send.
1990          */
1991         len = size - sent;
1992 
1993         if (len > mss)
1994             len = mss;
1995 
1996         /*
1997          * Wait for queue size to go down below the window
1998          * size.
1999          */
2000         if (dn_queue_too_long(scp, queue, flags)) {
2001             DEFINE_WAIT_FUNC(wait, woken_wake_function);
2002 
2003             if (flags & MSG_DONTWAIT) {
2004                 err = -EWOULDBLOCK;
2005                 goto out;
2006             }
2007 
2008             add_wait_queue(sk_sleep(sk), &wait);
2009             sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
2010             sk_wait_event(sk, &timeo,
2011                       !dn_queue_too_long(scp, queue, flags), &wait);
2012             sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
2013             remove_wait_queue(sk_sleep(sk), &wait);
2014             continue;
2015         }
2016 
2017         /*
2018          * Get a suitably sized skb.
2019          * 64 is a bit of a hack really, but its larger than any
2020          * link-layer headers and has served us well as a good
2021          * guess as to their real length.
2022          */
2023         skb = dn_alloc_send_pskb(sk, len + 64 + DN_MAX_NSP_DATA_HEADER,
2024                      flags & MSG_DONTWAIT, &err);
2025 
2026         if (err)
2027             break;
2028 
2029         if (!skb)
2030             continue;
2031 
2032         cb = DN_SKB_CB(skb);
2033 
2034         skb_reserve(skb, 64 + DN_MAX_NSP_DATA_HEADER);
2035 
2036         if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
2037             err = -EFAULT;
2038             goto out;
2039         }
2040 
2041         if (flags & MSG_OOB) {
2042             cb->nsp_flags = 0x30;
2043             if (fctype != NSP_FC_NONE)
2044                 scp->flowrem_oth--;
2045         } else {
2046             cb->nsp_flags = 0x00;
2047             if (scp->seg_total == 0)
2048                 cb->nsp_flags |= 0x20;
2049 
2050             scp->seg_total += len;
2051 
2052             if (((sent + len) == size) && (flags & MSG_EOR)) {
2053                 cb->nsp_flags |= 0x40;
2054                 scp->seg_total = 0;
2055                 if (fctype == NSP_FC_SCMC)
2056                     scp->flowrem_dat--;
2057             }
2058             if (fctype == NSP_FC_SRC)
2059                 scp->flowrem_dat--;
2060         }
2061 
2062         sent += len;
2063         dn_nsp_queue_xmit(sk, skb, sk->sk_allocation, flags & MSG_OOB);
2064         skb = NULL;
2065 
2066         scp->persist = dn_nsp_persist(sk);
2067 
2068     }
2069 out:
2070 
2071     kfree_skb(skb);
2072 
2073     release_sock(sk);
2074 
2075     return sent ? sent : err;
2076 
2077 out_err:
2078     err = sk_stream_error(sk, flags, err);
2079     release_sock(sk);
2080     return err;
2081 }
2082 
2083 static int dn_device_event(struct notifier_block *this, unsigned long event,
2084                void *ptr)
2085 {
2086     struct net_device *dev = netdev_notifier_info_to_dev(ptr);
2087 
2088     if (!net_eq(dev_net(dev), &init_net))
2089         return NOTIFY_DONE;
2090 
2091     switch (event) {
2092     case NETDEV_UP:
2093         dn_dev_up(dev);
2094         break;
2095     case NETDEV_DOWN:
2096         dn_dev_down(dev);
2097         break;
2098     default:
2099         break;
2100     }
2101 
2102     return NOTIFY_DONE;
2103 }
2104 
2105 static struct notifier_block dn_dev_notifier = {
2106     .notifier_call = dn_device_event,
2107 };
2108 
2109 static struct packet_type dn_dix_packet_type __read_mostly = {
2110     .type =     cpu_to_be16(ETH_P_DNA_RT),
2111     .func =     dn_route_rcv,
2112 };
2113 
2114 #ifdef CONFIG_PROC_FS
2115 struct dn_iter_state {
2116     int bucket;
2117 };
2118 
2119 static struct sock *dn_socket_get_first(struct seq_file *seq)
2120 {
2121     struct dn_iter_state *state = seq->private;
2122     struct sock *n = NULL;
2123 
2124     for(state->bucket = 0;
2125         state->bucket < DN_SK_HASH_SIZE;
2126         ++state->bucket) {
2127         n = sk_head(&dn_sk_hash[state->bucket]);
2128         if (n)
2129             break;
2130     }
2131 
2132     return n;
2133 }
2134 
2135 static struct sock *dn_socket_get_next(struct seq_file *seq,
2136                        struct sock *n)
2137 {
2138     struct dn_iter_state *state = seq->private;
2139 
2140     n = sk_next(n);
2141     while (!n) {
2142         if (++state->bucket >= DN_SK_HASH_SIZE)
2143             break;
2144         n = sk_head(&dn_sk_hash[state->bucket]);
2145     }
2146     return n;
2147 }
2148 
2149 static struct sock *socket_get_idx(struct seq_file *seq, loff_t *pos)
2150 {
2151     struct sock *sk = dn_socket_get_first(seq);
2152 
2153     if (sk) {
2154         while(*pos && (sk = dn_socket_get_next(seq, sk)))
2155             --*pos;
2156     }
2157     return *pos ? NULL : sk;
2158 }
2159 
2160 static void *dn_socket_get_idx(struct seq_file *seq, loff_t pos)
2161 {
2162     void *rc;
2163     read_lock_bh(&dn_hash_lock);
2164     rc = socket_get_idx(seq, &pos);
2165     if (!rc) {
2166         read_unlock_bh(&dn_hash_lock);
2167     }
2168     return rc;
2169 }
2170 
2171 static void *dn_socket_seq_start(struct seq_file *seq, loff_t *pos)
2172 {
2173     return *pos ? dn_socket_get_idx(seq, *pos - 1) : SEQ_START_TOKEN;
2174 }
2175 
2176 static void *dn_socket_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2177 {
2178     void *rc;
2179 
2180     if (v == SEQ_START_TOKEN) {
2181         rc = dn_socket_get_idx(seq, 0);
2182         goto out;
2183     }
2184 
2185     rc = dn_socket_get_next(seq, v);
2186     if (rc)
2187         goto out;
2188     read_unlock_bh(&dn_hash_lock);
2189 out:
2190     ++*pos;
2191     return rc;
2192 }
2193 
2194 static void dn_socket_seq_stop(struct seq_file *seq, void *v)
2195 {
2196     if (v && v != SEQ_START_TOKEN)
2197         read_unlock_bh(&dn_hash_lock);
2198 }
2199 
2200 #define IS_NOT_PRINTABLE(x) ((x) < 32 || (x) > 126)
2201 
2202 static void dn_printable_object(struct sockaddr_dn *dn, unsigned char *buf)
2203 {
2204     int i;
2205 
2206     switch (le16_to_cpu(dn->sdn_objnamel)) {
2207     case 0:
2208         sprintf(buf, "%d", dn->sdn_objnum);
2209         break;
2210     default:
2211         for (i = 0; i < le16_to_cpu(dn->sdn_objnamel); i++) {
2212             buf[i] = dn->sdn_objname[i];
2213             if (IS_NOT_PRINTABLE(buf[i]))
2214                 buf[i] = '.';
2215         }
2216         buf[i] = 0;
2217     }
2218 }
2219 
2220 static char *dn_state2asc(unsigned char state)
2221 {
2222     switch (state) {
2223     case DN_O:
2224         return "OPEN";
2225     case DN_CR:
2226         return "  CR";
2227     case DN_DR:
2228         return "  DR";
2229     case DN_DRC:
2230         return " DRC";
2231     case DN_CC:
2232         return "  CC";
2233     case DN_CI:
2234         return "  CI";
2235     case DN_NR:
2236         return "  NR";
2237     case DN_NC:
2238         return "  NC";
2239     case DN_CD:
2240         return "  CD";
2241     case DN_RJ:
2242         return "  RJ";
2243     case DN_RUN:
2244         return " RUN";
2245     case DN_DI:
2246         return "  DI";
2247     case DN_DIC:
2248         return " DIC";
2249     case DN_DN:
2250         return "  DN";
2251     case DN_CL:
2252         return "  CL";
2253     case DN_CN:
2254         return "  CN";
2255     }
2256 
2257     return "????";
2258 }
2259 
2260 static inline void dn_socket_format_entry(struct seq_file *seq, struct sock *sk)
2261 {
2262     struct dn_scp *scp = DN_SK(sk);
2263     char buf1[DN_ASCBUF_LEN];
2264     char buf2[DN_ASCBUF_LEN];
2265     char local_object[DN_MAXOBJL+3];
2266     char remote_object[DN_MAXOBJL+3];
2267 
2268     dn_printable_object(&scp->addr, local_object);
2269     dn_printable_object(&scp->peer, remote_object);
2270 
2271     seq_printf(seq,
2272            "%6s/%04X %04d:%04d %04d:%04d %01d %-16s "
2273            "%6s/%04X %04d:%04d %04d:%04d %01d %-16s %4s %s\n",
2274            dn_addr2asc(le16_to_cpu(dn_saddr2dn(&scp->addr)), buf1),
2275            scp->addrloc,
2276            scp->numdat,
2277            scp->numoth,
2278            scp->ackxmt_dat,
2279            scp->ackxmt_oth,
2280            scp->flowloc_sw,
2281            local_object,
2282            dn_addr2asc(le16_to_cpu(dn_saddr2dn(&scp->peer)), buf2),
2283            scp->addrrem,
2284            scp->numdat_rcv,
2285            scp->numoth_rcv,
2286            scp->ackrcv_dat,
2287            scp->ackrcv_oth,
2288            scp->flowrem_sw,
2289            remote_object,
2290            dn_state2asc(scp->state),
2291            ((scp->accept_mode == ACC_IMMED) ? "IMMED" : "DEFER"));
2292 }
2293 
2294 static int dn_socket_seq_show(struct seq_file *seq, void *v)
2295 {
2296     if (v == SEQ_START_TOKEN) {
2297         seq_puts(seq, "Local                                              Remote\n");
2298     } else {
2299         dn_socket_format_entry(seq, v);
2300     }
2301     return 0;
2302 }
2303 
2304 static const struct seq_operations dn_socket_seq_ops = {
2305     .start  = dn_socket_seq_start,
2306     .next   = dn_socket_seq_next,
2307     .stop   = dn_socket_seq_stop,
2308     .show   = dn_socket_seq_show,
2309 };
2310 #endif
2311 
2312 static const struct net_proto_family    dn_family_ops = {
2313     .family =   AF_DECnet,
2314     .create =   dn_create,
2315     .owner  =   THIS_MODULE,
2316 };
2317 
2318 static const struct proto_ops dn_proto_ops = {
2319     .family =   AF_DECnet,
2320     .owner =    THIS_MODULE,
2321     .release =  dn_release,
2322     .bind =     dn_bind,
2323     .connect =  dn_connect,
2324     .socketpair =   sock_no_socketpair,
2325     .accept =   dn_accept,
2326     .getname =  dn_getname,
2327     .poll =     dn_poll,
2328     .ioctl =    dn_ioctl,
2329     .listen =   dn_listen,
2330     .shutdown = dn_shutdown,
2331     .setsockopt =   dn_setsockopt,
2332     .getsockopt =   dn_getsockopt,
2333     .sendmsg =  dn_sendmsg,
2334     .recvmsg =  dn_recvmsg,
2335     .mmap =     sock_no_mmap,
2336     .sendpage = sock_no_sendpage,
2337 };
2338 
2339 MODULE_DESCRIPTION("The Linux DECnet Network Protocol");
2340 MODULE_AUTHOR("Linux DECnet Project Team");
2341 MODULE_LICENSE("GPL");
2342 MODULE_ALIAS_NETPROTO(PF_DECnet);
2343 
2344 static const char banner[] __initconst = KERN_INFO
2345 "NET4: DECnet for Linux: V.2.5.68s (C) 1995-2003 Linux DECnet Project Team\n";
2346 
2347 static int __init decnet_init(void)
2348 {
2349     int rc;
2350 
2351     printk(banner);
2352 
2353     rc = proto_register(&dn_proto, 1);
2354     if (rc != 0)
2355         goto out;
2356 
2357     dn_neigh_init();
2358     dn_dev_init();
2359     dn_route_init();
2360     dn_fib_init();
2361 
2362     sock_register(&dn_family_ops);
2363     dev_add_pack(&dn_dix_packet_type);
2364     register_netdevice_notifier(&dn_dev_notifier);
2365 
2366     proc_create_seq_private("decnet", 0444, init_net.proc_net,
2367             &dn_socket_seq_ops, sizeof(struct dn_iter_state),
2368             NULL);
2369     dn_register_sysctl();
2370 out:
2371     return rc;
2372 
2373 }
2374 module_init(decnet_init);
2375 
2376 /*
2377  * Prevent DECnet module unloading until its fixed properly.
2378  * Requires an audit of the code to check for memory leaks and
2379  * initialisation problems etc.
2380  */
2381 #if 0
2382 static void __exit decnet_exit(void)
2383 {
2384     sock_unregister(AF_DECnet);
2385     rtnl_unregister_all(PF_DECnet);
2386     dev_remove_pack(&dn_dix_packet_type);
2387 
2388     dn_unregister_sysctl();
2389 
2390     unregister_netdevice_notifier(&dn_dev_notifier);
2391 
2392     dn_route_cleanup();
2393     dn_dev_cleanup();
2394     dn_neigh_cleanup();
2395     dn_fib_cleanup();
2396 
2397     remove_proc_entry("decnet", init_net.proc_net);
2398 
2399     proto_unregister(&dn_proto);
2400 
2401     rcu_barrier(); /* Wait for completion of call_rcu()'s */
2402 }
2403 module_exit(decnet_exit);
2404 #endif
[ 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!