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, 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                         err = bt_sock_wait_state(sk, BT_CLOSED,
 809                                                         sk->sk_lingertime);
 810         }
 811
 812         if (!err && sk->sk_err)
 813                 err = -sk->sk_err;
 814
 815         release_sock(sk);
 816         return err;
 817 }
 818
 819 static int l2cap_sock_release(struct socket *sock)
 820 {
 821         struct sock *sk = sock->sk;
 822         int err;
 823
 824         BT_DBG("sock %p, sk %p", sock, sk);
 825
 826         if (!sk)
 827                 return 0;
 828
 829         err = l2cap_sock_shutdown(sock, 2);
 830
 831         sock_orphan(sk);
 832         l2cap_sock_kill(sk);
 833         return err;
 834 }
 835
 836 static struct l2cap_chan *l2cap_sock_new_connection_cb(void *data)
 837 {
 838         struct sock *sk, *parent = data;
 839
 840         sk = l2cap_sock_alloc(sock_net(parent), NULL, BTPROTO_L2CAP,
 841                                                                 GFP_ATOMIC);
 842         if (!sk)
 843                 return NULL;
 844
 845         l2cap_sock_init(sk, parent);
 846
 847         return l2cap_pi(sk)->chan;
 848 }
 849
 850 static int l2cap_sock_recv_cb(void *data, struct sk_buff *skb)
 851 {
 852         int err;
 853         struct sock *sk = data;
 854         struct l2cap_pinfo *pi = l2cap_pi(sk);
 855
 856         if (pi->rx_busy_skb)
 857                 return -ENOMEM;
 858
 859         err = sock_queue_rcv_skb(sk, skb);
 860
 861         /* For ERTM, handle one skb that doesn't fit into the recv
 862          * buffer.  This is important to do because the data frames
 863          * have already been acked, so the skb cannot be discarded.
 864          *
 865          * Notify the l2cap core that the buffer is full, so the
 866          * LOCAL_BUSY state is entered and no more frames are
 867          * acked and reassembled until there is buffer space
 868          * available.
 869          */
 870         if (err < 0 && pi->chan->mode == L2CAP_MODE_ERTM) {
 871                 pi->rx_busy_skb = skb;
 872                 l2cap_chan_busy(pi->chan, 1);
 873                 err = 0;
 874         }
 875
 876         return err;
 877 }
 878
 879 static void l2cap_sock_close_cb(void *data)
 880 {
 881         struct sock *sk = data;
 882
 883         l2cap_sock_kill(sk);
 884 }
 885
 886 static void l2cap_sock_state_change_cb(void *data, int state)
 887 {
 888         struct sock *sk = data;
 889
 890         sk->sk_state = state;
 891 }
 892
 893 static struct l2cap_ops l2cap_chan_ops = {
 894         .name           = "L2CAP Socket Interface",
 895         .new_connection = l2cap_sock_new_connection_cb,
 896         .recv           = l2cap_sock_recv_cb,
 897         .close          = l2cap_sock_close_cb,
 898         .state_change   = l2cap_sock_state_change_cb,
 899 };
 900
 901 static void l2cap_sock_destruct(struct sock *sk)
 902 {
 903         BT_DBG("sk %p", sk);
 904
 905         if (l2cap_pi(sk)->rx_busy_skb) {
 906                 kfree_skb(l2cap_pi(sk)->rx_busy_skb);
 907                 l2cap_pi(sk)->rx_busy_skb = NULL;
 908         }
 909
 910         skb_queue_purge(&sk->sk_receive_queue);
 911         skb_queue_purge(&sk->sk_write_queue);
 912 }
 913
 914 static void l2cap_sock_init(struct sock *sk, struct sock *parent)
 915 {
 916         struct l2cap_pinfo *pi = l2cap_pi(sk);
 917         struct l2cap_chan *chan = pi->chan;
 918
 919         BT_DBG("sk %p", sk);
 920
 921         if (parent) {
 922                 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
 923
 924                 sk->sk_type = parent->sk_type;
 925                 bt_sk(sk)->defer_setup = bt_sk(parent)->defer_setup;
 926
 927                 chan->chan_type = pchan->chan_type;
 928                 chan->imtu = pchan->imtu;
 929                 chan->omtu = pchan->omtu;
 930                 chan->conf_state = pchan->conf_state;
 931                 chan->mode = pchan->mode;
 932                 chan->fcs  = pchan->fcs;
 933                 chan->max_tx = pchan->max_tx;
 934                 chan->tx_win = pchan->tx_win;
 935                 chan->sec_level = pchan->sec_level;
 936                 chan->role_switch = pchan->role_switch;
 937                 chan->force_reliable = pchan->force_reliable;
 938                 chan->flushable = pchan->flushable;
 939                 chan->force_active = pchan->force_active;
 940
 941                 security_sk_clone(parent, sk);
 942         } else {
 943
 944                 switch (sk->sk_type) {
 945                 case SOCK_RAW:
 946                         chan->chan_type = L2CAP_CHAN_RAW;
 947                         break;
 948                 case SOCK_DGRAM:
 949                         chan->chan_type = L2CAP_CHAN_CONN_LESS;
 950                         break;
 951                 case SOCK_SEQPACKET:
 952                 case SOCK_STREAM:
 953                         chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
 954                         break;
 955                 }
 956
 957                 chan->imtu = L2CAP_DEFAULT_MTU;
 958                 chan->omtu = 0;
 959                 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
 960                         chan->mode = L2CAP_MODE_ERTM;
 961                         set_bit(CONF_STATE2_DEVICE, &chan->conf_state);
 962                 } else {
 963                         chan->mode = L2CAP_MODE_BASIC;
 964                 }
 965                 chan->max_tx = L2CAP_DEFAULT_MAX_TX;
 966                 chan->fcs  = L2CAP_FCS_CRC16;
 967                 chan->tx_win = L2CAP_DEFAULT_TX_WINDOW;
 968                 chan->sec_level = BT_SECURITY_LOW;
 969                 chan->role_switch = 0;
 970                 chan->force_reliable = 0;
 971                 chan->flushable = BT_FLUSHABLE_OFF;
 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 }