usr.sbin/bluetooth/hccontrol/node.c

   1 /*-
   2  * node.c
   3  *
   4  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   5  *
   6  * Copyright (c) 2001-2002 Maksim Yevmenkin <m_evmenkin@yahoo.com>
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted provided that the following conditions
  11  * are met:
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  21  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  28  * SUCH DAMAGE.
  29  *
  30  * $Id: node.c,v 1.6 2003/07/22 21:14:02 max Exp $
  31  * $FreeBSD$
  32  */
  33
  34 #include <sys/ioctl.h>
  35 #define L2CAP_SOCKET_CHECKED
  36 #include <bluetooth.h>
  37 #include <errno.h>
  38 #include <netgraph/ng_message.h>
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <unistd.h>
  43 #include <uuid.h>
  44 #include "hccontrol.h"
  45
  46 /* Send Read_Node_State command to the node */
  47 static int
  48 hci_read_node_state(int s, int argc, char **argv)
  49 {
  50         struct ng_btsocket_hci_raw_node_state   r;
  51
  52         memset(&r, 0, sizeof(r));
  53         if (ioctl(s, SIOC_HCI_RAW_NODE_GET_STATE, &r, sizeof(r)) < 0)
  54                 return (ERROR);
  55
  56         fprintf(stdout, "State: %#x\n", r.state);
  57
  58         return (OK);
  59 } /* hci_read_node_state */
  60
  61 /* Send Intitialize command to the node */
  62 static int
  63 hci_node_initialize(int s, int argc, char **argv)
  64 {
  65         if (ioctl(s, SIOC_HCI_RAW_NODE_INIT) < 0)
  66                 return (ERROR);
  67
  68         return (OK);
  69 } /* hci_node_initialize */
  70
  71 /* Send Read_Debug_Level command to the node */
  72 static int
  73 hci_read_debug_level(int s, int argc, char **argv)
  74 {
  75         struct ng_btsocket_hci_raw_node_debug   r;
  76
  77         memset(&r, 0, sizeof(r));
  78         if (ioctl(s, SIOC_HCI_RAW_NODE_GET_DEBUG, &r, sizeof(r)) < 0)
  79                 return (ERROR);
  80
  81         fprintf(stdout, "Debug level: %d\n", r.debug);
  82
  83         return (OK);
  84 } /* hci_read_debug_level */
  85
  86 /* Send Write_Debug_Level command to the node */
  87 static int
  88 hci_write_debug_level(int s, int argc, char **argv)
  89 {
  90         struct ng_btsocket_hci_raw_node_debug   r;
  91
  92         memset(&r, 0, sizeof(r));
  93         switch (argc) {
  94         case 1:
  95                 r.debug = atoi(argv[0]);
  96                 break;
  97
  98         default:
  99                 return (USAGE);
 100         }
 101
 102         if (ioctl(s, SIOC_HCI_RAW_NODE_SET_DEBUG, &r, sizeof(r)) < 0)
 103                 return (ERROR);
 104
 105         return (OK);
 106 } /* hci_write_debug_level */
 107
 108 /* Send Read_Node_Buffer_Size command to the node */
 109 static int
 110 hci_read_node_buffer_size(int s, int argc, char **argv)
 111 {
 112         struct ng_btsocket_hci_raw_node_buffer  r;
 113
 114         memset(&r, 0, sizeof(r));
 115         if (ioctl(s, SIOC_HCI_RAW_NODE_GET_BUFFER, &r, sizeof(r)) < 0)
 116                 return (ERROR);
 117
 118         fprintf(stdout, "Number of free command buffers: %d\n",
 119                 r.buffer.cmd_free);
 120         fprintf(stdout, "Max. ACL packet size: %d\n",
 121                 r.buffer.acl_size);
 122         fprintf(stdout, "Numbef of free ACL buffers: %d\n",
 123                 r.buffer.acl_free);
 124         fprintf(stdout, "Total number of ACL buffers: %d\n",
 125                 r.buffer.acl_pkts);
 126         fprintf(stdout, "Max. SCO packet size: %d\n",
 127                 r.buffer.sco_size);
 128         fprintf(stdout, "Numbef of free SCO buffers: %d\n",
 129                 r.buffer.sco_free);
 130         fprintf(stdout, "Total number of SCO buffers: %d\n",
 131                 r.buffer.sco_pkts);
 132
 133         return (OK);
 134 } /* hci_read_node_buffer_size */
 135
 136 /* Send Read_Node_BD_ADDR command to the node */
 137 static int
 138 hci_read_node_bd_addr(int s, int argc, char **argv)
 139 {
 140         struct ng_btsocket_hci_raw_node_bdaddr  r;
 141
 142         memset(&r, 0, sizeof(r));
 143         if (ioctl(s, SIOC_HCI_RAW_NODE_GET_BDADDR, &r, sizeof(r)) < 0)
 144                 return (ERROR);
 145
 146         fprintf(stdout, "BD_ADDR: %s\n", bt_ntoa(&r.bdaddr, NULL));
 147
 148         return (OK);
 149 } /* hci_read_node_bd_addr */
 150
 151 /* Send Read_Node_Features command to the node */
 152 static int
 153 hci_read_node_features(int s, int argc, char **argv)
 154 {
 155         struct ng_btsocket_hci_raw_node_features        r;
 156         int                                             n;
 157         char                                            buffer[2048];
 158
 159         memset(&r, 0, sizeof(r));
 160         if (ioctl(s, SIOC_HCI_RAW_NODE_GET_FEATURES, &r, sizeof(r)) < 0)
 161                 return (ERROR);
 162
 163         fprintf(stdout, "Features: ");
 164         for (n = 0; n < sizeof(r.features)/sizeof(r.features[0]); n++)
 165                 fprintf(stdout, "%#02x ", r.features[n]);
 166         fprintf(stdout, "\n%s\n", hci_features2str(r.features,
 167                 buffer, sizeof(buffer)));
 168
 169         return (OK);
 170 } /* hci_read_node_features */
 171
 172 /* Send Read_Node_Stat command to the node */
 173 static int
 174 hci_read_node_stat(int s, int argc, char **argv)
 175 {
 176         struct ng_btsocket_hci_raw_node_stat    r;
 177
 178         memset(&r, 0, sizeof(r));
 179         if (ioctl(s, SIOC_HCI_RAW_NODE_GET_STAT, &r, sizeof(r)) < 0)
 180                 return (ERROR);
 181
 182         fprintf(stdout, "Commands sent: %d\n", r.stat.cmd_sent);
 183         fprintf(stdout, "Events received: %d\n", r.stat.evnt_recv);
 184         fprintf(stdout, "ACL packets received: %d\n", r.stat.acl_recv);
 185         fprintf(stdout, "ACL packets sent: %d\n", r.stat.acl_sent);
 186         fprintf(stdout, "SCO packets received: %d\n", r.stat.sco_recv);
 187         fprintf(stdout, "SCO packets sent: %d\n", r.stat.sco_sent);
 188         fprintf(stdout, "Bytes received: %d\n", r.stat.bytes_recv);
 189         fprintf(stdout, "Bytes sent: %d\n", r.stat.bytes_sent);
 190
 191         return (OK);
 192 } /* hci_read_node_stat */
 193
 194 /* Send Reset_Node_Stat command to the node */
 195 static int
 196 hci_reset_node_stat(int s, int argc, char **argv)
 197 {
 198         if (ioctl(s, SIOC_HCI_RAW_NODE_RESET_STAT) < 0)
 199                 return (ERROR);
 200
 201         return (OK);
 202 } /* hci_reset_node_stat */
 203
 204 /* Send Flush_Neighbor_Cache command to the node */
 205 static int
 206 hci_flush_neighbor_cache(int s, int argc, char **argv)
 207 {
 208         if (ioctl(s, SIOC_HCI_RAW_NODE_FLUSH_NEIGHBOR_CACHE) < 0)
 209                 return (ERROR);
 210
 211         return (OK);
 212 } /* hci_flush_neighbor_cache */
 213
 214 /* Send Read_Neighbor_Cache command to the node */
 215 static int
 216 hci_read_neighbor_cache(int s, int argc, char **argv)
 217 {
 218         struct ng_btsocket_hci_raw_node_neighbor_cache  r;
 219         int                                             n, error = OK;
 220         const char  *addrtype2str[] = {"B", "P", "R", "E"};
 221
 222         memset(&r, 0, sizeof(r));
 223         r.num_entries = NG_HCI_MAX_NEIGHBOR_NUM;
 224         r.entries = calloc(NG_HCI_MAX_NEIGHBOR_NUM,
 225                                 sizeof(ng_hci_node_neighbor_cache_entry_ep));
 226         if (r.entries == NULL) {
 227                 errno = ENOMEM;
 228                 return (ERROR);
 229         }
 230
 231         if (ioctl(s, SIOC_HCI_RAW_NODE_GET_NEIGHBOR_CACHE, &r,
 232                         sizeof(r)) < 0) {
 233                 error = ERROR;
 234                 goto out;
 235         }
 236
 237         fprintf(stdout,
 238 "T " \
 239 "BD_ADDR           " \
 240 "Features                " \
 241 "Clock offset " \
 242 "Page scan " \
 243 "Rep. scan\n");
 244
 245         for (n = 0; n < r.num_entries; n++) {
 246                 uint8_t addrtype = r.entries[n].addrtype;
 247                 if(addrtype >= sizeof(addrtype2str)/sizeof(addrtype2str[0]))
 248                         addrtype = sizeof(addrtype2str)/sizeof(addrtype2str[0]) - 1;
 249                 fprintf(stdout,
 250 "%1s %-17.17s " \
 251 "%02x %02x %02x %02x %02x %02x %02x %02x " \
 252 "%#12x " \
 253 "%#9x " \
 254 "%#9x\n",
 255                         addrtype2str[addrtype],
 256                         hci_bdaddr2str(&r.entries[n].bdaddr),
 257                         r.entries[n].features[0], r.entries[n].features[1],
 258                         r.entries[n].features[2], r.entries[n].features[3],
 259                         r.entries[n].features[4], r.entries[n].features[5],
 260                         r.entries[n].features[6], r.entries[n].features[7],
 261                         r.entries[n].clock_offset, r.entries[n].page_scan_mode,
 262                         r.entries[n].page_scan_rep_mode);
 263                 print_adv_data(r.entries[n].extinq_size,
 264                         r.entries[n].extinq_data);
 265                 fprintf(stdout,"\n");
 266         }
 267 out:
 268         free(r.entries);
 269
 270         return (error);
 271 } /* hci_read_neightbor_cache */
 272
 273 /* Send Read_Connection_List command to the node */
 274 static int
 275 hci_read_connection_list(int s, int argc, char **argv)
 276 {
 277         struct ng_btsocket_hci_raw_con_list     r;
 278         int                                     n, error = OK;
 279
 280         memset(&r, 0, sizeof(r));
 281         r.num_connections = NG_HCI_MAX_CON_NUM;
 282         r.connections = calloc(NG_HCI_MAX_CON_NUM, sizeof(ng_hci_node_con_ep));
 283         if (r.connections == NULL) {
 284                 errno = ENOMEM;
 285                 return (ERROR);
 286         }
 287
 288         if (ioctl(s, SIOC_HCI_RAW_NODE_GET_CON_LIST, &r, sizeof(r)) < 0) {
 289                 error = ERROR;
 290                 goto out;
 291         }
 292
 293         fprintf(stdout,
 294 "Remote BD_ADDR    " \
 295 "Handle " \
 296 "Type " \
 297 "Mode " \
 298 "Role " \
 299 "Encrypt " \
 300 "Pending " \
 301 "Queue " \
 302 "State\n");
 303
 304         for (n = 0; n < r.num_connections; n++) {
 305                 fprintf(stdout,
 306 "%-17.17s " \
 307 "%6d " \
 308 "%4.4s " \
 309 "%4d " \
 310 "%4.4s " \
 311 "%7.7s " \
 312 "%7d " \
 313 "%5d " \
 314 "%s\n",
 315                         hci_bdaddr2str(&r.connections[n].bdaddr),
 316                         r.connections[n].con_handle,
 317                         (r.connections[n].link_type == NG_HCI_LINK_ACL)?
 318                                 "ACL" : "SCO",
 319                         r.connections[n].mode,
 320                         (r.connections[n].role == NG_HCI_ROLE_MASTER)?
 321                                 "MAST" : "SLAV",
 322                         hci_encrypt2str(r.connections[n].encryption_mode, 1),
 323                         r.connections[n].pending,
 324                         r.connections[n].queue_len,
 325                         hci_con_state2str(r.connections[n].state));
 326         }
 327 out:
 328         free(r.connections);
 329
 330         return (error);
 331 } /* hci_read_connection_list */
 332
 333 /* Send Read_Node_Link_Policy_Settings_Mask command to the node */
 334 int
 335 hci_read_node_link_policy_settings_mask(int s, int argc, char **argv)
 336 {
 337         struct ng_btsocket_hci_raw_node_link_policy_mask        r;
 338
 339         memset(&r, 0, sizeof(r));
 340         if (ioctl(s, SIOC_HCI_RAW_NODE_GET_LINK_POLICY_MASK, &r, sizeof(r)) < 0)
 341                 return (ERROR);
 342
 343         fprintf(stdout, "Link Policy Settings mask: %#04x\n", r.policy_mask);
 344
 345         return (OK);
 346 } /* hci_read_node_link_policy_settings_mask */
 347
 348 /* Send Write_Node_Link_Policy_Settings_Mask command to the node */
 349 int
 350 hci_write_node_link_policy_settings_mask(int s, int argc, char **argv)
 351 {
 352         struct ng_btsocket_hci_raw_node_link_policy_mask        r;
 353         int                                                     m;
 354
 355         memset(&r, 0, sizeof(r));
 356
 357         switch (argc) {
 358         case 1:
 359                 if (sscanf(argv[0], "%x", &m) != 1)
 360                         return (USAGE);
 361
 362                 r.policy_mask = (m & 0xffff);
 363                 break;
 364
 365         default:
 366                 return (USAGE);
 367         }
 368
 369         if (ioctl(s, SIOC_HCI_RAW_NODE_SET_LINK_POLICY_MASK, &r, sizeof(r)) < 0)
 370                 return (ERROR);
 371
 372         return (OK);
 373 } /* hci_write_node_link_policy_settings_mask */
 374
 375 /* Send Read_Node_Packet_Mask command to the node */
 376 int
 377 hci_read_node_packet_mask(int s, int argc, char **argv)
 378 {
 379         struct ng_btsocket_hci_raw_node_packet_mask     r;
 380
 381         memset(&r, 0, sizeof(r));
 382         if (ioctl(s, SIOC_HCI_RAW_NODE_GET_PACKET_MASK, &r, sizeof(r)) < 0)
 383                 return (ERROR);
 384
 385         fprintf(stdout, "Packet mask: %#04x\n", r.packet_mask);
 386
 387         return (OK);
 388 } /* hci_read_node_packet_mask */
 389
 390 /* Send Write_Node_Packet_Mask command to the node */
 391 int
 392 hci_write_node_packet_mask(int s, int argc, char **argv)
 393 {
 394         struct ng_btsocket_hci_raw_node_packet_mask     r;
 395         int                                             m;
 396
 397         memset(&r, 0, sizeof(r));
 398
 399         switch (argc) {
 400         case 1:
 401                 if (sscanf(argv[0], "%x", &m) != 1)
 402                         return (USAGE);
 403
 404                 r.packet_mask = (m & 0xffff);
 405                 break;
 406
 407         default:
 408                 return (USAGE);
 409         }
 410
 411         if (ioctl(s, SIOC_HCI_RAW_NODE_SET_PACKET_MASK, &r, sizeof(r)) < 0)
 412                 return (ERROR);
 413
 414         return (OK);
 415 } /* hci_write_node_packet_mask */
 416
 417 /* Send Read_Node_Role_Switch command to the node */
 418 int
 419 hci_read_node_role_switch(int s, int argc, char **argv)
 420 {
 421         struct ng_btsocket_hci_raw_node_role_switch     r;
 422
 423         memset(&r, 0, sizeof(r));
 424         if (ioctl(s, SIOC_HCI_RAW_NODE_GET_ROLE_SWITCH, &r, sizeof(r)) < 0)
 425                 return (ERROR);
 426
 427         fprintf(stdout, "Role switch: %d\n", r.role_switch);
 428
 429         return (OK);
 430 } /* hci_read_node_role_switch */
 431
 432 /* Send Write_Node_Role_Switch command to the node */
 433 int
 434 hci_write_node_role_switch(int s, int argc, char **argv)
 435 {
 436         struct ng_btsocket_hci_raw_node_role_switch     r;
 437         int                                             m;
 438
 439         memset(&r, 0, sizeof(r));
 440
 441         switch (argc) {
 442         case 1:
 443                 if (sscanf(argv[0], "%d", &m) != 1)
 444                         return (USAGE);
 445
 446                 r.role_switch = m? 1 : 0;
 447                 break;
 448
 449         default:
 450                 return (USAGE);
 451         }
 452
 453         if (ioctl(s, SIOC_HCI_RAW_NODE_SET_ROLE_SWITCH, &r, sizeof(r)) < 0)
 454                 return (ERROR);
 455
 456         return (OK);
 457 } /* hci_write_node_role_switch */
 458
 459 /* Send Read_Node_List command to the node */
 460 int
 461 hci_read_node_list(int s, int argc, char **argv)
 462 {
 463         struct ng_btsocket_hci_raw_node_list_names      r;
 464         int                                             i;
 465
 466         r.num_names = MAX_NODE_NUM;
 467         r.names = (struct nodeinfo*)calloc(MAX_NODE_NUM, sizeof(struct nodeinfo));
 468         if (r.names == NULL)
 469                 return (ERROR);
 470
 471         if (ioctl(s, SIOC_HCI_RAW_NODE_LIST_NAMES, &r, sizeof(r)) < 0) {
 472                 free(r.names);
 473                 return (ERROR);
 474         }
 475
 476         fprintf(stdout, "Name            ID       Num hooks\n");
 477         for (i = 0; i < r.num_names; ++i)
 478                 fprintf(stdout, "%-15s %08x %9d\n",
 479                     r.names[i].name, r.names[i].id, r.names[i].hooks);
 480
 481         free(r.names);
 482
 483         return (OK);
 484 } /* hci_read_node_list */
 485
 486 struct hci_command      node_commands[] = {
 487 {
 488 "read_node_state",
 489 "Get the HCI node state",
 490 &hci_read_node_state
 491 },
 492 {
 493 "initialize",
 494 "Initialize the HCI node",
 495 &hci_node_initialize
 496 },
 497 {
 498 "read_debug_level",
 499 "Read the HCI node debug level",
 500 &hci_read_debug_level
 501 },
 502 {
 503 "write_debug_level <level>",
 504 "Write the HCI node debug level",
 505 &hci_write_debug_level
 506 },
 507 {
 508 "read_node_buffer_size",
 509 "Read the HCI node buffer information. This will return current state of the\n"\
 510 "HCI buffer for the HCI node",
 511 &hci_read_node_buffer_size
 512 },
 513 {
 514 "read_node_bd_addr",
 515 "Read the HCI node BD_ADDR. Returns device BD_ADDR as cached by the HCI node",
 516 &hci_read_node_bd_addr
 517 },
 518 {
 519 "read_node_features",
 520 "Read the HCI node features. This will return list of supported features as\n" \
 521 "cached by the HCI node",
 522 &hci_read_node_features
 523 },
 524 {
 525 "read_node_stat",
 526 "Read packets and bytes counters for the HCI node",
 527 &hci_read_node_stat
 528 },
 529 {
 530 "reset_node_stat",
 531 "Reset packets and bytes counters for the HCI node",
 532 &hci_reset_node_stat
 533 },
 534 {
 535 "flush_neighbor_cache",
 536 "Flush content of the HCI node neighbor cache",
 537 &hci_flush_neighbor_cache
 538 },
 539 {
 540 "read_neighbor_cache",
 541 "Read content of the HCI node neighbor cache",
 542 &hci_read_neighbor_cache
 543 },
 544 {
 545 "read_connection_list",
 546 "Read the baseband connection descriptors list for the HCI node",
 547 &hci_read_connection_list
 548 },
 549 {
 550 "read_node_link_policy_settings_mask",
 551 "Read the value of the Link Policy Settinngs mask for the HCI node",
 552 &hci_read_node_link_policy_settings_mask
 553 },
 554 {
 555 "write_node_link_policy_settings_mask <policy_mask>",
 556 "Write the value of the Link Policy Settings mask for the HCI node. By default\n" \
 557 "all supported Link Policy modes (as reported by the local device features) are\n"\
 558 "enabled. The particular Link Policy mode is enabled if local device supports\n"\
 559 "it and correspinding bit in the mask was set\n\n" \
 560 "\t<policy_mask> - xxxx; Link Policy mask\n" \
 561 "\t\t0x0000 - Disable All LM Modes\n" \
 562 "\t\t0x0001 - Enable Master Slave Switch\n" \
 563 "\t\t0x0002 - Enable Hold Mode\n" \
 564 "\t\t0x0004 - Enable Sniff Mode\n" \
 565 "\t\t0x0008 - Enable Park Mode\n",
 566 &hci_write_node_link_policy_settings_mask
 567 },
 568 {
 569 "read_node_packet_mask",
 570 "Read the value of the Packet mask for the HCI node",
 571 &hci_read_node_packet_mask
 572 },
 573 {
 574 "write_node_packet_mask <packet_mask>",
 575 "Write the value of the Packet mask for the HCI node. By default all supported\n" \
 576 "packet types (as reported by the local device features) are enabled. The\n" \
 577 "particular packet type is enabled if local device supports it and corresponding\n" \
 578 "bit in the mask was set\n\n" \
 579 "\t<packet_mask> - xxxx; packet type mask\n" \
 580 "" \
 581 "\t\tACL packets\n" \
 582 "\t\t-----------\n" \
 583 "\t\t0x0008 DM1\n" \
 584 "\t\t0x0010 DH1\n" \
 585 "\t\t0x0400 DM3\n" \
 586 "\t\t0x0800 DH3\n" \
 587 "\t\t0x4000 DM5\n" \
 588 "\t\t0x8000 DH5\n" \
 589 "\n" \
 590 "\t\tSCO packets\n" \
 591 "\t\t-----------\n" \
 592 "\t\t0x0020 HV1\n" \
 593 "\t\t0x0040 HV2\n" \
 594 "\t\t0x0080 HV3\n",
 595 &hci_write_node_packet_mask
 596 },
 597 {
 598 "read_node_role_switch",
 599 "Read the value of the Role Switch parameter for the HCI node",
 600 &hci_read_node_role_switch
 601 },
 602 {
 603 "write_node_role_switch {0|1}",
 604 "Write the value of the Role Switch parameter for the HCI node. By default,\n" \
 605 "if Role Switch is supported, local device will try to perform Role Switch\n" \
 606 "and become Master on incoming connection. Some devices do not support Role\n" \
 607 "Switch and thus incoming connections from such devices will fail. Setting\n" \
 608 "this parameter to zero will prevent Role Switch and thus accepting device\n" \
 609 "will remain Slave",
 610 &hci_write_node_role_switch
 611 },
 612 {
 613 "read_node_list",
 614 "Get a list of HCI nodes, their Netgraph IDs and connected hooks.",
 615 &hci_read_node_list
 616 },
 617 {
 618 NULL,
 619 }};
 620