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 static const struct proto_ops l2cap_sock_ops;
  34
  35 static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
  36 {
  37         struct sock *sk = sock->sk;
  38         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
  39         struct sockaddr_l2 la;
  40         int len, err = 0;
  41
  42         BT_DBG("sk %p", sk);
  43
  44         if (!addr || addr->sa_family != AF_BLUETOOTH)
  45                 return -EINVAL;
  46
  47         memset(&la, 0, sizeof(la));
  48         len = min_t(unsigned int, sizeof(la), alen);
  49         memcpy(&la, addr, len);
  50
  51         if (la.l2_cid && la.l2_psm)
  52                 return -EINVAL;
  53
  54         lock_sock(sk);
  55
  56         if (sk->sk_state != BT_OPEN) {
  57                 err = -EBADFD;
  58                 goto done;
  59         }
  60
  61         if (la.l2_psm) {
  62                 __u16 psm = __le16_to_cpu(la.l2_psm);
  63
  64                 /* PSM must be odd and lsb of upper byte must be 0 */
  65                 if ((psm & 0x0101) != 0x0001) {
  66                         err = -EINVAL;
  67                         goto done;
  68                 }
  69
  70                 /* Restrict usage of well-known PSMs */
  71                 if (psm < 0x1001 && !capable(CAP_NET_BIND_SERVICE)) {
  72                         err = -EACCES;
  73                         goto done;
  74                 }
  75         }
  76
  77         if (la.l2_cid)
  78                 err = l2cap_add_scid(chan, la.l2_cid);
  79         else
  80                 err = l2cap_add_psm(chan, &la.l2_bdaddr, la.l2_psm);
  81
  82         if (err < 0)
  83                 goto done;
  84
  85         if (__le16_to_cpu(la.l2_psm) == 0x0001 ||
  86                                 __le16_to_cpu(la.l2_psm) == 0x0003)
  87                 chan->sec_level = BT_SECURITY_SDP;
  88
  89         bacpy(&bt_sk(sk)->src, &la.l2_bdaddr);
  90         sk->sk_state = BT_BOUND;
  91
  92 done:
  93         release_sock(sk);
  94         return err;
  95 }
  96
  97 static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
  98 {
  99         struct sock *sk = sock->sk;
 100         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 101         struct sockaddr_l2 la;
 102         int len, err = 0;
 103
 104         BT_DBG("sk %p", sk);
 105
 106         if (!addr || alen < sizeof(addr->sa_family) ||
 107             addr->sa_family != AF_BLUETOOTH)
 108                 return -EINVAL;
 109
 110         memset(&la, 0, sizeof(la));
 111         len = min_t(unsigned int, sizeof(la), alen);
 112         memcpy(&la, addr, len);
 113
 114         if (la.l2_cid && la.l2_psm)
 115                 return -EINVAL;
 116
 117         lock_sock(sk);
 118
 119         if (chan->chan_type == L2CAP_CHAN_CONN_ORIENTED
 120                         && !(la.l2_psm || la.l2_cid)) {
 121                 err = -EINVAL;
 122                 goto done;
 123         }
 124
 125         switch (chan->mode) {
 126         case L2CAP_MODE_BASIC:
 127                 break;
 128         case L2CAP_MODE_ERTM:
 129         case L2CAP_MODE_STREAMING:
 130                 if (!disable_ertm)
 131                         break;
 132                 /* fall through */
 133         default:
 134                 err = -ENOTSUPP;
 135                 goto done;
 136         }
 137
 138         switch (sk->sk_state) {
 139         case BT_CONNECT:
 140         case BT_CONNECT2:
 141         case BT_CONFIG:
 142                 /* Already connecting */
 143                 goto wait;
 144
 145         case BT_CONNECTED:
 146                 /* Already connected */
 147                 err = -EISCONN;
 148                 goto done;
 149
 150         case BT_OPEN:
 151         case BT_BOUND:
 152                 /* Can connect */
 153                 break;
 154
 155         default:
 156                 err = -EBADFD;
 157                 goto done;
 158         }
 159
 160         /* PSM must be odd and lsb of upper byte must be 0 */
 161         if ((__le16_to_cpu(la.l2_psm) & 0x0101) != 0x0001 && !la.l2_cid &&
 162                                         chan->chan_type != L2CAP_CHAN_RAW) {
 163                 err = -EINVAL;
 164                 goto done;
 165         }
 166
 167         /* Set destination address and psm */
 168         bacpy(&bt_sk(sk)->dst, &la.l2_bdaddr);
 169         chan->psm = la.l2_psm;
 170         chan->dcid = la.l2_cid;
 171
 172         err = l2cap_chan_connect(l2cap_pi(sk)->chan);
 173         if (err)
 174                 goto done;
 175
 176 wait:
 177         err = bt_sock_wait_state(sk, BT_CONNECTED,
 178                         sock_sndtimeo(sk, flags & O_NONBLOCK));
 179 done:
 180         release_sock(sk);
 181         return err;
 182 }
 183
 184 static int l2cap_sock_listen(struct socket *sock, int backlog)
 185 {
 186         struct sock *sk = sock->sk;
 187         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 188         int err = 0;
 189
 190         BT_DBG("sk %p backlog %d", sk, backlog);
 191
 192         lock_sock(sk);
 193
 194         if ((sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM)
 195                         || sk->sk_state != BT_BOUND) {
 196                 err = -EBADFD;
 197                 goto done;
 198         }
 199
 200         switch (chan->mode) {
 201         case L2CAP_MODE_BASIC:
 202                 break;
 203         case L2CAP_MODE_ERTM:
 204         case L2CAP_MODE_STREAMING:
 205                 if (!disable_ertm)
 206                         break;
 207                 /* fall through */
 208         default:
 209                 err = -ENOTSUPP;
 210                 goto done;
 211         }
 212
 213         sk->sk_max_ack_backlog = backlog;
 214         sk->sk_ack_backlog = 0;
 215         sk->sk_state = BT_LISTEN;
 216
 217 done:
 218         release_sock(sk);
 219         return err;
 220 }
 221
 222 static int l2cap_sock_accept(struct socket *sock, struct socket *newsock, int flags)
 223 {
 224         DECLARE_WAITQUEUE(wait, current);
 225         struct sock *sk = sock->sk, *nsk;
 226         long timeo;
 227         int err = 0;
 228
 229         lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
 230
 231         if (sk->sk_state != BT_LISTEN) {
 232                 err = -EBADFD;
 233                 goto done;
 234         }
 235
 236         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 237
 238         BT_DBG("sk %p timeo %ld", sk, timeo);
 239
 240         /* Wait for an incoming connection. (wake-one). */
 241         add_wait_queue_exclusive(sk_sleep(sk), &wait);
 242         while (!(nsk = bt_accept_dequeue(sk, newsock))) {
 243                 set_current_state(TASK_INTERRUPTIBLE);
 244                 if (!timeo) {
 245                         err = -EAGAIN;
 246                         break;
 247                 }
 248
 249                 release_sock(sk);
 250                 timeo = schedule_timeout(timeo);
 251                 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
 252
 253                 if (sk->sk_state != BT_LISTEN) {
 254                         err = -EBADFD;
 255                         break;
 256                 }
 257
 258                 if (signal_pending(current)) {
 259                         err = sock_intr_errno(timeo);
 260                         break;
 261                 }
 262         }
 263         set_current_state(TASK_RUNNING);
 264         remove_wait_queue(sk_sleep(sk), &wait);
 265
 266         if (err)
 267                 goto done;
 268
 269         newsock->state = SS_CONNECTED;
 270
 271         BT_DBG("new socket %p", nsk);
 272
 273 done:
 274         release_sock(sk);
 275         return err;
 276 }
 277
 278 static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
 279 {
 280         struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
 281         struct sock *sk = sock->sk;
 282         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 283
 284         BT_DBG("sock %p, sk %p", sock, sk);
 285
 286         addr->sa_family = AF_BLUETOOTH;
 287         *len = sizeof(struct sockaddr_l2);
 288
 289         if (peer) {
 290                 la->l2_psm = chan->psm;
 291                 bacpy(&la->l2_bdaddr, &bt_sk(sk)->dst);
 292                 la->l2_cid = cpu_to_le16(chan->dcid);
 293         } else {
 294                 la->l2_psm = chan->sport;
 295                 bacpy(&la->l2_bdaddr, &bt_sk(sk)->src);
 296                 la->l2_cid = cpu_to_le16(chan->scid);
 297         }
 298
 299         return 0;
 300 }
 301
 302 static int l2cap_sock_getsockopt_old(struct socket *sock, int optname, char __user *optval, int __user *optlen)
 303 {
 304         struct sock *sk = sock->sk;
 305         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 306         struct l2cap_options opts;
 307         struct l2cap_conninfo cinfo;
 308         int len, err = 0;
 309         u32 opt;
 310
 311         BT_DBG("sk %p", sk);
 312
 313         if (get_user(len, optlen))
 314                 return -EFAULT;
 315
 316         lock_sock(sk);
 317
 318         switch (optname) {
 319         case L2CAP_OPTIONS:
 320                 memset(&opts, 0, sizeof(opts));
 321                 opts.imtu     = chan->imtu;
 322                 opts.omtu     = chan->omtu;
 323                 opts.flush_to = chan->flush_to;
 324                 opts.mode     = chan->mode;
 325                 opts.fcs      = chan->fcs;
 326                 opts.max_tx   = chan->max_tx;
 327                 opts.txwin_size = (__u16)chan->tx_win;
 328
 329                 len = min_t(unsigned int, len, sizeof(opts));
 330                 if (copy_to_user(optval, (char *) &opts, len))
 331                         err = -EFAULT;
 332
 333                 break;
 334
 335         case L2CAP_LM:
 336                 switch (chan->sec_level) {
 337                 case BT_SECURITY_LOW:
 338                         opt = L2CAP_LM_AUTH;
 339                         break;
 340                 case BT_SECURITY_MEDIUM:
 341                         opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
 342                         break;
 343                 case BT_SECURITY_HIGH:
 344                         opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
 345                                                         L2CAP_LM_SECURE;
 346                         break;
 347                 default:
 348                         opt = 0;
 349                         break;
 350                 }
 351
 352                 if (chan->role_switch)
 353                         opt |= L2CAP_LM_MASTER;
 354
 355                 if (chan->force_reliable)
 356                         opt |= L2CAP_LM_RELIABLE;
 357
 358                 if (put_user(opt, (u32 __user *) optval))
 359                         err = -EFAULT;
 360                 break;
 361
 362         case L2CAP_CONNINFO:
 363                 if (sk->sk_state != BT_CONNECTED &&
 364                                         !(sk->sk_state == BT_CONNECT2 &&
 365                                                 bt_sk(sk)->defer_setup)) {
 366                         err = -ENOTCONN;
 367                         break;
 368                 }
 369
 370                 cinfo.hci_handle = chan->conn->hcon->handle;
 371                 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
 372
 373                 len = min_t(unsigned int, len, sizeof(cinfo));
 374                 if (copy_to_user(optval, (char *) &cinfo, len))
 375                         err = -EFAULT;
 376
 377                 break;
 378
 379         default:
 380                 err = -ENOPROTOOPT;
 381                 break;
 382         }
 383
 384         release_sock(sk);
 385         return err;
 386 }
 387
 388 static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
 389 {
 390         struct sock *sk = sock->sk;
 391         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 392         struct bt_security sec;
 393         struct bt_power pwr;
 394         int len, err = 0;
 395
 396         BT_DBG("sk %p", sk);
 397
 398         if (level == SOL_L2CAP)
 399                 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
 400
 401         if (level != SOL_BLUETOOTH)
 402                 return -ENOPROTOOPT;
 403
 404         if (get_user(len, optlen))
 405                 return -EFAULT;
 406
 407         lock_sock(sk);
 408
 409         switch (optname) {
 410         case BT_SECURITY:
 411                 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
 412                                         chan->chan_type != L2CAP_CHAN_RAW) {
 413                         err = -EINVAL;
 414                         break;
 415                 }
 416
 417                 sec.level = chan->sec_level;
 418
 419                 len = min_t(unsigned int, len, sizeof(sec));
 420                 if (copy_to_user(optval, (char *) &sec, len))
 421                         err = -EFAULT;
 422
 423                 break;
 424
 425         case BT_DEFER_SETUP:
 426                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 427                         err = -EINVAL;
 428                         break;
 429                 }
 430
 431                 if (put_user(bt_sk(sk)->defer_setup, (u32 __user *) optval))
 432                         err = -EFAULT;
 433
 434                 break;
 435
 436         case BT_FLUSHABLE:
 437                 if (put_user(chan->flushable, (u32 __user *) optval))
 438                         err = -EFAULT;
 439
 440                 break;
 441
 442         case BT_POWER:
 443                 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
 444                                 && sk->sk_type != SOCK_RAW) {
 445                         err = -EINVAL;
 446                         break;
 447                 }
 448
 449                 pwr.force_active = chan->force_active;
 450
 451                 len = min_t(unsigned int, len, sizeof(pwr));
 452                 if (copy_to_user(optval, (char *) &pwr, len))
 453                         err = -EFAULT;
 454
 455                 break;
 456
 457         default:
 458                 err = -ENOPROTOOPT;
 459                 break;
 460         }
 461
 462         release_sock(sk);
 463         return err;
 464 }
 465
 466 static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __user *optval, unsigned int optlen)
 467 {
 468         struct sock *sk = sock->sk;
 469         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 470         struct l2cap_options opts;
 471         int len, err = 0;
 472         u32 opt;
 473
 474         BT_DBG("sk %p", sk);
 475
 476         lock_sock(sk);
 477
 478         switch (optname) {
 479         case L2CAP_OPTIONS:
 480                 if (sk->sk_state == BT_CONNECTED) {
 481                         err = -EINVAL;
 482                         break;
 483                 }
 484
 485                 opts.imtu     = chan->imtu;
 486                 opts.omtu     = chan->omtu;
 487                 opts.flush_to = chan->flush_to;
 488                 opts.mode     = chan->mode;
 489                 opts.fcs      = chan->fcs;
 490                 opts.max_tx   = chan->max_tx;
 491                 opts.txwin_size = (__u16)chan->tx_win;
 492
 493                 len = min_t(unsigned int, sizeof(opts), optlen);
 494                 if (copy_from_user((char *) &opts, optval, len)) {
 495                         err = -EFAULT;
 496                         break;
 497                 }
 498
 499                 if (opts.txwin_size > L2CAP_DEFAULT_TX_WINDOW) {
 500                         err = -EINVAL;
 501                         break;
 502                 }
 503
 504                 chan->mode = opts.mode;
 505                 switch (chan->mode) {
 506                 case L2CAP_MODE_BASIC:
 507                         chan->conf_state &= ~L2CAP_CONF_STATE2_DEVICE;
 508                         break;
 509                 case L2CAP_MODE_ERTM:
 510                 case L2CAP_MODE_STREAMING:
 511                         if (!disable_ertm)
 512                                 break;
 513                         /* fall through */
 514                 default:
 515                         err = -EINVAL;
 516                         break;
 517                 }
 518
 519                 chan->imtu = opts.imtu;
 520                 chan->omtu = opts.omtu;
 521                 chan->fcs  = opts.fcs;
 522                 chan->max_tx = opts.max_tx;
 523                 chan->tx_win = (__u8)opts.txwin_size;
 524                 break;
 525
 526         case L2CAP_LM:
 527                 if (get_user(opt, (u32 __user *) optval)) {
 528                         err = -EFAULT;
 529                         break;
 530                 }
 531
 532                 if (opt & L2CAP_LM_AUTH)
 533                         chan->sec_level = BT_SECURITY_LOW;
 534                 if (opt & L2CAP_LM_ENCRYPT)
 535                         chan->sec_level = BT_SECURITY_MEDIUM;
 536                 if (opt & L2CAP_LM_SECURE)
 537                         chan->sec_level = BT_SECURITY_HIGH;
 538
 539                 chan->role_switch    = (opt & L2CAP_LM_MASTER);
 540                 chan->force_reliable = (opt & L2CAP_LM_RELIABLE);
 541                 break;
 542
 543         default:
 544                 err = -ENOPROTOOPT;
 545                 break;
 546         }
 547
 548         release_sock(sk);
 549         return err;
 550 }
 551
 552 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
 553 {
 554         struct sock *sk = sock->sk;
 555         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 556         struct bt_security sec;
 557         struct bt_power pwr;
 558         int len, err = 0;
 559         u32 opt;
 560
 561         BT_DBG("sk %p", sk);
 562
 563         if (level == SOL_L2CAP)
 564                 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
 565
 566         if (level != SOL_BLUETOOTH)
 567                 return -ENOPROTOOPT;
 568
 569         lock_sock(sk);
 570
 571         switch (optname) {
 572         case BT_SECURITY:
 573                 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
 574                                         chan->chan_type != L2CAP_CHAN_RAW) {
 575                         err = -EINVAL;
 576                         break;
 577                 }
 578
 579                 sec.level = BT_SECURITY_LOW;
 580
 581                 len = min_t(unsigned int, sizeof(sec), optlen);
 582                 if (copy_from_user((char *) &sec, optval, len)) {
 583                         err = -EFAULT;
 584                         break;
 585                 }
 586
 587                 if (sec.level < BT_SECURITY_LOW ||
 588                                         sec.level > BT_SECURITY_HIGH) {
 589                         err = -EINVAL;
 590                         break;
 591                 }
 592
 593                 chan->sec_level = sec.level;
 594                 break;
 595
 596         case BT_DEFER_SETUP:
 597                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 598                         err = -EINVAL;
 599                         break;
 600                 }
 601
 602                 if (get_user(opt, (u32 __user *) optval)) {
 603                         err = -EFAULT;
 604                         break;
 605                 }
 606
 607                 bt_sk(sk)->defer_setup = opt;
 608                 break;
 609
 610         case BT_FLUSHABLE:
 611                 if (get_user(opt, (u32 __user *) optval)) {
 612                         err = -EFAULT;
 613                         break;
 614                 }
 615
 616                 if (opt > BT_FLUSHABLE_ON) {
 617                         err = -EINVAL;
 618                         break;
 619                 }
 620
 621                 if (opt == BT_FLUSHABLE_OFF) {
 622                         struct l2cap_conn *conn = chan->conn;
 623                         /* proceed further only when we have l2cap_conn and
 624                            No Flush support in the LM */
 625                         if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
 626                                 err = -EINVAL;
 627                                 break;
 628                         }
 629                 }
 630
 631                 chan->flushable = opt;
 632                 break;
 633
 634         case BT_POWER:
 635                 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
 636                                         chan->chan_type != L2CAP_CHAN_RAW) {
 637                         err = -EINVAL;
 638                         break;
 639                 }
 640
 641                 pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
 642
 643                 len = min_t(unsigned int, sizeof(pwr), optlen);
 644                 if (copy_from_user((char *) &pwr, optval, len)) {
 645                         err = -EFAULT;
 646                         break;
 647                 }
 648                 chan->force_active = pwr.force_active;
 649                 break;
 650
 651         default:
 652                 err = -ENOPROTOOPT;
 653                 break;
 654         }
 655
 656         release_sock(sk);
 657         return err;
 658 }
 659
 660 static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len)
 661 {
 662         struct sock *sk = sock->sk;
 663         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 664         int err;
 665
 666         BT_DBG("sock %p, sk %p", sock, sk);
 667
 668         err = sock_error(sk);
 669         if (err)
 670                 return err;
 671
 672         if (msg->msg_flags & MSG_OOB)
 673                 return -EOPNOTSUPP;
 674
 675         lock_sock(sk);
 676
 677         if (sk->sk_state != BT_CONNECTED) {
 678                 release_sock(sk);
 679                 return -ENOTCONN;
 680         }
 681
 682         err = l2cap_chan_send(chan, msg, len);
 683
 684         release_sock(sk);
 685         return err;
 686 }
 687
 688 static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len, int flags)
 689 {
 690         struct sock *sk = sock->sk;
 691
 692         lock_sock(sk);
 693
 694         if (sk->sk_state == BT_CONNECT2 && bt_sk(sk)->defer_setup) {
 695                 sk->sk_state = BT_CONFIG;
 696
 697                 __l2cap_connect_rsp_defer(l2cap_pi(sk)->chan);
 698                 release_sock(sk);
 699                 return 0;
 700         }
 701
 702         release_sock(sk);
 703
 704         if (sock->type == SOCK_STREAM)
 705                 return bt_sock_stream_recvmsg(iocb, sock, msg, len, flags);
 706
 707         return bt_sock_recvmsg(iocb, sock, msg, len, flags);
 708 }
 709
 710 /* Kill socket (only if zapped and orphan)
 711  * Must be called on unlocked socket.
 712  */
 713 void l2cap_sock_kill(struct sock *sk)
 714 {
 715         if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
 716                 return;
 717
 718         BT_DBG("sk %p state %d", sk, sk->sk_state);
 719
 720         /* Kill poor orphan */
 721
 722         l2cap_chan_destroy(l2cap_pi(sk)->chan);
 723         sock_set_flag(sk, SOCK_DEAD);
 724         sock_put(sk);
 725 }
 726
 727 static int l2cap_sock_shutdown(struct socket *sock, int how)
 728 {
 729         struct sock *sk = sock->sk;
 730         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 731         int err = 0;
 732
 733         BT_DBG("sock %p, sk %p", sock, sk);
 734
 735         if (!sk)
 736                 return 0;
 737
 738         lock_sock(sk);
 739         if (!sk->sk_shutdown) {
 740                 if (chan->mode == L2CAP_MODE_ERTM)
 741                         err = __l2cap_wait_ack(sk);
 742
 743                 sk->sk_shutdown = SHUTDOWN_MASK;
 744                 l2cap_chan_close(chan, 0);
 745
 746                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
 747                         err = bt_sock_wait_state(sk, BT_CLOSED,
 748                                                         sk->sk_lingertime);
 749         }
 750
 751         if (!err && sk->sk_err)
 752                 err = -sk->sk_err;
 753
 754         release_sock(sk);
 755         return err;
 756 }
 757
 758 static int l2cap_sock_release(struct socket *sock)
 759 {
 760         struct sock *sk = sock->sk;
 761         int err;
 762
 763         BT_DBG("sock %p, sk %p", sock, sk);
 764
 765         if (!sk)
 766                 return 0;
 767
 768         err = l2cap_sock_shutdown(sock, 2);
 769
 770         sock_orphan(sk);
 771         l2cap_sock_kill(sk);
 772         return err;
 773 }
 774
 775 static void l2cap_sock_destruct(struct sock *sk)
 776 {
 777         BT_DBG("sk %p", sk);
 778
 779         skb_queue_purge(&sk->sk_receive_queue);
 780         skb_queue_purge(&sk->sk_write_queue);
 781 }
 782
 783 void l2cap_sock_init(struct sock *sk, struct sock *parent)
 784 {
 785         struct l2cap_pinfo *pi = l2cap_pi(sk);
 786         struct l2cap_chan *chan = pi->chan;
 787
 788         BT_DBG("sk %p", sk);
 789
 790         if (parent) {
 791                 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
 792
 793                 sk->sk_type = parent->sk_type;
 794                 bt_sk(sk)->defer_setup = bt_sk(parent)->defer_setup;
 795
 796                 chan->chan_type = pchan->chan_type;
 797                 chan->imtu = pchan->imtu;
 798                 chan->omtu = pchan->omtu;
 799                 chan->conf_state = pchan->conf_state;
 800                 chan->mode = pchan->mode;
 801                 chan->fcs  = pchan->fcs;
 802                 chan->max_tx = pchan->max_tx;
 803                 chan->tx_win = pchan->tx_win;
 804                 chan->sec_level = pchan->sec_level;
 805                 chan->role_switch = pchan->role_switch;
 806                 chan->force_reliable = pchan->force_reliable;
 807                 chan->flushable = pchan->flushable;
 808                 chan->force_active = pchan->force_active;
 809         } else {
 810
 811                 switch (sk->sk_type) {
 812                 case SOCK_RAW:
 813                         chan->chan_type = L2CAP_CHAN_RAW;
 814                         break;
 815                 case SOCK_DGRAM:
 816                         chan->chan_type = L2CAP_CHAN_CONN_LESS;
 817                         break;
 818                 case SOCK_SEQPACKET:
 819                 case SOCK_STREAM:
 820                         chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
 821                         break;
 822                 }
 823
 824                 chan->imtu = L2CAP_DEFAULT_MTU;
 825                 chan->omtu = 0;
 826                 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
 827                         chan->mode = L2CAP_MODE_ERTM;
 828                         chan->conf_state |= L2CAP_CONF_STATE2_DEVICE;
 829                 } else {
 830                         chan->mode = L2CAP_MODE_BASIC;
 831                 }
 832                 chan->max_tx = L2CAP_DEFAULT_MAX_TX;
 833                 chan->fcs  = L2CAP_FCS_CRC16;
 834                 chan->tx_win = L2CAP_DEFAULT_TX_WINDOW;
 835                 chan->sec_level = BT_SECURITY_LOW;
 836                 chan->role_switch = 0;
 837                 chan->force_reliable = 0;
 838                 chan->flushable = BT_FLUSHABLE_OFF;
 839                 chan->force_active = BT_POWER_FORCE_ACTIVE_ON;
 840         }
 841
 842         /* Default config options */
 843         chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
 844 }
 845
 846 static struct proto l2cap_proto = {
 847         .name           = "L2CAP",
 848         .owner          = THIS_MODULE,
 849         .obj_size       = sizeof(struct l2cap_pinfo)
 850 };
 851
 852 struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
 853 {
 854         struct sock *sk;
 855
 856         sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
 857         if (!sk)
 858                 return NULL;
 859
 860         sock_init_data(sock, sk);
 861         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
 862
 863         sk->sk_destruct = l2cap_sock_destruct;
 864         sk->sk_sndtimeo = msecs_to_jiffies(L2CAP_CONN_TIMEOUT);
 865
 866         sock_reset_flag(sk, SOCK_ZAPPED);
 867
 868         sk->sk_protocol = proto;
 869         sk->sk_state = BT_OPEN;
 870
 871         return sk;
 872 }
 873
 874 static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
 875                              int kern)
 876 {
 877         struct sock *sk;
 878         struct l2cap_chan *chan;
 879
 880         BT_DBG("sock %p", sock);
 881
 882         sock->state = SS_UNCONNECTED;
 883
 884         if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
 885                         sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
 886                 return -ESOCKTNOSUPPORT;
 887
 888         if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
 889                 return -EPERM;
 890
 891         sock->ops = &l2cap_sock_ops;
 892
 893         sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
 894         if (!sk)
 895                 return -ENOMEM;
 896
 897         chan = l2cap_chan_create(sk);
 898         if (!chan) {
 899                 l2cap_sock_kill(sk);
 900                 return -ENOMEM;
 901         }
 902
 903         l2cap_pi(sk)->chan = chan;
 904
 905         l2cap_sock_init(sk, NULL);
 906         return 0;
 907 }
 908
 909 static const struct proto_ops l2cap_sock_ops = {
 910         .family         = PF_BLUETOOTH,
 911         .owner          = THIS_MODULE,
 912         .release        = l2cap_sock_release,
 913         .bind           = l2cap_sock_bind,
 914         .connect        = l2cap_sock_connect,
 915         .listen         = l2cap_sock_listen,
 916         .accept         = l2cap_sock_accept,
 917         .getname        = l2cap_sock_getname,
 918         .sendmsg        = l2cap_sock_sendmsg,
 919         .recvmsg        = l2cap_sock_recvmsg,
 920         .poll           = bt_sock_poll,
 921         .ioctl          = bt_sock_ioctl,
 922         .mmap           = sock_no_mmap,
 923         .socketpair     = sock_no_socketpair,
 924         .shutdown       = l2cap_sock_shutdown,
 925         .setsockopt     = l2cap_sock_setsockopt,
 926         .getsockopt     = l2cap_sock_getsockopt
 927 };
 928
 929 static const struct net_proto_family l2cap_sock_family_ops = {
 930         .family = PF_BLUETOOTH,
 931         .owner  = THIS_MODULE,
 932         .create = l2cap_sock_create,
 933 };
 934
 935 int __init l2cap_init_sockets(void)
 936 {
 937         int err;
 938
 939         err = proto_register(&l2cap_proto, 0);
 940         if (err < 0)
 941                 return err;
 942
 943         err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
 944         if (err < 0)
 945                 goto error;
 946
 947         BT_INFO("L2CAP socket layer initialized");
 948
 949         return 0;
 950
 951 error:
 952         BT_ERR("L2CAP socket registration failed");
 953         proto_unregister(&l2cap_proto);
 954         return err;
 955 }
 956
 957 void l2cap_cleanup_sockets(void)
 958 {
 959         if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
 960                 BT_ERR("L2CAP socket unregistration failed");
 961
 962         proto_unregister(&l2cap_proto);
 963 }