File: /usr/src/linux/net/bluetooth/hci_sock.c
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 /*
26 * BlueZ HCI socket layer.
27 *
28 * $Id: hci_sock.c,v 1.9 2001/08/05 06:02:16 maxk Exp $
29 */
30
31 #include <linux/config.h>
32 #include <linux/module.h>
33
34 #include <linux/types.h>
35 #include <linux/errno.h>
36 #include <linux/kernel.h>
37 #include <linux/major.h>
38 #include <linux/sched.h>
39 #include <linux/slab.h>
40 #include <linux/poll.h>
41 #include <linux/fcntl.h>
42 #include <linux/init.h>
43 #include <linux/skbuff.h>
44 #include <linux/tqueue.h>
45 #include <linux/interrupt.h>
46 #include <linux/socket.h>
47 #include <linux/ioctl.h>
48 #include <net/sock.h>
49
50 #include <asm/system.h>
51 #include <asm/uaccess.h>
52
53 #include <net/bluetooth/bluetooth.h>
54 #include <net/bluetooth/bluez.h>
55 #include <net/bluetooth/hci_core.h>
56
57 #ifndef HCI_SOCK_DEBUG
58 #undef DBG
59 #define DBG( A... )
60 #endif
61
62 /* HCI socket interface */
63
64 static struct bluez_sock_list hci_sk_list = {
65 lock: RW_LOCK_UNLOCKED
66 };
67
68 static struct sock *hci_sock_lookup(struct hci_dev *hdev)
69 {
70 struct sock *sk;
71
72 read_lock(&hci_sk_list.lock);
73 for (sk = hci_sk_list.head; sk; sk = sk->next) {
74 if (hci_pi(sk)->hdev == hdev)
75 break;
76 }
77 read_unlock(&hci_sk_list.lock);
78 return sk;
79 }
80
81 /* Send frame to RAW socket */
82 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb)
83 {
84 struct sock * sk;
85
86 DBG("hdev %p len %d", hdev, skb->len);
87
88 read_lock(&hci_sk_list.lock);
89 for (sk = hci_sk_list.head; sk; sk = sk->next) {
90 struct hci_filter *flt;
91 struct sk_buff *nskb;
92
93 if (sk->state != BT_BOUND || hci_pi(sk)->hdev != hdev)
94 continue;
95
96 /* Don't send frame to the socket it came from */
97 if (skb->sk == sk)
98 continue;
99
100 /* Apply filter */
101 flt = &hci_pi(sk)->filter;
102
103 if (!test_bit(skb->pkt_type, &flt->type_mask))
104 continue;
105
106 if (skb->pkt_type == HCI_EVENT_PKT) {
107 register int evt = (*(__u8 *)skb->data & 63);
108
109 if (!test_bit(evt, &flt->event_mask))
110 continue;
111 }
112
113 if (!(nskb = skb_clone(skb, GFP_ATOMIC)))
114 continue;
115
116 /* Put type byte before the data */
117 memcpy(skb_push(nskb, 1), &nskb->pkt_type, 1);
118
119 skb_queue_tail(&sk->receive_queue, nskb);
120 sk->data_ready(sk, nskb->len);
121 }
122 read_unlock(&hci_sk_list.lock);
123 }
124
125 static int hci_sock_release(struct socket *sock)
126 {
127 struct sock *sk = sock->sk;
128 struct hci_dev *hdev = hci_pi(sk)->hdev;
129
130 DBG("sock %p sk %p", sock, sk);
131
132 if (!sk)
133 return 0;
134
135 bluez_sock_unlink(&hci_sk_list, sk);
136
137 if (hdev) {
138 if (!hci_sock_lookup(hdev))
139 hdev->flags &= ~HCI_SOCK;
140
141 hci_dev_put(hdev);
142 }
143
144 sock_orphan(sk);
145
146 skb_queue_purge(&sk->receive_queue);
147 skb_queue_purge(&sk->write_queue);
148
149 sock_put(sk);
150
151 MOD_DEC_USE_COUNT;
152
153 return 0;
154 }
155
156 static int hci_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
157 {
158 struct sock *sk = sock->sk;
159 struct hci_dev *hdev = hci_pi(sk)->hdev;
160 __u32 mode;
161
162 DBG("cmd %x arg %lx", cmd, arg);
163
164 switch (cmd) {
165 case HCIGETINFO:
166 return hci_dev_info(arg);
167
168 case HCIGETDEVLIST:
169 return hci_dev_list(arg);
170
171 case HCIDEVUP:
172 if (!capable(CAP_NET_ADMIN))
173 return -EACCES;
174 return hci_dev_open(arg);
175
176 case HCIDEVDOWN:
177 if (!capable(CAP_NET_ADMIN))
178 return -EACCES;
179 return hci_dev_close(arg);
180
181 case HCIDEVRESET:
182 if (!capable(CAP_NET_ADMIN))
183 return -EACCES;
184 return hci_dev_reset(arg);
185
186 case HCIRESETSTAT:
187 if (!capable(CAP_NET_ADMIN))
188 return -EACCES;
189 return hci_dev_reset_stat(arg);
190
191 case HCISETSCAN:
192 if (!capable(CAP_NET_ADMIN))
193 return -EACCES;
194 return hci_dev_setscan(arg);
195
196 case HCISETAUTH:
197 if (!capable(CAP_NET_ADMIN))
198 return -EACCES;
199 return hci_dev_setauth(arg);
200
201 case HCISETRAW:
202 if (!capable(CAP_NET_ADMIN))
203 return -EACCES;
204
205 if (!hdev)
206 return -EBADFD;
207
208 if (arg)
209 mode = HCI_RAW;
210 else
211 mode = HCI_NORMAL;
212
213 return hci_dev_setmode(hdev, mode);
214
215 case HCISETPTYPE:
216 if (!capable(CAP_NET_ADMIN))
217 return -EACCES;
218 return hci_dev_setptype(arg);
219
220 case HCIINQUIRY:
221 return hci_inquiry(arg);
222
223 case HCIGETCONNLIST:
224 return hci_conn_list(arg);
225
226 default:
227 return -EINVAL;
228 };
229 }
230
231 static int hci_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
232 {
233 struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
234 struct sock *sk = sock->sk;
235 struct hci_dev *hdev = NULL;
236
237 DBG("sock %p sk %p", sock, sk);
238
239 if (!haddr || haddr->hci_family != AF_BLUETOOTH)
240 return -EINVAL;
241
242 if (hci_pi(sk)->hdev) {
243 /* Already bound */
244 return 0;
245 }
246
247 if (haddr->hci_dev != HCI_DEV_NONE) {
248 if (!(hdev = hci_dev_get(haddr->hci_dev)))
249 return -ENODEV;
250
251 hdev->flags |= HCI_SOCK;
252 }
253
254 hci_pi(sk)->hdev = hdev;
255 sk->state = BT_BOUND;
256
257 return 0;
258 }
259
260 static int hci_sock_getname(struct socket *sock, struct sockaddr *addr, int *addr_len, int peer)
261 {
262 struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
263 struct sock *sk = sock->sk;
264
265 DBG("sock %p sk %p", sock, sk);
266
267 *addr_len = sizeof(*haddr);
268 haddr->hci_family = AF_BLUETOOTH;
269 haddr->hci_dev = hci_pi(sk)->hdev->id;
270
271 return 0;
272 }
273
274 static int hci_sock_sendmsg(struct socket *sock, struct msghdr *msg, int len,
275 struct scm_cookie *scm)
276 {
277 struct sock *sk = sock->sk;
278 struct hci_dev *hdev = hci_pi(sk)->hdev;
279 struct sk_buff *skb;
280 int err;
281
282 DBG("sock %p sk %p", sock, sk);
283
284 if (msg->msg_flags & MSG_OOB)
285 return -EOPNOTSUPP;
286
287 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE))
288 return -EINVAL;
289
290 if (!hdev)
291 return -EBADFD;
292
293 if (!(skb = bluez_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err)))
294 return err;
295
296 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
297 kfree_skb(skb);
298 return -EFAULT;
299 }
300
301 skb->dev = (void *) hdev;
302 skb->pkt_type = *((unsigned char *) skb->data);
303 skb_pull(skb, 1);
304
305 /* Send frame to HCI core */
306 hci_send_raw(skb);
307
308 return len;
309 }
310
311 static inline void hci_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
312 {
313 __u32 mask = hci_pi(sk)->cmsg_mask;
314
315 if (mask & HCI_CMSG_DIR)
316 put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(int), &bluez_cb(skb)->incomming);
317 }
318
319 static int hci_sock_recvmsg(struct socket *sock, struct msghdr *msg, int len,
320 int flags, struct scm_cookie *scm)
321 {
322 int noblock = flags & MSG_DONTWAIT;
323 struct sock *sk = sock->sk;
324 struct sk_buff *skb;
325 int copied, err;
326
327 DBG("sock %p sk %p", sock, sk);
328
329 if (flags & (MSG_OOB | MSG_PEEK))
330 return -EOPNOTSUPP;
331
332 if (!(skb = skb_recv_datagram(sk, flags, noblock, &err)))
333 return err;
334
335 msg->msg_namelen = 0;
336
337 copied = skb->len;
338 if (len < copied) {
339 msg->msg_flags |= MSG_TRUNC;
340 copied = len;
341 }
342
343 skb->h.raw = skb->data;
344 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
345
346 if (hci_pi(sk)->cmsg_mask)
347 hci_sock_cmsg(sk, msg, skb);
348
349 skb_free_datagram(sk, skb);
350
351 return err ? : copied;
352 }
353
354 int hci_sock_setsockopt(struct socket *sock, int level, int optname, char *optval, int len)
355 {
356 struct sock *sk = sock->sk;
357 struct hci_filter flt;
358 int err = 0, opt = 0;
359
360 DBG("sk %p, opt %d", sk, optname);
361
362 lock_sock(sk);
363
364 switch (optname) {
365 case HCI_DATA_DIR:
366 if (get_user(opt, (int *)optval))
367 return -EFAULT;
368
369 if (opt)
370 hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR;
371 else
372 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
373 break;
374
375 case HCI_FILTER:
376 len = MIN(len, sizeof(struct hci_filter));
377 if (copy_from_user(&flt, optval, len)) {
378 err = -EFAULT;
379 break;
380 }
381 memcpy(&hci_pi(sk)->filter, &flt, len);
382 break;
383
384 default:
385 err = -ENOPROTOOPT;
386 break;
387 };
388
389 release_sock(sk);
390 return err;
391 }
392
393 int hci_sock_getsockopt(struct socket *sock, int level, int optname, char *optval, int *optlen)
394 {
395 struct sock *sk = sock->sk;
396 int len, opt;
397
398 if (get_user(len, optlen))
399 return -EFAULT;
400
401 switch (optname) {
402 case HCI_DATA_DIR:
403 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
404 opt = 1;
405 else
406 opt = 0;
407
408 if (put_user(opt, optval))
409 return -EFAULT;
410 break;
411
412 case HCI_FILTER:
413 len = MIN(len, sizeof(struct hci_filter));
414 if (copy_to_user(optval, &hci_pi(sk)->filter, len))
415 return -EFAULT;
416 break;
417
418 default:
419 return -ENOPROTOOPT;
420 break;
421 };
422
423 return 0;
424 }
425
426 struct proto_ops hci_sock_ops = {
427 family: PF_BLUETOOTH,
428 release: hci_sock_release,
429 bind: hci_sock_bind,
430 getname: hci_sock_getname,
431 sendmsg: hci_sock_sendmsg,
432 recvmsg: hci_sock_recvmsg,
433 ioctl: hci_sock_ioctl,
434 poll: datagram_poll,
435 listen: sock_no_listen,
436 shutdown: sock_no_shutdown,
437 setsockopt: hci_sock_setsockopt,
438 getsockopt: hci_sock_getsockopt,
439 connect: sock_no_connect,
440 socketpair: sock_no_socketpair,
441 accept: sock_no_accept,
442 mmap: sock_no_mmap
443 };
444
445 static int hci_sock_create(struct socket *sock, int protocol)
446 {
447 struct sock *sk;
448
449 DBG("sock %p", sock);
450
451 if (sock->type != SOCK_RAW)
452 return -ESOCKTNOSUPPORT;
453
454 sock->ops = &hci_sock_ops;
455
456 if (!(sk = sk_alloc(PF_BLUETOOTH, GFP_KERNEL, 1)))
457 return -ENOMEM;
458
459 sock->state = SS_UNCONNECTED;
460 sock_init_data(sock, sk);
461
462 memset(&sk->protinfo, 0, sizeof(struct hci_pinfo));
463 sk->destruct = NULL;
464 sk->protocol = protocol;
465 sk->state = BT_OPEN;
466
467 /* Initialize filter */
468 hci_pi(sk)->filter.type_mask = (1<<HCI_EVENT_PKT);
469 hci_pi(sk)->filter.event_mask[0] = ~0L;
470 hci_pi(sk)->filter.event_mask[1] = ~0L;
471
472 bluez_sock_link(&hci_sk_list, sk);
473
474 MOD_INC_USE_COUNT;
475
476 return 0;
477 }
478
479 static int hci_sock_dev_event(struct notifier_block *this, unsigned long event, void *ptr)
480 {
481 struct hci_dev *hdev = (struct hci_dev *) ptr;
482 struct sk_buff *skb;
483
484 DBG("hdev %s event %ld", hdev->name, event);
485
486 /* Send event to sockets */
487 if ((skb = bluez_skb_alloc(HCI_EVENT_HDR_SIZE + EVT_HCI_DEV_EVENT_SIZE, GFP_ATOMIC))) {
488 hci_event_hdr eh = { EVT_HCI_DEV_EVENT, EVT_HCI_DEV_EVENT_SIZE };
489 evt_hci_dev_event he = { event, hdev->id };
490
491 skb->pkt_type = HCI_EVENT_PKT;
492 memcpy(skb_put(skb, HCI_EVENT_HDR_SIZE), &eh, HCI_EVENT_HDR_SIZE);
493 memcpy(skb_put(skb, EVT_HCI_DEV_EVENT_SIZE), &he, EVT_HCI_DEV_EVENT_SIZE);
494
495 hci_send_to_sock(NULL, skb);
496 kfree_skb(skb);
497 }
498
499 if (event == HCI_DEV_UNREG) {
500 struct sock *sk;
501
502 /* Detach sockets from device */
503 read_lock(&hci_sk_list.lock);
504 for (sk = hci_sk_list.head; sk; sk = sk->next) {
505 if (hci_pi(sk)->hdev == hdev) {
506 hci_pi(sk)->hdev = NULL;
507 sk->err = EPIPE;
508 sk->state = BT_OPEN;
509 sk->state_change(sk);
510
511 hci_dev_put(hdev);
512 }
513 }
514 read_unlock(&hci_sk_list.lock);
515 }
516
517 return NOTIFY_DONE;
518 }
519
520 struct net_proto_family hci_sock_family_ops = {
521 family: PF_BLUETOOTH,
522 create: hci_sock_create
523 };
524
525 struct notifier_block hci_sock_nblock = {
526 notifier_call: hci_sock_dev_event
527 };
528
529 int hci_sock_init(void)
530 {
531 if (bluez_sock_register(BTPROTO_HCI, &hci_sock_family_ops)) {
532 ERR("Can't register HCI socket");
533 return -EPROTO;
534 }
535
536 hci_register_notifier(&hci_sock_nblock);
537
538 return 0;
539 }
540
541 int hci_sock_cleanup(void)
542 {
543 if (bluez_sock_unregister(BTPROTO_HCI))
544 ERR("Can't unregister HCI socket");
545
546 hci_unregister_notifier(&hci_sock_nblock);
547
548 return 0;
549 }
550