linux/net/llc/af_llc.c
<<
>>
Prefs
   1/*
   2 * af_llc.c - LLC User Interface SAPs
   3 * Description:
   4 *   Functions in this module are implementation of socket based llc
   5 *   communications for the Linux operating system. Support of llc class
   6 *   one and class two is provided via SOCK_DGRAM and SOCK_STREAM
   7 *   respectively.
   8 *
   9 *   An llc2 connection is (mac + sap), only one llc2 sap connection
  10 *   is allowed per mac. Though one sap may have multiple mac + sap
  11 *   connections.
  12 *
  13 * Copyright (c) 2001 by Jay Schulist <jschlst@samba.org>
  14 *               2002-2003 by Arnaldo Carvalho de Melo <acme@conectiva.com.br>
  15 *
  16 * This program can be redistributed or modified under the terms of the
  17 * GNU General Public License as published by the Free Software Foundation.
  18 * This program is distributed without any warranty or implied warranty
  19 * of merchantability or fitness for a particular purpose.
  20 *
  21 * See the GNU General Public License for more details.
  22 */
  23#include <linux/compiler.h>
  24#include <linux/kernel.h>
  25#include <linux/module.h>
  26#include <linux/rtnetlink.h>
  27#include <linux/init.h>
  28#include <linux/slab.h>
  29#include <linux/sched/signal.h>
  30
  31#include <net/llc.h>
  32#include <net/llc_sap.h>
  33#include <net/llc_pdu.h>
  34#include <net/llc_conn.h>
  35#include <net/tcp_states.h>
  36
  37/* remember: uninitialized global data is zeroed because its in .bss */
  38static u16 llc_ui_sap_last_autoport = LLC_SAP_DYN_START;
  39static u16 llc_ui_sap_link_no_max[256];
  40static struct sockaddr_llc llc_ui_addrnull;
  41static const struct proto_ops llc_ui_ops;
  42
  43static bool llc_ui_wait_for_conn(struct sock *sk, long timeout);
  44static int llc_ui_wait_for_disc(struct sock *sk, long timeout);
  45static int llc_ui_wait_for_busy_core(struct sock *sk, long timeout);
  46
  47#if 0
  48#define dprintk(args...) printk(KERN_DEBUG args)
  49#else
  50#define dprintk(args...) do {} while (0)
  51#endif
  52
  53/* Maybe we'll add some more in the future. */
  54#define LLC_CMSG_PKTINFO        1
  55
  56
  57/**
  58 *      llc_ui_next_link_no - return the next unused link number for a sap
  59 *      @sap: Address of sap to get link number from.
  60 *
  61 *      Return the next unused link number for a given sap.
  62 */
  63static inline u16 llc_ui_next_link_no(int sap)
  64{
  65        return llc_ui_sap_link_no_max[sap]++;
  66}
  67
  68/**
  69 *      llc_proto_type - return eth protocol for ARP header type
  70 *      @arphrd: ARP header type.
  71 *
  72 *      Given an ARP header type return the corresponding ethernet protocol.
  73 */
  74static inline __be16 llc_proto_type(u16 arphrd)
  75{
  76        return htons(ETH_P_802_2);
  77}
  78
  79/**
  80 *      llc_ui_addr_null - determines if a address structure is null
  81 *      @addr: Address to test if null.
  82 */
  83static inline u8 llc_ui_addr_null(struct sockaddr_llc *addr)
  84{
  85        return !memcmp(addr, &llc_ui_addrnull, sizeof(*addr));
  86}
  87
  88/**
  89 *      llc_ui_header_len - return length of llc header based on operation
  90 *      @sk: Socket which contains a valid llc socket type.
  91 *      @addr: Complete sockaddr_llc structure received from the user.
  92 *
  93 *      Provide the length of the llc header depending on what kind of
  94 *      operation the user would like to perform and the type of socket.
  95 *      Returns the correct llc header length.
  96 */
  97static inline u8 llc_ui_header_len(struct sock *sk, struct sockaddr_llc *addr)
  98{
  99        u8 rc = LLC_PDU_LEN_U;
 100
 101        if (addr->sllc_test)
 102                rc = LLC_PDU_LEN_U;
 103        else if (addr->sllc_xid)
 104                /* We need to expand header to sizeof(struct llc_xid_info)
 105                 * since llc_pdu_init_as_xid_cmd() sets 4,5,6 bytes of LLC header
 106                 * as XID PDU. In llc_ui_sendmsg() we reserved header size and then
 107                 * filled all other space with user data. If we won't reserve this
 108                 * bytes, llc_pdu_init_as_xid_cmd() will overwrite user data
 109                 */
 110                rc = LLC_PDU_LEN_U_XID;
 111        else if (sk->sk_type == SOCK_STREAM)
 112                rc = LLC_PDU_LEN_I;
 113        return rc;
 114}
 115
 116/**
 117 *      llc_ui_send_data - send data via reliable llc2 connection
 118 *      @sk: Connection the socket is using.
 119 *      @skb: Data the user wishes to send.
 120 *      @noblock: can we block waiting for data?
 121 *
 122 *      Send data via reliable llc2 connection.
 123 *      Returns 0 upon success, non-zero if action did not succeed.
 124 *
 125 *      This function always consumes a reference to the skb.
 126 */
 127static int llc_ui_send_data(struct sock* sk, struct sk_buff *skb, int noblock)
 128{
 129        struct llc_sock* llc = llc_sk(sk);
 130
 131        if (unlikely(llc_data_accept_state(llc->state) ||
 132                     llc->remote_busy_flag ||
 133                     llc->p_flag)) {
 134                long timeout = sock_sndtimeo(sk, noblock);
 135                int rc;
 136
 137                rc = llc_ui_wait_for_busy_core(sk, timeout);
 138                if (rc) {
 139                        kfree_skb(skb);
 140                        return rc;
 141                }
 142        }
 143        return llc_build_and_send_pkt(sk, skb);
 144}
 145
 146static void llc_ui_sk_init(struct socket *sock, struct sock *sk)
 147{
 148        sock_graft(sk, sock);
 149        sk->sk_type     = sock->type;
 150        sock->ops       = &llc_ui_ops;
 151}
 152
 153static struct proto llc_proto = {
 154        .name     = "LLC",
 155        .owner    = THIS_MODULE,
 156        .obj_size = sizeof(struct llc_sock),
 157        .slab_flags = SLAB_TYPESAFE_BY_RCU,
 158};
 159
 160/**
 161 *      llc_ui_create - alloc and init a new llc_ui socket
 162 *      @net: network namespace (must be default network)
 163 *      @sock: Socket to initialize and attach allocated sk to.
 164 *      @protocol: Unused.
 165 *      @kern: on behalf of kernel or userspace
 166 *
 167 *      Allocate and initialize a new llc_ui socket, validate the user wants a
 168 *      socket type we have available.
 169 *      Returns 0 upon success, negative upon failure.
 170 */
 171static int llc_ui_create(struct net *net, struct socket *sock, int protocol,
 172                         int kern)
 173{
 174        struct sock *sk;
 175        int rc = -ESOCKTNOSUPPORT;
 176
 177        if (!ns_capable(net->user_ns, CAP_NET_RAW))
 178                return -EPERM;
 179
 180        if (!net_eq(net, &init_net))
 181                return -EAFNOSUPPORT;
 182
 183        if (likely(sock->type == SOCK_DGRAM || sock->type == SOCK_STREAM)) {
 184                rc = -ENOMEM;
 185                sk = llc_sk_alloc(net, PF_LLC, GFP_KERNEL, &llc_proto, kern);
 186                if (sk) {
 187                        rc = 0;
 188                        llc_ui_sk_init(sock, sk);
 189                }
 190        }
 191        return rc;
 192}
 193
 194/**
 195 *      llc_ui_release - shutdown socket
 196 *      @sock: Socket to release.
 197 *
 198 *      Shutdown and deallocate an existing socket.
 199 */
 200static int llc_ui_release(struct socket *sock)
 201{
 202        struct sock *sk = sock->sk;
 203        struct llc_sock *llc;
 204
 205        if (unlikely(sk == NULL))
 206                goto out;
 207        sock_hold(sk);
 208        lock_sock(sk);
 209        llc = llc_sk(sk);
 210        dprintk("%s: closing local(%02X) remote(%02X)\n", __func__,
 211                llc->laddr.lsap, llc->daddr.lsap);
 212        if (!llc_send_disc(sk))
 213                llc_ui_wait_for_disc(sk, sk->sk_rcvtimeo);
 214        if (!sock_flag(sk, SOCK_ZAPPED)) {
 215                struct llc_sap *sap = llc->sap;
 216
 217                /* Hold this for release_sock(), so that llc_backlog_rcv()
 218                 * could still use it.
 219                 */
 220                llc_sap_hold(sap);
 221                llc_sap_remove_socket(llc->sap, sk);
 222                release_sock(sk);
 223                llc_sap_put(sap);
 224        } else {
 225                release_sock(sk);
 226        }
 227        if (llc->dev)
 228                dev_put(llc->dev);
 229        sock_put(sk);
 230        llc_sk_free(sk);
 231out:
 232        return 0;
 233}
 234
 235/**
 236 *      llc_ui_autoport - provide dynamically allocate SAP number
 237 *
 238 *      Provide the caller with a dynamically allocated SAP number according
 239 *      to the rules that are set in this function. Returns: 0, upon failure,
 240 *      SAP number otherwise.
 241 */
 242static int llc_ui_autoport(void)
 243{
 244        struct llc_sap *sap;
 245        int i, tries = 0;
 246
 247        while (tries < LLC_SAP_DYN_TRIES) {
 248                for (i = llc_ui_sap_last_autoport;
 249                     i < LLC_SAP_DYN_STOP; i += 2) {
 250                        sap = llc_sap_find(i);
 251                        if (!sap) {
 252                                llc_ui_sap_last_autoport = i + 2;
 253                                goto out;
 254                        }
 255                        llc_sap_put(sap);
 256                }
 257                llc_ui_sap_last_autoport = LLC_SAP_DYN_START;
 258                tries++;
 259        }
 260        i = 0;
 261out:
 262        return i;
 263}
 264
 265/**
 266 *      llc_ui_autobind - automatically bind a socket to a sap
 267 *      @sock: socket to bind
 268 *      @addr: address to connect to
 269 *
 270 *      Used by llc_ui_connect and llc_ui_sendmsg when the user hasn't
 271 *      specifically used llc_ui_bind to bind to an specific address/sap
 272 *
 273 *      Returns: 0 upon success, negative otherwise.
 274 */
 275static int llc_ui_autobind(struct socket *sock, struct sockaddr_llc *addr)
 276{
 277        struct sock *sk = sock->sk;
 278        struct llc_sock *llc = llc_sk(sk);
 279        struct llc_sap *sap;
 280        int rc = -EINVAL;
 281
 282        if (!sock_flag(sk, SOCK_ZAPPED))
 283                goto out;
 284        if (!addr->sllc_arphrd)
 285                addr->sllc_arphrd = ARPHRD_ETHER;
 286        if (addr->sllc_arphrd != ARPHRD_ETHER)
 287                goto out;
 288        rc = -ENODEV;
 289        if (sk->sk_bound_dev_if) {
 290                llc->dev = dev_get_by_index(&init_net, sk->sk_bound_dev_if);
 291                if (llc->dev && addr->sllc_arphrd != llc->dev->type) {
 292                        dev_put(llc->dev);
 293                        llc->dev = NULL;
 294                }
 295        } else
 296                llc->dev = dev_getfirstbyhwtype(&init_net, addr->sllc_arphrd);
 297        if (!llc->dev)
 298                goto out;
 299        rc = -EUSERS;
 300        llc->laddr.lsap = llc_ui_autoport();
 301        if (!llc->laddr.lsap)
 302                goto out;
 303        rc = -EBUSY; /* some other network layer is using the sap */
 304        sap = llc_sap_open(llc->laddr.lsap, NULL);
 305        if (!sap)
 306                goto out;
 307        memcpy(llc->laddr.mac, llc->dev->dev_addr, IFHWADDRLEN);
 308        memcpy(&llc->addr, addr, sizeof(llc->addr));
 309        /* assign new connection to its SAP */
 310        llc_sap_add_socket(sap, sk);
 311        sock_reset_flag(sk, SOCK_ZAPPED);
 312        rc = 0;
 313out:
 314        return rc;
 315}
 316
 317/**
 318 *      llc_ui_bind - bind a socket to a specific address.
 319 *      @sock: Socket to bind an address to.
 320 *      @uaddr: Address the user wants the socket bound to.
 321 *      @addrlen: Length of the uaddr structure.
 322 *
 323 *      Bind a socket to a specific address. For llc a user is able to bind to
 324 *      a specific sap only or mac + sap.
 325 *      If the user desires to bind to a specific mac + sap, it is possible to
 326 *      have multiple sap connections via multiple macs.
 327 *      Bind and autobind for that matter must enforce the correct sap usage
 328 *      otherwise all hell will break loose.
 329 *      Returns: 0 upon success, negative otherwise.
 330 */
 331static int llc_ui_bind(struct socket *sock, struct sockaddr *uaddr, int addrlen)
 332{
 333        struct sockaddr_llc *addr = (struct sockaddr_llc *)uaddr;
 334        struct sock *sk = sock->sk;
 335        struct llc_sock *llc = llc_sk(sk);
 336        struct llc_sap *sap;
 337        int rc = -EINVAL;
 338
 339        lock_sock(sk);
 340        if (unlikely(!sock_flag(sk, SOCK_ZAPPED) || addrlen != sizeof(*addr)))
 341                goto out;
 342        rc = -EAFNOSUPPORT;
 343        if (!addr->sllc_arphrd)
 344                addr->sllc_arphrd = ARPHRD_ETHER;
 345        if (unlikely(addr->sllc_family != AF_LLC || addr->sllc_arphrd != ARPHRD_ETHER))
 346                goto out;
 347        dprintk("%s: binding %02X\n", __func__, addr->sllc_sap);
 348        rc = -ENODEV;
 349        rcu_read_lock();
 350        if (sk->sk_bound_dev_if) {
 351                llc->dev = dev_get_by_index_rcu(&init_net, sk->sk_bound_dev_if);
 352                if (llc->dev) {
 353                        if (is_zero_ether_addr(addr->sllc_mac))
 354                                memcpy(addr->sllc_mac, llc->dev->dev_addr,
 355                                       IFHWADDRLEN);
 356                        if (addr->sllc_arphrd != llc->dev->type ||
 357                            !ether_addr_equal(addr->sllc_mac,
 358                                              llc->dev->dev_addr)) {
 359                                rc = -EINVAL;
 360                                llc->dev = NULL;
 361                        }
 362                }
 363        } else
 364                llc->dev = dev_getbyhwaddr_rcu(&init_net, addr->sllc_arphrd,
 365                                           addr->sllc_mac);
 366        if (llc->dev)
 367                dev_hold(llc->dev);
 368        rcu_read_unlock();
 369        if (!llc->dev)
 370                goto out;
 371        if (!addr->sllc_sap) {
 372                rc = -EUSERS;
 373                addr->sllc_sap = llc_ui_autoport();
 374                if (!addr->sllc_sap)
 375                        goto out;
 376        }
 377        sap = llc_sap_find(addr->sllc_sap);
 378        if (!sap) {
 379                sap = llc_sap_open(addr->sllc_sap, NULL);
 380                rc = -EBUSY; /* some other network layer is using the sap */
 381                if (!sap)
 382                        goto out;
 383        } else {
 384                struct llc_addr laddr, daddr;
 385                struct sock *ask;
 386
 387                memset(&laddr, 0, sizeof(laddr));
 388                memset(&daddr, 0, sizeof(daddr));
 389                /*
 390                 * FIXME: check if the address is multicast,
 391                 *        only SOCK_DGRAM can do this.
 392                 */
 393                memcpy(laddr.mac, addr->sllc_mac, IFHWADDRLEN);
 394                laddr.lsap = addr->sllc_sap;
 395                rc = -EADDRINUSE; /* mac + sap clash. */
 396                ask = llc_lookup_established(sap, &daddr, &laddr);
 397                if (ask) {
 398                        sock_put(ask);
 399                        goto out_put;
 400                }
 401        }
 402        llc->laddr.lsap = addr->sllc_sap;
 403        memcpy(llc->laddr.mac, addr->sllc_mac, IFHWADDRLEN);
 404        memcpy(&llc->addr, addr, sizeof(llc->addr));
 405        /* assign new connection to its SAP */
 406        llc_sap_add_socket(sap, sk);
 407        sock_reset_flag(sk, SOCK_ZAPPED);
 408        rc = 0;
 409out_put:
 410        llc_sap_put(sap);
 411out:
 412        release_sock(sk);
 413        return rc;
 414}
 415
 416/**
 417 *      llc_ui_shutdown - shutdown a connect llc2 socket.
 418 *      @sock: Socket to shutdown.
 419 *      @how: What part of the socket to shutdown.
 420 *
 421 *      Shutdown a connected llc2 socket. Currently this function only supports
 422 *      shutting down both sends and receives (2), we could probably make this
 423 *      function such that a user can shutdown only half the connection but not
 424 *      right now.
 425 *      Returns: 0 upon success, negative otherwise.
 426 */
 427static int llc_ui_shutdown(struct socket *sock, int how)
 428{
 429        struct sock *sk = sock->sk;
 430        int rc = -ENOTCONN;
 431
 432        lock_sock(sk);
 433        if (unlikely(sk->sk_state != TCP_ESTABLISHED))
 434                goto out;
 435        rc = -EINVAL;
 436        if (how != 2)
 437                goto out;
 438        rc = llc_send_disc(sk);
 439        if (!rc)
 440                rc = llc_ui_wait_for_disc(sk, sk->sk_rcvtimeo);
 441        /* Wake up anyone sleeping in poll */
 442        sk->sk_state_change(sk);
 443out:
 444        release_sock(sk);
 445        return rc;
 446}
 447
 448/**
 449 *      llc_ui_connect - Connect to a remote llc2 mac + sap.
 450 *      @sock: Socket which will be connected to the remote destination.
 451 *      @uaddr: Remote and possibly the local address of the new connection.
 452 *      @addrlen: Size of uaddr structure.
 453 *      @flags: Operational flags specified by the user.
 454 *
 455 *      Connect to a remote llc2 mac + sap. The caller must specify the
 456 *      destination mac and address to connect to. If the user hasn't previously
 457 *      called bind(2) with a smac the address of the first interface of the
 458 *      specified arp type will be used.
 459 *      This function will autobind if user did not previously call bind.
 460 *      Returns: 0 upon success, negative otherwise.
 461 */
 462static int llc_ui_connect(struct socket *sock, struct sockaddr *uaddr,
 463                          int addrlen, int flags)
 464{
 465        struct sock *sk = sock->sk;
 466        struct llc_sock *llc = llc_sk(sk);
 467        struct sockaddr_llc *addr = (struct sockaddr_llc *)uaddr;
 468        int rc = -EINVAL;
 469
 470        lock_sock(sk);
 471        if (unlikely(addrlen != sizeof(*addr)))
 472                goto out;
 473        rc = -EAFNOSUPPORT;
 474        if (unlikely(addr->sllc_family != AF_LLC))
 475                goto out;
 476        if (unlikely(sk->sk_type != SOCK_STREAM))
 477                goto out;
 478        rc = -EALREADY;
 479        if (unlikely(sock->state == SS_CONNECTING))
 480                goto out;
 481        /* bind connection to sap if user hasn't done it. */
 482        if (sock_flag(sk, SOCK_ZAPPED)) {
 483                /* bind to sap with null dev, exclusive */
 484                rc = llc_ui_autobind(sock, addr);
 485                if (rc)
 486                        goto out;
 487        }
 488        llc->daddr.lsap = addr->sllc_sap;
 489        memcpy(llc->daddr.mac, addr->sllc_mac, IFHWADDRLEN);
 490        sock->state = SS_CONNECTING;
 491        sk->sk_state   = TCP_SYN_SENT;
 492        llc->link   = llc_ui_next_link_no(llc->sap->laddr.lsap);
 493        rc = llc_establish_connection(sk, llc->dev->dev_addr,
 494                                      addr->sllc_mac, addr->sllc_sap);
 495        if (rc) {
 496                dprintk("%s: llc_ui_send_conn failed :-(\n", __func__);
 497                sock->state  = SS_UNCONNECTED;
 498                sk->sk_state = TCP_CLOSE;
 499                goto out;
 500        }
 501
 502        if (sk->sk_state == TCP_SYN_SENT) {
 503                const long timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
 504
 505                if (!timeo || !llc_ui_wait_for_conn(sk, timeo))
 506                        goto out;
 507
 508                rc = sock_intr_errno(timeo);
 509                if (signal_pending(current))
 510                        goto out;
 511        }
 512
 513        if (sk->sk_state == TCP_CLOSE)
 514                goto sock_error;
 515
 516        sock->state = SS_CONNECTED;
 517        rc = 0;
 518out:
 519        release_sock(sk);
 520        return rc;
 521sock_error:
 522        rc = sock_error(sk) ? : -ECONNABORTED;
 523        sock->state = SS_UNCONNECTED;
 524        goto out;
 525}
 526
 527/**
 528 *      llc_ui_listen - allow a normal socket to accept incoming connections
 529 *      @sock: Socket to allow incoming connections on.
 530 *      @backlog: Number of connections to queue.
 531 *
 532 *      Allow a normal socket to accept incoming connections.
 533 *      Returns 0 upon success, negative otherwise.
 534 */
 535static int llc_ui_listen(struct socket *sock, int backlog)
 536{
 537        struct sock *sk = sock->sk;
 538        int rc = -EINVAL;
 539
 540        lock_sock(sk);
 541        if (unlikely(sock->state != SS_UNCONNECTED))
 542                goto out;
 543        rc = -EOPNOTSUPP;
 544        if (unlikely(sk->sk_type != SOCK_STREAM))
 545                goto out;
 546        rc = -EAGAIN;
 547        if (sock_flag(sk, SOCK_ZAPPED))
 548                goto out;
 549        rc = 0;
 550        if (!(unsigned int)backlog)     /* BSDism */
 551                backlog = 1;
 552        sk->sk_max_ack_backlog = backlog;
 553        if (sk->sk_state != TCP_LISTEN) {
 554                sk->sk_ack_backlog = 0;
 555                sk->sk_state       = TCP_LISTEN;
 556        }
 557        sk->sk_socket->flags |= __SO_ACCEPTCON;
 558out:
 559        release_sock(sk);
 560        return rc;
 561}
 562
 563static int llc_ui_wait_for_disc(struct sock *sk, long timeout)
 564{
 565        DEFINE_WAIT_FUNC(wait, woken_wake_function);
 566        int rc = 0;
 567
 568        add_wait_queue(sk_sleep(sk), &wait);
 569        while (1) {
 570                if (sk_wait_event(sk, &timeout, sk->sk_state == TCP_CLOSE, &wait))
 571                        break;
 572                rc = -ERESTARTSYS;
 573                if (signal_pending(current))
 574                        break;
 575                rc = -EAGAIN;
 576                if (!timeout)
 577                        break;
 578                rc = 0;
 579        }
 580        remove_wait_queue(sk_sleep(sk), &wait);
 581        return rc;
 582}
 583
 584static bool llc_ui_wait_for_conn(struct sock *sk, long timeout)
 585{
 586        DEFINE_WAIT_FUNC(wait, woken_wake_function);
 587
 588        add_wait_queue(sk_sleep(sk), &wait);
 589        while (1) {
 590                if (sk_wait_event(sk, &timeout, sk->sk_state != TCP_SYN_SENT, &wait))
 591                        break;
 592                if (signal_pending(current) || !timeout)
 593                        break;
 594        }
 595        remove_wait_queue(sk_sleep(sk), &wait);
 596        return timeout;
 597}
 598
 599static int llc_ui_wait_for_busy_core(struct sock *sk, long timeout)
 600{
 601        DEFINE_WAIT_FUNC(wait, woken_wake_function);
 602        struct llc_sock *llc = llc_sk(sk);
 603        int rc;
 604
 605        add_wait_queue(sk_sleep(sk), &wait);
 606        while (1) {
 607                rc = 0;
 608                if (sk_wait_event(sk, &timeout,
 609                                  (sk->sk_shutdown & RCV_SHUTDOWN) ||
 610                                  (!llc_data_accept_state(llc->state) &&
 611                                   !llc->remote_busy_flag &&
 612                                   !llc->p_flag), &wait))
 613                        break;
 614                rc = -ERESTARTSYS;
 615                if (signal_pending(current))
 616                        break;
 617                rc = -EAGAIN;
 618                if (!timeout)
 619                        break;
 620        }
 621        remove_wait_queue(sk_sleep(sk), &wait);
 622        return rc;
 623}
 624
 625static int llc_wait_data(struct sock *sk, long timeo)
 626{
 627        int rc;
 628
 629        while (1) {
 630                /*
 631                 * POSIX 1003.1g mandates this order.
 632                 */
 633                rc = sock_error(sk);
 634                if (rc)
 635                        break;
 636                rc = 0;
 637                if (sk->sk_shutdown & RCV_SHUTDOWN)
 638                        break;
 639                rc = -EAGAIN;
 640                if (!timeo)
 641                        break;
 642                rc = sock_intr_errno(timeo);
 643                if (signal_pending(current))
 644                        break;
 645                rc = 0;
 646                if (sk_wait_data(sk, &timeo, NULL))
 647                        break;
 648        }
 649        return rc;
 650}
 651
 652static void llc_cmsg_rcv(struct msghdr *msg, struct sk_buff *skb)
 653{
 654        struct llc_sock *llc = llc_sk(skb->sk);
 655
 656        if (llc->cmsg_flags & LLC_CMSG_PKTINFO) {
 657                struct llc_pktinfo info;
 658
 659                memset(&info, 0, sizeof(info));
 660                info.lpi_ifindex = llc_sk(skb->sk)->dev->ifindex;
 661                llc_pdu_decode_dsap(skb, &info.lpi_sap);
 662                llc_pdu_decode_da(skb, info.lpi_mac);
 663                put_cmsg(msg, SOL_LLC, LLC_OPT_PKTINFO, sizeof(info), &info);
 664        }
 665}
 666
 667/**
 668 *      llc_ui_accept - accept a new incoming connection.
 669 *      @sock: Socket which connections arrive on.
 670 *      @newsock: Socket to move incoming connection to.
 671 *      @flags: User specified operational flags.
 672 *      @kern: If the socket is kernel internal
 673 *
 674 *      Accept a new incoming connection.
 675 *      Returns 0 upon success, negative otherwise.
 676 */
 677static int llc_ui_accept(struct socket *sock, struct socket *newsock, int flags,
 678                         bool kern)
 679{
 680        struct sock *sk = sock->sk, *newsk;
 681        struct llc_sock *llc, *newllc;
 682        struct sk_buff *skb;
 683        int rc = -EOPNOTSUPP;
 684
 685        dprintk("%s: accepting on %02X\n", __func__,
 686                llc_sk(sk)->laddr.lsap);
 687        lock_sock(sk);
 688        if (unlikely(sk->sk_type != SOCK_STREAM))
 689                goto out;
 690        rc = -EINVAL;
 691        if (unlikely(sock->state != SS_UNCONNECTED ||
 692                     sk->sk_state != TCP_LISTEN))
 693                goto out;
 694        /* wait for a connection to arrive. */
 695        if (skb_queue_empty(&sk->sk_receive_queue)) {
 696                rc = llc_wait_data(sk, sk->sk_rcvtimeo);
 697                if (rc)
 698                        goto out;
 699        }
 700        dprintk("%s: got a new connection on %02X\n", __func__,
 701                llc_sk(sk)->laddr.lsap);
 702        skb = skb_dequeue(&sk->sk_receive_queue);
 703        rc = -EINVAL;
 704        if (!skb->sk)
 705                goto frees;
 706        rc = 0;
 707        newsk = skb->sk;
 708        /* attach connection to a new socket. */
 709        llc_ui_sk_init(newsock, newsk);
 710        sock_reset_flag(newsk, SOCK_ZAPPED);
 711        newsk->sk_state         = TCP_ESTABLISHED;
 712        newsock->state          = SS_CONNECTED;
 713        llc                     = llc_sk(sk);
 714        newllc                  = llc_sk(newsk);
 715        memcpy(&newllc->addr, &llc->addr, sizeof(newllc->addr));
 716        newllc->link = llc_ui_next_link_no(newllc->laddr.lsap);
 717
 718        /* put original socket back into a clean listen state. */
 719        sk->sk_state = TCP_LISTEN;
 720        sk_acceptq_removed(sk);
 721        dprintk("%s: ok success on %02X, client on %02X\n", __func__,
 722                llc_sk(sk)->addr.sllc_sap, newllc->daddr.lsap);
 723frees:
 724        kfree_skb(skb);
 725out:
 726        release_sock(sk);
 727        return rc;
 728}
 729
 730/**
 731 *      llc_ui_recvmsg - copy received data to the socket user.
 732 *      @sock: Socket to copy data from.
 733 *      @msg: Various user space related information.
 734 *      @len: Size of user buffer.
 735 *      @flags: User specified flags.
 736 *
 737 *      Copy received data to the socket user.
 738 *      Returns non-negative upon success, negative otherwise.
 739 */
 740static int llc_ui_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
 741                          int flags)
 742{
 743        DECLARE_SOCKADDR(struct sockaddr_llc *, uaddr, msg->msg_name);
 744        const int nonblock = flags & MSG_DONTWAIT;
 745        struct sk_buff *skb = NULL;
 746        struct sock *sk = sock->sk;
 747        struct llc_sock *llc = llc_sk(sk);
 748        size_t copied = 0;
 749        u32 peek_seq = 0;
 750        u32 *seq, skb_len;
 751        unsigned long used;
 752        int target;     /* Read at least this many bytes */
 753        long timeo;
 754
 755        lock_sock(sk);
 756        copied = -ENOTCONN;
 757        if (unlikely(sk->sk_type == SOCK_STREAM && sk->sk_state == TCP_LISTEN))
 758                goto out;
 759
 760        timeo = sock_rcvtimeo(sk, nonblock);
 761
 762        seq = &llc->copied_seq;
 763        if (flags & MSG_PEEK) {
 764                peek_seq = llc->copied_seq;
 765                seq = &peek_seq;
 766        }
 767
 768        target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
 769        copied = 0;
 770
 771        do {
 772                u32 offset;
 773
 774                /*
 775                 * We need to check signals first, to get correct SIGURG
 776                 * handling. FIXME: Need to check this doesn't impact 1003.1g
 777                 * and move it down to the bottom of the loop
 778                 */
 779                if (signal_pending(current)) {
 780                        if (copied)
 781                                break;
 782                        copied = timeo ? sock_intr_errno(timeo) : -EAGAIN;
 783                        break;
 784                }
 785
 786                /* Next get a buffer. */
 787
 788                skb = skb_peek(&sk->sk_receive_queue);
 789                if (skb) {
 790                        offset = *seq;
 791                        goto found_ok_skb;
 792                }
 793                /* Well, if we have backlog, try to process it now yet. */
 794
 795                if (copied >= target && !READ_ONCE(sk->sk_backlog.tail))
 796                        break;
 797
 798                if (copied) {
 799                        if (sk->sk_err ||
 800                            sk->sk_state == TCP_CLOSE ||
 801                            (sk->sk_shutdown & RCV_SHUTDOWN) ||
 802                            !timeo ||
 803                            (flags & MSG_PEEK))
 804                                break;
 805                } else {
 806                        if (sock_flag(sk, SOCK_DONE))
 807                                break;
 808
 809                        if (sk->sk_err) {
 810                                copied = sock_error(sk);
 811                                break;
 812                        }
 813                        if (sk->sk_shutdown & RCV_SHUTDOWN)
 814                                break;
 815
 816                        if (sk->sk_type == SOCK_STREAM && sk->sk_state == TCP_CLOSE) {
 817                                if (!sock_flag(sk, SOCK_DONE)) {
 818                                        /*
 819                                         * This occurs when user tries to read
 820                                         * from never connected socket.
 821                                         */
 822                                        copied = -ENOTCONN;
 823                                        break;
 824                                }
 825                                break;
 826                        }
 827                        if (!timeo) {
 828                                copied = -EAGAIN;
 829                                break;
 830                        }
 831                }
 832
 833                if (copied >= target) { /* Do not sleep, just process backlog. */
 834                        release_sock(sk);
 835                        lock_sock(sk);
 836                } else
 837                        sk_wait_data(sk, &timeo, NULL);
 838
 839                if ((flags & MSG_PEEK) && peek_seq != llc->copied_seq) {
 840                        net_dbg_ratelimited("LLC(%s:%d): Application bug, race in MSG_PEEK\n",
 841                                            current->comm,
 842                                            task_pid_nr(current));
 843                        peek_seq = llc->copied_seq;
 844                }
 845                continue;
 846        found_ok_skb:
 847                skb_len = skb->len;
 848                /* Ok so how much can we use? */
 849                used = skb->len - offset;
 850                if (len < used)
 851                        used = len;
 852
 853                if (!(flags & MSG_TRUNC)) {
 854                        int rc = skb_copy_datagram_msg(skb, offset, msg, used);
 855                        if (rc) {
 856                                /* Exception. Bailout! */
 857                                if (!copied)
 858                                        copied = -EFAULT;
 859                                break;
 860                        }
 861                }
 862
 863                *seq += used;
 864                copied += used;
 865                len -= used;
 866
 867                /* For non stream protcols we get one packet per recvmsg call */
 868                if (sk->sk_type != SOCK_STREAM)
 869                        goto copy_uaddr;
 870
 871                if (!(flags & MSG_PEEK)) {
 872                        skb_unlink(skb, &sk->sk_receive_queue);
 873                        kfree_skb(skb);
 874                        *seq = 0;
 875                }
 876
 877                /* Partial read */
 878                if (used + offset < skb_len)
 879                        continue;
 880        } while (len > 0);
 881
 882out:
 883        release_sock(sk);
 884        return copied;
 885copy_uaddr:
 886        if (uaddr != NULL && skb != NULL) {
 887                memcpy(uaddr, llc_ui_skb_cb(skb), sizeof(*uaddr));
 888                msg->msg_namelen = sizeof(*uaddr);
 889        }
 890        if (llc_sk(sk)->cmsg_flags)
 891                llc_cmsg_rcv(msg, skb);
 892
 893        if (!(flags & MSG_PEEK)) {
 894                skb_unlink(skb, &sk->sk_receive_queue);
 895                kfree_skb(skb);
 896                *seq = 0;
 897        }
 898
 899        goto out;
 900}
 901
 902/**
 903 *      llc_ui_sendmsg - Transmit data provided by the socket user.
 904 *      @sock: Socket to transmit data from.
 905 *      @msg: Various user related information.
 906 *      @len: Length of data to transmit.
 907 *
 908 *      Transmit data provided by the socket user.
 909 *      Returns non-negative upon success, negative otherwise.
 910 */
 911static int llc_ui_sendmsg(struct socket *sock, struct msghdr *msg, size_t len)
 912{
 913        struct sock *sk = sock->sk;
 914        struct llc_sock *llc = llc_sk(sk);
 915        DECLARE_SOCKADDR(struct sockaddr_llc *, addr, msg->msg_name);
 916        int flags = msg->msg_flags;
 917        int noblock = flags & MSG_DONTWAIT;
 918        struct sk_buff *skb = NULL;
 919        size_t size = 0;
 920        int rc = -EINVAL, copied = 0, hdrlen;
 921
 922        dprintk("%s: sending from %02X to %02X\n", __func__,
 923                llc->laddr.lsap, llc->daddr.lsap);
 924        lock_sock(sk);
 925        if (addr) {
 926                if (msg->msg_namelen < sizeof(*addr))
 927                        goto out;
 928        } else {
 929                if (llc_ui_addr_null(&llc->addr))
 930                        goto out;
 931                addr = &llc->addr;
 932        }
 933        /* must bind connection to sap if user hasn't done it. */
 934        if (sock_flag(sk, SOCK_ZAPPED)) {
 935                /* bind to sap with null dev, exclusive. */
 936                rc = llc_ui_autobind(sock, addr);
 937                if (rc)
 938                        goto out;
 939        }
 940        hdrlen = llc->dev->hard_header_len + llc_ui_header_len(sk, addr);
 941        size = hdrlen + len;
 942        if (size > llc->dev->mtu)
 943                size = llc->dev->mtu;
 944        copied = size - hdrlen;
 945        rc = -EINVAL;
 946        if (copied < 0)
 947                goto out;
 948        release_sock(sk);
 949        skb = sock_alloc_send_skb(sk, size, noblock, &rc);
 950        lock_sock(sk);
 951        if (!skb)
 952                goto out;
 953        skb->dev      = llc->dev;
 954        skb->protocol = llc_proto_type(addr->sllc_arphrd);
 955        skb_reserve(skb, hdrlen);
 956        rc = memcpy_from_msg(skb_put(skb, copied), msg, copied);
 957        if (rc)
 958                goto out;
 959        if (sk->sk_type == SOCK_DGRAM || addr->sllc_ua) {
 960                llc_build_and_send_ui_pkt(llc->sap, skb, addr->sllc_mac,
 961                                          addr->sllc_sap);
 962                skb = NULL;
 963                goto out;
 964        }
 965        if (addr->sllc_test) {
 966                llc_build_and_send_test_pkt(llc->sap, skb, addr->sllc_mac,
 967                                            addr->sllc_sap);
 968                skb = NULL;
 969                goto out;
 970        }
 971        if (addr->sllc_xid) {
 972                llc_build_and_send_xid_pkt(llc->sap, skb, addr->sllc_mac,
 973                                           addr->sllc_sap);
 974                skb = NULL;
 975                goto out;
 976        }
 977        rc = -ENOPROTOOPT;
 978        if (!(sk->sk_type == SOCK_STREAM && !addr->sllc_ua))
 979                goto out;
 980        rc = llc_ui_send_data(sk, skb, noblock);
 981        skb = NULL;
 982out:
 983        kfree_skb(skb);
 984        if (rc)
 985                dprintk("%s: failed sending from %02X to %02X: %d\n",
 986                        __func__, llc->laddr.lsap, llc->daddr.lsap, rc);
 987        release_sock(sk);
 988        return rc ? : copied;
 989}
 990
 991/**
 992 *      llc_ui_getname - return the address info of a socket
 993 *      @sock: Socket to get address of.
 994 *      @uaddr: Address structure to return information.
 995 *      @peer: Does user want local or remote address information.
 996 *
 997 *      Return the address information of a socket.
 998 */
 999static int llc_ui_getname(struct socket *sock, struct sockaddr *uaddr,
1000                          int peer)
1001{
1002        struct sockaddr_llc sllc;
1003        struct sock *sk = sock->sk;
1004        struct llc_sock *llc = llc_sk(sk);
1005        int rc = -EBADF;
1006
1007        memset(&sllc, 0, sizeof(sllc));
1008        lock_sock(sk);
1009        if (sock_flag(sk, SOCK_ZAPPED))
1010                goto out;
1011        if (peer) {
1012                rc = -ENOTCONN;
1013                if (sk->sk_state != TCP_ESTABLISHED)
1014                        goto out;
1015                if(llc->dev)
1016                        sllc.sllc_arphrd = llc->dev->type;
1017                sllc.sllc_sap = llc->daddr.lsap;
1018                memcpy(&sllc.sllc_mac, &llc->daddr.mac, IFHWADDRLEN);
1019        } else {
1020                rc = -EINVAL;
1021                if (!llc->sap)
1022                        goto out;
1023                sllc.sllc_sap = llc->sap->laddr.lsap;
1024
1025                if (llc->dev) {
1026                        sllc.sllc_arphrd = llc->dev->type;
1027                        memcpy(&sllc.sllc_mac, llc->dev->dev_addr,
1028                               IFHWADDRLEN);
1029                }
1030        }
1031        sllc.sllc_family = AF_LLC;
1032        memcpy(uaddr, &sllc, sizeof(sllc));
1033        rc = sizeof(sllc);
1034out:
1035        release_sock(sk);
1036        return rc;
1037}
1038
1039/**
1040 *      llc_ui_ioctl - io controls for PF_LLC
1041 *      @sock: Socket to get/set info
1042 *      @cmd: command
1043 *      @arg: optional argument for cmd
1044 *
1045 *      get/set info on llc sockets
1046 */
1047static int llc_ui_ioctl(struct socket *sock, unsigned int cmd,
1048                        unsigned long arg)
1049{
1050        return -ENOIOCTLCMD;
1051}
1052
1053/**
1054 *      llc_ui_setsockopt - set various connection specific parameters.
1055 *      @sock: Socket to set options on.
1056 *      @level: Socket level user is requesting operations on.
1057 *      @optname: Operation name.
1058 *      @optval: User provided operation data.
1059 *      @optlen: Length of optval.
1060 *
1061 *      Set various connection specific parameters.
1062 */
1063static int llc_ui_setsockopt(struct socket *sock, int level, int optname,
1064                             sockptr_t optval, unsigned int optlen)
1065{
1066        struct sock *sk = sock->sk;
1067        struct llc_sock *llc = llc_sk(sk);
1068        unsigned int opt;
1069        int rc = -EINVAL;
1070
1071        lock_sock(sk);
1072        if (unlikely(level != SOL_LLC || optlen != sizeof(int)))
1073                goto out;
1074        rc = copy_from_sockptr(&opt, optval, sizeof(opt));
1075        if (rc)
1076                goto out;
1077        rc = -EINVAL;
1078        switch (optname) {
1079        case LLC_OPT_RETRY:
1080                if (opt > LLC_OPT_MAX_RETRY)
1081                        goto out;
1082                llc->n2 = opt;
1083                break;
1084        case LLC_OPT_SIZE:
1085                if (opt > LLC_OPT_MAX_SIZE)
1086                        goto out;
1087                llc->n1 = opt;
1088                break;
1089        case LLC_OPT_ACK_TMR_EXP:
1090                if (opt > LLC_OPT_MAX_ACK_TMR_EXP)
1091                        goto out;
1092                llc->ack_timer.expire = opt * HZ;
1093                break;
1094        case LLC_OPT_P_TMR_EXP:
1095                if (opt > LLC_OPT_MAX_P_TMR_EXP)
1096                        goto out;
1097                llc->pf_cycle_timer.expire = opt * HZ;
1098                break;
1099        case LLC_OPT_REJ_TMR_EXP:
1100                if (opt > LLC_OPT_MAX_REJ_TMR_EXP)
1101                        goto out;
1102                llc->rej_sent_timer.expire = opt * HZ;
1103                break;
1104        case LLC_OPT_BUSY_TMR_EXP:
1105                if (opt > LLC_OPT_MAX_BUSY_TMR_EXP)
1106                        goto out;
1107                llc->busy_state_timer.expire = opt * HZ;
1108                break;
1109        case LLC_OPT_TX_WIN:
1110                if (opt > LLC_OPT_MAX_WIN)
1111                        goto out;
1112                llc->k = opt;
1113                break;
1114        case LLC_OPT_RX_WIN:
1115                if (opt > LLC_OPT_MAX_WIN)
1116                        goto out;
1117                llc->rw = opt;
1118                break;
1119        case LLC_OPT_PKTINFO:
1120                if (opt)
1121                        llc->cmsg_flags |= LLC_CMSG_PKTINFO;
1122                else
1123                        llc->cmsg_flags &= ~LLC_CMSG_PKTINFO;
1124                break;
1125        default:
1126                rc = -ENOPROTOOPT;
1127                goto out;
1128        }
1129        rc = 0;
1130out:
1131        release_sock(sk);
1132        return rc;
1133}
1134
1135/**
1136 *      llc_ui_getsockopt - get connection specific socket info
1137 *      @sock: Socket to get information from.
1138 *      @level: Socket level user is requesting operations on.
1139 *      @optname: Operation name.
1140 *      @optval: Variable to return operation data in.
1141 *      @optlen: Length of optval.
1142 *
1143 *      Get connection specific socket information.
1144 */
1145static int llc_ui_getsockopt(struct socket *sock, int level, int optname,
1146                             char __user *optval, int __user *optlen)
1147{
1148        struct sock *sk = sock->sk;
1149        struct llc_sock *llc = llc_sk(sk);
1150        int val = 0, len = 0, rc = -EINVAL;
1151
1152        lock_sock(sk);
1153        if (unlikely(level != SOL_LLC))
1154                goto out;
1155        rc = get_user(len, optlen);
1156        if (rc)
1157                goto out;
1158        rc = -EINVAL;
1159        if (len != sizeof(int))
1160                goto out;
1161        switch (optname) {
1162        case LLC_OPT_RETRY:
1163                val = llc->n2;                                  break;
1164        case LLC_OPT_SIZE:
1165                val = llc->n1;                                  break;
1166        case LLC_OPT_ACK_TMR_EXP:
1167                val = llc->ack_timer.expire / HZ;               break;
1168        case LLC_OPT_P_TMR_EXP:
1169                val = llc->pf_cycle_timer.expire / HZ;          break;
1170        case LLC_OPT_REJ_TMR_EXP:
1171                val = llc->rej_sent_timer.expire / HZ;          break;
1172        case LLC_OPT_BUSY_TMR_EXP:
1173                val = llc->busy_state_timer.expire / HZ;        break;
1174        case LLC_OPT_TX_WIN:
1175                val = llc->k;                           break;
1176        case LLC_OPT_RX_WIN:
1177                val = llc->rw;                          break;
1178        case LLC_OPT_PKTINFO:
1179                val = (llc->cmsg_flags & LLC_CMSG_PKTINFO) != 0;
1180                break;
1181        default:
1182                rc = -ENOPROTOOPT;
1183                goto out;
1184        }
1185        rc = 0;
1186        if (put_user(len, optlen) || copy_to_user(optval, &val, len))
1187                rc = -EFAULT;
1188out:
1189        release_sock(sk);
1190        return rc;
1191}
1192
1193static const struct net_proto_family llc_ui_family_ops = {
1194        .family = PF_LLC,
1195        .create = llc_ui_create,
1196        .owner  = THIS_MODULE,
1197};
1198
1199static const struct proto_ops llc_ui_ops = {
1200        .family      = PF_LLC,
1201        .owner       = THIS_MODULE,
1202        .release     = llc_ui_release,
1203        .bind        = llc_ui_bind,
1204        .connect     = llc_ui_connect,
1205        .socketpair  = sock_no_socketpair,
1206        .accept      = llc_ui_accept,
1207        .getname     = llc_ui_getname,
1208        .poll        = datagram_poll,
1209        .ioctl       = llc_ui_ioctl,
1210        .listen      = llc_ui_listen,
1211        .shutdown    = llc_ui_shutdown,
1212        .setsockopt  = llc_ui_setsockopt,
1213        .getsockopt  = llc_ui_getsockopt,
1214        .sendmsg     = llc_ui_sendmsg,
1215        .recvmsg     = llc_ui_recvmsg,
1216        .mmap        = sock_no_mmap,
1217        .sendpage    = sock_no_sendpage,
1218};
1219
1220static const char llc_proc_err_msg[] __initconst =
1221        KERN_CRIT "LLC: Unable to register the proc_fs entries\n";
1222static const char llc_sysctl_err_msg[] __initconst =
1223        KERN_CRIT "LLC: Unable to register the sysctl entries\n";
1224static const char llc_sock_err_msg[] __initconst =
1225        KERN_CRIT "LLC: Unable to register the network family\n";
1226
1227static int __init llc2_init(void)
1228{
1229        int rc = proto_register(&llc_proto, 0);
1230
1231        if (rc != 0)
1232                goto out;
1233
1234        llc_build_offset_table();
1235        llc_station_init();
1236        llc_ui_sap_last_autoport = LLC_SAP_DYN_START;
1237        rc = llc_proc_init();
1238        if (rc != 0) {
1239                printk(llc_proc_err_msg);
1240                goto out_station;
1241        }
1242        rc = llc_sysctl_init();
1243        if (rc) {
1244                printk(llc_sysctl_err_msg);
1245                goto out_proc;
1246        }
1247        rc = sock_register(&llc_ui_family_ops);
1248        if (rc) {
1249                printk(llc_sock_err_msg);
1250                goto out_sysctl;
1251        }
1252        llc_add_pack(LLC_DEST_SAP, llc_sap_handler);
1253        llc_add_pack(LLC_DEST_CONN, llc_conn_handler);
1254out:
1255        return rc;
1256out_sysctl:
1257        llc_sysctl_exit();
1258out_proc:
1259        llc_proc_exit();
1260out_station:
1261        llc_station_exit();
1262        proto_unregister(&llc_proto);
1263        goto out;
1264}
1265
1266static void __exit llc2_exit(void)
1267{
1268        llc_station_exit();
1269        llc_remove_pack(LLC_DEST_SAP);
1270        llc_remove_pack(LLC_DEST_CONN);
1271        sock_unregister(PF_LLC);
1272        llc_proc_exit();
1273        llc_sysctl_exit();
1274        proto_unregister(&llc_proto);
1275}
1276
1277module_init(llc2_init);
1278module_exit(llc2_exit);
1279
1280MODULE_LICENSE("GPL");
1281MODULE_AUTHOR("Procom 1997, Jay Schullist 2001, Arnaldo C. Melo 2001-2003");
1282MODULE_DESCRIPTION("IEEE 802.2 PF_LLC support");
1283MODULE_ALIAS_NETPROTO(PF_LLC);
1284