[NET]: Store skb->timestamp as offset to a base timestamp
[linux-2.6.git] / 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/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 }