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