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_clear_timer(chan);
 711                 __l2cap_chan_close(chan, 0);
 712
 713                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
 714                         err = bt_sock_wait_state(sk, BT_CLOSED,
 715                                                         sk->sk_lingertime);
 716         }
 717
 718         if (!err && sk->sk_err)
 719                 err = -sk->sk_err;
 720
 721         release_sock(sk);
 722         return err;
 723 }
 724
 725 static int l2cap_sock_release(struct socket *sock)
 726 {
 727         struct sock *sk = sock->sk;
 728         int err;
 729
 730         BT_DBG("sock %p, sk %p", sock, sk);
 731
 732         if (!sk)
 733                 return 0;
 734
 735         err = l2cap_sock_shutdown(sock, 2);
 736
 737         sock_orphan(sk);
 738         l2cap_sock_kill(sk);
 739         return err;
 740 }
 741
 742 static void l2cap_sock_destruct(struct sock *sk)
 743 {
 744         BT_DBG("sk %p", sk);
 745
 746         skb_queue_purge(&sk->sk_receive_queue);
 747         skb_queue_purge(&sk->sk_write_queue);
 748 }
 749
 750 void l2cap_sock_init(struct sock *sk, struct sock *parent)
 751 {
 752         struct l2cap_pinfo *pi = l2cap_pi(sk);
 753         struct l2cap_chan *chan = pi->chan;
 754
 755         BT_DBG("sk %p", sk);
 756
 757         if (parent) {
 758                 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
 759
 760                 sk->sk_type = parent->sk_type;
 761                 bt_sk(sk)->defer_setup = bt_sk(parent)->defer_setup;
 762
 763                 chan->chan_type = pchan->chan_type;
 764                 chan->imtu = pchan->imtu;
 765                 chan->omtu = pchan->omtu;
 766                 chan->conf_state = pchan->conf_state;
 767                 chan->mode = pchan->mode;
 768                 chan->fcs  = pchan->fcs;
 769                 chan->max_tx = pchan->max_tx;
 770                 chan->tx_win = pchan->tx_win;
 771                 chan->sec_level = pchan->sec_level;
 772                 chan->role_switch = pchan->role_switch;
 773                 chan->force_reliable = pchan->force_reliable;
 774                 chan->flushable = pchan->flushable;
 775         } else {
 776
 777                 switch (sk->sk_type) {
 778                 case SOCK_RAW:
 779                         chan->chan_type = L2CAP_CHAN_RAW;
 780                         break;
 781                 case SOCK_DGRAM:
 782                         chan->chan_type = L2CAP_CHAN_CONN_LESS;
 783                         break;
 784                 case SOCK_SEQPACKET:
 785                 case SOCK_STREAM:
 786                         chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
 787                         break;
 788                 }
 789
 790                 chan->imtu = L2CAP_DEFAULT_MTU;
 791                 chan->omtu = 0;
 792                 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
 793                         chan->mode = L2CAP_MODE_ERTM;
 794                         chan->conf_state |= L2CAP_CONF_STATE2_DEVICE;
 795                 } else {
 796                         chan->mode = L2CAP_MODE_BASIC;
 797                 }
 798                 chan->max_tx = L2CAP_DEFAULT_MAX_TX;
 799                 chan->fcs  = L2CAP_FCS_CRC16;
 800                 chan->tx_win = L2CAP_DEFAULT_TX_WINDOW;
 801                 chan->sec_level = BT_SECURITY_LOW;
 802                 chan->role_switch = 0;
 803                 chan->force_reliable = 0;
 804                 chan->flushable = BT_FLUSHABLE_OFF;
 805         }
 806
 807         /* Default config options */
 808         chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
 809 }
 810
 811 static struct proto l2cap_proto = {
 812         .name           = "L2CAP",
 813         .owner          = THIS_MODULE,
 814         .obj_size       = sizeof(struct l2cap_pinfo)
 815 };
 816
 817 struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
 818 {
 819         struct sock *sk;
 820
 821         sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
 822         if (!sk)
 823                 return NULL;
 824
 825         sock_init_data(sock, sk);
 826         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
 827
 828         sk->sk_destruct = l2cap_sock_destruct;
 829         sk->sk_sndtimeo = msecs_to_jiffies(L2CAP_CONN_TIMEOUT);
 830
 831         sock_reset_flag(sk, SOCK_ZAPPED);
 832
 833         sk->sk_protocol = proto;
 834         sk->sk_state = BT_OPEN;
 835
 836         return sk;
 837 }
 838
 839 static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
 840                              int kern)
 841 {
 842         struct sock *sk;
 843         struct l2cap_chan *chan;
 844
 845         BT_DBG("sock %p", sock);
 846
 847         sock->state = SS_UNCONNECTED;
 848
 849         if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
 850                         sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
 851                 return -ESOCKTNOSUPPORT;
 852
 853         if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
 854                 return -EPERM;
 855
 856         sock->ops = &l2cap_sock_ops;
 857
 858         sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
 859         if (!sk)
 860                 return -ENOMEM;
 861
 862         chan = l2cap_chan_create(sk);
 863         if (!chan) {
 864                 l2cap_sock_kill(sk);
 865                 return -ENOMEM;
 866         }
 867
 868         l2cap_pi(sk)->chan = chan;
 869
 870         l2cap_sock_init(sk, NULL);
 871         return 0;
 872 }
 873
 874 static const struct proto_ops l2cap_sock_ops = {
 875         .family         = PF_BLUETOOTH,
 876         .owner          = THIS_MODULE,
 877         .release        = l2cap_sock_release,
 878         .bind           = l2cap_sock_bind,
 879         .connect        = l2cap_sock_connect,
 880         .listen         = l2cap_sock_listen,
 881         .accept         = l2cap_sock_accept,
 882         .getname        = l2cap_sock_getname,
 883         .sendmsg        = l2cap_sock_sendmsg,
 884         .recvmsg        = l2cap_sock_recvmsg,
 885         .poll           = bt_sock_poll,
 886         .ioctl          = bt_sock_ioctl,
 887         .mmap           = sock_no_mmap,
 888         .socketpair     = sock_no_socketpair,
 889         .shutdown       = l2cap_sock_shutdown,
 890         .setsockopt     = l2cap_sock_setsockopt,
 891         .getsockopt     = l2cap_sock_getsockopt
 892 };
 893
 894 static const struct net_proto_family l2cap_sock_family_ops = {
 895         .family = PF_BLUETOOTH,
 896         .owner  = THIS_MODULE,
 897         .create = l2cap_sock_create,
 898 };
 899
 900 int __init l2cap_init_sockets(void)
 901 {
 902         int err;
 903
 904         err = proto_register(&l2cap_proto, 0);
 905         if (err < 0)
 906                 return err;
 907
 908         err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
 909         if (err < 0)
 910                 goto error;
 911
 912         BT_INFO("L2CAP socket layer initialized");
 913
 914         return 0;
 915
 916 error:
 917         BT_ERR("L2CAP socket registration failed");
 918         proto_unregister(&l2cap_proto);
 919         return err;
 920 }
 921
 922 void l2cap_cleanup_sockets(void)
 923 {
 924         if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
 925                 BT_ERR("L2CAP socket unregistration failed");
 926
 927         proto_unregister(&l2cap_proto);
 928 }