net/bluetooth/l2cap_sock.c

   1 /*
   2    BlueZ - Bluetooth protocol stack for Linux
   3    Copyright (C) 2000-2001 Qualcomm Incorporated
   4    Copyright (C) 2009-2010 Gustavo F. Padovan <gustavo@padovan.org>
   5    Copyright (C) 2010 Google Inc.
   6
   7    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License version 2 as
  11    published by the Free Software Foundation;
  12
  13    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  14    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  15    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  16    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
  17    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
  18    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  19    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  20    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  21
  22    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
  23    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
  24    SOFTWARE IS DISCLAIMED.
  25 */
  26
  27 /* Bluetooth L2CAP sockets. */
  28
  29 #include <net/bluetooth/bluetooth.h>
  30 #include <net/bluetooth/hci_core.h>
  31 #include <net/bluetooth/l2cap.h>
  32
  33 /* ---- L2CAP timers ---- */
  34 static void l2cap_sock_timeout(unsigned long arg)
  35 {
  36         struct sock *sk = (struct sock *) arg;
  37         int reason;
  38
  39         BT_DBG("sock %p state %d", sk, sk->sk_state);
  40
  41         bh_lock_sock(sk);
  42
  43         if (sock_owned_by_user(sk)) {
  44                 /* sk is owned by user. Try again later */
  45                 l2cap_sock_set_timer(sk, HZ / 5);
  46                 bh_unlock_sock(sk);
  47                 sock_put(sk);
  48                 return;
  49         }
  50
  51         if (sk->sk_state == BT_CONNECTED || sk->sk_state == BT_CONFIG)
  52                 reason = ECONNREFUSED;
  53         else if (sk->sk_state == BT_CONNECT &&
  54                                 l2cap_pi(sk)->sec_level != BT_SECURITY_SDP)
  55                 reason = ECONNREFUSED;
  56         else
  57                 reason = ETIMEDOUT;
  58
  59         __l2cap_sock_close(sk, reason);
  60
  61         bh_unlock_sock(sk);
  62
  63         l2cap_sock_kill(sk);
  64         sock_put(sk);
  65 }
  66
  67 void l2cap_sock_set_timer(struct sock *sk, long timeout)
  68 {
  69         BT_DBG("sk %p state %d timeout %ld", sk, sk->sk_state, timeout);
  70         sk_reset_timer(sk, &sk->sk_timer, jiffies + timeout);
  71 }
  72
  73 void l2cap_sock_clear_timer(struct sock *sk)
  74 {
  75         BT_DBG("sock %p state %d", sk, sk->sk_state);
  76         sk_stop_timer(sk, &sk->sk_timer);
  77 }
  78
  79 static struct sock *__l2cap_get_sock_by_addr(__le16 psm, bdaddr_t *src)
  80 {
  81         struct sock *sk;
  82         struct hlist_node *node;
  83         sk_for_each(sk, node, &l2cap_sk_list.head)
  84                 if (l2cap_pi(sk)->sport == psm && !bacmp(&bt_sk(sk)->src, src))
  85                         goto found;
  86         sk = NULL;
  87 found:
  88         return sk;
  89 }
  90
  91 static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
  92 {
  93         struct sock *sk = sock->sk;
  94         struct sockaddr_l2 la;
  95         int len, err = 0;
  96
  97         BT_DBG("sk %p", sk);
  98
  99         if (!addr || addr->sa_family != AF_BLUETOOTH)
 100                 return -EINVAL;
 101
 102         memset(&la, 0, sizeof(la));
 103         len = min_t(unsigned int, sizeof(la), alen);
 104         memcpy(&la, addr, len);
 105
 106         if (la.l2_cid && la.l2_psm)
 107                 return -EINVAL;
 108
 109         lock_sock(sk);
 110
 111         if (sk->sk_state != BT_OPEN) {
 112                 err = -EBADFD;
 113                 goto done;
 114         }
 115
 116         if (la.l2_psm) {
 117                 __u16 psm = __le16_to_cpu(la.l2_psm);
 118
 119                 /* PSM must be odd and lsb of upper byte must be 0 */
 120                 if ((psm & 0x0101) != 0x0001) {
 121                         err = -EINVAL;
 122                         goto done;
 123                 }
 124
 125                 /* Restrict usage of well-known PSMs */
 126                 if (psm < 0x1001 && !capable(CAP_NET_BIND_SERVICE)) {
 127                         err = -EACCES;
 128                         goto done;
 129                 }
 130         }
 131
 132         write_lock_bh(&l2cap_sk_list.lock);
 133
 134         if (la.l2_psm && __l2cap_get_sock_by_addr(la.l2_psm, &la.l2_bdaddr)) {
 135                 err = -EADDRINUSE;
 136         } else {
 137                 /* Save source address */
 138                 bacpy(&bt_sk(sk)->src, &la.l2_bdaddr);
 139                 l2cap_pi(sk)->psm   = la.l2_psm;
 140                 l2cap_pi(sk)->sport = la.l2_psm;
 141                 sk->sk_state = BT_BOUND;
 142
 143                 if (__le16_to_cpu(la.l2_psm) == 0x0001 ||
 144                                         __le16_to_cpu(la.l2_psm) == 0x0003)
 145                         l2cap_pi(sk)->sec_level = BT_SECURITY_SDP;
 146         }
 147
 148         if (la.l2_cid)
 149                 l2cap_pi(sk)->scid = la.l2_cid;
 150
 151         write_unlock_bh(&l2cap_sk_list.lock);
 152
 153 done:
 154         release_sock(sk);
 155         return err;
 156 }
 157
 158 static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
 159 {
 160         struct sock *sk = sock->sk;
 161         struct sockaddr_l2 la;
 162         int len, err = 0;
 163
 164         BT_DBG("sk %p", sk);
 165
 166         if (!addr || alen < sizeof(addr->sa_family) ||
 167             addr->sa_family != AF_BLUETOOTH)
 168                 return -EINVAL;
 169
 170         memset(&la, 0, sizeof(la));
 171         len = min_t(unsigned int, sizeof(la), alen);
 172         memcpy(&la, addr, len);
 173
 174         if (la.l2_cid && la.l2_psm)
 175                 return -EINVAL;
 176
 177         lock_sock(sk);
 178
 179         if ((sk->sk_type == SOCK_SEQPACKET || sk->sk_type == SOCK_STREAM)
 180                         && !(la.l2_psm || la.l2_cid)) {
 181                 err = -EINVAL;
 182                 goto done;
 183         }
 184
 185         switch (l2cap_pi(sk)->mode) {
 186         case L2CAP_MODE_BASIC:
 187                 break;
 188         case L2CAP_MODE_ERTM:
 189         case L2CAP_MODE_STREAMING:
 190                 if (!disable_ertm)
 191                         break;
 192                 /* fall through */
 193         default:
 194                 err = -ENOTSUPP;
 195                 goto done;
 196         }
 197
 198         switch (sk->sk_state) {
 199         case BT_CONNECT:
 200         case BT_CONNECT2:
 201         case BT_CONFIG:
 202                 /* Already connecting */
 203                 goto wait;
 204
 205         case BT_CONNECTED:
 206                 /* Already connected */
 207                 err = -EISCONN;
 208                 goto done;
 209
 210         case BT_OPEN:
 211         case BT_BOUND:
 212                 /* Can connect */
 213                 break;
 214
 215         default:
 216                 err = -EBADFD;
 217                 goto done;
 218         }
 219
 220         /* PSM must be odd and lsb of upper byte must be 0 */
 221         if ((__le16_to_cpu(la.l2_psm) & 0x0101) != 0x0001 &&
 222                                 sk->sk_type != SOCK_RAW && !la.l2_cid) {
 223                 err = -EINVAL;
 224                 goto done;
 225         }
 226
 227         /* Set destination address and psm */
 228         bacpy(&bt_sk(sk)->dst, &la.l2_bdaddr);
 229         l2cap_pi(sk)->psm = la.l2_psm;
 230         l2cap_pi(sk)->dcid = la.l2_cid;
 231
 232         err = l2cap_chan_connect(l2cap_pi(sk)->chan);
 233         if (err)
 234                 goto done;
 235
 236 wait:
 237         err = bt_sock_wait_state(sk, BT_CONNECTED,
 238                         sock_sndtimeo(sk, flags & O_NONBLOCK));
 239 done:
 240         release_sock(sk);
 241         return err;
 242 }
 243
 244 static int l2cap_sock_listen(struct socket *sock, int backlog)
 245 {
 246         struct sock *sk = sock->sk;
 247         int err = 0;
 248
 249         BT_DBG("sk %p backlog %d", sk, backlog);
 250
 251         lock_sock(sk);
 252
 253         if ((sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM)
 254                         || sk->sk_state != BT_BOUND) {
 255                 err = -EBADFD;
 256                 goto done;
 257         }
 258
 259         switch (l2cap_pi(sk)->mode) {
 260         case L2CAP_MODE_BASIC:
 261                 break;
 262         case L2CAP_MODE_ERTM:
 263         case L2CAP_MODE_STREAMING:
 264                 if (!disable_ertm)
 265                         break;
 266                 /* fall through */
 267         default:
 268                 err = -ENOTSUPP;
 269                 goto done;
 270         }
 271
 272         if (!l2cap_pi(sk)->psm && !l2cap_pi(sk)->scid) {
 273                 bdaddr_t *src = &bt_sk(sk)->src;
 274                 u16 psm;
 275
 276                 err = -EINVAL;
 277
 278                 write_lock_bh(&l2cap_sk_list.lock);
 279
 280                 for (psm = 0x1001; psm < 0x1100; psm += 2)
 281                         if (!__l2cap_get_sock_by_addr(cpu_to_le16(psm), src)) {
 282                                 l2cap_pi(sk)->psm   = cpu_to_le16(psm);
 283                                 l2cap_pi(sk)->sport = cpu_to_le16(psm);
 284                                 err = 0;
 285                                 break;
 286                         }
 287
 288                 write_unlock_bh(&l2cap_sk_list.lock);
 289
 290                 if (err < 0)
 291                         goto done;
 292         }
 293
 294         sk->sk_max_ack_backlog = backlog;
 295         sk->sk_ack_backlog = 0;
 296         sk->sk_state = BT_LISTEN;
 297
 298 done:
 299         release_sock(sk);
 300         return err;
 301 }
 302
 303 static int l2cap_sock_accept(struct socket *sock, struct socket *newsock, int flags)
 304 {
 305         DECLARE_WAITQUEUE(wait, current);
 306         struct sock *sk = sock->sk, *nsk;
 307         long timeo;
 308         int err = 0;
 309
 310         lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
 311
 312         if (sk->sk_state != BT_LISTEN) {
 313                 err = -EBADFD;
 314                 goto done;
 315         }
 316
 317         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 318
 319         BT_DBG("sk %p timeo %ld", sk, timeo);
 320
 321         /* Wait for an incoming connection. (wake-one). */
 322         add_wait_queue_exclusive(sk_sleep(sk), &wait);
 323         while (!(nsk = bt_accept_dequeue(sk, newsock))) {
 324                 set_current_state(TASK_INTERRUPTIBLE);
 325                 if (!timeo) {
 326                         err = -EAGAIN;
 327                         break;
 328                 }
 329
 330                 release_sock(sk);
 331                 timeo = schedule_timeout(timeo);
 332                 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
 333
 334                 if (sk->sk_state != BT_LISTEN) {
 335                         err = -EBADFD;
 336                         break;
 337                 }
 338
 339                 if (signal_pending(current)) {
 340                         err = sock_intr_errno(timeo);
 341                         break;
 342                 }
 343         }
 344         set_current_state(TASK_RUNNING);
 345         remove_wait_queue(sk_sleep(sk), &wait);
 346
 347         if (err)
 348                 goto done;
 349
 350         newsock->state = SS_CONNECTED;
 351
 352         BT_DBG("new socket %p", nsk);
 353
 354 done:
 355         release_sock(sk);
 356         return err;
 357 }
 358
 359 static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
 360 {
 361         struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
 362         struct sock *sk = sock->sk;
 363
 364         BT_DBG("sock %p, sk %p", sock, sk);
 365
 366         addr->sa_family = AF_BLUETOOTH;
 367         *len = sizeof(struct sockaddr_l2);
 368
 369         if (peer) {
 370                 la->l2_psm = l2cap_pi(sk)->psm;
 371                 bacpy(&la->l2_bdaddr, &bt_sk(sk)->dst);
 372                 la->l2_cid = cpu_to_le16(l2cap_pi(sk)->dcid);
 373         } else {
 374                 la->l2_psm = l2cap_pi(sk)->sport;
 375                 bacpy(&la->l2_bdaddr, &bt_sk(sk)->src);
 376                 la->l2_cid = cpu_to_le16(l2cap_pi(sk)->scid);
 377         }
 378
 379         return 0;
 380 }
 381
 382 static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
 383 {
 384         struct sock *sk = sock->sk;
 385         struct l2cap_options opts;
 386         struct l2cap_conninfo cinfo;
 387         int len, err = 0;
 388         u32 opt;
 389
 390         BT_DBG("sk %p", sk);
 391
 392         if (get_user(len, optlen))
 393                 return -EFAULT;
 394
 395         lock_sock(sk);
 396
 397         switch (optname) {
 398         case L2CAP_OPTIONS:
 399                 memset(&opts, 0, sizeof(opts));
 400                 opts.imtu     = l2cap_pi(sk)->imtu;
 401                 opts.omtu     = l2cap_pi(sk)->omtu;
 402                 opts.flush_to = l2cap_pi(sk)->flush_to;
 403                 opts.mode     = l2cap_pi(sk)->mode;
 404                 opts.fcs      = l2cap_pi(sk)->fcs;
 405                 opts.max_tx   = l2cap_pi(sk)->max_tx;
 406                 opts.txwin_size = (__u16)l2cap_pi(sk)->tx_win;
 407
 408                 len = min_t(unsigned int, len, sizeof(opts));
 409                 if (copy_to_user(optval, (char *) &opts, len))
 410                         err = -EFAULT;
 411
 412                 break;
 413
 414         case L2CAP_LM:
 415                 switch (l2cap_pi(sk)->sec_level) {
 416                 case BT_SECURITY_LOW:
 417                         opt = L2CAP_LM_AUTH;
 418                         break;
 419                 case BT_SECURITY_MEDIUM:
 420                         opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
 421                         break;
 422                 case BT_SECURITY_HIGH:
 423                         opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
 424                                                         L2CAP_LM_SECURE;
 425                         break;
 426                 default:
 427                         opt = 0;
 428                         break;
 429                 }
 430
 431                 if (l2cap_pi(sk)->role_switch)
 432                         opt |= L2CAP_LM_MASTER;
 433
 434                 if (l2cap_pi(sk)->force_reliable)
 435                         opt |= L2CAP_LM_RELIABLE;
 436
 437                 if (put_user(opt, (u32 __user *) optval))
 438                         err = -EFAULT;
 439                 break;
 440
 441         case L2CAP_CONNINFO:
 442                 if (sk->sk_state != BT_CONNECTED &&
 443                                         !(sk->sk_state == BT_CONNECT2 &&
 444                                                 bt_sk(sk)->defer_setup)) {
 445                         err = -ENOTCONN;
 446                         break;
 447                 }
 448
 449                 cinfo.hci_handle = l2cap_pi(sk)->conn->hcon->handle;
 450                 memcpy(cinfo.dev_class, l2cap_pi(sk)->conn->hcon->dev_class, 3);
 451
 452                 len = min_t(unsigned int, len, sizeof(cinfo));
 453                 if (copy_to_user(optval, (char *) &cinfo, len))
 454                         err = -EFAULT;
 455
 456                 break;
 457
 458         default:
 459                 err = -ENOPROTOOPT;
 460                 break;
 461         }
 462
 463         release_sock(sk);
 464         return err;
 465 }
 466
 467 static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
 468 {
 469         struct sock *sk = sock->sk;
 470         struct bt_security sec;
 471         int len, err = 0;
 472
 473         BT_DBG("sk %p", sk);
 474
 475         if (level == SOL_L2CAP)
 476                 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
 477
 478         if (level != SOL_BLUETOOTH)
 479                 return -ENOPROTOOPT;
 480
 481         if (get_user(len, optlen))
 482                 return -EFAULT;
 483
 484         lock_sock(sk);
 485
 486         switch (optname) {
 487         case BT_SECURITY:
 488                 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
 489                                 && sk->sk_type != SOCK_RAW) {
 490                         err = -EINVAL;
 491                         break;
 492                 }
 493
 494                 sec.level = l2cap_pi(sk)->sec_level;
 495
 496                 len = min_t(unsigned int, len, sizeof(sec));
 497                 if (copy_to_user(optval, (char *) &sec, len))
 498                         err = -EFAULT;
 499
 500                 break;
 501
 502         case BT_DEFER_SETUP:
 503                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 504                         err = -EINVAL;
 505                         break;
 506                 }
 507
 508                 if (put_user(bt_sk(sk)->defer_setup, (u32 __user *) optval))
 509                         err = -EFAULT;
 510
 511                 break;
 512
 513         case BT_FLUSHABLE:
 514                 if (put_user(l2cap_pi(sk)->flushable, (u32 __user *) optval))
 515                         err = -EFAULT;
 516
 517                 break;
 518
 519         default:
 520                 err = -ENOPROTOOPT;
 521                 break;
 522         }
 523
 524         release_sock(sk);
 525         return err;
 526 }
 527
 528 static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __user *optval, unsigned int optlen)
 529 {
 530         struct sock *sk = sock->sk;
 531         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 532         struct l2cap_options opts;
 533         int len, err = 0;
 534         u32 opt;
 535
 536         BT_DBG("sk %p", sk);
 537
 538         lock_sock(sk);
 539
 540         switch (optname) {
 541         case L2CAP_OPTIONS:
 542                 if (sk->sk_state == BT_CONNECTED) {
 543                         err = -EINVAL;
 544                         break;
 545                 }
 546
 547                 opts.imtu     = l2cap_pi(sk)->imtu;
 548                 opts.omtu     = l2cap_pi(sk)->omtu;
 549                 opts.flush_to = l2cap_pi(sk)->flush_to;
 550                 opts.mode     = l2cap_pi(sk)->mode;
 551                 opts.fcs      = l2cap_pi(sk)->fcs;
 552                 opts.max_tx   = l2cap_pi(sk)->max_tx;
 553                 opts.txwin_size = (__u16)l2cap_pi(sk)->tx_win;
 554
 555                 len = min_t(unsigned int, sizeof(opts), optlen);
 556                 if (copy_from_user((char *) &opts, optval, len)) {
 557                         err = -EFAULT;
 558                         break;
 559                 }
 560
 561                 if (opts.txwin_size > L2CAP_DEFAULT_TX_WINDOW) {
 562                         err = -EINVAL;
 563                         break;
 564                 }
 565
 566                 l2cap_pi(sk)->mode = opts.mode;
 567                 switch (l2cap_pi(sk)->mode) {
 568                 case L2CAP_MODE_BASIC:
 569                         chan->conf_state &= ~L2CAP_CONF_STATE2_DEVICE;
 570                         break;
 571                 case L2CAP_MODE_ERTM:
 572                 case L2CAP_MODE_STREAMING:
 573                         if (!disable_ertm)
 574                                 break;
 575                         /* fall through */
 576                 default:
 577                         err = -EINVAL;
 578                         break;
 579                 }
 580
 581                 l2cap_pi(sk)->imtu = opts.imtu;
 582                 l2cap_pi(sk)->omtu = opts.omtu;
 583                 l2cap_pi(sk)->fcs  = opts.fcs;
 584                 l2cap_pi(sk)->max_tx = opts.max_tx;
 585                 l2cap_pi(sk)->tx_win = (__u8)opts.txwin_size;
 586                 break;
 587
 588         case L2CAP_LM:
 589                 if (get_user(opt, (u32 __user *) optval)) {
 590                         err = -EFAULT;
 591                         break;
 592                 }
 593
 594                 if (opt & L2CAP_LM_AUTH)
 595                         l2cap_pi(sk)->sec_level = BT_SECURITY_LOW;
 596                 if (opt & L2CAP_LM_ENCRYPT)
 597                         l2cap_pi(sk)->sec_level = BT_SECURITY_MEDIUM;
 598                 if (opt & L2CAP_LM_SECURE)
 599                         l2cap_pi(sk)->sec_level = BT_SECURITY_HIGH;
 600
 601                 l2cap_pi(sk)->role_switch    = (opt & L2CAP_LM_MASTER);
 602                 l2cap_pi(sk)->force_reliable = (opt & L2CAP_LM_RELIABLE);
 603                 break;
 604
 605         default:
 606                 err = -ENOPROTOOPT;
 607                 break;
 608         }
 609
 610         release_sock(sk);
 611         return err;
 612 }
 613
 614 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
 615 {
 616         struct sock *sk = sock->sk;
 617         struct bt_security sec;
 618         int len, err = 0;
 619         u32 opt;
 620
 621         BT_DBG("sk %p", sk);
 622
 623         if (level == SOL_L2CAP)
 624                 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
 625
 626         if (level != SOL_BLUETOOTH)
 627                 return -ENOPROTOOPT;
 628
 629         lock_sock(sk);
 630
 631         switch (optname) {
 632         case BT_SECURITY:
 633                 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
 634                                 && sk->sk_type != SOCK_RAW) {
 635                         err = -EINVAL;
 636                         break;
 637                 }
 638
 639                 sec.level = BT_SECURITY_LOW;
 640
 641                 len = min_t(unsigned int, sizeof(sec), optlen);
 642                 if (copy_from_user((char *) &sec, optval, len)) {
 643                         err = -EFAULT;
 644                         break;
 645                 }
 646
 647                 if (sec.level < BT_SECURITY_LOW ||
 648                                         sec.level > BT_SECURITY_HIGH) {
 649                         err = -EINVAL;
 650                         break;
 651                 }
 652
 653                 l2cap_pi(sk)->sec_level = sec.level;
 654                 break;
 655
 656         case BT_DEFER_SETUP:
 657                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 658                         err = -EINVAL;
 659                         break;
 660                 }
 661
 662                 if (get_user(opt, (u32 __user *) optval)) {
 663                         err = -EFAULT;
 664                         break;
 665                 }
 666
 667                 bt_sk(sk)->defer_setup = opt;
 668                 break;
 669
 670         case BT_FLUSHABLE:
 671                 if (get_user(opt, (u32 __user *) optval)) {
 672                         err = -EFAULT;
 673                         break;
 674                 }
 675
 676                 if (opt > BT_FLUSHABLE_ON) {
 677                         err = -EINVAL;
 678                         break;
 679                 }
 680
 681                 if (opt == BT_FLUSHABLE_OFF) {
 682                         struct l2cap_conn *conn = l2cap_pi(sk)->conn;
 683                         /* proceed futher only when we have l2cap_conn and
 684                            No Flush support in the LM */
 685                         if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
 686                                 err = -EINVAL;
 687                                 break;
 688                         }
 689                 }
 690
 691                 l2cap_pi(sk)->flushable = opt;
 692                 break;
 693
 694         default:
 695                 err = -ENOPROTOOPT;
 696                 break;
 697         }
 698
 699         release_sock(sk);
 700         return err;
 701 }
 702
 703 static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len)
 704 {
 705         struct sock *sk = sock->sk;
 706         struct l2cap_pinfo *pi = l2cap_pi(sk);
 707         struct sk_buff *skb;
 708         u16 control;
 709         int err;
 710
 711         BT_DBG("sock %p, sk %p", sock, sk);
 712
 713         err = sock_error(sk);
 714         if (err)
 715                 return err;
 716
 717         if (msg->msg_flags & MSG_OOB)
 718                 return -EOPNOTSUPP;
 719
 720         lock_sock(sk);
 721
 722         if (sk->sk_state != BT_CONNECTED) {
 723                 err = -ENOTCONN;
 724                 goto done;
 725         }
 726
 727         /* Connectionless channel */
 728         if (sk->sk_type == SOCK_DGRAM) {
 729                 skb = l2cap_create_connless_pdu(sk, msg, len);
 730                 if (IS_ERR(skb)) {
 731                         err = PTR_ERR(skb);
 732                 } else {
 733                         l2cap_do_send(sk, skb);
 734                         err = len;
 735                 }
 736                 goto done;
 737         }
 738
 739         switch (pi->mode) {
 740         case L2CAP_MODE_BASIC:
 741                 /* Check outgoing MTU */
 742                 if (len > pi->omtu) {
 743                         err = -EMSGSIZE;
 744                         goto done;
 745                 }
 746
 747                 /* Create a basic PDU */
 748                 skb = l2cap_create_basic_pdu(sk, msg, len);
 749                 if (IS_ERR(skb)) {
 750                         err = PTR_ERR(skb);
 751                         goto done;
 752                 }
 753
 754                 l2cap_do_send(sk, skb);
 755                 err = len;
 756                 break;
 757
 758         case L2CAP_MODE_ERTM:
 759         case L2CAP_MODE_STREAMING:
 760                 /* Entire SDU fits into one PDU */
 761                 if (len <= pi->chan->remote_mps) {
 762                         control = L2CAP_SDU_UNSEGMENTED;
 763                         skb = l2cap_create_iframe_pdu(sk, msg, len, control, 0);
 764                         if (IS_ERR(skb)) {
 765                                 err = PTR_ERR(skb);
 766                                 goto done;
 767                         }
 768                         __skb_queue_tail(&pi->chan->tx_q, skb);
 769
 770                         if (pi->chan->tx_send_head == NULL)
 771                                 pi->chan->tx_send_head = skb;
 772
 773                 } else {
 774                 /* Segment SDU into multiples PDUs */
 775                         err = l2cap_sar_segment_sdu(pi->chan, msg, len);
 776                         if (err < 0)
 777                                 goto done;
 778                 }
 779
 780                 if (pi->mode == L2CAP_MODE_STREAMING) {
 781                         l2cap_streaming_send(pi->chan);
 782                         err = len;
 783                         break;
 784                 }
 785
 786                 if ((pi->chan->conn_state & L2CAP_CONN_REMOTE_BUSY) &&
 787                                 (pi->chan->conn_state & L2CAP_CONN_WAIT_F)) {
 788                         err = len;
 789                         break;
 790                 }
 791                 err = l2cap_ertm_send(pi->chan);
 792
 793                 if (err >= 0)
 794                         err = len;
 795                 break;
 796
 797         default:
 798                 BT_DBG("bad state %1.1x", pi->mode);
 799                 err = -EBADFD;
 800         }
 801
 802 done:
 803         release_sock(sk);
 804         return err;
 805 }
 806
 807 static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len, int flags)
 808 {
 809         struct sock *sk = sock->sk;
 810
 811         lock_sock(sk);
 812
 813         if (sk->sk_state == BT_CONNECT2 && bt_sk(sk)->defer_setup) {
 814                 __l2cap_connect_rsp_defer(sk);
 815                 release_sock(sk);
 816                 return 0;
 817         }
 818
 819         release_sock(sk);
 820
 821         if (sock->type == SOCK_STREAM)
 822                 return bt_sock_stream_recvmsg(iocb, sock, msg, len, flags);
 823
 824         return bt_sock_recvmsg(iocb, sock, msg, len, flags);
 825 }
 826
 827 /* Kill socket (only if zapped and orphan)
 828  * Must be called on unlocked socket.
 829  */
 830 void l2cap_sock_kill(struct sock *sk)
 831 {
 832         if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
 833                 return;
 834
 835         BT_DBG("sk %p state %d", sk, sk->sk_state);
 836
 837         /* Kill poor orphan */
 838         bt_sock_unlink(&l2cap_sk_list, sk);
 839         sock_set_flag(sk, SOCK_DEAD);
 840         sock_put(sk);
 841 }
 842
 843 /* Must be called on unlocked socket. */
 844 static void l2cap_sock_close(struct sock *sk)
 845 {
 846         l2cap_sock_clear_timer(sk);
 847         lock_sock(sk);
 848         __l2cap_sock_close(sk, ECONNRESET);
 849         release_sock(sk);
 850         l2cap_sock_kill(sk);
 851 }
 852
 853 static void l2cap_sock_cleanup_listen(struct sock *parent)
 854 {
 855         struct sock *sk;
 856
 857         BT_DBG("parent %p", parent);
 858
 859         /* Close not yet accepted channels */
 860         while ((sk = bt_accept_dequeue(parent, NULL)))
 861                 l2cap_sock_close(sk);
 862
 863         parent->sk_state = BT_CLOSED;
 864         sock_set_flag(parent, SOCK_ZAPPED);
 865 }
 866
 867 void __l2cap_sock_close(struct sock *sk, int reason)
 868 {
 869         struct l2cap_conn *conn = l2cap_pi(sk)->conn;
 870         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 871
 872         BT_DBG("sk %p state %d socket %p", sk, sk->sk_state, sk->sk_socket);
 873
 874         switch (sk->sk_state) {
 875         case BT_LISTEN:
 876                 l2cap_sock_cleanup_listen(sk);
 877                 break;
 878
 879         case BT_CONNECTED:
 880         case BT_CONFIG:
 881                 if ((sk->sk_type == SOCK_SEQPACKET ||
 882                                         sk->sk_type == SOCK_STREAM) &&
 883                                         conn->hcon->type == ACL_LINK) {
 884                         l2cap_sock_set_timer(sk, sk->sk_sndtimeo);
 885                         l2cap_send_disconn_req(conn, chan, reason);
 886                 } else
 887                         l2cap_chan_del(chan, reason);
 888                 break;
 889
 890         case BT_CONNECT2:
 891                 if ((sk->sk_type == SOCK_SEQPACKET ||
 892                                         sk->sk_type == SOCK_STREAM) &&
 893                                         conn->hcon->type == ACL_LINK) {
 894                         struct l2cap_conn_rsp rsp;
 895                         __u16 result;
 896
 897                         if (bt_sk(sk)->defer_setup)
 898                                 result = L2CAP_CR_SEC_BLOCK;
 899                         else
 900                                 result = L2CAP_CR_BAD_PSM;
 901
 902                         rsp.scid   = cpu_to_le16(l2cap_pi(sk)->dcid);
 903                         rsp.dcid   = cpu_to_le16(l2cap_pi(sk)->scid);
 904                         rsp.result = cpu_to_le16(result);
 905                         rsp.status = cpu_to_le16(L2CAP_CS_NO_INFO);
 906                         l2cap_send_cmd(conn, chan->ident, L2CAP_CONN_RSP,
 907                                                         sizeof(rsp), &rsp);
 908                 }
 909
 910                 l2cap_chan_del(chan, reason);
 911                 break;
 912
 913         case BT_CONNECT:
 914         case BT_DISCONN:
 915                 l2cap_chan_del(chan, reason);
 916                 break;
 917
 918         default:
 919                 sock_set_flag(sk, SOCK_ZAPPED);
 920                 break;
 921         }
 922 }
 923
 924 static int l2cap_sock_shutdown(struct socket *sock, int how)
 925 {
 926         struct sock *sk = sock->sk;
 927         int err = 0;
 928
 929         BT_DBG("sock %p, sk %p", sock, sk);
 930
 931         if (!sk)
 932                 return 0;
 933
 934         lock_sock(sk);
 935         if (!sk->sk_shutdown) {
 936                 if (l2cap_pi(sk)->mode == L2CAP_MODE_ERTM)
 937                         err = __l2cap_wait_ack(sk);
 938
 939                 sk->sk_shutdown = SHUTDOWN_MASK;
 940                 l2cap_sock_clear_timer(sk);
 941                 __l2cap_sock_close(sk, 0);
 942
 943                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
 944                         err = bt_sock_wait_state(sk, BT_CLOSED,
 945                                                         sk->sk_lingertime);
 946         }
 947
 948         if (!err && sk->sk_err)
 949                 err = -sk->sk_err;
 950
 951         release_sock(sk);
 952         return err;
 953 }
 954
 955 static int l2cap_sock_release(struct socket *sock)
 956 {
 957         struct sock *sk = sock->sk;
 958         int err;
 959
 960         BT_DBG("sock %p, sk %p", sock, sk);
 961
 962         if (!sk)
 963                 return 0;
 964
 965         err = l2cap_sock_shutdown(sock, 2);
 966
 967         sock_orphan(sk);
 968         l2cap_sock_kill(sk);
 969         return err;
 970 }
 971
 972 static void l2cap_sock_destruct(struct sock *sk)
 973 {
 974         BT_DBG("sk %p", sk);
 975
 976         skb_queue_purge(&sk->sk_receive_queue);
 977         skb_queue_purge(&sk->sk_write_queue);
 978 }
 979
 980 void l2cap_sock_init(struct sock *sk, struct sock *parent)
 981 {
 982         struct l2cap_pinfo *pi = l2cap_pi(sk);
 983         struct l2cap_chan *chan = pi->chan;
 984
 985         BT_DBG("sk %p", sk);
 986
 987         if (parent) {
 988                 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
 989
 990                 sk->sk_type = parent->sk_type;
 991                 bt_sk(sk)->defer_setup = bt_sk(parent)->defer_setup;
 992
 993                 pi->imtu = l2cap_pi(parent)->imtu;
 994                 pi->omtu = l2cap_pi(parent)->omtu;
 995                 chan->conf_state = pchan->conf_state;
 996                 pi->mode = l2cap_pi(parent)->mode;
 997                 pi->fcs  = l2cap_pi(parent)->fcs;
 998                 pi->max_tx = l2cap_pi(parent)->max_tx;
 999                 pi->tx_win = l2cap_pi(parent)->tx_win;
1000                 pi->sec_level = l2cap_pi(parent)->sec_level;
1001                 pi->role_switch = l2cap_pi(parent)->role_switch;
1002                 pi->force_reliable = l2cap_pi(parent)->force_reliable;
1003                 pi->flushable = l2cap_pi(parent)->flushable;
1004         } else {
1005                 pi->imtu = L2CAP_DEFAULT_MTU;
1006                 pi->omtu = 0;
1007                 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
1008                         pi->mode = L2CAP_MODE_ERTM;
1009                         chan->conf_state |= L2CAP_CONF_STATE2_DEVICE;
1010                 } else {
1011                         pi->mode = L2CAP_MODE_BASIC;
1012                 }
1013                 pi->max_tx = L2CAP_DEFAULT_MAX_TX;
1014                 pi->fcs  = L2CAP_FCS_CRC16;
1015                 pi->tx_win = L2CAP_DEFAULT_TX_WINDOW;
1016                 pi->sec_level = BT_SECURITY_LOW;
1017                 pi->role_switch = 0;
1018                 pi->force_reliable = 0;
1019                 pi->flushable = BT_FLUSHABLE_OFF;
1020         }
1021
1022         /* Default config options */
1023         pi->flush_to = L2CAP_DEFAULT_FLUSH_TO;
1024 }
1025
1026 static struct proto l2cap_proto = {
1027         .name           = "L2CAP",
1028         .owner          = THIS_MODULE,
1029         .obj_size       = sizeof(struct l2cap_pinfo)
1030 };
1031
1032 struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
1033 {
1034         struct sock *sk;
1035
1036         sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
1037         if (!sk)
1038                 return NULL;
1039
1040         sock_init_data(sock, sk);
1041         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
1042
1043         sk->sk_destruct = l2cap_sock_destruct;
1044         sk->sk_sndtimeo = msecs_to_jiffies(L2CAP_CONN_TIMEOUT);
1045
1046         sock_reset_flag(sk, SOCK_ZAPPED);
1047
1048         sk->sk_protocol = proto;
1049         sk->sk_state = BT_OPEN;
1050
1051         setup_timer(&sk->sk_timer, l2cap_sock_timeout, (unsigned long) sk);
1052
1053         bt_sock_link(&l2cap_sk_list, sk);
1054         return sk;
1055 }
1056
1057 static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1058                              int kern)
1059 {
1060         struct sock *sk;
1061         struct l2cap_chan *chan;
1062
1063         BT_DBG("sock %p", sock);
1064
1065         sock->state = SS_UNCONNECTED;
1066
1067         if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
1068                         sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
1069                 return -ESOCKTNOSUPPORT;
1070
1071         if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1072                 return -EPERM;
1073
1074         sock->ops = &l2cap_sock_ops;
1075
1076         sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
1077         if (!sk)
1078                 return -ENOMEM;
1079
1080         chan = l2cap_chan_alloc(sk);
1081         if (!chan) {
1082                 l2cap_sock_kill(sk);
1083                 return -ENOMEM;
1084         }
1085
1086         l2cap_pi(sk)->chan = chan;
1087
1088         l2cap_sock_init(sk, NULL);
1089         return 0;
1090 }
1091
1092 const struct proto_ops l2cap_sock_ops = {
1093         .family         = PF_BLUETOOTH,
1094         .owner          = THIS_MODULE,
1095         .release        = l2cap_sock_release,
1096         .bind           = l2cap_sock_bind,
1097         .connect        = l2cap_sock_connect,
1098         .listen         = l2cap_sock_listen,
1099         .accept         = l2cap_sock_accept,
1100         .getname        = l2cap_sock_getname,
1101         .sendmsg        = l2cap_sock_sendmsg,
1102         .recvmsg        = l2cap_sock_recvmsg,
1103         .poll           = bt_sock_poll,
1104         .ioctl          = bt_sock_ioctl,
1105         .mmap           = sock_no_mmap,
1106         .socketpair     = sock_no_socketpair,
1107         .shutdown       = l2cap_sock_shutdown,
1108         .setsockopt     = l2cap_sock_setsockopt,
1109         .getsockopt     = l2cap_sock_getsockopt
1110 };
1111
1112 static const struct net_proto_family l2cap_sock_family_ops = {
1113         .family = PF_BLUETOOTH,
1114         .owner  = THIS_MODULE,
1115         .create = l2cap_sock_create,
1116 };
1117
1118 int __init l2cap_init_sockets(void)
1119 {
1120         int err;
1121
1122         err = proto_register(&l2cap_proto, 0);
1123         if (err < 0)
1124                 return err;
1125
1126         err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
1127         if (err < 0)
1128                 goto error;
1129
1130         BT_INFO("L2CAP socket layer initialized");
1131
1132         return 0;
1133
1134 error:
1135         BT_ERR("L2CAP socket registration failed");
1136         proto_unregister(&l2cap_proto);
1137         return err;
1138 }
1139
1140 void l2cap_cleanup_sockets(void)
1141 {
1142         if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
1143                 BT_ERR("L2CAP socket unregistration failed");
1144
1145         proto_unregister(&l2cap_proto);
1146 }