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