projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Bluetooth: Set HCI_QUIRK_SIMULTANEOUS_DISCOVERY for BTUSB_CSR
[deliverable/linux.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
8c520a59 27#include <linux/export.h>
1da177e4
LT		 28#include <asm/unaligned.h>
29
30#include <net/bluetooth/bluetooth.h>
31#include <net/bluetooth/hci_core.h>
cd82e61c 32#include <net/bluetooth/hci_mon.h>
1da177e4 33
801c1e8d
JH		 34static LIST_HEAD(mgmt_chan_list);
35static DEFINE_MUTEX(mgmt_chan_list_lock);
36
cd82e61c
MH		 37static atomic_t monitor_promisc = ATOMIC_INIT(0);
38
1da177e4
LT		 39/* ----- HCI socket interface ----- */
40
863def58
MH		 41/* Socket info */
42#define hci_pi(sk) ((struct hci_pinfo *) sk)
43
44struct hci_pinfo {
45 struct bt_sock bt;
46 struct hci_dev *hdev;
47 struct hci_filter filter;
48 __u32 cmsg_mask;
49 unsigned short channel;
6befc644 50 unsigned long flags;
863def58
MH		 51};
52
6befc644
MH		 53void hci_sock_set_flag(struct sock *sk, int nr)
54{
55 set_bit(nr, &hci_pi(sk)->flags);
56}
57
58void hci_sock_clear_flag(struct sock *sk, int nr)
59{
60 clear_bit(nr, &hci_pi(sk)->flags);
61}
62
c85be545
MH		 63int hci_sock_test_flag(struct sock *sk, int nr)
64{
65 return test_bit(nr, &hci_pi(sk)->flags);
66}
67
9391976a 68static inline int hci_test_bit(int nr, const void *addr)
1da177e4 69{
9391976a 70 return *((const __u32 *) addr + (nr >> 5)) & ((__u32) 1 << (nr & 31));
1da177e4
LT		 71}
72
73/* Security filter */
3ad254f7
MH		 74#define HCI_SFLT_MAX_OGF 5
75
76struct hci_sec_filter {
77 __u32 type_mask;
78 __u32 event_mask[2];
79 __u32 ocf_mask[HCI_SFLT_MAX_OGF + 1][4];
80};
81
7e67c112 82static const struct hci_sec_filter hci_sec_filter = {
1da177e4
LT		 83 /* Packet types */
84 0x10,
85 /* Events */
dd7f5527 86 { 0x1000d9fe, 0x0000b00c },
1da177e4
LT		 87 /* Commands */
88 {
89 { 0x0 },
90 /* OGF_LINK_CTL */
7c631a67 91 { 0xbe000006, 0x00000001, 0x00000000, 0x00 },
1da177e4 92 /* OGF_LINK_POLICY */
7c631a67 93 { 0x00005200, 0x00000000, 0x00000000, 0x00 },
1da177e4 94 /* OGF_HOST_CTL */
7c631a67 95 { 0xaab00200, 0x2b402aaa, 0x05220154, 0x00 },
1da177e4 96 /* OGF_INFO_PARAM */
7c631a67 97 { 0x000002be, 0x00000000, 0x00000000, 0x00 },
1da177e4 98 /* OGF_STATUS_PARAM */
7c631a67 99 { 0x000000ea, 0x00000000, 0x00000000, 0x00 }
1da177e4
LT		 100 }
101};
102
103static struct bt_sock_list hci_sk_list = {
d5fb2962 104 .lock = __RW_LOCK_UNLOCKED(hci_sk_list.lock)
1da177e4
LT		 105};
106
f81fe64f
MH		 107static bool is_filtered_packet(struct sock *sk, struct sk_buff *skb)
108{
109 struct hci_filter *flt;
110 int flt_type, flt_event;
111
112 /* Apply filter */
113 flt = &hci_pi(sk)->filter;
114
115 if (bt_cb(skb)->pkt_type == HCI_VENDOR_PKT)
116 flt_type = 0;
117 else
118 flt_type = bt_cb(skb)->pkt_type & HCI_FLT_TYPE_BITS;
119
120 if (!test_bit(flt_type, &flt->type_mask))
121 return true;
122
123 /* Extra filter for event packets only */
124 if (bt_cb(skb)->pkt_type != HCI_EVENT_PKT)
125 return false;
126
127 flt_event = (*(__u8 *)skb->data & HCI_FLT_EVENT_BITS);
128
129 if (!hci_test_bit(flt_event, &flt->event_mask))
130 return true;
131
132 /* Check filter only when opcode is set */
133 if (!flt->opcode)
134 return false;
135
136 if (flt_event == HCI_EV_CMD_COMPLETE &&
137 flt->opcode != get_unaligned((__le16 *)(skb->data + 3)))
138 return true;
139
140 if (flt_event == HCI_EV_CMD_STATUS &&
141 flt->opcode != get_unaligned((__le16 *)(skb->data + 4)))
142 return true;
143
144 return false;
145}
146
1da177e4 147/* Send frame to RAW socket */
470fe1b5 148void hci_send_to_sock(struct hci_dev *hdev, struct sk_buff *skb)
1da177e4
LT		 149{
150 struct sock *sk;
e0edf373 151 struct sk_buff *skb_copy = NULL;
1da177e4
LT		 152
153 BT_DBG("hdev %p len %d", hdev, skb->len);
154
155 read_lock(&hci_sk_list.lock);
470fe1b5 156
b67bfe0d 157 sk_for_each(sk, &hci_sk_list.head) {
1da177e4
LT		 158 struct sk_buff *nskb;
159
160 if (sk->sk_state != BT_BOUND || hci_pi(sk)->hdev != hdev)
161 continue;
162
163 /* Don't send frame to the socket it came from */
164 if (skb->sk == sk)
165 continue;
166
23500189
MH		 167 if (hci_pi(sk)->channel == HCI_CHANNEL_RAW) {
168 if (is_filtered_packet(sk, skb))
169 continue;
170 } else if (hci_pi(sk)->channel == HCI_CHANNEL_USER) {
171 if (!bt_cb(skb)->incoming)
172 continue;
173 if (bt_cb(skb)->pkt_type != HCI_EVENT_PKT &&
174 bt_cb(skb)->pkt_type != HCI_ACLDATA_PKT &&
175 bt_cb(skb)->pkt_type != HCI_SCODATA_PKT)
176 continue;
177 } else {
178 /* Don't send frame to other channel types */
1da177e4 179 continue;
23500189 180 }
1da177e4 181
e0edf373
MH		 182 if (!skb_copy) {
183 /* Create a private copy with headroom */
bad93e9d 184 skb_copy = __pskb_copy_fclone(skb, 1, GFP_ATOMIC, true);
e0edf373
MH		 185 if (!skb_copy)
186 continue;
187
188 /* Put type byte before the data */
189 memcpy(skb_push(skb_copy, 1), &bt_cb(skb)->pkt_type, 1);
190 }
191
192 nskb = skb_clone(skb_copy, GFP_ATOMIC);
70f23020 193 if (!nskb)
1da177e4
LT		 194 continue;
195
470fe1b5
MH		 196 if (sock_queue_rcv_skb(sk, nskb))
197 kfree_skb(nskb);
198 }
199
200 read_unlock(&hci_sk_list.lock);
e0edf373
MH		 201
202 kfree_skb(skb_copy);
470fe1b5
MH		 203}
204
7129069e
JH		 205/* Send frame to sockets with specific channel */
206void hci_send_to_channel(unsigned short channel, struct sk_buff *skb,
c08b1a1d 207 int flag, struct sock *skip_sk)
470fe1b5
MH		 208{
209 struct sock *sk;
470fe1b5 210
7129069e 211 BT_DBG("channel %u len %d", channel, skb->len);
470fe1b5
MH		 212
213 read_lock(&hci_sk_list.lock);
214
b67bfe0d 215 sk_for_each(sk, &hci_sk_list.head) {
470fe1b5
MH		 216 struct sk_buff *nskb;
217
c08b1a1d 218 /* Ignore socket without the flag set */
c85be545 219 if (!hci_sock_test_flag(sk, flag))
d7f72f61
MH		 220 continue;
221
c08b1a1d
MH		 222 /* Skip the original socket */
223 if (sk == skip_sk)
17711c62
MH		 224 continue;
225
226 if (sk->sk_state != BT_BOUND)
227 continue;
228
229 if (hci_pi(sk)->channel != channel)
230 continue;
231
232 nskb = skb_clone(skb, GFP_ATOMIC);
233 if (!nskb)
234 continue;
235
236 if (sock_queue_rcv_skb(sk, nskb))
237 kfree_skb(nskb);
238 }
239
240 read_unlock(&hci_sk_list.lock);
241}
242
cd82e61c
MH		 243/* Send frame to monitor socket */
244void hci_send_to_monitor(struct hci_dev *hdev, struct sk_buff *skb)
245{
cd82e61c 246 struct sk_buff *skb_copy = NULL;
2b531294 247 struct hci_mon_hdr *hdr;
cd82e61c
MH		 248 __le16 opcode;
249
250 if (!atomic_read(&monitor_promisc))
251 return;
252
253 BT_DBG("hdev %p len %d", hdev, skb->len);
254
255 switch (bt_cb(skb)->pkt_type) {
256 case HCI_COMMAND_PKT:
dcf4adbf 257 opcode = cpu_to_le16(HCI_MON_COMMAND_PKT);
cd82e61c
MH		 258 break;
259 case HCI_EVENT_PKT:
dcf4adbf 260 opcode = cpu_to_le16(HCI_MON_EVENT_PKT);
cd82e61c
MH		 261 break;
262 case HCI_ACLDATA_PKT:
263 if (bt_cb(skb)->incoming)
dcf4adbf 264 opcode = cpu_to_le16(HCI_MON_ACL_RX_PKT);
cd82e61c 265 else
dcf4adbf 266 opcode = cpu_to_le16(HCI_MON_ACL_TX_PKT);
cd82e61c
MH		 267 break;
268 case HCI_SCODATA_PKT:
269 if (bt_cb(skb)->incoming)
dcf4adbf 270 opcode = cpu_to_le16(HCI_MON_SCO_RX_PKT);
cd82e61c 271 else
dcf4adbf 272 opcode = cpu_to_le16(HCI_MON_SCO_TX_PKT);
cd82e61c
MH		 273 break;
274 default:
275 return;
276 }
277
2b531294
MH		 278 /* Create a private copy with headroom */
279 skb_copy = __pskb_copy_fclone(skb, HCI_MON_HDR_SIZE, GFP_ATOMIC, true);
280 if (!skb_copy)
281 return;
282
283 /* Put header before the data */
284 hdr = (void *) skb_push(skb_copy, HCI_MON_HDR_SIZE);
285 hdr->opcode = opcode;
286 hdr->index = cpu_to_le16(hdev->id);
287 hdr->len = cpu_to_le16(skb->len);
288
c08b1a1d
MH		 289 hci_send_to_channel(HCI_CHANNEL_MONITOR, skb_copy,
290 HCI_SOCK_TRUSTED, NULL);
cd82e61c
MH		 291 kfree_skb(skb_copy);
292}
293
cd82e61c
MH		 294static struct sk_buff *create_monitor_event(struct hci_dev *hdev, int event)
295{
296 struct hci_mon_hdr *hdr;
297 struct hci_mon_new_index *ni;
298 struct sk_buff *skb;
299 __le16 opcode;
300
301 switch (event) {
302 case HCI_DEV_REG:
303 skb = bt_skb_alloc(HCI_MON_NEW_INDEX_SIZE, GFP_ATOMIC);
304 if (!skb)
305 return NULL;
306
307 ni = (void *) skb_put(skb, HCI_MON_NEW_INDEX_SIZE);
308 ni->type = hdev->dev_type;
309 ni->bus = hdev->bus;
310 bacpy(&ni->bdaddr, &hdev->bdaddr);
311 memcpy(ni->name, hdev->name, 8);
312
dcf4adbf 313 opcode = cpu_to_le16(HCI_MON_NEW_INDEX);
cd82e61c
MH		 314 break;
315
316 case HCI_DEV_UNREG:
317 skb = bt_skb_alloc(0, GFP_ATOMIC);
318 if (!skb)
319 return NULL;
320
dcf4adbf 321 opcode = cpu_to_le16(HCI_MON_DEL_INDEX);
cd82e61c
MH		 322 break;
323
324 default:
325 return NULL;
326 }
327
328 __net_timestamp(skb);
329
330 hdr = (void *) skb_push(skb, HCI_MON_HDR_SIZE);
331 hdr->opcode = opcode;
332 hdr->index = cpu_to_le16(hdev->id);
333 hdr->len = cpu_to_le16(skb->len - HCI_MON_HDR_SIZE);
334
335 return skb;
336}
337
338static void send_monitor_replay(struct sock *sk)
339{
340 struct hci_dev *hdev;
341
342 read_lock(&hci_dev_list_lock);
343
344 list_for_each_entry(hdev, &hci_dev_list, list) {
345 struct sk_buff *skb;
346
347 skb = create_monitor_event(hdev, HCI_DEV_REG);
348 if (!skb)
349 continue;
350
351 if (sock_queue_rcv_skb(sk, skb))
352 kfree_skb(skb);
353 }
354
355 read_unlock(&hci_dev_list_lock);
356}
357
040030ef
MH		 358/* Generate internal stack event */
359static void hci_si_event(struct hci_dev *hdev, int type, int dlen, void *data)
360{
361 struct hci_event_hdr *hdr;
362 struct hci_ev_stack_internal *ev;
363 struct sk_buff *skb;
364
365 skb = bt_skb_alloc(HCI_EVENT_HDR_SIZE + sizeof(*ev) + dlen, GFP_ATOMIC);
366 if (!skb)
367 return;
368
369 hdr = (void *) skb_put(skb, HCI_EVENT_HDR_SIZE);
370 hdr->evt = HCI_EV_STACK_INTERNAL;
371 hdr->plen = sizeof(*ev) + dlen;
372
373 ev = (void *) skb_put(skb, sizeof(*ev) + dlen);
374 ev->type = type;
375 memcpy(ev->data, data, dlen);
376
377 bt_cb(skb)->incoming = 1;
378 __net_timestamp(skb);
379
380 bt_cb(skb)->pkt_type = HCI_EVENT_PKT;
040030ef
MH		 381 hci_send_to_sock(hdev, skb);
382 kfree_skb(skb);
383}
384
385void hci_sock_dev_event(struct hci_dev *hdev, int event)
386{
387 struct hci_ev_si_device ev;
388
389 BT_DBG("hdev %s event %d", hdev->name, event);
390
cd82e61c
MH		 391 /* Send event to monitor */
392 if (atomic_read(&monitor_promisc)) {
393 struct sk_buff *skb;
394
395 skb = create_monitor_event(hdev, event);
396 if (skb) {
c08b1a1d
MH		 397 hci_send_to_channel(HCI_CHANNEL_MONITOR, skb,
398 HCI_SOCK_TRUSTED, NULL);
cd82e61c
MH		 399 kfree_skb(skb);
400 }
401 }
402
040030ef
MH		 403 /* Send event to sockets */
404 ev.event = event;
405 ev.dev_id = hdev->id;
406 hci_si_event(NULL, HCI_EV_SI_DEVICE, sizeof(ev), &ev);
407
408 if (event == HCI_DEV_UNREG) {
409 struct sock *sk;
040030ef
MH		 410
411 /* Detach sockets from device */
412 read_lock(&hci_sk_list.lock);
b67bfe0d 413 sk_for_each(sk, &hci_sk_list.head) {
040030ef
MH		 414 bh_lock_sock_nested(sk);
415 if (hci_pi(sk)->hdev == hdev) {
416 hci_pi(sk)->hdev = NULL;
417 sk->sk_err = EPIPE;
418 sk->sk_state = BT_OPEN;
419 sk->sk_state_change(sk);
420
421 hci_dev_put(hdev);
422 }
423 bh_unlock_sock(sk);
424 }
425 read_unlock(&hci_sk_list.lock);
426 }
427}
428
801c1e8d
JH		 429static struct hci_mgmt_chan *__hci_mgmt_chan_find(unsigned short channel)
430{
431 struct hci_mgmt_chan *c;
432
433 list_for_each_entry(c, &mgmt_chan_list, list) {
434 if (c->channel == channel)
435 return c;
436 }
437
438 return NULL;
439}
440
441static struct hci_mgmt_chan *hci_mgmt_chan_find(unsigned short channel)
442{
443 struct hci_mgmt_chan *c;
444
445 mutex_lock(&mgmt_chan_list_lock);
446 c = __hci_mgmt_chan_find(channel);
447 mutex_unlock(&mgmt_chan_list_lock);
448
449 return c;
450}
451
452int hci_mgmt_chan_register(struct hci_mgmt_chan *c)
453{
454 if (c->channel < HCI_CHANNEL_CONTROL)
455 return -EINVAL;
456
457 mutex_lock(&mgmt_chan_list_lock);
458 if (__hci_mgmt_chan_find(c->channel)) {
459 mutex_unlock(&mgmt_chan_list_lock);
460 return -EALREADY;
461 }
462
463 list_add_tail(&c->list, &mgmt_chan_list);
464
465 mutex_unlock(&mgmt_chan_list_lock);
466
467 return 0;
468}
469EXPORT_SYMBOL(hci_mgmt_chan_register);
470
471void hci_mgmt_chan_unregister(struct hci_mgmt_chan *c)
472{
473 mutex_lock(&mgmt_chan_list_lock);
474 list_del(&c->list);
475 mutex_unlock(&mgmt_chan_list_lock);
476}
477EXPORT_SYMBOL(hci_mgmt_chan_unregister);
478
1da177e4
LT		 479static int hci_sock_release(struct socket *sock)
480{
481 struct sock *sk = sock->sk;
7b005bd3 482 struct hci_dev *hdev;
1da177e4
LT		 483
484 BT_DBG("sock %p sk %p", sock, sk);
485
486 if (!sk)
487 return 0;
488
7b005bd3
MH		 489 hdev = hci_pi(sk)->hdev;
490
cd82e61c
MH		 491 if (hci_pi(sk)->channel == HCI_CHANNEL_MONITOR)
492 atomic_dec(&monitor_promisc);
493
1da177e4
LT		 494 bt_sock_unlink(&hci_sk_list, sk);
495
496 if (hdev) {
23500189 497 if (hci_pi(sk)->channel == HCI_CHANNEL_USER) {
0602a8ad 498 mgmt_index_added(hdev);
a358dc11 499 hci_dev_clear_flag(hdev, HCI_USER_CHANNEL);
23500189
MH		 500 hci_dev_close(hdev->id);
501 }
502
1da177e4
LT		 503 atomic_dec(&hdev->promisc);
504 hci_dev_put(hdev);
505 }
506
507 sock_orphan(sk);
508
509 skb_queue_purge(&sk->sk_receive_queue);
510 skb_queue_purge(&sk->sk_write_queue);
511
512 sock_put(sk);
513 return 0;
514}
515
b2a66aad 516static int hci_sock_blacklist_add(struct hci_dev *hdev, void __user *arg)
f0358568
JH		 517{
518 bdaddr_t bdaddr;
5e762444 519 int err;
f0358568
JH		 520
521 if (copy_from_user(&bdaddr, arg, sizeof(bdaddr)))
522 return -EFAULT;
523
09fd0de5 524 hci_dev_lock(hdev);
5e762444 525
dcc36c16 526 err = hci_bdaddr_list_add(&hdev->blacklist, &bdaddr, BDADDR_BREDR);
5e762444 527
09fd0de5 528 hci_dev_unlock(hdev);
5e762444
AJ		 529
530 return err;
f0358568
JH		 531}
532
b2a66aad 533static int hci_sock_blacklist_del(struct hci_dev *hdev, void __user *arg)
f0358568
JH		 534{
535 bdaddr_t bdaddr;
5e762444 536 int err;
f0358568
JH		 537
538 if (copy_from_user(&bdaddr, arg, sizeof(bdaddr)))
539 return -EFAULT;
540
09fd0de5 541 hci_dev_lock(hdev);
5e762444 542
dcc36c16 543 err = hci_bdaddr_list_del(&hdev->blacklist, &bdaddr, BDADDR_BREDR);
5e762444 544
09fd0de5 545 hci_dev_unlock(hdev);
5e762444
AJ		 546
547 return err;
f0358568
JH		 548}
549
8e87d142 550/* Ioctls that require bound socket */
6039aa73
GP		 551static int hci_sock_bound_ioctl(struct sock *sk, unsigned int cmd,
552 unsigned long arg)
1da177e4
LT		 553{
554 struct hci_dev *hdev = hci_pi(sk)->hdev;
555
556 if (!hdev)
557 return -EBADFD;
558
d7a5a11d 559 if (hci_dev_test_flag(hdev, HCI_USER_CHANNEL))
0736cfa8
MH		 560 return -EBUSY;
561
d7a5a11d 562 if (hci_dev_test_flag(hdev, HCI_UNCONFIGURED))
fee746b0
MH		 563 return -EOPNOTSUPP;
564
5b69bef5
MH		 565 if (hdev->dev_type != HCI_BREDR)
566 return -EOPNOTSUPP;
567
1da177e4
LT		 568 switch (cmd) {
569 case HCISETRAW:
570 if (!capable(CAP_NET_ADMIN))
bf5b30b8 571 return -EPERM;
db596681 572 return -EOPNOTSUPP;
1da177e4 573
1da177e4 574 case HCIGETCONNINFO:
40be492f
MH		 575 return hci_get_conn_info(hdev, (void __user *) arg);
576
577 case HCIGETAUTHINFO:
578 return hci_get_auth_info(hdev, (void __user *) arg);
1da177e4 579
f0358568
JH		 580 case HCIBLOCKADDR:
581 if (!capable(CAP_NET_ADMIN))
bf5b30b8 582 return -EPERM;
b2a66aad 583 return hci_sock_blacklist_add(hdev, (void __user *) arg);
f0358568
JH		 584
585 case HCIUNBLOCKADDR:
586 if (!capable(CAP_NET_ADMIN))
bf5b30b8 587 return -EPERM;
b2a66aad 588 return hci_sock_blacklist_del(hdev, (void __user *) arg);
1da177e4 589 }
0736cfa8 590
324d36ed 591 return -ENOIOCTLCMD;
1da177e4
LT		 592}
593
8fc9ced3
GP		 594static int hci_sock_ioctl(struct socket *sock, unsigned int cmd,
595 unsigned long arg)
1da177e4 596{
40be492f 597 void __user *argp = (void __user *) arg;
0736cfa8 598 struct sock *sk = sock->sk;
1da177e4
LT		 599 int err;
600
601 BT_DBG("cmd %x arg %lx", cmd, arg);
602
c1c4f956
MH		 603 lock_sock(sk);
604
605 if (hci_pi(sk)->channel != HCI_CHANNEL_RAW) {
606 err = -EBADFD;
607 goto done;
608 }
609
610 release_sock(sk);
611
1da177e4
LT		 612 switch (cmd) {
613 case HCIGETDEVLIST:
614 return hci_get_dev_list(argp);
615
616 case HCIGETDEVINFO:
617 return hci_get_dev_info(argp);
618
619 case HCIGETCONNLIST:
620 return hci_get_conn_list(argp);
621
622 case HCIDEVUP:
623 if (!capable(CAP_NET_ADMIN))
bf5b30b8 624 return -EPERM;
1da177e4
LT		 625 return hci_dev_open(arg);
626
627 case HCIDEVDOWN:
628 if (!capable(CAP_NET_ADMIN))
bf5b30b8 629 return -EPERM;
1da177e4
LT		 630 return hci_dev_close(arg);
631
632 case HCIDEVRESET:
633 if (!capable(CAP_NET_ADMIN))
bf5b30b8 634 return -EPERM;
1da177e4
LT		 635 return hci_dev_reset(arg);
636
637 case HCIDEVRESTAT:
638 if (!capable(CAP_NET_ADMIN))
bf5b30b8 639 return -EPERM;
1da177e4
LT		 640 return hci_dev_reset_stat(arg);
641
642 case HCISETSCAN:
643 case HCISETAUTH:
644 case HCISETENCRYPT:
645 case HCISETPTYPE:
646 case HCISETLINKPOL:
647 case HCISETLINKMODE:
648 case HCISETACLMTU:
649 case HCISETSCOMTU:
650 if (!capable(CAP_NET_ADMIN))
bf5b30b8 651 return -EPERM;
1da177e4
LT		 652 return hci_dev_cmd(cmd, argp);
653
654 case HCIINQUIRY:
655 return hci_inquiry(argp);
1da177e4 656 }
c1c4f956
MH		 657
658 lock_sock(sk);
659
660 err = hci_sock_bound_ioctl(sk, cmd, arg);
661
662done:
663 release_sock(sk);
664 return err;
1da177e4
LT		 665}
666
8fc9ced3
GP		 667static int hci_sock_bind(struct socket *sock, struct sockaddr *addr,
668 int addr_len)
1da177e4 669{
0381101f 670 struct sockaddr_hci haddr;
1da177e4
LT		 671 struct sock *sk = sock->sk;
672 struct hci_dev *hdev = NULL;
0381101f 673 int len, err = 0;
1da177e4
LT		 674
675 BT_DBG("sock %p sk %p", sock, sk);
676
0381101f
JH		 677 if (!addr)
678 return -EINVAL;
679
680 memset(&haddr, 0, sizeof(haddr));
681 len = min_t(unsigned int, sizeof(haddr), addr_len);
682 memcpy(&haddr, addr, len);
683
684 if (haddr.hci_family != AF_BLUETOOTH)
685 return -EINVAL;
686
1da177e4
LT		 687 lock_sock(sk);
688
7cc2ade2 689 if (sk->sk_state == BT_BOUND) {
1da177e4
LT		 690 err = -EALREADY;
691 goto done;
692 }
693
7cc2ade2
MH		 694 switch (haddr.hci_channel) {
695 case HCI_CHANNEL_RAW:
696 if (hci_pi(sk)->hdev) {
697 err = -EALREADY;
1da177e4
LT		 698 goto done;
699 }
700
7cc2ade2
MH		 701 if (haddr.hci_dev != HCI_DEV_NONE) {
702 hdev = hci_dev_get(haddr.hci_dev);
703 if (!hdev) {
704 err = -ENODEV;
705 goto done;
706 }
707
708 atomic_inc(&hdev->promisc);
709 }
710
711 hci_pi(sk)->hdev = hdev;
712 break;
713
23500189
MH		 714 case HCI_CHANNEL_USER:
715 if (hci_pi(sk)->hdev) {
716 err = -EALREADY;
717 goto done;
718 }
719
720 if (haddr.hci_dev == HCI_DEV_NONE) {
721 err = -EINVAL;
722 goto done;
723 }
724
10a8b86f 725 if (!capable(CAP_NET_ADMIN)) {
23500189
MH		 726 err = -EPERM;
727 goto done;
728 }
729
730 hdev = hci_dev_get(haddr.hci_dev);
731 if (!hdev) {
732 err = -ENODEV;
733 goto done;
734 }
735
736 if (test_bit(HCI_UP, &hdev->flags) ||
737 test_bit(HCI_INIT, &hdev->flags) ||
d7a5a11d
MH		 738 hci_dev_test_flag(hdev, HCI_SETUP) ||
739 hci_dev_test_flag(hdev, HCI_CONFIG)) {
23500189
MH		 740 err = -EBUSY;
741 hci_dev_put(hdev);
742 goto done;
743 }
744
238be788 745 if (hci_dev_test_and_set_flag(hdev, HCI_USER_CHANNEL)) {
23500189
MH		 746 err = -EUSERS;
747 hci_dev_put(hdev);
748 goto done;
749 }
750
0602a8ad 751 mgmt_index_removed(hdev);
23500189
MH		 752
753 err = hci_dev_open(hdev->id);
754 if (err) {
a358dc11 755 hci_dev_clear_flag(hdev, HCI_USER_CHANNEL);
0602a8ad 756 mgmt_index_added(hdev);
23500189
MH		 757 hci_dev_put(hdev);
758 goto done;
759 }
760
761 atomic_inc(&hdev->promisc);
762
763 hci_pi(sk)->hdev = hdev;
764 break;
765
cd82e61c
MH		 766 case HCI_CHANNEL_MONITOR:
767 if (haddr.hci_dev != HCI_DEV_NONE) {
768 err = -EINVAL;
769 goto done;
770 }
771
772 if (!capable(CAP_NET_RAW)) {
773 err = -EPERM;
774 goto done;
775 }
776
50ebc055
MH		 777 /* The monitor interface is restricted to CAP_NET_RAW
778 * capabilities and with that implicitly trusted.
779 */
780 hci_sock_set_flag(sk, HCI_SOCK_TRUSTED);
781
cd82e61c
MH		 782 send_monitor_replay(sk);
783
784 atomic_inc(&monitor_promisc);
785 break;
786
7cc2ade2 787 default:
801c1e8d
JH		 788 if (!hci_mgmt_chan_find(haddr.hci_channel)) {
789 err = -EINVAL;
790 goto done;
791 }
792
793 if (haddr.hci_dev != HCI_DEV_NONE) {
794 err = -EINVAL;
795 goto done;
796 }
797
1195fbb8
MH		 798 /* Users with CAP_NET_ADMIN capabilities are allowed
799 * access to all management commands and events. For
800 * untrusted users the interface is restricted and
801 * also only untrusted events are sent.
50ebc055 802 */
1195fbb8
MH		 803 if (capable(CAP_NET_ADMIN))
804 hci_sock_set_flag(sk, HCI_SOCK_TRUSTED);
50ebc055 805
f9207338
MH		 806 /* At the moment the index and unconfigured index events
807 * are enabled unconditionally. Setting them on each
808 * socket when binding keeps this functionality. They
809 * however might be cleared later and then sending of these
810 * events will be disabled, but that is then intentional.
f6b7712e
MH		 811 *
812 * This also enables generic events that are safe to be
813 * received by untrusted users. Example for such events
814 * are changes to settings, class of device, name etc.
f9207338
MH		 815 */
816 if (haddr.hci_channel == HCI_CHANNEL_CONTROL) {
817 hci_sock_set_flag(sk, HCI_MGMT_INDEX_EVENTS);
818 hci_sock_set_flag(sk, HCI_MGMT_UNCONF_INDEX_EVENTS);
f6b7712e 819 hci_sock_set_flag(sk, HCI_MGMT_GENERIC_EVENTS);
f9207338 820 }
801c1e8d 821 break;
1da177e4
LT		 822 }
823
7cc2ade2 824
0381101f 825 hci_pi(sk)->channel = haddr.hci_channel;
1da177e4
LT		 826 sk->sk_state = BT_BOUND;
827
828done:
829 release_sock(sk);
830 return err;
831}
832
8fc9ced3
GP		 833static int hci_sock_getname(struct socket *sock, struct sockaddr *addr,
834 int *addr_len, int peer)
1da177e4
LT		 835{
836 struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
837 struct sock *sk = sock->sk;
9d4b68b2
MH		 838 struct hci_dev *hdev;
839 int err = 0;
1da177e4
LT		 840
841 BT_DBG("sock %p sk %p", sock, sk);
842
06f43cbc
MH		 843 if (peer)
844 return -EOPNOTSUPP;
845
1da177e4
LT		 846 lock_sock(sk);
847
9d4b68b2
MH		 848 hdev = hci_pi(sk)->hdev;
849 if (!hdev) {
850 err = -EBADFD;
851 goto done;
852 }
853
1da177e4
LT		 854 *addr_len = sizeof(*haddr);
855 haddr->hci_family = AF_BLUETOOTH;
7b005bd3 856 haddr->hci_dev = hdev->id;
9d4b68b2 857 haddr->hci_channel= hci_pi(sk)->channel;
1da177e4 858
9d4b68b2 859done:
1da177e4 860 release_sock(sk);
9d4b68b2 861 return err;
1da177e4
LT		 862}
863
6039aa73
GP		 864static void hci_sock_cmsg(struct sock *sk, struct msghdr *msg,
865 struct sk_buff *skb)
1da177e4
LT		 866{
867 __u32 mask = hci_pi(sk)->cmsg_mask;
868
0d48d939
MH		 869 if (mask & HCI_CMSG_DIR) {
870 int incoming = bt_cb(skb)->incoming;
8fc9ced3
GP		 871 put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(incoming),
872 &incoming);
0d48d939 873 }
1da177e4 874
a61bbcf2 875 if (mask & HCI_CMSG_TSTAMP) {
f6e623a6
JFS		 876#ifdef CONFIG_COMPAT
877 struct compat_timeval ctv;
878#endif
a61bbcf2 879 struct timeval tv;
767c5eb5
MH		 880 void *data;
881 int len;
a61bbcf2
PM		 882
883 skb_get_timestamp(skb, &tv);
767c5eb5 884
1da97f83
DM		 885 data = &tv;
886 len = sizeof(tv);
887#ifdef CONFIG_COMPAT
da88cea1
L		 888 if (!COMPAT_USE_64BIT_TIME &&
889 (msg->msg_flags & MSG_CMSG_COMPAT)) {
767c5eb5
MH		 890 ctv.tv_sec = tv.tv_sec;
891 ctv.tv_usec = tv.tv_usec;
892 data = &ctv;
893 len = sizeof(ctv);
767c5eb5 894 }
1da97f83 895#endif
767c5eb5
MH		 896
897 put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, len, data);
a61bbcf2 898 }
1da177e4 899}
8e87d142 900
1b784140
YX		 901static int hci_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
902 int flags)
1da177e4
LT		 903{
904 int noblock = flags & MSG_DONTWAIT;
905 struct sock *sk = sock->sk;
906 struct sk_buff *skb;
907 int copied, err;
908
909 BT_DBG("sock %p, sk %p", sock, sk);
910
911 if (flags & (MSG_OOB))
912 return -EOPNOTSUPP;
913
914 if (sk->sk_state == BT_CLOSED)
915 return 0;
916
70f23020
AE		 917 skb = skb_recv_datagram(sk, flags, noblock, &err);
918 if (!skb)
1da177e4
LT		 919 return err;
920
1da177e4
LT		 921 copied = skb->len;
922 if (len < copied) {
923 msg->msg_flags |= MSG_TRUNC;
924 copied = len;
925 }
926
badff6d0 927 skb_reset_transport_header(skb);
51f3d02b 928 err = skb_copy_datagram_msg(skb, 0, msg, copied);
1da177e4 929
3a208627
MH		 930 switch (hci_pi(sk)->channel) {
931 case HCI_CHANNEL_RAW:
932 hci_sock_cmsg(sk, msg, skb);
933 break;
23500189 934 case HCI_CHANNEL_USER:
cd82e61c
MH		 935 case HCI_CHANNEL_MONITOR:
936 sock_recv_timestamp(msg, sk, skb);
937 break;
801c1e8d
JH		 938 default:
939 if (hci_mgmt_chan_find(hci_pi(sk)->channel))
940 sock_recv_timestamp(msg, sk, skb);
941 break;
3a208627 942 }
1da177e4
LT		 943
944 skb_free_datagram(sk, skb);
945
946 return err ? : copied;
947}
948
1b784140
YX		 949static int hci_sock_sendmsg(struct socket *sock, struct msghdr *msg,
950 size_t len)
1da177e4
LT		 951{
952 struct sock *sk = sock->sk;
801c1e8d 953 struct hci_mgmt_chan *chan;
1da177e4
LT		 954 struct hci_dev *hdev;
955 struct sk_buff *skb;
956 int err;
957
958 BT_DBG("sock %p sk %p", sock, sk);
959
960 if (msg->msg_flags & MSG_OOB)
961 return -EOPNOTSUPP;
962
963 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE))
964 return -EINVAL;
965
966 if (len < 4 || len > HCI_MAX_FRAME_SIZE)
967 return -EINVAL;
968
969 lock_sock(sk);
970
0381101f
JH		 971 switch (hci_pi(sk)->channel) {
972 case HCI_CHANNEL_RAW:
23500189 973 case HCI_CHANNEL_USER:
0381101f 974 break;
cd82e61c
MH		 975 case HCI_CHANNEL_MONITOR:
976 err = -EOPNOTSUPP;
977 goto done;
0381101f 978 default:
801c1e8d
JH		 979 mutex_lock(&mgmt_chan_list_lock);
980 chan = __hci_mgmt_chan_find(hci_pi(sk)->channel);
981 if (chan)
6d785aa3 982 err = mgmt_control(chan, sk, msg, len);
801c1e8d
JH		 983 else
984 err = -EINVAL;
985
986 mutex_unlock(&mgmt_chan_list_lock);
0381101f
JH		 987 goto done;
988 }
989
70f23020
AE		 990 hdev = hci_pi(sk)->hdev;
991 if (!hdev) {
1da177e4
LT		 992 err = -EBADFD;
993 goto done;
994 }
995
7e21addc
MH		 996 if (!test_bit(HCI_UP, &hdev->flags)) {
997 err = -ENETDOWN;
998 goto done;
999 }
1000
70f23020
AE		 1001 skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
1002 if (!skb)
1da177e4
LT		 1003 goto done;
1004
6ce8e9ce 1005 if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
1da177e4
LT		 1006 err = -EFAULT;
1007 goto drop;
1008 }
1009
0d48d939 1010 bt_cb(skb)->pkt_type = *((unsigned char *) skb->data);
1da177e4 1011 skb_pull(skb, 1);
1da177e4 1012
1bc5ad16
MH		 1013 if (hci_pi(sk)->channel == HCI_CHANNEL_USER) {
1014 /* No permission check is needed for user channel
1015 * since that gets enforced when binding the socket.
1016 *
1017 * However check that the packet type is valid.
1018 */
1019 if (bt_cb(skb)->pkt_type != HCI_COMMAND_PKT &&
1020 bt_cb(skb)->pkt_type != HCI_ACLDATA_PKT &&
1021 bt_cb(skb)->pkt_type != HCI_SCODATA_PKT) {
1022 err = -EINVAL;
1023 goto drop;
1024 }
1025
1026 skb_queue_tail(&hdev->raw_q, skb);
1027 queue_work(hdev->workqueue, &hdev->tx_work);
1028 } else if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) {
83985319 1029 u16 opcode = get_unaligned_le16(skb->data);
1da177e4
LT		 1030 u16 ogf = hci_opcode_ogf(opcode);
1031 u16 ocf = hci_opcode_ocf(opcode);
1032
1033 if (((ogf > HCI_SFLT_MAX_OGF) ||
3bb3c755
GP		 1034 !hci_test_bit(ocf & HCI_FLT_OCF_BITS,
1035 &hci_sec_filter.ocf_mask[ogf])) &&
1036 !capable(CAP_NET_RAW)) {
1da177e4
LT		 1037 err = -EPERM;
1038 goto drop;
1039 }
1040
fee746b0 1041 if (ogf == 0x3f) {
1da177e4 1042 skb_queue_tail(&hdev->raw_q, skb);
3eff45ea 1043 queue_work(hdev->workqueue, &hdev->tx_work);
1da177e4 1044 } else {
49c922bb 1045 /* Stand-alone HCI commands must be flagged as
11714b3d
JH		 1046 * single-command requests.
1047 */
6368c235 1048 bt_cb(skb)->req_start = 1;
11714b3d 1049
1da177e4 1050 skb_queue_tail(&hdev->cmd_q, skb);
c347b765 1051 queue_work(hdev->workqueue, &hdev->cmd_work);
1da177e4
LT		 1052 }
1053 } else {
1054 if (!capable(CAP_NET_RAW)) {
1055 err = -EPERM;
1056 goto drop;
1057 }
1058
1059 skb_queue_tail(&hdev->raw_q, skb);
3eff45ea 1060 queue_work(hdev->workqueue, &hdev->tx_work);
1da177e4
LT		 1061 }
1062
1063 err = len;
1064
1065done:
1066 release_sock(sk);
1067 return err;
1068
1069drop:
1070 kfree_skb(skb);
1071 goto done;
1072}
1073
8fc9ced3
GP		 1074static int hci_sock_setsockopt(struct socket *sock, int level, int optname,
1075 char __user *optval, unsigned int len)
1da177e4
LT		 1076{
1077 struct hci_ufilter uf = { .opcode = 0 };
1078 struct sock *sk = sock->sk;
1079 int err = 0, opt = 0;
1080
1081 BT_DBG("sk %p, opt %d", sk, optname);
1082
1083 lock_sock(sk);
1084
2f39cdb7 1085 if (hci_pi(sk)->channel != HCI_CHANNEL_RAW) {
c2371e80 1086 err = -EBADFD;
2f39cdb7
MH		 1087 goto done;
1088 }
1089
1da177e4
LT		 1090 switch (optname) {
1091 case HCI_DATA_DIR:
1092 if (get_user(opt, (int __user *)optval)) {
1093 err = -EFAULT;
1094 break;
1095 }
1096
1097 if (opt)
1098 hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR;
1099 else
1100 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
1101 break;
1102
1103 case HCI_TIME_STAMP:
1104 if (get_user(opt, (int __user *)optval)) {
1105 err = -EFAULT;
1106 break;
1107 }
1108
1109 if (opt)
1110 hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP;
1111 else
1112 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP;
1113 break;
1114
1115 case HCI_FILTER:
0878b666
MH		 1116 {
1117 struct hci_filter *f = &hci_pi(sk)->filter;
1118
1119 uf.type_mask = f->type_mask;
1120 uf.opcode = f->opcode;
1121 uf.event_mask[0] = *((u32 *) f->event_mask + 0);
1122 uf.event_mask[1] = *((u32 *) f->event_mask + 1);
1123 }
1124
1da177e4
LT		 1125 len = min_t(unsigned int, len, sizeof(uf));
1126 if (copy_from_user(&uf, optval, len)) {
1127 err = -EFAULT;
1128 break;
1129 }
1130
1131 if (!capable(CAP_NET_RAW)) {
1132 uf.type_mask &= hci_sec_filter.type_mask;
1133 uf.event_mask[0] &= *((u32 *) hci_sec_filter.event_mask + 0);
1134 uf.event_mask[1] &= *((u32 *) hci_sec_filter.event_mask + 1);
1135 }
1136
1137 {
1138 struct hci_filter *f = &hci_pi(sk)->filter;
1139
1140 f->type_mask = uf.type_mask;
1141 f->opcode = uf.opcode;
1142 *((u32 *) f->event_mask + 0) = uf.event_mask[0];
1143 *((u32 *) f->event_mask + 1) = uf.event_mask[1];
1144 }
8e87d142 1145 break;
1da177e4
LT		 1146
1147 default:
1148 err = -ENOPROTOOPT;
1149 break;
1150 }
1151
2f39cdb7 1152done:
1da177e4
LT		 1153 release_sock(sk);
1154 return err;
1155}
1156
8fc9ced3
GP		 1157static int hci_sock_getsockopt(struct socket *sock, int level, int optname,
1158 char __user *optval, int __user *optlen)
1da177e4
LT		 1159{
1160 struct hci_ufilter uf;
1161 struct sock *sk = sock->sk;
cedc5469
MH		 1162 int len, opt, err = 0;
1163
1164 BT_DBG("sk %p, opt %d", sk, optname);
1da177e4
LT		 1165
1166 if (get_user(len, optlen))
1167 return -EFAULT;
1168
cedc5469
MH		 1169 lock_sock(sk);
1170
1171 if (hci_pi(sk)->channel != HCI_CHANNEL_RAW) {
c2371e80 1172 err = -EBADFD;
cedc5469
MH		 1173 goto done;
1174 }
1175
1da177e4
LT		 1176 switch (optname) {
1177 case HCI_DATA_DIR:
1178 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
1179 opt = 1;
8e87d142 1180 else
1da177e4
LT		 1181 opt = 0;
1182
1183 if (put_user(opt, optval))
cedc5469 1184 err = -EFAULT;
1da177e4
LT		 1185 break;
1186
1187 case HCI_TIME_STAMP:
1188 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP)
1189 opt = 1;
8e87d142 1190 else
1da177e4
LT		 1191 opt = 0;
1192
1193 if (put_user(opt, optval))
cedc5469 1194 err = -EFAULT;
1da177e4
LT		 1195 break;
1196
1197 case HCI_FILTER:
1198 {
1199 struct hci_filter *f = &hci_pi(sk)->filter;
1200
e15ca9a0 1201 memset(&uf, 0, sizeof(uf));
1da177e4
LT		 1202 uf.type_mask = f->type_mask;
1203 uf.opcode = f->opcode;
1204 uf.event_mask[0] = *((u32 *) f->event_mask + 0);
1205 uf.event_mask[1] = *((u32 *) f->event_mask + 1);
1206 }
1207
1208 len = min_t(unsigned int, len, sizeof(uf));
1209 if (copy_to_user(optval, &uf, len))
cedc5469 1210 err = -EFAULT;
1da177e4
LT		 1211 break;
1212
1213 default:
cedc5469 1214 err = -ENOPROTOOPT;
1da177e4
LT		 1215 break;
1216 }
1217
cedc5469
MH		 1218done:
1219 release_sock(sk);
1220 return err;
1da177e4
LT		 1221}
1222
90ddc4f0 1223static const struct proto_ops hci_sock_ops = {
1da177e4
LT		 1224 .family = PF_BLUETOOTH,
1225 .owner = THIS_MODULE,
1226 .release = hci_sock_release,
1227 .bind = hci_sock_bind,
1228 .getname = hci_sock_getname,
1229 .sendmsg = hci_sock_sendmsg,
1230 .recvmsg = hci_sock_recvmsg,
1231 .ioctl = hci_sock_ioctl,
1232 .poll = datagram_poll,
1233 .listen = sock_no_listen,
1234 .shutdown = sock_no_shutdown,
1235 .setsockopt = hci_sock_setsockopt,
1236 .getsockopt = hci_sock_getsockopt,
1237 .connect = sock_no_connect,
1238 .socketpair = sock_no_socketpair,
1239 .accept = sock_no_accept,
1240 .mmap = sock_no_mmap
1241};
1242
1243static struct proto hci_sk_proto = {
1244 .name = "HCI",
1245 .owner = THIS_MODULE,
1246 .obj_size = sizeof(struct hci_pinfo)
1247};
1248
3f378b68
EP		 1249static int hci_sock_create(struct net *net, struct socket *sock, int protocol,
1250 int kern)
1da177e4
LT		 1251{
1252 struct sock *sk;
1253
1254 BT_DBG("sock %p", sock);
1255
1256 if (sock->type != SOCK_RAW)
1257 return -ESOCKTNOSUPPORT;
1258
1259 sock->ops = &hci_sock_ops;
1260
6257ff21 1261 sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &hci_sk_proto);
1da177e4
LT		 1262 if (!sk)
1263 return -ENOMEM;
1264
1265 sock_init_data(sock, sk);
1266
1267 sock_reset_flag(sk, SOCK_ZAPPED);
1268
1269 sk->sk_protocol = protocol;
1270
1271 sock->state = SS_UNCONNECTED;
1272 sk->sk_state = BT_OPEN;
1273
1274 bt_sock_link(&hci_sk_list, sk);
1275 return 0;
1276}
1277
ec1b4cf7 1278static const struct net_proto_family hci_sock_family_ops = {
1da177e4
LT		 1279 .family = PF_BLUETOOTH,
1280 .owner = THIS_MODULE,
1281 .create = hci_sock_create,
1282};
1283
1da177e4
LT		 1284int __init hci_sock_init(void)
1285{
1286 int err;
1287
b0a8e282
MH		 1288 BUILD_BUG_ON(sizeof(struct sockaddr_hci) > sizeof(struct sockaddr));
1289
1da177e4
LT		 1290 err = proto_register(&hci_sk_proto, 0);
1291 if (err < 0)
1292 return err;
1293
1294 err = bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops);
f7c86637
MY		 1295 if (err < 0) {
1296 BT_ERR("HCI socket registration failed");
1da177e4 1297 goto error;
f7c86637
MY		 1298 }
1299
b0316615 1300 err = bt_procfs_init(&init_net, "hci", &hci_sk_list, NULL);
f7c86637
MY		 1301 if (err < 0) {
1302 BT_ERR("Failed to create HCI proc file");
1303 bt_sock_unregister(BTPROTO_HCI);
1304 goto error;
1305 }
1da177e4 1306
1da177e4
LT		 1307 BT_INFO("HCI socket layer initialized");
1308
1309 return 0;
1310
1311error:
1da177e4
LT		 1312 proto_unregister(&hci_sk_proto);
1313 return err;
1314}
1315
b7440a14 1316void hci_sock_cleanup(void)
1da177e4 1317{
f7c86637 1318 bt_procfs_cleanup(&init_net, "hci");
5e9d7f86 1319 bt_sock_unregister(BTPROTO_HCI);
1da177e4 1320 proto_unregister(&hci_sk_proto);
1da177e4 1321}
Linux kernel - Deliverables
This page took 0.788825 seconds and 5 git commands to generate.