xref: /openbmc/linux/net/bluetooth/af_bluetooth.c (revision a1e58bbd) 
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/slab.h>
35 #include <linux/skbuff.h>
36 #include <linux/init.h>
37 #include <linux/poll.h>
38 #include <net/sock.h>
39 
40 #if defined(CONFIG_KMOD)
41 #include <linux/kmod.h>
42 #endif
43 
44 #include <net/bluetooth/bluetooth.h>
45 
46 #ifndef CONFIG_BT_SOCK_DEBUG
47 #undef  BT_DBG
48 #define BT_DBG(D...)
49 #endif
50 
51 #define VERSION "2.11"
52 
53 /* Bluetooth sockets */
54 #define BT_MAX_PROTO	8
55 static struct net_proto_family *bt_proto[BT_MAX_PROTO];
56 
57 static struct lock_class_key bt_slock_key[BT_MAX_PROTO];
58 static struct lock_class_key bt_lock_key[BT_MAX_PROTO];
59 static const char *bt_key_strings[BT_MAX_PROTO] = {
60 	"sk_lock-AF_BLUETOOTH-BTPROTO_L2CAP",
61 	"sk_lock-AF_BLUETOOTH-BTPROTO_HCI",
62 	"sk_lock-AF_BLUETOOTH-BTPROTO_SCO",
63 	"sk_lock-AF_BLUETOOTH-BTPROTO_RFCOMM",
64 	"sk_lock-AF_BLUETOOTH-BTPROTO_BNEP",
65 	"sk_lock-AF_BLUETOOTH-BTPROTO_CMTP",
66 	"sk_lock-AF_BLUETOOTH-BTPROTO_HIDP",
67 	"sk_lock-AF_BLUETOOTH-BTPROTO_AVDTP",
68 };
69 
70 static const char *bt_slock_key_strings[BT_MAX_PROTO] = {
71 	"slock-AF_BLUETOOTH-BTPROTO_L2CAP",
72 	"slock-AF_BLUETOOTH-BTPROTO_HCI",
73 	"slock-AF_BLUETOOTH-BTPROTO_SCO",
74 	"slock-AF_BLUETOOTH-BTPROTO_RFCOMM",
75 	"slock-AF_BLUETOOTH-BTPROTO_BNEP",
76 	"slock-AF_BLUETOOTH-BTPROTO_CMTP",
77 	"slock-AF_BLUETOOTH-BTPROTO_HIDP",
78 	"slock-AF_BLUETOOTH-BTPROTO_AVDTP",
79 };
80 static DEFINE_RWLOCK(bt_proto_lock);
81 
82 int bt_sock_register(int proto, struct net_proto_family *ops)
83 {
84 	int err = 0;
85 
86 	if (proto < 0 || proto >= BT_MAX_PROTO)
87 		return -EINVAL;
88 
89 	write_lock(&bt_proto_lock);
90 
91 	if (bt_proto[proto])
92 		err = -EEXIST;
93 	else
94 		bt_proto[proto] = ops;
95 
96 	write_unlock(&bt_proto_lock);
97 
98 	return err;
99 }
100 EXPORT_SYMBOL(bt_sock_register);
101 
102 int bt_sock_unregister(int proto)
103 {
104 	int err = 0;
105 
106 	if (proto < 0 || proto >= BT_MAX_PROTO)
107 		return -EINVAL;
108 
109 	write_lock(&bt_proto_lock);
110 
111 	if (!bt_proto[proto])
112 		err = -ENOENT;
113 	else
114 		bt_proto[proto] = NULL;
115 
116 	write_unlock(&bt_proto_lock);
117 
118 	return err;
119 }
120 EXPORT_SYMBOL(bt_sock_unregister);
121 
122 static void bt_reclassify_sock_lock(struct socket *sock, int proto)
123 {
124 	struct sock *sk = sock->sk;
125 
126 	if (!sk)
127 		return;
128 	BUG_ON(sock_owned_by_user(sk));
129 
130 	sock_lock_init_class_and_name(sk,
131 			bt_slock_key_strings[proto],
132 			&bt_slock_key[proto],
133 			bt_key_strings[proto],
134 			&bt_lock_key[proto]);
135 }
136 
137 static int bt_sock_create(struct net *net, struct socket *sock, int proto)
138 {
139 	int err;
140 
141 	if (net != &init_net)
142 		return -EAFNOSUPPORT;
143 
144 	if (proto < 0 || proto >= BT_MAX_PROTO)
145 		return -EINVAL;
146 
147 #if defined(CONFIG_KMOD)
148 	if (!bt_proto[proto]) {
149 		request_module("bt-proto-%d", proto);
150 	}
151 #endif
152 
153 	err = -EPROTONOSUPPORT;
154 
155 	read_lock(&bt_proto_lock);
156 
157 	if (bt_proto[proto] && try_module_get(bt_proto[proto]->owner)) {
158 		err = bt_proto[proto]->create(net, sock, proto);
159 		bt_reclassify_sock_lock(sock, proto);
160 		module_put(bt_proto[proto]->owner);
161 	}
162 
163 	read_unlock(&bt_proto_lock);
164 
165 	return err;
166 }
167 
168 void bt_sock_link(struct bt_sock_list *l, struct sock *sk)
169 {
170 	write_lock_bh(&l->lock);
171 	sk_add_node(sk, &l->head);
172 	write_unlock_bh(&l->lock);
173 }
174 EXPORT_SYMBOL(bt_sock_link);
175 
176 void bt_sock_unlink(struct bt_sock_list *l, struct sock *sk)
177 {
178 	write_lock_bh(&l->lock);
179 	sk_del_node_init(sk);
180 	write_unlock_bh(&l->lock);
181 }
182 EXPORT_SYMBOL(bt_sock_unlink);
183 
184 void bt_accept_enqueue(struct sock *parent, struct sock *sk)
185 {
186 	BT_DBG("parent %p, sk %p", parent, sk);
187 
188 	sock_hold(sk);
189 	list_add_tail(&bt_sk(sk)->accept_q, &bt_sk(parent)->accept_q);
190 	bt_sk(sk)->parent = parent;
191 	parent->sk_ack_backlog++;
192 }
193 EXPORT_SYMBOL(bt_accept_enqueue);
194 
195 void bt_accept_unlink(struct sock *sk)
196 {
197 	BT_DBG("sk %p state %d", sk, sk->sk_state);
198 
199 	list_del_init(&bt_sk(sk)->accept_q);
200 	bt_sk(sk)->parent->sk_ack_backlog--;
201 	bt_sk(sk)->parent = NULL;
202 	sock_put(sk);
203 }
204 EXPORT_SYMBOL(bt_accept_unlink);
205 
206 struct sock *bt_accept_dequeue(struct sock *parent, struct socket *newsock)
207 {
208 	struct list_head *p, *n;
209 	struct sock *sk;
210 
211 	BT_DBG("parent %p", parent);
212 
213 	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
214 		sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
215 
216 		lock_sock(sk);
217 
218 		/* FIXME: Is this check still needed */
219 		if (sk->sk_state == BT_CLOSED) {
220 			release_sock(sk);
221 			bt_accept_unlink(sk);
222 			continue;
223 		}
224 
225 		if (sk->sk_state == BT_CONNECTED || !newsock) {
226 			bt_accept_unlink(sk);
227 			if (newsock)
228 				sock_graft(sk, newsock);
229 			release_sock(sk);
230 			return sk;
231 		}
232 
233 		release_sock(sk);
234 	}
235 	return NULL;
236 }
237 EXPORT_SYMBOL(bt_accept_dequeue);
238 
239 int bt_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
240 	struct msghdr *msg, size_t len, int flags)
241 {
242 	int noblock = flags & MSG_DONTWAIT;
243 	struct sock *sk = sock->sk;
244 	struct sk_buff *skb;
245 	size_t copied;
246 	int err;
247 
248 	BT_DBG("sock %p sk %p len %d", sock, sk, len);
249 
250 	if (flags & (MSG_OOB))
251 		return -EOPNOTSUPP;
252 
253 	if (!(skb = skb_recv_datagram(sk, flags, noblock, &err))) {
254 		if (sk->sk_shutdown & RCV_SHUTDOWN)
255 			return 0;
256 		return err;
257 	}
258 
259 	msg->msg_namelen = 0;
260 
261 	copied = skb->len;
262 	if (len < copied) {
263 		msg->msg_flags |= MSG_TRUNC;
264 		copied = len;
265 	}
266 
267 	skb_reset_transport_header(skb);
268 	err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
269 
270 	skb_free_datagram(sk, skb);
271 
272 	return err ? : copied;
273 }
274 EXPORT_SYMBOL(bt_sock_recvmsg);
275 
276 static inline unsigned int bt_accept_poll(struct sock *parent)
277 {
278 	struct list_head *p, *n;
279 	struct sock *sk;
280 
281 	list_for_each_safe(p, n, &bt_sk(parent)->accept_q) {
282 		sk = (struct sock *) list_entry(p, struct bt_sock, accept_q);
283 		if (sk->sk_state == BT_CONNECTED)
284 			return POLLIN | POLLRDNORM;
285 	}
286 
287 	return 0;
288 }
289 
290 unsigned int bt_sock_poll(struct file * file, struct socket *sock, poll_table *wait)
291 {
292 	struct sock *sk = sock->sk;
293 	unsigned int mask = 0;
294 
295 	BT_DBG("sock %p, sk %p", sock, sk);
296 
297 	poll_wait(file, sk->sk_sleep, wait);
298 
299 	if (sk->sk_state == BT_LISTEN)
300 		return bt_accept_poll(sk);
301 
302 	if (sk->sk_err || !skb_queue_empty(&sk->sk_error_queue))
303 		mask |= POLLERR;
304 
305 	if (sk->sk_shutdown & RCV_SHUTDOWN)
306 		mask |= POLLRDHUP;
307 
308 	if (sk->sk_shutdown == SHUTDOWN_MASK)
309 		mask |= POLLHUP;
310 
311 	if (!skb_queue_empty(&sk->sk_receive_queue) ||
312 			(sk->sk_shutdown & RCV_SHUTDOWN))
313 		mask |= POLLIN | POLLRDNORM;
314 
315 	if (sk->sk_state == BT_CLOSED)
316 		mask |= POLLHUP;
317 
318 	if (sk->sk_state == BT_CONNECT ||
319 			sk->sk_state == BT_CONNECT2 ||
320 			sk->sk_state == BT_CONFIG)
321 		return mask;
322 
323 	if (sock_writeable(sk))
324 		mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
325 	else
326 		set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
327 
328 	return mask;
329 }
330 EXPORT_SYMBOL(bt_sock_poll);
331 
332 int bt_sock_wait_state(struct sock *sk, int state, unsigned long timeo)
333 {
334 	DECLARE_WAITQUEUE(wait, current);
335 	int err = 0;
336 
337 	BT_DBG("sk %p", sk);
338 
339 	add_wait_queue(sk->sk_sleep, &wait);
340 	while (sk->sk_state != state) {
341 		set_current_state(TASK_INTERRUPTIBLE);
342 
343 		if (!timeo) {
344 			err = -EINPROGRESS;
345 			break;
346 		}
347 
348 		if (signal_pending(current)) {
349 			err = sock_intr_errno(timeo);
350 			break;
351 		}
352 
353 		release_sock(sk);
354 		timeo = schedule_timeout(timeo);
355 		lock_sock(sk);
356 
357 		err = sock_error(sk);
358 		if (err)
359 			break;
360 	}
361 	set_current_state(TASK_RUNNING);
362 	remove_wait_queue(sk->sk_sleep, &wait);
363 	return err;
364 }
365 EXPORT_SYMBOL(bt_sock_wait_state);
366 
367 static struct net_proto_family bt_sock_family_ops = {
368 	.owner	= THIS_MODULE,
369 	.family	= PF_BLUETOOTH,
370 	.create	= bt_sock_create,
371 };
372 
373 static int __init bt_init(void)
374 {
375 	int err;
376 
377 	BT_INFO("Core ver %s", VERSION);
378 
379 	err = bt_sysfs_init();
380 	if (err < 0)
381 		return err;
382 
383 	err = sock_register(&bt_sock_family_ops);
384 	if (err < 0) {
385 		bt_sysfs_cleanup();
386 		return err;
387 	}
388 
389 	BT_INFO("HCI device and connection manager initialized");
390 
391 	hci_sock_init();
392 
393 	return 0;
394 }
395 
396 static void __exit bt_exit(void)
397 {
398 	hci_sock_cleanup();
399 
400 	sock_unregister(PF_BLUETOOTH);
401 
402 	bt_sysfs_cleanup();
403 }
404 
405 subsys_initcall(bt_init);
406 module_exit(bt_exit);
407 
408 MODULE_AUTHOR("Maxim Krasnyansky <maxk@qualcomm.com>, Marcel Holtmann <marcel@holtmann.org>");
409 MODULE_DESCRIPTION("Bluetooth Core ver " VERSION);
410 MODULE_VERSION(VERSION);
411 MODULE_LICENSE("GPL");
412 MODULE_ALIAS_NETPROTO(PF_BLUETOOTH);
413