net/bluetooth/af_bluetooth.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 /* Bluetooth address family and sockets. */
  26
  27 #include <linux/module.h>
  28 #include <linux/debugfs.h>
  29 #include <asm/ioctls.h>
  30
  31 #include <net/bluetooth/bluetooth.h>
  32 #include <linux/proc_fs.h>
  33
  34 #include "selftest.h"
  35
  36 #define VERSION "2.21"
  37
  38 /* Bluetooth sockets */
  39 #define BT_MAX_PROTO    8
  40 static const struct net_proto_family *bt_proto[BT_MAX_PROTO];
  41 static DEFINE_RWLOCK(bt_proto_lock);
  42
  43 static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
  44 static const char *const bt_key_strings[BT_MAX_PROTO] = {
  45         "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
  46         "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
  47         "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
  48         "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
  49         "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
  50         "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
  51         "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
  52         "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
  53 };
  54
  55 static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
  56 static const char *const bt_slock_key_strings[BT_MAX_PROTO] = {
  57         "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
  58         "slock-AF_BLUETOOTH-BTPROTO_HCI",
  59         "slock-AF_BLUETOOTH-BTPROTO_SCO",
  60         "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
  61         "slock-AF_BLUETOOTH-BTPROTO_BNEP",
  62         "slock-AF_BLUETOOTH-BTPROTO_CMTP",
  63         "slock-AF_BLUETOOTH-BTPROTO_HIDP",
  64         "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
  65 };
  66
  67 void bt_sock_reclassify_lock(struct sock *sk, int proto)
  68 {
  69         BUG_ON(!sk);
  70         BUG_ON(sock_owned_by_user(sk));
  71
  72         sock_lock_init_class_and_name(sk,
  73                         bt_slock_key_strings[proto], &bt_slock_key[proto],
  74                                 bt_key_strings[proto], &bt_lock_key[proto]);
  75 }
  76 EXPORT_SYMBOL(bt_sock_reclassify_lock);
  77
  78 int bt_sock_register(int proto, const struct net_proto_family *ops)
  79 {
  80         int err = 0;
  81
  82         if (proto < 0 || proto >= BT_MAX_PROTO)
  83                 return -EINVAL;
  84
  85         write_lock(&bt_proto_lock);
  86
  87         if (bt_proto[proto])
  88                 err = -EEXIST;
  89         else
  90                 bt_proto[proto] = ops;
  91
  92         write_unlock(&bt_proto_lock);
  93
  94         return err;
  95 }
  96 EXPORT_SYMBOL(bt_sock_register);
  97
  98 void bt_sock_unregister(int proto)
  99 {
 100         if (proto < 0 || proto >= BT_MAX_PROTO)
 101                 return;
 102
 103         write_lock(&bt_proto_lock);
 104         bt_proto[proto] = NULL;
 105         write_unlock(&bt_proto_lock);
 106 }
 107 EXPORT_SYMBOL(bt_sock_unregister);
 108
 109 #ifdef CONFIG_PARANOID_NETWORK
 110 static inline int current_has_bt_admin(void)
 111 {
 112         return !current_euid();
 113 }
 114
 115 static inline int current_has_bt(void)
 116 {
 117         return current_has_bt_admin();
 118 }
 119 # else
 120 static inline int current_has_bt_admin(void)
 121 {
 122         return 1;
 123 }
 124
 125 static inline int current_has_bt(void)
 126 {
 127         return 1;
 128 }
 129 #endif
 130
 131 static int bt_sock_create(struct net *net, struct socket *sock, int proto,
 132                           int kern)
 133 {
 134         int err;
 135
 136         if (proto == BTPROTO_RFCOMM || proto == BTPROTO_SCO ||
 137                         proto == BTPROTO_L2CAP) {
 138                 if (!current_has_bt())
 139                         return -EPERM;
 140         } else if (!current_has_bt_admin())
 141                 return -EPERM;
 142
 143         if (net != &init_net)
 144                 return -EAFNOSUPPORT;
 145
 146         if (proto < 0 || proto >= BT_MAX_PROTO)
 147                 return -EINVAL;
 148
 149         if (!bt_proto[proto])
 150                 request_module("bt-proto-%d", proto);
 151
 152         err = -EPROTONOSUPPORT;
 153
 154         read_lock(&bt_proto_lock);
 155
 156         if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
 157                 err = bt_proto[proto]->create(net, sock, proto, kern);
 158                 if (!err)
 159                         bt_sock_reclassify_lock(sock->sk, proto);
 160                 module_put(bt_proto[proto]->owner);
 161         }
 162
 163         read_unlock(&bt_proto_lock);
 164
 165         return err;
 166 }
 167
 168 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
 169 {
 170         write_lock(&l->lock);
 171         sk_add_node(sk, &l->head);
 172         write_unlock(&l->lock);
 173 }
 174 EXPORT_SYMBOL(bt_sock_link);
 175
 176 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
 177 {
 178         write_lock(&l->lock);
 179         sk_del_node_init(sk);
 180         write_unlock(&l->lock);
 181 }
 182 EXPORT_SYMBOL(bt_sock_unlink);
 183
 184 void bt_accept_enqueue(struct sock *parent, struct sock *sk)
 185 {
 186         BT_DBG("parent %p, sk %p", parent, sk);
 187
 188         sock_hold(sk);
 189         list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
 190         bt_sk(sk)->parent = parent;
 191         parent->sk_ack_backlog++;
 192 }
 193 EXPORT_SYMBOL(bt_accept_enqueue);
 194
 195 void bt_accept_unlink(struct sock *sk)
 196 {
 197         BT_DBG("sk %p state %d", sk, sk->sk_state);
 198
 199         list_del_init(&bt_sk(sk)->accept_q);
 200         bt_sk(sk)->parent->sk_ack_backlog--;
 201         bt_sk(sk)->parent = NULL;
 202         sock_put(sk);
 203 }
 204 EXPORT_SYMBOL(bt_accept_unlink);
 205
 206 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
 207 {
 208         struct list_head *p, *n;
 209         struct sock *sk;
 210
 211         BT_DBG("parent %p", parent);
 212
 213         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
 214                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
 215
 216                 lock_sock(sk);
 217
 218                 /* FIXME: Is this check still needed */
 219                 if (sk->sk_state == BT_CLOSED) {
 220                         release_sock(sk);
 221                         bt_accept_unlink(sk);
 222                         continue;
 223                 }
 224
 225                 if (sk->sk_state == BT_CONNECTED || !newsock ||
 226                     test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags)) {
 227                         bt_accept_unlink(sk);
 228                         if (newsock)
 229                                 sock_graft(sk, newsock);
 230
 231                         release_sock(sk);
 232                         return sk;
 233                 }
 234
 235                 release_sock(sk);
 236         }
 237
 238         return NULL;
 239 }
 240 EXPORT_SYMBOL(bt_accept_dequeue);
 241
 242 int bt_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
 243                     int flags)
 244 {
 245         int noblock = flags & MSG_DONTWAIT;
 246         struct sock *sk = sock->sk;
 247         struct sk_buff *skb;
 248         size_t copied;
 249         int err;
 250
 251         BT_DBG("sock %p sk %p len %zu", sock, sk, len);
 252
 253         if (flags & MSG_OOB)
 254                 return -EOPNOTSUPP;
 255
 256         skb = skb_recv_datagram(sk, flags, noblock, &err);
 257         if (!skb) {
 258                 if (sk->sk_shutdown & RCV_SHUTDOWN)
 259                         return 0;
 260
 261                 return err;
 262         }
 263
 264         copied = skb->len;
 265         if (len < copied) {
 266                 msg->msg_flags |= MSG_TRUNC;
 267                 copied = len;
 268         }
 269
 270         skb_reset_transport_header(skb);
 271         err = skb_copy_datagram_msg(skb, 0, msg, copied);
 272         if (err == 0) {
 273                 sock_recv_ts_and_drops(msg, sk, skb);
 274
 275                 if (bt_sk(sk)->skb_msg_name)
 276                         bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
 277                                                 &msg->msg_namelen);
 278         }
 279
 280         skb_free_datagram(sk, skb);
 281
 282         return err ? : copied;
 283 }
 284 EXPORT_SYMBOL(bt_sock_recvmsg);
 285
 286 static long bt_sock_data_wait(struct sock *sk, long timeo)
 287 {
 288         DECLARE_WAITQUEUE(wait, current);
 289
 290         add_wait_queue(sk_sleep(sk), &wait);
 291         for (;;) {
 292                 set_current_state(TASK_INTERRUPTIBLE);
 293
 294                 if (!skb_queue_empty(&sk->sk_receive_queue))
 295                         break;
 296
 297                 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
 298                         break;
 299
 300                 if (signal_pending(current) || !timeo)
 301                         break;
 302
 303                 sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
 304                 release_sock(sk);
 305                 timeo = schedule_timeout(timeo);
 306                 lock_sock(sk);
 307                 sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
 308         }
 309
 310         __set_current_state(TASK_RUNNING);
 311         remove_wait_queue(sk_sleep(sk), &wait);
 312         return timeo;
 313 }
 314
 315 int bt_sock_stream_recvmsg(struct socket *sock, struct msghdr *msg,
 316                            size_t size, int flags)
 317 {
 318         struct sock *sk = sock->sk;
 319         int err = 0;
 320         size_t target, copied = 0;
 321         long timeo;
 322
 323         if (flags & MSG_OOB)
 324                 return -EOPNOTSUPP;
 325
 326         BT_DBG("sk %p size %zu", sk, size);
 327
 328         lock_sock(sk);
 329
 330         target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
 331         timeo  = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
 332
 333         do {
 334                 struct sk_buff *skb;
 335                 int chunk;
 336
 337                 skb = skb_dequeue(&sk->sk_receive_queue);
 338                 if (!skb) {
 339                         if (copied >= target)
 340                                 break;
 341
 342                         err = sock_error(sk);
 343                         if (err)
 344                                 break;
 345                         if (sk->sk_shutdown & RCV_SHUTDOWN)
 346                                 break;
 347
 348                         err = -EAGAIN;
 349                         if (!timeo)
 350                                 break;
 351
 352                         timeo = bt_sock_data_wait(sk, timeo);
 353
 354                         if (signal_pending(current)) {
 355                                 err = sock_intr_errno(timeo);
 356                                 goto out;
 357                         }
 358                         continue;
 359                 }
 360
 361                 chunk = min_t(unsigned int, skb->len, size);
 362                 if (skb_copy_datagram_msg(skb, 0, msg, chunk)) {
 363                         skb_queue_head(&sk->sk_receive_queue, skb);
 364                         if (!copied)
 365                                 copied = -EFAULT;
 366                         break;
 367                 }
 368                 copied += chunk;
 369                 size   -= chunk;
 370
 371                 sock_recv_ts_and_drops(msg, sk, skb);
 372
 373                 if (!(flags & MSG_PEEK)) {
 374                         int skb_len = skb_headlen(skb);
 375
 376                         if (chunk <= skb_len) {
 377                                 __skb_pull(skb, chunk);
 378                         } else {
 379                                 struct sk_buff *frag;
 380
 381                                 __skb_pull(skb, skb_len);
 382                                 chunk -= skb_len;
 383
 384                                 skb_walk_frags(skb, frag) {
 385                                         if (chunk <= frag->len) {
 386                                                 /* Pulling partial data */
 387                                                 skb->len -= chunk;
 388                                                 skb->data_len -= chunk;
 389                                                 __skb_pull(frag, chunk);
 390                                                 break;
 391                                         } else if (frag->len) {
 392                                                 /* Pulling all frag data */
 393                                                 chunk -= frag->len;
 394                                                 skb->len -= frag->len;
 395                                                 skb->data_len -= frag->len;
 396                                                 __skb_pull(frag, frag->len);
 397                                         }
 398                                 }
 399                         }
 400
 401                         if (skb->len) {
 402                                 skb_queue_head(&sk->sk_receive_queue, skb);
 403                                 break;
 404                         }
 405                         kfree_skb(skb);
 406
 407                 } else {
 408                         /* put message back and return */
 409                         skb_queue_head(&sk->sk_receive_queue, skb);
 410                         break;
 411                 }
 412         } while (size);
 413
 414 out:
 415         release_sock(sk);
 416         return copied ? : err;
 417 }
 418 EXPORT_SYMBOL(bt_sock_stream_recvmsg);
 419
 420 static inline unsigned int bt_accept_poll(struct sock *parent)
 421 {
 422         struct list_head *p, *n;
 423         struct sock *sk;
 424
 425         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
 426                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
 427                 if (sk->sk_state == BT_CONNECTED ||
 428                     (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
 429                      sk->sk_state == BT_CONNECT2))
 430                         return POLLIN | POLLRDNORM;
 431         }
 432
 433         return 0;
 434 }
 435
 436 unsigned int bt_sock_poll(struct file *file, struct socket *sock,
 437                           poll_table *wait)
 438 {
 439         struct sock *sk = sock->sk;
 440         unsigned int mask = 0;
 441
 442         BT_DBG("sock %p, sk %p", sock, sk);
 443
 444         poll_wait(file, sk_sleep(sk), wait);
 445
 446         if (sk->sk_state == BT_LISTEN)
 447                 return bt_accept_poll(sk);
 448
 449         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
 450                 mask |= POLLERR |
 451                         (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
 452
 453         if (sk->sk_shutdown & RCV_SHUTDOWN)
 454                 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
 455
 456         if (sk->sk_shutdown == SHUTDOWN_MASK)
 457                 mask |= POLLHUP;
 458
 459         if (!skb_queue_empty(&sk->sk_receive_queue))
 460                 mask |= POLLIN | POLLRDNORM;
 461
 462         if (sk->sk_state == BT_CLOSED)
 463                 mask |= POLLHUP;
 464
 465         if (sk->sk_state == BT_CONNECT ||
 466                         sk->sk_state == BT_CONNECT2 ||
 467                         sk->sk_state == BT_CONFIG)
 468                 return mask;
 469
 470         if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
 471                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
 472         else
 473                 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
 474
 475         return mask;
 476 }
 477 EXPORT_SYMBOL(bt_sock_poll);
 478
 479 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 480 {
 481         struct sock *sk = sock->sk;
 482         struct sk_buff *skb;
 483         long amount;
 484         int err;
 485
 486         BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
 487
 488         switch (cmd) {
 489         case TIOCOUTQ:
 490                 if (sk->sk_state == BT_LISTEN)
 491                         return -EINVAL;
 492
 493                 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
 494                 if (amount < 0)
 495                         amount = 0;
 496                 err = put_user(amount, (int __user *) arg);
 497                 break;
 498
 499         case TIOCINQ:
 500                 if (sk->sk_state == BT_LISTEN)
 501                         return -EINVAL;
 502
 503                 lock_sock(sk);
 504                 skb = skb_peek(&sk->sk_receive_queue);
 505                 amount = skb ? skb->len : 0;
 506                 release_sock(sk);
 507                 err = put_user(amount, (int __user *) arg);
 508                 break;
 509
 510         case SIOCGSTAMP:
 511                 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
 512                 break;
 513
 514         case SIOCGSTAMPNS:
 515                 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
 516                 break;
 517
 518         default:
 519                 err = -ENOIOCTLCMD;
 520                 break;
 521         }
 522
 523         return err;
 524 }
 525 EXPORT_SYMBOL(bt_sock_ioctl);
 526
 527 /* This function expects the sk lock to be held when called */
 528 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
 529 {
 530         DECLARE_WAITQUEUE(wait, current);
 531         int err = 0;
 532
 533         BT_DBG("sk %p", sk);
 534
 535         add_wait_queue(sk_sleep(sk), &wait);
 536         set_current_state(TASK_INTERRUPTIBLE);
 537         while (sk->sk_state != state) {
 538                 if (!timeo) {
 539                         err = -EINPROGRESS;
 540                         break;
 541                 }
 542
 543                 if (signal_pending(current)) {
 544                         err = sock_intr_errno(timeo);
 545                         break;
 546                 }
 547
 548                 release_sock(sk);
 549                 timeo = schedule_timeout(timeo);
 550                 lock_sock(sk);
 551                 set_current_state(TASK_INTERRUPTIBLE);
 552
 553                 err = sock_error(sk);
 554                 if (err)
 555                         break;
 556         }
 557         __set_current_state(TASK_RUNNING);
 558         remove_wait_queue(sk_sleep(sk), &wait);
 559         return err;
 560 }
 561 EXPORT_SYMBOL(bt_sock_wait_state);
 562
 563 /* This function expects the sk lock to be held when called */
 564 int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
 565 {
 566         DECLARE_WAITQUEUE(wait, current);
 567         unsigned long timeo;
 568         int err = 0;
 569
 570         BT_DBG("sk %p", sk);
 571
 572         timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
 573
 574         add_wait_queue(sk_sleep(sk), &wait);
 575         set_current_state(TASK_INTERRUPTIBLE);
 576         while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
 577                 if (!timeo) {
 578                         err = -EAGAIN;
 579                         break;
 580                 }
 581
 582                 if (signal_pending(current)) {
 583                         err = sock_intr_errno(timeo);
 584                         break;
 585                 }
 586
 587                 release_sock(sk);
 588                 timeo = schedule_timeout(timeo);
 589                 lock_sock(sk);
 590                 set_current_state(TASK_INTERRUPTIBLE);
 591
 592                 err = sock_error(sk);
 593                 if (err)
 594                         break;
 595         }
 596         __set_current_state(TASK_RUNNING);
 597         remove_wait_queue(sk_sleep(sk), &wait);
 598
 599         return err;
 600 }
 601 EXPORT_SYMBOL(bt_sock_wait_ready);
 602
 603 #ifdef CONFIG_PROC_FS
 604 struct bt_seq_state {
 605         struct bt_sock_list *l;
 606 };
 607
 608 static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
 609         __acquires(seq->private->l->lock)
 610 {
 611         struct bt_seq_state *s = seq->private;
 612         struct bt_sock_list *l = s->l;
 613
 614         read_lock(&l->lock);
 615         return seq_hlist_start_head(&l->head, *pos);
 616 }
 617
 618 static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 619 {
 620         struct bt_seq_state *s = seq->private;
 621         struct bt_sock_list *l = s->l;
 622
 623         return seq_hlist_next(v, &l->head, pos);
 624 }
 625
 626 static void bt_seq_stop(struct seq_file *seq, void *v)
 627         __releases(seq->private->l->lock)
 628 {
 629         struct bt_seq_state *s = seq->private;
 630         struct bt_sock_list *l = s->l;
 631
 632         read_unlock(&l->lock);
 633 }
 634
 635 static int bt_seq_show(struct seq_file *seq, void *v)
 636 {
 637         struct bt_seq_state *s = seq->private;
 638         struct bt_sock_list *l = s->l;
 639
 640         if (v == SEQ_START_TOKEN) {
 641                 seq_puts(seq ,"sk               RefCnt Rmem   Wmem   User   Inode  Parent");
 642
 643                 if (l->custom_seq_show) {
 644                         seq_putc(seq, ' ');
 645                         l->custom_seq_show(seq, v);
 646                 }
 647
 648                 seq_putc(seq, '\n');
 649         } else {
 650                 struct sock *sk = sk_entry(v);
 651                 struct bt_sock *bt = bt_sk(sk);
 652
 653                 seq_printf(seq,
 654                            "%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
 655                            sk,
 656                            atomic_read(&sk->sk_refcnt),
 657                            sk_rmem_alloc_get(sk),
 658                            sk_wmem_alloc_get(sk),
 659                            from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
 660                            sock_i_ino(sk),
 661                            bt->parent? sock_i_ino(bt->parent): 0LU);
 662
 663                 if (l->custom_seq_show) {
 664                         seq_putc(seq, ' ');
 665                         l->custom_seq_show(seq, v);
 666                 }
 667
 668                 seq_putc(seq, '\n');
 669         }
 670         return 0;
 671 }
 672
 673 static const struct seq_operations bt_seq_ops = {
 674         .start = bt_seq_start,
 675         .next  = bt_seq_next,
 676         .stop  = bt_seq_stop,
 677         .show  = bt_seq_show,
 678 };
 679
 680 static int bt_seq_open(struct inode *inode, struct file *file)
 681 {
 682         struct bt_sock_list *sk_list;
 683         struct bt_seq_state *s;
 684
 685         sk_list = PDE_DATA(inode);
 686         s = __seq_open_private(file, &bt_seq_ops,
 687                                sizeof(struct bt_seq_state));
 688         if (!s)
 689                 return -ENOMEM;
 690
 691         s->l = sk_list;
 692         return 0;
 693 }
 694
 695 static const struct file_operations bt_fops = {
 696         .open = bt_seq_open,
 697         .read = seq_read,
 698         .llseek = seq_lseek,
 699         .release = seq_release_private
 700 };
 701
 702 int bt_procfs_init(struct net *net, const char *name,
 703                    struct bt_sock_list* sk_list,
 704                    int (* seq_show)(struct seq_file *, void *))
 705 {
 706         sk_list->custom_seq_show = seq_show;
 707
 708         if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
 709                 return -ENOMEM;
 710         return 0;
 711 }
 712
 713 void bt_procfs_cleanup(struct net *net, const char *name)
 714 {
 715         remove_proc_entry(name, net->proc_net);
 716 }
 717 #else
 718 int bt_procfs_init(struct net *net, const char *name,
 719                    struct bt_sock_list* sk_list,
 720                    int (* seq_show)(struct seq_file *, void *))
 721 {
 722         return 0;
 723 }
 724
 725 void bt_procfs_cleanup(struct net *net, const char *name)
 726 {
 727 }
 728 #endif
 729 EXPORT_SYMBOL(bt_procfs_init);
 730 EXPORT_SYMBOL(bt_procfs_cleanup);
 731
 732 static struct net_proto_family bt_sock_family_ops = {
 733         .owner  = THIS_MODULE,
 734         .family = PF_BLUETOOTH,
 735         .create = bt_sock_create,
 736 };
 737
 738 struct dentry *bt_debugfs;
 739 EXPORT_SYMBOL_GPL(bt_debugfs);
 740
 741 static int __init bt_init(void)
 742 {
 743         int err;
 744
 745         sock_skb_cb_check_size(sizeof(struct bt_skb_cb));
 746
 747         BT_INFO("Core ver %s", VERSION);
 748
 749         err = bt_selftest();
 750         if (err < 0)
 751                 return err;
 752
 753         bt_debugfs = debugfs_create_dir("bluetooth", NULL);
 754
 755         err = bt_sysfs_init();
 756         if (err < 0)
 757                 return err;
 758
 759         err = sock_register(&bt_sock_family_ops);
 760         if (err < 0) {
 761                 bt_sysfs_cleanup();
 762                 return err;
 763         }
 764
 765         BT_INFO("HCI device and connection manager initialized");
 766
 767         err = hci_sock_init();
 768         if (err < 0)
 769                 goto error;
 770
 771         err = l2cap_init();
 772         if (err < 0)
 773                 goto sock_err;
 774
 775         err = sco_init();
 776         if (err < 0) {
 777                 l2cap_exit();
 778                 goto sock_err;
 779         }
 780
 781         err = mgmt_init();
 782         if (err < 0) {
 783                 sco_exit();
 784                 l2cap_exit();
 785                 goto sock_err;
 786         }
 787
 788         return 0;
 789
 790 sock_err:
 791         hci_sock_cleanup();
 792
 793 error:
 794         sock_unregister(PF_BLUETOOTH);
 795         bt_sysfs_cleanup();
 796
 797         return err;
 798 }
 799
 800 static void __exit bt_exit(void)
 801 {
 802         mgmt_exit();
 803
 804         sco_exit();
 805
 806         l2cap_exit();
 807
 808         hci_sock_cleanup();
 809
 810         sock_unregister(PF_BLUETOOTH);
 811
 812         bt_sysfs_cleanup();
 813
 814         debugfs_remove_recursive(bt_debugfs);
 815 }
 816
 817 subsys_initcall(bt_init);
 818 module_exit(bt_exit);
 819
 820 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 821 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
 822 MODULE_VERSION(VERSION);
 823 MODULE_LICENSE("GPL");
 824 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);