projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Bluetooth: Open management interface for untrusted users
[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.
811 */
812 if (haddr.hci_channel == HCI_CHANNEL_CONTROL) {
813 hci_sock_set_flag(sk, HCI_MGMT_INDEX_EVENTS);
814 hci_sock_set_flag(sk, HCI_MGMT_UNCONF_INDEX_EVENTS);
815 }
801c1e8d 816 break;
1da177e4
LT		 817 }
818
7cc2ade2 819
0381101f 820 hci_pi(sk)->channel = haddr.hci_channel;
1da177e4
LT		 821 sk->sk_state = BT_BOUND;
822
823done:
824 release_sock(sk);
825 return err;
826}
827
8fc9ced3
GP		 828static int hci_sock_getname(struct socket *sock, struct sockaddr *addr,
829 int *addr_len, int peer)
1da177e4
LT		 830{
831 struct sockaddr_hci *haddr = (struct sockaddr_hci *) addr;
832 struct sock *sk = sock->sk;
9d4b68b2
MH		 833 struct hci_dev *hdev;
834 int err = 0;
1da177e4
LT		 835
836 BT_DBG("sock %p sk %p", sock, sk);
837
06f43cbc
MH		 838 if (peer)
839 return -EOPNOTSUPP;
840
1da177e4
LT		 841 lock_sock(sk);
842
9d4b68b2
MH		 843 hdev = hci_pi(sk)->hdev;
844 if (!hdev) {
845 err = -EBADFD;
846 goto done;
847 }
848
1da177e4
LT		 849 *addr_len = sizeof(*haddr);
850 haddr->hci_family = AF_BLUETOOTH;
7b005bd3 851 haddr->hci_dev = hdev->id;
9d4b68b2 852 haddr->hci_channel= hci_pi(sk)->channel;
1da177e4 853
9d4b68b2 854done:
1da177e4 855 release_sock(sk);
9d4b68b2 856 return err;
1da177e4
LT		 857}
858
6039aa73
GP		 859static void hci_sock_cmsg(struct sock *sk, struct msghdr *msg,
860 struct sk_buff *skb)
1da177e4
LT		 861{
862 __u32 mask = hci_pi(sk)->cmsg_mask;
863
0d48d939
MH		 864 if (mask & HCI_CMSG_DIR) {
865 int incoming = bt_cb(skb)->incoming;
8fc9ced3
GP		 866 put_cmsg(msg, SOL_HCI, HCI_CMSG_DIR, sizeof(incoming),
867 &incoming);
0d48d939 868 }
1da177e4 869
a61bbcf2 870 if (mask & HCI_CMSG_TSTAMP) {
f6e623a6
JFS		 871#ifdef CONFIG_COMPAT
872 struct compat_timeval ctv;
873#endif
a61bbcf2 874 struct timeval tv;
767c5eb5
MH		 875 void *data;
876 int len;
a61bbcf2
PM		 877
878 skb_get_timestamp(skb, &tv);
767c5eb5 879
1da97f83
DM		 880 data = &tv;
881 len = sizeof(tv);
882#ifdef CONFIG_COMPAT
da88cea1
L		 883 if (!COMPAT_USE_64BIT_TIME &&
884 (msg->msg_flags & MSG_CMSG_COMPAT)) {
767c5eb5
MH		 885 ctv.tv_sec = tv.tv_sec;
886 ctv.tv_usec = tv.tv_usec;
887 data = &ctv;
888 len = sizeof(ctv);
767c5eb5 889 }
1da97f83 890#endif
767c5eb5
MH		 891
892 put_cmsg(msg, SOL_HCI, HCI_CMSG_TSTAMP, len, data);
a61bbcf2 893 }
1da177e4 894}
8e87d142 895
1b784140
YX		 896static int hci_sock_recvmsg(struct socket *sock, struct msghdr *msg, size_t len,
897 int flags)
1da177e4
LT		 898{
899 int noblock = flags & MSG_DONTWAIT;
900 struct sock *sk = sock->sk;
901 struct sk_buff *skb;
902 int copied, err;
903
904 BT_DBG("sock %p, sk %p", sock, sk);
905
906 if (flags & (MSG_OOB))
907 return -EOPNOTSUPP;
908
909 if (sk->sk_state == BT_CLOSED)
910 return 0;
911
70f23020
AE		 912 skb = skb_recv_datagram(sk, flags, noblock, &err);
913 if (!skb)
1da177e4
LT		 914 return err;
915
1da177e4
LT		 916 copied = skb->len;
917 if (len < copied) {
918 msg->msg_flags |= MSG_TRUNC;
919 copied = len;
920 }
921
badff6d0 922 skb_reset_transport_header(skb);
51f3d02b 923 err = skb_copy_datagram_msg(skb, 0, msg, copied);
1da177e4 924
3a208627
MH		 925 switch (hci_pi(sk)->channel) {
926 case HCI_CHANNEL_RAW:
927 hci_sock_cmsg(sk, msg, skb);
928 break;
23500189 929 case HCI_CHANNEL_USER:
cd82e61c
MH		 930 case HCI_CHANNEL_MONITOR:
931 sock_recv_timestamp(msg, sk, skb);
932 break;
801c1e8d
JH		 933 default:
934 if (hci_mgmt_chan_find(hci_pi(sk)->channel))
935 sock_recv_timestamp(msg, sk, skb);
936 break;
3a208627 937 }
1da177e4
LT		 938
939 skb_free_datagram(sk, skb);
940
941 return err ? : copied;
942}
943
1b784140
YX		 944static int hci_sock_sendmsg(struct socket *sock, struct msghdr *msg,
945 size_t len)
1da177e4
LT		 946{
947 struct sock *sk = sock->sk;
801c1e8d 948 struct hci_mgmt_chan *chan;
1da177e4
LT		 949 struct hci_dev *hdev;
950 struct sk_buff *skb;
951 int err;
952
953 BT_DBG("sock %p sk %p", sock, sk);
954
955 if (msg->msg_flags & MSG_OOB)
956 return -EOPNOTSUPP;
957
958 if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_NOSIGNAL|MSG_ERRQUEUE))
959 return -EINVAL;
960
961 if (len < 4 || len > HCI_MAX_FRAME_SIZE)
962 return -EINVAL;
963
964 lock_sock(sk);
965
0381101f
JH		 966 switch (hci_pi(sk)->channel) {
967 case HCI_CHANNEL_RAW:
23500189 968 case HCI_CHANNEL_USER:
0381101f 969 break;
cd82e61c
MH		 970 case HCI_CHANNEL_MONITOR:
971 err = -EOPNOTSUPP;
972 goto done;
0381101f 973 default:
801c1e8d
JH		 974 mutex_lock(&mgmt_chan_list_lock);
975 chan = __hci_mgmt_chan_find(hci_pi(sk)->channel);
976 if (chan)
6d785aa3 977 err = mgmt_control(chan, sk, msg, len);
801c1e8d
JH		 978 else
979 err = -EINVAL;
980
981 mutex_unlock(&mgmt_chan_list_lock);
0381101f
JH		 982 goto done;
983 }
984
70f23020
AE		 985 hdev = hci_pi(sk)->hdev;
986 if (!hdev) {
1da177e4
LT		 987 err = -EBADFD;
988 goto done;
989 }
990
7e21addc
MH		 991 if (!test_bit(HCI_UP, &hdev->flags)) {
992 err = -ENETDOWN;
993 goto done;
994 }
995
70f23020
AE		 996 skb = bt_skb_send_alloc(sk, len, msg->msg_flags & MSG_DONTWAIT, &err);
997 if (!skb)
1da177e4
LT		 998 goto done;
999
6ce8e9ce 1000 if (memcpy_from_msg(skb_put(skb, len), msg, len)) {
1da177e4
LT		 1001 err = -EFAULT;
1002 goto drop;
1003 }
1004
0d48d939 1005 bt_cb(skb)->pkt_type = *((unsigned char *) skb->data);
1da177e4 1006 skb_pull(skb, 1);
1da177e4 1007
1bc5ad16
MH		 1008 if (hci_pi(sk)->channel == HCI_CHANNEL_USER) {
1009 /* No permission check is needed for user channel
1010 * since that gets enforced when binding the socket.
1011 *
1012 * However check that the packet type is valid.
1013 */
1014 if (bt_cb(skb)->pkt_type != HCI_COMMAND_PKT &&
1015 bt_cb(skb)->pkt_type != HCI_ACLDATA_PKT &&
1016 bt_cb(skb)->pkt_type != HCI_SCODATA_PKT) {
1017 err = -EINVAL;
1018 goto drop;
1019 }
1020
1021 skb_queue_tail(&hdev->raw_q, skb);
1022 queue_work(hdev->workqueue, &hdev->tx_work);
1023 } else if (bt_cb(skb)->pkt_type == HCI_COMMAND_PKT) {
83985319 1024 u16 opcode = get_unaligned_le16(skb->data);
1da177e4
LT		 1025 u16 ogf = hci_opcode_ogf(opcode);
1026 u16 ocf = hci_opcode_ocf(opcode);
1027
1028 if (((ogf > HCI_SFLT_MAX_OGF) ||
3bb3c755
GP		 1029 !hci_test_bit(ocf & HCI_FLT_OCF_BITS,
1030 &hci_sec_filter.ocf_mask[ogf])) &&
1031 !capable(CAP_NET_RAW)) {
1da177e4
LT		 1032 err = -EPERM;
1033 goto drop;
1034 }
1035
fee746b0 1036 if (ogf == 0x3f) {
1da177e4 1037 skb_queue_tail(&hdev->raw_q, skb);
3eff45ea 1038 queue_work(hdev->workqueue, &hdev->tx_work);
1da177e4 1039 } else {
49c922bb 1040 /* Stand-alone HCI commands must be flagged as
11714b3d
JH		 1041 * single-command requests.
1042 */
6368c235 1043 bt_cb(skb)->req_start = 1;
11714b3d 1044
1da177e4 1045 skb_queue_tail(&hdev->cmd_q, skb);
c347b765 1046 queue_work(hdev->workqueue, &hdev->cmd_work);
1da177e4
LT		 1047 }
1048 } else {
1049 if (!capable(CAP_NET_RAW)) {
1050 err = -EPERM;
1051 goto drop;
1052 }
1053
1054 skb_queue_tail(&hdev->raw_q, skb);
3eff45ea 1055 queue_work(hdev->workqueue, &hdev->tx_work);
1da177e4
LT		 1056 }
1057
1058 err = len;
1059
1060done:
1061 release_sock(sk);
1062 return err;
1063
1064drop:
1065 kfree_skb(skb);
1066 goto done;
1067}
1068
8fc9ced3
GP		 1069static int hci_sock_setsockopt(struct socket *sock, int level, int optname,
1070 char __user *optval, unsigned int len)
1da177e4
LT		 1071{
1072 struct hci_ufilter uf = { .opcode = 0 };
1073 struct sock *sk = sock->sk;
1074 int err = 0, opt = 0;
1075
1076 BT_DBG("sk %p, opt %d", sk, optname);
1077
1078 lock_sock(sk);
1079
2f39cdb7 1080 if (hci_pi(sk)->channel != HCI_CHANNEL_RAW) {
c2371e80 1081 err = -EBADFD;
2f39cdb7
MH		 1082 goto done;
1083 }
1084
1da177e4
LT		 1085 switch (optname) {
1086 case HCI_DATA_DIR:
1087 if (get_user(opt, (int __user *)optval)) {
1088 err = -EFAULT;
1089 break;
1090 }
1091
1092 if (opt)
1093 hci_pi(sk)->cmsg_mask |= HCI_CMSG_DIR;
1094 else
1095 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_DIR;
1096 break;
1097
1098 case HCI_TIME_STAMP:
1099 if (get_user(opt, (int __user *)optval)) {
1100 err = -EFAULT;
1101 break;
1102 }
1103
1104 if (opt)
1105 hci_pi(sk)->cmsg_mask |= HCI_CMSG_TSTAMP;
1106 else
1107 hci_pi(sk)->cmsg_mask &= ~HCI_CMSG_TSTAMP;
1108 break;
1109
1110 case HCI_FILTER:
0878b666
MH		 1111 {
1112 struct hci_filter *f = &hci_pi(sk)->filter;
1113
1114 uf.type_mask = f->type_mask;
1115 uf.opcode = f->opcode;
1116 uf.event_mask[0] = *((u32 *) f->event_mask + 0);
1117 uf.event_mask[1] = *((u32 *) f->event_mask + 1);
1118 }
1119
1da177e4
LT		 1120 len = min_t(unsigned int, len, sizeof(uf));
1121 if (copy_from_user(&uf, optval, len)) {
1122 err = -EFAULT;
1123 break;
1124 }
1125
1126 if (!capable(CAP_NET_RAW)) {
1127 uf.type_mask &= hci_sec_filter.type_mask;
1128 uf.event_mask[0] &= *((u32 *) hci_sec_filter.event_mask + 0);
1129 uf.event_mask[1] &= *((u32 *) hci_sec_filter.event_mask + 1);
1130 }
1131
1132 {
1133 struct hci_filter *f = &hci_pi(sk)->filter;
1134
1135 f->type_mask = uf.type_mask;
1136 f->opcode = uf.opcode;
1137 *((u32 *) f->event_mask + 0) = uf.event_mask[0];
1138 *((u32 *) f->event_mask + 1) = uf.event_mask[1];
1139 }
8e87d142 1140 break;
1da177e4
LT		 1141
1142 default:
1143 err = -ENOPROTOOPT;
1144 break;
1145 }
1146
2f39cdb7 1147done:
1da177e4
LT		 1148 release_sock(sk);
1149 return err;
1150}
1151
8fc9ced3
GP		 1152static int hci_sock_getsockopt(struct socket *sock, int level, int optname,
1153 char __user *optval, int __user *optlen)
1da177e4
LT		 1154{
1155 struct hci_ufilter uf;
1156 struct sock *sk = sock->sk;
cedc5469
MH		 1157 int len, opt, err = 0;
1158
1159 BT_DBG("sk %p, opt %d", sk, optname);
1da177e4
LT		 1160
1161 if (get_user(len, optlen))
1162 return -EFAULT;
1163
cedc5469
MH		 1164 lock_sock(sk);
1165
1166 if (hci_pi(sk)->channel != HCI_CHANNEL_RAW) {
c2371e80 1167 err = -EBADFD;
cedc5469
MH		 1168 goto done;
1169 }
1170
1da177e4
LT		 1171 switch (optname) {
1172 case HCI_DATA_DIR:
1173 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_DIR)
1174 opt = 1;
8e87d142 1175 else
1da177e4
LT		 1176 opt = 0;
1177
1178 if (put_user(opt, optval))
cedc5469 1179 err = -EFAULT;
1da177e4
LT		 1180 break;
1181
1182 case HCI_TIME_STAMP:
1183 if (hci_pi(sk)->cmsg_mask & HCI_CMSG_TSTAMP)
1184 opt = 1;
8e87d142 1185 else
1da177e4
LT		 1186 opt = 0;
1187
1188 if (put_user(opt, optval))
cedc5469 1189 err = -EFAULT;
1da177e4
LT		 1190 break;
1191
1192 case HCI_FILTER:
1193 {
1194 struct hci_filter *f = &hci_pi(sk)->filter;
1195
e15ca9a0 1196 memset(&uf, 0, sizeof(uf));
1da177e4
LT		 1197 uf.type_mask = f->type_mask;
1198 uf.opcode = f->opcode;
1199 uf.event_mask[0] = *((u32 *) f->event_mask + 0);
1200 uf.event_mask[1] = *((u32 *) f->event_mask + 1);
1201 }
1202
1203 len = min_t(unsigned int, len, sizeof(uf));
1204 if (copy_to_user(optval, &uf, len))
cedc5469 1205 err = -EFAULT;
1da177e4
LT		 1206 break;
1207
1208 default:
cedc5469 1209 err = -ENOPROTOOPT;
1da177e4
LT		 1210 break;
1211 }
1212
cedc5469
MH		 1213done:
1214 release_sock(sk);
1215 return err;
1da177e4
LT		 1216}
1217
90ddc4f0 1218static const struct proto_ops hci_sock_ops = {
1da177e4
LT		 1219 .family = PF_BLUETOOTH,
1220 .owner = THIS_MODULE,
1221 .release = hci_sock_release,
1222 .bind = hci_sock_bind,
1223 .getname = hci_sock_getname,
1224 .sendmsg = hci_sock_sendmsg,
1225 .recvmsg = hci_sock_recvmsg,
1226 .ioctl = hci_sock_ioctl,
1227 .poll = datagram_poll,
1228 .listen = sock_no_listen,
1229 .shutdown = sock_no_shutdown,
1230 .setsockopt = hci_sock_setsockopt,
1231 .getsockopt = hci_sock_getsockopt,
1232 .connect = sock_no_connect,
1233 .socketpair = sock_no_socketpair,
1234 .accept = sock_no_accept,
1235 .mmap = sock_no_mmap
1236};
1237
1238static struct proto hci_sk_proto = {
1239 .name = "HCI",
1240 .owner = THIS_MODULE,
1241 .obj_size = sizeof(struct hci_pinfo)
1242};
1243
3f378b68
EP		 1244static int hci_sock_create(struct net *net, struct socket *sock, int protocol,
1245 int kern)
1da177e4
LT		 1246{
1247 struct sock *sk;
1248
1249 BT_DBG("sock %p", sock);
1250
1251 if (sock->type != SOCK_RAW)
1252 return -ESOCKTNOSUPPORT;
1253
1254 sock->ops = &hci_sock_ops;
1255
6257ff21 1256 sk = sk_alloc(net, PF_BLUETOOTH, GFP_ATOMIC, &hci_sk_proto);
1da177e4
LT		 1257 if (!sk)
1258 return -ENOMEM;
1259
1260 sock_init_data(sock, sk);
1261
1262 sock_reset_flag(sk, SOCK_ZAPPED);
1263
1264 sk->sk_protocol = protocol;
1265
1266 sock->state = SS_UNCONNECTED;
1267 sk->sk_state = BT_OPEN;
1268
1269 bt_sock_link(&hci_sk_list, sk);
1270 return 0;
1271}
1272
ec1b4cf7 1273static const struct net_proto_family hci_sock_family_ops = {
1da177e4
LT		 1274 .family = PF_BLUETOOTH,
1275 .owner = THIS_MODULE,
1276 .create = hci_sock_create,
1277};
1278
1da177e4
LT		 1279int __init hci_sock_init(void)
1280{
1281 int err;
1282
b0a8e282
MH		 1283 BUILD_BUG_ON(sizeof(struct sockaddr_hci) > sizeof(struct sockaddr));
1284
1da177e4
LT		 1285 err = proto_register(&hci_sk_proto, 0);
1286 if (err < 0)
1287 return err;
1288
1289 err = bt_sock_register(BTPROTO_HCI, &hci_sock_family_ops);
f7c86637
MY		 1290 if (err < 0) {
1291 BT_ERR("HCI socket registration failed");
1da177e4 1292 goto error;
f7c86637
MY		 1293 }
1294
b0316615 1295 err = bt_procfs_init(&init_net, "hci", &hci_sk_list, NULL);
f7c86637
MY		 1296 if (err < 0) {
1297 BT_ERR("Failed to create HCI proc file");
1298 bt_sock_unregister(BTPROTO_HCI);
1299 goto error;
1300 }
1da177e4 1301
1da177e4
LT		 1302 BT_INFO("HCI socket layer initialized");
1303
1304 return 0;
1305
1306error:
1da177e4
LT		 1307 proto_unregister(&hci_sk_proto);
1308 return err;
1309}
1310
b7440a14 1311void hci_sock_cleanup(void)
1da177e4 1312{
f7c86637 1313 bt_procfs_cleanup(&init_net, "hci");
5e9d7f86 1314 bt_sock_unregister(BTPROTO_HCI);
1da177e4 1315 proto_unregister(&hci_sk_proto);
1da177e4 1316}
Linux kernel - Deliverables
This page took 0.803855 seconds and 5 git commands to generate.