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    Copyright (C) 2011 ProFUSION Embedded Systems
   7
   8    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License version 2 as
  12    published by the Free Software Foundation;
  13
  14    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  15    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  17    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
  18    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
  19    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  20    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  21    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22
  23    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
  24    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
  25    SOFTWARE IS DISCLAIMED.
  26 */
  27
  28 /* Bluetooth L2CAP sockets. */
  29
  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
  36 #include "smp.h"
  37
  38 static struct bt_sock_list l2cap_sk_list = {
  39         .lock = __RW_LOCK_UNLOCKED(l2cap_sk_list.lock)
  40 };
  41
  42 static const struct proto_ops l2cap_sock_ops;
  43 static void l2cap_sock_init(struct sock *sk, struct sock *parent);
  44 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock,
  45                                      int proto, gfp_t prio);
  46
  47 bool l2cap_is_socket(struct socket *sock)
  48 {
  49         return sock && sock->ops == &l2cap_sock_ops;
  50 }
  51 EXPORT_SYMBOL(l2cap_is_socket);
  52
  53 static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int alen)
  54 {
  55         struct sock *sk = sock->sk;
  56         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
  57         struct sockaddr_l2 la;
  58         int len, err = 0;
  59
  60         BT_DBG("sk %p", sk);
  61
  62         if (!addr || addr->sa_family != AF_BLUETOOTH)
  63                 return -EINVAL;
  64
  65         memset(&la, 0, sizeof(la));
  66         len = min_t(unsigned int, sizeof(la), alen);
  67         memcpy(&la, addr, len);
  68
  69         if (la.l2_cid && la.l2_psm)
  70                 return -EINVAL;
  71
  72         if (!bdaddr_type_is_valid(la.l2_bdaddr_type))
  73                 return -EINVAL;
  74
  75         if (bdaddr_type_is_le(la.l2_bdaddr_type)) {
  76                 /* Connection oriented channels are not supported on LE */
  77                 if (la.l2_psm)
  78                         return -EINVAL;
  79                 /* We only allow ATT user space socket */
  80                 if (la.l2_cid != __constant_cpu_to_le16(L2CAP_CID_ATT))
  81                         return -EINVAL;
  82         }
  83
  84         lock_sock(sk);
  85
  86         if (sk->sk_state != BT_OPEN) {
  87                 err = -EBADFD;
  88                 goto done;
  89         }
  90
  91         if (la.l2_psm) {
  92                 __u16 psm = __le16_to_cpu(la.l2_psm);
  93
  94                 /* PSM must be odd and lsb of upper byte must be 0 */
  95                 if ((psm & 0x0101) != 0x0001) {
  96                         err = -EINVAL;
  97                         goto done;
  98                 }
  99
 100                 /* Restrict usage of well-known PSMs */
 101                 if (psm < 0x1001 && !capable(CAP_NET_BIND_SERVICE)) {
 102                         err = -EACCES;
 103                         goto done;
 104                 }
 105         }
 106
 107         if (la.l2_cid)
 108                 err = l2cap_add_scid(chan, __le16_to_cpu(la.l2_cid));
 109         else
 110                 err = l2cap_add_psm(chan, &la.l2_bdaddr, la.l2_psm);
 111
 112         if (err < 0)
 113                 goto done;
 114
 115         switch (chan->chan_type) {
 116         case L2CAP_CHAN_CONN_LESS:
 117                 if (__le16_to_cpu(la.l2_psm) == L2CAP_PSM_3DSP)
 118                         chan->sec_level = BT_SECURITY_SDP;
 119                 break;
 120         case L2CAP_CHAN_CONN_ORIENTED:
 121                 if (__le16_to_cpu(la.l2_psm) == L2CAP_PSM_SDP ||
 122                     __le16_to_cpu(la.l2_psm) == L2CAP_PSM_RFCOMM)
 123                         chan->sec_level = BT_SECURITY_SDP;
 124                 break;
 125         }
 126
 127         bacpy(&chan->src, &la.l2_bdaddr);
 128         chan->src_type = la.l2_bdaddr_type;
 129
 130         chan->state = BT_BOUND;
 131         sk->sk_state = BT_BOUND;
 132
 133 done:
 134         release_sock(sk);
 135         return err;
 136 }
 137
 138 static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr,
 139                               int alen, int flags)
 140 {
 141         struct sock *sk = sock->sk;
 142         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 143         struct sockaddr_l2 la;
 144         int len, err = 0;
 145
 146         BT_DBG("sk %p", sk);
 147
 148         if (!addr || alen < sizeof(addr->sa_family) ||
 149             addr->sa_family != AF_BLUETOOTH)
 150                 return -EINVAL;
 151
 152         memset(&la, 0, sizeof(la));
 153         len = min_t(unsigned int, sizeof(la), alen);
 154         memcpy(&la, addr, len);
 155
 156         if (la.l2_cid && la.l2_psm)
 157                 return -EINVAL;
 158
 159         if (!bdaddr_type_is_valid(la.l2_bdaddr_type))
 160                 return -EINVAL;
 161
 162         /* Check that the socket wasn't bound to something that
 163          * conflicts with the address given to connect(). If chan->src
 164          * is BDADDR_ANY it means bind() was never used, in which case
 165          * chan->src_type and la.l2_bdaddr_type do not need to match.
 166          */
 167         if (chan->src_type == BDADDR_BREDR && bacmp(&chan->src, BDADDR_ANY) &&
 168             bdaddr_type_is_le(la.l2_bdaddr_type)) {
 169                 /* Old user space versions will try to incorrectly bind
 170                  * the ATT socket using BDADDR_BREDR. We need to accept
 171                  * this and fix up the source address type only when
 172                  * both the source CID and destination CID indicate
 173                  * ATT. Anything else is an invalid combination.
 174                  */
 175                 if (chan->scid != L2CAP_CID_ATT ||
 176                     la.l2_cid != __constant_cpu_to_le16(L2CAP_CID_ATT))
 177                         return -EINVAL;
 178
 179                 /* We don't have the hdev available here to make a
 180                  * better decision on random vs public, but since all
 181                  * user space versions that exhibit this issue anyway do
 182                  * not support random local addresses assuming public
 183                  * here is good enough.
 184                  */
 185                 chan->src_type = BDADDR_LE_PUBLIC;
 186         }
 187
 188         if (chan->src_type != BDADDR_BREDR && la.l2_bdaddr_type == BDADDR_BREDR)
 189                 return -EINVAL;
 190
 191         if (bdaddr_type_is_le(la.l2_bdaddr_type)) {
 192                 /* Connection oriented channels are not supported on LE */
 193                 if (la.l2_psm)
 194                         return -EINVAL;
 195                 /* We only allow ATT user space socket */
 196                 if (la.l2_cid != __constant_cpu_to_le16(L2CAP_CID_ATT))
 197                         return -EINVAL;
 198         }
 199
 200         err = l2cap_chan_connect(chan, la.l2_psm, __le16_to_cpu(la.l2_cid),
 201                                  &la.l2_bdaddr, la.l2_bdaddr_type);
 202         if (err)
 203                 return err;
 204
 205         lock_sock(sk);
 206
 207         err = bt_sock_wait_state(sk, BT_CONNECTED,
 208                                  sock_sndtimeo(sk, flags & O_NONBLOCK));
 209
 210         release_sock(sk);
 211
 212         return err;
 213 }
 214
 215 static int l2cap_sock_listen(struct socket *sock, int backlog)
 216 {
 217         struct sock *sk = sock->sk;
 218         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 219         int err = 0;
 220
 221         BT_DBG("sk %p backlog %d", sk, backlog);
 222
 223         lock_sock(sk);
 224
 225         if (sk->sk_state != BT_BOUND) {
 226                 err = -EBADFD;
 227                 goto done;
 228         }
 229
 230         if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM) {
 231                 err = -EINVAL;
 232                 goto done;
 233         }
 234
 235         switch (chan->mode) {
 236         case L2CAP_MODE_BASIC:
 237                 break;
 238         case L2CAP_MODE_ERTM:
 239         case L2CAP_MODE_STREAMING:
 240                 if (!disable_ertm)
 241                         break;
 242                 /* fall through */
 243         default:
 244                 err = -ENOTSUPP;
 245                 goto done;
 246         }
 247
 248         sk->sk_max_ack_backlog = backlog;
 249         sk->sk_ack_backlog = 0;
 250
 251         chan->state = BT_LISTEN;
 252         sk->sk_state = BT_LISTEN;
 253
 254 done:
 255         release_sock(sk);
 256         return err;
 257 }
 258
 259 static int l2cap_sock_accept(struct socket *sock, struct socket *newsock,
 260                              int flags)
 261 {
 262         DECLARE_WAITQUEUE(wait, current);
 263         struct sock *sk = sock->sk, *nsk;
 264         long timeo;
 265         int err = 0;
 266
 267         lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
 268
 269         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 270
 271         BT_DBG("sk %p timeo %ld", sk, timeo);
 272
 273         /* Wait for an incoming connection. (wake-one). */
 274         add_wait_queue_exclusive(sk_sleep(sk), &wait);
 275         while (1) {
 276                 set_current_state(TASK_INTERRUPTIBLE);
 277
 278                 if (sk->sk_state != BT_LISTEN) {
 279                         err = -EBADFD;
 280                         break;
 281                 }
 282
 283                 nsk = bt_accept_dequeue(sk, newsock);
 284                 if (nsk)
 285                         break;
 286
 287                 if (!timeo) {
 288                         err = -EAGAIN;
 289                         break;
 290                 }
 291
 292                 if (signal_pending(current)) {
 293                         err = sock_intr_errno(timeo);
 294                         break;
 295                 }
 296
 297                 release_sock(sk);
 298                 timeo = schedule_timeout(timeo);
 299                 lock_sock_nested(sk, SINGLE_DEPTH_NESTING);
 300         }
 301         __set_current_state(TASK_RUNNING);
 302         remove_wait_queue(sk_sleep(sk), &wait);
 303
 304         if (err)
 305                 goto done;
 306
 307         newsock->state = SS_CONNECTED;
 308
 309         BT_DBG("new socket %p", nsk);
 310
 311 done:
 312         release_sock(sk);
 313         return err;
 314 }
 315
 316 static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr,
 317                               int *len, int peer)
 318 {
 319         struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
 320         struct sock *sk = sock->sk;
 321         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 322
 323         BT_DBG("sock %p, sk %p", sock, sk);
 324
 325         memset(la, 0, sizeof(struct sockaddr_l2));
 326         addr->sa_family = AF_BLUETOOTH;
 327         *len = sizeof(struct sockaddr_l2);
 328
 329         if (peer) {
 330                 la->l2_psm = chan->psm;
 331                 bacpy(&la->l2_bdaddr, &chan->dst);
 332                 la->l2_cid = cpu_to_le16(chan->dcid);
 333                 la->l2_bdaddr_type = chan->dst_type;
 334         } else {
 335                 la->l2_psm = chan->sport;
 336                 bacpy(&la->l2_bdaddr, &chan->src);
 337                 la->l2_cid = cpu_to_le16(chan->scid);
 338                 la->l2_bdaddr_type = chan->src_type;
 339         }
 340
 341         return 0;
 342 }
 343
 344 static int l2cap_sock_getsockopt_old(struct socket *sock, int optname,
 345                                      char __user *optval, int __user *optlen)
 346 {
 347         struct sock *sk = sock->sk;
 348         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 349         struct l2cap_options opts;
 350         struct l2cap_conninfo cinfo;
 351         int len, err = 0;
 352         u32 opt;
 353
 354         BT_DBG("sk %p", sk);
 355
 356         if (get_user(len, optlen))
 357                 return -EFAULT;
 358
 359         lock_sock(sk);
 360
 361         switch (optname) {
 362         case L2CAP_OPTIONS:
 363                 memset(&opts, 0, sizeof(opts));
 364                 opts.imtu     = chan->imtu;
 365                 opts.omtu     = chan->omtu;
 366                 opts.flush_to = chan->flush_to;
 367                 opts.mode     = chan->mode;
 368                 opts.fcs      = chan->fcs;
 369                 opts.max_tx   = chan->max_tx;
 370                 opts.txwin_size = chan->tx_win;
 371
 372                 len = min_t(unsigned int, len, sizeof(opts));
 373                 if (copy_to_user(optval, (char *) &opts, len))
 374                         err = -EFAULT;
 375
 376                 break;
 377
 378         case L2CAP_LM:
 379                 switch (chan->sec_level) {
 380                 case BT_SECURITY_LOW:
 381                         opt = L2CAP_LM_AUTH;
 382                         break;
 383                 case BT_SECURITY_MEDIUM:
 384                         opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT;
 385                         break;
 386                 case BT_SECURITY_HIGH:
 387                         opt = L2CAP_LM_AUTH | L2CAP_LM_ENCRYPT |
 388                               L2CAP_LM_SECURE;
 389                         break;
 390                 default:
 391                         opt = 0;
 392                         break;
 393                 }
 394
 395                 if (test_bit(FLAG_ROLE_SWITCH, &chan->flags))
 396                         opt |= L2CAP_LM_MASTER;
 397
 398                 if (test_bit(FLAG_FORCE_RELIABLE, &chan->flags))
 399                         opt |= L2CAP_LM_RELIABLE;
 400
 401                 if (put_user(opt, (u32 __user *) optval))
 402                         err = -EFAULT;
 403                 break;
 404
 405         case L2CAP_CONNINFO:
 406                 if (sk->sk_state != BT_CONNECTED &&
 407                     !(sk->sk_state == BT_CONNECT2 &&
 408                       test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags))) {
 409                         err = -ENOTCONN;
 410                         break;
 411                 }
 412
 413                 memset(&cinfo, 0, sizeof(cinfo));
 414                 cinfo.hci_handle = chan->conn->hcon->handle;
 415                 memcpy(cinfo.dev_class, chan->conn->hcon->dev_class, 3);
 416
 417                 len = min_t(unsigned int, len, sizeof(cinfo));
 418                 if (copy_to_user(optval, (char *) &cinfo, len))
 419                         err = -EFAULT;
 420
 421                 break;
 422
 423         default:
 424                 err = -ENOPROTOOPT;
 425                 break;
 426         }
 427
 428         release_sock(sk);
 429         return err;
 430 }
 431
 432 static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname,
 433                                  char __user *optval, int __user *optlen)
 434 {
 435         struct sock *sk = sock->sk;
 436         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 437         struct bt_security sec;
 438         struct bt_power pwr;
 439         int len, err = 0;
 440
 441         BT_DBG("sk %p", sk);
 442
 443         if (level == SOL_L2CAP)
 444                 return l2cap_sock_getsockopt_old(sock, optname, optval, optlen);
 445
 446         if (level != SOL_BLUETOOTH)
 447                 return -ENOPROTOOPT;
 448
 449         if (get_user(len, optlen))
 450                 return -EFAULT;
 451
 452         lock_sock(sk);
 453
 454         switch (optname) {
 455         case BT_SECURITY:
 456                 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
 457                     chan->chan_type != L2CAP_CHAN_RAW) {
 458                         err = -EINVAL;
 459                         break;
 460                 }
 461
 462                 memset(&sec, 0, sizeof(sec));
 463                 if (chan->conn) {
 464                         sec.level = chan->conn->hcon->sec_level;
 465
 466                         if (sk->sk_state == BT_CONNECTED)
 467                                 sec.key_size = chan->conn->hcon->enc_key_size;
 468                 } else {
 469                         sec.level = chan->sec_level;
 470                 }
 471
 472                 len = min_t(unsigned int, len, sizeof(sec));
 473                 if (copy_to_user(optval, (char *) &sec, len))
 474                         err = -EFAULT;
 475
 476                 break;
 477
 478         case BT_DEFER_SETUP:
 479                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 480                         err = -EINVAL;
 481                         break;
 482                 }
 483
 484                 if (put_user(test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags),
 485                              (u32 __user *) optval))
 486                         err = -EFAULT;
 487
 488                 break;
 489
 490         case BT_FLUSHABLE:
 491                 if (put_user(test_bit(FLAG_FLUSHABLE, &chan->flags),
 492                              (u32 __user *) optval))
 493                         err = -EFAULT;
 494
 495                 break;
 496
 497         case BT_POWER:
 498                 if (sk->sk_type != SOCK_SEQPACKET && sk->sk_type != SOCK_STREAM
 499                     && sk->sk_type != SOCK_RAW) {
 500                         err = -EINVAL;
 501                         break;
 502                 }
 503
 504                 pwr.force_active = test_bit(FLAG_FORCE_ACTIVE, &chan->flags);
 505
 506                 len = min_t(unsigned int, len, sizeof(pwr));
 507                 if (copy_to_user(optval, (char *) &pwr, len))
 508                         err = -EFAULT;
 509
 510                 break;
 511
 512         case BT_CHANNEL_POLICY:
 513                 if (put_user(chan->chan_policy, (u32 __user *) optval))
 514                         err = -EFAULT;
 515                 break;
 516
 517         default:
 518                 err = -ENOPROTOOPT;
 519                 break;
 520         }
 521
 522         release_sock(sk);
 523         return err;
 524 }
 525
 526 static bool l2cap_valid_mtu(struct l2cap_chan *chan, u16 mtu)
 527 {
 528         switch (chan->scid) {
 529         case L2CAP_CID_ATT:
 530                 if (mtu < L2CAP_LE_MIN_MTU)
 531                         return false;
 532                 break;
 533
 534         default:
 535                 if (mtu < L2CAP_DEFAULT_MIN_MTU)
 536                         return false;
 537         }
 538
 539         return true;
 540 }
 541
 542 static int l2cap_sock_setsockopt_old(struct socket *sock, int optname,
 543                                      char __user *optval, unsigned int optlen)
 544 {
 545         struct sock *sk = sock->sk;
 546         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 547         struct l2cap_options opts;
 548         int len, err = 0;
 549         u32 opt;
 550
 551         BT_DBG("sk %p", sk);
 552
 553         lock_sock(sk);
 554
 555         switch (optname) {
 556         case L2CAP_OPTIONS:
 557                 if (sk->sk_state == BT_CONNECTED) {
 558                         err = -EINVAL;
 559                         break;
 560                 }
 561
 562                 opts.imtu     = chan->imtu;
 563                 opts.omtu     = chan->omtu;
 564                 opts.flush_to = chan->flush_to;
 565                 opts.mode     = chan->mode;
 566                 opts.fcs      = chan->fcs;
 567                 opts.max_tx   = chan->max_tx;
 568                 opts.txwin_size = chan->tx_win;
 569
 570                 len = min_t(unsigned int, sizeof(opts), optlen);
 571                 if (copy_from_user((char *) &opts, optval, len)) {
 572                         err = -EFAULT;
 573                         break;
 574                 }
 575
 576                 if (opts.txwin_size > L2CAP_DEFAULT_EXT_WINDOW) {
 577                         err = -EINVAL;
 578                         break;
 579                 }
 580
 581                 if (!l2cap_valid_mtu(chan, opts.imtu)) {
 582                         err = -EINVAL;
 583                         break;
 584                 }
 585
 586                 chan->mode = opts.mode;
 587                 switch (chan->mode) {
 588                 case L2CAP_MODE_BASIC:
 589                         clear_bit(CONF_STATE2_DEVICE, &chan->conf_state);
 590                         break;
 591                 case L2CAP_MODE_ERTM:
 592                 case L2CAP_MODE_STREAMING:
 593                         if (!disable_ertm)
 594                                 break;
 595                         /* fall through */
 596                 default:
 597                         err = -EINVAL;
 598                         break;
 599                 }
 600
 601                 chan->imtu = opts.imtu;
 602                 chan->omtu = opts.omtu;
 603                 chan->fcs  = opts.fcs;
 604                 chan->max_tx = opts.max_tx;
 605                 chan->tx_win = opts.txwin_size;
 606                 chan->flush_to = opts.flush_to;
 607                 break;
 608
 609         case L2CAP_LM:
 610                 if (get_user(opt, (u32 __user *) optval)) {
 611                         err = -EFAULT;
 612                         break;
 613                 }
 614
 615                 if (opt & L2CAP_LM_AUTH)
 616                         chan->sec_level = BT_SECURITY_LOW;
 617                 if (opt & L2CAP_LM_ENCRYPT)
 618                         chan->sec_level = BT_SECURITY_MEDIUM;
 619                 if (opt & L2CAP_LM_SECURE)
 620                         chan->sec_level = BT_SECURITY_HIGH;
 621
 622                 if (opt & L2CAP_LM_MASTER)
 623                         set_bit(FLAG_ROLE_SWITCH, &chan->flags);
 624                 else
 625                         clear_bit(FLAG_ROLE_SWITCH, &chan->flags);
 626
 627                 if (opt & L2CAP_LM_RELIABLE)
 628                         set_bit(FLAG_FORCE_RELIABLE, &chan->flags);
 629                 else
 630                         clear_bit(FLAG_FORCE_RELIABLE, &chan->flags);
 631                 break;
 632
 633         default:
 634                 err = -ENOPROTOOPT;
 635                 break;
 636         }
 637
 638         release_sock(sk);
 639         return err;
 640 }
 641
 642 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname,
 643                                  char __user *optval, unsigned int optlen)
 644 {
 645         struct sock *sk = sock->sk;
 646         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 647         struct bt_security sec;
 648         struct bt_power pwr;
 649         struct l2cap_conn *conn;
 650         int len, err = 0;
 651         u32 opt;
 652
 653         BT_DBG("sk %p", sk);
 654
 655         if (level == SOL_L2CAP)
 656                 return l2cap_sock_setsockopt_old(sock, optname, optval, optlen);
 657
 658         if (level != SOL_BLUETOOTH)
 659                 return -ENOPROTOOPT;
 660
 661         lock_sock(sk);
 662
 663         switch (optname) {
 664         case BT_SECURITY:
 665                 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
 666                     chan->chan_type != L2CAP_CHAN_RAW) {
 667                         err = -EINVAL;
 668                         break;
 669                 }
 670
 671                 sec.level = BT_SECURITY_LOW;
 672
 673                 len = min_t(unsigned int, sizeof(sec), optlen);
 674                 if (copy_from_user((char *) &sec, optval, len)) {
 675                         err = -EFAULT;
 676                         break;
 677                 }
 678
 679                 if (sec.level < BT_SECURITY_LOW ||
 680                     sec.level > BT_SECURITY_HIGH) {
 681                         err = -EINVAL;
 682                         break;
 683                 }
 684
 685                 chan->sec_level = sec.level;
 686
 687                 if (!chan->conn)
 688                         break;
 689
 690                 conn = chan->conn;
 691
 692                 /*change security for LE channels */
 693                 if (chan->scid == L2CAP_CID_ATT) {
 694                         if (!conn->hcon->out) {
 695                                 err = -EINVAL;
 696                                 break;
 697                         }
 698
 699                         if (smp_conn_security(conn->hcon, sec.level))
 700                                 break;
 701                         sk->sk_state = BT_CONFIG;
 702                         chan->state = BT_CONFIG;
 703
 704                 /* or for ACL link */
 705                 } else if ((sk->sk_state == BT_CONNECT2 &&
 706                             test_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags)) ||
 707                            sk->sk_state == BT_CONNECTED) {
 708                         if (!l2cap_chan_check_security(chan))
 709                                 set_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
 710                         else
 711                                 sk->sk_state_change(sk);
 712                 } else {
 713                         err = -EINVAL;
 714                 }
 715                 break;
 716
 717         case BT_DEFER_SETUP:
 718                 if (sk->sk_state != BT_BOUND && sk->sk_state != BT_LISTEN) {
 719                         err = -EINVAL;
 720                         break;
 721                 }
 722
 723                 if (get_user(opt, (u32 __user *) optval)) {
 724                         err = -EFAULT;
 725                         break;
 726                 }
 727
 728                 if (opt) {
 729                         set_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
 730                         set_bit(FLAG_DEFER_SETUP, &chan->flags);
 731                 } else {
 732                         clear_bit(BT_SK_DEFER_SETUP, &bt_sk(sk)->flags);
 733                         clear_bit(FLAG_DEFER_SETUP, &chan->flags);
 734                 }
 735                 break;
 736
 737         case BT_FLUSHABLE:
 738                 if (get_user(opt, (u32 __user *) optval)) {
 739                         err = -EFAULT;
 740                         break;
 741                 }
 742
 743                 if (opt > BT_FLUSHABLE_ON) {
 744                         err = -EINVAL;
 745                         break;
 746                 }
 747
 748                 if (opt == BT_FLUSHABLE_OFF) {
 749                         conn = chan->conn;
 750                         /* proceed further only when we have l2cap_conn and
 751                            No Flush support in the LM */
 752                         if (!conn || !lmp_no_flush_capable(conn->hcon->hdev)) {
 753                                 err = -EINVAL;
 754                                 break;
 755                         }
 756                 }
 757
 758                 if (opt)
 759                         set_bit(FLAG_FLUSHABLE, &chan->flags);
 760                 else
 761                         clear_bit(FLAG_FLUSHABLE, &chan->flags);
 762                 break;
 763
 764         case BT_POWER:
 765                 if (chan->chan_type != L2CAP_CHAN_CONN_ORIENTED &&
 766                     chan->chan_type != L2CAP_CHAN_RAW) {
 767                         err = -EINVAL;
 768                         break;
 769                 }
 770
 771                 pwr.force_active = BT_POWER_FORCE_ACTIVE_ON;
 772
 773                 len = min_t(unsigned int, sizeof(pwr), optlen);
 774                 if (copy_from_user((char *) &pwr, optval, len)) {
 775                         err = -EFAULT;
 776                         break;
 777                 }
 778
 779                 if (pwr.force_active)
 780                         set_bit(FLAG_FORCE_ACTIVE, &chan->flags);
 781                 else
 782                         clear_bit(FLAG_FORCE_ACTIVE, &chan->flags);
 783                 break;
 784
 785         case BT_CHANNEL_POLICY:
 786                 if (get_user(opt, (u32 __user *) optval)) {
 787                         err = -EFAULT;
 788                         break;
 789                 }
 790
 791                 if (opt > BT_CHANNEL_POLICY_AMP_PREFERRED) {
 792                         err = -EINVAL;
 793                         break;
 794                 }
 795
 796                 if (chan->mode != L2CAP_MODE_ERTM &&
 797                     chan->mode != L2CAP_MODE_STREAMING) {
 798                         err = -EOPNOTSUPP;
 799                         break;
 800                 }
 801
 802                 chan->chan_policy = (u8) opt;
 803
 804                 if (sk->sk_state == BT_CONNECTED &&
 805                     chan->move_role == L2CAP_MOVE_ROLE_NONE)
 806                         l2cap_move_start(chan);
 807
 808                 break;
 809
 810         default:
 811                 err = -ENOPROTOOPT;
 812                 break;
 813         }
 814
 815         release_sock(sk);
 816         return err;
 817 }
 818
 819 static int l2cap_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
 820                               struct msghdr *msg, size_t len)
 821 {
 822         struct sock *sk = sock->sk;
 823         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 824         int err;
 825
 826         BT_DBG("sock %p, sk %p", sock, sk);
 827
 828         err = sock_error(sk);
 829         if (err)
 830                 return err;
 831
 832         if (msg->msg_flags & MSG_OOB)
 833                 return -EOPNOTSUPP;
 834
 835         if (sk->sk_state != BT_CONNECTED)
 836                 return -ENOTCONN;
 837
 838         lock_sock(sk);
 839         err = bt_sock_wait_ready(sk, msg->msg_flags);
 840         release_sock(sk);
 841         if (err)
 842                 return err;
 843
 844         l2cap_chan_lock(chan);
 845         err = l2cap_chan_send(chan, msg, len, sk->sk_priority);
 846         l2cap_chan_unlock(chan);
 847
 848         return err;
 849 }
 850
 851 static int l2cap_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
 852                               struct msghdr *msg, size_t len, int flags)
 853 {
 854         struct sock *sk = sock->sk;
 855         struct l2cap_pinfo *pi = l2cap_pi(sk);
 856         int err;
 857
 858         lock_sock(sk);
 859
 860         if (sk->sk_state == BT_CONNECT2 && test_bit(BT_SK_DEFER_SETUP,
 861                                                     &bt_sk(sk)->flags)) {
 862                 sk->sk_state = BT_CONFIG;
 863                 pi->chan->state = BT_CONFIG;
 864
 865                 __l2cap_connect_rsp_defer(pi->chan);
 866                 err = 0;
 867                 goto done;
 868         }
 869
 870         release_sock(sk);
 871
 872         if (sock->type == SOCK_STREAM)
 873                 err = bt_sock_stream_recvmsg(iocb, sock, msg, len, flags);
 874         else
 875                 err = bt_sock_recvmsg(iocb, sock, msg, len, flags);
 876
 877         if (pi->chan->mode != L2CAP_MODE_ERTM)
 878                 return err;
 879
 880         /* Attempt to put pending rx data in the socket buffer */
 881
 882         lock_sock(sk);
 883
 884         if (!test_bit(CONN_LOCAL_BUSY, &pi->chan->conn_state))
 885                 goto done;
 886
 887         if (pi->rx_busy_skb) {
 888                 if (!sock_queue_rcv_skb(sk, pi->rx_busy_skb))
 889                         pi->rx_busy_skb = NULL;
 890                 else
 891                         goto done;
 892         }
 893
 894         /* Restore data flow when half of the receive buffer is
 895          * available.  This avoids resending large numbers of
 896          * frames.
 897          */
 898         if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf >> 1)
 899                 l2cap_chan_busy(pi->chan, 0);
 900
 901 done:
 902         release_sock(sk);
 903         return err;
 904 }
 905
 906 /* Kill socket (only if zapped and orphan)
 907  * Must be called on unlocked socket.
 908  */
 909 static void l2cap_sock_kill(struct sock *sk)
 910 {
 911         if (!sock_flag(sk, SOCK_ZAPPED) || sk->sk_socket)
 912                 return;
 913
 914         BT_DBG("sk %p state %s", sk, state_to_string(sk->sk_state));
 915
 916         /* Kill poor orphan */
 917
 918         l2cap_chan_put(l2cap_pi(sk)->chan);
 919         sock_set_flag(sk, SOCK_DEAD);
 920         sock_put(sk);
 921 }
 922
 923 static int __l2cap_wait_ack(struct sock *sk)
 924 {
 925         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
 926         DECLARE_WAITQUEUE(wait, current);
 927         int err = 0;
 928         int timeo = HZ/5;
 929
 930         add_wait_queue(sk_sleep(sk), &wait);
 931         set_current_state(TASK_INTERRUPTIBLE);
 932         while (chan->unacked_frames > 0 && chan->conn) {
 933                 if (!timeo)
 934                         timeo = HZ/5;
 935
 936                 if (signal_pending(current)) {
 937                         err = sock_intr_errno(timeo);
 938                         break;
 939                 }
 940
 941                 release_sock(sk);
 942                 timeo = schedule_timeout(timeo);
 943                 lock_sock(sk);
 944                 set_current_state(TASK_INTERRUPTIBLE);
 945
 946                 err = sock_error(sk);
 947                 if (err)
 948                         break;
 949         }
 950         set_current_state(TASK_RUNNING);
 951         remove_wait_queue(sk_sleep(sk), &wait);
 952         return err;
 953 }
 954
 955 static int l2cap_sock_shutdown(struct socket *sock, int how)
 956 {
 957         struct sock *sk = sock->sk;
 958         struct l2cap_chan *chan;
 959         struct l2cap_conn *conn;
 960         int err = 0;
 961
 962         BT_DBG("sock %p, sk %p", sock, sk);
 963
 964         if (!sk)
 965                 return 0;
 966
 967         chan = l2cap_pi(sk)->chan;
 968         conn = chan->conn;
 969
 970         if (conn)
 971                 mutex_lock(&conn->chan_lock);
 972
 973         l2cap_chan_lock(chan);
 974         lock_sock(sk);
 975
 976         if (!sk->sk_shutdown) {
 977                 if (chan->mode == L2CAP_MODE_ERTM)
 978                         err = __l2cap_wait_ack(sk);
 979
 980                 sk->sk_shutdown = SHUTDOWN_MASK;
 981
 982                 release_sock(sk);
 983                 l2cap_chan_close(chan, 0);
 984                 lock_sock(sk);
 985
 986                 if (sock_flag(sk, SOCK_LINGER) && sk->sk_lingertime)
 987                         err = bt_sock_wait_state(sk, BT_CLOSED,
 988                                                  sk->sk_lingertime);
 989         }
 990
 991         if (!err && sk->sk_err)
 992                 err = -sk->sk_err;
 993
 994         release_sock(sk);
 995         l2cap_chan_unlock(chan);
 996
 997         if (conn)
 998                 mutex_unlock(&conn->chan_lock);
 999
1000         return err;
1001 }
1002
1003 static int l2cap_sock_release(struct socket *sock)
1004 {
1005         struct sock *sk = sock->sk;
1006         int err;
1007
1008         BT_DBG("sock %p, sk %p", sock, sk);
1009
1010         if (!sk)
1011                 return 0;
1012
1013         bt_sock_unlink(&l2cap_sk_list, sk);
1014
1015         err = l2cap_sock_shutdown(sock, 2);
1016
1017         sock_orphan(sk);
1018         l2cap_sock_kill(sk);
1019         return err;
1020 }
1021
1022 static void l2cap_sock_cleanup_listen(struct sock *parent)
1023 {
1024         struct sock *sk;
1025
1026         BT_DBG("parent %p", parent);
1027
1028         /* Close not yet accepted channels */
1029         while ((sk = bt_accept_dequeue(parent, NULL))) {
1030                 struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1031
1032                 l2cap_chan_lock(chan);
1033                 __clear_chan_timer(chan);
1034                 l2cap_chan_close(chan, ECONNRESET);
1035                 l2cap_chan_unlock(chan);
1036
1037                 l2cap_sock_kill(sk);
1038         }
1039 }
1040
1041 static struct l2cap_chan *l2cap_sock_new_connection_cb(struct l2cap_chan *chan)
1042 {
1043         struct sock *sk, *parent = chan->data;
1044
1045         /* Check for backlog size */
1046         if (sk_acceptq_is_full(parent)) {
1047                 BT_DBG("backlog full %d", parent->sk_ack_backlog);
1048                 return NULL;
1049         }
1050
1051         sk = l2cap_sock_alloc(sock_net(parent), NULL, BTPROTO_L2CAP,
1052                               GFP_ATOMIC);
1053         if (!sk)
1054                 return NULL;
1055
1056         bt_sock_reclassify_lock(sk, BTPROTO_L2CAP);
1057
1058         l2cap_sock_init(sk, parent);
1059
1060         bt_accept_enqueue(parent, sk);
1061
1062         return l2cap_pi(sk)->chan;
1063 }
1064
1065 static int l2cap_sock_recv_cb(struct l2cap_chan *chan, struct sk_buff *skb)
1066 {
1067         struct sock *sk = chan->data;
1068         int err;
1069
1070         lock_sock(sk);
1071
1072         if (l2cap_pi(sk)->rx_busy_skb) {
1073                 err = -ENOMEM;
1074                 goto done;
1075         }
1076
1077         err = sock_queue_rcv_skb(sk, skb);
1078
1079         /* For ERTM, handle one skb that doesn't fit into the recv
1080          * buffer.  This is important to do because the data frames
1081          * have already been acked, so the skb cannot be discarded.
1082          *
1083          * Notify the l2cap core that the buffer is full, so the
1084          * LOCAL_BUSY state is entered and no more frames are
1085          * acked and reassembled until there is buffer space
1086          * available.
1087          */
1088         if (err < 0 && chan->mode == L2CAP_MODE_ERTM) {
1089                 l2cap_pi(sk)->rx_busy_skb = skb;
1090                 l2cap_chan_busy(chan, 1);
1091                 err = 0;
1092         }
1093
1094 done:
1095         release_sock(sk);
1096
1097         return err;
1098 }
1099
1100 static void l2cap_sock_close_cb(struct l2cap_chan *chan)
1101 {
1102         struct sock *sk = chan->data;
1103
1104         l2cap_sock_kill(sk);
1105 }
1106
1107 static void l2cap_sock_teardown_cb(struct l2cap_chan *chan, int err)
1108 {
1109         struct sock *sk = chan->data;
1110         struct sock *parent;
1111
1112         lock_sock(sk);
1113
1114         parent = bt_sk(sk)->parent;
1115
1116         sock_set_flag(sk, SOCK_ZAPPED);
1117
1118         switch (chan->state) {
1119         case BT_OPEN:
1120         case BT_BOUND:
1121         case BT_CLOSED:
1122                 break;
1123         case BT_LISTEN:
1124                 l2cap_sock_cleanup_listen(sk);
1125                 sk->sk_state = BT_CLOSED;
1126                 chan->state = BT_CLOSED;
1127
1128                 break;
1129         default:
1130                 sk->sk_state = BT_CLOSED;
1131                 chan->state = BT_CLOSED;
1132
1133                 sk->sk_err = err;
1134
1135                 if (parent) {
1136                         bt_accept_unlink(sk);
1137                         parent->sk_data_ready(parent, 0);
1138                 } else {
1139                         sk->sk_state_change(sk);
1140                 }
1141
1142                 break;
1143         }
1144
1145         release_sock(sk);
1146 }
1147
1148 static void l2cap_sock_state_change_cb(struct l2cap_chan *chan, int state,
1149                                        int err)
1150 {
1151         struct sock *sk = chan->data;
1152
1153         sk->sk_state = state;
1154
1155         if (err)
1156                 sk->sk_err = err;
1157 }
1158
1159 static struct sk_buff *l2cap_sock_alloc_skb_cb(struct l2cap_chan *chan,
1160                                                unsigned long len, int nb)
1161 {
1162         struct sock *sk = chan->data;
1163         struct sk_buff *skb;
1164         int err;
1165
1166         l2cap_chan_unlock(chan);
1167         skb = bt_skb_send_alloc(sk, len, nb, &err);
1168         l2cap_chan_lock(chan);
1169
1170         if (!skb)
1171                 return ERR_PTR(err);
1172
1173         return skb;
1174 }
1175
1176 static void l2cap_sock_ready_cb(struct l2cap_chan *chan)
1177 {
1178         struct sock *sk = chan->data;
1179         struct sock *parent;
1180
1181         lock_sock(sk);
1182
1183         parent = bt_sk(sk)->parent;
1184
1185         BT_DBG("sk %p, parent %p", sk, parent);
1186
1187         sk->sk_state = BT_CONNECTED;
1188         sk->sk_state_change(sk);
1189
1190         if (parent)
1191                 parent->sk_data_ready(parent, 0);
1192
1193         release_sock(sk);
1194 }
1195
1196 static void l2cap_sock_defer_cb(struct l2cap_chan *chan)
1197 {
1198         struct sock *sk = chan->data;
1199         struct sock *parent = bt_sk(sk)->parent;
1200
1201         if (parent)
1202                 parent->sk_data_ready(parent, 0);
1203 }
1204
1205 static void l2cap_sock_resume_cb(struct l2cap_chan *chan)
1206 {
1207         struct sock *sk = chan->data;
1208
1209         clear_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags);
1210         sk->sk_state_change(sk);
1211 }
1212
1213 static void l2cap_sock_set_shutdown_cb(struct l2cap_chan *chan)
1214 {
1215         struct sock *sk = chan->data;
1216
1217         lock_sock(sk);
1218         sk->sk_shutdown = SHUTDOWN_MASK;
1219         release_sock(sk);
1220 }
1221
1222 static long l2cap_sock_get_sndtimeo_cb(struct l2cap_chan *chan)
1223 {
1224         struct sock *sk = chan->data;
1225
1226         return sk->sk_sndtimeo;
1227 }
1228
1229 static struct l2cap_ops l2cap_chan_ops = {
1230         .name           = "L2CAP Socket Interface",
1231         .new_connection = l2cap_sock_new_connection_cb,
1232         .recv           = l2cap_sock_recv_cb,
1233         .close          = l2cap_sock_close_cb,
1234         .teardown       = l2cap_sock_teardown_cb,
1235         .state_change   = l2cap_sock_state_change_cb,
1236         .ready          = l2cap_sock_ready_cb,
1237         .defer          = l2cap_sock_defer_cb,
1238         .resume         = l2cap_sock_resume_cb,
1239         .set_shutdown   = l2cap_sock_set_shutdown_cb,
1240         .get_sndtimeo   = l2cap_sock_get_sndtimeo_cb,
1241         .alloc_skb      = l2cap_sock_alloc_skb_cb,
1242 };
1243
1244 static void l2cap_sock_destruct(struct sock *sk)
1245 {
1246         BT_DBG("sk %p", sk);
1247
1248         if (l2cap_pi(sk)->chan)
1249                 l2cap_chan_put(l2cap_pi(sk)->chan);
1250
1251         if (l2cap_pi(sk)->rx_busy_skb) {
1252                 kfree_skb(l2cap_pi(sk)->rx_busy_skb);
1253                 l2cap_pi(sk)->rx_busy_skb = NULL;
1254         }
1255
1256         skb_queue_purge(&sk->sk_receive_queue);
1257         skb_queue_purge(&sk->sk_write_queue);
1258 }
1259
1260 static void l2cap_skb_msg_name(struct sk_buff *skb, void *msg_name,
1261                                int *msg_namelen)
1262 {
1263         struct sockaddr_l2 *la = (struct sockaddr_l2 *) msg_name;
1264
1265         memset(la, 0, sizeof(struct sockaddr_l2));
1266         la->l2_family = AF_BLUETOOTH;
1267         la->l2_psm = bt_cb(skb)->psm;
1268         bacpy(&la->l2_bdaddr, &bt_cb(skb)->bdaddr);
1269
1270         *msg_namelen = sizeof(struct sockaddr_l2);
1271 }
1272
1273 static void l2cap_sock_init(struct sock *sk, struct sock *parent)
1274 {
1275         struct l2cap_chan *chan = l2cap_pi(sk)->chan;
1276
1277         BT_DBG("sk %p", sk);
1278
1279         if (parent) {
1280                 struct l2cap_chan *pchan = l2cap_pi(parent)->chan;
1281
1282                 sk->sk_type = parent->sk_type;
1283                 bt_sk(sk)->flags = bt_sk(parent)->flags;
1284
1285                 chan->chan_type = pchan->chan_type;
1286                 chan->imtu = pchan->imtu;
1287                 chan->omtu = pchan->omtu;
1288                 chan->conf_state = pchan->conf_state;
1289                 chan->mode = pchan->mode;
1290                 chan->fcs  = pchan->fcs;
1291                 chan->max_tx = pchan->max_tx;
1292                 chan->tx_win = pchan->tx_win;
1293                 chan->tx_win_max = pchan->tx_win_max;
1294                 chan->sec_level = pchan->sec_level;
1295                 chan->flags = pchan->flags;
1296
1297                 security_sk_clone(parent, sk);
1298         } else {
1299                 switch (sk->sk_type) {
1300                 case SOCK_RAW:
1301                         chan->chan_type = L2CAP_CHAN_RAW;
1302                         break;
1303                 case SOCK_DGRAM:
1304                         chan->chan_type = L2CAP_CHAN_CONN_LESS;
1305                         bt_sk(sk)->skb_msg_name = l2cap_skb_msg_name;
1306                         break;
1307                 case SOCK_SEQPACKET:
1308                 case SOCK_STREAM:
1309                         chan->chan_type = L2CAP_CHAN_CONN_ORIENTED;
1310                         break;
1311                 }
1312
1313                 chan->imtu = L2CAP_DEFAULT_MTU;
1314                 chan->omtu = 0;
1315                 if (!disable_ertm && sk->sk_type == SOCK_STREAM) {
1316                         chan->mode = L2CAP_MODE_ERTM;
1317                         set_bit(CONF_STATE2_DEVICE, &chan->conf_state);
1318                 } else {
1319                         chan->mode = L2CAP_MODE_BASIC;
1320                 }
1321
1322                 l2cap_chan_set_defaults(chan);
1323         }
1324
1325         /* Default config options */
1326         chan->flush_to = L2CAP_DEFAULT_FLUSH_TO;
1327
1328         chan->data = sk;
1329         chan->ops = &l2cap_chan_ops;
1330 }
1331
1332 static struct proto l2cap_proto = {
1333         .name           = "L2CAP",
1334         .owner          = THIS_MODULE,
1335         .obj_size       = sizeof(struct l2cap_pinfo)
1336 };
1337
1338 static struct sock *l2cap_sock_alloc(struct net *net, struct socket *sock,
1339                                      int proto, gfp_t prio)
1340 {
1341         struct sock *sk;
1342         struct l2cap_chan *chan;
1343
1344         sk = sk_alloc(net, PF_BLUETOOTH, prio, &l2cap_proto);
1345         if (!sk)
1346                 return NULL;
1347
1348         sock_init_data(sock, sk);
1349         INIT_LIST_HEAD(&bt_sk(sk)->accept_q);
1350
1351         sk->sk_destruct = l2cap_sock_destruct;
1352         sk->sk_sndtimeo = L2CAP_CONN_TIMEOUT;
1353
1354         sock_reset_flag(sk, SOCK_ZAPPED);
1355
1356         sk->sk_protocol = proto;
1357         sk->sk_state = BT_OPEN;
1358
1359         chan = l2cap_chan_create();
1360         if (!chan) {
1361                 sk_free(sk);
1362                 return NULL;
1363         }
1364
1365         l2cap_chan_hold(chan);
1366
1367         chan->sk = sk;
1368
1369         l2cap_pi(sk)->chan = chan;
1370
1371         return sk;
1372 }
1373
1374 static int l2cap_sock_create(struct net *net, struct socket *sock, int protocol,
1375                              int kern)
1376 {
1377         struct sock *sk;
1378
1379         BT_DBG("sock %p", sock);
1380
1381         sock->state = SS_UNCONNECTED;
1382
1383         if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_STREAM &&
1384             sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
1385                 return -ESOCKTNOSUPPORT;
1386
1387         if (sock->type == SOCK_RAW && !kern && !capable(CAP_NET_RAW))
1388                 return -EPERM;
1389
1390         sock->ops = &l2cap_sock_ops;
1391
1392         sk = l2cap_sock_alloc(net, sock, protocol, GFP_ATOMIC);
1393         if (!sk)
1394                 return -ENOMEM;
1395
1396         l2cap_sock_init(sk, NULL);
1397         bt_sock_link(&l2cap_sk_list, sk);
1398         return 0;
1399 }
1400
1401 static const struct proto_ops l2cap_sock_ops = {
1402         .family         = PF_BLUETOOTH,
1403         .owner          = THIS_MODULE,
1404         .release        = l2cap_sock_release,
1405         .bind           = l2cap_sock_bind,
1406         .connect        = l2cap_sock_connect,
1407         .listen         = l2cap_sock_listen,
1408         .accept         = l2cap_sock_accept,
1409         .getname        = l2cap_sock_getname,
1410         .sendmsg        = l2cap_sock_sendmsg,
1411         .recvmsg        = l2cap_sock_recvmsg,
1412         .poll           = bt_sock_poll,
1413         .ioctl          = bt_sock_ioctl,
1414         .mmap           = sock_no_mmap,
1415         .socketpair     = sock_no_socketpair,
1416         .shutdown       = l2cap_sock_shutdown,
1417         .setsockopt     = l2cap_sock_setsockopt,
1418         .getsockopt     = l2cap_sock_getsockopt
1419 };
1420
1421 static const struct net_proto_family l2cap_sock_family_ops = {
1422         .family = PF_BLUETOOTH,
1423         .owner  = THIS_MODULE,
1424         .create = l2cap_sock_create,
1425 };
1426
1427 int __init l2cap_init_sockets(void)
1428 {
1429         int err;
1430
1431         err = proto_register(&l2cap_proto, 0);
1432         if (err < 0)
1433                 return err;
1434
1435         err = bt_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops);
1436         if (err < 0) {
1437                 BT_ERR("L2CAP socket registration failed");
1438                 goto error;
1439         }
1440
1441         err = bt_procfs_init(&init_net, "l2cap", &l2cap_sk_list,
1442                              NULL);
1443         if (err < 0) {
1444                 BT_ERR("Failed to create L2CAP proc file");
1445                 bt_sock_unregister(BTPROTO_L2CAP);
1446                 goto error;
1447         }
1448
1449         BT_INFO("L2CAP socket layer initialized");
1450
1451         return 0;
1452
1453 error:
1454         proto_unregister(&l2cap_proto);
1455         return err;
1456 }
1457
1458 void l2cap_cleanup_sockets(void)
1459 {
1460         bt_procfs_cleanup(&init_net, "l2cap");
1461         bt_sock_unregister(BTPROTO_L2CAP);
1462         proto_unregister(&l2cap_proto);
1463 }