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 = (__u16)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 (chan->role_switch)
 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 = chan->force_active;
 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 = (__u16)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_TX_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 = (__u8)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                 chan->role_switch    = (opt & L2CAP_LM_MASTER);
 553
 554                 if (opt & L2CAP_LM_RELIABLE)
 555                         set_bit(FLAG_FORCE_RELIABLE, &chan->flags);
 556                 else
 557                         clear_bit(FLAG_FORCE_RELIABLE, &chan->flags);
 558                 break;
 559
 560         default:
 561                 err = -ENOPROTOOPT;
 562                 break;
 563         }
 564
 565         release_sock(sk);
 566         return err;
 567 }
 568
 569 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int optlen)
 570 {
 571         struct sock *sk = sock->sk;
 572         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 573         struct bt_security sec;
 574         struct bt_power pwr;
 575         struct l2cap_conn *conn;
 576         int len, err = 0;
 577         u32 opt;
 578
 579         BT_DBG("sk %p", sk);
 580
 581         if (level == SOL_L2CAP)
 582                 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
 583
 584         if (level != SOL_BLUETOOTH)
 585                 return -ENOPROTOOPT;
 586
 587         lock_sock(sk);
 588
 589         switch (optname) {
 590         case BT_SECURITY:
 591                 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
 592                                         chan->chan_type != L2CAP_CHAN_RAW) {
 593                         err = -EINVAL;
 594                         break;
 595                 }
 596
 597                 sec.level = BT_SECURITY_LOW;
 598
 599                 len = min_t(unsigned int, sizeof(sec), optlen);
 600                 if (copy_from_user((char *) &sec, optval, len)) {
 601                         err = -EFAULT;
 602                         break;
 603                 }
 604
 605                 if (sec.level < BT_SECURITY_LOW ||
 606                                         sec.level > BT_SECURITY_HIGH) {
 607                         err = -EINVAL;
 608                         break;
 609                 }
 610
 611                 chan->sec_level = sec.level;
 612
 613                 conn = chan->conn;
 614                 if (conn && chan->scid == L2CAP_CID_LE_DATA) {
 615                         if (!conn->hcon->out) {
 616                                 err = -EINVAL;
 617                                 break;
 618                         }
 619
 620                         if (smp_conn_security(conn, sec.level))
 621                                 break;
 622
 623                         err = 0;
 624                         sk->sk_state = BT_CONFIG;
 625                 }
 626                 break;
 627
 628         case BT_DEFER_SETUP:
 629                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 630                         err = -EINVAL;
 631                         break;
 632                 }
 633
 634                 if (get_user(opt, (u32 __user *) optval)) {
 635                         err = -EFAULT;
 636                         break;
 637                 }
 638
 639                 bt_sk(sk)->defer_setup = opt;
 640                 break;
 641
 642         case BT_FLUSHABLE:
 643                 if (get_user(opt, (u32 __user *) optval)) {
 644                         err = -EFAULT;
 645                         break;
 646                 }
 647
 648                 if (opt > BT_FLUSHABLE_ON) {
 649                         err = -EINVAL;
 650                         break;
 651                 }
 652
 653                 if (opt == BT_FLUSHABLE_OFF) {
 654                         struct l2cap_conn *conn = chan->conn;
 655                         /* proceed further only when we have l2cap_conn and
 656                            No Flush support in the LM */
 657                         if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
 658                                 err = -EINVAL;
 659                                 break;
 660                         }
 661                 }
 662
 663                 if (opt)
 664                         set_bit(FLAG_FLUSHABLE, &chan->flags);
 665                 else
 666                         clear_bit(FLAG_FLUSHABLE, &chan->flags);
 667                 break;
 668
 669         case BT_POWER:
 670                 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
 671                                         chan->chan_type != L2CAP_CHAN_RAW) {
 672                         err = -EINVAL;
 673                         break;
 674                 }
 675
 676                 pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
 677
 678                 len = min_t(unsigned int, sizeof(pwr), optlen);
 679                 if (copy_from_user((char *) &pwr, optval, len)) {
 680                         err = -EFAULT;
 681                         break;
 682                 }
 683                 chan->force_active = pwr.force_active;
 684                 break;
 685
 686         default:
 687                 err = -ENOPROTOOPT;
 688                 break;
 689         }
 690
 691         release_sock(sk);
 692         return err;
 693 }
 694
 695 static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len)
 696 {
 697         struct sock *sk = sock->sk;
 698         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 699         int err;
 700
 701         BT_DBG("sock %p, sk %p", sock, sk);
 702
 703         err = sock_error(sk);
 704         if (err)
 705                 return err;
 706
 707         if (msg->msg_flags & MSG_OOB)
 708                 return -EOPNOTSUPP;
 709
 710         lock_sock(sk);
 711
 712         if (sk->sk_state != BT_CONNECTED) {
 713                 release_sock(sk);
 714                 return -ENOTCONN;
 715         }
 716
 717         err = l2cap_chan_send(chan, msg, len);
 718
 719         release_sock(sk);
 720         return err;
 721 }
 722
 723 static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *msg, size_t len, int flags)
 724 {
 725         struct sock *sk = sock->sk;
 726         struct l2cap_pinfo *pi = l2cap_pi(sk);
 727         int err;
 728
 729         lock_sock(sk);
 730
 731         if (sk->sk_state == BT_CONNECT2 && bt_sk(sk)->defer_setup) {
 732                 sk->sk_state = BT_CONFIG;
 733
 734                 __l2cap_connect_rsp_defer(pi->chan);
 735                 release_sock(sk);
 736                 return 0;
 737         }
 738
 739         release_sock(sk);
 740
 741         if (sock->type == SOCK_STREAM)
 742                 err = bt_sock_stream_recvmsg(iocb, sock, msg, len, flags);
 743         else
 744                 err = bt_sock_recvmsg(iocb, sock, msg, len, flags);
 745
 746         if (pi->chan->mode != L2CAP_MODE_ERTM)
 747                 return err;
 748
 749         /* Attempt to put pending rx data in the socket buffer */
 750
 751         lock_sock(sk);
 752
 753         if (!test_bit(CONN_LOCAL_BUSY, &pi->chan->conn_state))
 754                 goto done;
 755
 756         if (pi->rx_busy_skb) {
 757                 if (!sock_queue_rcv_skb(sk, pi->rx_busy_skb))
 758                         pi->rx_busy_skb = NULL;
 759                 else
 760                         goto done;
 761         }
 762
 763         /* Restore data flow when half of the receive buffer is
 764          * available.  This avoids resending large numbers of
 765          * frames.
 766          */
 767         if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf >> 1)
 768                 l2cap_chan_busy(pi->chan, 0);
 769
 770 done:
 771         release_sock(sk);
 772         return err;
 773 }
 774
 775 /* Kill socket (only if zapped and orphan)
 776  * Must be called on unlocked socket.
 777  */
 778 static void l2cap_sock_kill(struct sock *sk)
 779 {
 780         if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
 781                 return;
 782
 783         BT_DBG("sk %p state %d", sk, sk->sk_state);
 784
 785         /* Kill poor orphan */
 786
 787         l2cap_chan_destroy(l2cap_pi(sk)->chan);
 788         sock_set_flag(sk, SOCK_DEAD);
 789         sock_put(sk);
 790 }
 791
 792 static int l2cap_sock_shutdown(struct socket *sock, int how)
 793 {
 794         struct sock *sk = sock->sk;
 795         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 796         int err = 0;
 797
 798         BT_DBG("sock %p, sk %p", sock, sk);
 799
 800         if (!sk)
 801                 return 0;
 802
 803         lock_sock(sk);
 804         if (!sk->sk_shutdown) {
 805                 if (chan->mode == L2CAP_MODE_ERTM)
 806                         err = __l2cap_wait_ack(sk);
 807
 808                 sk->sk_shutdown = SHUTDOWN_MASK;
 809                 l2cap_chan_close(chan, 0);
 810
 811                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
 812                         err = bt_sock_wait_state(sk, BT_CLOSED,
 813                                                         sk->sk_lingertime);
 814         }
 815
 816         if (!err && sk->sk_err)
 817                 err = -sk->sk_err;
 818
 819         release_sock(sk);
 820         return err;
 821 }
 822
 823 static int l2cap_sock_release(struct socket *sock)
 824 {
 825         struct sock *sk = sock->sk;
 826         int err;
 827
 828         BT_DBG("sock %p, sk %p", sock, sk);
 829
 830         if (!sk)
 831                 return 0;
 832
 833         err = l2cap_sock_shutdown(sock, 2);
 834
 835         sock_orphan(sk);
 836         l2cap_sock_kill(sk);
 837         return err;
 838 }
 839
 840 static struct l2cap_chan *l2cap_sock_new_connection_cb(void *data)
 841 {
 842         struct sock *sk, *parent = data;
 843
 844         sk = l2cap_sock_alloc(sock_net(parent), NULL, BTPROTO_L2CAP,
 845                                                                 GFP_ATOMIC);
 846         if (!sk)
 847                 return NULL;
 848
 849         l2cap_sock_init(sk, parent);
 850
 851         return l2cap_pi(sk)->chan;
 852 }
 853
 854 static int l2cap_sock_recv_cb(void *data, struct sk_buff *skb)
 855 {
 856         int err;
 857         struct sock *sk = data;
 858         struct l2cap_pinfo *pi = l2cap_pi(sk);
 859
 860         if (pi->rx_busy_skb)
 861                 return -ENOMEM;
 862
 863         err = sock_queue_rcv_skb(sk, skb);
 864
 865         /* For ERTM, handle one skb that doesn't fit into the recv
 866          * buffer.  This is important to do because the data frames
 867          * have already been acked, so the skb cannot be discarded.
 868          *
 869          * Notify the l2cap core that the buffer is full, so the
 870          * LOCAL_BUSY state is entered and no more frames are
 871          * acked and reassembled until there is buffer space
 872          * available.
 873          */
 874         if (err < 0 && pi->chan->mode == L2CAP_MODE_ERTM) {
 875                 pi->rx_busy_skb = skb;
 876                 l2cap_chan_busy(pi->chan, 1);
 877                 err = 0;
 878         }
 879
 880         return err;
 881 }
 882
 883 static void l2cap_sock_close_cb(void *data)
 884 {
 885         struct sock *sk = data;
 886
 887         l2cap_sock_kill(sk);
 888 }
 889
 890 static void l2cap_sock_state_change_cb(void *data, int state)
 891 {
 892         struct sock *sk = data;
 893
 894         sk->sk_state = state;
 895 }
 896
 897 static struct l2cap_ops l2cap_chan_ops = {
 898         .name           = "L2CAP Socket Interface",
 899         .new_connection = l2cap_sock_new_connection_cb,
 900         .recv           = l2cap_sock_recv_cb,
 901         .close          = l2cap_sock_close_cb,
 902         .state_change   = l2cap_sock_state_change_cb,
 903 };
 904
 905 static void l2cap_sock_destruct(struct sock *sk)
 906 {
 907         BT_DBG("sk %p", sk);
 908
 909         if (l2cap_pi(sk)->rx_busy_skb) {
 910                 kfree_skb(l2cap_pi(sk)->rx_busy_skb);
 911                 l2cap_pi(sk)->rx_busy_skb = NULL;
 912         }
 913
 914         skb_queue_purge(&sk->sk_receive_queue);
 915         skb_queue_purge(&sk->sk_write_queue);
 916 }
 917
 918 static void l2cap_sock_init(struct sock *sk, struct sock *parent)
 919 {
 920         struct l2cap_pinfo *pi = l2cap_pi(sk);
 921         struct l2cap_chan *chan = pi->chan;
 922
 923         BT_DBG("sk %p", sk);
 924
 925         if (parent) {
 926                 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
 927
 928                 sk->sk_type = parent->sk_type;
 929                 bt_sk(sk)->defer_setup = bt_sk(parent)->defer_setup;
 930
 931                 chan->chan_type = pchan->chan_type;
 932                 chan->imtu = pchan->imtu;
 933                 chan->omtu = pchan->omtu;
 934                 chan->conf_state = pchan->conf_state;
 935                 chan->mode = pchan->mode;
 936                 chan->fcs  = pchan->fcs;
 937                 chan->max_tx = pchan->max_tx;
 938                 chan->tx_win = pchan->tx_win;
 939                 chan->sec_level = pchan->sec_level;
 940                 chan->role_switch = pchan->role_switch;
 941                 chan->flags = pchan->flags;
 942                 chan->force_active = pchan->force_active;
 943         } else {
 944
 945                 switch (sk->sk_type) {
 946                 case SOCK_RAW:
 947                         chan->chan_type = L2CAP_CHAN_RAW;
 948                         break;
 949                 case SOCK_DGRAM:
 950                         chan->chan_type = L2CAP_CHAN_CONN_LESS;
 951                         break;
 952                 case SOCK_SEQPACKET:
 953                 case SOCK_STREAM:
 954                         chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
 955                         break;
 956                 }
 957
 958                 chan->imtu = L2CAP_DEFAULT_MTU;
 959                 chan->omtu = 0;
 960                 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
 961                         chan->mode = L2CAP_MODE_ERTM;
 962                         set_bit(CONF_STATE2_DEVICE, &chan->conf_state);
 963                 } else {
 964                         chan->mode = L2CAP_MODE_BASIC;
 965                 }
 966                 chan->max_tx = L2CAP_DEFAULT_MAX_TX;
 967                 chan->fcs  = L2CAP_FCS_CRC16;
 968                 chan->tx_win = L2CAP_DEFAULT_TX_WINDOW;
 969                 chan->sec_level = BT_SECURITY_LOW;
 970                 chan->role_switch = 0;
 971                 chan->flags = 0;
 972                 chan->force_active = BT_POWER_FORCE_ACTIVE_ON;
 973
 974         }
 975
 976         /* Default config options */
 977         chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
 978
 979         chan->data = sk;
 980         chan->ops = &l2cap_chan_ops;
 981 }
 982
 983 static struct proto l2cap_proto = {
 984         .name           = "L2CAP",
 985         .owner          = THIS_MODULE,
 986         .obj_size       = sizeof(struct l2cap_pinfo)
 987 };
 988
 989 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock, int proto, gfp_t prio)
 990 {
 991         struct sock *sk;
 992         struct l2cap_chan *chan;
 993
 994         sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
 995         if (!sk)
 996                 return NULL;
 997
 998         sock_init_data(sock, sk);
 999         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
1000
1001         sk->sk_destruct = l2cap_sock_destruct;
1002         sk->sk_sndtimeo = L2CAP_CONN_TIMEOUT;
1003
1004         sock_reset_flag(sk, SOCK_ZAPPED);
1005
1006         sk->sk_protocol = proto;
1007         sk->sk_state = BT_OPEN;
1008
1009         chan = l2cap_chan_create(sk);
1010         if (!chan) {
1011                 l2cap_sock_kill(sk);
1012                 return NULL;
1013         }
1014
1015         l2cap_pi(sk)->chan = chan;
1016
1017         return sk;
1018 }
1019
1020 static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1021                              int kern)
1022 {
1023         struct sock *sk;
1024
1025         BT_DBG("sock %p", sock);
1026
1027         sock->state = SS_UNCONNECTED;
1028
1029         if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
1030                         sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
1031                 return -ESOCKTNOSUPPORT;
1032
1033         if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1034                 return -EPERM;
1035
1036         sock->ops = &l2cap_sock_ops;
1037
1038         sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
1039         if (!sk)
1040                 return -ENOMEM;
1041
1042         l2cap_sock_init(sk, NULL);
1043         return 0;
1044 }
1045
1046 static const struct proto_ops l2cap_sock_ops = {
1047         .family         = PF_BLUETOOTH,
1048         .owner          = THIS_MODULE,
1049         .release        = l2cap_sock_release,
1050         .bind           = l2cap_sock_bind,
1051         .connect        = l2cap_sock_connect,
1052         .listen         = l2cap_sock_listen,
1053         .accept         = l2cap_sock_accept,
1054         .getname        = l2cap_sock_getname,
1055         .sendmsg        = l2cap_sock_sendmsg,
1056         .recvmsg        = l2cap_sock_recvmsg,
1057         .poll           = bt_sock_poll,
1058         .ioctl          = bt_sock_ioctl,
1059         .mmap           = sock_no_mmap,
1060         .socketpair     = sock_no_socketpair,
1061         .shutdown       = l2cap_sock_shutdown,
1062         .setsockopt     = l2cap_sock_setsockopt,
1063         .getsockopt     = l2cap_sock_getsockopt
1064 };
1065
1066 static const struct net_proto_family l2cap_sock_family_ops = {
1067         .family = PF_BLUETOOTH,
1068         .owner  = THIS_MODULE,
1069         .create = l2cap_sock_create,
1070 };
1071
1072 int __init l2cap_init_sockets(void)
1073 {
1074         int err;
1075
1076         err = proto_register(&l2cap_proto, 0);
1077         if (err < 0)
1078                 return err;
1079
1080         err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
1081         if (err < 0)
1082                 goto error;
1083
1084         BT_INFO("L2CAP socket layer initialized");
1085
1086         return 0;
1087
1088 error:
1089         BT_ERR("L2CAP socket registration failed");
1090         proto_unregister(&l2cap_proto);
1091         return err;
1092 }
1093
1094 void l2cap_cleanup_sockets(void)
1095 {
1096         if (bt_sock_unregister(BTPROTO_L2CAP) < 0)
1097                 BT_ERR("L2CAP socket unregistration failed");
1098
1099         proto_unregister(&l2cap_proto);
1100 }