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        rtnl_lock();
 320        rcu_read_lock();
 321        if (sk->sk_bound_dev_if) {
 322                llc->dev = dev_get_by_index_rcu(&init_net, sk->sk_bound_dev_if);
 323                if (llc->dev) {
 324                        if (!addr->sllc_arphrd)
 325                                addr->sllc_arphrd = llc->dev->type;
 326                        if (llc_mac_null(addr->sllc_mac))
 327                                memcpy(addr->sllc_mac, llc->dev->dev_addr,
 328                                       IFHWADDRLEN);
 329                        if (addr->sllc_arphrd != llc->dev->type ||
 330                            !llc_mac_match(addr->sllc_mac,
 331                                           llc->dev->dev_addr)) {
 332                                rc = -EINVAL;
 333                                llc->dev = NULL;
 334                        }
 335                }
 336        } else
 337                llc->dev = dev_getbyhwaddr(&init_net, addr->sllc_arphrd,
 338                                           addr->sllc_mac);
 339        rcu_read_unlock();
 340        rtnl_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        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                        if (net_ratelimit())
 809                                printk(KERN_DEBUG "LLC(%s:%d): Application "
 810                                                  "bug, race in MSG_PEEK.\n",
 811                                       current->comm, task_pid_nr(current));
 812                        peek_seq = llc->copied_seq;
 813                }
 814                continue;
 815        found_ok_skb:
 816                /* Ok so how much can we use? */
 817                used = skb->len - offset;
 818                if (len < used)
 819                        used = len;
 820
 821                if (!(flags & MSG_TRUNC)) {
 822                        int rc = skb_copy_datagram_iovec(skb, offset,
 823                                                         msg->msg_iov, used);
 824                        if (rc) {
 825                                /* Exception. Bailout! */
 826                                if (!copied)
 827                                        copied = -EFAULT;
 828                                break;
 829                        }
 830                }
 831
 832                *seq += used;
 833                copied += used;
 834                len -= used;
 835
 836                if (!(flags & MSG_PEEK)) {
 837                        sk_eat_skb(sk, skb, 0);
 838                        *seq = 0;
 839                }
 840
 841                /* For non stream protcols we get one packet per recvmsg call */
 842                if (sk->sk_type != SOCK_STREAM)
 843                        goto copy_uaddr;
 844
 845                /* Partial read */
 846                if (used + offset < skb->len)
 847                        continue;
 848        } while (len > 0);
 849
 850out:
 851        release_sock(sk);
 852        return copied;
 853copy_uaddr:
 854        if (uaddr != NULL && skb != NULL) {
 855                memcpy(uaddr, llc_ui_skb_cb(skb), sizeof(*uaddr));
 856                msg->msg_namelen = sizeof(*uaddr);
 857        }
 858        if (llc_sk(sk)->cmsg_flags)
 859                llc_cmsg_rcv(msg, skb);
 860        goto out;
 861}
 862
 863/**
 864 *      llc_ui_sendmsg - Transmit data provided by the socket user.
 865 *      @sock: Socket to transmit data from.
 866 *      @msg: Various user related information.
 867 *      @len: Length of data to transmit.
 868 *
 869 *      Transmit data provided by the socket user.
 870 *      Returns non-negative upon success, negative otherwise.
 871 */
 872static int llc_ui_sendmsg(struct kiocb *iocb, struct socket *sock,
 873                          struct msghdr *msg, size_t len)
 874{
 875        struct sock *sk = sock->sk;
 876        struct llc_sock *llc = llc_sk(sk);
 877        struct sockaddr_llc *addr = (struct sockaddr_llc *)msg->msg_name;
 878        int flags = msg->msg_flags;
 879        int noblock = flags & MSG_DONTWAIT;
 880        struct sk_buff *skb;
 881        size_t size = 0;
 882        int rc = -EINVAL, copied = 0, hdrlen;
 883
 884        dprintk("%s: sending from %02X to %02X\n", __func__,
 885                llc->laddr.lsap, llc->daddr.lsap);
 886        lock_sock(sk);
 887        if (addr) {
 888                if (msg->msg_namelen < sizeof(*addr))
 889                        goto release;
 890        } else {
 891                if (llc_ui_addr_null(&llc->addr))
 892                        goto release;
 893                addr = &llc->addr;
 894        }
 895        /* must bind connection to sap if user hasn't done it. */
 896        if (sock_flag(sk, SOCK_ZAPPED)) {
 897                /* bind to sap with null dev, exclusive. */
 898                rc = llc_ui_autobind(sock, addr);
 899                if (rc)
 900                        goto release;
 901        }
 902        hdrlen = llc->dev->hard_header_len + llc_ui_header_len(sk, addr);
 903        size = hdrlen + len;
 904        if (size > llc->dev->mtu)
 905                size = llc->dev->mtu;
 906        copied = size - hdrlen;
 907        release_sock(sk);
 908        skb = sock_alloc_send_skb(sk, size, noblock, &rc);
 909        lock_sock(sk);
 910        if (!skb)
 911                goto release;
 912        skb->dev      = llc->dev;
 913        skb->protocol = llc_proto_type(addr->sllc_arphrd);
 914        skb_reserve(skb, hdrlen);
 915        rc = memcpy_fromiovec(skb_put(skb, copied), msg->msg_iov, copied);
 916        if (rc)
 917                goto out;
 918        if (sk->sk_type == SOCK_DGRAM || addr->sllc_ua) {
 919                llc_build_and_send_ui_pkt(llc->sap, skb, addr->sllc_mac,
 920                                          addr->sllc_sap);
 921                goto out;
 922        }
 923        if (addr->sllc_test) {
 924                llc_build_and_send_test_pkt(llc->sap, skb, addr->sllc_mac,
 925                                            addr->sllc_sap);
 926                goto out;
 927        }
 928        if (addr->sllc_xid) {
 929                llc_build_and_send_xid_pkt(llc->sap, skb, addr->sllc_mac,
 930                                           addr->sllc_sap);
 931                goto out;
 932        }
 933        rc = -ENOPROTOOPT;
 934        if (!(sk->sk_type == SOCK_STREAM && !addr->sllc_ua))
 935                goto out;
 936        rc = llc_ui_send_data(sk, skb, noblock);
 937out:
 938        if (rc) {
 939                kfree_skb(skb);
 940release:
 941                dprintk("%s: failed sending from %02X to %02X: %d\n",
 942                        __func__, llc->laddr.lsap, llc->daddr.lsap, rc);
 943        }
 944        release_sock(sk);
 945        return rc ? : copied;
 946}
 947
 948/**
 949 *      llc_ui_getname - return the address info of a socket
 950 *      @sock: Socket to get address of.
 951 *      @uaddr: Address structure to return information.
 952 *      @uaddrlen: Length of address structure.
 953 *      @peer: Does user want local or remote address information.
 954 *
 955 *      Return the address information of a socket.
 956 */
 957static int llc_ui_getname(struct socket *sock, struct sockaddr *uaddr,
 958                          int *uaddrlen, int peer)
 959{
 960        struct sockaddr_llc sllc;
 961        struct sock *sk = sock->sk;
 962        struct llc_sock *llc = llc_sk(sk);
 963        int rc = 0;
 964
 965        memset(&sllc, 0, sizeof(sllc));
 966        lock_sock(sk);
 967        if (sock_flag(sk, SOCK_ZAPPED))
 968                goto out;
 969        *uaddrlen = sizeof(sllc);
 970        memset(uaddr, 0, *uaddrlen);
 971        if (peer) {
 972                rc = -ENOTCONN;
 973                if (sk->sk_state != TCP_ESTABLISHED)
 974                        goto out;
 975                if(llc->dev)
 976                        sllc.sllc_arphrd = llc->dev->type;
 977                sllc.sllc_sap = llc->daddr.lsap;
 978                memcpy(&sllc.sllc_mac, &llc->daddr.mac, IFHWADDRLEN);
 979        } else {
 980                rc = -EINVAL;
 981                if (!llc->sap)
 982                        goto out;
 983                sllc.sllc_sap = llc->sap->laddr.lsap;
 984
 985                if (llc->dev) {
 986                        sllc.sllc_arphrd = llc->dev->type;
 987                        memcpy(&sllc.sllc_mac, llc->dev->dev_addr,
 988                               IFHWADDRLEN);
 989                }
 990        }
 991        rc = 0;
 992        sllc.sllc_family = AF_LLC;
 993        memcpy(uaddr, &sllc, sizeof(sllc));
 994out:
 995        release_sock(sk);
 996        return rc;
 997}
 998
 999/**
1000 *      llc_ui_ioctl - io controls for PF_LLC
1001 *      @sock: Socket to get/set info
1002 *      @cmd: command
1003 *      @arg: optional argument for cmd
1004 *
1005 *      get/set info on llc sockets
1006 */
1007static int llc_ui_ioctl(struct socket *sock, unsigned int cmd,
1008                        unsigned long arg)
1009{
1010        return -ENOIOCTLCMD;
1011}
1012
1013/**
1014 *      llc_ui_setsockopt - set various connection specific parameters.
1015 *      @sock: Socket to set options on.
1016 *      @level: Socket level user is requesting operations on.
1017 *      @optname: Operation name.
1018 *      @optval User provided operation data.
1019 *      @optlen: Length of optval.
1020 *
1021 *      Set various connection specific parameters.
1022 */
1023static int llc_ui_setsockopt(struct socket *sock, int level, int optname,
1024                             char __user *optval, unsigned int optlen)
1025{
1026        struct sock *sk = sock->sk;
1027        struct llc_sock *llc = llc_sk(sk);
1028        unsigned int opt;
1029        int rc = -EINVAL;
1030
1031        lock_sock(sk);
1032        if (unlikely(level != SOL_LLC || optlen != sizeof(int)))
1033                goto out;
1034        rc = get_user(opt, (int __user *)optval);
1035        if (rc)
1036                goto out;
1037        rc = -EINVAL;
1038        switch (optname) {
1039        case LLC_OPT_RETRY:
1040                if (opt > LLC_OPT_MAX_RETRY)
1041                        goto out;
1042                llc->n2 = opt;
1043                break;
1044        case LLC_OPT_SIZE:
1045                if (opt > LLC_OPT_MAX_SIZE)
1046                        goto out;
1047                llc->n1 = opt;
1048                break;
1049        case LLC_OPT_ACK_TMR_EXP:
1050                if (opt > LLC_OPT_MAX_ACK_TMR_EXP)
1051                        goto out;
1052                llc->ack_timer.expire = opt * HZ;
1053                break;
1054        case LLC_OPT_P_TMR_EXP:
1055                if (opt > LLC_OPT_MAX_P_TMR_EXP)
1056                        goto out;
1057                llc->pf_cycle_timer.expire = opt * HZ;
1058                break;
1059        case LLC_OPT_REJ_TMR_EXP:
1060                if (opt > LLC_OPT_MAX_REJ_TMR_EXP)
1061                        goto out;
1062                llc->rej_sent_timer.expire = opt * HZ;
1063                break;
1064        case LLC_OPT_BUSY_TMR_EXP:
1065                if (opt > LLC_OPT_MAX_BUSY_TMR_EXP)
1066                        goto out;
1067                llc->busy_state_timer.expire = opt * HZ;
1068                break;
1069        case LLC_OPT_TX_WIN:
1070                if (opt > LLC_OPT_MAX_WIN)
1071                        goto out;
1072                llc->k = opt;
1073                break;
1074        case LLC_OPT_RX_WIN:
1075                if (opt > LLC_OPT_MAX_WIN)
1076                        goto out;
1077                llc->rw = opt;
1078                break;
1079        case LLC_OPT_PKTINFO:
1080                if (opt)
1081                        llc->cmsg_flags |= LLC_CMSG_PKTINFO;
1082                else
1083                        llc->cmsg_flags &= ~LLC_CMSG_PKTINFO;
1084                break;
1085        default:
1086                rc = -ENOPROTOOPT;
1087                goto out;
1088        }
1089        rc = 0;
1090out:
1091        release_sock(sk);
1092        return rc;
1093}
1094
1095/**
1096 *      llc_ui_getsockopt - get connection specific socket info
1097 *      @sock: Socket to get information from.
1098 *      @level: Socket level user is requesting operations on.
1099 *      @optname: Operation name.
1100 *      @optval: Variable to return operation data in.
1101 *      @optlen: Length of optval.
1102 *
1103 *      Get connection specific socket information.
1104 */
1105static int llc_ui_getsockopt(struct socket *sock, int level, int optname,
1106                             char __user *optval, int __user *optlen)
1107{
1108        struct sock *sk = sock->sk;
1109        struct llc_sock *llc = llc_sk(sk);
1110        int val = 0, len = 0, rc = -EINVAL;
1111
1112        lock_sock(sk);
1113        if (unlikely(level != SOL_LLC))
1114                goto out;
1115        rc = get_user(len, optlen);
1116        if (rc)
1117                goto out;
1118        rc = -EINVAL;
1119        if (len != sizeof(int))
1120                goto out;
1121        switch (optname) {
1122        case LLC_OPT_RETRY:
1123                val = llc->n2;                                  break;
1124        case LLC_OPT_SIZE:
1125                val = llc->n1;                                  break;
1126        case LLC_OPT_ACK_TMR_EXP:
1127                val = llc->ack_timer.expire / HZ;               break;
1128        case LLC_OPT_P_TMR_EXP:
1129                val = llc->pf_cycle_timer.expire / HZ;          break;
1130        case LLC_OPT_REJ_TMR_EXP:
1131                val = llc->rej_sent_timer.expire / HZ;          break;
1132        case LLC_OPT_BUSY_TMR_EXP:
1133                val = llc->busy_state_timer.expire / HZ;        break;
1134        case LLC_OPT_TX_WIN:
1135                val = llc->k;                           break;
1136        case LLC_OPT_RX_WIN:
1137                val = llc->rw;                          break;
1138        case LLC_OPT_PKTINFO:
1139                val = (llc->cmsg_flags & LLC_CMSG_PKTINFO) != 0;
1140                break;
1141        default:
1142                rc = -ENOPROTOOPT;
1143                goto out;
1144        }
1145        rc = 0;
1146        if (put_user(len, optlen) || copy_to_user(optval, &val, len))
1147                rc = -EFAULT;
1148out:
1149        release_sock(sk);
1150        return rc;
1151}
1152
1153static const struct net_proto_family llc_ui_family_ops = {
1154        .family = PF_LLC,
1155        .create = llc_ui_create,
1156        .owner  = THIS_MODULE,
1157};
1158
1159static const struct proto_ops llc_ui_ops = {
1160        .family      = PF_LLC,
1161        .owner       = THIS_MODULE,
1162        .release     = llc_ui_release,
1163        .bind        = llc_ui_bind,
1164        .connect     = llc_ui_connect,
1165        .socketpair  = sock_no_socketpair,
1166        .accept      = llc_ui_accept,
1167        .getname     = llc_ui_getname,
1168        .poll        = datagram_poll,
1169        .ioctl       = llc_ui_ioctl,
1170        .listen      = llc_ui_listen,
1171        .shutdown    = llc_ui_shutdown,
1172        .setsockopt  = llc_ui_setsockopt,
1173        .getsockopt  = llc_ui_getsockopt,
1174        .sendmsg     = llc_ui_sendmsg,
1175        .recvmsg     = llc_ui_recvmsg,
1176        .mmap        = sock_no_mmap,
1177        .sendpage    = sock_no_sendpage,
1178};
1179
1180static const char llc_proc_err_msg[] __initconst =
1181        KERN_CRIT "LLC: Unable to register the proc_fs entries\n";
1182static const char llc_sysctl_err_msg[] __initconst =
1183        KERN_CRIT "LLC: Unable to register the sysctl entries\n";
1184static const char llc_sock_err_msg[] __initconst =
1185        KERN_CRIT "LLC: Unable to register the network family\n";
1186
1187static int __init llc2_init(void)
1188{
1189        int rc = proto_register(&llc_proto, 0);
1190
1191        if (rc != 0)
1192                goto out;
1193
1194        llc_build_offset_table();
1195        llc_station_init();
1196        llc_ui_sap_last_autoport = LLC_SAP_DYN_START;
1197        rc = llc_proc_init();
1198        if (rc != 0) {
1199                printk(llc_proc_err_msg);
1200                goto out_unregister_llc_proto;
1201        }
1202        rc = llc_sysctl_init();
1203        if (rc) {
1204                printk(llc_sysctl_err_msg);
1205                goto out_proc;
1206        }
1207        rc = sock_register(&llc_ui_family_ops);
1208        if (rc) {
1209                printk(llc_sock_err_msg);
1210                goto out_sysctl;
1211        }
1212        llc_add_pack(LLC_DEST_SAP, llc_sap_handler);
1213        llc_add_pack(LLC_DEST_CONN, llc_conn_handler);
1214out:
1215        return rc;
1216out_sysctl:
1217        llc_sysctl_exit();
1218out_proc:
1219        llc_proc_exit();
1220out_unregister_llc_proto:
1221        proto_unregister(&llc_proto);
1222        goto out;
1223}
1224
1225static void __exit llc2_exit(void)
1226{
1227        llc_station_exit();
1228        llc_remove_pack(LLC_DEST_SAP);
1229        llc_remove_pack(LLC_DEST_CONN);
1230        sock_unregister(PF_LLC);
1231        llc_proc_exit();
1232        llc_sysctl_exit();
1233        proto_unregister(&llc_proto);
1234}
1235
1236module_init(llc2_init);
1237module_exit(llc2_exit);
1238
1239MODULE_LICENSE("GPL");
1240MODULE_AUTHOR("Procom 1997, Jay Schullist 2001, Arnaldo C. Melo 2001-2003");
1241MODULE_DESCRIPTION("IEEE 802.2 PF_LLC support");
1242MODULE_ALIAS_NETPROTO(PF_LLC);
1243