projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Bluetooth: Fix hci_connect error return values
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / bluetooth / hci_sock.c
CommitLineData
8e87d142 1/*
1da177e4
LT		 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
8e87d142
YH		 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
1da177e4
LT		 18 OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
19
8e87d142
YH		 20 ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS,
21 COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS
1da177e4
LT		 22 SOFTWARE IS DISCLAIMED.
23*/
24
25/* Bluetooth HCI sockets. */
26
1da177e4
LT		 27#include <linux/module.h>
28
29#include <linux/types.h>
4fc268d2 30#include <linux/capability.h>
1da177e4
LT		 31#include <linux/errno.h>
32#include <linux/kernel.h>
1da177e4
LT		 33#include <linux/slab.h>
34#include <linux/poll.h>
35#include <linux/fcntl.h>
36#include <linux/init.h>
37#include <linux/skbuff.h>
38#include <linux/workqueue.h>
39#include <linux/interrupt.h>
767c5eb5 40#include <linux/compat.h>
1da177e4
LT		 41#include <linux/socket.h>
42#include <linux/ioctl.h>
43#include <net/sock.h>
44
45#include <asm/system.h>
70f23020 46#include <linux/uaccess.h>
1da177e4
LT		 47#include <asm/unaligned.h>
48
49#include <net/bluetooth/bluetooth.h>
50#include <net/bluetooth/hci_core.h>
51
eb939922 52static bool enable_mgmt;
0381101f 53
1da177e4
LT		 54/* ----- HCI socket interface ----- */
55
56static inline int hci_test_bit(int nr, void *addr)
57{
58 return *((__u32 *) addr + (nr >> 5)) & ((__u32) 1 << (nr & 31));
59}
60
61/* Security filter */
62static struct hci_sec_filter hci_sec_filter = {
63 /* Packet types */
64 0x10,
65 /* Events */
dd7f5527 66 { 0x1000d9fe, 0x0000b00c },
1da177e4
LT		 67 /* Commands */
68 {
69 { 0x0 },
70 /* OGF_LINK_CTL */
7c631a67 71 { 0xbe000006, 0x00000001, 0x00000000, 0x00 },
1da177e4 72 /* OGF_LINK_POLICY */
7c631a67 73 { 0x00005200, 0x00000000, 0x00000000, 0x00 },
1da177e4 74 /* OGF_HOST_CTL */
7c631a67 75 { 0xaab00200, 0x2b402aaa, 0x05220154, 0x00 },
1da177e4 76 /* OGF_INFO_PARAM */
7c631a67 77 { 0x000002be, 0x00000000, 0x00000000, 0x00 },
1da177e4 78 /* OGF_STATUS_PARAM */
7c631a67 79 { 0x000000ea, 0x00000000, 0x00000000, 0x00 }
1da177e4
LT		 80 }
81};
82
83static struct bt_sock_list hci_sk_list = {
d5fb2962 84 .lock = __RW_LOCK_UNLOCKED(hci_sk_list.lock)
1da177e4
LT		 85};
86
87/* Send frame to RAW socket */
eec8d2bc
JH		 88void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb,
89 struct sock *skip_sk)
1da177e4
LT		 90{
91 struct sock *sk;
92 struct hlist_node *node;
93
94 BT_DBG("hdev %p len %d", hdev, skb->len);
95
96 read_lock(&hci_sk_list.lock);
97 sk_for_each(sk, node, &hci_sk_list.head) {
98 struct hci_filter *flt;
99 struct sk_buff *nskb;
100
eec8d2bc
JH		 101 if (sk == skip_sk)
102 continue;
103
1da177e4
LT		 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
a40c406c
JH		 111 if (bt_cb(skb)->channel != hci_pi(sk)->channel)
112 continue;
113
114 if (bt_cb(skb)->channel == HCI_CHANNEL_CONTROL)
115 goto clone;
116
1da177e4
LT		 117 /* Apply filter */
118 flt = &hci_pi(sk)->filter;
119
0d48d939
MH		 120 if (!test_bit((bt_cb(skb)->pkt_type == HCI_VENDOR_PKT) ?
121 0 : (bt_cb(skb)->pkt_type & HCI_FLT_TYPE_BITS), &flt->type_mask))
1da177e4
LT		 122 continue;
123
0d48d939 124 if (bt_cb(skb)->pkt_type == HCI_EVENT_PKT) {
1da177e4
LT		 125 register int evt = (*(__u8 *)skb->data & HCI_FLT_EVENT_BITS);
126
127 if (!hci_test_bit(evt, &flt->event_mask))
128 continue;
129
4498c80d
DM		 130 if (flt->opcode &&
131 ((evt == HCI_EV_CMD_COMPLETE &&
132 flt->opcode !=
905f3ed6 133 get_unaligned((__le16 *)(skb->data + 3))) ||
4498c80d
DM		 134 (evt == HCI_EV_CMD_STATUS &&
135 flt->opcode !=
905f3ed6 136 get_unaligned((__le16 *)(skb->data + 4)))))
1da177e4
LT		 137 continue;
138 }
139
a40c406c 140clone:
70f23020
AE		 141 nskb = skb_clone(skb, GFP_ATOMIC);
142 if (!nskb)
1da177e4
LT		 143 continue;
144
145 /* Put type byte before the data */
a40c406c
JH		 146 if (bt_cb(skb)->channel == HCI_CHANNEL_RAW)
147 memcpy(skb_push(nskb, 1), &bt_cb(nskb)->pkt_type, 1);
1da177e4
LT		 148
149 if (sock_queue_rcv_skb(sk, nskb))
150 kfree_skb(nskb);
151 }
152 read_unlock(&hci_sk_list.lock);
153}
154
155static int hci_sock_release(struct socket *sock)
156{
157 struct sock *sk = sock->sk;
7b005bd3 158 struct hci_dev *hdev;
1da177e4
LT		 159
160 BT_DBG("sock %p sk %p", sock, sk);
161
162 if (!sk)
163 return 0;
164
7b005bd3
MH		 165 hdev = hci_pi(sk)->hdev;
166
1da177e4
LT		 167 bt_sock_unlink(&hci_sk_list, sk);
168
169 if (hdev) {
170 atomic_dec(&hdev->promisc);
171 hci_dev_put(hdev);
172 }
173
174 sock_orphan(sk);
175
176 skb_queue_purge(&sk->sk_receive_queue);
177 skb_queue_purge(&sk->sk_write_queue);
178
179 sock_put(sk);
180 return 0;
181}
182
b2a66aad 183static int hci_sock_blacklist_add(struct hci_dev *hdev, void __user *arg)
f0358568
JH		 184{
185 bdaddr_t bdaddr;
5e762444 186 int err;
f0358568
JH		 187
188 if (copy_from_user(&bdaddr, arg, sizeof(bdaddr)))
189 return -EFAULT;
190
09fd0de5 191 hci_dev_lock(hdev);
5e762444 192
88c1fe4b 193 err = hci_blacklist_add(hdev, &bdaddr, 0);
5e762444 194
09fd0de5 195 hci_dev_unlock(hdev);
5e762444
AJ		 196
197 return err;
f0358568
JH		 198}
199
b2a66aad 200static int hci_sock_blacklist_del(struct hci_dev *hdev, void __user *arg)
f0358568
JH		 201{
202 bdaddr_t bdaddr;
5e762444 203 int err;
f0358568
JH		 204
205 if (copy_from_user(&bdaddr, arg, sizeof(bdaddr)))
206 return -EFAULT;
207
09fd0de5 208 hci_dev_lock(hdev);
5e762444 209
88c1fe4b 210 err = hci_blacklist_del(hdev, &bdaddr, 0);
5e762444 211
09fd0de5 212 hci_dev_unlock(hdev);
5e762444
AJ		 213
214 return err;
f0358568
JH		 215}
216
8e87d142 217/* Ioctls that require bound socket */
1da177e4
LT		 218static inline int hci_sock_bound_ioctl(struct sock *sk, unsigned int cmd, unsigned long arg)
219{
220 struct hci_dev *hdev = hci_pi(sk)->hdev;
221
222 if (!hdev)
223 return -EBADFD;
224
225 switch (cmd) {
226 case HCISETRAW:
227 if (!capable(CAP_NET_ADMIN))
228 return -EACCES;
229
230 if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks))
231 return -EPERM;
232
233 if (arg)
234 set_bit(HCI_RAW, &hdev->flags);
235 else
236 clear_bit(HCI_RAW, &hdev->flags);
237
238 return 0;
239
1da177e4 240 case HCIGETCONNINFO:
40be492f
MH		 241 return hci_get_conn_info(hdev, (void __user *) arg);
242
243 case HCIGETAUTHINFO:
244 return hci_get_auth_info(hdev, (void __user *) arg);
1da177e4 245
f0358568
JH		 246 case HCIBLOCKADDR:
247 if (!capable(CAP_NET_ADMIN))
248 return -EACCES;
b2a66aad 249 return hci_sock_blacklist_add(hdev, (void __user *) arg);
f0358568
JH		 250
251 case HCIUNBLOCKADDR:
252 if (!capable(CAP_NET_ADMIN))
253 return -EACCES;
b2a66aad 254 return hci_sock_blacklist_del(hdev, (void __user *) arg);
f0358568 255
1da177e4
LT		 256 default:
257 if (hdev->ioctl)
258 return hdev->ioctl(hdev, cmd, arg);
259 return -EINVAL;
260 }
261}
262
263static int hci_sock_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
264{
265 struct sock *sk = sock->sk;
40be492f 266 void __user *argp = (void __user *) arg;
1da177e4
LT		 267 int err;
268
269 BT_DBG("cmd %x arg %lx", cmd, arg);
270
271 switch (cmd) {
272 case HCIGETDEVLIST:
273 return hci_get_dev_list(argp);
274
275 case HCIGETDEVINFO:
276 return hci_get_dev_info(argp);
277
278 case HCIGETCONNLIST:
279 return hci_get_conn_list(argp);
280
281 case HCIDEVUP:
282 if (!capable(CAP_NET_ADMIN))
283 return -EACCES;
284 return hci_dev_open(arg);
285
286 case HCIDEVDOWN:
287 if (!capable(CAP_NET_ADMIN))
288 return -EACCES;
289 return hci_dev_close(arg);
290
291 case HCIDEVRESET:
292 if (!capable(CAP_NET_ADMIN))
293 return -EACCES;
294 return hci_dev_reset(arg);
295
296 case HCIDEVRESTAT:
297 if (!capable(CAP_NET_ADMIN))
298 return -EACCES;
299 return hci_dev_reset_stat(arg);
300
301 case HCISETSCAN:
302 case HCISETAUTH:
303 case HCISETENCRYPT:
304 case HCISETPTYPE:
305 case HCISETLINKPOL:
306 case HCISETLINKMODE:
307 case HCISETACLMTU:
308 case HCISETSCOMTU:
309 if (!capable(CAP_NET_ADMIN))
310 return -EACCES;
311 return hci_dev_cmd(cmd, argp);
312
313 case HCIINQUIRY:
314 return hci_inquiry(argp);
315
316 default:
317 lock_sock(sk);
318 err = hci_sock_bound_ioctl(sk, cmd, arg);
319 release_sock(sk);
320 return err;
321 }
322}
323
324static int hci_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
325{
0381101f 326 struct sockaddr_hci haddr;
1da177e4
LT		 327 struct sock *sk = sock->sk;
328 struct hci_dev *hdev = NULL;
0381101f 329 int len, err = 0;
1da177e4
LT		 330
331 BT_DBG("sock %p sk %p", sock, sk);
332
0381101f
JH		 333 if (!addr)
334 return -EINVAL;
335
336 memset(&haddr, 0, sizeof(haddr));
337 len = min_t(unsigned int, sizeof(haddr), addr_len);
338 memcpy(&haddr, addr, len);
339
340 if (haddr.hci_family != AF_BLUETOOTH)
341 return -EINVAL;
342
17f9cc31
GP		 343 if (haddr.hci_channel > HCI_CHANNEL_CONTROL)
344 return -EINVAL;
345
14c0b608
JH		 346 if (haddr.hci_channel == HCI_CHANNEL_CONTROL) {
347 if (!enable_mgmt)
348 return -EINVAL;
349 set_bit(HCI_PI_MGMT_INIT, &hci_pi(sk)->flags);
350 }
1da177e4
LT		 351
352 lock_sock(sk);
353
0381101f 354 if (sk->sk_state == BT_BOUND || hci_pi(sk)->hdev) {
1da177e4
LT		 355 err = -EALREADY;
356 goto done;
357 }
358
0381101f
JH		 359 if (haddr.hci_dev != HCI_DEV_NONE) {
360 hdev = hci_dev_get(haddr.hci_dev);
70f23020 361 if (!hdev) {
1da177e4
LT		 362 err = -ENODEV;
363 goto done;
364 }
365
366 atomic_inc(&hdev->promisc);
367 }
368
0381101f 369 hci_pi(sk)->channel = haddr.hci_channel;
1da177e4
LT		 370 hci_pi(sk)->hdev = hdev;
371 sk->sk_state = BT_BOUND;
372
373done:
374 release_sock(sk);
375 return err;
376}
377
378static int hci_sock_getname(struct socket *sock, struct sockaddr *addr, int *addr_len, int peer)
379{
380 struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
381 struct sock *sk = sock->sk;
7b005bd3 382 struct hci_dev *hdev = hci_pi(sk)->hdev;
1da177e4
LT		 383
384 BT_DBG("sock %p sk %p", sock, sk);
385
7b005bd3
MH		 386 if (!hdev)
387 return -EBADFD;
388
1da177e4
LT		 389 lock_sock(sk);
390
391 *addr_len = sizeof(*haddr);
392 haddr->hci_family = AF_BLUETOOTH;
7b005bd3 393 haddr->hci_dev = hdev->id;
1da177e4
LT		 394
395 release_sock(sk);
396 return 0;
397}
398
399static inline void hci_sock_cmsg(struct sock *sk, struct msghdr *msg, struct sk_buff *skb)
400{
401 __u32 mask = hci_pi(sk)->cmsg_mask;
402
0d48d939
MH		 403 if (mask & HCI_CMSG_DIR) {
404 int incoming = bt_cb(skb)->incoming;
405 put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(incoming), &incoming);
406 }
1da177e4 407
a61bbcf2 408 if (mask & HCI_CMSG_TSTAMP) {
f6e623a6
JFS		 409#ifdef CONFIG_COMPAT
410 struct compat_timeval ctv;
411#endif
a61bbcf2 412 struct timeval tv;
767c5eb5
MH		 413 void *data;
414 int len;
a61bbcf2
PM		 415
416 skb_get_timestamp(skb, &tv);
767c5eb5 417
1da97f83
DM		 418 data = &tv;
419 len = sizeof(tv);
420#ifdef CONFIG_COMPAT
767c5eb5 421 if (msg->msg_flags & MSG_CMSG_COMPAT) {
767c5eb5
MH		 422 ctv.tv_sec = tv.tv_sec;
423 ctv.tv_usec = tv.tv_usec;
424 data = &ctv;
425 len = sizeof(ctv);
767c5eb5 426 }
1da97f83 427#endif
767c5eb5
MH		 428
429 put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, len, data);
a61bbcf2 430 }
1da177e4 431}
8e87d142
YH		 432
433static int hci_sock_recvmsg(struct kiocb *iocb, struct socket *sock,
1da177e4
LT		 434 struct msghdr *msg, size_t len, int flags)
435{
436 int noblock = flags & MSG_DONTWAIT;
437 struct sock *sk = sock->sk;
438 struct sk_buff *skb;
439 int copied, err;
440
441 BT_DBG("sock %p, sk %p", sock, sk);
442
443 if (flags & (MSG_OOB))
444 return -EOPNOTSUPP;
445
446 if (sk->sk_state == BT_CLOSED)
447 return 0;
448
70f23020
AE		 449 skb = skb_recv_datagram(sk, flags, noblock, &err);
450 if (!skb)
1da177e4
LT		 451 return err;
452
453 msg->msg_namelen = 0;
454
455 copied = skb->len;
456 if (len < copied) {
457 msg->msg_flags |= MSG_TRUNC;
458 copied = len;
459 }
460
badff6d0 461 skb_reset_transport_header(skb);
1da177e4
LT		 462 err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
463
464 hci_sock_cmsg(sk, msg, skb);
465
466 skb_free_datagram(sk, skb);
467
468 return err ? : copied;
469}
470
8e87d142 471static int hci_sock_sendmsg(struct kiocb *iocb, struct socket *sock,
1da177e4
LT		 472 struct msghdr *msg, size_t len)
473{
474 struct sock *sk = sock->sk;
475 struct hci_dev *hdev;
476 struct sk_buff *skb;
477 int err;
478
479 BT_DBG("sock %p sk %p", sock, sk);
480
481 if (msg->msg_flags & MSG_OOB)
482 return -EOPNOTSUPP;
483
484 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE))
485 return -EINVAL;
486
487 if (len < 4 || len > HCI_MAX_FRAME_SIZE)
488 return -EINVAL;
489
490 lock_sock(sk);
491
0381101f
JH		 492 switch (hci_pi(sk)->channel) {
493 case HCI_CHANNEL_RAW:
494 break;
495 case HCI_CHANNEL_CONTROL:
496 err = mgmt_control(sk, msg, len);
497 goto done;
498 default:
499 err = -EINVAL;
500 goto done;
501 }
502
70f23020
AE		 503 hdev = hci_pi(sk)->hdev;
504 if (!hdev) {
1da177e4
LT		 505 err = -EBADFD;
506 goto done;
507 }
508
7e21addc
MH		 509 if (!test_bit(HCI_UP, &hdev->flags)) {
510 err = -ENETDOWN;
511 goto done;
512 }
513
70f23020
AE		 514 skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
515 if (!skb)
1da177e4
LT		 516 goto done;
517
518 if (memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len)) {
519 err = -EFAULT;
520 goto drop;
521 }
522
0d48d939 523 bt_cb(skb)->pkt_type = *((unsigned char *) skb->data);
1da177e4
LT		 524 skb_pull(skb, 1);
525 skb->dev = (void *) hdev;
526
0d48d939 527 if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) {
83985319 528 u16 opcode = get_unaligned_le16(skb->data);
1da177e4
LT		 529 u16 ogf = hci_opcode_ogf(opcode);
530 u16 ocf = hci_opcode_ocf(opcode);
531
532 if (((ogf > HCI_SFLT_MAX_OGF) ||
533 !hci_test_bit(ocf & HCI_FLT_OCF_BITS, &hci_sec_filter.ocf_mask[ogf])) &&
534 !capable(CAP_NET_RAW)) {
535 err = -EPERM;
536 goto drop;
537 }
538
a9de9248 539 if (test_bit(HCI_RAW, &hdev->flags) || (ogf == 0x3f)) {
1da177e4 540 skb_queue_tail(&hdev->raw_q, skb);
3eff45ea 541 queue_work(hdev->workqueue, &hdev->tx_work);
1da177e4
LT		 542 } else {
543 skb_queue_tail(&hdev->cmd_q, skb);
c347b765 544 queue_work(hdev->workqueue, &hdev->cmd_work);
1da177e4
LT		 545 }
546 } else {
547 if (!capable(CAP_NET_RAW)) {
548 err = -EPERM;
549 goto drop;
550 }
551
552 skb_queue_tail(&hdev->raw_q, skb);
3eff45ea 553 queue_work(hdev->workqueue, &hdev->tx_work);
1da177e4
LT		 554 }
555
556 err = len;
557
558done:
559 release_sock(sk);
560 return err;
561
562drop:
563 kfree_skb(skb);
564 goto done;
565}
566
b7058842 567static int hci_sock_setsockopt(struct socket *sock, int level, int optname, char __user *optval, unsigned int len)
1da177e4
LT		 568{
569 struct hci_ufilter uf = { .opcode = 0 };
570 struct sock *sk = sock->sk;
571 int err = 0, opt = 0;
572
573 BT_DBG("sk %p, opt %d", sk, optname);
574
575 lock_sock(sk);
576
577 switch (optname) {
578 case HCI_DATA_DIR:
579 if (get_user(opt, (int __user *)optval)) {
580 err = -EFAULT;
581 break;
582 }
583
584 if (opt)
585 hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR;
586 else
587 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
588 break;
589
590 case HCI_TIME_STAMP:
591 if (get_user(opt, (int __user *)optval)) {
592 err = -EFAULT;
593 break;
594 }
595
596 if (opt)
597 hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP;
598 else
599 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP;
600 break;
601
602 case HCI_FILTER:
0878b666
MH		 603 {
604 struct hci_filter *f = &hci_pi(sk)->filter;
605
606 uf.type_mask = f->type_mask;
607 uf.opcode = f->opcode;
608 uf.event_mask[0] = *((u32 *) f->event_mask + 0);
609 uf.event_mask[1] = *((u32 *) f->event_mask + 1);
610 }
611
1da177e4
LT		 612 len = min_t(unsigned int, len, sizeof(uf));
613 if (copy_from_user(&uf, optval, len)) {
614 err = -EFAULT;
615 break;
616 }
617
618 if (!capable(CAP_NET_RAW)) {
619 uf.type_mask &= hci_sec_filter.type_mask;
620 uf.event_mask[0] &= *((u32 *) hci_sec_filter.event_mask + 0);
621 uf.event_mask[1] &= *((u32 *) hci_sec_filter.event_mask + 1);
622 }
623
624 {
625 struct hci_filter *f = &hci_pi(sk)->filter;
626
627 f->type_mask = uf.type_mask;
628 f->opcode = uf.opcode;
629 *((u32 *) f->event_mask + 0) = uf.event_mask[0];
630 *((u32 *) f->event_mask + 1) = uf.event_mask[1];
631 }
8e87d142 632 break;
1da177e4
LT		 633
634 default:
635 err = -ENOPROTOOPT;
636 break;
637 }
638
639 release_sock(sk);
640 return err;
641}
642
643static int hci_sock_getsockopt(struct socket *sock, int level, int optname, char __user *optval, int __user *optlen)
644{
645 struct hci_ufilter uf;
646 struct sock *sk = sock->sk;
8e87d142 647 int len, opt;
1da177e4
LT		 648
649 if (get_user(len, optlen))
650 return -EFAULT;
651
652 switch (optname) {
653 case HCI_DATA_DIR:
654 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
655 opt = 1;
8e87d142 656 else
1da177e4
LT		 657 opt = 0;
658
659 if (put_user(opt, optval))
660 return -EFAULT;
661 break;
662
663 case HCI_TIME_STAMP:
664 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP)
665 opt = 1;
8e87d142 666 else
1da177e4
LT		 667 opt = 0;
668
669 if (put_user(opt, optval))
670 return -EFAULT;
671 break;
672
673 case HCI_FILTER:
674 {
675 struct hci_filter *f = &hci_pi(sk)->filter;
676
677 uf.type_mask = f->type_mask;
678 uf.opcode = f->opcode;
679 uf.event_mask[0] = *((u32 *) f->event_mask + 0);
680 uf.event_mask[1] = *((u32 *) f->event_mask + 1);
681 }
682
683 len = min_t(unsigned int, len, sizeof(uf));
684 if (copy_to_user(optval, &uf, len))
685 return -EFAULT;
686 break;
687
688 default:
689 return -ENOPROTOOPT;
690 break;
691 }
692
693 return 0;
694}
695
90ddc4f0 696static const struct proto_ops hci_sock_ops = {
1da177e4
LT		 697 .family = PF_BLUETOOTH,
698 .owner = THIS_MODULE,
699 .release = hci_sock_release,
700 .bind = hci_sock_bind,
701 .getname = hci_sock_getname,
702 .sendmsg = hci_sock_sendmsg,
703 .recvmsg = hci_sock_recvmsg,
704 .ioctl = hci_sock_ioctl,
705 .poll = datagram_poll,
706 .listen = sock_no_listen,
707 .shutdown = sock_no_shutdown,
708 .setsockopt = hci_sock_setsockopt,
709 .getsockopt = hci_sock_getsockopt,
710 .connect = sock_no_connect,
711 .socketpair = sock_no_socketpair,
712 .accept = sock_no_accept,
713 .mmap = sock_no_mmap
714};
715
716static struct proto hci_sk_proto = {
717 .name = "HCI",
718 .owner = THIS_MODULE,
719 .obj_size = sizeof(struct hci_pinfo)
720};
721
3f378b68
EP		 722static int hci_sock_create(struct net *net, struct socket *sock, int protocol,
723 int kern)
1da177e4
LT		 724{
725 struct sock *sk;
726
727 BT_DBG("sock %p", sock);
728
729 if (sock->type != SOCK_RAW)
730 return -ESOCKTNOSUPPORT;
731
732 sock->ops = &hci_sock_ops;
733
6257ff21 734 sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &hci_sk_proto);
1da177e4
LT		 735 if (!sk)
736 return -ENOMEM;
737
738 sock_init_data(sock, sk);
739
740 sock_reset_flag(sk, SOCK_ZAPPED);
741
742 sk->sk_protocol = protocol;
743
744 sock->state = SS_UNCONNECTED;
745 sk->sk_state = BT_OPEN;
746
747 bt_sock_link(&hci_sk_list, sk);
748 return 0;
749}
750
751static int hci_sock_dev_event(struct notifier_block *this, unsigned long event, void *ptr)
752{
753 struct hci_dev *hdev = (struct hci_dev *) ptr;
754 struct hci_ev_si_device ev;
755
756 BT_DBG("hdev %s event %ld", hdev->name, event);
757
758 /* Send event to sockets */
759 ev.event = event;
760 ev.dev_id = hdev->id;
761 hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev);
762
763 if (event == HCI_DEV_UNREG) {
764 struct sock *sk;
765 struct hlist_node *node;
766
767 /* Detach sockets from device */
768 read_lock(&hci_sk_list.lock);
769 sk_for_each(sk, node, &hci_sk_list.head) {
4ce61d1c 770 bh_lock_sock_nested(sk);
1da177e4
LT		 771 if (hci_pi(sk)->hdev == hdev) {
772 hci_pi(sk)->hdev = NULL;
773 sk->sk_err = EPIPE;
774 sk->sk_state = BT_OPEN;
775 sk->sk_state_change(sk);
776
777 hci_dev_put(hdev);
778 }
4ce61d1c 779 bh_unlock_sock(sk);
1da177e4
LT		 780 }
781 read_unlock(&hci_sk_list.lock);
782 }
783
784 return NOTIFY_DONE;
785}
786
ec1b4cf7 787static const struct net_proto_family hci_sock_family_ops = {
1da177e4
LT		 788 .family = PF_BLUETOOTH,
789 .owner = THIS_MODULE,
790 .create = hci_sock_create,
791};
792
793static struct notifier_block hci_sock_nblock = {
794 .notifier_call = hci_sock_dev_event
795};
796
797int __init hci_sock_init(void)
798{
799 int err;
800
801 err = proto_register(&hci_sk_proto, 0);
802 if (err < 0)
803 return err;
804
805 err = bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops);
806 if (err < 0)
807 goto error;
808
809 hci_register_notifier(&hci_sock_nblock);
810
811 BT_INFO("HCI socket layer initialized");
812
813 return 0;
814
815error:
816 BT_ERR("HCI socket registration failed");
817 proto_unregister(&hci_sk_proto);
818 return err;
819}
820
b7440a14 821void hci_sock_cleanup(void)
1da177e4
LT		 822{
823 if (bt_sock_unregister(BTPROTO_HCI) < 0)
824 BT_ERR("HCI socket unregistration failed");
825
826 hci_unregister_notifier(&hci_sock_nblock);
827
828 proto_unregister(&hci_sk_proto);
1da177e4 829}
0381101f
JH		 830
831module_param(enable_mgmt, bool, 0644);
832MODULE_PARM_DESC(enable_mgmt, "Enable Management interface");
kernel source for telekom puls (alcatel/mediatek)