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