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         int len, err = 0;
 394
 395         BT_DBG("sk %p", sk);
 396
 397         if (level == SOL_L2CAP)
 398                 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
 399
 400         if (level != SOL_BLUETOOTH)
 401                 return -ENOPROTOOPT;
 402
 403         if (get_user(len, optlen))
 404                 return -EFAULT;
 405
 406         lock_sock(sk);
 407
 408         switch (optname) {
 409         case BT_SECURITY:
 410                 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
 411                                         chan->chan_type != L2CAP_CHAN_RAW) {
 412                         err = -EINVAL;
 413                         break;
 414                 }
 415
 416                 sec.level = chan->sec_level;
 417
 418                 len = min_t(unsigned int, len, sizeof(sec));
 419                 if (copy_to_user(optval, (char *) &sec, len))
 420                         err = -EFAULT;
 421
 422                 break;
 423
 424         case BT_DEFER_SETUP:
 425                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 426                         err = -EINVAL;
 427                         break;
 428                 }
 429
 430                 if (put_user(bt_sk(sk)->defer_setup, (u32 __user *) optval))
 431                         err = -EFAULT;
 432
 433                 break;
 434
 435         case BT_FLUSHABLE:
 436                 if (put_user(chan->flushable, (u32 __user *) optval))
 437                         err = -EFAULT;
 438
 439                 break;
 440
 441         default:
 442                 err = -ENOPROTOOPT;
 443                 break;
 444         }
 445
 446         release_sock(sk);
 447         return err;
 448 }
 449
 450 static int l2cap_sock_setsockopt_old(struct socket *sock, int optname, char __user *optval, unsigned int optlen)
 451 {
 452         struct sock *sk = sock->sk;
 453         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 454         struct l2cap_options opts;
 455         int len, err = 0;
 456         u32 opt;
 457
 458         BT_DBG("sk %p", sk);
 459
 460         lock_sock(sk);
 461
 462         switch (optname) {
 463         case L2CAP_OPTIONS:
 464                 if (sk->sk_state == BT_CONNECTED) {
 465                         err = -EINVAL;
 466                         break;
 467                 }
 468
 469                 opts.imtu     = chan->imtu;
 470                 opts.omtu     = chan->omtu;
 471                 opts.flush_to = chan->flush_to;
 472                 opts.mode     = chan->mode;
 473                 opts.fcs      = chan->fcs;
 474                 opts.max_tx   = chan->max_tx;
 475                 opts.txwin_size = (__u16)chan->tx_win;
 476
 477                 len = min_t(unsigned int, sizeof(opts), optlen);
 478                 if (copy_from_user((char *) &opts, optval, len)) {
 479                         err = -EFAULT;
 480                         break;
 481                 }
 482
 483                 if (opts.txwin_size > L2CAP_DEFAULT_TX_WINDOW) {
 484                         err = -EINVAL;
 485                         break;
 486                 }
 487
 488                 chan->mode = opts.mode;
 489                 switch (chan->mode) {
 490                 case L2CAP_MODE_BASIC:
 491                         chan->conf_state &= ~L2CAP_CONF_STATE2_DEVICE;
 492                         break;
 493                 case L2CAP_MODE_ERTM:
 494                 case L2CAP_MODE_STREAMING:
 495                         if (!disable_ertm)
 496                                 break;
 497                         /* fall through */
 498                 default:
 499                         err = -EINVAL;
 500                         break;
 501                 }
 502
 503                 chan->imtu = opts.imtu;
 504                 chan->omtu = opts.omtu;
 505                 chan->fcs  = opts.fcs;
 506                 chan->max_tx = opts.max_tx;
 507                 chan->tx_win = (__u8)opts.txwin_size;
 508                 break;
 509
 510         case L2CAP_LM:
 511                 if (get_user(opt, (u32 __user *) optval)) {
 512                         err = -EFAULT;
 513                         break;
 514                 }
 515
 516                 if (opt & L2CAP_LM_AUTH)
 517                         chan->sec_level = BT_SECURITY_LOW;
 518                 if (opt & L2CAP_LM_ENCRYPT)
 519                         chan->sec_level = BT_SECURITY_MEDIUM;
 520                 if (opt & L2CAP_LM_SECURE)
 521                         chan->sec_level = BT_SECURITY_HIGH;
 522
 523                 chan->role_switch    = (opt & L2CAP_LM_MASTER);
 524                 chan->force_reliable = (opt & L2CAP_LM_RELIABLE);
 525                 break;
 526
 527         default:
 528                 err = -ENOPROTOOPT;
 529                 break;
 530         }
 531
 532         release_sock(sk);
 533         return err;
 534 }
 535
 536 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
 537 {
 538         struct sock *sk = sock->sk;
 539         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 540         struct bt_security sec;
 541         int len, err = 0;
 542         u32 opt;
 543
 544         BT_DBG("sk %p", sk);
 545
 546         if (level == SOL_L2CAP)
 547                 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
 548
 549         if (level != SOL_BLUETOOTH)
 550                 return -ENOPROTOOPT;
 551
 552         lock_sock(sk);
 553
 554         switch (optname) {
 555         case BT_SECURITY:
 556                 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
 557                                         chan->chan_type != L2CAP_CHAN_RAW) {
 558                         err = -EINVAL;
 559                         break;
 560                 }
 561
 562                 sec.level = BT_SECURITY_LOW;
 563
 564                 len = min_t(unsigned int, sizeof(sec), optlen);
 565                 if (copy_from_user((char *) &sec, optval, len)) {
 566                         err = -EFAULT;
 567                         break;
 568                 }
 569
 570                 if (sec.level < BT_SECURITY_LOW ||
 571                                         sec.level > BT_SECURITY_HIGH) {
 572                         err = -EINVAL;
 573                         break;
 574                 }
 575
 576                 chan->sec_level = sec.level;
 577                 break;
 578
 579         case BT_DEFER_SETUP:
 580                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 581                         err = -EINVAL;
 582                         break;
 583                 }
 584
 585                 if (get_user(opt, (u32 __user *) optval)) {
 586                         err = -EFAULT;
 587                         break;
 588                 }
 589
 590                 bt_sk(sk)->defer_setup = opt;
 591                 break;
 592
 593         case BT_FLUSHABLE:
 594                 if (get_user(opt, (u32 __user *) optval)) {
 595                         err = -EFAULT;
 596                         break;
 597                 }
 598
 599                 if (opt > BT_FLUSHABLE_ON) {
 600                         err = -EINVAL;
 601                         break;
 602                 }
 603
 604                 if (opt == BT_FLUSHABLE_OFF) {
 605                         struct l2cap_conn *conn = chan->conn;
 606                         /* proceed further only when we have l2cap_conn and
 607                            No Flush support in the LM */
 608                         if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
 609                                 err = -EINVAL;
 610                                 break;
 611                         }
 612                 }
 613
 614                 chan->flushable = opt;
 615                 break;
 616
 617         default:
 618                 err = -ENOPROTOOPT;
 619                 break;
 620         }
 621
 622         release_sock(sk);
 623         return err;
 624 }
 625
 626 static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len)
 627 {
 628         struct sock *sk = sock->sk;
 629         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 630         int err;
 631
 632         BT_DBG("sock %p, sk %p", sock, sk);
 633
 634         err = sock_error(sk);
 635         if (err)
 636                 return err;
 637
 638         if (msg->msg_flags & MSG_OOB)
 639                 return -EOPNOTSUPP;
 640
 641         lock_sock(sk);
 642
 643         if (sk->sk_state != BT_CONNECTED) {
 644                 release_sock(sk);
 645                 return -ENOTCONN;
 646         }
 647
 648         err = l2cap_chan_send(chan, msg, len);
 649
 650         release_sock(sk);
 651         return err;
 652 }
 653
 654 static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len, int flags)
 655 {
 656         struct sock *sk = sock->sk;
 657
 658         lock_sock(sk);
 659
 660         if (sk->sk_state == BT_CONNECT2 && bt_sk(sk)->defer_setup) {
 661                 sk->sk_state = BT_CONFIG;
 662
 663                 __l2cap_connect_rsp_defer(l2cap_pi(sk)->chan);
 664                 release_sock(sk);
 665                 return 0;
 666         }
 667
 668         release_sock(sk);
 669
 670         if (sock->type == SOCK_STREAM)
 671                 return bt_sock_stream_recvmsg(iocb, sock, msg, len, flags);
 672
 673         return bt_sock_recvmsg(iocb, sock, msg, len, flags);
 674 }
 675
 676 /* Kill socket (only if zapped and orphan)
 677  * Must be called on unlocked socket.
 678  */
 679 void l2cap_sock_kill(struct sock *sk)
 680 {
 681         if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
 682                 return;
 683
 684         BT_DBG("sk %p state %d", sk, sk->sk_state);
 685
 686         /* Kill poor orphan */
 687
 688         l2cap_chan_destroy(l2cap_pi(sk)->chan);
 689         sock_set_flag(sk, SOCK_DEAD);
 690         sock_put(sk);
 691 }
 692
 693 static int l2cap_sock_shutdown(struct socket *sock, int how)
 694 {
 695         struct sock *sk = sock->sk;
 696         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 697         int err = 0;
 698
 699         BT_DBG("sock %p, sk %p", sock, sk);
 700
 701         if (!sk)
 702                 return 0;
 703
 704         lock_sock(sk);
 705         if (!sk->sk_shutdown) {
 706                 if (chan->mode == L2CAP_MODE_ERTM)
 707                         err = __l2cap_wait_ack(sk);
 708
 709                 sk->sk_shutdown = SHUTDOWN_MASK;
 710                 l2cap_chan_close(chan, 0);
 711
 712                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
 713                         err = bt_sock_wait_state(sk, BT_CLOSED,
 714                                                         sk->sk_lingertime);
 715         }
 716
 717         if (!err && sk->sk_err)
 718                 err = -sk->sk_err;
 719
 720         release_sock(sk);
 721         return err;
 722 }
 723
 724 static int l2cap_sock_release(struct socket *sock)
 725 {
 726         struct sock *sk = sock->sk;
 727         int err;
 728
 729         BT_DBG("sock %p, sk %p", sock, sk);
 730
 731         if (!sk)
 732                 return 0;
 733
 734         err = l2cap_sock_shutdown(sock, 2);
 735
 736         sock_orphan(sk);
 737         l2cap_sock_kill(sk);
 738         return err;
 739 }
 740
 741 static void l2cap_sock_destruct(struct sock *sk)
 742 {
 743         BT_DBG("sk %p", sk);
 744
 745         skb_queue_purge(&sk->sk_receive_queue);
 746         skb_queue_purge(&sk->sk_write_queue);
 747 }
 748
 749 void l2cap_sock_init(struct sock *sk, struct sock *parent)
 750 {
 751         struct l2cap_pinfo *pi = l2cap_pi(sk);
 752         struct l2cap_chan *chan = pi->chan;
 753
 754         BT_DBG("sk %p", sk);
 755
 756         if (parent) {
 757                 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
 758
 759                 sk->sk_type = parent->sk_type;
 760                 bt_sk(sk)->defer_setup = bt_sk(parent)->defer_setup;
 761
 762                 chan->chan_type = pchan->chan_type;
 763                 chan->imtu = pchan->imtu;
 764                 chan->omtu = pchan->omtu;
 765                 chan->conf_state = pchan->conf_state;
 766                 chan->mode = pchan->mode;
 767                 chan->fcs  = pchan->fcs;
 768                 chan->max_tx = pchan->max_tx;
 769                 chan->tx_win = pchan->tx_win;
 770                 chan->sec_level = pchan->sec_level;
 771                 chan->role_switch = pchan->role_switch;
 772                 chan->force_reliable = pchan->force_reliable;
 773                 chan->flushable = pchan->flushable;
 774         } else {
 775
 776                 switch (sk->sk_type) {
 777                 case SOCK_RAW:
 778                         chan->chan_type = L2CAP_CHAN_RAW;
 779                         break;
 780                 case SOCK_DGRAM:
 781                         chan->chan_type = L2CAP_CHAN_CONN_LESS;
 782                         break;
 783                 case SOCK_SEQPACKET:
 784                 case SOCK_STREAM:
 785                         chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
 786                         break;
 787                 }
 788
 789                 chan->imtu = L2CAP_DEFAULT_MTU;
 790                 chan->omtu = 0;
 791                 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
 792                         chan->mode = L2CAP_MODE_ERTM;
 793                         chan->conf_state |= L2CAP_CONF_STATE2_DEVICE;
 794                 } else {
 795                         chan->mode = L2CAP_MODE_BASIC;
 796                 }
 797                 chan->max_tx = L2CAP_DEFAULT_MAX_TX;
 798                 chan->fcs  = L2CAP_FCS_CRC16;
 799                 chan->tx_win = L2CAP_DEFAULT_TX_WINDOW;
 800                 chan->sec_level = BT_SECURITY_LOW;
 801                 chan->role_switch = 0;
 802                 chan->force_reliable = 0;
 803                 chan->flushable = BT_FLUSHABLE_OFF;
 804         }
 805
 806         /* Default config options */
 807         chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
 808 }
 809
 810 static struct proto l2cap_proto = {
 811         .name           = "L2CAP",
 812         .owner          = THIS_MODULE,
 813         .obj_size       = sizeof(struct l2cap_pinfo)
 814 };
 815
 816 struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
 817 {
 818         struct sock *sk;
 819
 820         sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
 821         if (!sk)
 822                 return NULL;
 823
 824         sock_init_data(sock, sk);
 825         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
 826
 827         sk->sk_destruct = l2cap_sock_destruct;
 828         sk->sk_sndtimeo = msecs_to_jiffies(L2CAP_CONN_TIMEOUT);
 829
 830         sock_reset_flag(sk, SOCK_ZAPPED);
 831
 832         sk->sk_protocol = proto;
 833         sk->sk_state = BT_OPEN;
 834
 835         return sk;
 836 }
 837
 838 static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
 839                              int kern)
 840 {
 841         struct sock *sk;
 842         struct l2cap_chan *chan;
 843
 844         BT_DBG("sock %p", sock);
 845
 846         sock->state = SS_UNCONNECTED;
 847
 848         if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
 849                         sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
 850                 return -ESOCKTNOSUPPORT;
 851
 852         if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
 853                 return -EPERM;
 854
 855         sock->ops = &l2cap_sock_ops;
 856
 857         sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
 858         if (!sk)
 859                 return -ENOMEM;
 860
 861         chan = l2cap_chan_create(sk);
 862         if (!chan) {
 863                 l2cap_sock_kill(sk);
 864                 return -ENOMEM;
 865         }
 866
 867         l2cap_pi(sk)->chan = chan;
 868
 869         l2cap_sock_init(sk, NULL);
 870         return 0;
 871 }
 872
 873 static const struct proto_ops l2cap_sock_ops = {
 874         .family         = PF_BLUETOOTH,
 875         .owner          = THIS_MODULE,
 876         .release        = l2cap_sock_release,
 877         .bind           = l2cap_sock_bind,
 878         .connect        = l2cap_sock_connect,
 879         .listen         = l2cap_sock_listen,
 880         .accept         = l2cap_sock_accept,
 881         .getname        = l2cap_sock_getname,
 882         .sendmsg        = l2cap_sock_sendmsg,
 883         .recvmsg        = l2cap_sock_recvmsg,
 884         .poll           = bt_sock_poll,
 885         .ioctl          = bt_sock_ioctl,
 886         .mmap           = sock_no_mmap,
 887         .socketpair     = sock_no_socketpair,
 888         .shutdown       = l2cap_sock_shutdown,
 889         .setsockopt     = l2cap_sock_setsockopt,
 890         .getsockopt     = l2cap_sock_getsockopt
 891 };
 892
 893 static const struct net_proto_family l2cap_sock_family_ops = {
 894         .family = PF_BLUETOOTH,
 895         .owner  = THIS_MODULE,
 896         .create = l2cap_sock_create,
 897 };
 898
 899 int __init l2cap_init_sockets(void)
 900 {
 901         int err;
 902
 903         err = proto_register(&l2cap_proto, 0);
 904         if (err < 0)
 905                 return err;
 906
 907         err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
 908         if (err < 0)
 909                 goto error;
 910
 911         BT_INFO("L2CAP socket layer initialized");
 912
 913         return 0;
 914
 915 error:
 916         BT_ERR("L2CAP socket registration failed");
 917         proto_unregister(&l2cap_proto);
 918         return err;
 919 }
 920
 921 void l2cap_cleanup_sockets(void)
 922 {
 923         if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
 924                 BT_ERR("L2CAP socket unregistration failed");
 925
 926         proto_unregister(&l2cap_proto);
 927 }