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>
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>
38 #include <asm/ioctls.h>
39 #include <linux/kmod.h>
41 #include <net/bluetooth/bluetooth.h>
43 #define VERSION "2.15"
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
);
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",
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",
74 static inline void bt_sock_reclassify_lock(struct socket
*sock
, int proto
)
76 struct sock
*sk
= sock
->sk
;
81 BUG_ON(sock_owned_by_user(sk
));
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
]);
88 int bt_sock_register(int proto
, const struct net_proto_family
*ops
)
92 if (proto
< 0 || proto
>= BT_MAX_PROTO
)
95 write_lock(&bt_proto_lock
);
100 bt_proto
[proto
] = ops
;
102 write_unlock(&bt_proto_lock
);
106 EXPORT_SYMBOL(bt_sock_register
);
108 int bt_sock_unregister(int proto
)
112 if (proto
< 0 || proto
>= BT_MAX_PROTO
)
115 write_lock(&bt_proto_lock
);
117 if (!bt_proto
[proto
])
120 bt_proto
[proto
] = NULL
;
122 write_unlock(&bt_proto_lock
);
126 EXPORT_SYMBOL(bt_sock_unregister
);
128 static int bt_sock_create(struct net
*net
, struct socket
*sock
, int proto
,
133 if (net
!= &init_net
)
134 return -EAFNOSUPPORT
;
136 if (proto
< 0 || proto
>= BT_MAX_PROTO
)
139 if (!bt_proto
[proto
])
140 request_module("bt-proto-%d", proto
);
142 err
= -EPROTONOSUPPORT
;
144 read_lock(&bt_proto_lock
);
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
);
152 read_unlock(&bt_proto_lock
);
157 void bt_sock_link(struct bt_sock_list
*l
, struct sock
*sk
)
159 write_lock_bh(&l
->lock
);
160 sk_add_node(sk
, &l
->head
);
161 write_unlock_bh(&l
->lock
);
163 EXPORT_SYMBOL(bt_sock_link
);
165 void bt_sock_unlink(struct bt_sock_list
*l
, struct sock
*sk
)
167 write_lock_bh(&l
->lock
);
168 sk_del_node_init(sk
);
169 write_unlock_bh(&l
->lock
);
171 EXPORT_SYMBOL(bt_sock_unlink
);
173 void bt_accept_enqueue(struct sock
*parent
, struct sock
*sk
)
175 BT_DBG("parent %p, sk %p", parent
, 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
++;
182 EXPORT_SYMBOL(bt_accept_enqueue
);
184 void bt_accept_unlink(struct sock
*sk
)
186 BT_DBG("sk %p state %d", sk
, sk
->sk_state
);
188 list_del_init(&bt_sk(sk
)->accept_q
);
189 bt_sk(sk
)->parent
->sk_ack_backlog
--;
190 bt_sk(sk
)->parent
= NULL
;
193 EXPORT_SYMBOL(bt_accept_unlink
);
195 struct sock
*bt_accept_dequeue(struct sock
*parent
, struct socket
*newsock
)
197 struct list_head
*p
, *n
;
200 BT_DBG("parent %p", parent
);
202 list_for_each_safe(p
, n
, &bt_sk(parent
)->accept_q
) {
203 sk
= (struct sock
*) list_entry(p
, struct bt_sock
, accept_q
);
207 /* FIXME: Is this check still needed */
208 if (sk
->sk_state
== BT_CLOSED
) {
210 bt_accept_unlink(sk
);
214 if (sk
->sk_state
== BT_CONNECTED
|| !newsock
||
215 bt_sk(parent
)->defer_setup
) {
216 bt_accept_unlink(sk
);
218 sock_graft(sk
, newsock
);
227 EXPORT_SYMBOL(bt_accept_dequeue
);
229 int bt_sock_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
230 struct msghdr
*msg
, size_t len
, int flags
)
232 int noblock
= flags
& MSG_DONTWAIT
;
233 struct sock
*sk
= sock
->sk
;
238 BT_DBG("sock %p sk %p len %zu", sock
, sk
, len
);
240 if (flags
& (MSG_OOB
))
243 skb
= skb_recv_datagram(sk
, flags
, noblock
, &err
);
245 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
250 msg
->msg_namelen
= 0;
254 msg
->msg_flags
|= MSG_TRUNC
;
258 skb_reset_transport_header(skb
);
259 err
= skb_copy_datagram_iovec(skb
, 0, msg
->msg_iov
, copied
);
261 sock_recv_ts_and_drops(msg
, sk
, skb
);
263 skb_free_datagram(sk
, skb
);
265 return err
? : copied
;
267 EXPORT_SYMBOL(bt_sock_recvmsg
);
269 static long bt_sock_data_wait(struct sock
*sk
, long timeo
)
271 DECLARE_WAITQUEUE(wait
, current
);
273 add_wait_queue(sk_sleep(sk
), &wait
);
275 set_current_state(TASK_INTERRUPTIBLE
);
277 if (!skb_queue_empty(&sk
->sk_receive_queue
))
280 if (sk
->sk_err
|| (sk
->sk_shutdown
& RCV_SHUTDOWN
))
283 if (signal_pending(current
) || !timeo
)
286 set_bit(SOCK_ASYNC_WAITDATA
, &sk
->sk_socket
->flags
);
288 timeo
= schedule_timeout(timeo
);
290 clear_bit(SOCK_ASYNC_WAITDATA
, &sk
->sk_socket
->flags
);
293 __set_current_state(TASK_RUNNING
);
294 remove_wait_queue(sk_sleep(sk
), &wait
);
298 int bt_sock_stream_recvmsg(struct kiocb
*iocb
, struct socket
*sock
,
299 struct msghdr
*msg
, size_t size
, int flags
)
301 struct sock
*sk
= sock
->sk
;
303 size_t target
, copied
= 0;
309 msg
->msg_namelen
= 0;
311 BT_DBG("sk %p size %zu", sk
, size
);
315 target
= sock_rcvlowat(sk
, flags
& MSG_WAITALL
, size
);
316 timeo
= sock_rcvtimeo(sk
, flags
& MSG_DONTWAIT
);
322 skb
= skb_dequeue(&sk
->sk_receive_queue
);
324 if (copied
>= target
)
327 err
= sock_error(sk
);
330 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
337 timeo
= bt_sock_data_wait(sk
, timeo
);
339 if (signal_pending(current
)) {
340 err
= sock_intr_errno(timeo
);
346 chunk
= min_t(unsigned int, skb
->len
, size
);
347 if (memcpy_toiovec(msg
->msg_iov
, skb
->data
, chunk
)) {
348 skb_queue_head(&sk
->sk_receive_queue
, skb
);
356 sock_recv_ts_and_drops(msg
, sk
, skb
);
358 if (!(flags
& MSG_PEEK
)) {
359 skb_pull(skb
, chunk
);
361 skb_queue_head(&sk
->sk_receive_queue
, skb
);
367 /* put message back and return */
368 skb_queue_head(&sk
->sk_receive_queue
, skb
);
375 return copied
? : err
;
377 EXPORT_SYMBOL(bt_sock_stream_recvmsg
);
379 static inline unsigned int bt_accept_poll(struct sock
*parent
)
381 struct list_head
*p
, *n
;
384 list_for_each_safe(p
, n
, &bt_sk(parent
)->accept_q
) {
385 sk
= (struct sock
*) list_entry(p
, struct bt_sock
, accept_q
);
386 if (sk
->sk_state
== BT_CONNECTED
||
387 (bt_sk(parent
)->defer_setup
&&
388 sk
->sk_state
== BT_CONNECT2
))
389 return POLLIN
| POLLRDNORM
;
395 unsigned int bt_sock_poll(struct file
* file
, struct socket
*sock
, poll_table
*wait
)
397 struct sock
*sk
= sock
->sk
;
398 unsigned int mask
= 0;
400 BT_DBG("sock %p, sk %p", sock
, sk
);
402 poll_wait(file
, sk_sleep(sk
), wait
);
404 if (sk
->sk_state
== BT_LISTEN
)
405 return bt_accept_poll(sk
);
407 if (sk
->sk_err
|| !skb_queue_empty(&sk
->sk_error_queue
))
410 if (sk
->sk_shutdown
& RCV_SHUTDOWN
)
411 mask
|= POLLRDHUP
| POLLIN
| POLLRDNORM
;
413 if (sk
->sk_shutdown
== SHUTDOWN_MASK
)
416 if (!skb_queue_empty(&sk
->sk_receive_queue
))
417 mask
|= POLLIN
| POLLRDNORM
;
419 if (sk
->sk_state
== BT_CLOSED
)
422 if (sk
->sk_state
== BT_CONNECT
||
423 sk
->sk_state
== BT_CONNECT2
||
424 sk
->sk_state
== BT_CONFIG
)
427 if (sock_writeable(sk
))
428 mask
|= POLLOUT
| POLLWRNORM
| POLLWRBAND
;
430 set_bit(SOCK_ASYNC_NOSPACE
, &sk
->sk_socket
->flags
);
434 EXPORT_SYMBOL(bt_sock_poll
);
436 int bt_sock_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
438 struct sock
*sk
= sock
->sk
;
443 BT_DBG("sk %p cmd %x arg %lx", sk
, cmd
, arg
);
447 if (sk
->sk_state
== BT_LISTEN
)
450 amount
= sk
->sk_sndbuf
- sk_wmem_alloc_get(sk
);
453 err
= put_user(amount
, (int __user
*) arg
);
457 if (sk
->sk_state
== BT_LISTEN
)
461 skb
= skb_peek(&sk
->sk_receive_queue
);
462 amount
= skb
? skb
->len
: 0;
464 err
= put_user(amount
, (int __user
*) arg
);
468 err
= sock_get_timestamp(sk
, (struct timeval __user
*) arg
);
472 err
= sock_get_timestampns(sk
, (struct timespec __user
*) arg
);
482 EXPORT_SYMBOL(bt_sock_ioctl
);
484 int bt_sock_wait_state(struct sock
*sk
, int state
, unsigned long timeo
)
486 DECLARE_WAITQUEUE(wait
, current
);
491 add_wait_queue(sk_sleep(sk
), &wait
);
492 while (sk
->sk_state
!= state
) {
493 set_current_state(TASK_INTERRUPTIBLE
);
500 if (signal_pending(current
)) {
501 err
= sock_intr_errno(timeo
);
506 timeo
= schedule_timeout(timeo
);
509 err
= sock_error(sk
);
513 set_current_state(TASK_RUNNING
);
514 remove_wait_queue(sk_sleep(sk
), &wait
);
517 EXPORT_SYMBOL(bt_sock_wait_state
);
519 static struct net_proto_family bt_sock_family_ops
= {
520 .owner
= THIS_MODULE
,
521 .family
= PF_BLUETOOTH
,
522 .create
= bt_sock_create
,
525 static int __init
bt_init(void)
529 BT_INFO("Core ver %s", VERSION
);
531 err
= bt_sysfs_init();
535 err
= sock_register(&bt_sock_family_ops
);
541 BT_INFO("HCI device and connection manager initialized");
548 static void __exit
bt_exit(void)
552 sock_unregister(PF_BLUETOOTH
);
557 subsys_initcall(bt_init
);
558 module_exit(bt_exit
);
560 MODULE_AUTHOR("Marcel Holtmann <marcel@holtmann.org>");
561 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION
);
562 MODULE_VERSION(VERSION
);
563 MODULE_LICENSE("GPL");
564 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH
);