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