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