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