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.17"
  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                         msg->msg_namelen = 0;
 228                         return 0;
 229                 }
 230                 return err;
 231         }
 232
 233         copied = skb->len;
 234         if (len < copied) {
 235                 msg->msg_flags |= MSG_TRUNC;
 236                 copied = len;
 237         }
 238
 239         skb_reset_transport_header(skb);
 240         err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
 241         if (err == 0) {
 242                 sock_recv_ts_and_drops(msg, sk, skb);
 243
 244                 if (bt_sk(sk)->skb_msg_name)
 245                         bt_sk(sk)->skb_msg_name(skb, msg->msg_name,
 246                                                 &msg->msg_namelen);
 247                 else
 248                         msg->msg_namelen = 0;
 249         }
 250
 251         skb_free_datagram(sk, skb);
 252
 253         return err ? : copied;
 254 }
 255 EXPORT_SYMBOL(bt_sock_recvmsg);
 256
 257 static long bt_sock_data_wait(struct sock *sk, long timeo)
 258 {
 259         DECLARE_WAITQUEUE(wait, current);
 260
 261         add_wait_queue(sk_sleep(sk), &wait);
 262         for (;;) {
 263                 set_current_state(TASK_INTERRUPTIBLE);
 264
 265                 if (!skb_queue_empty(&sk->sk_receive_queue))
 266                         break;
 267
 268                 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN))
 269                         break;
 270
 271                 if (signal_pending(current) || !timeo)
 272                         break;
 273
 274                 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
 275                 release_sock(sk);
 276                 timeo = schedule_timeout(timeo);
 277                 lock_sock(sk);
 278                 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
 279         }
 280
 281         __set_current_state(TASK_RUNNING);
 282         remove_wait_queue(sk_sleep(sk), &wait);
 283         return timeo;
 284 }
 285
 286 int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock,
 287                                struct msghdr *msg, size_t size, int flags)
 288 {
 289         struct sock *sk = sock->sk;
 290         int err = 0;
 291         size_t target, copied = 0;
 292         long timeo;
 293
 294         if (flags & MSG_OOB)
 295                 return -EOPNOTSUPP;
 296
 297         msg->msg_namelen = 0;
 298
 299         BT_DBG("sk %p size %zu", sk, size);
 300
 301         lock_sock(sk);
 302
 303         target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
 304         timeo  = sock_rcvtimeo(sk, flags & MSG_DONTWAIT);
 305
 306         do {
 307                 struct sk_buff *skb;
 308                 int chunk;
 309
 310                 skb = skb_dequeue(&sk->sk_receive_queue);
 311                 if (!skb) {
 312                         if (copied >= target)
 313                                 break;
 314
 315                         err = sock_error(sk);
 316                         if (err)
 317                                 break;
 318                         if (sk->sk_shutdown & RCV_SHUTDOWN)
 319                                 break;
 320
 321                         err = -EAGAIN;
 322                         if (!timeo)
 323                                 break;
 324
 325                         timeo = bt_sock_data_wait(sk, timeo);
 326
 327                         if (signal_pending(current)) {
 328                                 err = sock_intr_errno(timeo);
 329                                 goto out;
 330                         }
 331                         continue;
 332                 }
 333
 334                 chunk = min_t(unsigned int, skb->len, size);
 335                 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) {
 336                         skb_queue_head(&sk->sk_receive_queue, skb);
 337                         if (!copied)
 338                                 copied = -EFAULT;
 339                         break;
 340                 }
 341                 copied += chunk;
 342                 size   -= chunk;
 343
 344                 sock_recv_ts_and_drops(msg, sk, skb);
 345
 346                 if (!(flags & MSG_PEEK)) {
 347                         int skb_len = skb_headlen(skb);
 348
 349                         if (chunk <= skb_len) {
 350                                 __skb_pull(skb, chunk);
 351                         } else {
 352                                 struct sk_buff *frag;
 353
 354                                 __skb_pull(skb, skb_len);
 355                                 chunk -= skb_len;
 356
 357                                 skb_walk_frags(skb, frag) {
 358                                         if (chunk <= frag->len) {
 359                                                 /* Pulling partial data */
 360                                                 skb->len -= chunk;
 361                                                 skb->data_len -= chunk;
 362                                                 __skb_pull(frag, chunk);
 363                                                 break;
 364                                         } else if (frag->len) {
 365                                                 /* Pulling all frag data */
 366                                                 chunk -= frag->len;
 367                                                 skb->len -= frag->len;
 368                                                 skb->data_len -= frag->len;
 369                                                 __skb_pull(frag, frag->len);
 370                                         }
 371                                 }
 372                         }
 373
 374                         if (skb->len) {
 375                                 skb_queue_head(&sk->sk_receive_queue, skb);
 376                                 break;
 377                         }
 378                         kfree_skb(skb);
 379
 380                 } else {
 381                         /* put message back and return */
 382                         skb_queue_head(&sk->sk_receive_queue, skb);
 383                         break;
 384                 }
 385         } while (size);
 386
 387 out:
 388         release_sock(sk);
 389         return copied ? : err;
 390 }
 391 EXPORT_SYMBOL(bt_sock_stream_recvmsg);
 392
 393 static inline unsigned int bt_accept_poll(struct sock *parent)
 394 {
 395         struct list_head *p, *n;
 396         struct sock *sk;
 397
 398         list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
 399                 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
 400                 if (sk->sk_state == BT_CONNECTED ||
 401                     (test_bit(BT_SK_DEFER_SETUP, &bt_sk(parent)->flags) &&
 402                      sk->sk_state == BT_CONNECT2))
 403                         return POLLIN | POLLRDNORM;
 404         }
 405
 406         return 0;
 407 }
 408
 409 unsigned int bt_sock_poll(struct file *file, struct socket *sock,
 410                           poll_table *wait)
 411 {
 412         struct sock *sk = sock->sk;
 413         unsigned int mask = 0;
 414
 415         BT_DBG("sock %p, sk %p", sock, sk);
 416
 417         poll_wait(file, sk_sleep(sk), wait);
 418
 419         if (sk->sk_state == BT_LISTEN)
 420                 return bt_accept_poll(sk);
 421
 422         if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
 423                 mask |= POLLERR |
 424                         (sock_flag(sk, SOCK_SELECT_ERR_QUEUE) ? POLLPRI : 0);
 425
 426         if (sk->sk_shutdown & RCV_SHUTDOWN)
 427                 mask |= POLLRDHUP | POLLIN | POLLRDNORM;
 428
 429         if (sk->sk_shutdown == SHUTDOWN_MASK)
 430                 mask |= POLLHUP;
 431
 432         if (!skb_queue_empty(&sk->sk_receive_queue))
 433                 mask |= POLLIN | POLLRDNORM;
 434
 435         if (sk->sk_state == BT_CLOSED)
 436                 mask |= POLLHUP;
 437
 438         if (sk->sk_state == BT_CONNECT ||
 439                         sk->sk_state == BT_CONNECT2 ||
 440                         sk->sk_state == BT_CONFIG)
 441                 return mask;
 442
 443         if (!test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags) && sock_writeable(sk))
 444                 mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
 445         else
 446                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
 447
 448         return mask;
 449 }
 450 EXPORT_SYMBOL(bt_sock_poll);
 451
 452 int bt_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 453 {
 454         struct sock *sk = sock->sk;
 455         struct sk_buff *skb;
 456         long amount;
 457         int err;
 458
 459         BT_DBG("sk %p cmd %x arg %lx", sk, cmd, arg);
 460
 461         switch (cmd) {
 462         case TIOCOUTQ:
 463                 if (sk->sk_state == BT_LISTEN)
 464                         return -EINVAL;
 465
 466                 amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
 467                 if (amount < 0)
 468                         amount = 0;
 469                 err = put_user(amount, (int __user *) arg);
 470                 break;
 471
 472         case TIOCINQ:
 473                 if (sk->sk_state == BT_LISTEN)
 474                         return -EINVAL;
 475
 476                 lock_sock(sk);
 477                 skb = skb_peek(&sk->sk_receive_queue);
 478                 amount = skb ? skb->len : 0;
 479                 release_sock(sk);
 480                 err = put_user(amount, (int __user *) arg);
 481                 break;
 482
 483         case SIOCGSTAMP:
 484                 err = sock_get_timestamp(sk, (struct timeval __user *) arg);
 485                 break;
 486
 487         case SIOCGSTAMPNS:
 488                 err = sock_get_timestampns(sk, (struct timespec __user *) arg);
 489                 break;
 490
 491         default:
 492                 err = -ENOIOCTLCMD;
 493                 break;
 494         }
 495
 496         return err;
 497 }
 498 EXPORT_SYMBOL(bt_sock_ioctl);
 499
 500 /* This function expects the sk lock to be held when called */
 501 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
 502 {
 503         DECLARE_WAITQUEUE(wait, current);
 504         int err = 0;
 505
 506         BT_DBG("sk %p", sk);
 507
 508         add_wait_queue(sk_sleep(sk), &wait);
 509         set_current_state(TASK_INTERRUPTIBLE);
 510         while (sk->sk_state != state) {
 511                 if (!timeo) {
 512                         err = -EINPROGRESS;
 513                         break;
 514                 }
 515
 516                 if (signal_pending(current)) {
 517                         err = sock_intr_errno(timeo);
 518                         break;
 519                 }
 520
 521                 release_sock(sk);
 522                 timeo = schedule_timeout(timeo);
 523                 lock_sock(sk);
 524                 set_current_state(TASK_INTERRUPTIBLE);
 525
 526                 err = sock_error(sk);
 527                 if (err)
 528                         break;
 529         }
 530         __set_current_state(TASK_RUNNING);
 531         remove_wait_queue(sk_sleep(sk), &wait);
 532         return err;
 533 }
 534 EXPORT_SYMBOL(bt_sock_wait_state);
 535
 536 /* This function expects the sk lock to be held when called */
 537 int bt_sock_wait_ready(struct sock *sk, unsigned long flags)
 538 {
 539         DECLARE_WAITQUEUE(wait, current);
 540         unsigned long timeo;
 541         int err = 0;
 542
 543         BT_DBG("sk %p", sk);
 544
 545         timeo = sock_sndtimeo(sk, flags & O_NONBLOCK);
 546
 547         add_wait_queue(sk_sleep(sk), &wait);
 548         set_current_state(TASK_INTERRUPTIBLE);
 549         while (test_bit(BT_SK_SUSPEND, &bt_sk(sk)->flags)) {
 550                 if (!timeo) {
 551                         err = -EAGAIN;
 552                         break;
 553                 }
 554
 555                 if (signal_pending(current)) {
 556                         err = sock_intr_errno(timeo);
 557                         break;
 558                 }
 559
 560                 release_sock(sk);
 561                 timeo = schedule_timeout(timeo);
 562                 lock_sock(sk);
 563                 set_current_state(TASK_INTERRUPTIBLE);
 564
 565                 err = sock_error(sk);
 566                 if (err)
 567                         break;
 568         }
 569         __set_current_state(TASK_RUNNING);
 570         remove_wait_queue(sk_sleep(sk), &wait);
 571
 572         return err;
 573 }
 574 EXPORT_SYMBOL(bt_sock_wait_ready);
 575
 576 #ifdef CONFIG_PROC_FS
 577 struct bt_seq_state {
 578         struct bt_sock_list *l;
 579 };
 580
 581 static void *bt_seq_start(struct seq_file *seq, loff_t *pos)
 582         __acquires(seq->private->l->lock)
 583 {
 584         struct bt_seq_state *s = seq->private;
 585         struct bt_sock_list *l = s->l;
 586
 587         read_lock(&l->lock);
 588         return seq_hlist_start_head(&l->head, *pos);
 589 }
 590
 591 static void *bt_seq_next(struct seq_file *seq, void *v, loff_t *pos)
 592 {
 593         struct bt_seq_state *s = seq->private;
 594         struct bt_sock_list *l = s->l;
 595
 596         return seq_hlist_next(v, &l->head, pos);
 597 }
 598
 599 static void bt_seq_stop(struct seq_file *seq, void *v)
 600         __releases(seq->private->l->lock)
 601 {
 602         struct bt_seq_state *s = seq->private;
 603         struct bt_sock_list *l = s->l;
 604
 605         read_unlock(&l->lock);
 606 }
 607
 608 static int bt_seq_show(struct seq_file *seq, void *v)
 609 {
 610         struct bt_seq_state *s = seq->private;
 611         struct bt_sock_list *l = s->l;
 612
 613         if (v == SEQ_START_TOKEN) {
 614                 seq_puts(seq ,"sk               RefCnt Rmem   Wmem   User   Inode  Parent");
 615
 616                 if (l->custom_seq_show) {
 617                         seq_putc(seq, ' ');
 618                         l->custom_seq_show(seq, v);
 619                 }
 620
 621                 seq_putc(seq, '\n');
 622         } else {
 623                 struct sock *sk = sk_entry(v);
 624                 struct bt_sock *bt = bt_sk(sk);
 625
 626                 seq_printf(seq,
 627                            "%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
 628                            sk,
 629                            atomic_read(&sk->sk_refcnt),
 630                            sk_rmem_alloc_get(sk),
 631                            sk_wmem_alloc_get(sk),
 632                            from_kuid(seq_user_ns(seq), sock_i_uid(sk)),
 633                            sock_i_ino(sk),
 634                            bt->parent? sock_i_ino(bt->parent): 0LU);
 635
 636                 if (l->custom_seq_show) {
 637                         seq_putc(seq, ' ');
 638                         l->custom_seq_show(seq, v);
 639                 }
 640
 641                 seq_putc(seq, '\n');
 642         }
 643         return 0;
 644 }
 645
 646 static struct seq_operations bt_seq_ops = {
 647         .start = bt_seq_start,
 648         .next  = bt_seq_next,
 649         .stop  = bt_seq_stop,
 650         .show  = bt_seq_show,
 651 };
 652
 653 static int bt_seq_open(struct inode *inode, struct file *file)
 654 {
 655         struct bt_sock_list *sk_list;
 656         struct bt_seq_state *s;
 657
 658         sk_list = PDE_DATA(inode);
 659         s = __seq_open_private(file, &bt_seq_ops,
 660                                sizeof(struct bt_seq_state));
 661         if (!s)
 662                 return -ENOMEM;
 663
 664         s->l = sk_list;
 665         return 0;
 666 }
 667
 668 static const struct file_operations bt_fops = {
 669         .open = bt_seq_open,
 670         .read = seq_read,
 671         .llseek = seq_lseek,
 672         .release = seq_release_private
 673 };
 674
 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         sk_list->custom_seq_show = seq_show;
 680
 681         if (!proc_create_data(name, 0, net->proc_net, &bt_fops, sk_list))
 682                 return -ENOMEM;
 683         return 0;
 684 }
 685
 686 void bt_procfs_cleanup(struct net *net, const char *name)
 687 {
 688         remove_proc_entry(name, net->proc_net);
 689 }
 690 #else
 691 int bt_procfs_init(struct net *net, const char *name,
 692                    struct bt_sock_list* sk_list,
 693                    int (* seq_show)(struct seq_file *, void *))
 694 {
 695         return 0;
 696 }
 697
 698 void bt_procfs_cleanup(struct net *net, const char *name)
 699 {
 700 }
 701 #endif
 702 EXPORT_SYMBOL(bt_procfs_init);
 703 EXPORT_SYMBOL(bt_procfs_cleanup);
 704
 705 static struct net_proto_family bt_sock_family_ops = {
 706         .owner  = THIS_MODULE,
 707         .family = PF_BLUETOOTH,
 708         .create = bt_sock_create,
 709 };
 710
 711 static int __init bt_init(void)
 712 {
 713         int err;
 714
 715         BT_INFO("Core ver %s", VERSION);
 716
 717         err = bt_sysfs_init();
 718         if (err < 0)
 719                 return err;
 720
 721         err = sock_register(&bt_sock_family_ops);
 722         if (err < 0) {
 723                 bt_sysfs_cleanup();
 724                 return err;
 725         }
 726
 727         BT_INFO("HCI device and connection manager initialized");
 728
 729         err = hci_sock_init();
 730         if (err < 0)
 731                 goto error;
 732
 733         err = l2cap_init();
 734         if (err < 0)
 735                 goto sock_err;
 736
 737         err = sco_init();
 738         if (err < 0) {
 739                 l2cap_exit();
 740                 goto sock_err;
 741         }
 742
 743         return 0;
 744
 745 sock_err:
 746         hci_sock_cleanup();
 747
 748 error:
 749         sock_unregister(PF_BLUETOOTH);
 750         bt_sysfs_cleanup();
 751
 752         return err;
 753 }
 754
 755 static void __exit bt_exit(void)
 756 {
 757
 758         sco_exit();
 759
 760         l2cap_exit();
 761
 762         hci_sock_cleanup();
 763
 764         sock_unregister(PF_BLUETOOTH);
 765
 766         bt_sysfs_cleanup();
 767 }
 768
 769 subsys_initcall(bt_init);
 770 module_exit(bt_exit);
 771
 772 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
 773 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
 774 MODULE_VERSION(VERSION);
 775 MODULE_LICENSE("GPL");
 776 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);