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