[PATCH] sysfs: (driver/block) if show/store is missing return -EIO
[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((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 }