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