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