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