2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
5 Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com>
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;
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.
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.
25 /* Bluetooth address family and sockets. */
27 #include <linux/module.h>
28 #include <asm/ioctls.h>
30 #include <net/bluetooth/bluetooth.h>
31 #include <linux/proc_fs.h>
33 #ifndef CONFIG_BT_SOCK_DEBUG
38 #define VERSION "2.16"
40 /* Bluetooth sockets */
41 #define BT_MAX_PROTO 8
42 static const struct net_proto_family
*bt_proto
[BT_MAX_PROTO
];
43 static DEFINE_RWLOCK(bt_proto_lock
);
45 static struct lock_class_key bt_lock_key
[BT_MAX_PROTO
];
46 static const char *const bt_key_strings
[BT_MAX_PROTO
] = {
47 "sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
48 "sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
49 "sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
50 "sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
51 "sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
52 "sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
53 "sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
54 "sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
57 static struct lock_class_key bt_slock_key
[BT_MAX_PROTO
];
58 static const char *const bt_slock_key_strings
[BT_MAX_PROTO
] = {
59 "slock-AF_BLUETOOTH-BTPROTO_L2CAP",
60 "slock-AF_BLUETOOTH-BTPROTO_HCI",
61 "slock-AF_BLUETOOTH-BTPROTO_SCO",
62 "slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
63 "slock-AF_BLUETOOTH-BTPROTO_BNEP",
64 "slock-AF_BLUETOOTH-BTPROTO_CMTP",
65 "slock-AF_BLUETOOTH-BTPROTO_HIDP",
66 "slock-AF_BLUETOOTH-BTPROTO_AVDTP",
69 void bt_sock_reclassify_lock(struct sock
*sk
, int proto
)
72 BUG_ON(sock_owned_by_user(sk
));
74 sock_lock_init_class_and_name(sk
,
75 bt_slock_key_strings
[proto
], &bt_slock_key
[proto
],
76 bt_key_strings
[proto
], &bt_lock_key
[proto
]);
78 EXPORT_SYMBOL(bt_sock_reclassify_lock
);
80 int bt_sock_register(int proto
, const struct net_proto_family
*ops
)
84 if (proto
< 0 || proto
>= BT_MAX_PROTO
)
87 write_lock(&bt_proto_lock
);
92 bt_proto
[proto
] = ops
;
94 write_unlock(&bt_proto_lock
);
98 EXPORT_SYMBOL(bt_sock_register
);
100 void bt_sock_unregister(int proto
)
102 if (proto
< 0 || proto
>= BT_MAX_PROTO
)
105 write_lock(&bt_proto_lock
);
106 bt_proto
[proto
] = NULL
;
107 write_unlock(&bt_proto_lock
);
109 EXPORT_SYMBOL(bt_sock_unregister
);
111 #ifdef CONFIG_PARANOID_NETWORK
112 static inline int current_has_bt_admin(void)
114 return !current_euid();
117 static inline int current_has_bt(void)
119 return current_has_bt_admin();
122 static inline int current_has_bt_admin(void)
127 static inline int current_has_bt(void)
133 static int bt_sock_create(struct net
*net
, struct socket
*sock
, int proto
,
138 if (proto
== BTPROTO_RFCOMM
|| proto
== BTPROTO_SCO
||
139 proto
== BTPROTO_L2CAP
) {
140 if (!current_has_bt())
142 } else if (!current_has_bt_admin())
145 if (net
!= &init_net
)
146 return -EAFNOSUPPORT
;
148 if (proto
< 0 || proto
>= BT_MAX_PROTO
)
151 if (!bt_proto
[proto
])
152 request_module("bt-proto-%d", proto
);
154 err
= -EPROTONOSUPPORT
;
156 read_lock(&bt_proto_lock
);
158 if (bt_proto
[proto
] && try_module_get(bt_proto
[proto
]->owner
)) {
159 err
= bt_proto
[proto
]->create(net
, sock
, proto
, kern
);
161 bt_sock_reclassify_lock(sock
->sk
, proto
);
162 module_put(bt_proto
[proto
]->owner
);
165 read_unlock(&bt_proto_lock
);
170 void bt_sock_link(struct bt_sock_list
*l
, struct sock
*sk
)
172 write_lock(&l
->lock
);
173 sk_add_node(sk
, &l
->head
);
174 write_unlock(&l
->lock
);
176 EXPORT_SYMBOL(bt_sock_link
);
178 void bt_sock_unlink(struct bt_sock_list
*l
, struct sock
*sk
)
180 write_lock(&l
->lock
);
181 sk_del_node_init(sk
);
182 write_unlock(&l
->lock
);
184 EXPORT_SYMBOL(bt_sock_unlink
);
186 void bt_accept_enqueue(struct sock
*parent
, struct sock
*sk
)
188 BT_DBG("parent %p, sk %p", parent
, sk
);
191 list_add_tail(&bt_sk(sk
)->accept_q
, &bt_sk(parent
)->accept_q
);
192 bt_sk(sk
)->parent
= parent
;
193 parent
->sk_ack_backlog
++;
195 EXPORT_SYMBOL(bt_accept_enqueue
);
197 void bt_accept_unlink(struct sock
*sk
)
199 BT_DBG("sk %p state %d", sk
, sk
->sk_state
);
201 list_del_init(&bt_sk(sk
)->accept_q
);
202 bt_sk(sk
)->parent
->sk_ack_backlog
--;
203 bt_sk(sk
)->parent
= NULL
;
206 EXPORT_SYMBOL(bt_accept_unlink
);
208 struct sock
*bt_accept_dequeue(struct sock
*parent
, struct socket
*newsock
)
210 struct list_head
*p
, *n
;
213 BT_DBG("parent %p", parent
);
215 list_for_each_safe(p
, n
, &bt_sk(parent
)->accept_q
) {
216 sk
= (struct sock
*) list_entry(p
, struct bt_sock
, accept_q
);
220 /* FIXME: Is this check still needed */
221 if (sk
->sk_state
== BT_CLOSED
) {
223 bt_accept_unlink(sk
);
227 if (sk
->sk_state
== BT_CONNECTED
|| !newsock
||
228 test_bit(BT_SK_DEFER_SETUP
, &bt_sk(parent
)->flags
)) {
229 bt_accept_unlink(sk
);
231 sock_graft(sk
, newsock
);
242 EXPORT_SYMBOL(bt_accept_dequeue
);
244 int bt_sock_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
245 struct msghdr
*msg
, size_t len
, int flags
)
247 int noblock
= flags
& MSG_DONTWAIT
;
248 struct sock
*sk
= sock
->sk
;
253 BT_DBG("sock %p sk %p len %zu", sock
, sk
, len
);
255 if (flags
& (MSG_OOB
))
258 skb
= skb_recv_datagram(sk
, flags
, noblock
, &err
);
260 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
267 msg
->msg_flags
|= MSG_TRUNC
;
271 skb_reset_transport_header(skb
);
272 err
= skb_copy_datagram_iovec(skb
, 0, msg
->msg_iov
, copied
);
274 sock_recv_ts_and_drops(msg
, sk
, skb
);
276 skb_free_datagram(sk
, skb
);
278 return err
? : copied
;
280 EXPORT_SYMBOL(bt_sock_recvmsg
);
282 static long bt_sock_data_wait(struct sock
*sk
, long timeo
)
284 DECLARE_WAITQUEUE(wait
, current
);
286 add_wait_queue(sk_sleep(sk
), &wait
);
288 set_current_state(TASK_INTERRUPTIBLE
);
290 if (!skb_queue_empty(&sk
->sk_receive_queue
))
293 if (sk
->sk_err
|| (sk
->sk_shutdown
& RCV_SHUTDOWN
))
296 if (signal_pending(current
) || !timeo
)
299 set_bit(SOCK_ASYNC_WAITDATA
, &sk
->sk_socket
->flags
);
301 timeo
= schedule_timeout(timeo
);
303 clear_bit(SOCK_ASYNC_WAITDATA
, &sk
->sk_socket
->flags
);
306 __set_current_state(TASK_RUNNING
);
307 remove_wait_queue(sk_sleep(sk
), &wait
);
311 int bt_sock_stream_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
312 struct msghdr
*msg
, size_t size
, int flags
)
314 struct sock
*sk
= sock
->sk
;
316 size_t target
, copied
= 0;
322 BT_DBG("sk %p size %zu", sk
, size
);
326 target
= sock_rcvlowat(sk
, flags
& MSG_WAITALL
, size
);
327 timeo
= sock_rcvtimeo(sk
, flags
& MSG_DONTWAIT
);
333 skb
= skb_dequeue(&sk
->sk_receive_queue
);
335 if (copied
>= target
)
338 err
= sock_error(sk
);
341 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
348 timeo
= bt_sock_data_wait(sk
, timeo
);
350 if (signal_pending(current
)) {
351 err
= sock_intr_errno(timeo
);
357 chunk
= min_t(unsigned int, skb
->len
, size
);
358 if (skb_copy_datagram_iovec(skb
, 0, msg
->msg_iov
, chunk
)) {
359 skb_queue_head(&sk
->sk_receive_queue
, skb
);
367 sock_recv_ts_and_drops(msg
, sk
, skb
);
369 if (!(flags
& MSG_PEEK
)) {
370 int skb_len
= skb_headlen(skb
);
372 if (chunk
<= skb_len
) {
373 __skb_pull(skb
, chunk
);
375 struct sk_buff
*frag
;
377 __skb_pull(skb
, skb_len
);
380 skb_walk_frags(skb
, frag
) {
381 if (chunk
<= frag
->len
) {
382 /* Pulling partial data */
384 skb
->data_len
-= chunk
;
385 __skb_pull(frag
, chunk
);
387 } else if (frag
->len
) {
388 /* Pulling all frag data */
390 skb
->len
-= frag
->len
;
391 skb
->data_len
-= frag
->len
;
392 __skb_pull(frag
, frag
->len
);
398 skb_queue_head(&sk
->sk_receive_queue
, skb
);
404 /* put message back and return */
405 skb_queue_head(&sk
->sk_receive_queue
, skb
);
412 return copied
? : err
;
414 EXPORT_SYMBOL(bt_sock_stream_recvmsg
);
416 static inline unsigned int bt_accept_poll(struct sock
*parent
)
418 struct list_head
*p
, *n
;
421 list_for_each_safe(p
, n
, &bt_sk(parent
)->accept_q
) {
422 sk
= (struct sock
*) list_entry(p
, struct bt_sock
, accept_q
);
423 if (sk
->sk_state
== BT_CONNECTED
||
424 (test_bit(BT_SK_DEFER_SETUP
, &bt_sk(parent
)->flags
) &&
425 sk
->sk_state
== BT_CONNECT2
))
426 return POLLIN
| POLLRDNORM
;
432 unsigned int bt_sock_poll(struct file
*file
, struct socket
*sock
,
435 struct sock
*sk
= sock
->sk
;
436 unsigned int mask
= 0;
438 BT_DBG("sock %p, sk %p", sock
, sk
);
440 poll_wait(file
, sk_sleep(sk
), wait
);
442 if (sk
->sk_state
== BT_LISTEN
)
443 return bt_accept_poll(sk
);
445 if (sk
->sk_err
|| !skb_queue_empty(&sk
->sk_error_queue
))
447 (sock_flag(sk
, SOCK_SELECT_ERR_QUEUE
) ? POLLPRI
: 0);
449 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
450 mask
|= POLLRDHUP
| POLLIN
| POLLRDNORM
;
452 if (sk
->sk_shutdown
== SHUTDOWN_MASK
)
455 if (!skb_queue_empty(&sk
->sk_receive_queue
))
456 mask
|= POLLIN
| POLLRDNORM
;
458 if (sk
->sk_state
== BT_CLOSED
)
461 if (sk
->sk_state
== BT_CONNECT
||
462 sk
->sk_state
== BT_CONNECT2
||
463 sk
->sk_state
== BT_CONFIG
)
466 if (!test_bit(BT_SK_SUSPEND
, &bt_sk(sk
)->flags
) && sock_writeable(sk
))
467 mask
|= POLLOUT
| POLLWRNORM
| POLLWRBAND
;
469 set_bit(SOCK_ASYNC_NOSPACE
, &sk
->sk_socket
->flags
);
473 EXPORT_SYMBOL(bt_sock_poll
);
475 int bt_sock_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
477 struct sock
*sk
= sock
->sk
;
482 BT_DBG("sk %p cmd %x arg %lx", sk
, cmd
, arg
);
486 if (sk
->sk_state
== BT_LISTEN
)
489 amount
= sk
->sk_sndbuf
- sk_wmem_alloc_get(sk
);
492 err
= put_user(amount
, (int __user
*) arg
);
496 if (sk
->sk_state
== BT_LISTEN
)
500 skb
= skb_peek(&sk
->sk_receive_queue
);
501 amount
= skb
? skb
->len
: 0;
503 err
= put_user(amount
, (int __user
*) arg
);
507 err
= sock_get_timestamp(sk
, (struct timeval __user
*) arg
);
511 err
= sock_get_timestampns(sk
, (struct timespec __user
*) arg
);
521 EXPORT_SYMBOL(bt_sock_ioctl
);
523 int bt_sock_wait_state(struct sock
*sk
, int state
, unsigned long timeo
)
525 DECLARE_WAITQUEUE(wait
, current
);
530 add_wait_queue(sk_sleep(sk
), &wait
);
531 set_current_state(TASK_INTERRUPTIBLE
);
532 while (sk
->sk_state
!= state
) {
538 if (signal_pending(current
)) {
539 err
= sock_intr_errno(timeo
);
544 timeo
= schedule_timeout(timeo
);
546 set_current_state(TASK_INTERRUPTIBLE
);
548 err
= sock_error(sk
);
552 __set_current_state(TASK_RUNNING
);
553 remove_wait_queue(sk_sleep(sk
), &wait
);
556 EXPORT_SYMBOL(bt_sock_wait_state
);
558 #ifdef CONFIG_PROC_FS
559 struct bt_seq_state
{
560 struct bt_sock_list
*l
;
563 static void *bt_seq_start(struct seq_file
*seq
, loff_t
*pos
)
564 __acquires(seq
->private->l
->lock
)
566 struct bt_seq_state
*s
= seq
->private;
567 struct bt_sock_list
*l
= s
->l
;
570 return seq_hlist_start_head(&l
->head
, *pos
);
573 static void *bt_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
575 struct bt_seq_state
*s
= seq
->private;
576 struct bt_sock_list
*l
= s
->l
;
578 return seq_hlist_next(v
, &l
->head
, pos
);
581 static void bt_seq_stop(struct seq_file
*seq
, void *v
)
582 __releases(seq
->private->l
->lock
)
584 struct bt_seq_state
*s
= seq
->private;
585 struct bt_sock_list
*l
= s
->l
;
587 read_unlock(&l
->lock
);
590 static int bt_seq_show(struct seq_file
*seq
, void *v
)
592 struct bt_seq_state
*s
= seq
->private;
593 struct bt_sock_list
*l
= s
->l
;
595 if (v
== SEQ_START_TOKEN
) {
596 seq_puts(seq
,"sk RefCnt Rmem Wmem User Inode Src Dst Parent");
598 if (l
->custom_seq_show
) {
600 l
->custom_seq_show(seq
, v
);
605 struct sock
*sk
= sk_entry(v
);
606 struct bt_sock
*bt
= bt_sk(sk
);
609 "%pK %-6d %-6u %-6u %-6u %-6lu %pMR %pMR %-6lu",
611 atomic_read(&sk
->sk_refcnt
),
612 sk_rmem_alloc_get(sk
),
613 sk_wmem_alloc_get(sk
),
614 from_kuid(seq_user_ns(seq
), sock_i_uid(sk
)),
618 bt
->parent
? sock_i_ino(bt
->parent
): 0LU);
620 if (l
->custom_seq_show
) {
622 l
->custom_seq_show(seq
, v
);
630 static struct seq_operations bt_seq_ops
= {
631 .start
= bt_seq_start
,
637 static int bt_seq_open(struct inode
*inode
, struct file
*file
)
639 struct bt_sock_list
*sk_list
;
640 struct bt_seq_state
*s
;
642 sk_list
= PDE_DATA(inode
);
643 s
= __seq_open_private(file
, &bt_seq_ops
,
644 sizeof(struct bt_seq_state
));
652 static const struct file_operations bt_fops
= {
656 .release
= seq_release_private
659 int bt_procfs_init(struct net
*net
, const char *name
,
660 struct bt_sock_list
* sk_list
,
661 int (* seq_show
)(struct seq_file
*, void *))
663 sk_list
->custom_seq_show
= seq_show
;
665 if (!proc_create_data(name
, 0, net
->proc_net
, &bt_fops
, sk_list
))
670 void bt_procfs_cleanup(struct net
*net
, const char *name
)
672 remove_proc_entry(name
, net
->proc_net
);
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 *))
682 void bt_procfs_cleanup(struct net
*net
, const char *name
)
686 EXPORT_SYMBOL(bt_procfs_init
);
687 EXPORT_SYMBOL(bt_procfs_cleanup
);
689 static struct net_proto_family bt_sock_family_ops
= {
690 .owner
= THIS_MODULE
,
691 .family
= PF_BLUETOOTH
,
692 .create
= bt_sock_create
,
695 static int __init
bt_init(void)
699 BT_INFO("Core ver %s", VERSION
);
701 err
= bt_sysfs_init();
705 err
= sock_register(&bt_sock_family_ops
);
711 BT_INFO("HCI device and connection manager initialized");
713 err
= hci_sock_init();
733 sock_unregister(PF_BLUETOOTH
);
739 static void __exit
bt_exit(void)
748 sock_unregister(PF_BLUETOOTH
);
753 subsys_initcall(bt_init
);
754 module_exit(bt_exit
);
756 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
757 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION
);
758 MODULE_VERSION(VERSION
);
759 MODULE_LICENSE("GPL");
760 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH
);