hci_socket.c revision 1.20.14.1
1 /* $NetBSD: hci_socket.c,v 1.20.14.1 2014/08/20 00:04:35 tls Exp $ */ 2 3 /*- 4 * Copyright (c) 2005 Iain Hibbert. 5 * Copyright (c) 2006 Itronix Inc. 6 * All rights reserved. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 3. The name of Itronix Inc. may not be used to endorse 17 * or promote products derived from this software without specific 18 * prior written permission. 19 * 20 * THIS SOFTWARE IS PROVIDED BY ITRONIX INC. ``AS IS'' AND 21 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL ITRONIX INC. BE LIABLE FOR ANY 24 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 25 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 26 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND 27 * ON ANY THEORY OF LIABILITY, WHETHER IN 28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 30 * POSSIBILITY OF SUCH DAMAGE. 31 */ 32 33 #include <sys/cdefs.h> 34 __KERNEL_RCSID(0, "$NetBSD: hci_socket.c,v 1.20.14.1 2014/08/20 00:04:35 tls Exp $"); 35 36 /* load symbolic names */ 37 #ifdef BLUETOOTH_DEBUG 38 #define PRUREQUESTS 39 #define PRCOREQUESTS 40 #endif 41 42 #include <sys/param.h> 43 #include <sys/domain.h> 44 #include <sys/kauth.h> 45 #include <sys/kernel.h> 46 #include <sys/kmem.h> 47 #include <sys/mbuf.h> 48 #include <sys/proc.h> 49 #include <sys/protosw.h> 50 #include <sys/socket.h> 51 #include <sys/socketvar.h> 52 #include <sys/systm.h> 53 54 #include <netbt/bluetooth.h> 55 #include <netbt/hci.h> 56 57 /******************************************************************************* 58 * 59 * HCI SOCK_RAW Sockets - for control of Bluetooth Devices 60 * 61 */ 62 63 /* 64 * the raw HCI protocol control block 65 */ 66 struct hci_pcb { 67 struct socket *hp_socket; /* socket */ 68 kauth_cred_t hp_cred; /* owner credential */ 69 unsigned int hp_flags; /* flags */ 70 bdaddr_t hp_laddr; /* local address */ 71 bdaddr_t hp_raddr; /* remote address */ 72 struct hci_filter hp_efilter; /* user event filter */ 73 struct hci_filter hp_pfilter; /* user packet filter */ 74 LIST_ENTRY(hci_pcb) hp_next; /* next HCI pcb */ 75 }; 76 77 /* hp_flags */ 78 #define HCI_DIRECTION (1<<1) /* direction control messages */ 79 #define HCI_PROMISCUOUS (1<<2) /* listen to all units */ 80 81 LIST_HEAD(hci_pcb_list, hci_pcb) hci_pcb = LIST_HEAD_INITIALIZER(hci_pcb); 82 83 /* sysctl defaults */ 84 int hci_sendspace = HCI_CMD_PKT_SIZE; 85 int hci_recvspace = 4096; 86 87 /* unprivileged commands opcode table */ 88 static const struct { 89 uint16_t opcode; 90 uint8_t offs; /* 0 - 63 */ 91 uint8_t mask; /* bit 0 - 7 */ 92 uint8_t length; /* approved length */ 93 } hci_cmds[] = { 94 { HCI_CMD_INQUIRY, 95 0, 0x01, sizeof(hci_inquiry_cp) }, 96 { HCI_CMD_REMOTE_NAME_REQ, 97 2, 0x08, sizeof(hci_remote_name_req_cp) }, 98 { HCI_CMD_READ_REMOTE_FEATURES, 99 2, 0x20, sizeof(hci_read_remote_features_cp) }, 100 { HCI_CMD_READ_REMOTE_EXTENDED_FEATURES, 101 2, 0x40, sizeof(hci_read_remote_extended_features_cp) }, 102 { HCI_CMD_READ_REMOTE_VER_INFO, 103 2, 0x80, sizeof(hci_read_remote_ver_info_cp) }, 104 { HCI_CMD_READ_CLOCK_OFFSET, 105 3, 0x01, sizeof(hci_read_clock_offset_cp) }, 106 { HCI_CMD_READ_LMP_HANDLE, 107 3, 0x02, sizeof(hci_read_lmp_handle_cp) }, 108 { HCI_CMD_ROLE_DISCOVERY, 109 4, 0x80, sizeof(hci_role_discovery_cp) }, 110 { HCI_CMD_READ_LINK_POLICY_SETTINGS, 111 5, 0x02, sizeof(hci_read_link_policy_settings_cp) }, 112 { HCI_CMD_READ_DEFAULT_LINK_POLICY_SETTINGS, 113 5, 0x08, 0 }, 114 { HCI_CMD_READ_PIN_TYPE, 115 6, 0x04, 0 }, 116 { HCI_CMD_READ_LOCAL_NAME, 117 7, 0x02, 0 }, 118 { HCI_CMD_READ_CON_ACCEPT_TIMEOUT, 119 7, 0x04, 0 }, 120 { HCI_CMD_READ_PAGE_TIMEOUT, 121 7, 0x10, 0 }, 122 { HCI_CMD_READ_SCAN_ENABLE, 123 7, 0x40, 0 }, 124 { HCI_CMD_READ_PAGE_SCAN_ACTIVITY, 125 8, 0x01, 0 }, 126 { HCI_CMD_READ_INQUIRY_SCAN_ACTIVITY, 127 8, 0x04, 0 }, 128 { HCI_CMD_READ_AUTH_ENABLE, 129 8, 0x10, 0 }, 130 { HCI_CMD_READ_ENCRYPTION_MODE, 131 8, 0x40, 0 }, 132 { HCI_CMD_READ_UNIT_CLASS, 133 9, 0x01, 0 }, 134 { HCI_CMD_READ_VOICE_SETTING, 135 9, 0x04, 0 }, 136 { HCI_CMD_READ_AUTO_FLUSH_TIMEOUT, 137 9, 0x10, sizeof(hci_read_auto_flush_timeout_cp) }, 138 { HCI_CMD_READ_NUM_BROADCAST_RETRANS, 139 9, 0x40, 0 }, 140 { HCI_CMD_READ_HOLD_MODE_ACTIVITY, 141 10, 0x01, 0 }, 142 { HCI_CMD_READ_XMIT_LEVEL, 143 10, 0x04, sizeof(hci_read_xmit_level_cp) }, 144 { HCI_CMD_READ_SCO_FLOW_CONTROL, 145 10, 0x08, 0 }, 146 { HCI_CMD_READ_LINK_SUPERVISION_TIMEOUT, 147 11, 0x01, sizeof(hci_read_link_supervision_timeout_cp) }, 148 { HCI_CMD_READ_NUM_SUPPORTED_IAC, 149 11, 0x04, 0 }, 150 { HCI_CMD_READ_IAC_LAP, 151 11, 0x08, 0 }, 152 { HCI_CMD_READ_PAGE_SCAN_PERIOD, 153 11, 0x20, 0 }, 154 { HCI_CMD_READ_PAGE_SCAN, 155 11, 0x80, 0 }, 156 { HCI_CMD_READ_INQUIRY_SCAN_TYPE, 157 12, 0x10, 0 }, 158 { HCI_CMD_READ_INQUIRY_MODE, 159 12, 0x40, 0 }, 160 { HCI_CMD_READ_PAGE_SCAN_TYPE, 161 13, 0x01, 0 }, 162 { HCI_CMD_READ_AFH_ASSESSMENT, 163 13, 0x04, 0 }, 164 { HCI_CMD_READ_LOCAL_VER, 165 14, 0x08, 0 }, 166 { HCI_CMD_READ_LOCAL_COMMANDS, 167 14, 0x10, 0 }, 168 { HCI_CMD_READ_LOCAL_FEATURES, 169 14, 0x20, 0 }, 170 { HCI_CMD_READ_LOCAL_EXTENDED_FEATURES, 171 14, 0x40, sizeof(hci_read_local_extended_features_cp) }, 172 { HCI_CMD_READ_BUFFER_SIZE, 173 14, 0x80, 0 }, 174 { HCI_CMD_READ_COUNTRY_CODE, 175 15, 0x01, 0 }, 176 { HCI_CMD_READ_BDADDR, 177 15, 0x02, 0 }, 178 { HCI_CMD_READ_FAILED_CONTACT_CNTR, 179 15, 0x04, sizeof(hci_read_failed_contact_cntr_cp) }, 180 { HCI_CMD_READ_LINK_QUALITY, 181 15, 0x10, sizeof(hci_read_link_quality_cp) }, 182 { HCI_CMD_READ_RSSI, 183 15, 0x20, sizeof(hci_read_rssi_cp) }, 184 { HCI_CMD_READ_AFH_CHANNEL_MAP, 185 15, 0x40, sizeof(hci_read_afh_channel_map_cp) }, 186 { HCI_CMD_READ_CLOCK, 187 15, 0x80, sizeof(hci_read_clock_cp) }, 188 { HCI_CMD_READ_LOOPBACK_MODE, 189 16, 0x01, 0 }, 190 { HCI_CMD_READ_EXTENDED_INQUIRY_RSP, 191 17, 0x01, 0 }, 192 { HCI_CMD_READ_SIMPLE_PAIRING_MODE, 193 17, 0x20, 0 }, 194 { HCI_CMD_READ_INQUIRY_RSP_XMIT_POWER, 195 18, 0x01, 0 }, 196 { HCI_CMD_READ_DEFAULT_ERRDATA_REPORTING, 197 18, 0x04, 0 }, 198 }; 199 200 /* 201 * supply a basic device send/recv policy 202 */ 203 static int 204 hci_device_cb(kauth_cred_t cred, kauth_action_t action, void *cookie, 205 void *arg0, void *arg1, void *arg2, void *arg3) 206 { 207 int i, result; 208 209 result = KAUTH_RESULT_DEFER; 210 211 switch (action) { 212 case KAUTH_DEVICE_BLUETOOTH_SEND: { 213 struct hci_unit *unit = (struct hci_unit *)arg0; 214 hci_cmd_hdr_t *hdr = (hci_cmd_hdr_t *)arg1; 215 216 /* 217 * Allow sending unprivileged commands if the packet size 218 * is correct and the unit claims to support it 219 */ 220 221 if (hdr->type != HCI_CMD_PKT) 222 break; 223 224 for (i = 0; i < __arraycount(hci_cmds); i++) { 225 if (hdr->opcode == hci_cmds[i].opcode 226 && hdr->length == hci_cmds[i].length 227 && (unit->hci_cmds[hci_cmds[i].offs] & hci_cmds[i].mask)) { 228 result = KAUTH_RESULT_ALLOW; 229 break; 230 } 231 } 232 233 break; 234 } 235 236 case KAUTH_DEVICE_BLUETOOTH_RECV: 237 switch((uint8_t)(uintptr_t)arg0) { 238 case HCI_CMD_PKT: { 239 uint16_t opcode = (uint16_t)(uintptr_t)arg1; 240 241 /* 242 * Allow to see any unprivileged command packet 243 */ 244 245 for (i = 0; i < __arraycount(hci_cmds); i++) { 246 if (opcode == hci_cmds[i].opcode) { 247 result = KAUTH_RESULT_ALLOW; 248 break; 249 } 250 } 251 252 break; 253 } 254 255 case HCI_EVENT_PKT: { 256 uint8_t event = (uint8_t)(uintptr_t)arg1; 257 258 /* 259 * Allow to receive most events 260 */ 261 262 switch (event) { 263 case HCI_EVENT_RETURN_LINK_KEYS: 264 case HCI_EVENT_LINK_KEY_NOTIFICATION: 265 case HCI_EVENT_USER_CONFIRM_REQ: 266 case HCI_EVENT_USER_PASSKEY_NOTIFICATION: 267 case HCI_EVENT_VENDOR: 268 break; 269 270 default: 271 result = KAUTH_RESULT_ALLOW; 272 break; 273 } 274 275 break; 276 } 277 278 case HCI_ACL_DATA_PKT: 279 case HCI_SCO_DATA_PKT: { 280 /* uint16_t handle = (uint16_t)(uintptr_t)arg1; */ 281 /* 282 * don't normally allow receiving data packets 283 */ 284 break; 285 } 286 287 default: 288 break; 289 } 290 291 break; 292 293 default: 294 break; 295 } 296 297 return result; 298 } 299 300 /* 301 * HCI protocol init routine, 302 * - set up a kauth listener to provide basic packet access policy 303 */ 304 void 305 hci_init(void) 306 { 307 308 if (kauth_listen_scope(KAUTH_SCOPE_DEVICE, hci_device_cb, NULL) == NULL) 309 panic("Bluetooth HCI: cannot listen on device scope"); 310 } 311 312 /* 313 * When command packet reaches the device, we can drop 314 * it from the socket buffer (called from hci_output_acl) 315 */ 316 void 317 hci_drop(void *arg) 318 { 319 struct socket *so = arg; 320 321 sbdroprecord(&so->so_snd); 322 sowwakeup(so); 323 } 324 325 /* 326 * HCI socket is going away and has some pending packets. We let them 327 * go by design, but remove the context pointer as it will be invalid 328 * and we no longer need to be notified. 329 */ 330 static void 331 hci_cmdwait_flush(struct socket *so) 332 { 333 struct hci_unit *unit; 334 struct socket *ctx; 335 struct mbuf *m; 336 337 DPRINTF("flushing %p\n", so); 338 339 SIMPLEQ_FOREACH(unit, &hci_unit_list, hci_next) { 340 m = MBUFQ_FIRST(&unit->hci_cmdwait); 341 while (m != NULL) { 342 ctx = M_GETCTX(m, struct socket *); 343 if (ctx == so) 344 M_SETCTX(m, NULL); 345 346 m = MBUFQ_NEXT(m); 347 } 348 } 349 } 350 351 /* 352 * HCI send packet 353 * This came from userland, so check it out. 354 */ 355 static int 356 hci_send_pcb(struct hci_pcb *pcb, struct mbuf *m, bdaddr_t *addr) 357 { 358 struct hci_unit *unit; 359 struct mbuf *m0; 360 hci_cmd_hdr_t hdr; 361 int err; 362 363 KASSERT(m != NULL); 364 KASSERT(addr != NULL); 365 366 /* wants at least a header to start with */ 367 if (m->m_pkthdr.len < sizeof(hdr)) { 368 err = EMSGSIZE; 369 goto bad; 370 } 371 m_copydata(m, 0, sizeof(hdr), &hdr); 372 hdr.opcode = le16toh(hdr.opcode); 373 374 /* only allows CMD packets to be sent */ 375 if (hdr.type != HCI_CMD_PKT) { 376 err = EINVAL; 377 goto bad; 378 } 379 380 /* validates packet length */ 381 if (m->m_pkthdr.len != sizeof(hdr) + hdr.length) { 382 err = EMSGSIZE; 383 goto bad; 384 } 385 386 /* finds destination */ 387 unit = hci_unit_lookup(addr); 388 if (unit == NULL) { 389 err = ENETDOWN; 390 goto bad; 391 } 392 393 /* security checks for unprivileged users */ 394 if (pcb->hp_cred != NULL 395 && kauth_authorize_device(pcb->hp_cred, 396 KAUTH_DEVICE_BLUETOOTH_SEND, 397 unit, &hdr, NULL, NULL) != 0) { 398 err = EPERM; 399 goto bad; 400 } 401 402 /* makess a copy for precious to keep */ 403 m0 = m_copypacket(m, M_DONTWAIT); 404 if (m0 == NULL) { 405 err = ENOMEM; 406 goto bad; 407 } 408 sbappendrecord(&pcb->hp_socket->so_snd, m0); 409 M_SETCTX(m, pcb->hp_socket); /* enable drop callback */ 410 411 DPRINTFN(2, "(%s) opcode (%03x|%04x)\n", device_xname(unit->hci_dev), 412 HCI_OGF(hdr.opcode), HCI_OCF(hdr.opcode)); 413 414 /* Sendss it */ 415 if (unit->hci_num_cmd_pkts == 0) 416 MBUFQ_ENQUEUE(&unit->hci_cmdwait, m); 417 else 418 hci_output_cmd(unit, m); 419 420 return 0; 421 422 bad: 423 DPRINTF("packet (%d bytes) not sent (error %d)\n", 424 m->m_pkthdr.len, err); 425 if (m) m_freem(m); 426 return err; 427 } 428 429 static int 430 hci_attach(struct socket *so, int proto) 431 { 432 struct hci_pcb *pcb; 433 int error; 434 435 KASSERT(so->so_pcb == NULL); 436 437 if (so->so_lock == NULL) { 438 mutex_obj_hold(bt_lock); 439 so->so_lock = bt_lock; 440 solock(so); 441 } 442 KASSERT(solocked(so)); 443 444 error = soreserve(so, hci_sendspace, hci_recvspace); 445 if (error) { 446 return error; 447 } 448 449 pcb = kmem_zalloc(sizeof(struct hci_pcb), KM_SLEEP); 450 pcb->hp_cred = kauth_cred_dup(curlwp->l_cred); 451 pcb->hp_socket = so; 452 453 /* 454 * Set default user filter. By default, socket only passes 455 * Command_Complete and Command_Status Events. 456 */ 457 hci_filter_set(HCI_EVENT_COMMAND_COMPL, &pcb->hp_efilter); 458 hci_filter_set(HCI_EVENT_COMMAND_STATUS, &pcb->hp_efilter); 459 hci_filter_set(HCI_EVENT_PKT, &pcb->hp_pfilter); 460 461 LIST_INSERT_HEAD(&hci_pcb, pcb, hp_next); 462 so->so_pcb = pcb; 463 464 return 0; 465 } 466 467 static void 468 hci_detach(struct socket *so) 469 { 470 struct hci_pcb *pcb; 471 472 pcb = (struct hci_pcb *)so->so_pcb; 473 KASSERT(pcb != NULL); 474 475 if (so->so_snd.sb_mb != NULL) 476 hci_cmdwait_flush(so); 477 478 if (pcb->hp_cred != NULL) 479 kauth_cred_free(pcb->hp_cred); 480 481 so->so_pcb = NULL; 482 LIST_REMOVE(pcb, hp_next); 483 kmem_free(pcb, sizeof(*pcb)); 484 } 485 486 static int 487 hci_accept(struct socket *so, struct mbuf *nam) 488 { 489 KASSERT(solocked(so)); 490 491 return EOPNOTSUPP; 492 } 493 494 static int 495 hci_bind(struct socket *so, struct mbuf *nam, struct lwp *l) 496 { 497 struct hci_pcb *pcb = so->so_pcb; 498 struct sockaddr_bt *sa; 499 500 KASSERT(solocked(so)); 501 KASSERT(pcb != NULL); 502 KASSERT(nam != NULL); 503 504 sa = mtod(nam, struct sockaddr_bt *); 505 if (sa->bt_len != sizeof(struct sockaddr_bt)) 506 return EINVAL; 507 508 if (sa->bt_family != AF_BLUETOOTH) 509 return EAFNOSUPPORT; 510 511 bdaddr_copy(&pcb->hp_laddr, &sa->bt_bdaddr); 512 513 if (bdaddr_any(&sa->bt_bdaddr)) 514 pcb->hp_flags |= HCI_PROMISCUOUS; 515 else 516 pcb->hp_flags &= ~HCI_PROMISCUOUS; 517 518 return 0; 519 } 520 521 static int 522 hci_listen(struct socket *so, struct lwp *l) 523 { 524 KASSERT(solocked(so)); 525 526 return EOPNOTSUPP; 527 } 528 529 static int 530 hci_connect(struct socket *so, struct mbuf *nam, struct lwp *l) 531 { 532 struct hci_pcb *pcb = so->so_pcb; 533 struct sockaddr_bt *sa; 534 535 KASSERT(solocked(so)); 536 KASSERT(pcb != NULL); 537 KASSERT(nam != NULL); 538 539 sa = mtod(nam, struct sockaddr_bt *); 540 if (sa->bt_len != sizeof(struct sockaddr_bt)) 541 return EINVAL; 542 543 if (sa->bt_family != AF_BLUETOOTH) 544 return EAFNOSUPPORT; 545 546 if (hci_unit_lookup(&sa->bt_bdaddr) == NULL) 547 return EADDRNOTAVAIL; 548 549 bdaddr_copy(&pcb->hp_raddr, &sa->bt_bdaddr); 550 soisconnected(so); 551 return 0; 552 } 553 554 static int 555 hci_connect2(struct socket *so, struct socket *so2) 556 { 557 KASSERT(solocked(so)); 558 559 return EOPNOTSUPP; 560 } 561 562 static int 563 hci_disconnect(struct socket *so) 564 { 565 struct hci_pcb *pcb = so->so_pcb; 566 567 KASSERT(solocked(so)); 568 KASSERT(pcb != NULL); 569 570 bdaddr_copy(&pcb->hp_raddr, BDADDR_ANY); 571 572 /* XXX we cannot call soisdisconnected() here, as it sets 573 * SS_CANTRCVMORE and SS_CANTSENDMORE. The problem being, 574 * that soisconnected() does not clear these and if you 575 * try to reconnect this socket (which is permitted) you 576 * get a broken pipe when you try to write any data. 577 */ 578 so->so_state &= ~SS_ISCONNECTED; 579 return 0; 580 } 581 582 static int 583 hci_shutdown(struct socket *so) 584 { 585 KASSERT(solocked(so)); 586 587 socantsendmore(so); 588 return 0; 589 } 590 591 static int 592 hci_abort(struct socket *so) 593 { 594 KASSERT(solocked(so)); 595 596 soisdisconnected(so); 597 hci_detach(so); 598 return 0; 599 } 600 601 static int 602 hci_ioctl(struct socket *so, u_long cmd, void *nam, struct ifnet *ifp) 603 { 604 int err; 605 mutex_enter(bt_lock); 606 err = hci_ioctl_pcb(cmd, nam); 607 mutex_exit(bt_lock); 608 return err; 609 } 610 611 static int 612 hci_stat(struct socket *so, struct stat *ub) 613 { 614 KASSERT(solocked(so)); 615 616 return 0; 617 } 618 619 static int 620 hci_peeraddr(struct socket *so, struct mbuf *nam) 621 { 622 struct hci_pcb *pcb = (struct hci_pcb *)so->so_pcb; 623 struct sockaddr_bt *sa; 624 625 KASSERT(solocked(so)); 626 KASSERT(pcb != NULL); 627 KASSERT(nam != NULL); 628 629 sa = mtod(nam, struct sockaddr_bt *); 630 memset(sa, 0, sizeof(struct sockaddr_bt)); 631 nam->m_len = 632 sa->bt_len = sizeof(struct sockaddr_bt); 633 sa->bt_family = AF_BLUETOOTH; 634 bdaddr_copy(&sa->bt_bdaddr, &pcb->hp_raddr); 635 return 0; 636 } 637 638 static int 639 hci_sockaddr(struct socket *so, struct mbuf *nam) 640 { 641 struct hci_pcb *pcb = (struct hci_pcb *)so->so_pcb; 642 struct sockaddr_bt *sa; 643 644 KASSERT(solocked(so)); 645 KASSERT(pcb != NULL); 646 KASSERT(nam != NULL); 647 648 sa = mtod(nam, struct sockaddr_bt *); 649 memset(sa, 0, sizeof(struct sockaddr_bt)); 650 nam->m_len = 651 sa->bt_len = sizeof(struct sockaddr_bt); 652 sa->bt_family = AF_BLUETOOTH; 653 bdaddr_copy(&sa->bt_bdaddr, &pcb->hp_laddr); 654 return 0; 655 } 656 657 static int 658 hci_rcvd(struct socket *so, int flags, struct lwp *l) 659 { 660 KASSERT(solocked(so)); 661 662 return EOPNOTSUPP; 663 } 664 665 static int 666 hci_recvoob(struct socket *so, struct mbuf *m, int flags) 667 { 668 KASSERT(solocked(so)); 669 670 return EOPNOTSUPP; 671 } 672 673 static int 674 hci_send(struct socket *so, struct mbuf *m, struct mbuf *nam, 675 struct mbuf *control, struct lwp *l) 676 { 677 struct hci_pcb *pcb = so->so_pcb; 678 struct sockaddr_bt * sa = NULL; 679 int err = 0; 680 681 KASSERT(solocked(so)); 682 KASSERT(pcb != NULL); 683 684 if (control) /* have no use for this */ 685 m_freem(control); 686 687 if (nam) { 688 sa = mtod(nam, struct sockaddr_bt *); 689 690 if (sa->bt_len != sizeof(struct sockaddr_bt)) { 691 err = EINVAL; 692 goto release; 693 } 694 695 if (sa->bt_family != AF_BLUETOOTH) { 696 err = EAFNOSUPPORT; 697 goto release; 698 } 699 } 700 701 return hci_send_pcb(pcb, m, (sa ? &sa->bt_bdaddr : &pcb->hp_raddr)); 702 703 release: 704 if (m) 705 m_freem(m); 706 707 return err; 708 } 709 710 static int 711 hci_sendoob(struct socket *so, struct mbuf *m, struct mbuf *control) 712 { 713 KASSERT(solocked(so)); 714 715 if (m) 716 m_freem(m); 717 if (control) 718 m_freem(control); 719 720 return EOPNOTSUPP; 721 } 722 723 static int 724 hci_purgeif(struct socket *so, struct ifnet *ifp) 725 { 726 727 return EOPNOTSUPP; 728 } 729 730 /* 731 * User Request. 732 * up is socket 733 * m is optional mbuf chain containing message 734 * nam is optional mbuf chain containing an address 735 * ctl is optional mbuf chain containing socket options 736 * l is pointer to process requesting action (if any) 737 * 738 * we are responsible for disposing of m and ctl 739 */ 740 static int 741 hci_usrreq(struct socket *up, int req, struct mbuf *m, 742 struct mbuf *nam, struct mbuf *ctl, struct lwp *l) 743 { 744 struct hci_pcb *pcb = up->so_pcb; 745 int err = 0; 746 747 DPRINTFN(2, "%s\n", prurequests[req]); 748 KASSERT(req != PRU_ATTACH); 749 KASSERT(req != PRU_DETACH); 750 KASSERT(req != PRU_ACCEPT); 751 KASSERT(req != PRU_BIND); 752 KASSERT(req != PRU_LISTEN); 753 KASSERT(req != PRU_CONNECT); 754 KASSERT(req != PRU_CONNECT2); 755 KASSERT(req != PRU_DISCONNECT); 756 KASSERT(req != PRU_SHUTDOWN); 757 KASSERT(req != PRU_ABORT); 758 KASSERT(req != PRU_CONTROL); 759 KASSERT(req != PRU_SENSE); 760 KASSERT(req != PRU_PEERADDR); 761 KASSERT(req != PRU_SOCKADDR); 762 KASSERT(req != PRU_RCVD); 763 KASSERT(req != PRU_RCVOOB); 764 KASSERT(req != PRU_SEND); 765 KASSERT(req != PRU_SENDOOB); 766 KASSERT(req != PRU_PURGEIF); 767 768 /* anything after here *requires* a pcb */ 769 if (pcb == NULL) { 770 err = EINVAL; 771 goto release; 772 } 773 774 switch(req) { 775 case PRU_FASTTIMO: 776 case PRU_SLOWTIMO: 777 case PRU_PROTORCV: 778 case PRU_PROTOSEND: 779 err = EOPNOTSUPP; 780 break; 781 782 default: 783 UNKNOWN(req); 784 err = EOPNOTSUPP; 785 break; 786 } 787 788 release: 789 if (m) 790 m_freem(m); 791 if (ctl) 792 m_freem(ctl); 793 return err; 794 } 795 796 /* 797 * get/set socket options 798 */ 799 int 800 hci_ctloutput(int req, struct socket *so, struct sockopt *sopt) 801 { 802 struct hci_pcb *pcb = (struct hci_pcb *)so->so_pcb; 803 int optval, err = 0; 804 805 DPRINTFN(2, "req %s\n", prcorequests[req]); 806 807 if (pcb == NULL) 808 return EINVAL; 809 810 if (sopt->sopt_level != BTPROTO_HCI) 811 return ENOPROTOOPT; 812 813 switch(req) { 814 case PRCO_GETOPT: 815 switch (sopt->sopt_name) { 816 case SO_HCI_EVT_FILTER: 817 err = sockopt_set(sopt, &pcb->hp_efilter, 818 sizeof(struct hci_filter)); 819 820 break; 821 822 case SO_HCI_PKT_FILTER: 823 err = sockopt_set(sopt, &pcb->hp_pfilter, 824 sizeof(struct hci_filter)); 825 826 break; 827 828 case SO_HCI_DIRECTION: 829 err = sockopt_setint(sopt, 830 (pcb->hp_flags & HCI_DIRECTION ? 1 : 0)); 831 832 break; 833 834 default: 835 err = ENOPROTOOPT; 836 break; 837 } 838 break; 839 840 case PRCO_SETOPT: 841 switch (sopt->sopt_name) { 842 case SO_HCI_EVT_FILTER: /* set event filter */ 843 err = sockopt_get(sopt, &pcb->hp_efilter, 844 sizeof(pcb->hp_efilter)); 845 846 break; 847 848 case SO_HCI_PKT_FILTER: /* set packet filter */ 849 err = sockopt_get(sopt, &pcb->hp_pfilter, 850 sizeof(pcb->hp_pfilter)); 851 852 break; 853 854 case SO_HCI_DIRECTION: /* request direction ctl messages */ 855 err = sockopt_getint(sopt, &optval); 856 if (err) 857 break; 858 859 if (optval) 860 pcb->hp_flags |= HCI_DIRECTION; 861 else 862 pcb->hp_flags &= ~HCI_DIRECTION; 863 break; 864 865 default: 866 err = ENOPROTOOPT; 867 break; 868 } 869 break; 870 871 default: 872 err = ENOPROTOOPT; 873 break; 874 } 875 876 return err; 877 } 878 879 /* 880 * HCI mbuf tap routine 881 * 882 * copy packets to any raw HCI sockets that wish (and are 883 * permitted) to see them 884 */ 885 void 886 hci_mtap(struct mbuf *m, struct hci_unit *unit) 887 { 888 struct hci_pcb *pcb; 889 struct mbuf *m0, *ctlmsg, **ctl; 890 struct sockaddr_bt sa; 891 uint8_t type; 892 uint8_t event; 893 uint16_t arg1; 894 895 KASSERT(m->m_len >= sizeof(type)); 896 897 type = *mtod(m, uint8_t *); 898 899 memset(&sa, 0, sizeof(sa)); 900 sa.bt_len = sizeof(struct sockaddr_bt); 901 sa.bt_family = AF_BLUETOOTH; 902 bdaddr_copy(&sa.bt_bdaddr, &unit->hci_bdaddr); 903 904 LIST_FOREACH(pcb, &hci_pcb, hp_next) { 905 /* 906 * filter according to source address 907 */ 908 if ((pcb->hp_flags & HCI_PROMISCUOUS) == 0 909 && bdaddr_same(&pcb->hp_laddr, &sa.bt_bdaddr) == 0) 910 continue; 911 912 /* 913 * filter according to packet type filter 914 */ 915 if (hci_filter_test(type, &pcb->hp_pfilter) == 0) 916 continue; 917 918 /* 919 * filter according to event/security filters 920 */ 921 switch(type) { 922 case HCI_EVENT_PKT: 923 KASSERT(m->m_len >= sizeof(hci_event_hdr_t)); 924 925 event = mtod(m, hci_event_hdr_t *)->event; 926 927 if (hci_filter_test(event, &pcb->hp_efilter) == 0) 928 continue; 929 930 arg1 = event; 931 break; 932 933 case HCI_CMD_PKT: 934 KASSERT(m->m_len >= sizeof(hci_cmd_hdr_t)); 935 arg1 = le16toh(mtod(m, hci_cmd_hdr_t *)->opcode); 936 break; 937 938 case HCI_ACL_DATA_PKT: 939 KASSERT(m->m_len >= sizeof(hci_acldata_hdr_t)); 940 arg1 = le16toh(mtod(m, hci_acldata_hdr_t *)->con_handle); 941 arg1 = HCI_CON_HANDLE(arg1); 942 break; 943 944 case HCI_SCO_DATA_PKT: 945 KASSERT(m->m_len >= sizeof(hci_scodata_hdr_t)); 946 arg1 = le16toh(mtod(m, hci_scodata_hdr_t *)->con_handle); 947 arg1 = HCI_CON_HANDLE(arg1); 948 break; 949 950 default: 951 arg1 = 0; 952 break; 953 } 954 955 if (pcb->hp_cred != NULL 956 && kauth_authorize_device(pcb->hp_cred, 957 KAUTH_DEVICE_BLUETOOTH_RECV, 958 KAUTH_ARG(type), KAUTH_ARG(arg1), NULL, NULL) != 0) 959 continue; 960 961 /* 962 * create control messages 963 */ 964 ctlmsg = NULL; 965 ctl = &ctlmsg; 966 if (pcb->hp_flags & HCI_DIRECTION) { 967 int dir = m->m_flags & M_LINK0 ? 1 : 0; 968 969 *ctl = sbcreatecontrol(&dir, sizeof(dir), 970 SCM_HCI_DIRECTION, BTPROTO_HCI); 971 972 if (*ctl != NULL) 973 ctl = &((*ctl)->m_next); 974 } 975 if (pcb->hp_socket->so_options & SO_TIMESTAMP) { 976 struct timeval tv; 977 978 microtime(&tv); 979 *ctl = sbcreatecontrol(&tv, sizeof(tv), 980 SCM_TIMESTAMP, SOL_SOCKET); 981 982 if (*ctl != NULL) 983 ctl = &((*ctl)->m_next); 984 } 985 986 /* 987 * copy to socket 988 */ 989 m0 = m_copypacket(m, M_DONTWAIT); 990 if (m0 && sbappendaddr(&pcb->hp_socket->so_rcv, 991 (struct sockaddr *)&sa, m0, ctlmsg)) { 992 sorwakeup(pcb->hp_socket); 993 } else { 994 m_freem(ctlmsg); 995 m_freem(m0); 996 } 997 } 998 } 999 1000 PR_WRAP_USRREQS(hci) 1001 1002 #define hci_attach hci_attach_wrapper 1003 #define hci_detach hci_detach_wrapper 1004 #define hci_accept hci_accept_wrapper 1005 #define hci_bind hci_bind_wrapper 1006 #define hci_listen hci_listen_wrapper 1007 #define hci_connect hci_connect_wrapper 1008 #define hci_connect2 hci_connect2_wrapper 1009 #define hci_disconnect hci_disconnect_wrapper 1010 #define hci_shutdown hci_shutdown_wrapper 1011 #define hci_abort hci_abort_wrapper 1012 #define hci_ioctl hci_ioctl_wrapper 1013 #define hci_stat hci_stat_wrapper 1014 #define hci_peeraddr hci_peeraddr_wrapper 1015 #define hci_sockaddr hci_sockaddr_wrapper 1016 #define hci_rcvd hci_rcvd_wrapper 1017 #define hci_recvoob hci_recvoob_wrapper 1018 #define hci_send hci_send_wrapper 1019 #define hci_sendoob hci_sendoob_wrapper 1020 #define hci_purgeif hci_purgeif_wrapper 1021 #define hci_usrreq hci_usrreq_wrapper 1022 1023 const struct pr_usrreqs hci_usrreqs = { 1024 .pr_attach = hci_attach, 1025 .pr_detach = hci_detach, 1026 .pr_accept = hci_accept, 1027 .pr_bind = hci_bind, 1028 .pr_listen = hci_listen, 1029 .pr_connect = hci_connect, 1030 .pr_connect2 = hci_connect2, 1031 .pr_disconnect = hci_disconnect, 1032 .pr_shutdown = hci_shutdown, 1033 .pr_abort = hci_abort, 1034 .pr_ioctl = hci_ioctl, 1035 .pr_stat = hci_stat, 1036 .pr_peeraddr = hci_peeraddr, 1037 .pr_sockaddr = hci_sockaddr, 1038 .pr_rcvd = hci_rcvd, 1039 .pr_recvoob = hci_recvoob, 1040 .pr_send = hci_send, 1041 .pr_sendoob = hci_sendoob, 1042 .pr_purgeif = hci_purgeif, 1043 .pr_generic = hci_usrreq, 1044 }; 1045
Indexes created Wed Oct 01 19:09:53 GMT 2025