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 #define VERSION "2.16"
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
);
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",
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",
64 void bt_sock_reclassify_lock(struct sock
*sk
, int proto
)
67 BUG_ON(sock_owned_by_user(sk
));
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
]);
73 EXPORT_SYMBOL(bt_sock_reclassify_lock
);
75 int bt_sock_register(int proto
, const struct net_proto_family
*ops
)
79 if (proto
< 0 || proto
>= BT_MAX_PROTO
)
82 write_lock(&bt_proto_lock
);
87 bt_proto
[proto
] = ops
;
89 write_unlock(&bt_proto_lock
);
93 EXPORT_SYMBOL(bt_sock_register
);
95 int bt_sock_unregister(int proto
)
99 if (proto
< 0 || proto
>= BT_MAX_PROTO
)
102 write_lock(&bt_proto_lock
);
104 if (!bt_proto
[proto
])
107 bt_proto
[proto
] = NULL
;
109 write_unlock(&bt_proto_lock
);
113 EXPORT_SYMBOL(bt_sock_unregister
);
115 static int bt_sock_create(struct net
*net
, struct socket
*sock
, int proto
,
120 if (net
!= &init_net
)
121 return -EAFNOSUPPORT
;
123 if (proto
< 0 || proto
>= BT_MAX_PROTO
)
126 if (!bt_proto
[proto
])
127 request_module("bt-proto-%d", proto
);
129 err
= -EPROTONOSUPPORT
;
131 read_lock(&bt_proto_lock
);
133 if (bt_proto
[proto
] && try_module_get(bt_proto
[proto
]->owner
)) {
134 err
= bt_proto
[proto
]->create(net
, sock
, proto
, kern
);
136 bt_sock_reclassify_lock(sock
->sk
, proto
);
137 module_put(bt_proto
[proto
]->owner
);
140 read_unlock(&bt_proto_lock
);
145 void bt_sock_link(struct bt_sock_list
*l
, struct sock
*sk
)
147 write_lock(&l
->lock
);
148 sk_add_node(sk
, &l
->head
);
149 write_unlock(&l
->lock
);
151 EXPORT_SYMBOL(bt_sock_link
);
153 void bt_sock_unlink(struct bt_sock_list
*l
, struct sock
*sk
)
155 write_lock(&l
->lock
);
156 sk_del_node_init(sk
);
157 write_unlock(&l
->lock
);
159 EXPORT_SYMBOL(bt_sock_unlink
);
161 void bt_accept_enqueue(struct sock
*parent
, struct sock
*sk
)
163 BT_DBG("parent %p, sk %p", parent
, sk
);
166 list_add_tail(&bt_sk(sk
)->accept_q
, &bt_sk(parent
)->accept_q
);
167 bt_sk(sk
)->parent
= parent
;
168 parent
->sk_ack_backlog
++;
170 EXPORT_SYMBOL(bt_accept_enqueue
);
172 void bt_accept_unlink(struct sock
*sk
)
174 BT_DBG("sk %p state %d", sk
, sk
->sk_state
);
176 list_del_init(&bt_sk(sk
)->accept_q
);
177 bt_sk(sk
)->parent
->sk_ack_backlog
--;
178 bt_sk(sk
)->parent
= NULL
;
181 EXPORT_SYMBOL(bt_accept_unlink
);
183 struct sock
*bt_accept_dequeue(struct sock
*parent
, struct socket
*newsock
)
185 struct list_head
*p
, *n
;
188 BT_DBG("parent %p", parent
);
190 list_for_each_safe(p
, n
, &bt_sk(parent
)->accept_q
) {
191 sk
= (struct sock
*) list_entry(p
, struct bt_sock
, accept_q
);
195 /* FIXME: Is this check still needed */
196 if (sk
->sk_state
== BT_CLOSED
) {
198 bt_accept_unlink(sk
);
202 if (sk
->sk_state
== BT_CONNECTED
|| !newsock
||
203 test_bit(BT_SK_DEFER_SETUP
, &bt_sk(parent
)->flags
)) {
204 bt_accept_unlink(sk
);
206 sock_graft(sk
, newsock
);
217 EXPORT_SYMBOL(bt_accept_dequeue
);
219 int bt_sock_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
220 struct msghdr
*msg
, size_t len
, int flags
)
222 int noblock
= flags
& MSG_DONTWAIT
;
223 struct sock
*sk
= sock
->sk
;
228 BT_DBG("sock %p sk %p len %zu", sock
, sk
, len
);
230 if (flags
& (MSG_OOB
))
233 skb
= skb_recv_datagram(sk
, flags
, noblock
, &err
);
235 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
240 msg
->msg_namelen
= 0;
244 msg
->msg_flags
|= MSG_TRUNC
;
248 skb_reset_transport_header(skb
);
249 err
= skb_copy_datagram_iovec(skb
, 0, msg
->msg_iov
, copied
);
251 sock_recv_ts_and_drops(msg
, sk
, skb
);
253 skb_free_datagram(sk
, skb
);
255 return err
? : copied
;
257 EXPORT_SYMBOL(bt_sock_recvmsg
);
259 static long bt_sock_data_wait(struct sock
*sk
, long timeo
)
261 DECLARE_WAITQUEUE(wait
, current
);
263 add_wait_queue(sk_sleep(sk
), &wait
);
265 set_current_state(TASK_INTERRUPTIBLE
);
267 if (!skb_queue_empty(&sk
->sk_receive_queue
))
270 if (sk
->sk_err
|| (sk
->sk_shutdown
& RCV_SHUTDOWN
))
273 if (signal_pending(current
) || !timeo
)
276 set_bit(SOCK_ASYNC_WAITDATA
, &sk
->sk_socket
->flags
);
278 timeo
= schedule_timeout(timeo
);
280 clear_bit(SOCK_ASYNC_WAITDATA
, &sk
->sk_socket
->flags
);
283 __set_current_state(TASK_RUNNING
);
284 remove_wait_queue(sk_sleep(sk
), &wait
);
288 int bt_sock_stream_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
289 struct msghdr
*msg
, size_t size
, int flags
)
291 struct sock
*sk
= sock
->sk
;
293 size_t target
, copied
= 0;
299 msg
->msg_namelen
= 0;
301 BT_DBG("sk %p size %zu", sk
, size
);
305 target
= sock_rcvlowat(sk
, flags
& MSG_WAITALL
, size
);
306 timeo
= sock_rcvtimeo(sk
, flags
& MSG_DONTWAIT
);
312 skb
= skb_dequeue(&sk
->sk_receive_queue
);
314 if (copied
>= target
)
317 err
= sock_error(sk
);
320 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
327 timeo
= bt_sock_data_wait(sk
, timeo
);
329 if (signal_pending(current
)) {
330 err
= sock_intr_errno(timeo
);
336 chunk
= min_t(unsigned int, skb
->len
, size
);
337 if (skb_copy_datagram_iovec(skb
, 0, msg
->msg_iov
, chunk
)) {
338 skb_queue_head(&sk
->sk_receive_queue
, skb
);
346 sock_recv_ts_and_drops(msg
, sk
, skb
);
348 if (!(flags
& MSG_PEEK
)) {
349 int skb_len
= skb_headlen(skb
);
351 if (chunk
<= skb_len
) {
352 __skb_pull(skb
, chunk
);
354 struct sk_buff
*frag
;
356 __skb_pull(skb
, skb_len
);
359 skb_walk_frags(skb
, frag
) {
360 if (chunk
<= frag
->len
) {
361 /* Pulling partial data */
363 skb
->data_len
-= chunk
;
364 __skb_pull(frag
, chunk
);
366 } else if (frag
->len
) {
367 /* Pulling all frag data */
369 skb
->len
-= frag
->len
;
370 skb
->data_len
-= frag
->len
;
371 __skb_pull(frag
, frag
->len
);
377 skb_queue_head(&sk
->sk_receive_queue
, skb
);
383 /* put message back and return */
384 skb_queue_head(&sk
->sk_receive_queue
, skb
);
391 return copied
? : err
;
393 EXPORT_SYMBOL(bt_sock_stream_recvmsg
);
395 static inline unsigned int bt_accept_poll(struct sock
*parent
)
397 struct list_head
*p
, *n
;
400 list_for_each_safe(p
, n
, &bt_sk(parent
)->accept_q
) {
401 sk
= (struct sock
*) list_entry(p
, struct bt_sock
, accept_q
);
402 if (sk
->sk_state
== BT_CONNECTED
||
403 (test_bit(BT_SK_DEFER_SETUP
, &bt_sk(parent
)->flags
) &&
404 sk
->sk_state
== BT_CONNECT2
))
405 return POLLIN
| POLLRDNORM
;
411 unsigned int bt_sock_poll(struct file
*file
, struct socket
*sock
,
414 struct sock
*sk
= sock
->sk
;
415 unsigned int mask
= 0;
417 BT_DBG("sock %p, sk %p", sock
, sk
);
419 poll_wait(file
, sk_sleep(sk
), wait
);
421 if (sk
->sk_state
== BT_LISTEN
)
422 return bt_accept_poll(sk
);
424 if (sk
->sk_err
|| !skb_queue_empty(&sk
->sk_error_queue
))
426 (sock_flag(sk
, SOCK_SELECT_ERR_QUEUE
) ? POLLPRI
: 0);
428 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
429 mask
|= POLLRDHUP
| POLLIN
| POLLRDNORM
;
431 if (sk
->sk_shutdown
== SHUTDOWN_MASK
)
434 if (!skb_queue_empty(&sk
->sk_receive_queue
))
435 mask
|= POLLIN
| POLLRDNORM
;
437 if (sk
->sk_state
== BT_CLOSED
)
440 if (sk
->sk_state
== BT_CONNECT
||
441 sk
->sk_state
== BT_CONNECT2
||
442 sk
->sk_state
== BT_CONFIG
)
445 if (!test_bit(BT_SK_SUSPEND
, &bt_sk(sk
)->flags
) && sock_writeable(sk
))
446 mask
|= POLLOUT
| POLLWRNORM
| POLLWRBAND
;
448 set_bit(SOCK_ASYNC_NOSPACE
, &sk
->sk_socket
->flags
);
452 EXPORT_SYMBOL(bt_sock_poll
);
454 int bt_sock_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
456 struct sock
*sk
= sock
->sk
;
461 BT_DBG("sk %p cmd %x arg %lx", sk
, cmd
, arg
);
465 if (sk
->sk_state
== BT_LISTEN
)
468 amount
= sk
->sk_sndbuf
- sk_wmem_alloc_get(sk
);
471 err
= put_user(amount
, (int __user
*) arg
);
475 if (sk
->sk_state
== BT_LISTEN
)
479 skb
= skb_peek(&sk
->sk_receive_queue
);
480 amount
= skb
? skb
->len
: 0;
482 err
= put_user(amount
, (int __user
*) arg
);
486 err
= sock_get_timestamp(sk
, (struct timeval __user
*) arg
);
490 err
= sock_get_timestampns(sk
, (struct timespec __user
*) arg
);
500 EXPORT_SYMBOL(bt_sock_ioctl
);
502 int bt_sock_wait_state(struct sock
*sk
, int state
, unsigned long timeo
)
504 DECLARE_WAITQUEUE(wait
, current
);
509 add_wait_queue(sk_sleep(sk
), &wait
);
510 set_current_state(TASK_INTERRUPTIBLE
);
511 while (sk
->sk_state
!= state
) {
517 if (signal_pending(current
)) {
518 err
= sock_intr_errno(timeo
);
523 timeo
= schedule_timeout(timeo
);
525 set_current_state(TASK_INTERRUPTIBLE
);
527 err
= sock_error(sk
);
531 __set_current_state(TASK_RUNNING
);
532 remove_wait_queue(sk_sleep(sk
), &wait
);
535 EXPORT_SYMBOL(bt_sock_wait_state
);
537 #ifdef CONFIG_PROC_FS
538 struct bt_seq_state
{
539 struct bt_sock_list
*l
;
542 static void *bt_seq_start(struct seq_file
*seq
, loff_t
*pos
)
543 __acquires(seq
->private->l
->lock
)
545 struct bt_seq_state
*s
= seq
->private;
546 struct bt_sock_list
*l
= s
->l
;
549 return seq_hlist_start_head(&l
->head
, *pos
);
552 static void *bt_seq_next(struct seq_file
*seq
, void *v
, loff_t
*pos
)
554 struct bt_seq_state
*s
= seq
->private;
555 struct bt_sock_list
*l
= s
->l
;
557 return seq_hlist_next(v
, &l
->head
, pos
);
560 static void bt_seq_stop(struct seq_file
*seq
, void *v
)
561 __releases(seq
->private->l
->lock
)
563 struct bt_seq_state
*s
= seq
->private;
564 struct bt_sock_list
*l
= s
->l
;
566 read_unlock(&l
->lock
);
569 static int bt_seq_show(struct seq_file
*seq
, void *v
)
571 struct bt_seq_state
*s
= seq
->private;
572 struct bt_sock_list
*l
= s
->l
;
574 if (v
== SEQ_START_TOKEN
) {
575 seq_puts(seq
,"sk RefCnt Rmem Wmem User Inode Src Dst Parent");
577 if (l
->custom_seq_show
) {
579 l
->custom_seq_show(seq
, v
);
584 struct sock
*sk
= sk_entry(v
);
585 struct bt_sock
*bt
= bt_sk(sk
);
588 "%pK %-6d %-6u %-6u %-6u %-6lu %pMR %pMR %-6lu",
590 atomic_read(&sk
->sk_refcnt
),
591 sk_rmem_alloc_get(sk
),
592 sk_wmem_alloc_get(sk
),
593 from_kuid(seq_user_ns(seq
), sock_i_uid(sk
)),
597 bt
->parent
? sock_i_ino(bt
->parent
): 0LU);
599 if (l
->custom_seq_show
) {
601 l
->custom_seq_show(seq
, v
);
609 static struct seq_operations bt_seq_ops
= {
610 .start
= bt_seq_start
,
616 static int bt_seq_open(struct inode
*inode
, struct file
*file
)
618 struct bt_sock_list
*sk_list
;
619 struct bt_seq_state
*s
;
621 sk_list
= PDE(inode
)->data
;
622 s
= __seq_open_private(file
, &bt_seq_ops
,
623 sizeof(struct bt_seq_state
));
631 int bt_procfs_init(struct module
* module
, struct net
*net
, const char *name
,
632 struct bt_sock_list
* sk_list
,
633 int (* seq_show
)(struct seq_file
*, void *))
635 struct proc_dir_entry
* pde
;
637 sk_list
->custom_seq_show
= seq_show
;
639 sk_list
->fops
.owner
= module
;
640 sk_list
->fops
.open
= bt_seq_open
;
641 sk_list
->fops
.read
= seq_read
;
642 sk_list
->fops
.llseek
= seq_lseek
;
643 sk_list
->fops
.release
= seq_release_private
;
645 pde
= proc_create(name
, 0, net
->proc_net
, &sk_list
->fops
);
654 void bt_procfs_cleanup(struct net
*net
, const char *name
)
656 remove_proc_entry(name
, net
->proc_net
);
659 int bt_procfs_init(struct module
* module
, struct net
*net
, const char *name
,
660 struct bt_sock_list
* sk_list
,
661 int (* seq_show
)(struct seq_file
*, void *))
666 void bt_procfs_cleanup(struct net
*net
, const char *name
)
670 EXPORT_SYMBOL(bt_procfs_init
);
671 EXPORT_SYMBOL(bt_procfs_cleanup
);
673 static struct net_proto_family bt_sock_family_ops
= {
674 .owner
= THIS_MODULE
,
675 .family
= PF_BLUETOOTH
,
676 .create
= bt_sock_create
,
679 static int __init
bt_init(void)
683 BT_INFO("Core ver %s", VERSION
);
685 err
= bt_sysfs_init();
689 err
= sock_register(&bt_sock_family_ops
);
695 BT_INFO("HCI device and connection manager initialized");
697 err
= hci_sock_init();
717 sock_unregister(PF_BLUETOOTH
);
723 static void __exit
bt_exit(void)
732 sock_unregister(PF_BLUETOOTH
);
737 subsys_initcall(bt_init
);
738 module_exit(bt_exit
);
740 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
741 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION
);
742 MODULE_VERSION(VERSION
);
743 MODULE_LICENSE("GPL");
744 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH
);