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