Back to home page

OSCL-LXR
 
 

     

0001 /*
0002  * af_llc.c - LLC User Interface SAPs
0003  * Description:
0004  *   Functions in this module are implementation of socket based llc
0005  *   communications for the Linux operating system. Support of llc class
0006  *   one and class two is provided via SOCK_DGRAM and SOCK_STREAM
0007  *   respectively.
0008  *
0009  *   An llc2 connection is (mac + sap), only one llc2 sap connection
0010  *   is allowed per mac. Though one sap may have multiple mac + sap
0011  *   connections.
0012  *
0013  * Copyright (c) 2001 by Jay Schulist <jschlst@samba.org>
0014  *       2002-2003 by Arnaldo Carvalho de Melo <acme@conectiva.com.br>
0015  *
0016  * This program can be redistributed or modified under the terms of the
0017  * GNU General Public License as published by the Free Software Foundation.
0018  * This program is distributed without any warranty or implied warranty
0019  * of merchantability or fitness for a particular purpose.
0020  *
0021  * See the GNU General Public License for more details.
0022  */
0023 #include <linux/compiler.h>
0024 #include <linux/kernel.h>
0025 #include <linux/module.h>
0026 #include <linux/rtnetlink.h>
0027 #include <linux/init.h>
0028 #include <linux/slab.h>
0029 #include <linux/sched/signal.h>
0030 
0031 #include <net/llc.h>
0032 #include <net/llc_sap.h>
0033 #include <net/llc_pdu.h>
0034 #include <net/llc_conn.h>
0035 #include <net/tcp_states.h>
0036 
0037 /* remember: uninitialized global data is zeroed because its in .bss */
0038 static u16 llc_ui_sap_last_autoport = LLC_SAP_DYN_START;
0039 static u16 llc_ui_sap_link_no_max[256];
0040 static struct sockaddr_llc llc_ui_addrnull;
0041 static const struct proto_ops llc_ui_ops;
0042 
0043 static bool llc_ui_wait_for_conn(struct sock *sk, long timeout);
0044 static int llc_ui_wait_for_disc(struct sock *sk, long timeout);
0045 static int llc_ui_wait_for_busy_core(struct sock *sk, long timeout);
0046 
0047 #if 0
0048 #define dprintk(args...) printk(KERN_DEBUG args)
0049 #else
0050 #define dprintk(args...) do {} while (0)
0051 #endif
0052 
0053 /* Maybe we'll add some more in the future. */
0054 #define LLC_CMSG_PKTINFO    1
0055 
0056 
0057 /**
0058  *  llc_ui_next_link_no - return the next unused link number for a sap
0059  *  @sap: Address of sap to get link number from.
0060  *
0061  *  Return the next unused link number for a given sap.
0062  */
0063 static inline u16 llc_ui_next_link_no(int sap)
0064 {
0065     return llc_ui_sap_link_no_max[sap]++;
0066 }
0067 
0068 /**
0069  *  llc_proto_type - return eth protocol for ARP header type
0070  *  @arphrd: ARP header type.
0071  *
0072  *  Given an ARP header type return the corresponding ethernet protocol.
0073  */
0074 static inline __be16 llc_proto_type(u16 arphrd)
0075 {
0076     return htons(ETH_P_802_2);
0077 }
0078 
0079 /**
0080  *  llc_ui_addr_null - determines if a address structure is null
0081  *  @addr: Address to test if null.
0082  */
0083 static inline u8 llc_ui_addr_null(struct sockaddr_llc *addr)
0084 {
0085     return !memcmp(addr, &llc_ui_addrnull, sizeof(*addr));
0086 }
0087 
0088 /**
0089  *  llc_ui_header_len - return length of llc header based on operation
0090  *  @sk: Socket which contains a valid llc socket type.
0091  *  @addr: Complete sockaddr_llc structure received from the user.
0092  *
0093  *  Provide the length of the llc header depending on what kind of
0094  *  operation the user would like to perform and the type of socket.
0095  *  Returns the correct llc header length.
0096  */
0097 static inline u8 llc_ui_header_len(struct sock *sk, struct sockaddr_llc *addr)
0098 {
0099     u8 rc = LLC_PDU_LEN_U;
0100 
0101     if (addr->sllc_test)
0102         rc = LLC_PDU_LEN_U;
0103     else if (addr->sllc_xid)
0104         /* We need to expand header to sizeof(struct llc_xid_info)
0105          * since llc_pdu_init_as_xid_cmd() sets 4,5,6 bytes of LLC header
0106          * as XID PDU. In llc_ui_sendmsg() we reserved header size and then
0107          * filled all other space with user data. If we won't reserve this
0108          * bytes, llc_pdu_init_as_xid_cmd() will overwrite user data
0109          */
0110         rc = LLC_PDU_LEN_U_XID;
0111     else if (sk->sk_type == SOCK_STREAM)
0112         rc = LLC_PDU_LEN_I;
0113     return rc;
0114 }
0115 
0116 /**
0117  *  llc_ui_send_data - send data via reliable llc2 connection
0118  *  @sk: Connection the socket is using.
0119  *  @skb: Data the user wishes to send.
0120  *  @noblock: can we block waiting for data?
0121  *
0122  *  Send data via reliable llc2 connection.
0123  *  Returns 0 upon success, non-zero if action did not succeed.
0124  *
0125  *  This function always consumes a reference to the skb.
0126  */
0127 static int llc_ui_send_data(struct sock* sk, struct sk_buff *skb, int noblock)
0128 {
0129     struct llc_sock* llc = llc_sk(sk);
0130 
0131     if (unlikely(llc_data_accept_state(llc->state) ||
0132              llc->remote_busy_flag ||
0133              llc->p_flag)) {
0134         long timeout = sock_sndtimeo(sk, noblock);
0135         int rc;
0136 
0137         rc = llc_ui_wait_for_busy_core(sk, timeout);
0138         if (rc) {
0139             kfree_skb(skb);
0140             return rc;
0141         }
0142     }
0143     return llc_build_and_send_pkt(sk, skb);
0144 }
0145 
0146 static void llc_ui_sk_init(struct socket *sock, struct sock *sk)
0147 {
0148     sock_graft(sk, sock);
0149     sk->sk_type = sock->type;
0150     sock->ops   = &llc_ui_ops;
0151 }
0152 
0153 static struct proto llc_proto = {
0154     .name     = "LLC",
0155     .owner    = THIS_MODULE,
0156     .obj_size = sizeof(struct llc_sock),
0157     .slab_flags = SLAB_TYPESAFE_BY_RCU,
0158 };
0159 
0160 /**
0161  *  llc_ui_create - alloc and init a new llc_ui socket
0162  *  @net: network namespace (must be default network)
0163  *  @sock: Socket to initialize and attach allocated sk to.
0164  *  @protocol: Unused.
0165  *  @kern: on behalf of kernel or userspace
0166  *
0167  *  Allocate and initialize a new llc_ui socket, validate the user wants a
0168  *  socket type we have available.
0169  *  Returns 0 upon success, negative upon failure.
0170  */
0171 static int llc_ui_create(struct net *net, struct socket *sock, int protocol,
0172              int kern)
0173 {
0174     struct sock *sk;
0175     int rc = -ESOCKTNOSUPPORT;
0176 
0177     if (!ns_capable(net->user_ns, CAP_NET_RAW))
0178         return -EPERM;
0179 
0180     if (!net_eq(net, &init_net))
0181         return -EAFNOSUPPORT;
0182 
0183     if (likely(sock->type == SOCK_DGRAM || sock->type == SOCK_STREAM)) {
0184         rc = -ENOMEM;
0185         sk = llc_sk_alloc(net, PF_LLC, GFP_KERNEL, &llc_proto, kern);
0186         if (sk) {
0187             rc = 0;
0188             llc_ui_sk_init(sock, sk);
0189         }
0190     }
0191     return rc;
0192 }
0193 
0194 /**
0195  *  llc_ui_release - shutdown socket
0196  *  @sock: Socket to release.
0197  *
0198  *  Shutdown and deallocate an existing socket.
0199  */
0200 static int llc_ui_release(struct socket *sock)
0201 {
0202     struct sock *sk = sock->sk;
0203     struct llc_sock *llc;
0204 
0205     if (unlikely(sk == NULL))
0206         goto out;
0207     sock_hold(sk);
0208     lock_sock(sk);
0209     llc = llc_sk(sk);
0210     dprintk("%s: closing local(%02X) remote(%02X)\n", __func__,
0211         llc->laddr.lsap, llc->daddr.lsap);
0212     if (!llc_send_disc(sk))
0213         llc_ui_wait_for_disc(sk, sk->sk_rcvtimeo);
0214     if (!sock_flag(sk, SOCK_ZAPPED)) {
0215         struct llc_sap *sap = llc->sap;
0216 
0217         /* Hold this for release_sock(), so that llc_backlog_rcv()
0218          * could still use it.
0219          */
0220         llc_sap_hold(sap);
0221         llc_sap_remove_socket(llc->sap, sk);
0222         release_sock(sk);
0223         llc_sap_put(sap);
0224     } else {
0225         release_sock(sk);
0226     }
0227     netdev_put(llc->dev, &llc->dev_tracker);
0228     sock_put(sk);
0229     llc_sk_free(sk);
0230 out:
0231     return 0;
0232 }
0233 
0234 /**
0235  *  llc_ui_autoport - provide dynamically allocate SAP number
0236  *
0237  *  Provide the caller with a dynamically allocated SAP number according
0238  *  to the rules that are set in this function. Returns: 0, upon failure,
0239  *  SAP number otherwise.
0240  */
0241 static int llc_ui_autoport(void)
0242 {
0243     struct llc_sap *sap;
0244     int i, tries = 0;
0245 
0246     while (tries < LLC_SAP_DYN_TRIES) {
0247         for (i = llc_ui_sap_last_autoport;
0248              i < LLC_SAP_DYN_STOP; i += 2) {
0249             sap = llc_sap_find(i);
0250             if (!sap) {
0251                 llc_ui_sap_last_autoport = i + 2;
0252                 goto out;
0253             }
0254             llc_sap_put(sap);
0255         }
0256         llc_ui_sap_last_autoport = LLC_SAP_DYN_START;
0257         tries++;
0258     }
0259     i = 0;
0260 out:
0261     return i;
0262 }
0263 
0264 /**
0265  *  llc_ui_autobind - automatically bind a socket to a sap
0266  *  @sock: socket to bind
0267  *  @addr: address to connect to
0268  *
0269  *  Used by llc_ui_connect and llc_ui_sendmsg when the user hasn't
0270  *  specifically used llc_ui_bind to bind to an specific address/sap
0271  *
0272  *  Returns: 0 upon success, negative otherwise.
0273  */
0274 static int llc_ui_autobind(struct socket *sock, struct sockaddr_llc *addr)
0275 {
0276     struct sock *sk = sock->sk;
0277     struct llc_sock *llc = llc_sk(sk);
0278     struct net_device *dev = NULL;
0279     struct llc_sap *sap;
0280     int rc = -EINVAL;
0281 
0282     if (!sock_flag(sk, SOCK_ZAPPED))
0283         goto out;
0284     if (!addr->sllc_arphrd)
0285         addr->sllc_arphrd = ARPHRD_ETHER;
0286     if (addr->sllc_arphrd != ARPHRD_ETHER)
0287         goto out;
0288     rc = -ENODEV;
0289     if (sk->sk_bound_dev_if) {
0290         dev = dev_get_by_index(&init_net, sk->sk_bound_dev_if);
0291         if (dev && addr->sllc_arphrd != dev->type) {
0292             dev_put(dev);
0293             dev = NULL;
0294         }
0295     } else
0296         dev = dev_getfirstbyhwtype(&init_net, addr->sllc_arphrd);
0297     if (!dev)
0298         goto out;
0299     rc = -EUSERS;
0300     llc->laddr.lsap = llc_ui_autoport();
0301     if (!llc->laddr.lsap)
0302         goto out;
0303     rc = -EBUSY; /* some other network layer is using the sap */
0304     sap = llc_sap_open(llc->laddr.lsap, NULL);
0305     if (!sap)
0306         goto out;
0307 
0308     /* Note: We do not expect errors from this point. */
0309     llc->dev = dev;
0310     netdev_tracker_alloc(llc->dev, &llc->dev_tracker, GFP_KERNEL);
0311     dev = NULL;
0312 
0313     memcpy(llc->laddr.mac, llc->dev->dev_addr, IFHWADDRLEN);
0314     memcpy(&llc->addr, addr, sizeof(llc->addr));
0315     /* assign new connection to its SAP */
0316     llc_sap_add_socket(sap, sk);
0317     sock_reset_flag(sk, SOCK_ZAPPED);
0318     rc = 0;
0319 out:
0320     dev_put(dev);
0321     return rc;
0322 }
0323 
0324 /**
0325  *  llc_ui_bind - bind a socket to a specific address.
0326  *  @sock: Socket to bind an address to.
0327  *  @uaddr: Address the user wants the socket bound to.
0328  *  @addrlen: Length of the uaddr structure.
0329  *
0330  *  Bind a socket to a specific address. For llc a user is able to bind to
0331  *  a specific sap only or mac + sap.
0332  *  If the user desires to bind to a specific mac + sap, it is possible to
0333  *  have multiple sap connections via multiple macs.
0334  *  Bind and autobind for that matter must enforce the correct sap usage
0335  *  otherwise all hell will break loose.
0336  *  Returns: 0 upon success, negative otherwise.
0337  */
0338 static int llc_ui_bind(struct socket *sock, struct sockaddr *uaddr, int addrlen)
0339 {
0340     struct sockaddr_llc *addr = (struct sockaddr_llc *)uaddr;
0341     struct sock *sk = sock->sk;
0342     struct llc_sock *llc = llc_sk(sk);
0343     struct net_device *dev = NULL;
0344     struct llc_sap *sap;
0345     int rc = -EINVAL;
0346 
0347     lock_sock(sk);
0348     if (unlikely(!sock_flag(sk, SOCK_ZAPPED) || addrlen != sizeof(*addr)))
0349         goto out;
0350     rc = -EAFNOSUPPORT;
0351     if (!addr->sllc_arphrd)
0352         addr->sllc_arphrd = ARPHRD_ETHER;
0353     if (unlikely(addr->sllc_family != AF_LLC || addr->sllc_arphrd != ARPHRD_ETHER))
0354         goto out;
0355     dprintk("%s: binding %02X\n", __func__, addr->sllc_sap);
0356     rc = -ENODEV;
0357     rcu_read_lock();
0358     if (sk->sk_bound_dev_if) {
0359         dev = dev_get_by_index_rcu(&init_net, sk->sk_bound_dev_if);
0360         if (dev) {
0361             if (is_zero_ether_addr(addr->sllc_mac))
0362                 memcpy(addr->sllc_mac, dev->dev_addr,
0363                        IFHWADDRLEN);
0364             if (addr->sllc_arphrd != dev->type ||
0365                 !ether_addr_equal(addr->sllc_mac,
0366                           dev->dev_addr)) {
0367                 rc = -EINVAL;
0368                 dev = NULL;
0369             }
0370         }
0371     } else {
0372         dev = dev_getbyhwaddr_rcu(&init_net, addr->sllc_arphrd,
0373                        addr->sllc_mac);
0374     }
0375     dev_hold(dev);
0376     rcu_read_unlock();
0377     if (!dev)
0378         goto out;
0379 
0380     if (!addr->sllc_sap) {
0381         rc = -EUSERS;
0382         addr->sllc_sap = llc_ui_autoport();
0383         if (!addr->sllc_sap)
0384             goto out;
0385     }
0386     sap = llc_sap_find(addr->sllc_sap);
0387     if (!sap) {
0388         sap = llc_sap_open(addr->sllc_sap, NULL);
0389         rc = -EBUSY; /* some other network layer is using the sap */
0390         if (!sap)
0391             goto out;
0392     } else {
0393         struct llc_addr laddr, daddr;
0394         struct sock *ask;
0395 
0396         memset(&laddr, 0, sizeof(laddr));
0397         memset(&daddr, 0, sizeof(daddr));
0398         /*
0399          * FIXME: check if the address is multicast,
0400          *    only SOCK_DGRAM can do this.
0401          */
0402         memcpy(laddr.mac, addr->sllc_mac, IFHWADDRLEN);
0403         laddr.lsap = addr->sllc_sap;
0404         rc = -EADDRINUSE; /* mac + sap clash. */
0405         ask = llc_lookup_established(sap, &daddr, &laddr);
0406         if (ask) {
0407             sock_put(ask);
0408             goto out_put;
0409         }
0410     }
0411 
0412     /* Note: We do not expect errors from this point. */
0413     llc->dev = dev;
0414     netdev_tracker_alloc(llc->dev, &llc->dev_tracker, GFP_KERNEL);
0415     dev = NULL;
0416 
0417     llc->laddr.lsap = addr->sllc_sap;
0418     memcpy(llc->laddr.mac, addr->sllc_mac, IFHWADDRLEN);
0419     memcpy(&llc->addr, addr, sizeof(llc->addr));
0420     /* assign new connection to its SAP */
0421     llc_sap_add_socket(sap, sk);
0422     sock_reset_flag(sk, SOCK_ZAPPED);
0423     rc = 0;
0424 out_put:
0425     llc_sap_put(sap);
0426 out:
0427     dev_put(dev);
0428     release_sock(sk);
0429     return rc;
0430 }
0431 
0432 /**
0433  *  llc_ui_shutdown - shutdown a connect llc2 socket.
0434  *  @sock: Socket to shutdown.
0435  *  @how: What part of the socket to shutdown.
0436  *
0437  *  Shutdown a connected llc2 socket. Currently this function only supports
0438  *  shutting down both sends and receives (2), we could probably make this
0439  *  function such that a user can shutdown only half the connection but not
0440  *  right now.
0441  *  Returns: 0 upon success, negative otherwise.
0442  */
0443 static int llc_ui_shutdown(struct socket *sock, int how)
0444 {
0445     struct sock *sk = sock->sk;
0446     int rc = -ENOTCONN;
0447 
0448     lock_sock(sk);
0449     if (unlikely(sk->sk_state != TCP_ESTABLISHED))
0450         goto out;
0451     rc = -EINVAL;
0452     if (how != 2)
0453         goto out;
0454     rc = llc_send_disc(sk);
0455     if (!rc)
0456         rc = llc_ui_wait_for_disc(sk, sk->sk_rcvtimeo);
0457     /* Wake up anyone sleeping in poll */
0458     sk->sk_state_change(sk);
0459 out:
0460     release_sock(sk);
0461     return rc;
0462 }
0463 
0464 /**
0465  *  llc_ui_connect - Connect to a remote llc2 mac + sap.
0466  *  @sock: Socket which will be connected to the remote destination.
0467  *  @uaddr: Remote and possibly the local address of the new connection.
0468  *  @addrlen: Size of uaddr structure.
0469  *  @flags: Operational flags specified by the user.
0470  *
0471  *  Connect to a remote llc2 mac + sap. The caller must specify the
0472  *  destination mac and address to connect to. If the user hasn't previously
0473  *  called bind(2) with a smac the address of the first interface of the
0474  *  specified arp type will be used.
0475  *  This function will autobind if user did not previously call bind.
0476  *  Returns: 0 upon success, negative otherwise.
0477  */
0478 static int llc_ui_connect(struct socket *sock, struct sockaddr *uaddr,
0479               int addrlen, int flags)
0480 {
0481     struct sock *sk = sock->sk;
0482     struct llc_sock *llc = llc_sk(sk);
0483     struct sockaddr_llc *addr = (struct sockaddr_llc *)uaddr;
0484     int rc = -EINVAL;
0485 
0486     lock_sock(sk);
0487     if (unlikely(addrlen != sizeof(*addr)))
0488         goto out;
0489     rc = -EAFNOSUPPORT;
0490     if (unlikely(addr->sllc_family != AF_LLC))
0491         goto out;
0492     if (unlikely(sk->sk_type != SOCK_STREAM))
0493         goto out;
0494     rc = -EALREADY;
0495     if (unlikely(sock->state == SS_CONNECTING))
0496         goto out;
0497     /* bind connection to sap if user hasn't done it. */
0498     if (sock_flag(sk, SOCK_ZAPPED)) {
0499         /* bind to sap with null dev, exclusive */
0500         rc = llc_ui_autobind(sock, addr);
0501         if (rc)
0502             goto out;
0503     }
0504     llc->daddr.lsap = addr->sllc_sap;
0505     memcpy(llc->daddr.mac, addr->sllc_mac, IFHWADDRLEN);
0506     sock->state = SS_CONNECTING;
0507     sk->sk_state   = TCP_SYN_SENT;
0508     llc->link   = llc_ui_next_link_no(llc->sap->laddr.lsap);
0509     rc = llc_establish_connection(sk, llc->dev->dev_addr,
0510                       addr->sllc_mac, addr->sllc_sap);
0511     if (rc) {
0512         dprintk("%s: llc_ui_send_conn failed :-(\n", __func__);
0513         sock->state  = SS_UNCONNECTED;
0514         sk->sk_state = TCP_CLOSE;
0515         goto out;
0516     }
0517 
0518     if (sk->sk_state == TCP_SYN_SENT) {
0519         const long timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
0520 
0521         if (!timeo || !llc_ui_wait_for_conn(sk, timeo))
0522             goto out;
0523 
0524         rc = sock_intr_errno(timeo);
0525         if (signal_pending(current))
0526             goto out;
0527     }
0528 
0529     if (sk->sk_state == TCP_CLOSE)
0530         goto sock_error;
0531 
0532     sock->state = SS_CONNECTED;
0533     rc = 0;
0534 out:
0535     release_sock(sk);
0536     return rc;
0537 sock_error:
0538     rc = sock_error(sk) ? : -ECONNABORTED;
0539     sock->state = SS_UNCONNECTED;
0540     goto out;
0541 }
0542 
0543 /**
0544  *  llc_ui_listen - allow a normal socket to accept incoming connections
0545  *  @sock: Socket to allow incoming connections on.
0546  *  @backlog: Number of connections to queue.
0547  *
0548  *  Allow a normal socket to accept incoming connections.
0549  *  Returns 0 upon success, negative otherwise.
0550  */
0551 static int llc_ui_listen(struct socket *sock, int backlog)
0552 {
0553     struct sock *sk = sock->sk;
0554     int rc = -EINVAL;
0555 
0556     lock_sock(sk);
0557     if (unlikely(sock->state != SS_UNCONNECTED))
0558         goto out;
0559     rc = -EOPNOTSUPP;
0560     if (unlikely(sk->sk_type != SOCK_STREAM))
0561         goto out;
0562     rc = -EAGAIN;
0563     if (sock_flag(sk, SOCK_ZAPPED))
0564         goto out;
0565     rc = 0;
0566     if (!(unsigned int)backlog) /* BSDism */
0567         backlog = 1;
0568     sk->sk_max_ack_backlog = backlog;
0569     if (sk->sk_state != TCP_LISTEN) {
0570         sk->sk_ack_backlog = 0;
0571         sk->sk_state       = TCP_LISTEN;
0572     }
0573     sk->sk_socket->flags |= __SO_ACCEPTCON;
0574 out:
0575     release_sock(sk);
0576     return rc;
0577 }
0578 
0579 static int llc_ui_wait_for_disc(struct sock *sk, long timeout)
0580 {
0581     DEFINE_WAIT_FUNC(wait, woken_wake_function);
0582     int rc = 0;
0583 
0584     add_wait_queue(sk_sleep(sk), &wait);
0585     while (1) {
0586         if (sk_wait_event(sk, &timeout, sk->sk_state == TCP_CLOSE, &wait))
0587             break;
0588         rc = -ERESTARTSYS;
0589         if (signal_pending(current))
0590             break;
0591         rc = -EAGAIN;
0592         if (!timeout)
0593             break;
0594         rc = 0;
0595     }
0596     remove_wait_queue(sk_sleep(sk), &wait);
0597     return rc;
0598 }
0599 
0600 static bool llc_ui_wait_for_conn(struct sock *sk, long timeout)
0601 {
0602     DEFINE_WAIT_FUNC(wait, woken_wake_function);
0603 
0604     add_wait_queue(sk_sleep(sk), &wait);
0605     while (1) {
0606         if (sk_wait_event(sk, &timeout, sk->sk_state != TCP_SYN_SENT, &wait))
0607             break;
0608         if (signal_pending(current) || !timeout)
0609             break;
0610     }
0611     remove_wait_queue(sk_sleep(sk), &wait);
0612     return timeout;
0613 }
0614 
0615 static int llc_ui_wait_for_busy_core(struct sock *sk, long timeout)
0616 {
0617     DEFINE_WAIT_FUNC(wait, woken_wake_function);
0618     struct llc_sock *llc = llc_sk(sk);
0619     int rc;
0620 
0621     add_wait_queue(sk_sleep(sk), &wait);
0622     while (1) {
0623         rc = 0;
0624         if (sk_wait_event(sk, &timeout,
0625                   (sk->sk_shutdown & RCV_SHUTDOWN) ||
0626                   (!llc_data_accept_state(llc->state) &&
0627                    !llc->remote_busy_flag &&
0628                    !llc->p_flag), &wait))
0629             break;
0630         rc = -ERESTARTSYS;
0631         if (signal_pending(current))
0632             break;
0633         rc = -EAGAIN;
0634         if (!timeout)
0635             break;
0636     }
0637     remove_wait_queue(sk_sleep(sk), &wait);
0638     return rc;
0639 }
0640 
0641 static int llc_wait_data(struct sock *sk, long timeo)
0642 {
0643     int rc;
0644 
0645     while (1) {
0646         /*
0647          * POSIX 1003.1g mandates this order.
0648          */
0649         rc = sock_error(sk);
0650         if (rc)
0651             break;
0652         rc = 0;
0653         if (sk->sk_shutdown & RCV_SHUTDOWN)
0654             break;
0655         rc = -EAGAIN;
0656         if (!timeo)
0657             break;
0658         rc = sock_intr_errno(timeo);
0659         if (signal_pending(current))
0660             break;
0661         rc = 0;
0662         if (sk_wait_data(sk, &timeo, NULL))
0663             break;
0664     }
0665     return rc;
0666 }
0667 
0668 static void llc_cmsg_rcv(struct msghdr *msg, struct sk_buff *skb)
0669 {
0670     struct llc_sock *llc = llc_sk(skb->sk);
0671 
0672     if (llc->cmsg_flags & LLC_CMSG_PKTINFO) {
0673         struct llc_pktinfo info;
0674 
0675         memset(&info, 0, sizeof(info));
0676         info.lpi_ifindex = llc_sk(skb->sk)->dev->ifindex;
0677         llc_pdu_decode_dsap(skb, &info.lpi_sap);
0678         llc_pdu_decode_da(skb, info.lpi_mac);
0679         put_cmsg(msg, SOL_LLC, LLC_OPT_PKTINFO, sizeof(info), &info);
0680     }
0681 }
0682 
0683 /**
0684  *  llc_ui_accept - accept a new incoming connection.
0685  *  @sock: Socket which connections arrive on.
0686  *  @newsock: Socket to move incoming connection to.
0687  *  @flags: User specified operational flags.
0688  *  @kern: If the socket is kernel internal
0689  *
0690  *  Accept a new incoming connection.
0691  *  Returns 0 upon success, negative otherwise.
0692  */
0693 static int llc_ui_accept(struct socket *sock, struct socket *newsock, int flags,
0694              bool kern)
0695 {
0696     struct sock *sk = sock->sk, *newsk;
0697     struct llc_sock *llc, *newllc;
0698     struct sk_buff *skb;
0699     int rc = -EOPNOTSUPP;
0700 
0701     dprintk("%s: accepting on %02X\n", __func__,
0702         llc_sk(sk)->laddr.lsap);
0703     lock_sock(sk);
0704     if (unlikely(sk->sk_type != SOCK_STREAM))
0705         goto out;
0706     rc = -EINVAL;
0707     if (unlikely(sock->state != SS_UNCONNECTED ||
0708              sk->sk_state != TCP_LISTEN))
0709         goto out;
0710     /* wait for a connection to arrive. */
0711     if (skb_queue_empty(&sk->sk_receive_queue)) {
0712         rc = llc_wait_data(sk, sk->sk_rcvtimeo);
0713         if (rc)
0714             goto out;
0715     }
0716     dprintk("%s: got a new connection on %02X\n", __func__,
0717         llc_sk(sk)->laddr.lsap);
0718     skb = skb_dequeue(&sk->sk_receive_queue);
0719     rc = -EINVAL;
0720     if (!skb->sk)
0721         goto frees;
0722     rc = 0;
0723     newsk = skb->sk;
0724     /* attach connection to a new socket. */
0725     llc_ui_sk_init(newsock, newsk);
0726     sock_reset_flag(newsk, SOCK_ZAPPED);
0727     newsk->sk_state     = TCP_ESTABLISHED;
0728     newsock->state      = SS_CONNECTED;
0729     llc         = llc_sk(sk);
0730     newllc          = llc_sk(newsk);
0731     memcpy(&newllc->addr, &llc->addr, sizeof(newllc->addr));
0732     newllc->link = llc_ui_next_link_no(newllc->laddr.lsap);
0733 
0734     /* put original socket back into a clean listen state. */
0735     sk->sk_state = TCP_LISTEN;
0736     sk_acceptq_removed(sk);
0737     dprintk("%s: ok success on %02X, client on %02X\n", __func__,
0738         llc_sk(sk)->addr.sllc_sap, newllc->daddr.lsap);
0739 frees:
0740     kfree_skb(skb);
0741 out:
0742     release_sock(sk);
0743     return rc;
0744 }
0745 
0746 /**
0747  *  llc_ui_recvmsg - copy received data to the socket user.
0748  *  @sock: Socket to copy data from.
0749  *  @msg: Various user space related information.
0750  *  @len: Size of user buffer.
0751  *  @flags: User specified flags.
0752  *
0753  *  Copy received data to the socket user.
0754  *  Returns non-negative upon success, negative otherwise.
0755  */
0756 static int llc_ui_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
0757               int flags)
0758 {
0759     DECLARE_SOCKADDR(struct sockaddr_llc *, uaddr, msg->msg_name);
0760     const int nonblock = flags & MSG_DONTWAIT;
0761     struct sk_buff *skb = NULL;
0762     struct sock *sk = sock->sk;
0763     struct llc_sock *llc = llc_sk(sk);
0764     size_t copied = 0;
0765     u32 peek_seq = 0;
0766     u32 *seq, skb_len;
0767     unsigned long used;
0768     int target; /* Read at least this many bytes */
0769     long timeo;
0770 
0771     lock_sock(sk);
0772     copied = -ENOTCONN;
0773     if (unlikely(sk->sk_type == SOCK_STREAM && sk->sk_state == TCP_LISTEN))
0774         goto out;
0775 
0776     timeo = sock_rcvtimeo(sk, nonblock);
0777 
0778     seq = &llc->copied_seq;
0779     if (flags & MSG_PEEK) {
0780         peek_seq = llc->copied_seq;
0781         seq = &peek_seq;
0782     }
0783 
0784     target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
0785     copied = 0;
0786 
0787     do {
0788         u32 offset;
0789 
0790         /*
0791          * We need to check signals first, to get correct SIGURG
0792          * handling. FIXME: Need to check this doesn't impact 1003.1g
0793          * and move it down to the bottom of the loop
0794          */
0795         if (signal_pending(current)) {
0796             if (copied)
0797                 break;
0798             copied = timeo ? sock_intr_errno(timeo) : -EAGAIN;
0799             break;
0800         }
0801 
0802         /* Next get a buffer. */
0803 
0804         skb = skb_peek(&sk->sk_receive_queue);
0805         if (skb) {
0806             offset = *seq;
0807             goto found_ok_skb;
0808         }
0809         /* Well, if we have backlog, try to process it now yet. */
0810 
0811         if (copied >= target && !READ_ONCE(sk->sk_backlog.tail))
0812             break;
0813 
0814         if (copied) {
0815             if (sk->sk_err ||
0816                 sk->sk_state == TCP_CLOSE ||
0817                 (sk->sk_shutdown & RCV_SHUTDOWN) ||
0818                 !timeo ||
0819                 (flags & MSG_PEEK))
0820                 break;
0821         } else {
0822             if (sock_flag(sk, SOCK_DONE))
0823                 break;
0824 
0825             if (sk->sk_err) {
0826                 copied = sock_error(sk);
0827                 break;
0828             }
0829             if (sk->sk_shutdown & RCV_SHUTDOWN)
0830                 break;
0831 
0832             if (sk->sk_type == SOCK_STREAM && sk->sk_state == TCP_CLOSE) {
0833                 if (!sock_flag(sk, SOCK_DONE)) {
0834                     /*
0835                      * This occurs when user tries to read
0836                      * from never connected socket.
0837                      */
0838                     copied = -ENOTCONN;
0839                     break;
0840                 }
0841                 break;
0842             }
0843             if (!timeo) {
0844                 copied = -EAGAIN;
0845                 break;
0846             }
0847         }
0848 
0849         if (copied >= target) { /* Do not sleep, just process backlog. */
0850             release_sock(sk);
0851             lock_sock(sk);
0852         } else
0853             sk_wait_data(sk, &timeo, NULL);
0854 
0855         if ((flags & MSG_PEEK) && peek_seq != llc->copied_seq) {
0856             net_dbg_ratelimited("LLC(%s:%d): Application bug, race in MSG_PEEK\n",
0857                         current->comm,
0858                         task_pid_nr(current));
0859             peek_seq = llc->copied_seq;
0860         }
0861         continue;
0862     found_ok_skb:
0863         skb_len = skb->len;
0864         /* Ok so how much can we use? */
0865         used = skb->len - offset;
0866         if (len < used)
0867             used = len;
0868 
0869         if (!(flags & MSG_TRUNC)) {
0870             int rc = skb_copy_datagram_msg(skb, offset, msg, used);
0871             if (rc) {
0872                 /* Exception. Bailout! */
0873                 if (!copied)
0874                     copied = -EFAULT;
0875                 break;
0876             }
0877         }
0878 
0879         *seq += used;
0880         copied += used;
0881         len -= used;
0882 
0883         /* For non stream protcols we get one packet per recvmsg call */
0884         if (sk->sk_type != SOCK_STREAM)
0885             goto copy_uaddr;
0886 
0887         if (!(flags & MSG_PEEK)) {
0888             skb_unlink(skb, &sk->sk_receive_queue);
0889             kfree_skb(skb);
0890             *seq = 0;
0891         }
0892 
0893         /* Partial read */
0894         if (used + offset < skb_len)
0895             continue;
0896     } while (len > 0);
0897 
0898 out:
0899     release_sock(sk);
0900     return copied;
0901 copy_uaddr:
0902     if (uaddr != NULL && skb != NULL) {
0903         memcpy(uaddr, llc_ui_skb_cb(skb), sizeof(*uaddr));
0904         msg->msg_namelen = sizeof(*uaddr);
0905     }
0906     if (llc_sk(sk)->cmsg_flags)
0907         llc_cmsg_rcv(msg, skb);
0908 
0909     if (!(flags & MSG_PEEK)) {
0910         skb_unlink(skb, &sk->sk_receive_queue);
0911         kfree_skb(skb);
0912         *seq = 0;
0913     }
0914 
0915     goto out;
0916 }
0917 
0918 /**
0919  *  llc_ui_sendmsg - Transmit data provided by the socket user.
0920  *  @sock: Socket to transmit data from.
0921  *  @msg: Various user related information.
0922  *  @len: Length of data to transmit.
0923  *
0924  *  Transmit data provided by the socket user.
0925  *  Returns non-negative upon success, negative otherwise.
0926  */
0927 static int llc_ui_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
0928 {
0929     struct sock *sk = sock->sk;
0930     struct llc_sock *llc = llc_sk(sk);
0931     DECLARE_SOCKADDR(struct sockaddr_llc *, addr, msg->msg_name);
0932     int flags = msg->msg_flags;
0933     int noblock = flags & MSG_DONTWAIT;
0934     struct sk_buff *skb = NULL;
0935     size_t size = 0;
0936     int rc = -EINVAL, copied = 0, hdrlen;
0937 
0938     dprintk("%s: sending from %02X to %02X\n", __func__,
0939         llc->laddr.lsap, llc->daddr.lsap);
0940     lock_sock(sk);
0941     if (addr) {
0942         if (msg->msg_namelen < sizeof(*addr))
0943             goto out;
0944     } else {
0945         if (llc_ui_addr_null(&llc->addr))
0946             goto out;
0947         addr = &llc->addr;
0948     }
0949     /* must bind connection to sap if user hasn't done it. */
0950     if (sock_flag(sk, SOCK_ZAPPED)) {
0951         /* bind to sap with null dev, exclusive. */
0952         rc = llc_ui_autobind(sock, addr);
0953         if (rc)
0954             goto out;
0955     }
0956     hdrlen = llc->dev->hard_header_len + llc_ui_header_len(sk, addr);
0957     size = hdrlen + len;
0958     if (size > llc->dev->mtu)
0959         size = llc->dev->mtu;
0960     copied = size - hdrlen;
0961     rc = -EINVAL;
0962     if (copied < 0)
0963         goto out;
0964     release_sock(sk);
0965     skb = sock_alloc_send_skb(sk, size, noblock, &rc);
0966     lock_sock(sk);
0967     if (!skb)
0968         goto out;
0969     skb->dev      = llc->dev;
0970     skb->protocol = llc_proto_type(addr->sllc_arphrd);
0971     skb_reserve(skb, hdrlen);
0972     rc = memcpy_from_msg(skb_put(skb, copied), msg, copied);
0973     if (rc)
0974         goto out;
0975     if (sk->sk_type == SOCK_DGRAM || addr->sllc_ua) {
0976         llc_build_and_send_ui_pkt(llc->sap, skb, addr->sllc_mac,
0977                       addr->sllc_sap);
0978         skb = NULL;
0979         goto out;
0980     }
0981     if (addr->sllc_test) {
0982         llc_build_and_send_test_pkt(llc->sap, skb, addr->sllc_mac,
0983                         addr->sllc_sap);
0984         skb = NULL;
0985         goto out;
0986     }
0987     if (addr->sllc_xid) {
0988         llc_build_and_send_xid_pkt(llc->sap, skb, addr->sllc_mac,
0989                        addr->sllc_sap);
0990         skb = NULL;
0991         goto out;
0992     }
0993     rc = -ENOPROTOOPT;
0994     if (!(sk->sk_type == SOCK_STREAM && !addr->sllc_ua))
0995         goto out;
0996     rc = llc_ui_send_data(sk, skb, noblock);
0997     skb = NULL;
0998 out:
0999     kfree_skb(skb);
1000     if (rc)
1001         dprintk("%s: failed sending from %02X to %02X: %d\n",
1002             __func__, llc->laddr.lsap, llc->daddr.lsap, rc);
1003     release_sock(sk);
1004     return rc ? : copied;
1005 }
1006 
1007 /**
1008  *  llc_ui_getname - return the address info of a socket
1009  *  @sock: Socket to get address of.
1010  *  @uaddr: Address structure to return information.
1011  *  @peer: Does user want local or remote address information.
1012  *
1013  *  Return the address information of a socket.
1014  */
1015 static int llc_ui_getname(struct socket *sock, struct sockaddr *uaddr,
1016               int peer)
1017 {
1018     struct sockaddr_llc sllc;
1019     struct sock *sk = sock->sk;
1020     struct llc_sock *llc = llc_sk(sk);
1021     int rc = -EBADF;
1022 
1023     memset(&sllc, 0, sizeof(sllc));
1024     lock_sock(sk);
1025     if (sock_flag(sk, SOCK_ZAPPED))
1026         goto out;
1027     if (peer) {
1028         rc = -ENOTCONN;
1029         if (sk->sk_state != TCP_ESTABLISHED)
1030             goto out;
1031         if(llc->dev)
1032             sllc.sllc_arphrd = llc->dev->type;
1033         sllc.sllc_sap = llc->daddr.lsap;
1034         memcpy(&sllc.sllc_mac, &llc->daddr.mac, IFHWADDRLEN);
1035     } else {
1036         rc = -EINVAL;
1037         if (!llc->sap)
1038             goto out;
1039         sllc.sllc_sap = llc->sap->laddr.lsap;
1040 
1041         if (llc->dev) {
1042             sllc.sllc_arphrd = llc->dev->type;
1043             memcpy(&sllc.sllc_mac, llc->dev->dev_addr,
1044                    IFHWADDRLEN);
1045         }
1046     }
1047     sllc.sllc_family = AF_LLC;
1048     memcpy(uaddr, &sllc, sizeof(sllc));
1049     rc = sizeof(sllc);
1050 out:
1051     release_sock(sk);
1052     return rc;
1053 }
1054 
1055 /**
1056  *  llc_ui_ioctl - io controls for PF_LLC
1057  *  @sock: Socket to get/set info
1058  *  @cmd: command
1059  *  @arg: optional argument for cmd
1060  *
1061  *  get/set info on llc sockets
1062  */
1063 static int llc_ui_ioctl(struct socket *sock, unsigned int cmd,
1064             unsigned long arg)
1065 {
1066     return -ENOIOCTLCMD;
1067 }
1068 
1069 /**
1070  *  llc_ui_setsockopt - set various connection specific parameters.
1071  *  @sock: Socket to set options on.
1072  *  @level: Socket level user is requesting operations on.
1073  *  @optname: Operation name.
1074  *  @optval: User provided operation data.
1075  *  @optlen: Length of optval.
1076  *
1077  *  Set various connection specific parameters.
1078  */
1079 static int llc_ui_setsockopt(struct socket *sock, int level, int optname,
1080                  sockptr_t optval, unsigned int optlen)
1081 {
1082     struct sock *sk = sock->sk;
1083     struct llc_sock *llc = llc_sk(sk);
1084     unsigned int opt;
1085     int rc = -EINVAL;
1086 
1087     lock_sock(sk);
1088     if (unlikely(level != SOL_LLC || optlen != sizeof(int)))
1089         goto out;
1090     rc = copy_from_sockptr(&opt, optval, sizeof(opt));
1091     if (rc)
1092         goto out;
1093     rc = -EINVAL;
1094     switch (optname) {
1095     case LLC_OPT_RETRY:
1096         if (opt > LLC_OPT_MAX_RETRY)
1097             goto out;
1098         llc->n2 = opt;
1099         break;
1100     case LLC_OPT_SIZE:
1101         if (opt > LLC_OPT_MAX_SIZE)
1102             goto out;
1103         llc->n1 = opt;
1104         break;
1105     case LLC_OPT_ACK_TMR_EXP:
1106         if (opt > LLC_OPT_MAX_ACK_TMR_EXP)
1107             goto out;
1108         llc->ack_timer.expire = opt * HZ;
1109         break;
1110     case LLC_OPT_P_TMR_EXP:
1111         if (opt > LLC_OPT_MAX_P_TMR_EXP)
1112             goto out;
1113         llc->pf_cycle_timer.expire = opt * HZ;
1114         break;
1115     case LLC_OPT_REJ_TMR_EXP:
1116         if (opt > LLC_OPT_MAX_REJ_TMR_EXP)
1117             goto out;
1118         llc->rej_sent_timer.expire = opt * HZ;
1119         break;
1120     case LLC_OPT_BUSY_TMR_EXP:
1121         if (opt > LLC_OPT_MAX_BUSY_TMR_EXP)
1122             goto out;
1123         llc->busy_state_timer.expire = opt * HZ;
1124         break;
1125     case LLC_OPT_TX_WIN:
1126         if (opt > LLC_OPT_MAX_WIN)
1127             goto out;
1128         llc->k = opt;
1129         break;
1130     case LLC_OPT_RX_WIN:
1131         if (opt > LLC_OPT_MAX_WIN)
1132             goto out;
1133         llc->rw = opt;
1134         break;
1135     case LLC_OPT_PKTINFO:
1136         if (opt)
1137             llc->cmsg_flags |= LLC_CMSG_PKTINFO;
1138         else
1139             llc->cmsg_flags &= ~LLC_CMSG_PKTINFO;
1140         break;
1141     default:
1142         rc = -ENOPROTOOPT;
1143         goto out;
1144     }
1145     rc = 0;
1146 out:
1147     release_sock(sk);
1148     return rc;
1149 }
1150 
1151 /**
1152  *  llc_ui_getsockopt - get connection specific socket info
1153  *  @sock: Socket to get information from.
1154  *  @level: Socket level user is requesting operations on.
1155  *  @optname: Operation name.
1156  *  @optval: Variable to return operation data in.
1157  *  @optlen: Length of optval.
1158  *
1159  *  Get connection specific socket information.
1160  */
1161 static int llc_ui_getsockopt(struct socket *sock, int level, int optname,
1162                  char __user *optval, int __user *optlen)
1163 {
1164     struct sock *sk = sock->sk;
1165     struct llc_sock *llc = llc_sk(sk);
1166     int val = 0, len = 0, rc = -EINVAL;
1167 
1168     lock_sock(sk);
1169     if (unlikely(level != SOL_LLC))
1170         goto out;
1171     rc = get_user(len, optlen);
1172     if (rc)
1173         goto out;
1174     rc = -EINVAL;
1175     if (len != sizeof(int))
1176         goto out;
1177     switch (optname) {
1178     case LLC_OPT_RETRY:
1179         val = llc->n2;                  break;
1180     case LLC_OPT_SIZE:
1181         val = llc->n1;                  break;
1182     case LLC_OPT_ACK_TMR_EXP:
1183         val = llc->ack_timer.expire / HZ;       break;
1184     case LLC_OPT_P_TMR_EXP:
1185         val = llc->pf_cycle_timer.expire / HZ;      break;
1186     case LLC_OPT_REJ_TMR_EXP:
1187         val = llc->rej_sent_timer.expire / HZ;      break;
1188     case LLC_OPT_BUSY_TMR_EXP:
1189         val = llc->busy_state_timer.expire / HZ;    break;
1190     case LLC_OPT_TX_WIN:
1191         val = llc->k;               break;
1192     case LLC_OPT_RX_WIN:
1193         val = llc->rw;              break;
1194     case LLC_OPT_PKTINFO:
1195         val = (llc->cmsg_flags & LLC_CMSG_PKTINFO) != 0;
1196         break;
1197     default:
1198         rc = -ENOPROTOOPT;
1199         goto out;
1200     }
1201     rc = 0;
1202     if (put_user(len, optlen) || copy_to_user(optval, &val, len))
1203         rc = -EFAULT;
1204 out:
1205     release_sock(sk);
1206     return rc;
1207 }
1208 
1209 static const struct net_proto_family llc_ui_family_ops = {
1210     .family = PF_LLC,
1211     .create = llc_ui_create,
1212     .owner  = THIS_MODULE,
1213 };
1214 
1215 static const struct proto_ops llc_ui_ops = {
1216     .family      = PF_LLC,
1217     .owner       = THIS_MODULE,
1218     .release     = llc_ui_release,
1219     .bind        = llc_ui_bind,
1220     .connect     = llc_ui_connect,
1221     .socketpair  = sock_no_socketpair,
1222     .accept      = llc_ui_accept,
1223     .getname     = llc_ui_getname,
1224     .poll        = datagram_poll,
1225     .ioctl       = llc_ui_ioctl,
1226     .listen      = llc_ui_listen,
1227     .shutdown    = llc_ui_shutdown,
1228     .setsockopt  = llc_ui_setsockopt,
1229     .getsockopt  = llc_ui_getsockopt,
1230     .sendmsg     = llc_ui_sendmsg,
1231     .recvmsg     = llc_ui_recvmsg,
1232     .mmap        = sock_no_mmap,
1233     .sendpage    = sock_no_sendpage,
1234 };
1235 
1236 static const char llc_proc_err_msg[] __initconst =
1237     KERN_CRIT "LLC: Unable to register the proc_fs entries\n";
1238 static const char llc_sysctl_err_msg[] __initconst =
1239     KERN_CRIT "LLC: Unable to register the sysctl entries\n";
1240 static const char llc_sock_err_msg[] __initconst =
1241     KERN_CRIT "LLC: Unable to register the network family\n";
1242 
1243 static int __init llc2_init(void)
1244 {
1245     int rc = proto_register(&llc_proto, 0);
1246 
1247     if (rc != 0)
1248         goto out;
1249 
1250     llc_build_offset_table();
1251     llc_station_init();
1252     llc_ui_sap_last_autoport = LLC_SAP_DYN_START;
1253     rc = llc_proc_init();
1254     if (rc != 0) {
1255         printk(llc_proc_err_msg);
1256         goto out_station;
1257     }
1258     rc = llc_sysctl_init();
1259     if (rc) {
1260         printk(llc_sysctl_err_msg);
1261         goto out_proc;
1262     }
1263     rc = sock_register(&llc_ui_family_ops);
1264     if (rc) {
1265         printk(llc_sock_err_msg);
1266         goto out_sysctl;
1267     }
1268     llc_add_pack(LLC_DEST_SAP, llc_sap_handler);
1269     llc_add_pack(LLC_DEST_CONN, llc_conn_handler);
1270 out:
1271     return rc;
1272 out_sysctl:
1273     llc_sysctl_exit();
1274 out_proc:
1275     llc_proc_exit();
1276 out_station:
1277     llc_station_exit();
1278     proto_unregister(&llc_proto);
1279     goto out;
1280 }
1281 
1282 static void __exit llc2_exit(void)
1283 {
1284     llc_station_exit();
1285     llc_remove_pack(LLC_DEST_SAP);
1286     llc_remove_pack(LLC_DEST_CONN);
1287     sock_unregister(PF_LLC);
1288     llc_proc_exit();
1289     llc_sysctl_exit();
1290     proto_unregister(&llc_proto);
1291 }
1292 
1293 module_init(llc2_init);
1294 module_exit(llc2_exit);
1295 
1296 MODULE_LICENSE("GPL");
1297 MODULE_AUTHOR("Procom 1997, Jay Schullist 2001, Arnaldo C. Melo 2001-2003");
1298 MODULE_DESCRIPTION("IEEE 802.2 PF_LLC support");
1299 MODULE_ALIAS_NETPROTO(PF_LLC);
[ 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!