net/bluetooth/l2cap.c

   1 /*
   2    BlueZ - Bluetooth protocol stack for Linux
   3    Copyright (C) 2000-2001 Qualcomm Incorporated
   4
   5    Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License version 2 as
   9    published by the Free Software Foundation;
  10
  11    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  12    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  13    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS.
  14    IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY
  15    CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES
  16    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  17    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  18    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  19
  20    ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
  21    COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
  22    SOFTWARE IS DISCLAIMED.
  23 */
  24
  25 /*
  26  * BlueZ L2CAP core and sockets.
  27  *
  28  * $Id: l2cap.c,v 1.1.1.1 2005/04/11 02:51:12 jack Exp $
  29  */
  30 #define VERSION "2.1"
  31
  32 #include <linux/config.h>
  33 #include <linux/module.h>
  34
  35 #include <linux/types.h>
  36 #include <linux/errno.h>
  37 #include <linux/kernel.h>
  38 #include <linux/major.h>
  39 #include <linux/sched.h>
  40 #include <linux/slab.h>
  41 #include <linux/poll.h>
  42 #include <linux/fcntl.h>
  43 #include <linux/init.h>
  44 #include <linux/skbuff.h>
  45 #include <linux/interrupt.h>
  46 #include <linux/socket.h>
  47 #include <linux/skbuff.h>
  48 #include <linux/proc_fs.h>
  49 #include <linux/list.h>
  50 #include <net/sock.h>
  51
  52 #include <asm/system.h>
  53 #include <asm/uaccess.h>
  54 #include <asm/unaligned.h>
  55
  56 #include <net/bluetooth/bluetooth.h>
  57 #include <net/bluetooth/hci_core.h>
  58 #include <net/bluetooth/l2cap.h>
  59
  60 #ifndef L2CAP_DEBUG
  61 #undef  BT_DBG
  62 #define BT_DBG( A... )
  63 #endif
  64
  65 static struct proto_ops l2cap_sock_ops;
  66
  67 struct bluez_sock_list l2cap_sk_list = {
  68         lock: RW_LOCK_UNLOCKED
  69 };
  70
  71 static int l2cap_conn_del(struct hci_conn *conn, int err);
  72
  73 static inline void l2cap_chan_add(struct l2cap_conn *conn, struct sock *sk, struct sock *parent);
  74 static void l2cap_chan_del(struct sock *sk, int err);
  75 static int  l2cap_chan_send(struct sock *sk, struct msghdr *msg, int len);
  76
  77 static void __l2cap_sock_close(struct sock *sk, int reason);
  78 static void l2cap_sock_close(struct sock *sk);
  79 static void l2cap_sock_kill(struct sock *sk);
  80
  81 static int l2cap_send_req(struct l2cap_conn *conn, __u8 code, __u16 len, void *data);
  82 static int l2cap_send_rsp(struct l2cap_conn *conn, __u8 ident, __u8 code, __u16 len, void *data);
  83
  84 /* ----- L2CAP timers ------ */
  85 static void l2cap_sock_timeout(unsigned long arg)
  86 {
  87         struct sock *sk = (struct sock *) arg;
  88
  89         BT_DBG("sock %p state %d", sk, sk->state);
  90
  91         bh_lock_sock(sk);
  92         __l2cap_sock_close(sk, ETIMEDOUT);
  93         bh_unlock_sock(sk);
  94
  95         l2cap_sock_kill(sk);
  96         sock_put(sk);
  97 }
  98
  99 static void l2cap_sock_set_timer(struct sock *sk, long timeout)
 100 {
 101         BT_DBG("sk %p state %d timeout %ld", sk, sk->state, timeout);
 102
 103         if (!mod_timer(&sk->timer, jiffies + timeout))
 104                 sock_hold(sk);
 105 }
 106
 107 static void l2cap_sock_clear_timer(struct sock *sk)
 108 {
 109         BT_DBG("sock %p state %d", sk, sk->state);
 110
 111         if (timer_pending(&sk->timer) && del_timer(&sk->timer))
 112                 __sock_put(sk);
 113 }
 114
 115 static void l2cap_sock_init_timer(struct sock *sk)
 116 {
 117         init_timer(&sk->timer);
 118         sk->timer.function = l2cap_sock_timeout;
 119         sk->timer.data = (unsigned long)sk;
 120 }
 121
 122 /* -------- L2CAP connections --------- */
 123 static struct l2cap_conn *l2cap_conn_add(struct hci_conn *hcon, __u8 status)
 124 {
 125         struct l2cap_conn *conn;
 126
 127         if ((conn = hcon->l2cap_data))
 128                 return conn;
 129
 130         if (status)
 131                 return conn;
 132
 133         if (!(conn = kmalloc(sizeof(struct l2cap_conn), GFP_ATOMIC)))
 134                 return NULL;
 135         memset(conn, 0, sizeof(struct l2cap_conn));
 136
 137         hcon->l2cap_data = conn;
 138         conn->hcon = hcon;
 139
 140         conn->mtu = hcon->hdev->acl_mtu;
 141         conn->src = &hcon->hdev->bdaddr;
 142         conn->dst = &hcon->dst;
 143
 144         spin_lock_init(&conn->lock);
 145         conn->chan_list.lock = RW_LOCK_UNLOCKED;
 146
 147         BT_DBG("hcon %p conn %p", hcon, conn);
 148
 149         MOD_INC_USE_COUNT;
 150         return conn;
 151 }
 152
 153 static int l2cap_conn_del(struct hci_conn *hcon, int err)
 154 {
 155         struct l2cap_conn *conn;
 156         struct sock *sk;
 157
 158         if (!(conn = hcon->l2cap_data))
 159                 return 0;
 160
 161         BT_DBG("hcon %p conn %p, err %d", hcon, conn, err);
 162
 163         if (conn->rx_skb)
 164                 kfree_skb(conn->rx_skb);
 165
 166         /* Kill channels */
 167         while ((sk = conn->chan_list.head)) {
 168                 bh_lock_sock(sk);
 169                 l2cap_chan_del(sk, err);
 170                 bh_unlock_sock(sk);
 171                 l2cap_sock_kill(sk);
 172         }
 173
 174         hcon->l2cap_data = NULL;
 175         kfree(conn);
 176
 177         MOD_DEC_USE_COUNT;
 178         return 0;
 179 }
 180
 181 /* -------- Socket interface ---------- */
 182 static struct sock *__l2cap_get_sock_by_addr(__u16 psm, bdaddr_t *src)
 183 {
 184         struct sock *sk;
 185         for (sk = l2cap_sk_list.head; sk; sk = sk->next) {
 186                 if (sk->sport == psm && !bacmp(&bluez_pi(sk)->src, src))
 187                         break;
 188         }
 189         return sk;
 190 }
 191
 192 /* Find socket with psm and source bdaddr.
 193  * Returns closest match.
 194  */
 195 static struct sock *__l2cap_get_sock_by_psm(int state, __u16 psm, bdaddr_t *src)
 196 {
 197         struct sock *sk, *sk1 = NULL;
 198
 199         for (sk = l2cap_sk_list.head; sk; sk = sk->next) {
 200                 if (state && sk->state != state)
 201                         continue;
 202
 203                 if (l2cap_pi(sk)->psm == psm) {
 204                         /* Exact match. */
 205                         if (!bacmp(&bluez_pi(sk)->src, src))
 206                                 break;
 207
 208                         /* Closest match */
 209                         if (!bacmp(&bluez_pi(sk)->src, BDADDR_ANY))
 210                                 sk1 = sk;
 211                 }
 212         }
 213         return sk ? sk : sk1;
 214 }
 215
 216 /* Find socket with given address (psm, src).
 217  * Returns locked socket */
 218 static inline struct sock *l2cap_get_sock_by_psm(int state, __u16 psm, bdaddr_t *src)
 219 {
 220         struct sock *s;
 221         read_lock(&l2cap_sk_list.lock);
 222         s = __l2cap_get_sock_by_psm(state, psm, src);
 223         if (s) bh_lock_sock(s);
 224         read_unlock(&l2cap_sk_list.lock);
 225         return s;
 226 }
 227
 228 static void l2cap_sock_destruct(struct sock *sk)
 229 {
 230         BT_DBG("sk %p", sk);
 231
 232         skb_queue_purge(&sk->receive_queue);
 233         skb_queue_purge(&sk->write_queue);
 234
 235         MOD_DEC_USE_COUNT;
 236 }
 237
 238 static void l2cap_sock_cleanup_listen(struct sock *parent)
 239 {
 240         struct sock *sk;
 241
 242         BT_DBG("parent %p", parent);
 243
 244         /* Close not yet accepted channels */
 245         while ((sk = bluez_accept_dequeue(parent, NULL)))
 246                 l2cap_sock_close(sk);
 247
 248         parent->state  = BT_CLOSED;
 249         parent->zapped = 1;
 250 }
 251
 252 /* Kill socket (only if zapped and orphan)
 253  * Must be called on unlocked socket.
 254  */
 255 static void l2cap_sock_kill(struct sock *sk)
 256 {
 257         if (!sk->zapped || sk->socket)
 258                 return;
 259
 260         BT_DBG("sk %p state %d", sk, sk->state);
 261
 262         /* Kill poor orphan */
 263         bluez_sock_unlink(&l2cap_sk_list, sk);
 264         sk->dead = 1;
 265         sock_put(sk);
 266 }
 267
 268 /* Close socket.
 269  */
 270 static void __l2cap_sock_close(struct sock *sk, int reason)
 271 {
 272         BT_DBG("sk %p state %d socket %p", sk, sk->state, sk->socket);
 273
 274         switch (sk->state) {
 275         case BT_LISTEN:
 276                 l2cap_sock_cleanup_listen(sk);
 277                 break;
 278
 279         case BT_CONNECTED:
 280         case BT_CONFIG:
 281         case BT_CONNECT2:
 282                 if (sk->type == SOCK_SEQPACKET) {
 283                         struct l2cap_conn *conn = l2cap_pi(sk)->conn;
 284                         l2cap_disconn_req req;
 285
 286                         sk->state = BT_DISCONN;
 287                         l2cap_sock_set_timer(sk, HZ * 5);
 288
 289                         req.dcid = __cpu_to_le16(l2cap_pi(sk)->dcid);
 290                         req.scid = __cpu_to_le16(l2cap_pi(sk)->scid);
 291                         l2cap_send_req(conn, L2CAP_DISCONN_REQ, L2CAP_DISCONN_REQ_SIZE, &req);
 292                 } else {
 293                         l2cap_chan_del(sk, reason);
 294                 }
 295                 break;
 296
 297         case BT_CONNECT:
 298         case BT_DISCONN:
 299                 l2cap_chan_del(sk, reason);
 300                 break;
 301
 302         default:
 303                 sk->zapped = 1;
 304                 break;
 305         };
 306 }
 307
 308 /* Must be called on unlocked socket. */
 309 static void l2cap_sock_close(struct sock *sk)
 310 {
 311         l2cap_sock_clear_timer(sk);
 312
 313         lock_sock(sk);
 314         __l2cap_sock_close(sk, ECONNRESET);
 315         release_sock(sk);
 316
 317         l2cap_sock_kill(sk);
 318 }
 319
 320 static void l2cap_sock_init(struct sock *sk, struct sock *parent)
 321 {
 322         struct l2cap_pinfo *pi = l2cap_pi(sk);
 323
 324         BT_DBG("sk %p", sk);
 325
 326         if (parent) {
 327                 sk->type = parent->type;
 328                 pi->imtu = l2cap_pi(parent)->imtu;
 329                 pi->omtu = l2cap_pi(parent)->omtu;
 330                 pi->link_mode = l2cap_pi(parent)->link_mode;
 331         } else {
 332                 pi->imtu = L2CAP_DEFAULT_MTU;
 333                 pi->omtu = 0;
 334                 pi->link_mode = 0;
 335         }
 336
 337         /* Default config options */
 338         pi->conf_mtu = L2CAP_DEFAULT_MTU;
 339         pi->flush_to = L2CAP_DEFAULT_FLUSH_TO;
 340 }
 341
 342 static struct sock *l2cap_sock_alloc(struct socket *sock, int proto, int prio)
 343 {
 344         struct sock *sk;
 345
 346         if (!(sk = sk_alloc(PF_BLUETOOTH, prio, 1)))
 347                 return NULL;
 348
 349         bluez_sock_init(sock, sk);
 350
 351         sk->zapped   = 0;
 352
 353         sk->destruct = l2cap_sock_destruct;
 354         sk->sndtimeo = L2CAP_CONN_TIMEOUT;
 355
 356         sk->protocol = proto;
 357         sk->state    = BT_OPEN;
 358
 359         l2cap_sock_init_timer(sk);
 360
 361         bluez_sock_link(&l2cap_sk_list, sk);
 362
 363         MOD_INC_USE_COUNT;
 364         return sk;
 365 }
 366
 367 static int l2cap_sock_create(struct socket *sock, int protocol)
 368 {
 369         struct sock *sk;
 370
 371         BT_DBG("sock %p", sock);
 372
 373         sock->state = SS_UNCONNECTED;
 374
 375         if (sock->type != SOCK_SEQPACKET && sock->type != SOCK_DGRAM && sock->type != SOCK_RAW)
 376                 return -ESOCKTNOSUPPORT;
 377
 378         if (sock->type == SOCK_RAW && !capable(CAP_NET_RAW))
 379                 return -EPERM;
 380
 381         sock->ops = &l2cap_sock_ops;
 382
 383         if (!(sk = l2cap_sock_alloc(sock, protocol, GFP_KERNEL)))
 384                 return -ENOMEM;
 385
 386         l2cap_sock_init(sk, NULL);
 387         return 0;
 388 }
 389
 390 static int l2cap_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
 391 {
 392         struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
 393         struct sock *sk = sock->sk;
 394         int err = 0;
 395
 396         BT_DBG("sk %p, %s %d", sk, batostr(&la->l2_bdaddr), la->l2_psm);
 397
 398         if (!addr || addr->sa_family != AF_BLUETOOTH)
 399                 return -EINVAL;
 400
 401         lock_sock(sk);
 402
 403         if (sk->state != BT_OPEN) {
 404                 err = -EBADFD;
 405                 goto done;
 406         }
 407
 408         write_lock_bh(&l2cap_sk_list.lock);
 409         if (la->l2_psm && __l2cap_get_sock_by_addr(la->l2_psm, &la->l2_bdaddr)) {
 410                 err = -EADDRINUSE;
 411         } else {
 412                 /* Save source address */
 413                 bacpy(&bluez_pi(sk)->src, &la->l2_bdaddr);
 414                 l2cap_pi(sk)->psm = la->l2_psm;
 415                 sk->sport = la->l2_psm;
 416                 sk->state = BT_BOUND;
 417         }
 418         write_unlock_bh(&l2cap_sk_list.lock);
 419
 420 done:
 421         release_sock(sk);
 422         return err;
 423 }
 424
 425 static int l2cap_do_connect(struct sock *sk)
 426 {
 427         bdaddr_t *src = &bluez_pi(sk)->src;
 428         bdaddr_t *dst = &bluez_pi(sk)->dst;
 429         struct l2cap_conn *conn;
 430         struct hci_conn   *hcon;
 431         struct hci_dev    *hdev;
 432         int err = 0;
 433
 434         BT_DBG("%s -> %s psm 0x%2.2x", batostr(src), batostr(dst), l2cap_pi(sk)->psm);
 435
 436         if (!(hdev = hci_get_route(dst, src)))
 437                 return -EHOSTUNREACH;
 438
 439         hci_dev_lock_bh(hdev);
 440
 441         err = -ENOMEM;
 442
 443         hcon = hci_connect(hdev, ACL_LINK, dst);
 444         if (!hcon)
 445                 goto done;
 446
 447         conn = l2cap_conn_add(hcon, 0);
 448         if (!conn) {
 449                 hci_conn_put(hcon);
 450                 goto done;
 451         }
 452
 453         err = 0;
 454
 455         /* Update source addr of the socket */
 456         bacpy(src, conn->src);
 457
 458         l2cap_chan_add(conn, sk, NULL);
 459
 460         sk->state = BT_CONNECT;
 461         l2cap_sock_set_timer(sk, sk->sndtimeo);
 462
 463         if (hcon->state == BT_CONNECTED) {
 464                 if (sk->type == SOCK_SEQPACKET) {
 465                         l2cap_conn_req req;
 466                         req.scid = __cpu_to_le16(l2cap_pi(sk)->scid);
 467                         req.psm  = l2cap_pi(sk)->psm;
 468                         l2cap_send_req(conn, L2CAP_CONN_REQ, L2CAP_CONN_REQ_SIZE, &req);
 469                 } else {
 470                         l2cap_sock_clear_timer(sk);
 471                         sk->state = BT_CONNECTED;
 472                 }
 473         }
 474
 475 done:
 476         hci_dev_unlock_bh(hdev);
 477         hci_dev_put(hdev);
 478         return err;
 479 }
 480
 481 static int l2cap_sock_connect(struct socket *sock, struct sockaddr *addr, int alen, int flags)
 482 {
 483         struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
 484         struct sock *sk = sock->sk;
 485         int err = 0;
 486
 487         lock_sock(sk);
 488
 489         BT_DBG("sk %p", sk);
 490
 491         if (addr->sa_family != AF_BLUETOOTH || alen < sizeof(struct sockaddr_l2)) {
 492                 err = -EINVAL;
 493                 goto done;
 494         }
 495
 496         if (sk->type == SOCK_SEQPACKET && !la->l2_psm) {
 497                 err = -EINVAL;
 498                 goto done;
 499         }
 500
 501         switch(sk->state) {
 502         case BT_CONNECT:
 503         case BT_CONNECT2:
 504         case BT_CONFIG:
 505                 /* Already connecting */
 506                 goto wait;
 507
 508         case BT_CONNECTED:
 509                 /* Already connected */
 510                 goto done;
 511
 512         case BT_OPEN:
 513         case BT_BOUND:
 514                 /* Can connect */
 515                 break;
 516
 517         default:
 518                 err = -EBADFD;
 519                 goto done;
 520         }
 521
 522         /* Set destination address and psm */
 523         bacpy(&bluez_pi(sk)->dst, &la->l2_bdaddr);
 524         l2cap_pi(sk)->psm = la->l2_psm;
 525
 526         if ((err = l2cap_do_connect(sk)))
 527                 goto done;
 528
 529 wait:
 530         err = bluez_sock_w4_connect(sk, flags);
 531
 532 done:
 533         release_sock(sk);
 534         return err;
 535 }
 536
 537 int l2cap_sock_listen(struct socket *sock, int backlog)
 538 {
 539         struct sock *sk = sock->sk;
 540         int err = 0;
 541
 542         BT_DBG("sk %p backlog %d", sk, backlog);
 543
 544         lock_sock(sk);
 545
 546         if (sk->state != BT_BOUND || sock->type != SOCK_SEQPACKET) {
 547                 err = -EBADFD;
 548                 goto done;
 549         }
 550
 551         if (!l2cap_pi(sk)->psm) {
 552                 err = -EINVAL;
 553                 goto done;
 554         }
 555
 556         sk->max_ack_backlog = backlog;
 557         sk->ack_backlog = 0;
 558         sk->state = BT_LISTEN;
 559
 560 done:
 561         release_sock(sk);
 562         return err;
 563 }
 564
 565 int l2cap_sock_accept(struct socket *sock, struct socket *newsock, int flags)
 566 {
 567         DECLARE_WAITQUEUE(wait, current);
 568         struct sock *sk = sock->sk, *nsk;
 569         long timeo;
 570         int err = 0;
 571
 572         lock_sock(sk);
 573
 574         if (sk->state != BT_LISTEN) {
 575                 err = -EBADFD;
 576                 goto done;
 577         }
 578
 579         timeo = sock_rcvtimeo(sk, flags & O_NONBLOCK);
 580
 581         BT_DBG("sk %p timeo %ld", sk, timeo);
 582
 583         /* Wait for an incoming connection. (wake-one). */
 584         add_wait_queue_exclusive(sk->sleep, &wait);
 585         while (!(nsk = bluez_accept_dequeue(sk, newsock))) {
 586                 set_current_state(TASK_INTERRUPTIBLE);
 587                 if (!timeo) {
 588                         err = -EAGAIN;
 589                         break;
 590                 }
 591
 592                 release_sock(sk);
 593                 timeo = schedule_timeout(timeo);
 594                 lock_sock(sk);
 595
 596                 if (sk->state != BT_LISTEN) {
 597                         err = -EBADFD;
 598                         break;
 599                 }
 600
 601                 if (signal_pending(current)) {
 602                         err = sock_intr_errno(timeo);
 603                         break;
 604                 }
 605         }
 606         set_current_state(TASK_RUNNING);
 607         remove_wait_queue(sk->sleep, &wait);
 608
 609         if (err)
 610                 goto done;
 611
 612         newsock->state = SS_CONNECTED;
 613
 614         BT_DBG("new socket %p", nsk);
 615
 616 done:
 617         release_sock(sk);
 618         return err;
 619 }
 620
 621 static int l2cap_sock_getname(struct socket *sock, struct sockaddr *addr, int *len, int peer)
 622 {
 623         struct sockaddr_l2 *la = (struct sockaddr_l2 *) addr;
 624         struct sock *sk = sock->sk;
 625
 626         BT_DBG("sock %p, sk %p", sock, sk);
 627
 628         addr->sa_family = AF_BLUETOOTH;
 629         *len = sizeof(struct sockaddr_l2);
 630
 631         if (peer)
 632                 bacpy(&la->l2_bdaddr, &bluez_pi(sk)->dst);
 633         else
 634                 bacpy(&la->l2_bdaddr, &bluez_pi(sk)->src);
 635
 636         la->l2_psm = l2cap_pi(sk)->psm;
 637         return 0;
 638 }
 639
 640 static int l2cap_sock_sendmsg(struct socket *sock, struct msghdr *msg, int len, struct scm_cookie *scm)
 641 {
 642         struct sock *sk = sock->sk;
 643         int err = 0;
 644
 645         BT_DBG("sock %p, sk %p", sock, sk);
 646
 647         if (sk->err)
 648                 return sock_error(sk);
 649
 650         if (msg->msg_flags & MSG_OOB)
 651                 return -EOPNOTSUPP;
 652
 653         /* Check outgoing MTU */
 654         if (len > l2cap_pi(sk)->omtu)
 655                 return -EINVAL;
 656
 657         lock_sock(sk);
 658
 659         if (sk->state == BT_CONNECTED)
 660                 err = l2cap_chan_send(sk, msg, len);
 661         else
 662                 err = -ENOTCONN;
 663
 664         release_sock(sk);
 665         return err;
 666 }
 667
 668 static int l2cap_sock_setsockopt(struct socket *sock, int level, int optname, char *optval, int optlen)
 669 {
 670         struct sock *sk = sock->sk;
 671         struct l2cap_options opts;
 672         int err = 0, len;
 673         __u32 opt;
 674
 675         BT_DBG("sk %p", sk);
 676
 677         lock_sock(sk);
 678
 679         switch (optname) {
 680         case L2CAP_OPTIONS:
 681                 len = MIN(sizeof(opts), optlen);
 682                 if (copy_from_user((char *)&opts, optval, len)) {
 683                         err = -EFAULT;
 684                         break;
 685                 }
 686                 l2cap_pi(sk)->imtu  = opts.imtu;
 687                 l2cap_pi(sk)->omtu  = opts.omtu;
 688                 break;
 689
 690         case L2CAP_LM:
 691                 if (get_user(opt, (__u32 *)optval)) {
 692                         err = -EFAULT;
 693                         break;
 694                 }
 695
 696                 l2cap_pi(sk)->link_mode = opt;
 697                 break;
 698
 699         default:
 700                 err = -ENOPROTOOPT;
 701                 break;
 702         }
 703
 704         release_sock(sk);
 705         return err;
 706 }
 707
 708 static int l2cap_sock_getsockopt(struct socket *sock, int level, int optname, char *optval, int *optlen)
 709 {
 710         struct sock *sk = sock->sk;
 711         struct l2cap_options opts;
 712         struct l2cap_conninfo cinfo;
 713         int len, err = 0;
 714
 715         if (get_user(len, optlen))
 716                 return -EFAULT;
 717
 718         lock_sock(sk);
 719
 720         switch (optname) {
 721         case L2CAP_OPTIONS:
 722                 opts.imtu     = l2cap_pi(sk)->imtu;
 723                 opts.omtu     = l2cap_pi(sk)->omtu;
 724                 opts.flush_to = l2cap_pi(sk)->flush_to;
 725
 726                 len = MIN(len, sizeof(opts));
 727                 if (copy_to_user(optval, (char *)&opts, len))
 728                         err = -EFAULT;
 729
 730                 break;
 731
 732         case L2CAP_LM:
 733                 if (put_user(l2cap_pi(sk)->link_mode, (__u32 *)optval))
 734                         err = -EFAULT;
 735                 break;
 736
 737         case L2CAP_CONNINFO:
 738                 if (sk->state != BT_CONNECTED) {
 739                         err = -ENOTCONN;
 740                         break;
 741                 }
 742
 743                 cinfo.hci_handle = l2cap_pi(sk)->conn->hcon->handle;
 744
 745                 len = MIN(len, sizeof(cinfo));
 746                 if (copy_to_user(optval, (char *)&cinfo, len))
 747                         err = -EFAULT;
 748
 749                 break;
 750
 751         default:
 752                 err = -ENOPROTOOPT;
 753                 break;
 754         }
 755
 756         release_sock(sk);
 757         return err;
 758 }
 759
 760 static int l2cap_sock_shutdown(struct socket *sock, int how)
 761 {
 762         struct sock *sk = sock->sk;
 763
 764         BT_DBG("sock %p, sk %p", sock, sk);
 765
 766         if (!sk) return 0;
 767
 768         l2cap_sock_clear_timer(sk);
 769
 770         lock_sock(sk);
 771         sk->shutdown = SHUTDOWN_MASK;
 772         __l2cap_sock_close(sk, ECONNRESET);
 773         release_sock(sk);
 774
 775         return 0;
 776 }
 777
 778 static int l2cap_sock_release(struct socket *sock)
 779 {
 780         struct sock *sk = sock->sk;
 781
 782         BT_DBG("sock %p, sk %p", sock, sk);
 783
 784         if (!sk) return 0;
 785
 786         sock_orphan(sk);
 787         l2cap_sock_close(sk);
 788         return 0;
 789 }
 790
 791 /* --------- L2CAP channels --------- */
 792 static struct sock * __l2cap_get_chan_by_dcid(struct l2cap_chan_list *l, __u16 cid)
 793 {
 794         struct sock *s;
 795         for (s = l->head; s; s = l2cap_pi(s)->next_c) {
 796                 if (l2cap_pi(s)->dcid == cid)
 797                         break;
 798         }
 799         return s;
 800 }
 801
 802 static struct sock *__l2cap_get_chan_by_scid(struct l2cap_chan_list *l, __u16 cid)
 803 {
 804         struct sock *s;
 805         for (s = l->head; s; s = l2cap_pi(s)->next_c) {
 806                 if (l2cap_pi(s)->scid == cid)
 807                         break;
 808         }
 809         return s;
 810 }
 811
 812 /* Find channel with given SCID.
 813  * Returns locked socket */
 814 static inline struct sock *l2cap_get_chan_by_scid(struct l2cap_chan_list *l, __u16 cid)
 815 {
 816         struct sock *s;
 817         read_lock(&l->lock);
 818         s = __l2cap_get_chan_by_scid(l, cid);
 819         if (s) bh_lock_sock(s);
 820         read_unlock(&l->lock);
 821         return s;
 822 }
 823
 824 static __u16 l2cap_alloc_cid(struct l2cap_chan_list *l)
 825 {
 826         __u16 cid = 0x0040;
 827
 828         for (; cid < 0xffff; cid++) {
 829                 if(!__l2cap_get_chan_by_scid(l, cid))
 830                         return cid;
 831         }
 832
 833         return 0;
 834 }
 835
 836 static inline void __l2cap_chan_link(struct l2cap_chan_list *l, struct sock *sk)
 837 {
 838         sock_hold(sk);
 839
 840         if (l->head)
 841                 l2cap_pi(l->head)->prev_c = sk;
 842
 843         l2cap_pi(sk)->next_c = l->head;
 844         l2cap_pi(sk)->prev_c = NULL;
 845         l->head = sk;
 846 }
 847
 848 static inline void l2cap_chan_unlink(struct l2cap_chan_list *l, struct sock *sk)
 849 {
 850         struct sock *next = l2cap_pi(sk)->next_c, *prev = l2cap_pi(sk)->prev_c;
 851
 852         write_lock(&l->lock);
 853         if (sk == l->head)
 854                 l->head = next;
 855
 856         if (next)
 857                 l2cap_pi(next)->prev_c = prev;
 858         if (prev)
 859                 l2cap_pi(prev)->next_c = next;
 860         write_unlock(&l->lock);
 861
 862         __sock_put(sk);
 863 }
 864
 865 static void __l2cap_chan_add(struct l2cap_conn *conn, struct sock *sk, struct sock *parent)
 866 {
 867         struct l2cap_chan_list *l = &conn->chan_list;
 868
 869         BT_DBG("conn %p, psm 0x%2.2x, dcid 0x%4.4x", conn, l2cap_pi(sk)->psm, l2cap_pi(sk)->dcid);
 870
 871         l2cap_pi(sk)->conn = conn;
 872
 873         if (sk->type == SOCK_SEQPACKET) {
 874                 /* Alloc CID for connection-oriented socket */
 875                 l2cap_pi(sk)->scid = l2cap_alloc_cid(l);
 876         } else if (sk->type == SOCK_DGRAM) {
 877                 /* Connectionless socket */
 878                 l2cap_pi(sk)->scid = 0x0002;
 879                 l2cap_pi(sk)->dcid = 0x0002;
 880                 l2cap_pi(sk)->omtu = L2CAP_DEFAULT_MTU;
 881         } else {
 882                 /* Raw socket can send/recv signalling messages only */
 883                 l2cap_pi(sk)->scid = 0x0001;
 884                 l2cap_pi(sk)->dcid = 0x0001;
 885                 l2cap_pi(sk)->omtu = L2CAP_DEFAULT_MTU;
 886         }
 887
 888         __l2cap_chan_link(l, sk);
 889
 890         if (parent)
 891                 bluez_accept_enqueue(parent, sk);
 892 }
 893
 894 static inline void l2cap_chan_add(struct l2cap_conn *conn, struct sock *sk, struct sock *parent)
 895 {
 896         struct l2cap_chan_list *l = &conn->chan_list;
 897         write_lock(&l->lock);
 898         __l2cap_chan_add(conn, sk, parent);
 899         write_unlock(&l->lock);
 900 }
 901
 902 /* Delete channel.
 903  * Must be called on the locked socket. */
 904 static void l2cap_chan_del(struct sock *sk, int err)
 905 {
 906         struct l2cap_conn *conn = l2cap_pi(sk)->conn;
 907         struct sock *parent = bluez_pi(sk)->parent;
 908
 909         l2cap_sock_clear_timer(sk);
 910
 911         BT_DBG("sk %p, conn %p, err %d", sk, conn, err);
 912
 913         if (conn) {
 914                 /* Unlink from channel list */
 915                 l2cap_chan_unlink(&conn->chan_list, sk);
 916                 l2cap_pi(sk)->conn = NULL;
 917                 hci_conn_put(conn->hcon);
 918         }
 919
 920         sk->state = BT_CLOSED;
 921         sk->err   = err;
 922         sk->zapped = 1;
 923
 924         if (parent)
 925                 parent->data_ready(parent, 0);
 926         else
 927                 sk->state_change(sk);
 928 }
 929
 930 static void l2cap_conn_ready(struct l2cap_conn *conn)
 931 {
 932         struct l2cap_chan_list *l = &conn->chan_list;
 933         struct sock *sk;
 934
 935         BT_DBG("conn %p", conn);
 936
 937         read_lock(&l->lock);
 938
 939         for (sk = l->head; sk; sk = l2cap_pi(sk)->next_c) {
 940                 bh_lock_sock(sk);
 941
 942                 if (sk->type != SOCK_SEQPACKET) {
 943                         l2cap_sock_clear_timer(sk);
 944                         sk->state = BT_CONNECTED;
 945                         sk->state_change(sk);
 946                 } else if (sk->state == BT_CONNECT) {
 947                         l2cap_conn_req req;
 948                         req.scid = __cpu_to_le16(l2cap_pi(sk)->scid);
 949                         req.psm  = l2cap_pi(sk)->psm;
 950                         l2cap_send_req(conn, L2CAP_CONN_REQ, L2CAP_CONN_REQ_SIZE, &req);
 951                 }
 952
 953                 bh_unlock_sock(sk);
 954         }
 955
 956         read_unlock(&l->lock);
 957 }
 958
 959 static void l2cap_chan_ready(struct sock *sk)
 960 {
 961         struct sock *parent = bluez_pi(sk)->parent;
 962
 963         BT_DBG("sk %p, parent %p", sk, parent);
 964
 965         l2cap_pi(sk)->conf_state = 0;
 966         l2cap_sock_clear_timer(sk);
 967
 968         if (!parent) {
 969                 /* Outgoing channel.
 970                  * Wake up socket sleeping on connect.
 971                  */
 972                 sk->state = BT_CONNECTED;
 973                 sk->state_change(sk);
 974         } else {
 975                 /* Incomming channel.
 976                  * Wake up socket sleeping on accept.
 977                  */
 978                 parent->data_ready(parent, 0);
 979         }
 980 }
 981
 982 /* Copy frame to all raw sockets on that connection */
 983 void l2cap_raw_recv(struct l2cap_conn *conn, struct sk_buff *skb)
 984 {
 985         struct l2cap_chan_list *l = &conn->chan_list;
 986         struct sk_buff *nskb;
 987         struct sock * sk;
 988
 989         BT_DBG("conn %p", conn);
 990
 991         read_lock(&l->lock);
 992         for (sk = l->head; sk; sk = l2cap_pi(sk)->next_c) {
 993                 if (sk->type != SOCK_RAW)
 994                         continue;
 995
 996                 /* Don't send frame to the socket it came from */
 997                 if (skb->sk == sk)
 998                         continue;
 999
1000                 if (!(nskb = skb_clone(skb, GFP_ATOMIC)))
1001                         continue;
1002
1003                 if (sock_queue_rcv_skb(sk, nskb))
1004                         kfree_skb(nskb);
1005         }
1006         read_unlock(&l->lock);
1007 }
1008
1009 static int l2cap_chan_send(struct sock *sk, struct msghdr *msg, int len)
1010 {
1011         struct l2cap_conn *conn = l2cap_pi(sk)->conn;
1012         struct sk_buff *skb, **frag;
1013         int err, hlen, count, sent=0;
1014         l2cap_hdr *lh;
1015
1016         BT_DBG("sk %p len %d", sk, len);
1017
1018         /* First fragment (with L2CAP header) */
1019         if (sk->type == SOCK_DGRAM)
1020                 hlen = L2CAP_HDR_SIZE + 2;
1021         else
1022                 hlen = L2CAP_HDR_SIZE;
1023
1024         count = MIN(conn->mtu - hlen, len);
1025
1026         skb = bluez_skb_send_alloc(sk, hlen + count,
1027                         msg->msg_flags & MSG_DONTWAIT, &err);
1028         if (!skb)
1029                 return err;
1030
1031         /* Create L2CAP header */
1032         lh = (l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
1033         lh->cid = __cpu_to_le16(l2cap_pi(sk)->dcid);
1034         lh->len = __cpu_to_le16(len + (hlen - L2CAP_HDR_SIZE));
1035
1036         if (sk->type == SOCK_DGRAM)
1037                 put_unaligned(l2cap_pi(sk)->psm, (__u16 *) skb_put(skb, 2));
1038
1039         if (memcpy_fromiovec(skb_put(skb, count), msg->msg_iov, count)) {
1040                 err = -EFAULT;
1041                 goto fail;
1042         }
1043
1044         sent += count;
1045         len  -= count;
1046
1047         /* Continuation fragments (no L2CAP header) */
1048         frag = &skb_shinfo(skb)->frag_list;
1049         while (len) {
1050                 count = MIN(conn->mtu, len);
1051
1052                 *frag = bluez_skb_send_alloc(sk, count, msg->msg_flags & MSG_DONTWAIT, &err);
1053                 if (!*frag)
1054                         goto fail;
1055
1056                 if (memcpy_fromiovec(skb_put(*frag, count), msg->msg_iov, count)) {
1057                         err = -EFAULT;
1058                         goto fail;
1059                 }
1060
1061                 sent += count;
1062                 len  -= count;
1063
1064                 frag = &(*frag)->next;
1065         }
1066
1067         if ((err = hci_send_acl(conn->hcon, skb, 0)) < 0)
1068                 goto fail;
1069
1070         return sent;
1071
1072 fail:
1073         kfree_skb(skb);
1074         return err;
1075 }
1076
1077 /* --------- L2CAP signalling commands --------- */
1078 static inline __u8 l2cap_get_ident(struct l2cap_conn *conn)
1079 {
1080         __u8 id;
1081
1082         /* Get next available identificator.
1083          *    1 - 199 are used by kernel.
1084          *  200 - 254 are used by utilities like l2ping, etc
1085          */
1086
1087         spin_lock(&conn->lock);
1088
1089         if (++conn->tx_ident > 199)
1090                 conn->tx_ident = 1;
1091
1092         id = conn->tx_ident;
1093
1094         spin_unlock(&conn->lock);
1095
1096         return id;
1097 }
1098
1099 static struct sk_buff *l2cap_build_cmd(struct l2cap_conn *conn,
1100                                 __u8 code, __u8 ident, __u16 dlen, void *data)
1101 {
1102         struct sk_buff *skb, **frag;
1103         l2cap_cmd_hdr *cmd;
1104         l2cap_hdr *lh;
1105         int len, count;
1106
1107         BT_DBG("conn %p, code 0x%2.2x, ident 0x%2.2x, len %d", conn, code, ident, dlen);
1108
1109         len = L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE + dlen;
1110         count = MIN(conn->mtu, len);
1111
1112         skb = bluez_skb_alloc(count, GFP_ATOMIC);
1113         if (!skb)
1114                 return NULL;
1115
1116         lh = (l2cap_hdr *) skb_put(skb, L2CAP_HDR_SIZE);
1117         lh->len = __cpu_to_le16(L2CAP_CMD_HDR_SIZE + dlen);
1118         lh->cid = __cpu_to_le16(0x0001);
1119
1120         cmd = (l2cap_cmd_hdr *) skb_put(skb, L2CAP_CMD_HDR_SIZE);
1121         cmd->code  = code;
1122         cmd->ident = ident;
1123         cmd->len   = __cpu_to_le16(dlen);
1124
1125         if (dlen) {
1126                 count -= L2CAP_HDR_SIZE + L2CAP_CMD_HDR_SIZE;
1127                 memcpy(skb_put(skb, count), data, count);
1128                 data += count;
1129         }
1130
1131         len -= skb->len;
1132
1133         /* Continuation fragments (no L2CAP header) */
1134         frag = &skb_shinfo(skb)->frag_list;
1135         while (len) {
1136                 count = MIN(conn->mtu, len);
1137
1138                 *frag = bluez_skb_alloc(count, GFP_ATOMIC);
1139                 if (!*frag)
1140                         goto fail;
1141
1142                 memcpy(skb_put(*frag, count), data, count);
1143
1144                 len  -= count;
1145                 data += count;
1146
1147                 frag = &(*frag)->next;
1148         }
1149
1150         return skb;
1151
1152 fail:
1153         kfree_skb(skb);
1154         return NULL;
1155 }
1156
1157 static int l2cap_send_req(struct l2cap_conn *conn, __u8 code, __u16 len, void *data)
1158 {
1159         __u8 ident = l2cap_get_ident(conn);
1160         struct sk_buff *skb = l2cap_build_cmd(conn, code, ident, len, data);
1161
1162         BT_DBG("code 0x%2.2x", code);
1163
1164         if (!skb)
1165                 return -ENOMEM;
1166         return hci_send_acl(conn->hcon, skb, 0);
1167 }
1168
1169 static int l2cap_send_rsp(struct l2cap_conn *conn, __u8 ident, __u8 code, __u16 len, void *data)
1170 {
1171         struct sk_buff *skb = l2cap_build_cmd(conn, code, ident, len, data);
1172
1173         BT_DBG("code 0x%2.2x", code);
1174
1175         if (!skb)
1176                 return -ENOMEM;
1177         return hci_send_acl(conn->hcon, skb, 0);
1178 }
1179
1180 static inline int l2cap_get_conf_opt(void **ptr, int *type, int *olen, unsigned long *val)
1181 {
1182         l2cap_conf_opt *opt = *ptr;
1183         int len;
1184
1185         len = L2CAP_CONF_OPT_SIZE + opt->len;
1186         *ptr += len;
1187
1188         *type = opt->type;
1189         *olen = opt->len;
1190
1191         switch (opt->len) {
1192         case 1:
1193                 *val = *((__u8 *) opt->val);
1194                 break;
1195
1196         case 2:
1197                 *val = __le16_to_cpu(*((__u16 *)opt->val));
1198                 break;
1199
1200         case 4:
1201                 *val = __le32_to_cpu(*((__u32 *)opt->val));
1202                 break;
1203
1204         default:
1205                 *val = (unsigned long) opt->val;
1206                 break;
1207         };
1208
1209         BT_DBG("type 0x%2.2x len %d val 0x%lx", *type, opt->len, *val);
1210         return len;
1211 }
1212
1213 static inline void l2cap_parse_conf_req(struct sock *sk, void *data, int len)
1214 {
1215         int type, hint, olen;
1216         unsigned long val;
1217         void *ptr = data;
1218
1219         BT_DBG("sk %p len %d", sk, len);
1220
1221         while (len >= L2CAP_CONF_OPT_SIZE) {
1222                 len -= l2cap_get_conf_opt(&ptr, &type, &olen, &val);
1223
1224                 hint  = type & 0x80;
1225                 type &= 0x7f;
1226
1227                 switch (type) {
1228                 case L2CAP_CONF_MTU:
1229                         l2cap_pi(sk)->conf_mtu = val;
1230                         break;
1231
1232                 case L2CAP_CONF_FLUSH_TO:
1233                         l2cap_pi(sk)->flush_to = val;
1234                         break;
1235
1236                 case L2CAP_CONF_QOS:
1237                         break;
1238
1239                 default:
1240                         if (hint)
1241                                 break;
1242
1243                         /* FIXME: Reject unknown option */
1244                         break;
1245                 };
1246         }
1247 }
1248
1249 static void l2cap_add_conf_opt(void **ptr, __u8 type, __u8 len, unsigned long val)
1250 {
1251         register l2cap_conf_opt *opt = *ptr;
1252
1253         BT_DBG("type 0x%2.2x len %d val 0x%lx", type, len, val);
1254
1255         opt->type = type;
1256         opt->len  = len;
1257
1258         switch (len) {
1259         case 1:
1260                 *((__u8 *) opt->val)  = val;
1261                 break;
1262
1263         case 2:
1264                 *((__u16 *) opt->val) = __cpu_to_le16(val);
1265                 break;
1266
1267         case 4:
1268                 *((__u32 *) opt->val) = __cpu_to_le32(val);
1269                 break;
1270
1271         default:
1272                 memcpy(opt->val, (void *) val, len);
1273                 break;
1274         };
1275
1276         *ptr += L2CAP_CONF_OPT_SIZE + len;
1277 }
1278
1279 static int l2cap_build_conf_req(struct sock *sk, void *data)
1280 {
1281         struct l2cap_pinfo *pi = l2cap_pi(sk);
1282         l2cap_conf_req *req = (l2cap_conf_req *) data;
1283         void *ptr = req->data;
1284
1285         BT_DBG("sk %p", sk);
1286
1287         if (pi->imtu != L2CAP_DEFAULT_MTU)
1288                 l2cap_add_conf_opt(&ptr, L2CAP_CONF_MTU, 2, pi->imtu);
1289
1290         /* FIXME. Need actual value of the flush timeout */
1291         //if (flush_to != L2CAP_DEFAULT_FLUSH_TO)
1292         //   l2cap_add_conf_opt(&ptr, L2CAP_CONF_FLUSH_TO, 2, pi->flush_to);
1293
1294         req->dcid  = __cpu_to_le16(pi->dcid);
1295         req->flags = __cpu_to_le16(0);
1296
1297         return ptr - data;
1298 }
1299
1300 static inline int l2cap_conf_output(struct sock *sk, void **ptr)
1301 {
1302         struct l2cap_pinfo *pi = l2cap_pi(sk);
1303         int result = 0;
1304
1305         /* Configure output options and let the other side know
1306          * which ones we don't like.
1307          */
1308         if (pi->conf_mtu < pi->omtu) {
1309                 l2cap_add_conf_opt(ptr, L2CAP_CONF_MTU, 2, pi->omtu);
1310                 result = L2CAP_CONF_UNACCEPT;
1311         } else {
1312                 pi->omtu = pi->conf_mtu;
1313         }
1314
1315         BT_DBG("sk %p result %d", sk, result);
1316         return result;
1317 }
1318
1319 static int l2cap_build_conf_rsp(struct sock *sk, void *data, int *result)
1320 {
1321         l2cap_conf_rsp *rsp = (l2cap_conf_rsp *) data;
1322         void *ptr = rsp->data;
1323
1324         BT_DBG("sk %p complete %d", sk, result ? 1 : 0);
1325
1326         if (result)
1327                 *result = l2cap_conf_output(sk, &ptr);
1328
1329         rsp->scid   = __cpu_to_le16(l2cap_pi(sk)->dcid);
1330         rsp->result = __cpu_to_le16(result ? *result : 0);
1331         rsp->flags  = __cpu_to_le16(0);
1332
1333         return ptr - data;
1334 }
1335
1336 static inline int l2cap_connect_req(struct l2cap_conn *conn, l2cap_cmd_hdr *cmd, __u8 *data)
1337 {
1338         struct l2cap_chan_list *list = &conn->chan_list;
1339         l2cap_conn_req *req = (l2cap_conn_req *) data;
1340         l2cap_conn_rsp rsp;
1341         struct sock *sk, *parent;
1342         int result = 0, status = 0;
1343
1344         __u16 dcid = 0, scid = __le16_to_cpu(req->scid);
1345         __u16 psm  = req->psm;
1346
1347         BT_DBG("psm 0x%2.2x scid 0x%4.4x", psm, scid);
1348
1349         /* Check if we have socket listening on psm */
1350         parent = l2cap_get_sock_by_psm(BT_LISTEN, psm, conn->src);
1351         if (!parent) {
1352                 result = L2CAP_CR_BAD_PSM;
1353                 goto sendresp;
1354         }
1355
1356         result = L2CAP_CR_NO_MEM;
1357
1358         /* Check for backlog size */
1359         if (parent->ack_backlog > parent->max_ack_backlog) {
1360                 BT_DBG("backlog full %d", parent->ack_backlog);
1361                 goto response;
1362         }
1363
1364         sk = l2cap_sock_alloc(NULL, BTPROTO_L2CAP, GFP_ATOMIC);
1365         if (!sk)
1366                 goto response;
1367
1368         write_lock(&list->lock);
1369
1370         /* Check if we already have channel with that dcid */
1371         if (__l2cap_get_chan_by_dcid(list, scid)) {
1372                 write_unlock(&list->lock);
1373                 sk->zapped = 1;
1374                 l2cap_sock_kill(sk);
1375                 goto response;
1376         }
1377
1378         hci_conn_hold(conn->hcon);
1379
1380         l2cap_sock_init(sk, parent);
1381         bacpy(&bluez_pi(sk)->src, conn->src);
1382         bacpy(&bluez_pi(sk)->dst, conn->dst);
1383         l2cap_pi(sk)->psm  = psm;
1384         l2cap_pi(sk)->dcid = scid;
1385
1386         __l2cap_chan_add(conn, sk, parent);
1387         dcid = l2cap_pi(sk)->scid;
1388
1389         l2cap_sock_set_timer(sk, sk->sndtimeo);
1390
1391         /* Service level security */
1392         result = L2CAP_CR_PEND;
1393         status = L2CAP_CS_AUTHEN_PEND;
1394         sk->state = BT_CONNECT2;
1395         l2cap_pi(sk)->ident = cmd->ident;
1396
1397         if (l2cap_pi(sk)->link_mode & L2CAP_LM_ENCRYPT) {
1398                 if (!hci_conn_encrypt(conn->hcon))
1399                         goto done;
1400         } else if (l2cap_pi(sk)->link_mode & L2CAP_LM_AUTH) {
1401                 if (!hci_conn_auth(conn->hcon))
1402                         goto done;
1403         }
1404
1405         sk->state = BT_CONFIG;
1406         result = status = 0;
1407
1408 done:
1409         write_unlock(&list->lock);
1410
1411 response:
1412         bh_unlock_sock(parent);
1413
1414 sendresp:
1415         rsp.scid   = __cpu_to_le16(scid);
1416         rsp.dcid   = __cpu_to_le16(dcid);
1417         rsp.result = __cpu_to_le16(result);
1418         rsp.status = __cpu_to_le16(status);
1419         l2cap_send_rsp(conn, cmd->ident, L2CAP_CONN_RSP, L2CAP_CONN_RSP_SIZE, &rsp);
1420         return 0;
1421 }
1422
1423 static inline int l2cap_connect_rsp(struct l2cap_conn *conn, l2cap_cmd_hdr *cmd, __u8 *data)
1424 {
1425         l2cap_conn_rsp *rsp = (l2cap_conn_rsp *) data;
1426         __u16 scid, dcid, result, status;
1427         struct sock *sk;
1428         char req[128];
1429
1430         scid   = __le16_to_cpu(rsp->scid);
1431         dcid   = __le16_to_cpu(rsp->dcid);
1432         result = __le16_to_cpu(rsp->result);
1433         status = __le16_to_cpu(rsp->status);
1434
1435         BT_DBG("dcid 0x%4.4x scid 0x%4.4x result 0x%2.2x status 0x%2.2x", dcid, scid, result, status);
1436
1437         if (!(sk = l2cap_get_chan_by_scid(&conn->chan_list, scid)))
1438                 return -ENOENT;
1439
1440         switch (result) {
1441         case L2CAP_CR_SUCCESS:
1442                 sk->state = BT_CONFIG;
1443                 l2cap_pi(sk)->dcid = dcid;
1444                 l2cap_pi(sk)->conf_state |= CONF_REQ_SENT;
1445
1446                 l2cap_send_req(conn, L2CAP_CONF_REQ, l2cap_build_conf_req(sk, req), req);
1447                 break;
1448
1449         case L2CAP_CR_PEND:
1450                 break;
1451
1452         default:
1453                 l2cap_chan_del(sk, ECONNREFUSED);
1454                 break;
1455         }
1456
1457         bh_unlock_sock(sk);
1458         return 0;
1459 }
1460
1461 static inline int l2cap_config_req(struct l2cap_conn *conn, l2cap_cmd_hdr *cmd, __u8 *data)
1462 {
1463         l2cap_conf_req * req = (l2cap_conf_req *) data;
1464         __u16 dcid, flags;
1465         __u8 rsp[64];
1466         struct sock *sk;
1467         int result;
1468
1469         dcid  = __le16_to_cpu(req->dcid);
1470         flags = __le16_to_cpu(req->flags);
1471
1472         BT_DBG("dcid 0x%4.4x flags 0x%2.2x", dcid, flags);
1473
1474         if (!(sk = l2cap_get_chan_by_scid(&conn->chan_list, dcid)))
1475                 return -ENOENT;
1476
1477         l2cap_parse_conf_req(sk, req->data, cmd->len - L2CAP_CONF_REQ_SIZE);
1478
1479         if (flags & 0x01) {
1480                 /* Incomplete config. Send empty response. */
1481                 l2cap_send_rsp(conn, cmd->ident, L2CAP_CONF_RSP, l2cap_build_conf_rsp(sk, rsp, NULL), rsp);
1482                 goto unlock;
1483         }
1484
1485         /* Complete config. */
1486         l2cap_send_rsp(conn, cmd->ident, L2CAP_CONF_RSP, l2cap_build_conf_rsp(sk, rsp, &result), rsp);
1487
1488         if (result)
1489                 goto unlock;
1490
1491         /* Output config done */
1492         l2cap_pi(sk)->conf_state |= CONF_OUTPUT_DONE;
1493
1494         if (l2cap_pi(sk)->conf_state & CONF_INPUT_DONE) {
1495                 sk->state = BT_CONNECTED;
1496                 l2cap_chan_ready(sk);
1497         } else if (!(l2cap_pi(sk)->conf_state & CONF_REQ_SENT)) {
1498                 char req[64];
1499                 l2cap_send_req(conn, L2CAP_CONF_REQ, l2cap_build_conf_req(sk, req), req);
1500         }
1501
1502 unlock:
1503         bh_unlock_sock(sk);
1504         return 0;
1505 }
1506
1507 static inline int l2cap_config_rsp(struct l2cap_conn *conn, l2cap_cmd_hdr *cmd, __u8 *data)
1508 {
1509         l2cap_conf_rsp *rsp = (l2cap_conf_rsp *)data;
1510         __u16 scid, flags, result;
1511         struct sock *sk;
1512         int err = 0;
1513
1514         scid   = __le16_to_cpu(rsp->scid);
1515         flags  = __le16_to_cpu(rsp->flags);
1516         result = __le16_to_cpu(rsp->result);
1517
1518         BT_DBG("scid 0x%4.4x flags 0x%2.2x result 0x%2.2x", scid, flags, result);
1519
1520         if (!(sk = l2cap_get_chan_by_scid(&conn->chan_list, scid)))
1521                 return -ENOENT;
1522
1523         if (result) {
1524                 l2cap_disconn_req req;
1525
1526                 /* They didn't like our options. Well... we do not negotiate.
1527                  * Close channel.
1528                  */
1529                 sk->state = BT_DISCONN;
1530                 l2cap_sock_set_timer(sk, HZ * 5);
1531
1532                 req.dcid = __cpu_to_le16(l2cap_pi(sk)->dcid);
1533                 req.scid = __cpu_to_le16(l2cap_pi(sk)->scid);
1534                 l2cap_send_req(conn, L2CAP_DISCONN_REQ, L2CAP_DISCONN_REQ_SIZE, &req);
1535                 goto done;
1536         }
1537
1538         if (flags & 0x01)
1539                 goto done;
1540
1541         /* Input config done */
1542         l2cap_pi(sk)->conf_state |= CONF_INPUT_DONE;
1543
1544         if (l2cap_pi(sk)->conf_state & CONF_OUTPUT_DONE) {
1545                 sk->state = BT_CONNECTED;
1546                 l2cap_chan_ready(sk);
1547         }
1548
1549 done:
1550         bh_unlock_sock(sk);
1551         return err;
1552 }
1553
1554 static inline int l2cap_disconnect_req(struct l2cap_conn *conn, l2cap_cmd_hdr *cmd, __u8 *data)
1555 {
1556         l2cap_disconn_req *req = (l2cap_disconn_req *) data;
1557         l2cap_disconn_rsp rsp;
1558         __u16 dcid, scid;
1559         struct sock *sk;
1560
1561         scid = __le16_to_cpu(req->scid);
1562         dcid = __le16_to_cpu(req->dcid);
1563
1564         BT_DBG("scid 0x%4.4x dcid 0x%4.4x", scid, dcid);
1565
1566         if (!(sk = l2cap_get_chan_by_scid(&conn->chan_list, dcid)))
1567                 return 0;
1568
1569         rsp.dcid = __cpu_to_le16(l2cap_pi(sk)->scid);
1570         rsp.scid = __cpu_to_le16(l2cap_pi(sk)->dcid);
1571         l2cap_send_rsp(conn, cmd->ident, L2CAP_DISCONN_RSP, L2CAP_DISCONN_RSP_SIZE, &rsp);
1572
1573         sk->shutdown = SHUTDOWN_MASK;
1574
1575         l2cap_chan_del(sk, ECONNRESET);
1576         bh_unlock_sock(sk);
1577
1578         l2cap_sock_kill(sk);
1579         return 0;
1580 }
1581
1582 static inline int l2cap_disconnect_rsp(struct l2cap_conn *conn, l2cap_cmd_hdr *cmd, __u8 *data)
1583 {
1584         l2cap_disconn_rsp *rsp = (l2cap_disconn_rsp *) data;
1585         __u16 dcid, scid;
1586         struct sock *sk;
1587
1588         scid = __le16_to_cpu(rsp->scid);
1589         dcid = __le16_to_cpu(rsp->dcid);
1590
1591         BT_DBG("dcid 0x%4.4x scid 0x%4.4x", dcid, scid);
1592
1593         if (!(sk = l2cap_get_chan_by_scid(&conn->chan_list, scid)))
1594                 return 0;
1595         l2cap_chan_del(sk, ECONNABORTED);
1596         bh_unlock_sock(sk);
1597
1598         l2cap_sock_kill(sk);
1599         return 0;
1600 }
1601
1602 static inline void l2cap_sig_channel(struct l2cap_conn *conn, struct sk_buff *skb)
1603 {
1604         __u8 *data = skb->data;
1605         int len = skb->len;
1606         l2cap_cmd_hdr cmd;
1607         int err = 0;
1608
1609         while (len >= L2CAP_CMD_HDR_SIZE) {
1610                 memcpy(&cmd, data, L2CAP_CMD_HDR_SIZE);
1611                 data += L2CAP_CMD_HDR_SIZE;
1612                 len  -= L2CAP_CMD_HDR_SIZE;
1613
1614                 cmd.len = __le16_to_cpu(cmd.len);
1615
1616                 BT_DBG("code 0x%2.2x len %d id 0x%2.2x", cmd.code, cmd.len, cmd.ident);
1617
1618                 if (cmd.len > len || !cmd.ident) {
1619                         BT_DBG("corrupted command");
1620                         break;
1621                 }
1622
1623                 switch (cmd.code) {
1624                 case L2CAP_CONN_REQ:
1625                         err = l2cap_connect_req(conn, &cmd, data);
1626                         break;
1627
1628                 case L2CAP_CONN_RSP:
1629                         err = l2cap_connect_rsp(conn, &cmd, data);
1630                         break;
1631
1632                 case L2CAP_CONF_REQ:
1633                         err = l2cap_config_req(conn, &cmd, data);
1634                         break;
1635
1636                 case L2CAP_CONF_RSP:
1637                         err = l2cap_config_rsp(conn, &cmd, data);
1638                         break;
1639
1640                 case L2CAP_DISCONN_REQ:
1641                         err = l2cap_disconnect_req(conn, &cmd, data);
1642                         break;
1643
1644                 case L2CAP_DISCONN_RSP:
1645                         err = l2cap_disconnect_rsp(conn, &cmd, data);
1646                         break;
1647
1648                 case L2CAP_COMMAND_REJ:
1649                         /* FIXME: We should process this */
1650                         l2cap_raw_recv(conn, skb);
1651                         break;
1652
1653                 case L2CAP_ECHO_REQ:
1654                         l2cap_send_rsp(conn, cmd.ident, L2CAP_ECHO_RSP, cmd.len, data);
1655                         break;
1656
1657                 case L2CAP_ECHO_RSP:
1658                 case L2CAP_INFO_REQ:
1659                 case L2CAP_INFO_RSP:
1660                         l2cap_raw_recv(conn, skb);
1661                         break;
1662
1663                 default:
1664                         BT_ERR("Uknown signaling command 0x%2.2x", cmd.code);
1665                         err = -EINVAL;
1666                         break;
1667                 };
1668
1669                 if (err) {
1670                         l2cap_cmd_rej rej;
1671                         BT_DBG("error %d", err);
1672
1673                         /* FIXME: Map err to a valid reason. */
1674                         rej.reason = __cpu_to_le16(0);
1675                         l2cap_send_rsp(conn, cmd.ident, L2CAP_COMMAND_REJ, L2CAP_CMD_REJ_SIZE, &rej);
1676                 }
1677
1678                 data += cmd.len;
1679                 len  -= cmd.len;
1680         }
1681
1682         kfree_skb(skb);
1683 }
1684
1685 static inline int l2cap_data_channel(struct l2cap_conn *conn, __u16 cid, struct sk_buff *skb)
1686 {
1687         struct sock *sk;
1688
1689         sk = l2cap_get_chan_by_scid(&conn->chan_list, cid);
1690         if (!sk) {
1691                 BT_DBG("unknown cid 0x%4.4x", cid);
1692                 goto drop;
1693         }
1694
1695         BT_DBG("sk %p, len %d", sk, skb->len);
1696
1697         if (sk->state != BT_CONNECTED)
1698                 goto drop;
1699
1700         if (l2cap_pi(sk)->imtu < skb->len)
1701                 goto drop;
1702
1703         /* If socket recv buffers overflows we drop data here
1704          * which is *bad* because L2CAP has to be reliable.
1705          * But we don't have any other choice. L2CAP doesn't
1706          * provide flow control mechanism */
1707
1708         if (!sock_queue_rcv_skb(sk, skb))
1709                 goto done;
1710
1711 drop:
1712         kfree_skb(skb);
1713
1714 done:
1715         if (sk) bh_unlock_sock(sk);
1716         return 0;
1717 }
1718
1719 static inline int l2cap_conless_channel(struct l2cap_conn *conn, __u16 psm, struct sk_buff *skb)
1720 {
1721         struct sock *sk;
1722
1723         sk = l2cap_get_sock_by_psm(0, psm, conn->src);
1724         if (!sk)
1725                 goto drop;
1726
1727         BT_DBG("sk %p, len %d", sk, skb->len);
1728
1729         if (sk->state != BT_BOUND && sk->state != BT_CONNECTED)
1730                 goto drop;
1731
1732         if (l2cap_pi(sk)->imtu < skb->len)
1733                 goto drop;
1734
1735         if (!sock_queue_rcv_skb(sk, skb))
1736                 goto done;
1737
1738 drop:
1739         kfree_skb(skb);
1740
1741 done:
1742         if (sk) bh_unlock_sock(sk);
1743         return 0;
1744 }
1745
1746 static void l2cap_recv_frame(struct l2cap_conn *conn, struct sk_buff *skb)
1747 {
1748         l2cap_hdr *lh = (l2cap_hdr *) skb->data;
1749         __u16 cid, psm, len;
1750
1751         skb_pull(skb, L2CAP_HDR_SIZE);
1752         cid = __le16_to_cpu(lh->cid);
1753         len = __le16_to_cpu(lh->len);
1754
1755         BT_DBG("len %d, cid 0x%4.4x", len, cid);
1756
1757         switch (cid) {
1758         case 0x0001:
1759                 l2cap_sig_channel(conn, skb);
1760                 break;
1761
1762         case 0x0002:
1763                 psm = get_unaligned((__u16 *) skb->data);
1764                 skb_pull(skb, 2);
1765                 l2cap_conless_channel(conn, psm, skb);
1766                 break;
1767
1768         default:
1769                 l2cap_data_channel(conn, cid, skb);
1770                 break;
1771         }
1772 }
1773
1774 /* ------------ L2CAP interface with lower layer (HCI) ------------- */
1775
1776 static int l2cap_connect_ind(struct hci_dev *hdev, bdaddr_t *bdaddr, __u8 type)
1777 {
1778         int exact = 0, lm1 = 0, lm2 = 0;
1779         register struct sock *sk;
1780
1781         if (type != ACL_LINK)
1782                 return 0;
1783
1784         BT_DBG("hdev %s, bdaddr %s", hdev->name, batostr(bdaddr));
1785
1786         /* Find listening sockets and check their link_mode */
1787         read_lock(&l2cap_sk_list.lock);
1788         for (sk = l2cap_sk_list.head; sk; sk = sk->next) {
1789                 if (sk->state != BT_LISTEN)
1790                         continue;
1791
1792                 if (!bacmp(&bluez_pi(sk)->src, bdaddr)) {
1793                         lm1 |= (HCI_LM_ACCEPT | l2cap_pi(sk)->link_mode);
1794                         exact++;
1795                 } else if (!bacmp(&bluez_pi(sk)->src, BDADDR_ANY))
1796                         lm2 |= (HCI_LM_ACCEPT | l2cap_pi(sk)->link_mode);
1797         }
1798         read_unlock(&l2cap_sk_list.lock);
1799
1800         return exact ? lm1 : lm2;
1801 }
1802
1803 static int l2cap_connect_cfm(struct hci_conn *hcon, __u8 status)
1804 {
1805         BT_DBG("hcon %p bdaddr %s status %d", hcon, batostr(&hcon->dst), status);
1806
1807         if (hcon->type != ACL_LINK)
1808                 return 0;
1809
1810         if (!status) {
1811                 struct l2cap_conn *conn;
1812
1813                 conn = l2cap_conn_add(hcon, status);
1814                 if (conn)
1815                         l2cap_conn_ready(conn);
1816         } else
1817                 l2cap_conn_del(hcon, bterr(status));
1818
1819         return 0;
1820 }
1821
1822 static int l2cap_disconn_ind(struct hci_conn *hcon, __u8 reason)
1823 {
1824         BT_DBG("hcon %p reason %d", hcon, reason);
1825
1826         if (hcon->type != ACL_LINK)
1827                 return 0;
1828
1829         l2cap_conn_del(hcon, bterr(reason));
1830         return 0;
1831 }
1832
1833 static int l2cap_auth_cfm(struct hci_conn *hcon, __u8 status)
1834 {
1835         struct l2cap_chan_list *l;
1836         struct l2cap_conn *conn;
1837         l2cap_conn_rsp rsp;
1838         struct sock *sk;
1839         int result;
1840
1841         if (!(conn = hcon->l2cap_data))
1842                 return 0;
1843         l = &conn->chan_list;
1844
1845         BT_DBG("conn %p", conn);
1846
1847         read_lock(&l->lock);
1848
1849         for (sk = l->head; sk; sk = l2cap_pi(sk)->next_c) {
1850                 bh_lock_sock(sk);
1851
1852                 if (sk->state != BT_CONNECT2 ||
1853                                 (l2cap_pi(sk)->link_mode & L2CAP_LM_ENCRYPT)) {
1854                         bh_unlock_sock(sk);
1855                         continue;
1856                 }
1857
1858                 if (!status) {
1859                         sk->state = BT_CONFIG;
1860                         result = 0;
1861                 } else {
1862                         sk->state = BT_DISCONN;
1863                         l2cap_sock_set_timer(sk, HZ/10);
1864                         result = L2CAP_CR_SEC_BLOCK;
1865                 }
1866
1867                 rsp.scid   = __cpu_to_le16(l2cap_pi(sk)->dcid);
1868                 rsp.dcid   = __cpu_to_le16(l2cap_pi(sk)->scid);
1869                 rsp.result = __cpu_to_le16(result);
1870                 rsp.status = __cpu_to_le16(0);
1871                 l2cap_send_rsp(conn, l2cap_pi(sk)->ident, L2CAP_CONN_RSP,
1872                         L2CAP_CONN_RSP_SIZE, &rsp);
1873
1874                 bh_unlock_sock(sk);
1875         }
1876
1877         read_unlock(&l->lock);
1878         return 0;
1879 }
1880
1881 static int l2cap_encrypt_cfm(struct hci_conn *hcon, __u8 status)
1882 {
1883         struct l2cap_chan_list *l;
1884         struct l2cap_conn *conn;
1885         l2cap_conn_rsp rsp;
1886         struct sock *sk;
1887         int result;
1888
1889         if (!(conn = hcon->l2cap_data))
1890                 return 0;
1891         l = &conn->chan_list;
1892
1893         BT_DBG("conn %p", conn);
1894
1895         read_lock(&l->lock);
1896
1897         for (sk = l->head; sk; sk = l2cap_pi(sk)->next_c) {
1898                 bh_lock_sock(sk);
1899
1900                 if (sk->state != BT_CONNECT2) {
1901                         bh_unlock_sock(sk);
1902                         continue;
1903                 }
1904
1905                 if (!status) {
1906                         sk->state = BT_CONFIG;
1907                         result = 0;
1908                 } else {
1909                         sk->state = BT_DISCONN;
1910                         l2cap_sock_set_timer(sk, HZ/10);
1911                         result = L2CAP_CR_SEC_BLOCK;
1912                 }
1913
1914                 rsp.scid   = __cpu_to_le16(l2cap_pi(sk)->dcid);
1915                 rsp.dcid   = __cpu_to_le16(l2cap_pi(sk)->scid);
1916                 rsp.result = __cpu_to_le16(result);
1917                 rsp.status = __cpu_to_le16(0);
1918                 l2cap_send_rsp(conn, l2cap_pi(sk)->ident, L2CAP_CONN_RSP,
1919                         L2CAP_CONN_RSP_SIZE, &rsp);
1920
1921                 bh_unlock_sock(sk);
1922         }
1923
1924         read_unlock(&l->lock);
1925         return 0;
1926 }
1927
1928 static int l2cap_recv_acldata(struct hci_conn *hcon, struct sk_buff *skb, __u16 flags)
1929 {
1930         struct l2cap_conn *conn = hcon->l2cap_data;
1931
1932         if (!conn && !(conn = l2cap_conn_add(hcon, 0)))
1933                 goto drop;
1934
1935         BT_DBG("conn %p len %d flags 0x%x", conn, skb->len, flags);
1936
1937         if (flags & ACL_START) {
1938                 l2cap_hdr *hdr;
1939                 int len;
1940
1941                 if (conn->rx_len) {
1942                         BT_ERR("Unexpected start frame (len %d)", skb->len);
1943                         kfree_skb(conn->rx_skb);
1944                         conn->rx_skb = NULL;
1945                         conn->rx_len = 0;
1946                 }
1947
1948                 if (skb->len < 2) {
1949                         BT_ERR("Frame is too small (len %d)", skb->len);
1950                         goto drop;
1951                 }
1952
1953                 hdr = (l2cap_hdr *) skb->data;
1954                 len = __le16_to_cpu(hdr->len) + L2CAP_HDR_SIZE;
1955
1956                 BT_DBG("Start: total len %d, frag len %d", len, skb->len);
1957
1958                 if (len == skb->len) {
1959                         /* Complete frame received */
1960                         l2cap_recv_frame(conn, skb);
1961                         return 0;
1962                 }
1963
1964                 /* Allocate skb for the complete frame (with header) */
1965                 if (!(conn->rx_skb = bluez_skb_alloc(len, GFP_ATOMIC)))
1966                         goto drop;
1967
1968                 memcpy(skb_put(conn->rx_skb, skb->len), skb->data, skb->len);
1969                 conn->rx_len = len - skb->len;
1970         } else {
1971                 BT_DBG("Cont: frag len %d (expecting %d)", skb->len, conn->rx_len);
1972
1973                 if (!conn->rx_len) {
1974                         BT_ERR("Unexpected continuation frame (len %d)", skb->len);
1975                         goto drop;
1976                 }
1977
1978                 if (skb->len > conn->rx_len) {
1979                         BT_ERR("Fragment is too large (len %d, expect %d)",
1980                                         skb->len, conn->rx_len);
1981                         kfree_skb(conn->rx_skb);
1982                         conn->rx_skb = NULL;
1983                         conn->rx_len = 0;
1984                         goto drop;
1985                 }
1986
1987                 memcpy(skb_put(conn->rx_skb, skb->len), skb->data, skb->len);
1988                 conn->rx_len -= skb->len;
1989
1990                 if (!conn->rx_len) {
1991                         /* Complete frame received */
1992                         l2cap_recv_frame(conn, conn->rx_skb);
1993                         conn->rx_skb = NULL;
1994                 }
1995         }
1996
1997 drop:
1998         kfree_skb(skb);
1999         return 0;
2000 }
2001
2002 /* ----- Proc fs support ------ */
2003 static int l2cap_sock_dump(char *buf, struct bluez_sock_list *list)
2004 {
2005         struct l2cap_pinfo *pi;
2006         struct sock *sk;
2007         char *ptr = buf;
2008
2009         read_lock_bh(&list->lock);
2010
2011         for (sk = list->head; sk; sk = sk->next) {
2012                 pi = l2cap_pi(sk);
2013                 ptr += sprintf(ptr, "%s %s %d %d 0x%4.4x 0x%4.4x %d %d 0x%x\n",
2014                                 batostr(&bluez_pi(sk)->src), batostr(&bluez_pi(sk)->dst),
2015                                 sk->state, pi->psm, pi->scid, pi->dcid, pi->imtu, pi->omtu,
2016                                 pi->link_mode);
2017         }
2018
2019         read_unlock_bh(&list->lock);
2020
2021         ptr += sprintf(ptr, "\n");
2022         return ptr - buf;
2023 }
2024
2025 static int l2cap_read_proc(char *buf, char **start, off_t offset, int count, int *eof, void *priv)
2026 {
2027         char *ptr = buf;
2028         int len;
2029
2030         BT_DBG("count %d, offset %ld", count, offset);
2031
2032         ptr += l2cap_sock_dump(ptr, &l2cap_sk_list);
2033         len  = ptr - buf;
2034
2035         if (len <= count + offset)
2036                 *eof = 1;
2037
2038         *start = buf + offset;
2039         len -= offset;
2040
2041         if (len > count)
2042                 len = count;
2043         if (len < 0)
2044                 len = 0;
2045
2046         return len;
2047 }
2048
2049 static struct proto_ops l2cap_sock_ops = {
2050         family:         PF_BLUETOOTH,
2051         release:        l2cap_sock_release,
2052         bind:           l2cap_sock_bind,
2053         connect:        l2cap_sock_connect,
2054         listen:         l2cap_sock_listen,
2055         accept:         l2cap_sock_accept,
2056         getname:        l2cap_sock_getname,
2057         sendmsg:        l2cap_sock_sendmsg,
2058         recvmsg:        bluez_sock_recvmsg,
2059         poll:           bluez_sock_poll,
2060         socketpair:     sock_no_socketpair,
2061         ioctl:          sock_no_ioctl,
2062         shutdown:       l2cap_sock_shutdown,
2063         setsockopt:     l2cap_sock_setsockopt,
2064         getsockopt:     l2cap_sock_getsockopt,
2065         mmap:           sock_no_mmap
2066 };
2067
2068 static struct net_proto_family l2cap_sock_family_ops = {
2069         family:         PF_BLUETOOTH,
2070         create:         l2cap_sock_create
2071 };
2072
2073 static struct hci_proto l2cap_hci_proto = {
2074         name:           "L2CAP",
2075         id:             HCI_PROTO_L2CAP,
2076         connect_ind:    l2cap_connect_ind,
2077         connect_cfm:    l2cap_connect_cfm,
2078         disconn_ind:    l2cap_disconn_ind,
2079         recv_acldata:   l2cap_recv_acldata,
2080         auth_cfm:       l2cap_auth_cfm,
2081         encrypt_cfm:    l2cap_encrypt_cfm
2082 };
2083
2084 int __init l2cap_init(void)
2085 {
2086         int err;
2087
2088         if ((err = bluez_sock_register(BTPROTO_L2CAP, &l2cap_sock_family_ops))) {
2089                 BT_ERR("Can't register L2CAP socket");
2090                 return err;
2091         }
2092
2093         if ((err = hci_register_proto(&l2cap_hci_proto))) {
2094                 BT_ERR("Can't register L2CAP protocol");
2095                 return err;
2096         }
2097
2098         create_proc_read_entry("bluetooth/l2cap", 0, 0, l2cap_read_proc, NULL);
2099
2100         BT_INFO("BlueZ L2CAP ver %s Copyright (C) 2000,2001 Qualcomm Inc", VERSION);
2101         BT_INFO("Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>");
2102         return 0;
2103 }
2104
2105 void l2cap_cleanup(void)
2106 {
2107         remove_proc_entry("bluetooth/l2cap", NULL);
2108
2109         /* Unregister socket and protocol */
2110         if (bluez_sock_unregister(BTPROTO_L2CAP))
2111                 BT_ERR("Can't unregister L2CAP socket");
2112
2113         if (hci_unregister_proto(&l2cap_hci_proto))
2114                 BT_ERR("Can't unregister L2CAP protocol");
2115 }
2116
2117 module_init(l2cap_init);
2118 module_exit(l2cap_cleanup);
2119
2120 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>");
2121 MODULE_DESCRIPTION("BlueZ L2CAP ver " VERSION);
2122 MODULE_LICENSE("GPL");