?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
SUNRPC: Provide a callback to allow free pages allocated during xdr encoding
[linux-2.6/verdex.git] / net / bluetooth / hci_sock.c
blob32ef7975a139149a31481711a34de2c27040ce17
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((bt_cb(skb)->pkt_type == HCI_VENDOR_PKT) ?
114 0 : (bt_cb(skb)->pkt_type & HCI_FLT_TYPE_BITS), &flt->type_mask))
115 continue;
116
117 if (bt_cb(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), &bt_cb(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 int incoming = bt_cb(skb)->incoming;
332 put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(incoming), &incoming);
333 }
334
335 if (mask & HCI_CMSG_TSTAMP) {
336 struct timeval tv;
337
338 skb_get_timestamp(skb, &tv);
339 put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, sizeof(tv), &tv);
340 }
341 }
342
343 static int hci_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
344 struct msghdr *msg, size_t len, int flags)
345 {
346 int noblock = flags & MSG_DONTWAIT;
347 struct sock *sk = sock->sk;
348 struct sk_buff *skb;
349 int copied, err;
350
351 BT_DBG("sock %p, sk %p", sock, sk);
352
353 if (flags & (MSG_OOB))
354 return -EOPNOTSUPP;
355
356 if (sk->sk_state == BT_CLOSED)
357 return 0;
358
359 if (!(skb = skb_recv_datagram(sk, flags, noblock, &err)))
360 return err;
361
362 msg->msg_namelen = 0;
363
364 copied = skb->len;
365 if (len < copied) {
366 msg->msg_flags |= MSG_TRUNC;
367 copied = len;
368 }
369
370 skb->h.raw = skb->data;
371 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
372
373 hci_sock_cmsg(sk, msg, skb);
374
375 skb_free_datagram(sk, skb);
376
377 return err ? : copied;
378 }
379
380 static int hci_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
381 struct msghdr *msg, size_t len)
382 {
383 struct sock *sk = sock->sk;
384 struct hci_dev *hdev;
385 struct sk_buff *skb;
386 int err;
387
388 BT_DBG("sock %p sk %p", sock, sk);
389
390 if (msg->msg_flags & MSG_OOB)
391 return -EOPNOTSUPP;
392
393 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE))
394 return -EINVAL;
395
396 if (len < 4 || len > HCI_MAX_FRAME_SIZE)
397 return -EINVAL;
398
399 lock_sock(sk);
400
401 if (!(hdev = hci_pi(sk)->hdev)) {
402 err = -EBADFD;
403 goto done;
404 }
405
406 if (!(skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err)))
407 goto done;
408
409 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
410 err = -EFAULT;
411 goto drop;
412 }
413
414 bt_cb(skb)->pkt_type = *((unsigned char *) skb->data);
415 skb_pull(skb, 1);
416 skb->dev = (void *) hdev;
417
418 if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) {
419 u16 opcode = __le16_to_cpu(get_unaligned((u16 *)skb->data));
420 u16 ogf = hci_opcode_ogf(opcode);
421 u16 ocf = hci_opcode_ocf(opcode);
422
423 if (((ogf > HCI_SFLT_MAX_OGF) ||
424 !hci_test_bit(ocf & HCI_FLT_OCF_BITS, &hci_sec_filter.ocf_mask[ogf])) &&
425 !capable(CAP_NET_RAW)) {
426 err = -EPERM;
427 goto drop;
428 }
429
430 if (test_bit(HCI_RAW, &hdev->flags) || (ogf == OGF_VENDOR_CMD)) {
431 skb_queue_tail(&hdev->raw_q, skb);
432 hci_sched_tx(hdev);
433 } else {
434 skb_queue_tail(&hdev->cmd_q, skb);
435 hci_sched_cmd(hdev);
436 }
437 } else {
438 if (!capable(CAP_NET_RAW)) {
439 err = -EPERM;
440 goto drop;
441 }
442
443 skb_queue_tail(&hdev->raw_q, skb);
444 hci_sched_tx(hdev);
445 }
446
447 err = len;
448
449 done:
450 release_sock(sk);
451 return err;
452
453 drop:
454 kfree_skb(skb);
455 goto done;
456 }
457
458 static int hci_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, int len)
459 {
460 struct hci_ufilter uf = { .opcode = 0 };
461 struct sock *sk = sock->sk;
462 int err = 0, opt = 0;
463
464 BT_DBG("sk %p, opt %d", sk, optname);
465
466 lock_sock(sk);
467
468 switch (optname) {
469 case HCI_DATA_DIR:
470 if (get_user(opt, (int __user *)optval)) {
471 err = -EFAULT;
472 break;
473 }
474
475 if (opt)
476 hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR;
477 else
478 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
479 break;
480
481 case HCI_TIME_STAMP:
482 if (get_user(opt, (int __user *)optval)) {
483 err = -EFAULT;
484 break;
485 }
486
487 if (opt)
488 hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP;
489 else
490 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP;
491 break;
492
493 case HCI_FILTER:
494 len = min_t(unsigned int, len, sizeof(uf));
495 if (copy_from_user(&uf, optval, len)) {
496 err = -EFAULT;
497 break;
498 }
499
500 if (!capable(CAP_NET_RAW)) {
501 uf.type_mask &= hci_sec_filter.type_mask;
502 uf.event_mask[0] &= *((u32 *) hci_sec_filter.event_mask + 0);
503 uf.event_mask[1] &= *((u32 *) hci_sec_filter.event_mask + 1);
504 }
505
506 {
507 struct hci_filter *f = &hci_pi(sk)->filter;
508
509 f->type_mask = uf.type_mask;
510 f->opcode = uf.opcode;
511 *((u32 *) f->event_mask + 0) = uf.event_mask[0];
512 *((u32 *) f->event_mask + 1) = uf.event_mask[1];
513 }
514 break;
515
516 default:
517 err = -ENOPROTOOPT;
518 break;
519 }
520
521 release_sock(sk);
522 return err;
523 }
524
525 static int hci_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
526 {
527 struct hci_ufilter uf;
528 struct sock *sk = sock->sk;
529 int len, opt;
530
531 if (get_user(len, optlen))
532 return -EFAULT;
533
534 switch (optname) {
535 case HCI_DATA_DIR:
536 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
537 opt = 1;
538 else
539 opt = 0;
540
541 if (put_user(opt, optval))
542 return -EFAULT;
543 break;
544
545 case HCI_TIME_STAMP:
546 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP)
547 opt = 1;
548 else
549 opt = 0;
550
551 if (put_user(opt, optval))
552 return -EFAULT;
553 break;
554
555 case HCI_FILTER:
556 {
557 struct hci_filter *f = &hci_pi(sk)->filter;
558
559 uf.type_mask = f->type_mask;
560 uf.opcode = f->opcode;
561 uf.event_mask[0] = *((u32 *) f->event_mask + 0);
562 uf.event_mask[1] = *((u32 *) f->event_mask + 1);
563 }
564
565 len = min_t(unsigned int, len, sizeof(uf));
566 if (copy_to_user(optval, &uf, len))
567 return -EFAULT;
568 break;
569
570 default:
571 return -ENOPROTOOPT;
572 break;
573 }
574
575 return 0;
576 }
577
578 static struct proto_ops hci_sock_ops = {
579 .family = PF_BLUETOOTH,
580 .owner = THIS_MODULE,
581 .release = hci_sock_release,
582 .bind = hci_sock_bind,
583 .getname = hci_sock_getname,
584 .sendmsg = hci_sock_sendmsg,
585 .recvmsg = hci_sock_recvmsg,
586 .ioctl = hci_sock_ioctl,
587 .poll = datagram_poll,
588 .listen = sock_no_listen,
589 .shutdown = sock_no_shutdown,
590 .setsockopt = hci_sock_setsockopt,
591 .getsockopt = hci_sock_getsockopt,
592 .connect = sock_no_connect,
593 .socketpair = sock_no_socketpair,
594 .accept = sock_no_accept,
595 .mmap = sock_no_mmap
596 };
597
598 static struct proto hci_sk_proto = {
599 .name = "HCI",
600 .owner = THIS_MODULE,
601 .obj_size = sizeof(struct hci_pinfo)
602 };
603
604 static int hci_sock_create(struct socket *sock, int protocol)
605 {
606 struct sock *sk;
607
608 BT_DBG("sock %p", sock);
609
610 if (sock->type != SOCK_RAW)
611 return -ESOCKTNOSUPPORT;
612
613 sock->ops = &hci_sock_ops;
614
615 sk = sk_alloc(PF_BLUETOOTH, GFP_KERNEL, &hci_sk_proto, 1);
616 if (!sk)
617 return -ENOMEM;
618
619 sock_init_data(sock, sk);
620
621 sock_reset_flag(sk, SOCK_ZAPPED);
622
623 sk->sk_protocol = protocol;
624
625 sock->state = SS_UNCONNECTED;
626 sk->sk_state = BT_OPEN;
627
628 bt_sock_link(&hci_sk_list, sk);
629 return 0;
630 }
631
632 static int hci_sock_dev_event(struct notifier_block *this, unsigned long event, void *ptr)
633 {
634 struct hci_dev *hdev = (struct hci_dev *) ptr;
635 struct hci_ev_si_device ev;
636
637 BT_DBG("hdev %s event %ld", hdev->name, event);
638
639 /* Send event to sockets */
640 ev.event = event;
641 ev.dev_id = hdev->id;
642 hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev);
643
644 if (event == HCI_DEV_UNREG) {
645 struct sock *sk;
646 struct hlist_node *node;
647
648 /* Detach sockets from device */
649 read_lock(&hci_sk_list.lock);
650 sk_for_each(sk, node, &hci_sk_list.head) {
651 bh_lock_sock(sk);
652 if (hci_pi(sk)->hdev == hdev) {
653 hci_pi(sk)->hdev = NULL;
654 sk->sk_err = EPIPE;
655 sk->sk_state = BT_OPEN;
656 sk->sk_state_change(sk);
657
658 hci_dev_put(hdev);
659 }
660 bh_unlock_sock(sk);
661 }
662 read_unlock(&hci_sk_list.lock);
663 }
664
665 return NOTIFY_DONE;
666 }
667
668 static struct net_proto_family hci_sock_family_ops = {
669 .family = PF_BLUETOOTH,
670 .owner = THIS_MODULE,
671 .create = hci_sock_create,
672 };
673
674 static struct notifier_block hci_sock_nblock = {
675 .notifier_call = hci_sock_dev_event
676 };
677
678 int __init hci_sock_init(void)
679 {
680 int err;
681
682 err = proto_register(&hci_sk_proto, 0);
683 if (err < 0)
684 return err;
685
686 err = bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops);
687 if (err < 0)
688 goto error;
689
690 hci_register_notifier(&hci_sock_nblock);
691
692 BT_INFO("HCI socket layer initialized");
693
694 return 0;
695
696 error:
697 BT_ERR("HCI socket registration failed");
698 proto_unregister(&hci_sk_proto);
699 return err;
700 }
701
702 int __exit hci_sock_cleanup(void)
703 {
704 if (bt_sock_unregister(BTPROTO_HCI) < 0)
705 BT_ERR("HCI socket unregistration failed");
706
707 hci_unregister_notifier(&hci_sock_nblock);
708
709 proto_unregister(&hci_sk_proto);
710
711 return 0;
712 }
Verdex Pro support