1 /* 2 * link_control.c 3 * 4 * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com> 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 * $Id: link_control.c,v 1.4 2003/08/18 19:19:54 max Exp $ 29 * $FreeBSD$ 30 */ 31 32 #include <bluetooth.h> 33 #include <errno.h> 34 #include <stdio.h> 35 #include <string.h> 36 #include "hccontrol.h" 37 38 static void hci_inquiry_response (int n, uint8_t **b); 39 40 /* Send Inquiry command to the unit */ 41 static int 42 hci_inquiry(int s, int argc, char **argv) 43 { 44 int n0, n1, n2, timo; 45 char b[512]; 46 ng_hci_inquiry_cp cp; 47 ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; 48 49 /* set defaults */ 50 cp.lap[2] = 0x9e; 51 cp.lap[1] = 0x8b; 52 cp.lap[0] = 0x33; 53 cp.inquiry_length = 5; 54 cp.num_responses = 8; 55 56 /* parse command parameters */ 57 switch (argc) { 58 case 3: 59 /* number of responses, range 0x00 - 0xff */ 60 if (sscanf(argv[2], "%d", &n0) != 1 || n0 < 0 || n0 > 0xff) 61 return (USAGE); 62 63 cp.num_responses = (n0 & 0xff); 64 65 case 2: 66 /* inquiry length (N * 1.28) sec, range 0x01 - 0x30 */ 67 if (sscanf(argv[1], "%d", &n0) != 1 || n0 < 0x1 || n0 > 0x30) 68 return (USAGE); 69 70 cp.inquiry_length = (n0 & 0xff); 71 72 case 1: 73 /* LAP */ 74 if (sscanf(argv[0], "%x:%x:%x", &n2, &n1, &n0) != 3) 75 return (USAGE); 76 77 cp.lap[0] = (n0 & 0xff); 78 cp.lap[1] = (n1 & 0xff); 79 cp.lap[2] = (n2 & 0xff); 80 81 case 0: 82 /* use defaults */ 83 break; 84 85 default: 86 return (USAGE); 87 } 88 89 /* send request and expect status back */ 90 n0 = sizeof(b); 91 if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, 92 NG_HCI_OCF_INQUIRY), (char const *) &cp, sizeof(cp), 93 b, &n0) == ERROR) 94 return (ERROR); 95 96 if (*b != 0x00) 97 return (FAILED); 98 99 timo = timeout; 100 timeout = cp.inquiry_length * 1.28 + 1; 101 102 wait_for_more: 103 /* wait for inquiry events */ 104 n0 = sizeof(b); 105 if (hci_recv(s, b, &n0) == ERROR) { 106 timeout = timo; 107 return (ERROR); 108 } 109 110 if (n0 < sizeof(*e)) { 111 timeout = timo; 112 errno = EIO; 113 return (ERROR); 114 } 115 116 switch (e->event) { 117 case NG_HCI_EVENT_INQUIRY_RESULT: { 118 ng_hci_inquiry_result_ep *ir = 119 (ng_hci_inquiry_result_ep *)(e + 1); 120 uint8_t *r = (uint8_t *)(ir + 1); 121 122 fprintf(stdout, "Inquiry result, num_responses=%d\n", 123 ir->num_responses); 124 125 for (n0 = 0; n0 < ir->num_responses; n0++) 126 hci_inquiry_response(n0, &r); 127 128 goto wait_for_more; 129 } 130 131 case NG_HCI_EVENT_INQUIRY_COMPL: 132 fprintf(stdout, "Inquiry complete. Status: %s [%#02x]\n", 133 hci_status2str(*(b + sizeof(*e))), *(b + sizeof(*e))); 134 break; 135 136 default: 137 goto wait_for_more; 138 } 139 140 timeout = timo; 141 142 return (OK); 143 } /* hci_inquiry */ 144 145 /* Print Inquiry_Result event */ 146 static void 147 hci_inquiry_response(int n, uint8_t **b) 148 { 149 ng_hci_inquiry_response *ir = (ng_hci_inquiry_response *)(*b); 150 151 fprintf(stdout, "Inquiry result #%d\n", n); 152 fprintf(stdout, "\tBD_ADDR: %s\n", hci_bdaddr2str(&ir->bdaddr)); 153 fprintf(stdout, "\tPage Scan Rep. Mode: %#02x\n", 154 ir->page_scan_rep_mode); 155 fprintf(stdout, "\tPage Scan Period Mode: %#02x\n", 156 ir->page_scan_period_mode); 157 fprintf(stdout, "\tPage Scan Mode: %#02x\n", 158 ir->page_scan_mode); 159 fprintf(stdout, "\tClass: %02x:%02x:%02x\n", 160 ir->uclass[2], ir->uclass[1], ir->uclass[0]); 161 fprintf(stdout, "\tClock offset: %#04x\n", 162 le16toh(ir->clock_offset)); 163 164 *b += sizeof(*ir); 165 } /* hci_inquiry_response */ 166 167 /* Send Create_Connection command to the unit */ 168 static int 169 hci_create_connection(int s, int argc, char **argv) 170 { 171 int n0; 172 char b[512]; 173 ng_hci_create_con_cp cp; 174 ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; 175 176 /* Set defaults */ 177 memset(&cp, 0, sizeof(cp)); 178 cp.pkt_type = htole16( NG_HCI_PKT_DM1 | NG_HCI_PKT_DH1 | 179 NG_HCI_PKT_DM3 | NG_HCI_PKT_DH3 | 180 NG_HCI_PKT_DM5); 181 cp.page_scan_rep_mode = NG_HCI_SCAN_REP_MODE0; 182 cp.page_scan_mode = NG_HCI_MANDATORY_PAGE_SCAN_MODE; 183 cp.clock_offset = 0; 184 cp.accept_role_switch = 1; 185 186 /* parse command parameters */ 187 switch (argc) { 188 case 6: 189 /* accept role switch */ 190 if (sscanf(argv[5], "%d", &n0) != 1) 191 return (USAGE); 192 193 cp.accept_role_switch = n0 ? 1 : 0; 194 195 case 5: 196 /* clock offset */ 197 if (sscanf(argv[4], "%d", &n0) != 1) 198 return (USAGE); 199 200 cp.clock_offset = (n0 & 0xffff); 201 cp.clock_offset = htole16(cp.clock_offset); 202 203 case 4: 204 /* page scan mode */ 205 if (sscanf(argv[3], "%d", &n0) != 1 || n0 < 0 || n0 > 3) 206 return (USAGE); 207 208 cp.page_scan_mode = (n0 & 0xff); 209 210 case 3: 211 /* page scan rep mode */ 212 if (sscanf(argv[2], "%d", &n0) != 1 || n0 < 0 || n0 > 2) 213 return (USAGE); 214 215 cp.page_scan_rep_mode = (n0 & 0xff); 216 217 case 2: 218 /* packet type */ 219 if (sscanf(argv[1], "%x", &n0) != 1) 220 return (USAGE); 221 222 n0 &= ( NG_HCI_PKT_DM1 | NG_HCI_PKT_DH1 | 223 NG_HCI_PKT_DM3 | NG_HCI_PKT_DH3 | 224 NG_HCI_PKT_DM5); 225 if (n0 == 0) 226 return (USAGE); 227 228 cp.pkt_type = (n0 & 0xffff); 229 cp.pkt_type = htole16(cp.pkt_type); 230 231 case 1: 232 /* BD_ADDR */ 233 if (!bt_aton(argv[0], &cp.bdaddr)) { 234 struct hostent *he = NULL; 235 236 if ((he = bt_gethostbyname(argv[0])) == NULL) 237 return (USAGE); 238 239 memcpy(&cp.bdaddr, he->h_addr, sizeof(cp.bdaddr)); 240 } 241 break; 242 243 default: 244 return (USAGE); 245 } 246 247 /* send request and expect status response */ 248 n0 = sizeof(b); 249 if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, 250 NG_HCI_OCF_CREATE_CON), 251 (char const *) &cp, sizeof(cp), b, &n0) == ERROR) 252 return (ERROR); 253 254 if (*b != 0x00) 255 return (FAILED); 256 257 /* wait for event */ 258 again: 259 n0 = sizeof(b); 260 if (hci_recv(s, b, &n0) == ERROR) 261 return (ERROR); 262 if (n0 < sizeof(*e)) { 263 errno = EIO; 264 return (ERROR); 265 } 266 267 if (e->event == NG_HCI_EVENT_CON_COMPL) { 268 ng_hci_con_compl_ep *ep = (ng_hci_con_compl_ep *)(e + 1); 269 270 if (ep->status != 0x00) { 271 fprintf(stdout, "Status: %s [%#02x]\n", 272 hci_status2str(ep->status), ep->status); 273 return (FAILED); 274 } 275 276 fprintf(stdout, "BD_ADDR: %s\n", hci_bdaddr2str(&ep->bdaddr)); 277 fprintf(stdout, "Connection handle: %d\n", 278 le16toh(ep->con_handle)); 279 fprintf(stdout, "Encryption mode: %s [%d]\n", 280 hci_encrypt2str(ep->encryption_mode, 0), 281 ep->encryption_mode); 282 } else 283 goto again; 284 285 return (OK); 286 } /* hci_create_connection */ 287 288 /* Send Disconnect command to the unit */ 289 static int 290 hci_disconnect(int s, int argc, char **argv) 291 { 292 int n; 293 char b[512]; 294 ng_hci_discon_cp cp; 295 ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; 296 297 /* Set defaults */ 298 memset(&cp, 0, sizeof(cp)); 299 cp.reason = 0x13; 300 301 /* parse command parameters */ 302 switch (argc) { 303 case 2: 304 /* reason */ 305 if (sscanf(argv[1], "%d", &n) != 1 || n <= 0x00 || n > 0xff) 306 return (USAGE); 307 308 cp.reason = (uint8_t) (n & 0xff); 309 310 case 1: 311 /* connection handle */ 312 if (sscanf(argv[0], "%d", &n) != 1 || n <= 0 || n > 0x0eff) 313 return (USAGE); 314 315 cp.con_handle = (uint16_t) (n & 0x0fff); 316 cp.con_handle = htole16(cp.con_handle); 317 break; 318 319 default: 320 return (USAGE); 321 } 322 323 /* send request and expect status response */ 324 n = sizeof(b); 325 if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, 326 NG_HCI_OCF_DISCON), 327 (char const *) &cp, sizeof(cp), b, &n) == ERROR) 328 return (ERROR); 329 330 if (*b != 0x00) 331 return (FAILED); 332 333 /* wait for event */ 334 again: 335 n = sizeof(b); 336 if (hci_recv(s, b, &n) == ERROR) 337 return (ERROR); 338 if (n < sizeof(*e)) { 339 errno = EIO; 340 return (ERROR); 341 } 342 343 if (e->event == NG_HCI_EVENT_DISCON_COMPL) { 344 ng_hci_discon_compl_ep *ep = (ng_hci_discon_compl_ep *)(e + 1); 345 346 if (ep->status != 0x00) { 347 fprintf(stdout, "Status: %s [%#02x]\n", 348 hci_status2str(ep->status), ep->status); 349 return (FAILED); 350 } 351 352 fprintf(stdout, "Connection handle: %d\n", 353 le16toh(ep->con_handle)); 354 fprintf(stdout, "Reason: %s [%#02x]\n", 355 hci_status2str(ep->reason), ep->reason); 356 } else 357 goto again; 358 359 return (OK); 360 } /* hci_diconnect */ 361 362 /* Send Add_SCO_Connection command to the unit */ 363 static int 364 hci_add_sco_connection(int s, int argc, char **argv) 365 { 366 int n; 367 char b[512]; 368 ng_hci_add_sco_con_cp cp; 369 ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; 370 371 /* Set defaults */ 372 memset(&cp, 0, sizeof(cp)); 373 cp.pkt_type = htole16(NG_HCI_PKT_HV1 | NG_HCI_PKT_HV2 | NG_HCI_PKT_HV3); 374 375 /* parse command parameters */ 376 switch (argc) { 377 case 2: 378 /* packet type */ 379 if (sscanf(argv[1], "%x", &n) != 1) 380 return (USAGE); 381 382 n &= (NG_HCI_PKT_HV1 | NG_HCI_PKT_HV2 | NG_HCI_PKT_HV3); 383 if (n == 0) 384 return (USAGE); 385 386 cp.pkt_type = (uint16_t) (n & 0x0fff); 387 cp.pkt_type = htole16(cp.pkt_type); 388 389 case 1: 390 /* acl connection handle */ 391 if (sscanf(argv[0], "%d", &n) != 1 || n <= 0 || n > 0x0eff) 392 return (USAGE); 393 394 cp.con_handle = (uint16_t) (n & 0x0fff); 395 cp.con_handle = htole16(cp.con_handle); 396 break; 397 398 default: 399 return (USAGE); 400 } 401 402 /* send request and expect status response */ 403 n = sizeof(b); 404 if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, 405 NG_HCI_OCF_ADD_SCO_CON), 406 (char const *) &cp, sizeof(cp), b, &n) == ERROR) 407 return (ERROR); 408 409 if (*b != 0x00) 410 return (FAILED); 411 412 /* wait for event */ 413 again: 414 n = sizeof(b); 415 if (hci_recv(s, b, &n) == ERROR) 416 return (ERROR); 417 if (n < sizeof(*e)) { 418 errno = EIO; 419 return (ERROR); 420 } 421 422 if (e->event == NG_HCI_EVENT_CON_COMPL) { 423 ng_hci_con_compl_ep *ep = (ng_hci_con_compl_ep *)(e + 1); 424 425 if (ep->status != 0x00) { 426 fprintf(stdout, "Status: %s [%#02x]\n", 427 hci_status2str(ep->status), ep->status); 428 return (FAILED); 429 } 430 431 fprintf(stdout, "BD_ADDR: %s\n", hci_bdaddr2str(&ep->bdaddr)); 432 fprintf(stdout, "Connection handle: %d\n", 433 le16toh(ep->con_handle)); 434 fprintf(stdout, "Encryption mode: %s [%d]\n", 435 hci_encrypt2str(ep->encryption_mode, 0), 436 ep->encryption_mode); 437 } else 438 goto again; 439 440 return (OK); 441 } /* Add_SCO_Connection */ 442 443 /* Send Change_Connection_Packet_Type command to the unit */ 444 static int 445 hci_change_connection_packet_type(int s, int argc, char **argv) 446 { 447 int n; 448 char b[512]; 449 ng_hci_change_con_pkt_type_cp cp; 450 ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; 451 452 switch (argc) { 453 case 2: 454 /* connection handle */ 455 if (sscanf(argv[0], "%d", &n) != 1 || n <= 0 || n > 0x0eff) 456 return (USAGE); 457 458 cp.con_handle = (uint16_t) (n & 0x0fff); 459 cp.con_handle = htole16(cp.con_handle); 460 461 /* packet type */ 462 if (sscanf(argv[1], "%x", &n) != 1) 463 return (USAGE); 464 465 cp.pkt_type = (uint16_t) (n & 0xffff); 466 cp.pkt_type = htole16(cp.pkt_type); 467 break; 468 469 default: 470 return (USAGE); 471 } 472 473 /* send request and expect status response */ 474 n = sizeof(b); 475 if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, 476 NG_HCI_OCF_CHANGE_CON_PKT_TYPE), 477 (char const *) &cp, sizeof(cp), b, &n) == ERROR) 478 return (ERROR); 479 480 if (*b != 0x00) 481 return (FAILED); 482 483 /* wait for event */ 484 again: 485 n = sizeof(b); 486 if (hci_recv(s, b, &n) == ERROR) 487 return (ERROR); 488 if (n < sizeof(*e)) { 489 errno = EIO; 490 return (ERROR); 491 } 492 493 if (e->event == NG_HCI_EVENT_CON_PKT_TYPE_CHANGED) { 494 ng_hci_con_pkt_type_changed_ep *ep = 495 (ng_hci_con_pkt_type_changed_ep *)(e + 1); 496 497 if (ep->status != 0x00) { 498 fprintf(stdout, "Status: %s [%#02x]\n", 499 hci_status2str(ep->status), ep->status); 500 return (FAILED); 501 } 502 503 fprintf(stdout, "Connection handle: %d\n", 504 le16toh(ep->con_handle)); 505 fprintf(stdout, "Packet type: %#04x\n", 506 le16toh(ep->pkt_type)); 507 } else 508 goto again; 509 510 return (OK); 511 } /* hci_change_connection_packet_type */ 512 513 /* Send Remote_Name_Request command to the unit */ 514 static int 515 hci_remote_name_request(int s, int argc, char **argv) 516 { 517 int n0; 518 char b[512]; 519 ng_hci_remote_name_req_cp cp; 520 ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; 521 522 memset(&cp, 0, sizeof(cp)); 523 cp.page_scan_rep_mode = NG_HCI_SCAN_REP_MODE0; 524 cp.page_scan_mode = NG_HCI_MANDATORY_PAGE_SCAN_MODE; 525 526 /* parse command parameters */ 527 switch (argc) { 528 case 4: 529 /* clock_offset */ 530 if (sscanf(argv[3], "%x", &n0) != 1) 531 return (USAGE); 532 533 cp.clock_offset = (n0 & 0xffff); 534 cp.clock_offset = htole16(cp.clock_offset); 535 536 case 3: 537 /* page_scan_mode */ 538 if (sscanf(argv[2], "%d", &n0) != 1 || n0 < 0x00 || n0 > 0x03) 539 return (USAGE); 540 541 cp.page_scan_mode = (n0 & 0xff); 542 543 case 2: 544 /* page_scan_rep_mode */ 545 if (sscanf(argv[1], "%d", &n0) != 1 || n0 < 0x00 || n0 > 0x02) 546 return (USAGE); 547 548 cp.page_scan_rep_mode = (n0 & 0xff); 549 550 case 1: 551 /* BD_ADDR */ 552 if (!bt_aton(argv[0], &cp.bdaddr)) { 553 struct hostent *he = NULL; 554 555 if ((he = bt_gethostbyname(argv[0])) == NULL) 556 return (USAGE); 557 558 memcpy(&cp.bdaddr, he->h_addr, sizeof(cp.bdaddr)); 559 } 560 break; 561 562 default: 563 return (USAGE); 564 } 565 566 /* send request and expect status response */ 567 n0 = sizeof(b); 568 if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, 569 NG_HCI_OCF_REMOTE_NAME_REQ), 570 (char const *) &cp, sizeof(cp), b, &n0) == ERROR) 571 return (ERROR); 572 573 if (*b != 0x00) 574 return (FAILED); 575 576 /* wait for event */ 577 again: 578 n0 = sizeof(b); 579 if (hci_recv(s, b, &n0) == ERROR) 580 return (ERROR); 581 if (n0 < sizeof(*e)) { 582 errno = EIO; 583 return (ERROR); 584 } 585 586 if (e->event == NG_HCI_EVENT_REMOTE_NAME_REQ_COMPL) { 587 ng_hci_remote_name_req_compl_ep *ep = 588 (ng_hci_remote_name_req_compl_ep *)(e + 1); 589 590 if (ep->status != 0x00) { 591 fprintf(stdout, "Status: %s [%#02x]\n", 592 hci_status2str(ep->status), ep->status); 593 return (FAILED); 594 } 595 596 fprintf(stdout, "BD_ADDR: %s\n", hci_bdaddr2str(&ep->bdaddr)); 597 fprintf(stdout, "Name: %s\n", ep->name); 598 } else 599 goto again; 600 601 return (OK); 602 } /* hci_remote_name_request */ 603 604 /* Send Read_Remote_Supported_Features command to the unit */ 605 static int 606 hci_read_remote_supported_features(int s, int argc, char **argv) 607 { 608 int n; 609 char b[512]; 610 ng_hci_read_remote_features_cp cp; 611 ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; 612 char buffer[1024]; 613 614 /* parse command parameters */ 615 switch (argc) { 616 case 1: 617 /* connecton handle */ 618 if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 0x0eff) 619 return (USAGE); 620 621 cp.con_handle = (n & 0x0fff); 622 cp.con_handle = htole16(cp.con_handle); 623 break; 624 625 default: 626 return (USAGE); 627 } 628 629 /* send request and expect status response */ 630 n = sizeof(b); 631 if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, 632 NG_HCI_OCF_READ_REMOTE_FEATURES), 633 (char const *) &cp, sizeof(cp), b, &n) == ERROR) 634 return (ERROR); 635 636 if (*b != 0x00) 637 return (FAILED); 638 639 /* wait for event */ 640 again: 641 n = sizeof(b); 642 if (hci_recv(s, b, &n) == ERROR) 643 return (ERROR); 644 645 if (n < sizeof(*e)) { 646 errno = EIO; 647 return (ERROR); 648 } 649 650 if (e->event == NG_HCI_EVENT_READ_REMOTE_FEATURES_COMPL) { 651 ng_hci_read_remote_features_compl_ep *ep = 652 (ng_hci_read_remote_features_compl_ep *)(e + 1); 653 654 if (ep->status != 0x00) { 655 fprintf(stdout, "Status: %s [%#02x]\n", 656 hci_status2str(ep->status), ep->status); 657 return (FAILED); 658 } 659 660 fprintf(stdout, "Connection handle: %d\n", 661 le16toh(ep->con_handle)); 662 fprintf(stdout, "Features: "); 663 for (n = 0; n < sizeof(ep->features); n++) 664 fprintf(stdout, "%#02x ", ep->features[n]); 665 fprintf(stdout, "\n%s\n", hci_features2str(ep->features, 666 buffer, sizeof(buffer))); 667 } else 668 goto again; 669 670 return (OK); 671 } /* hci_read_remote_supported_features */ 672 673 /* Send Read_Remote_Version_Information command to the unit */ 674 static int 675 hci_read_remote_version_information(int s, int argc, char **argv) 676 { 677 int n; 678 char b[512]; 679 ng_hci_read_remote_ver_info_cp cp; 680 ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; 681 682 /* parse command parameters */ 683 switch (argc) { 684 case 1: 685 /* connecton handle */ 686 if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 0x0eff) 687 return (USAGE); 688 689 cp.con_handle = (n & 0x0fff); 690 cp.con_handle = htole16(cp.con_handle); 691 break; 692 693 default: 694 return (USAGE); 695 } 696 697 /* send request and expect status response */ 698 n = sizeof(b); 699 if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, 700 NG_HCI_OCF_READ_REMOTE_VER_INFO), 701 (char const *) &cp, sizeof(cp), b, &n) == ERROR) 702 return (ERROR); 703 704 if (*b != 0x00) 705 return (FAILED); 706 707 /* wait for event */ 708 again: 709 n = sizeof(b); 710 if (hci_recv(s, b, &n) == ERROR) 711 return (ERROR); 712 713 if (n < sizeof(*e)) { 714 errno = EIO; 715 return (ERROR); 716 } 717 718 if (e->event == NG_HCI_EVENT_READ_REMOTE_VER_INFO_COMPL) { 719 ng_hci_read_remote_ver_info_compl_ep *ep = 720 (ng_hci_read_remote_ver_info_compl_ep *)(e + 1); 721 722 if (ep->status != 0x00) { 723 fprintf(stdout, "Status: %s [%#02x]\n", 724 hci_status2str(ep->status), ep->status); 725 return (FAILED); 726 } 727 728 ep->manufacturer = le16toh(ep->manufacturer); 729 730 fprintf(stdout, "Connection handle: %d\n", 731 le16toh(ep->con_handle)); 732 fprintf(stdout, "LMP version: %s [%#02x]\n", 733 hci_lmpver2str(ep->lmp_version), ep->lmp_version); 734 fprintf(stdout, "LMP sub-version: %#04x\n", 735 le16toh(ep->lmp_subversion)); 736 fprintf(stdout, "Manufacturer: %s [%#04x]\n", 737 hci_manufacturer2str(ep->manufacturer), 738 ep->manufacturer); 739 } else 740 goto again; 741 742 return (OK); 743 } /* hci_read_remote_version_information */ 744 745 /* Send Read_Clock_Offset command to the unit */ 746 static int 747 hci_read_clock_offset(int s, int argc, char **argv) 748 { 749 int n; 750 char b[512]; 751 ng_hci_read_clock_offset_cp cp; 752 ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; 753 754 /* parse command parameters */ 755 switch (argc) { 756 case 1: 757 /* connecton handle */ 758 if (sscanf(argv[0], "%d", &n) != 1 || n < 0 || n > 0x0eff) 759 return (USAGE); 760 761 cp.con_handle = (n & 0x0fff); 762 cp.con_handle = htole16(cp.con_handle); 763 break; 764 765 default: 766 return (USAGE); 767 } 768 769 /* send request and expect status response */ 770 n = sizeof(b); 771 if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LINK_CONTROL, 772 NG_HCI_OCF_READ_CLOCK_OFFSET), 773 (char const *) &cp, sizeof(cp), b, &n) == ERROR) 774 return (ERROR); 775 776 if (*b != 0x00) 777 return (FAILED); 778 779 /* wait for event */ 780 again: 781 n = sizeof(b); 782 if (hci_recv(s, b, &n) == ERROR) 783 return (ERROR); 784 785 if (n < sizeof(*e)) { 786 errno = EIO; 787 return (ERROR); 788 } 789 790 if (e->event == NG_HCI_EVENT_READ_CLOCK_OFFSET_COMPL) { 791 ng_hci_read_clock_offset_compl_ep *ep = 792 (ng_hci_read_clock_offset_compl_ep *)(e + 1); 793 794 if (ep->status != 0x00) { 795 fprintf(stdout, "Status: %s [%#02x]\n", 796 hci_status2str(ep->status), ep->status); 797 return (FAILED); 798 } 799 800 fprintf(stdout, "Connection handle: %d\n", 801 le16toh(ep->con_handle)); 802 fprintf(stdout, "Clock offset: %#04x\n", 803 le16toh(ep->clock_offset)); 804 } else 805 goto again; 806 807 return (OK); 808 } /* hci_read_clock_offset */ 809 810 struct hci_command link_control_commands[] = { 811 { 812 "inquiry <LAP> <inquiry_length> <num_reponses>", 813 "\nThis command will cause the Bluetooth unit to enter Inquiry Mode.\n" \ 814 "Inquiry Mode is used to discover other nearby Bluetooth units. The LAP\n" \ 815 "input parameter contains the LAP from which the inquiry access code shall\n" \ 816 "be derived when the inquiry procedure is made. The Inquiry_Length parameter\n"\ 817 "specifies the total duration of the Inquiry Mode and, when this time\n" \ 818 "expires, Inquiry will be halted. The Num_Responses parameter specifies the\n" \ 819 "number of responses that can be received before the Inquiry is halted.\n\n" \ 820 "\t<LAP> - xx:xx:xx; 9e:8b:33 (GIAC), 93:8b:00 (LDIAC)\n" \ 821 "\t<inquiry_length> - dd; total length == dd * 1.28 sec\n" \ 822 "\t<num_responses> - dd", 823 &hci_inquiry 824 }, 825 { 826 "create_connection <BD_ADDR> <pkt> <rep_mode> <ps_mode> <clck_off> <role_sw>", 827 "" \ 828 "\t<BD_ADDR> - xx:xx:xx:xx:xx:xx BD_ADDR or name\n\n" \ 829 "\t<pkt> - xxxx; packet type\n" \ 830 "" \ 831 "\t\tACL packets\n" \ 832 "\t\t-----------\n" \ 833 "\t\t0x0008 DM1\n" \ 834 "\t\t0x0010 DH1\n" \ 835 "\t\t0x0400 DM3\n" \ 836 "\t\t0x0800 DH3\n" \ 837 "\t\t0x4000 DM5\n" \ 838 "\t\t0x8000 DH5\n\n" \ 839 "" \ 840 "\trep_mode - d; page scan repetition mode\n" \ 841 "" \ 842 "\t\tPage scan repetition modes\n" \ 843 "\t\t--------------------------\n" \ 844 "\t\t0 Page scan repetition mode 0\n" \ 845 "\t\t1 Page scan repetition mode 1\n" \ 846 "\t\t2 Page scan repetition mode 2\n" \ 847 "\n" \ 848 "\tps_mode - d; Page scan mode\n" \ 849 "" \ 850 "\t\tPage scan modes\n" \ 851 "\t\t---------------\n" \ 852 "\t\t0 Mandatory page scan mode\n" \ 853 "\t\t1 Optional page scan mode1\n" \ 854 "\t\t2 Optional page scan mode2\n" \ 855 "\t\t3 Optional page scan mode3\n" \ 856 "\n" \ 857 "\tclck_off - dddd; clock offset. Use 0 if unknown\n\n" \ 858 "\trole_sw - d; allow (1) or deny role switch\n", 859 &hci_create_connection 860 }, 861 { 862 "disconnect <connection_handle> <reason>", 863 "\nThe Disconnection command is used to terminate an existing connection.\n" \ 864 "The connection handle command parameter indicates which connection is to\n" \ 865 "be disconnected. The Reason command parameter indicates the reason for\n" \ 866 "ending the connection.\n\n" \ 867 "\t<connection_handle> - dddd; connection handle\n" \ 868 "\t<reason> - dd; reason; usually 19 (0x13) - user ended;\n" \ 869 "\t also 0x05, 0x13-0x15, 0x1A, 0x29", 870 &hci_disconnect 871 }, 872 { 873 "add_sco_connection <acl connection handle> <packet type>", 874 "This command will cause the link manager to create a SCO connection using\n" \ 875 "the ACL connection specified by the connection handle command parameter.\n" \ 876 "The Link Manager will determine how the new connection is established. This\n"\ 877 "connection is determined by the current state of the device, its piconet,\n" \ 878 "and the state of the device to be connected. The packet type command parameter\n" \ 879 "specifies which packet types the Link Manager should use for the connection.\n"\ 880 "The Link Manager must only use the packet type(s) specified by the packet\n" \ 881 "type command parameter for sending HCI SCO data packets. Multiple packet\n" \ 882 "types may be specified for the packet type command parameter by performing\n" \ 883 "a bitwise OR operation of the different packet types. Note: An SCO connection\n" \ 884 "can only be created when an ACL connection already exists and when it is\n" \ 885 "not put in park mode.\n\n" \ 886 "\t<connection_handle> - dddd; ACL connection handle\n" \ 887 "\t<packet_type> - xxxx; packet type\n" \ 888 "" \ 889 "\t\tSCO packets\n" \ 890 "\t\t-----------\n" \ 891 "\t\t0x0020 HV1\n" \ 892 "\t\t0x0040 HV2\n" \ 893 "\t\t0x0080 HV3\n", 894 &hci_add_sco_connection 895 }, 896 { 897 "change_connection_packet_type <connection_hande> <packet_type>", 898 "The Change_Connection_Packet_Type command is used to change which packet\n" \ 899 "types can be used for a connection that is currently established. This\n" \ 900 "allows current connections to be dynamically modified to support different\n" \ 901 "types of user data. The Packet_Type command parameter specifies which\n" \ 902 "packet types the Link Manager can use for the connection. Multiple packet\n" \ 903 "types may be specified for the Packet_Type command parameter by bitwise OR\n" \ 904 "operation of the different packet types.\n\n" \ 905 "\t<connection_handle> - dddd; connection handle\n" \ 906 "\t<packet_type> - xxxx; packet type mask\n" \ 907 "" \ 908 "\t\tACL packets\n" \ 909 "\t\t-----------\n" \ 910 "\t\t0x0008 DM1\n" \ 911 "\t\t0x0010 DH1\n" \ 912 "\t\t0x0400 DM3\n" \ 913 "\t\t0x0800 DH3\n" \ 914 "\t\t0x4000 DM5\n" \ 915 "\t\t0x8000 DH5\n\n" \ 916 "" \ 917 "\t\tSCO packets\n" \ 918 "\t\t-----------\n" \ 919 "\t\t0x0020 HV1\n" \ 920 "\t\t0x0040 HV2\n" \ 921 "\t\t0x0080 HV3\n" \ 922 "", 923 &hci_change_connection_packet_type 924 }, 925 { 926 "remote_name_request <BD_ADDR> <ps_rep_mode> <ps_mode> <clock_offset>", 927 "\nThe Remote_Name_Request command is used to obtain the user-friendly\n" \ 928 "name of another Bluetooth unit.\n\n" \ 929 "\t<BD_ADDR> - xx:xx:xx:xx:xx:xx BD_ADDR or name\n" \ 930 "\t<ps_rep_mode> - dd; page scan repetition mode [0-2]\n" \ 931 "\t<ps_mode> - dd; page scan mode [0-3]\n" \ 932 "\t<clock_offset> - xxxx; clock offset [0 - 0xffff]", 933 &hci_remote_name_request 934 }, 935 { 936 "read_remote_supported_features <connection_handle>", 937 "\nThis command requests a list of the supported features for the remote\n" \ 938 "unit identified by the connection handle parameter. The connection handle\n" \ 939 "must be a connection handle for an ACL connection.\n\n" \ 940 "\t<connection_handle> - dddd; connection handle", 941 &hci_read_remote_supported_features 942 }, 943 { 944 "read_remote_version_information <connection_handle>", 945 "\nThis command will obtain the values for the version information for the\n" \ 946 "remote Bluetooth unit identified by the connection handle parameter. The\n" \ 947 "connection handle must be a connection handle for an ACL connection.\n\n" \ 948 "\t<connection_handle> - dddd; connection handle", 949 &hci_read_remote_version_information 950 }, 951 { 952 "read_clock_offset <connection_handle>", 953 "\nThis command allows the Host to read the clock offset from the remote unit.\n" \ 954 "\t<connection_handle> - dddd; connection handle", 955 &hci_read_clock_offset 956 }, 957 { 958 NULL, 959 }}; 960 961