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