Index: head/usr.sbin/bluetooth/hccontrol/hccontrol.8 =================================================================== --- head/usr.sbin/bluetooth/hccontrol/hccontrol.8 (revision 363001) +++ head/usr.sbin/bluetooth/hccontrol/hccontrol.8 (revision 363002) @@ -1,218 +1,219 @@ .\" Copyright (c) 2001-2002 Maksim Yevmenkin .\" All rights reserved. .\" .\" Redistribution and use in source and binary forms, with or without .\" modification, are permitted provided that the following conditions .\" are met: .\" 1. Redistributions of source code must retain the above copyright .\" notice, this list of conditions and the following disclaimer. .\" 2. Redistributions in binary form must reproduce the above copyright .\" notice, this list of conditions and the following disclaimer in the .\" documentation and/or other materials provided with the distribution. .\" .\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND .\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE .\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE .\" ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE .\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL .\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS .\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) .\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT .\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY .\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF .\" SUCH DAMAGE. .\" .\" $Id: hccontrol.8,v 1.6 2003/08/06 21:26:38 max Exp $ .\" $FreeBSD$ .\" .Dd May 3, 2020 .Dt HCCONTROL 8 .Os .Sh NAME .Nm hccontrol .Nd Bluetooth HCI configuration utility .Sh SYNOPSIS .Nm .Op Fl hN .Op Fl n Ar HCI_node_name .Ar command .Op Ar parameters ... .Sh DESCRIPTION The .Nm utility connects to the specified Netgraph node of type .Dv HCI or the first one found if none is specified and attempts to send the specified command to the HCI Netgraph node or to the associated Bluetooth device. The .Nm utility will print results to the standard output and error messages to the standard error. .Pp The options are as follows: .Bl -tag -width indent .It Fl h Display usage message and exit. .It Fl N Show Bluetooth addresses as numbers. Normally .Nm attempts to resolve Bluetooth addresses, and display them symbolically. .It Fl n Ar HCI_node_name Connect to the specified HCI Netgraph node. .It Ar command One of the supported commands (see below). The special command .Cm help can be used to obtain the list of all supported commands. To get more information about a specific command use .Cm help Ar command . .It Ar parameters One or more optional space separated command parameters. Many commands require a remote device address as one of the parameters. The remote device address can be specified as BD_ADDR or a name. If a name was specified then the .Nm utility will attempt to resolve the name via .Xr bt_gethostbyname 3 . .El .Sh COMMANDS The currently supported HCI commands in .Nm are: .Pp .Bl -tag -width 40n -offset indent -compact .It Cm Inquiry .It Cm Create_Connection .It Cm Disconnect .It Cm Add_SCO_Connection .It Cm Change_Connection_Packet_Type .It Cm Remote_Name_Request .It Cm Read_Remote_Supported_Features .It Cm Read_Remote_Version_Information .It Cm Read_Clock_Offset .It Cm Role_Discovery .It Cm Switch_Role .It Cm Read_Link_Policy_Settings .It Cm Write_Link_Policy_Settings .It Cm Reset .It Cm Read_Pin_Type .It Cm Write_Pin_Type .It Cm Read_Stored_Link_Key .It Cm Write_Stored_Link_Key .It Cm Delete_Stored_Link_Key .It Cm Change_Local_Name .It Cm Read_Local_Name .It Cm Read_Connection_Accept_Timeout .It Cm Write_Connection_Accept_Timeout .It Cm Read_Page_Timeout .It Cm Write_Page_Timeout .It Cm Read_Scan_Enable .It Cm Write_Scan_Enable .It Cm Read_Page_Scan_Activity .It Cm Write_Page_Scan_Activity .It Cm Read_Inquiry_Scan_Activity .It Cm Write_Inquiry_Scan_Activity .It Cm Read_Authentication_Enable .It Cm Write_Authentication_Enable .It Cm Read_Encryption_Mode .It Cm Write_Encryption_Mode .It Cm Read_Class_Of_Device .It Cm Write_Class_Of_Device .It Cm Read_Voice_Settings .It Cm Write_Voice_Settings .It Cm Read_Number_Broadcast_Retransmissions .It Cm Write_Number_Broadcast_Retransmissions .It Cm Read_Hold_Mode_Activity .It Cm Write_Hold_Mode_Activity .It Cm Read_SCO_Flow_Control_Enable .It Cm Write_SCO_Flow_Control_Enable .It Cm Read_Link_Supervision_Timeout .It Cm Write_Link_Supervision_Timeout .It Cm Read_Page_Scan_Period_Mode .It Cm Write_Page_Scan_Period_Mode .It Cm Read_Page_Scan_Mode .It Cm Write_Page_Scan_Mode .It Cm Read_LE_Host_Support .It Cm Write_LE_Host_Support .It Cm Read_Local_Version_Information .It Cm Read_Local_Supported_Commands .It Cm Read_Local_Supported_Features .It Cm Read_Buffer_Size .It Cm Read_Country_Code .It Cm Read_BD_ADDR .It Cm Read_Failed_Contact_Counter .It Cm Reset_Failed_Contact_Counter .It Cm Get_Link_Quality .It Cm Read_RSSI .It Cm LE_Enable .It Cm LE_Read_Local_Supported_Features .It Cm LE_Set_Advertising_Parameters .It Cm LE_Read_Advertising_Physical_Channel_Tx_Power .It Cm LE_Set_Advertising_Data .It Cm LE_Set_Scan_Response_Data .It Cm LE_Set_Advertising_Enable .It Cm LE_Set_Scan_Parameters .It Cm LE_Set_Scan_Enable .It Cm LE_Read_Supported_States .It Cm LE_Read_Buffer_Size .It Cm LE Scan .It Cm LE_Read_White_List_Size .It Cm LE_Clear_White_List .It Cm LE_Add_Device_To_White_List .It Cm LE_Remove_Device_From_White_List .It Cm LE_Connect .It Cm LE_Read_Channel_Map .It Cm LE_Read_Remote_Features +.It Cm LE_Rand .El .Pp The currently supported node commands in .Nm are: .Pp .Bl -tag -width 40n -offset indent -compact .It Cm Read_Node_State .It Cm Initialize .It Cm Read_Debug_Level .It Cm Write_Debug_Level .It Cm Read_Node_Buffer_Size .It Cm Read_Node_BD_ADDR .It Cm Read_Node_Features .It Cm Read_Node_Stat .It Cm Reset_Node_Stat .It Cm Flush_Neighbor_Cache .It Cm Read_Neighbor_Cache .It Cm Read_Connection_List .It Cm Read_Node_Link_Policy_Settings_Mask .It Cm Write_Node_Link_Policy_Settings_Mask .It Cm Read_Node_Packet_Mask .It Cm Write_Node_Packet_Mask .It Cm Read_Node_Role_Switch .It Cm Write_Node_Role_Switch .It Cm Read_Node_List .El .Sh EXAMPLES Make the blutooth LE host, ubt0hci, scannable through .Xr hccontrol 8 commands: .Pp .Bd -literal -offset indent hccontrol -n ubt0hci le_set_advertising_enable disable hccontrol -n ubt0hci le_set_advertising_param hccontrol -n ubt0hci le_read_advertising_channel_tx_power hccontrol -n ubt0hci le_set_advertising_data hccontrol -n ubt0hci le_set_scan_response -n FBSD_Host hccontrol -n ubt0hci le_set_advertising_enable enable .Ed .Sh EXIT STATUS .Ex -std .Sh SEE ALSO .Xr bluetooth 3 , .Xr netgraph 3 , .Xr netgraph 4 , .Xr ng_hci 4 , .Xr hcseriald 8 .Sh AUTHORS .An Maksim Yevmenkin Aq Mt m_evmenkin@yahoo.com .Sh BUGS Most likely. Please report if found. Index: head/usr.sbin/bluetooth/hccontrol/le.c =================================================================== --- head/usr.sbin/bluetooth/hccontrol/le.c (revision 363001) +++ head/usr.sbin/bluetooth/hccontrol/le.c (revision 363002) @@ -1,1339 +1,1371 @@ /* * le.c * * Copyright (c) 2015 Takanori Watanabe * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $Id: hccontrol.c,v 1.5 2003/09/05 00:38:24 max Exp $ * $FreeBSD$ */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define L2CAP_SOCKET_CHECKED #include #include "hccontrol.h" static int le_set_scan_param(int s, int argc, char *argv[]); static int le_set_scan_enable(int s, int argc, char *argv[]); static int parse_param(int argc, char *argv[], char *buf, int *len); static int le_set_scan_response(int s, int argc, char *argv[]); static int le_read_supported_states(int s, int argc, char *argv[]); static int le_read_local_supported_features(int s, int argc ,char *argv[]); static int set_le_event_mask(int s, uint64_t mask); static int set_event_mask(int s, uint64_t mask); static int le_enable(int s, int argc, char *argv[]); static int le_set_advertising_enable(int s, int argc, char *argv[]); static int le_set_advertising_param(int s, int argc, char *argv[]); static int le_read_advertising_channel_tx_power(int s, int argc, char *argv[]); static int le_scan(int s, int argc, char *argv[]); static void handle_le_event(ng_hci_event_pkt_t* e, bool verbose); static int le_read_white_list_size(int s, int argc, char *argv[]); static int le_clear_white_list(int s, int argc, char *argv[]); static int le_add_device_to_white_list(int s, int argc, char *argv[]); static int le_remove_device_from_white_list(int s, int argc, char *argv[]); static int le_connect(int s, int argc, char *argv[]); static void handle_le_connection_event(ng_hci_event_pkt_t* e, bool verbose); static int le_read_channel_map(int s, int argc, char *argv[]); static void handle_le_remote_features_event(ng_hci_event_pkt_t* e); +static int le_rand(int s, int argc, char *argv[]); static int le_set_scan_param(int s, int argc, char *argv[]) { int type; int interval; int window; int adrtype; int policy; int n; ng_hci_le_set_scan_parameters_cp cp; ng_hci_le_set_scan_parameters_rp rp; if (argc != 5) return (USAGE); if (strcmp(argv[0], "active") == 0) type = 1; else if (strcmp(argv[0], "passive") == 0) type = 0; else return (USAGE); interval = (int)(atof(argv[1])/0.625); interval = (interval < 4)? 4: interval; window = (int)(atof(argv[2])/0.625); window = (window < 4) ? 4 : interval; if (strcmp(argv[3], "public") == 0) adrtype = 0; else if (strcmp(argv[3], "random") == 0) adrtype = 1; else return (USAGE); if (strcmp(argv[4], "all") == 0) policy = 0; else if (strcmp(argv[4], "whitelist") == 0) policy = 1; else return (USAGE); cp.le_scan_type = type; cp.le_scan_interval = interval; cp.own_address_type = adrtype; cp.le_scan_window = window; cp.scanning_filter_policy = policy; n = sizeof(rp); if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE, NG_HCI_OCF_LE_SET_SCAN_PARAMETERS), (void *)&cp, sizeof(cp), (void *)&rp, &n) == ERROR) return (ERROR); if (rp.status != 0x00) { fprintf(stdout, "Status: %s [%#02x]\n", hci_status2str(rp.status), rp.status); return (FAILED); } return (OK); } static int le_set_scan_enable(int s, int argc, char *argv[]) { ng_hci_le_set_scan_enable_cp cp; ng_hci_le_set_scan_enable_rp rp; int n, enable = 0; if (argc != 1) return (USAGE); if (strcmp(argv[0], "enable") == 0) enable = 1; else if (strcmp(argv[0], "disable") != 0) return (USAGE); n = sizeof(rp); cp.le_scan_enable = enable; cp.filter_duplicates = 0; if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE, NG_HCI_OCF_LE_SET_SCAN_ENABLE), (void *)&cp, sizeof(cp), (void *)&rp, &n) == ERROR) return (ERROR); if (rp.status != 0x00) { fprintf(stdout, "Status: %s [%#02x]\n", hci_status2str(rp.status), rp.status); return (FAILED); } fprintf(stdout, "LE Scan: %s\n", enable? "Enabled" : "Disabled"); return (OK); } static int parse_param(int argc, char *argv[], char *buf, int *len) { char *buflast = buf + (*len); char *curbuf = buf; char *token,*lenpos; int ch; int datalen; uint16_t value; optreset = 1; optind = 0; while ((ch = getopt(argc, argv , "n:f:u:")) != -1) { switch(ch){ case 'n': datalen = strlen(optarg); if ((curbuf + datalen + 2) >= buflast) goto done; curbuf[0] = datalen + 1; curbuf[1] = 8; curbuf += 2; memcpy(curbuf, optarg, datalen); curbuf += datalen; break; case 'f': if (curbuf+3 > buflast) goto done; curbuf[0] = 2; curbuf[1] = 1; curbuf[2] = (uint8_t)strtol(optarg, NULL, 16); curbuf += 3; break; case 'u': if ((buf+2) >= buflast) goto done; lenpos = curbuf; curbuf[1] = 2; *lenpos = 1; curbuf += 2; while ((token = strsep(&optarg, ",")) != NULL) { value = strtol(token, NULL, 16); if ((curbuf+2) >= buflast) break; curbuf[0] = value &0xff; curbuf[1] = (value>>8)&0xff; curbuf += 2; *lenpos += 2; } } } done: *len = curbuf - buf; return (OK); } static int le_set_scan_response(int s, int argc, char *argv[]) { ng_hci_le_set_scan_response_data_cp cp; ng_hci_le_set_scan_response_data_rp rp; int n; int len; char buf[NG_HCI_ADVERTISING_DATA_SIZE]; len = sizeof(buf); parse_param(argc, argv, buf, &len); memset(cp.scan_response_data, 0, sizeof(cp.scan_response_data)); cp.scan_response_data_length = len; memcpy(cp.scan_response_data, buf, len); n = sizeof(rp); if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE, NG_HCI_OCF_LE_SET_SCAN_RESPONSE_DATA), (void *)&cp, sizeof(cp), (void *)&rp, &n) == ERROR) return (ERROR); if (rp.status != 0x00) { fprintf(stdout, "Status: %s [%#02x]\n", hci_status2str(rp.status), rp.status); return (FAILED); } return (OK); } static int le_read_local_supported_features(int s, int argc ,char *argv[]) { ng_hci_le_read_local_supported_features_rp rp; int n = sizeof(rp); union { uint64_t raw; uint8_t octets[8]; } le_features; char buffer[2048]; if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE, NG_HCI_OCF_LE_READ_LOCAL_SUPPORTED_FEATURES), (void *)&rp, &n) == ERROR) return (ERROR); if (rp.status != 0x00) { fprintf(stdout, "Status: %s [%#02x]\n", hci_status2str(rp.status), rp.status); return (FAILED); } le_features.raw = rp.le_features; fprintf(stdout, "LE Features: "); for(int i = 0; i < 8; i++) fprintf(stdout, " %#02x", le_features.octets[i]); fprintf(stdout, "\n%s\n", hci_le_features2str(le_features.octets, buffer, sizeof(buffer))); fprintf(stdout, "\n"); return (OK); } static int le_read_supported_states(int s, int argc, char *argv[]) { ng_hci_le_read_supported_states_rp rp; int n = sizeof(rp); if (hci_simple_request(s, NG_HCI_OPCODE( NG_HCI_OGF_LE, NG_HCI_OCF_LE_READ_SUPPORTED_STATES), (void *)&rp, &n) == ERROR) return (ERROR); if (rp.status != 0x00) { fprintf(stdout, "Status: %s [%#02x]\n", hci_status2str(rp.status), rp.status); return (FAILED); } fprintf(stdout, "LE States: %jx\n", rp.le_states); return (OK); } static int set_le_event_mask(int s, uint64_t mask) { ng_hci_le_set_event_mask_cp semc; ng_hci_le_set_event_mask_rp rp; int i, n; n = sizeof(rp); for (i=0; i < NG_HCI_LE_EVENT_MASK_SIZE; i++) { semc.event_mask[i] = mask&0xff; mask >>= 8; } if(hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE, NG_HCI_OCF_LE_SET_EVENT_MASK), (void *)&semc, sizeof(semc), (void *)&rp, &n) == ERROR) return (ERROR); if (rp.status != 0x00) { fprintf(stdout, "Status: %s [%#02x]\n", hci_status2str(rp.status), rp.status); return (FAILED); } return (OK); } static int set_event_mask(int s, uint64_t mask) { ng_hci_set_event_mask_cp semc; ng_hci_set_event_mask_rp rp; int i, n; n = sizeof(rp); for (i=0; i < NG_HCI_EVENT_MASK_SIZE; i++) { semc.event_mask[i] = mask&0xff; mask >>= 8; } if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND, NG_HCI_OCF_SET_EVENT_MASK), (void *)&semc, sizeof(semc), (void *)&rp, &n) == ERROR) return (ERROR); if (rp.status != 0x00) { fprintf(stdout, "Status: %s [%#02x]\n", hci_status2str(rp.status), rp.status); return (FAILED); } return (OK); } static int le_enable(int s, int argc, char *argv[]) { int result; if (argc != 1) return (USAGE); if (strcasecmp(argv[0], "enable") == 0) { result = set_event_mask(s, NG_HCI_EVENT_MASK_DEFAULT | NG_HCI_EVENT_MASK_LE); if (result != OK) return result; result = set_le_event_mask(s, NG_HCI_LE_EVENT_MASK_ALL); if (result == OK) { fprintf(stdout, "LE enabled\n"); return (OK); } else return result; } else if (strcasecmp(argv[0], "disable") == 0) { result = set_event_mask(s, NG_HCI_EVENT_MASK_DEFAULT); if (result == OK) { fprintf(stdout, "LE disabled\n"); return (OK); } else return result; } else return (USAGE); } static int le_set_advertising_enable(int s, int argc, char *argv[]) { ng_hci_le_set_advertise_enable_cp cp; ng_hci_le_set_advertise_enable_rp rp; int n, enable = 0; if (argc != 1) return USAGE; if (strcmp(argv[0], "enable") == 0) enable = 1; else if (strcmp(argv[0], "disable") != 0) return USAGE; n = sizeof(rp); cp.advertising_enable = enable; if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE, NG_HCI_OCF_LE_SET_ADVERTISE_ENABLE), (void *)&cp, sizeof(cp), (void *)&rp, &n) == ERROR) return (ERROR); if (rp.status != 0x00) { fprintf(stdout, "Status: %s [%#02x]\n", hci_status2str(rp.status), rp.status); return (FAILED); } fprintf(stdout, "LE Advertising %s\n", (enable ? "enabled" : "disabled")); return (OK); } static int le_set_advertising_param(int s, int argc, char *argv[]) { ng_hci_le_set_advertising_parameters_cp cp; ng_hci_le_set_advertising_parameters_rp rp; int n, ch; cp.advertising_interval_min = 0x800; cp.advertising_interval_max = 0x800; cp.advertising_type = 0; cp.own_address_type = 0; cp.direct_address_type = 0; cp.advertising_channel_map = 7; cp.advertising_filter_policy = 0; optreset = 1; optind = 0; while ((ch = getopt(argc, argv , "m:M:t:o:p:a:c:f:")) != -1) { switch(ch) { case 'm': cp.advertising_interval_min = (uint16_t)(strtod(optarg, NULL)/0.625); break; case 'M': cp.advertising_interval_max = (uint16_t)(strtod(optarg, NULL)/0.625); break; case 't': cp.advertising_type = (uint8_t)strtod(optarg, NULL); break; case 'o': cp.own_address_type = (uint8_t)strtod(optarg, NULL); break; case 'p': cp.direct_address_type = (uint8_t)strtod(optarg, NULL); break; case 'a': if (!bt_aton(optarg, &cp.direct_address)) { struct hostent *he = NULL; if ((he = bt_gethostbyname(optarg)) == NULL) return (USAGE); memcpy(&cp.direct_address, he->h_addr, sizeof(cp.direct_address)); } break; case 'c': cp.advertising_channel_map = (uint8_t)strtod(optarg, NULL); break; case 'f': cp.advertising_filter_policy = (uint8_t)strtod(optarg, NULL); break; } } n = sizeof(rp); if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE, NG_HCI_OCF_LE_SET_ADVERTISING_PARAMETERS), (void *)&cp, sizeof(cp), (void *)&rp, &n) == ERROR) return (ERROR); if (rp.status != 0x00) { fprintf(stdout, "Status: %s [%#02x]\n", hci_status2str(rp.status), rp.status); return (FAILED); } return (OK); } static int le_read_advertising_channel_tx_power(int s, int argc, char *argv[]) { ng_hci_le_read_advertising_channel_tx_power_rp rp; int n; n = sizeof(rp); if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE, NG_HCI_OCF_LE_READ_ADVERTISING_CHANNEL_TX_POWER), (void *)&rp, &n) == ERROR) return (ERROR); if (rp.status != 0x00) { fprintf(stdout, "Status: %s [%#02x]\n", hci_status2str(rp.status), rp.status); return (FAILED); } fprintf(stdout, "Advertising transmit power level: %d dBm\n", (int8_t)rp.transmit_power_level); return (OK); } static int le_set_advertising_data(int s, int argc, char *argv[]) { ng_hci_le_set_advertising_data_cp cp; ng_hci_le_set_advertising_data_rp rp; int n, len; n = sizeof(rp); char buf[NG_HCI_ADVERTISING_DATA_SIZE]; len = sizeof(buf); parse_param(argc, argv, buf, &len); memset(cp.advertising_data, 0, sizeof(cp.advertising_data)); cp.advertising_data_length = len; memcpy(cp.advertising_data, buf, len); if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE, NG_HCI_OCF_LE_SET_ADVERTISING_DATA), (void *)&cp, sizeof(cp), (void *)&rp, &n) == ERROR) return (ERROR); if (rp.status != 0x00) { fprintf(stdout, "Status: %s [%#02x]\n", hci_status2str(rp.status), rp.status); return (FAILED); } return (OK); } static int le_read_buffer_size(int s, int argc, char *argv[]) { union { ng_hci_le_read_buffer_size_rp v1; ng_hci_le_read_buffer_size_rp_v2 v2; } rp; int n, ch; uint8_t v; uint16_t cmd; optreset = 1; optind = 0; /* Default to version 1*/ v = 1; cmd = NG_HCI_OCF_LE_READ_BUFFER_SIZE; while ((ch = getopt(argc, argv , "v:")) != -1) { switch(ch) { case 'v': v = (uint8_t)strtol(optarg, NULL, 16); if (v == 2) cmd = NG_HCI_OCF_LE_READ_BUFFER_SIZE_V2; else if (v > 2) return (USAGE); break; default: v = 1; } } n = sizeof(rp); if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE, cmd), (void *)&rp, &n) == ERROR) return (ERROR); if (rp.v1.status != 0x00) { fprintf(stdout, "Status: %s [%#02x]\n", hci_status2str(rp.v1.status), rp.v1.status); return (FAILED); } fprintf(stdout, "ACL data packet length: %d\n", rp.v1.hc_le_data_packet_length); fprintf(stdout, "Number of ACL data packets: %d\n", rp.v1.hc_total_num_le_data_packets); if (v == 2) { fprintf(stdout, "ISO data packet length: %d\n", rp.v2.hc_iso_data_packet_length); fprintf(stdout, "Number of ISO data packets: %d\n", rp.v2.hc_total_num_iso_data_packets); } return (OK); } static int le_scan(int s, int argc, char *argv[]) { int n, bufsize, scancount, numscans; bool verbose; uint8_t active = 0; char ch; char b[512]; ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; ng_hci_le_set_scan_parameters_cp scan_param_cp; ng_hci_le_set_scan_parameters_rp scan_param_rp; ng_hci_le_set_scan_enable_cp scan_enable_cp; ng_hci_le_set_scan_enable_rp scan_enable_rp; optreset = 1; optind = 0; verbose = false; numscans = 1; while ((ch = getopt(argc, argv , "an:v")) != -1) { switch(ch) { case 'a': active = 1; break; case 'n': numscans = (uint8_t)strtol(optarg, NULL, 10); break; case 'v': verbose = true; break; } } scan_param_cp.le_scan_type = active; scan_param_cp.le_scan_interval = (uint16_t)(100/0.625); scan_param_cp.le_scan_window = (uint16_t)(50/0.625); /* Address type public */ scan_param_cp.own_address_type = 0; /* 'All' filter policy */ scan_param_cp.scanning_filter_policy = 0; n = sizeof(scan_param_rp); if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE, NG_HCI_OCF_LE_SET_SCAN_PARAMETERS), (void *)&scan_param_cp, sizeof(scan_param_cp), (void *)&scan_param_rp, &n) == ERROR) return (ERROR); if (scan_param_rp.status != 0x00) { fprintf(stdout, "LE_Set_Scan_Parameters failed. Status: %s [%#02x]\n", hci_status2str(scan_param_rp.status), scan_param_rp.status); return (FAILED); } /* Enable scanning */ n = sizeof(scan_enable_rp); scan_enable_cp.le_scan_enable = 1; scan_enable_cp.filter_duplicates = 1; if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE, NG_HCI_OCF_LE_SET_SCAN_ENABLE), (void *)&scan_enable_cp, sizeof(scan_enable_cp), (void *)&scan_enable_rp, &n) == ERROR) return (ERROR); if (scan_enable_rp.status != 0x00) { fprintf(stdout, "LE_Scan_Enable enable failed. Status: %s [%#02x]\n", hci_status2str(scan_enable_rp.status), scan_enable_rp.status); return (FAILED); } scancount = 0; while (scancount < numscans) { /* wait for scan events */ bufsize = sizeof(b); if (hci_recv(s, b, &bufsize) == ERROR) { return (ERROR); } if (bufsize < sizeof(*e)) { errno = EIO; return (ERROR); } scancount++; if (e->event == NG_HCI_EVENT_LE) { fprintf(stdout, "Scan %d\n", scancount); handle_le_event(e, verbose); } } fprintf(stdout, "Scan complete\n"); /* Disable scanning */ n = sizeof(scan_enable_rp); scan_enable_cp.le_scan_enable = 0; if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE, NG_HCI_OCF_LE_SET_SCAN_ENABLE), (void *)&scan_enable_cp, sizeof(scan_enable_cp), (void *)&scan_enable_rp, &n) == ERROR) return (ERROR); if (scan_enable_rp.status != 0x00) { fprintf(stdout, "LE_Scan_Enable disable failed. Status: %s [%#02x]\n", hci_status2str(scan_enable_rp.status), scan_enable_rp.status); return (FAILED); } return (OK); } static void handle_le_event(ng_hci_event_pkt_t* e, bool verbose) { int rc; ng_hci_le_ep *leer = (ng_hci_le_ep *)(e + 1); ng_hci_le_advertising_report_ep *advrep = (ng_hci_le_advertising_report_ep *)(leer + 1); ng_hci_le_advreport *reports = (ng_hci_le_advreport *)(advrep + 1); if (leer->subevent_code == NG_HCI_LEEV_ADVREP) { fprintf(stdout, "Scan result, num_reports: %d\n", advrep->num_reports); for(rc = 0; rc < advrep->num_reports; rc++) { uint8_t length = (uint8_t)reports[rc].length_data; fprintf(stdout, "\tBD_ADDR %s \n", hci_bdaddr2str(&reports[rc].bdaddr)); fprintf(stdout, "\tAddress type: %s\n", hci_addrtype2str(reports[rc].addr_type)); if (length > 0 && verbose) { dump_adv_data(length, reports[rc].data); print_adv_data(length, reports[rc].data); fprintf(stdout, "\tRSSI: %d dBm\n", (int8_t)reports[rc].data[length]); fprintf(stdout, "\n"); } } } } static int le_read_white_list_size(int s, int argc, char *argv[]) { ng_hci_le_read_white_list_size_rp rp; int n; n = sizeof(rp); if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE, NG_HCI_OCF_LE_READ_WHITE_LIST_SIZE), (void *)&rp, &n) == ERROR) return (ERROR); if (rp.status != 0x00) { fprintf(stdout, "Status: %s [%#02x]\n", hci_status2str(rp.status), rp.status); return (FAILED); } fprintf(stdout, "White list size: %d\n", (uint8_t)rp.white_list_size); return (OK); } static int le_clear_white_list(int s, int argc, char *argv[]) { ng_hci_le_clear_white_list_rp rp; int n; n = sizeof(rp); if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE, NG_HCI_OCF_LE_CLEAR_WHITE_LIST), (void *)&rp, &n) == ERROR) return (ERROR); if (rp.status != 0x00) { fprintf(stdout, "Status: %s [%#02x]\n", hci_status2str(rp.status), rp.status); return (FAILED); } fprintf(stdout, "White list cleared\n"); return (OK); } static int le_add_device_to_white_list(int s, int argc, char *argv[]) { ng_hci_le_add_device_to_white_list_cp cp; ng_hci_le_add_device_to_white_list_rp rp; int n; char ch; optreset = 1; optind = 0; bool addr_set = false; n = sizeof(rp); cp.address_type = 0x00; while ((ch = getopt(argc, argv , "t:a:")) != -1) { switch(ch) { case 't': if (strcmp(optarg, "public") == 0) cp.address_type = 0x00; else if (strcmp(optarg, "random") == 0) cp.address_type = 0x01; else return (USAGE); break; case 'a': addr_set = true; if (!bt_aton(optarg, &cp.address)) { struct hostent *he = NULL; if ((he = bt_gethostbyname(optarg)) == NULL) return (USAGE); memcpy(&cp.address, he->h_addr, sizeof(cp.address)); } break; } } if (addr_set == false) return (USAGE); if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE, NG_HCI_OCF_LE_ADD_DEVICE_TO_WHITE_LIST), (void *)&cp, sizeof(cp), (void *)&rp, &n) == ERROR) return (ERROR); if (rp.status != 0x00) { fprintf(stdout, "Status: %s [%#02x]\n", hci_status2str(rp.status), rp.status); return (FAILED); } fprintf(stdout, "Address added to white list\n"); return (OK); } static int le_remove_device_from_white_list(int s, int argc, char *argv[]) { ng_hci_le_remove_device_from_white_list_cp cp; ng_hci_le_remove_device_from_white_list_rp rp; int n; char ch; optreset = 1; optind = 0; bool addr_set = false; n = sizeof(rp); cp.address_type = 0x00; while ((ch = getopt(argc, argv , "t:a:")) != -1) { switch(ch) { case 't': if (strcmp(optarg, "public") == 0) cp.address_type = 0x00; else if (strcmp(optarg, "random") == 0) cp.address_type = 0x01; else return (USAGE); break; case 'a': addr_set = true; if (!bt_aton(optarg, &cp.address)) { struct hostent *he = NULL; if ((he = bt_gethostbyname(optarg)) == NULL) return (USAGE); memcpy(&cp.address, he->h_addr, sizeof(cp.address)); } break; } } if (addr_set == false) return (USAGE); if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE, NG_HCI_OCF_LE_ADD_DEVICE_TO_WHITE_LIST), (void *)&cp, sizeof(cp), (void *)&rp, &n) == ERROR) return (ERROR); if (rp.status != 0x00) { fprintf(stdout, "Status: %s [%#02x]\n", hci_status2str(rp.status), rp.status); return (FAILED); } fprintf(stdout, "Address removed from white list\n"); return (OK); } static int le_connect(int s, int argc, char *argv[]) { ng_hci_le_create_connection_cp cp; ng_hci_status_rp rp; char b[512]; ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; int n, scancount, bufsize; char ch; bool addr_set = false; bool verbose = false; optreset = 1; optind = 0; /* minimal scan interval (2.5ms) */ cp.scan_interval = htole16(4); cp.scan_window = htole16(4); /* Don't use the whitelist */ cp.filter_policy = 0x00; /* Default to public peer address */ cp.peer_addr_type = 0x00; /* Own address type public */ cp.own_address_type = 0x00; /* 18.75ms min connection interval */ cp.conn_interval_min = htole16(0x000F); /* 18.75ms max connection interval */ cp.conn_interval_max = htole16(0x000F); /* 0 events connection latency */ cp.conn_latency = htole16(0x0000); /* 32s supervision timeout */ cp.supervision_timeout = htole16(0x0C80); /* Min CE Length 0.625 ms */ cp.min_ce_length = htole16(1); /* Max CE Length 0.625 ms */ cp.max_ce_length = htole16(1); while ((ch = getopt(argc, argv , "a:t:v")) != -1) { switch(ch) { case 't': if (strcmp(optarg, "public") == 0) cp.peer_addr_type = 0x00; else if (strcmp(optarg, "random") == 0) cp.peer_addr_type = 0x01; else return (USAGE); break; case 'a': addr_set = true; if (!bt_aton(optarg, &cp.peer_addr)) { struct hostent *he = NULL; if ((he = bt_gethostbyname(optarg)) == NULL) return (USAGE); memcpy(&cp.peer_addr, he->h_addr, sizeof(cp.peer_addr)); } break; case 'v': verbose = true; break; } } if (addr_set == false) return (USAGE); n = sizeof(rp); if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE, NG_HCI_OCF_LE_CREATE_CONNECTION), (void *)&cp, sizeof(cp), (void *)&rp, &n) == ERROR) return (ERROR); if (rp.status != 0x00) { fprintf(stdout, "Create connection failed. Status: %s [%#02x]\n", hci_status2str(rp.status), rp.status); return (FAILED); } scancount = 0; while (scancount < 3) { /* wait for connection events */ bufsize = sizeof(b); if (hci_recv(s, b, &bufsize) == ERROR) { return (ERROR); } if (bufsize < sizeof(*e)) { errno = EIO; return (ERROR); } scancount++; if (e->event == NG_HCI_EVENT_LE) { handle_le_connection_event(e, verbose); break; } } return (OK); } static void handle_le_connection_event(ng_hci_event_pkt_t* e, bool verbose) { ng_hci_le_ep *ev_pkt; ng_hci_le_connection_complete_ep *conn_event; ev_pkt = (ng_hci_le_ep *)(e + 1); if (ev_pkt->subevent_code == NG_HCI_LEEV_CON_COMPL) { conn_event =(ng_hci_le_connection_complete_ep *)(ev_pkt + 1); fprintf(stdout, "Handle: %d\n", le16toh(conn_event->handle)); if (verbose) { fprintf(stdout, "Status: %s\n", hci_status2str(conn_event->status)); fprintf(stdout, "Role: %s\n", hci_role2str(conn_event->role)); fprintf(stdout, "Address Type: %s\n", hci_addrtype2str(conn_event->address_type)); fprintf(stdout, "Address: %s\n", hci_bdaddr2str(&conn_event->address)); fprintf(stdout, "Interval: %.2fms\n", 6.25 * le16toh(conn_event->interval)); fprintf(stdout, "Latency: %d events\n", conn_event->latency); fprintf(stdout, "Supervision timeout: %dms\n", 10 * le16toh(conn_event->supervision_timeout)); fprintf(stdout, "Master clock accuracy: %s\n", hci_mc_accuracy2str( conn_event->master_clock_accuracy)); } } return; } static int le_read_channel_map(int s, int argc, char *argv[]) { ng_hci_le_read_channel_map_cp cp; ng_hci_le_read_channel_map_rp rp; int n; char buffer[2048]; /* parse command parameters */ switch (argc) { case 1: /* connection handle */ if (sscanf(argv[0], "%d", &n) != 1 || n <= 0 || n > 0x0eff) return (USAGE); cp.connection_handle = (uint16_t) (n & 0x0fff); cp.connection_handle = htole16(cp.connection_handle); break; default: return (USAGE); } n = sizeof(rp); if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE, NG_HCI_OCF_LE_READ_CHANNEL_MAP), (void *)&cp, sizeof(cp), (void *)&rp, &n) == ERROR) return (ERROR); if (rp.status != 0x00) { fprintf(stdout, "Read channel map failed. Status: %s [%#02x]\n", hci_status2str(rp.status), rp.status); return (FAILED); } fprintf(stdout, "Connection handle: %d\n", le16toh(rp.connection_handle)); fprintf(stdout, "Used channels:\n"); fprintf(stdout, "\n%s\n", hci_le_chanmap2str(rp.le_channel_map, buffer, sizeof(buffer))); return (OK); } /* le_read_channel_map */ static int le_read_remote_features(int s, int argc, char *argv[]) { ng_hci_le_read_remote_used_features_cp cp; ng_hci_status_rp rp; int n, bufsize; char b[512]; ng_hci_event_pkt_t *e = (ng_hci_event_pkt_t *) b; /* parse command parameters */ switch (argc) { case 1: /* connection handle */ if (sscanf(argv[0], "%d", &n) != 1 || n <= 0 || n > 0x0eff) return (USAGE); cp.connection_handle = (uint16_t) (n & 0x0fff); cp.connection_handle = htole16(cp.connection_handle); break; default: return (USAGE); } n = sizeof(rp); if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE, NG_HCI_OCF_LE_READ_REMOTE_USED_FEATURES), (void *)&cp, sizeof(cp), (void *)&rp, &n) == ERROR) return (ERROR); if (rp.status != 0x00) { fprintf(stdout, "Read remote features failed. Status: %s [%#02x]\n", hci_status2str(rp.status), rp.status); return (FAILED); } /* wait for connection events */ bufsize = sizeof(b); if (hci_recv(s, b, &bufsize) == ERROR) { return (ERROR); } if (bufsize < sizeof(*e)) { errno = EIO; return (ERROR); } if (e->event == NG_HCI_EVENT_LE) { handle_le_remote_features_event(e); } return (OK); } /* le_read_remote_features */ static void handle_le_remote_features_event(ng_hci_event_pkt_t* e) { ng_hci_le_ep *ev_pkt; ng_hci_le_read_remote_features_ep *feat_event; char buffer[2048]; ev_pkt = (ng_hci_le_ep *)(e + 1); if (ev_pkt->subevent_code == NG_HCI_LEEV_READ_REMOTE_FEATURES_COMPL) { feat_event =(ng_hci_le_read_remote_features_ep *)(ev_pkt + 1); fprintf(stdout, "Handle: %d\n", le16toh(feat_event->connection_handle)); fprintf(stdout, "Status: %s\n", hci_status2str(feat_event->status)); fprintf(stdout, "Features:\n%s\n", hci_le_features2str(feat_event->features, buffer, sizeof(buffer))); } return; } /* handle_le_remote_features_event */ +static int le_rand(int s, int argc, char *argv[]) +{ + ng_hci_le_rand_rp rp; + int n; + n = sizeof(rp); + if (hci_simple_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE, + NG_HCI_OCF_LE_RAND), + (void *)&rp, &n) == ERROR) + return (ERROR); + + if (rp.status != 0x00) { + fprintf(stdout, "Status: %s [%#02x]\n", + hci_status2str(rp.status), rp.status); + return (FAILED); + } + + fprintf(stdout, + "Random number : %08llx\n", + (unsigned long long)le64toh(rp.random_number)); + + return (OK); +} + + + struct hci_command le_commands[] = { { "le_enable", "le_enable [enable|disable] \n" "Enable LE event ", &le_enable, }, { "le_read_local_supported_features", "le_read_local_supported_features\n" "read local supported features mask", &le_read_local_supported_features, }, { "le_read_supported_states", "le_read_supported_states\n" "read supported status" , &le_read_supported_states, }, { "le_set_scan_response", "le_set_scan_response -n $name -f $flag -u $uuid16,$uuid16 \n" "set LE scan response data" , &le_set_scan_response, }, { "le_set_scan_enable", "le_set_scan_enable [enable|disable] \n" "enable or disable LE device scan", &le_set_scan_enable }, { "le_set_scan_param", "le_set_scan_param [active|passive] interval(ms) window(ms) [public|random] [all|whitelist] \n" "set LE device scan parameter", &le_set_scan_param }, { "le_set_advertising_enable", "le_set_advertising_enable [enable|disable] \n" "start or stop advertising", &le_set_advertising_enable }, { "le_read_advertising_channel_tx_power", "le_read_advertising_channel_tx_power\n" "read host advertising transmit poser level (dBm)", &le_read_advertising_channel_tx_power }, { "le_set_advertising_param", "le_set_advertising_param [-m min_interval(ms)] [-M max_interval(ms)]\n" "[-t advertising_type] [-o own_address_type] [-p peer_address_type]\n" "[-c advertising_channel_map] [-f advertising_filter_policy]\n" "[-a peer_address]\n" "set LE device advertising parameters", &le_set_advertising_param }, { "le_set_advertising_data", "le_set_advertising_data -n $name -f $flag -u $uuid16,$uuid16 \n" "set LE device advertising packed data", &le_set_advertising_data }, { "le_read_buffer_size", "le_read_buffer_size [-v 1|2]\n" "Read the maximum size of ACL and ISO data packets", &le_read_buffer_size }, { "le_scan", "le_scan [-a] [-v] [-n number_of_scans]\n" "Do an LE scan", &le_scan }, { "le_read_white_list_size", "le_read_white_list_size\n" "Read total number of white list entries that can be stored", &le_read_white_list_size }, { "le_clear_white_list", "le_clear_white_list\n" "Clear the white list in the controller", &le_clear_white_list }, { "le_add_device_to_white_list", "le_add_device_to_white_list\n" "[-t public|random] -a address\n" "Add device to the white list", &le_add_device_to_white_list }, { "le_remove_device_from_white_list", "le_remove_device_from_white_list\n" "[-t public|random] -a address\n" "Remove device from the white list", &le_remove_device_from_white_list }, { "le_connect", "le_connect -a address [-t public|random] [-v]\n" "Connect to an LE device", &le_connect }, { "le_read_channel_map", "le_read_channel_map \n" "Read the channel map for a connection", &le_read_channel_map }, { "le_read_remote_features", "le_read_remote_features \n" "Read supported features for the device\n" "identified by the connection handle", &le_read_remote_features + }, + { + "le_rand", + "le_rand\n" + "Generate 64 bits of random data", + &le_rand }, };