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