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