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 29 #include <linux/types.h> 30 #include <linux/list.h> 31 #include <linux/errno.h> 32 #include <linux/kernel.h> 33 #include <linux/sched.h> 34 #include <linux/skbuff.h> 35 #include <linux/init.h> 36 #include <linux/poll.h> 37 #include <net/sock.h> 38 #include <asm/ioctls.h> 39 #include <linux/kmod.h> 40 41 #include <net/bluetooth/bluetooth.h> 42 43 #define VERSION "2.16" 44 45 /* Bluetooth sockets */ 46 #define BT_MAX_PROTO 8 47 static const struct net_proto_family *bt_proto[BT_MAX_PROTO]; 48 static DEFINE_RWLOCK(bt_proto_lock); 49 50 static struct lock_class_key bt_lock_key[BT_MAX_PROTO]; 51 static const char *const bt_key_strings[BT_MAX_PROTO] = { 52 "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP", 53 "sk_lock-AF_BLUETOOTH-BTPROTO_HCI", 54 "sk_lock-AF_BLUETOOTH-BTPROTO_SCO", 55 "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM", 56 "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP", 57 "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP", 58 "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP", 59 "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP", 60 }; 61 62 static struct lock_class_key bt_slock_key[BT_MAX_PROTO]; 63 static const char *const bt_slock_key_strings[BT_MAX_PROTO] = { 64 "slock-AF_BLUETOOTH-BTPROTO_L2CAP", 65 "slock-AF_BLUETOOTH-BTPROTO_HCI", 66 "slock-AF_BLUETOOTH-BTPROTO_SCO", 67 "slock-AF_BLUETOOTH-BTPROTO_RFCOMM", 68 "slock-AF_BLUETOOTH-BTPROTO_BNEP", 69 "slock-AF_BLUETOOTH-BTPROTO_CMTP", 70 "slock-AF_BLUETOOTH-BTPROTO_HIDP", 71 "slock-AF_BLUETOOTH-BTPROTO_AVDTP", 72 }; 73 74 static inline void bt_sock_reclassify_lock(struct socket *sock, int proto) 75 { 76 struct sock *sk = sock->sk; 77 78 if (!sk) 79 return; 80 81 BUG_ON(sock_owned_by_user(sk)); 82 83 sock_lock_init_class_and_name(sk, 84 bt_slock_key_strings[proto], &bt_slock_key[proto], 85 bt_key_strings[proto], &bt_lock_key[proto]); 86 } 87 88 int bt_sock_register(int proto, const struct net_proto_family *ops) 89 { 90 int err = 0; 91 92 if (proto < 0 || proto >= BT_MAX_PROTO) 93 return -EINVAL; 94 95 write_lock(&bt_proto_lock); 96 97 if (bt_proto[proto]) 98 err = -EEXIST; 99 else 100 bt_proto[proto] = ops; 101 102 write_unlock(&bt_proto_lock); 103 104 return err; 105 } 106 EXPORT_SYMBOL(bt_sock_register); 107 108 int bt_sock_unregister(int proto) 109 { 110 int err = 0; 111 112 if (proto < 0 || proto >= BT_MAX_PROTO) 113 return -EINVAL; 114 115 write_lock(&bt_proto_lock); 116 117 if (!bt_proto[proto]) 118 err = -ENOENT; 119 else 120 bt_proto[proto] = NULL; 121 122 write_unlock(&bt_proto_lock); 123 124 return err; 125 } 126 EXPORT_SYMBOL(bt_sock_unregister); 127 128 static int bt_sock_create(struct net *net, struct socket *sock, int proto, 129 int kern) 130 { 131 int err; 132 133 if (net != &init_net) 134 return -EAFNOSUPPORT; 135 136 if (proto < 0 || proto >= BT_MAX_PROTO) 137 return -EINVAL; 138 139 if (!bt_proto[proto]) 140 request_module("bt-proto-%d", proto); 141 142 err = -EPROTONOSUPPORT; 143 144 read_lock(&bt_proto_lock); 145 146 if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) { 147 err = bt_proto[proto]->create(net, sock, proto, kern); 148 bt_sock_reclassify_lock(sock, proto); 149 module_put(bt_proto[proto]->owner); 150 } 151 152 read_unlock(&bt_proto_lock); 153 154 return err; 155 } 156 157 void bt_sock_link(struct bt_sock_list *l, struct sock *sk) 158 { 159 write_lock(&l->lock); 160 sk_add_node(sk, &l->head); 161 write_unlock(&l->lock); 162 } 163 EXPORT_SYMBOL(bt_sock_link); 164 165 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk) 166 { 167 write_lock(&l->lock); 168 sk_del_node_init(sk); 169 write_unlock(&l->lock); 170 } 171 EXPORT_SYMBOL(bt_sock_unlink); 172 173 void bt_accept_enqueue(struct sock *parent, struct sock *sk) 174 { 175 BT_DBG("parent %p, sk %p", parent, sk); 176 177 sock_hold(sk); 178 list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q); 179 bt_sk(sk)->parent = parent; 180 parent->sk_ack_backlog++; 181 } 182 EXPORT_SYMBOL(bt_accept_enqueue); 183 184 void bt_accept_unlink(struct sock *sk) 185 { 186 BT_DBG("sk %p state %d", sk, sk->sk_state); 187 188 list_del_init(&bt_sk(sk)->accept_q); 189 bt_sk(sk)->parent->sk_ack_backlog--; 190 bt_sk(sk)->parent = NULL; 191 sock_put(sk); 192 } 193 EXPORT_SYMBOL(bt_accept_unlink); 194 195 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock) 196 { 197 struct list_head *p, *n; 198 struct sock *sk; 199 200 BT_DBG("parent %p", parent); 201 202 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) { 203 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q); 204 205 lock_sock(sk); 206 207 /* FIXME: Is this check still needed */ 208 if (sk->sk_state == BT_CLOSED) { 209 release_sock(sk); 210 bt_accept_unlink(sk); 211 continue; 212 } 213 214 if (sk->sk_state == BT_CONNECTED || !newsock || 215 bt_sk(parent)->defer_setup) { 216 bt_accept_unlink(sk); 217 if (newsock) 218 sock_graft(sk, newsock); 219 220 release_sock(sk); 221 return sk; 222 } 223 224 release_sock(sk); 225 } 226 227 return NULL; 228 } 229 EXPORT_SYMBOL(bt_accept_dequeue); 230 231 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock, 232 struct msghdr *msg, size_t len, int flags) 233 { 234 int noblock = flags & MSG_DONTWAIT; 235 struct sock *sk = sock->sk; 236 struct sk_buff *skb; 237 size_t copied; 238 int err; 239 240 BT_DBG("sock %p sk %p len %zu", sock, sk, len); 241 242 if (flags & (MSG_OOB)) 243 return -EOPNOTSUPP; 244 245 skb = skb_recv_datagram(sk, flags, noblock, &err); 246 if (!skb) { 247 if (sk->sk_shutdown & RCV_SHUTDOWN) 248 return 0; 249 return err; 250 } 251 252 msg->msg_namelen = 0; 253 254 copied = skb->len; 255 if (len < copied) { 256 msg->msg_flags |= MSG_TRUNC; 257 copied = len; 258 } 259 260 skb_reset_transport_header(skb); 261 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); 262 if (err == 0) 263 sock_recv_ts_and_drops(msg, sk, skb); 264 265 skb_free_datagram(sk, skb); 266 267 return err ? : copied; 268 } 269 EXPORT_SYMBOL(bt_sock_recvmsg); 270 271 static long bt_sock_data_wait(struct sock *sk, long timeo) 272 { 273 DECLARE_WAITQUEUE(wait, current); 274 275 add_wait_queue(sk_sleep(sk), &wait); 276 for (;;) { 277 set_current_state(TASK_INTERRUPTIBLE); 278 279 if (!skb_queue_empty(&sk->sk_receive_queue)) 280 break; 281 282 if (sk->sk_err || (sk->sk_shutdown & RCV_SHUTDOWN)) 283 break; 284 285 if (signal_pending(current) || !timeo) 286 break; 287 288 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags); 289 release_sock(sk); 290 timeo = schedule_timeout(timeo); 291 lock_sock(sk); 292 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags); 293 } 294 295 __set_current_state(TASK_RUNNING); 296 remove_wait_queue(sk_sleep(sk), &wait); 297 return timeo; 298 } 299 300 int bt_sock_stream_recvmsg(struct kiocb *iocb, struct socket *sock, 301 struct msghdr *msg, size_t size, int flags) 302 { 303 struct sock *sk = sock->sk; 304 int err = 0; 305 size_t target, copied = 0; 306 long timeo; 307 308 if (flags & MSG_OOB) 309 return -EOPNOTSUPP; 310 311 msg->msg_namelen = 0; 312 313 BT_DBG("sk %p size %zu", sk, size); 314 315 lock_sock(sk); 316 317 target = sock_rcvlowat(sk, flags & MSG_WAITALL, size); 318 timeo = sock_rcvtimeo(sk, flags & MSG_DONTWAIT); 319 320 do { 321 struct sk_buff *skb; 322 int chunk; 323 324 skb = skb_dequeue(&sk->sk_receive_queue); 325 if (!skb) { 326 if (copied >= target) 327 break; 328 329 err = sock_error(sk); 330 if (err) 331 break; 332 if (sk->sk_shutdown & RCV_SHUTDOWN) 333 break; 334 335 err = -EAGAIN; 336 if (!timeo) 337 break; 338 339 timeo = bt_sock_data_wait(sk, timeo); 340 341 if (signal_pending(current)) { 342 err = sock_intr_errno(timeo); 343 goto out; 344 } 345 continue; 346 } 347 348 chunk = min_t(unsigned int, skb->len, size); 349 if (skb_copy_datagram_iovec(skb, 0, msg->msg_iov, chunk)) { 350 skb_queue_head(&sk->sk_receive_queue, skb); 351 if (!copied) 352 copied = -EFAULT; 353 break; 354 } 355 copied += chunk; 356 size -= chunk; 357 358 sock_recv_ts_and_drops(msg, sk, skb); 359 360 if (!(flags & MSG_PEEK)) { 361 int skb_len = skb_headlen(skb); 362 363 if (chunk <= skb_len) { 364 __skb_pull(skb, chunk); 365 } else { 366 struct sk_buff *frag; 367 368 __skb_pull(skb, skb_len); 369 chunk -= skb_len; 370 371 skb_walk_frags(skb, frag) { 372 if (chunk <= frag->len) { 373 /* Pulling partial data */ 374 skb->len -= chunk; 375 skb->data_len -= chunk; 376 __skb_pull(frag, chunk); 377 break; 378 } else if (frag->len) { 379 /* Pulling all frag data */ 380 chunk -= frag->len; 381 skb->len -= frag->len; 382 skb->data_len -= frag->len; 383 __skb_pull(frag, frag->len); 384 } 385 } 386 } 387 388 if (skb->len) { 389 skb_queue_head(&sk->sk_receive_queue, skb); 390 break; 391 } 392 kfree_skb(skb); 393 394 } else { 395 /* put message back and return */ 396 skb_queue_head(&sk->sk_receive_queue, skb); 397 break; 398 } 399 } while (size); 400 401 out: 402 release_sock(sk); 403 return copied ? : err; 404 } 405 EXPORT_SYMBOL(bt_sock_stream_recvmsg); 406 407 static inline unsigned int bt_accept_poll(struct sock *parent) 408 { 409 struct list_head *p, *n; 410 struct sock *sk; 411 412 list_for_each_safe(p, n, &bt_sk(parent)->accept_q) { 413 sk = (struct sock *) list_entry(p, struct bt_sock, accept_q); 414 if (sk->sk_state == BT_CONNECTED || 415 (bt_sk(parent)->defer_setup && 416 sk->sk_state == BT_CONNECT2)) 417 return POLLIN | POLLRDNORM; 418 } 419 420 return 0; 421 } 422 423 unsigned int bt_sock_poll(struct file *file, struct socket *sock, poll_table *wait) 424 { 425 struct sock *sk = sock->sk; 426 unsigned int mask = 0; 427 428 BT_DBG("sock %p, sk %p", sock, sk); 429 430 poll_wait(file, sk_sleep(sk), wait); 431 432 if (sk->sk_state == BT_LISTEN) 433 return bt_accept_poll(sk); 434 435 if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue)) 436 mask |= POLLERR; 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 (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 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo) 513 { 514 DECLARE_WAITQUEUE(wait, current); 515 int err = 0; 516 517 BT_DBG("sk %p", sk); 518 519 add_wait_queue(sk_sleep(sk), &wait); 520 set_current_state(TASK_INTERRUPTIBLE); 521 while (sk->sk_state != state) { 522 if (!timeo) { 523 err = -EINPROGRESS; 524 break; 525 } 526 527 if (signal_pending(current)) { 528 err = sock_intr_errno(timeo); 529 break; 530 } 531 532 release_sock(sk); 533 timeo = schedule_timeout(timeo); 534 lock_sock(sk); 535 set_current_state(TASK_INTERRUPTIBLE); 536 537 err = sock_error(sk); 538 if (err) 539 break; 540 } 541 __set_current_state(TASK_RUNNING); 542 remove_wait_queue(sk_sleep(sk), &wait); 543 return err; 544 } 545 EXPORT_SYMBOL(bt_sock_wait_state); 546 547 static struct net_proto_family bt_sock_family_ops = { 548 .owner = THIS_MODULE, 549 .family = PF_BLUETOOTH, 550 .create = bt_sock_create, 551 }; 552 553 static int __init bt_init(void) 554 { 555 int err; 556 557 BT_INFO("Core ver %s", VERSION); 558 559 err = bt_sysfs_init(); 560 if (err < 0) 561 return err; 562 563 err = sock_register(&bt_sock_family_ops); 564 if (err < 0) { 565 bt_sysfs_cleanup(); 566 return err; 567 } 568 569 BT_INFO("HCI device and connection manager initialized"); 570 571 err = hci_sock_init(); 572 if (err < 0) 573 goto error; 574 575 err = l2cap_init(); 576 if (err < 0) 577 goto sock_err; 578 579 err = sco_init(); 580 if (err < 0) { 581 l2cap_exit(); 582 goto sock_err; 583 } 584 585 return 0; 586 587 sock_err: 588 hci_sock_cleanup(); 589 590 error: 591 sock_unregister(PF_BLUETOOTH); 592 bt_sysfs_cleanup(); 593 594 return err; 595 } 596 597 static void __exit bt_exit(void) 598 { 599 600 sco_exit(); 601 602 l2cap_exit(); 603 604 hci_sock_cleanup(); 605 606 sock_unregister(PF_BLUETOOTH); 607 608 bt_sysfs_cleanup(); 609 } 610 611 subsys_initcall(bt_init); 612 module_exit(bt_exit); 613 614 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>"); 615 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION); 616 MODULE_VERSION(VERSION); 617 MODULE_LICENSE("GPL"); 618 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH); 619