?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] kill gratitious includes of major.h under net/*
[linux-2.6/linux-2.6-openrd.git] / net / bluetooth / hci_sock.c
blobebdcce5e7ca0b6d67e8974a52ede4f934e2c1936
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 HCI sockets. */
26
27 #include <linux/config.h>
28 #include <linux/module.h>
29
30 #include <linux/types.h>
31 #include <linux/errno.h>
32 #include <linux/kernel.h>
33 #include <linux/sched.h>
34 #include <linux/slab.h>
35 #include <linux/poll.h>
36 #include <linux/fcntl.h>
37 #include <linux/init.h>
38 #include <linux/skbuff.h>
39 #include <linux/workqueue.h>
40 #include <linux/interrupt.h>
41 #include <linux/socket.h>
42 #include <linux/ioctl.h>
43 #include <net/sock.h>
44
45 #include <asm/system.h>
46 #include <asm/uaccess.h>
47 #include <asm/unaligned.h>
48
49 #include <net/bluetooth/bluetooth.h>
50 #include <net/bluetooth/hci_core.h>
51
52 #ifndef CONFIG_BT_HCI_SOCK_DEBUG
53 #undef BT_DBG
54 #define BT_DBG(D...)
55 #endif
56
57 /* ----- HCI socket interface ----- */
58
59 static inline int hci_test_bit(int nr, void *addr)
60 {
61 return *((__u32 *) addr + (nr >> 5)) & ((__u32) 1 << (nr & 31));
62 }
63
64 /* Security filter */
65 static struct hci_sec_filter hci_sec_filter = {
66 /* Packet types */
67 0x10,
68 /* Events */
69 { 0x1000d9fe, 0x0000300c },
70 /* Commands */
71 {
72 { 0x0 },
73 /* OGF_LINK_CTL */
74 { 0xbe000006, 0x00000001, 0x0000, 0x00 },
75 /* OGF_LINK_POLICY */
76 { 0x00005200, 0x00000000, 0x0000, 0x00 },
77 /* OGF_HOST_CTL */
78 { 0xaab00200, 0x2b402aaa, 0x0154, 0x00 },
79 /* OGF_INFO_PARAM */
80 { 0x000002be, 0x00000000, 0x0000, 0x00 },
81 /* OGF_STATUS_PARAM */
82 { 0x000000ea, 0x00000000, 0x0000, 0x00 }
83 }
84 };
85
86 static struct bt_sock_list hci_sk_list = {
87 .lock = RW_LOCK_UNLOCKED
88 };
89
90 /* Send frame to RAW socket */
91 void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb)
92 {
93 struct sock *sk;
94 struct hlist_node *node;
95
96 BT_DBG("hdev %p len %d", hdev, skb->len);
97
98 read_lock(&hci_sk_list.lock);
99 sk_for_each(sk, node, &hci_sk_list.head) {
100 struct hci_filter *flt;
101 struct sk_buff *nskb;
102
103 if (sk->sk_state != BT_BOUND || hci_pi(sk)->hdev != hdev)
104 continue;
105
106 /* Don't send frame to the socket it came from */
107 if (skb->sk == sk)
108 continue;
109
110 /* Apply filter */
111 flt = &hci_pi(sk)->filter;
112
113 if (!test_bit((skb->pkt_type == HCI_VENDOR_PKT) ?
114 0 : (skb->pkt_type & HCI_FLT_TYPE_BITS), &flt->type_mask))
115 continue;
116
117 if (skb->pkt_type == HCI_EVENT_PKT) {
118 register int evt = (*(__u8 *)skb->data & HCI_FLT_EVENT_BITS);
119
120 if (!hci_test_bit(evt, &flt->event_mask))
121 continue;
122
123 if (flt->opcode && ((evt == HCI_EV_CMD_COMPLETE &&
124 flt->opcode != *(__u16 *)(skb->data + 3)) ||
125 (evt == HCI_EV_CMD_STATUS &&
126 flt->opcode != *(__u16 *)(skb->data + 4))))
127 continue;
128 }
129
130 if (!(nskb = skb_clone(skb, GFP_ATOMIC)))
131 continue;
132
133 /* Put type byte before the data */
134 memcpy(skb_push(nskb, 1), &nskb->pkt_type, 1);
135
136 if (sock_queue_rcv_skb(sk, nskb))
137 kfree_skb(nskb);
138 }
139 read_unlock(&hci_sk_list.lock);
140 }
141
142 static int hci_sock_release(struct socket *sock)
143 {
144 struct sock *sk = sock->sk;
145 struct hci_dev *hdev = hci_pi(sk)->hdev;
146
147 BT_DBG("sock %p sk %p", sock, sk);
148
149 if (!sk)
150 return 0;
151
152 bt_sock_unlink(&hci_sk_list, sk);
153
154 if (hdev) {
155 atomic_dec(&hdev->promisc);
156 hci_dev_put(hdev);
157 }
158
159 sock_orphan(sk);
160
161 skb_queue_purge(&sk->sk_receive_queue);
162 skb_queue_purge(&sk->sk_write_queue);
163
164 sock_put(sk);
165 return 0;
166 }
167
168 /* Ioctls that require bound socket */
169 static inline int hci_sock_bound_ioctl(struct sock *sk, unsigned int cmd, unsigned long arg)
170 {
171 struct hci_dev *hdev = hci_pi(sk)->hdev;
172
173 if (!hdev)
174 return -EBADFD;
175
176 switch (cmd) {
177 case HCISETRAW:
178 if (!capable(CAP_NET_ADMIN))
179 return -EACCES;
180
181 if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks))
182 return -EPERM;
183
184 if (arg)
185 set_bit(HCI_RAW, &hdev->flags);
186 else
187 clear_bit(HCI_RAW, &hdev->flags);
188
189 return 0;
190
191 case HCISETSECMGR:
192 if (!capable(CAP_NET_ADMIN))
193 return -EACCES;
194
195 if (arg)
196 set_bit(HCI_SECMGR, &hdev->flags);
197 else
198 clear_bit(HCI_SECMGR, &hdev->flags);
199
200 return 0;
201
202 case HCIGETCONNINFO:
203 return hci_get_conn_info(hdev, (void __user *)arg);
204
205 default:
206 if (hdev->ioctl)
207 return hdev->ioctl(hdev, cmd, arg);
208 return -EINVAL;
209 }
210 }
211
212 static int hci_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
213 {
214 struct sock *sk = sock->sk;
215 void __user *argp = (void __user *)arg;
216 int err;
217
218 BT_DBG("cmd %x arg %lx", cmd, arg);
219
220 switch (cmd) {
221 case HCIGETDEVLIST:
222 return hci_get_dev_list(argp);
223
224 case HCIGETDEVINFO:
225 return hci_get_dev_info(argp);
226
227 case HCIGETCONNLIST:
228 return hci_get_conn_list(argp);
229
230 case HCIDEVUP:
231 if (!capable(CAP_NET_ADMIN))
232 return -EACCES;
233 return hci_dev_open(arg);
234
235 case HCIDEVDOWN:
236 if (!capable(CAP_NET_ADMIN))
237 return -EACCES;
238 return hci_dev_close(arg);
239
240 case HCIDEVRESET:
241 if (!capable(CAP_NET_ADMIN))
242 return -EACCES;
243 return hci_dev_reset(arg);
244
245 case HCIDEVRESTAT:
246 if (!capable(CAP_NET_ADMIN))
247 return -EACCES;
248 return hci_dev_reset_stat(arg);
249
250 case HCISETSCAN:
251 case HCISETAUTH:
252 case HCISETENCRYPT:
253 case HCISETPTYPE:
254 case HCISETLINKPOL:
255 case HCISETLINKMODE:
256 case HCISETACLMTU:
257 case HCISETSCOMTU:
258 if (!capable(CAP_NET_ADMIN))
259 return -EACCES;
260 return hci_dev_cmd(cmd, argp);
261
262 case HCIINQUIRY:
263 return hci_inquiry(argp);
264
265 default:
266 lock_sock(sk);
267 err = hci_sock_bound_ioctl(sk, cmd, arg);
268 release_sock(sk);
269 return err;
270 }
271 }
272
273 static int hci_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
274 {
275 struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
276 struct sock *sk = sock->sk;
277 struct hci_dev *hdev = NULL;
278 int err = 0;
279
280 BT_DBG("sock %p sk %p", sock, sk);
281
282 if (!haddr || haddr->hci_family != AF_BLUETOOTH)
283 return -EINVAL;
284
285 lock_sock(sk);
286
287 if (hci_pi(sk)->hdev) {
288 err = -EALREADY;
289 goto done;
290 }
291
292 if (haddr->hci_dev != HCI_DEV_NONE) {
293 if (!(hdev = hci_dev_get(haddr->hci_dev))) {
294 err = -ENODEV;
295 goto done;
296 }
297
298 atomic_inc(&hdev->promisc);
299 }
300
301 hci_pi(sk)->hdev = hdev;
302 sk->sk_state = BT_BOUND;
303
304 done:
305 release_sock(sk);
306 return err;
307 }
308
309 static int hci_sock_getname(struct socket *sock, struct sockaddr *addr, int *addr_len, int peer)
310 {
311 struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
312 struct sock *sk = sock->sk;
313
314 BT_DBG("sock %p sk %p", sock, sk);
315
316 lock_sock(sk);
317
318 *addr_len = sizeof(*haddr);
319 haddr->hci_family = AF_BLUETOOTH;
320 haddr->hci_dev = hci_pi(sk)->hdev->id;
321
322 release_sock(sk);
323 return 0;
324 }
325
326 static inline void hci_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
327 {
328 __u32 mask = hci_pi(sk)->cmsg_mask;
329
330 if (mask & HCI_CMSG_DIR)
331 put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(int), &bt_cb(skb)->incoming);
332
333 if (mask & HCI_CMSG_TSTAMP)
334 put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, sizeof(skb->stamp), &skb->stamp);
335 }
336
337 static int hci_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
338 struct msghdr *msg, size_t len, int flags)
339 {
340 int noblock = flags & MSG_DONTWAIT;
341 struct sock *sk = sock->sk;
342 struct sk_buff *skb;
343 int copied, err;
344
345 BT_DBG("sock %p, sk %p", sock, sk);
346
347 if (flags & (MSG_OOB))
348 return -EOPNOTSUPP;
349
350 if (sk->sk_state == BT_CLOSED)
351 return 0;
352
353 if (!(skb = skb_recv_datagram(sk, flags, noblock, &err)))
354 return err;
355
356 msg->msg_namelen = 0;
357
358 copied = skb->len;
359 if (len < copied) {
360 msg->msg_flags |= MSG_TRUNC;
361 copied = len;
362 }
363
364 skb->h.raw = skb->data;
365 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
366
367 hci_sock_cmsg(sk, msg, skb);
368
369 skb_free_datagram(sk, skb);
370
371 return err ? : copied;
372 }
373
374 static int hci_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
375 struct msghdr *msg, size_t len)
376 {
377 struct sock *sk = sock->sk;
378 struct hci_dev *hdev;
379 struct sk_buff *skb;
380 int err;
381
382 BT_DBG("sock %p sk %p", sock, sk);
383
384 if (msg->msg_flags & MSG_OOB)
385 return -EOPNOTSUPP;
386
387 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE))
388 return -EINVAL;
389
390 if (len < 4 || len > HCI_MAX_FRAME_SIZE)
391 return -EINVAL;
392
393 lock_sock(sk);
394
395 if (!(hdev = hci_pi(sk)->hdev)) {
396 err = -EBADFD;
397 goto done;
398 }
399
400 if (!(skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err)))
401 goto done;
402
403 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
404 err = -EFAULT;
405 goto drop;
406 }
407
408 skb->pkt_type = *((unsigned char *) skb->data);
409 skb_pull(skb, 1);
410 skb->dev = (void *) hdev;
411
412 if (skb->pkt_type == HCI_COMMAND_PKT) {
413 u16 opcode = __le16_to_cpu(get_unaligned((u16 *)skb->data));
414 u16 ogf = hci_opcode_ogf(opcode);
415 u16 ocf = hci_opcode_ocf(opcode);
416
417 if (((ogf > HCI_SFLT_MAX_OGF) ||
418 !hci_test_bit(ocf & HCI_FLT_OCF_BITS, &hci_sec_filter.ocf_mask[ogf])) &&
419 !capable(CAP_NET_RAW)) {
420 err = -EPERM;
421 goto drop;
422 }
423
424 if (test_bit(HCI_RAW, &hdev->flags) || (ogf == OGF_VENDOR_CMD)) {
425 skb_queue_tail(&hdev->raw_q, skb);
426 hci_sched_tx(hdev);
427 } else {
428 skb_queue_tail(&hdev->cmd_q, skb);
429 hci_sched_cmd(hdev);
430 }
431 } else {
432 if (!capable(CAP_NET_RAW)) {
433 err = -EPERM;
434 goto drop;
435 }
436
437 skb_queue_tail(&hdev->raw_q, skb);
438 hci_sched_tx(hdev);
439 }
440
441 err = len;
442
443 done:
444 release_sock(sk);
445 return err;
446
447 drop:
448 kfree_skb(skb);
449 goto done;
450 }
451
452 static int hci_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int len)
453 {
454 struct hci_ufilter uf = { .opcode = 0 };
455 struct sock *sk = sock->sk;
456 int err = 0, opt = 0;
457
458 BT_DBG("sk %p, opt %d", sk, optname);
459
460 lock_sock(sk);
461
462 switch (optname) {
463 case HCI_DATA_DIR:
464 if (get_user(opt, (int __user *)optval)) {
465 err = -EFAULT;
466 break;
467 }
468
469 if (opt)
470 hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR;
471 else
472 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
473 break;
474
475 case HCI_TIME_STAMP:
476 if (get_user(opt, (int __user *)optval)) {
477 err = -EFAULT;
478 break;
479 }
480
481 if (opt)
482 hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP;
483 else
484 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP;
485 break;
486
487 case HCI_FILTER:
488 len = min_t(unsigned int, len, sizeof(uf));
489 if (copy_from_user(&uf, optval, len)) {
490 err = -EFAULT;
491 break;
492 }
493
494 if (!capable(CAP_NET_RAW)) {
495 uf.type_mask &= hci_sec_filter.type_mask;
496 uf.event_mask[0] &= *((u32 *) hci_sec_filter.event_mask + 0);
497 uf.event_mask[1] &= *((u32 *) hci_sec_filter.event_mask + 1);
498 }
499
500 {
501 struct hci_filter *f = &hci_pi(sk)->filter;
502
503 f->type_mask = uf.type_mask;
504 f->opcode = uf.opcode;
505 *((u32 *) f->event_mask + 0) = uf.event_mask[0];
506 *((u32 *) f->event_mask + 1) = uf.event_mask[1];
507 }
508 break;
509
510 default:
511 err = -ENOPROTOOPT;
512 break;
513 }
514
515 release_sock(sk);
516 return err;
517 }
518
519 static int hci_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
520 {
521 struct hci_ufilter uf;
522 struct sock *sk = sock->sk;
523 int len, opt;
524
525 if (get_user(len, optlen))
526 return -EFAULT;
527
528 switch (optname) {
529 case HCI_DATA_DIR:
530 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
531 opt = 1;
532 else
533 opt = 0;
534
535 if (put_user(opt, optval))
536 return -EFAULT;
537 break;
538
539 case HCI_TIME_STAMP:
540 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP)
541 opt = 1;
542 else
543 opt = 0;
544
545 if (put_user(opt, optval))
546 return -EFAULT;
547 break;
548
549 case HCI_FILTER:
550 {
551 struct hci_filter *f = &hci_pi(sk)->filter;
552
553 uf.type_mask = f->type_mask;
554 uf.opcode = f->opcode;
555 uf.event_mask[0] = *((u32 *) f->event_mask + 0);
556 uf.event_mask[1] = *((u32 *) f->event_mask + 1);
557 }
558
559 len = min_t(unsigned int, len, sizeof(uf));
560 if (copy_to_user(optval, &uf, len))
561 return -EFAULT;
562 break;
563
564 default:
565 return -ENOPROTOOPT;
566 break;
567 }
568
569 return 0;
570 }
571
572 static struct proto_ops hci_sock_ops = {
573 .family = PF_BLUETOOTH,
574 .owner = THIS_MODULE,
575 .release = hci_sock_release,
576 .bind = hci_sock_bind,
577 .getname = hci_sock_getname,
578 .sendmsg = hci_sock_sendmsg,
579 .recvmsg = hci_sock_recvmsg,
580 .ioctl = hci_sock_ioctl,
581 .poll = datagram_poll,
582 .listen = sock_no_listen,
583 .shutdown = sock_no_shutdown,
584 .setsockopt = hci_sock_setsockopt,
585 .getsockopt = hci_sock_getsockopt,
586 .connect = sock_no_connect,
587 .socketpair = sock_no_socketpair,
588 .accept = sock_no_accept,
589 .mmap = sock_no_mmap
590 };
591
592 static struct proto hci_sk_proto = {
593 .name = "HCI",
594 .owner = THIS_MODULE,
595 .obj_size = sizeof(struct hci_pinfo)
596 };
597
598 static int hci_sock_create(struct socket *sock, int protocol)
599 {
600 struct sock *sk;
601
602 BT_DBG("sock %p", sock);
603
604 if (sock->type != SOCK_RAW)
605 return -ESOCKTNOSUPPORT;
606
607 sock->ops = &hci_sock_ops;
608
609 sk = sk_alloc(PF_BLUETOOTH, GFP_KERNEL, &hci_sk_proto, 1);
610 if (!sk)
611 return -ENOMEM;
612
613 sock_init_data(sock, sk);
614
615 sock_reset_flag(sk, SOCK_ZAPPED);
616
617 sk->sk_protocol = protocol;
618
619 sock->state = SS_UNCONNECTED;
620 sk->sk_state = BT_OPEN;
621
622 bt_sock_link(&hci_sk_list, sk);
623 return 0;
624 }
625
626 static int hci_sock_dev_event(struct notifier_block *this, unsigned long event, void *ptr)
627 {
628 struct hci_dev *hdev = (struct hci_dev *) ptr;
629 struct hci_ev_si_device ev;
630
631 BT_DBG("hdev %s event %ld", hdev->name, event);
632
633 /* Send event to sockets */
634 ev.event = event;
635 ev.dev_id = hdev->id;
636 hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev);
637
638 if (event == HCI_DEV_UNREG) {
639 struct sock *sk;
640 struct hlist_node *node;
641
642 /* Detach sockets from device */
643 read_lock(&hci_sk_list.lock);
644 sk_for_each(sk, node, &hci_sk_list.head) {
645 bh_lock_sock(sk);
646 if (hci_pi(sk)->hdev == hdev) {
647 hci_pi(sk)->hdev = NULL;
648 sk->sk_err = EPIPE;
649 sk->sk_state = BT_OPEN;
650 sk->sk_state_change(sk);
651
652 hci_dev_put(hdev);
653 }
654 bh_unlock_sock(sk);
655 }
656 read_unlock(&hci_sk_list.lock);
657 }
658
659 return NOTIFY_DONE;
660 }
661
662 static struct net_proto_family hci_sock_family_ops = {
663 .family = PF_BLUETOOTH,
664 .owner = THIS_MODULE,
665 .create = hci_sock_create,
666 };
667
668 static struct notifier_block hci_sock_nblock = {
669 .notifier_call = hci_sock_dev_event
670 };
671
672 int __init hci_sock_init(void)
673 {
674 int err;
675
676 err = proto_register(&hci_sk_proto, 0);
677 if (err < 0)
678 return err;
679
680 err = bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops);
681 if (err < 0)
682 goto error;
683
684 hci_register_notifier(&hci_sock_nblock);
685
686 BT_INFO("HCI socket layer initialized");
687
688 return 0;
689
690 error:
691 BT_ERR("HCI socket registration failed");
692 proto_unregister(&hci_sk_proto);
693 return err;
694 }
695
696 int __exit hci_sock_cleanup(void)
697 {
698 if (bt_sock_unregister(BTPROTO_HCI) < 0)
699 BT_ERR("HCI socket unregistration failed");
700
701 hci_unregister_notifier(&hci_sock_nblock);
702
703 proto_unregister(&hci_sk_proto);
704
705 return 0;
706 }
linux 2.6 git repository for openrd