net/bluetooth/af_bluetooth.c

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