2015-04-18 04:53:17 +00:00
|
|
|
/*
|
|
|
|
* le.c
|
|
|
|
*
|
|
|
|
* Copyright (c) 2015 Takanori Watanabe <takawata@freebsd.org>
|
|
|
|
* 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 <sys/types.h>
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <sys/sysctl.h>
|
|
|
|
#include <sys/select.h>
|
|
|
|
#include <assert.h>
|
Improve performance and functionality of the bitstring(3) api
Two new functions are provided, bit_ffs_at() and bit_ffc_at(), which allow
for efficient searching of set or cleared bits starting from any bit offset
within the bit string.
Performance is improved by operating on longs instead of bytes and using
ffsl() for searches within a long. ffsl() is a compiler builtin in both
clang and gcc for most architectures, converting what was a brute force
while loop search into a couple of instructions.
All of the bitstring(3) API continues to be contained in the header file.
Some of the functions are large enough that perhaps they should be uninlined
and moved to a library, but that is beyond the scope of this commit.
sys/sys/bitstring.h:
Convert the majority of the existing bit string implementation from
macros to inline functions.
Properly protect the implementation from inadvertant macro expansion
when included in a user's program by prefixing all private
macros/functions and local variables with '_'.
Add bit_ffs_at() and bit_ffc_at(). Implement bit_ffs() and
bit_ffc() in terms of their "at" counterparts.
Provide a kernel implementation of bit_alloc(), making the full API
usable in the kernel.
Improve code documenation.
share/man/man3/bitstring.3:
Add pre-exisiting API bit_ffc() to the synopsis.
Document new APIs.
Document the initialization state of the bit strings
allocated/declared by bit_alloc() and bit_decl().
Correct documentation for bitstr_size(). The original code comments
indicate the size is in bytes, not "elements of bitstr_t". The new
implementation follows this lead. Only hastd assumed "elements"
rather than bytes and it has been corrected.
etc/mtree/BSD.tests.dist:
tests/sys/Makefile:
tests/sys/sys/Makefile:
tests/sys/sys/bitstring.c:
Add tests for all existing and new functionality.
include/bitstring.h
Include all headers needed by sys/bitstring.h
lib/libbluetooth/bluetooth.h:
usr.sbin/bluetooth/hccontrol/le.c:
Include bitstring.h instead of sys/bitstring.h.
sbin/hastd/activemap.c:
Correct usage of bitstr_size().
sys/dev/xen/blkback/blkback.c
Use new bit_alloc.
sys/kern/subr_unit.c:
Remove hard-coded assumption that sizeof(bitstr_t) is 1. Get rid of
unrb.busy, which caches the number of bits set in unrb.map. When
INVARIANTS are disabled, nothing needs to know that information.
callapse_unr can be adapted to use bit_ffs and bit_ffc instead.
Eliminating unrb.busy saves memory, simplifies the code, and
provides a slight speedup when INVARIANTS are disabled.
sys/net/flowtable.c:
Use the new kernel implementation of bit-alloc, instead of hacking
the old libc-dependent macro.
sys/sys/param.h
Update __FreeBSD_version to indicate availability of new API
Submitted by: gibbs, asomers
Reviewed by: gibbs, ngie
MFC after: 4 weeks
Sponsored by: Spectra Logic Corp
Differential Revision: https://reviews.freebsd.org/D6004
2016-05-04 22:34:11 +00:00
|
|
|
#include <bitstring.h>
|
2015-04-18 04:53:17 +00:00
|
|
|
#include <err.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <netgraph/ng_message.h>
|
|
|
|
#include <errno.h>
|
2020-05-11 15:32:32 +00:00
|
|
|
#include <stdbool.h>
|
2015-04-18 04:53:17 +00:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <unistd.h>
|
2015-04-18 17:41:09 +00:00
|
|
|
#include <stdint.h>
|
2015-04-18 04:53:17 +00:00
|
|
|
#define L2CAP_SOCKET_CHECKED
|
|
|
|
#include <bluetooth.h>
|
|
|
|
#include "hccontrol.h"
|
2015-04-18 06:48:03 +00:00
|
|
|
|
2015-04-18 04:53:17 +00:00
|
|
|
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[]);
|
2020-04-20 13:44:14 +00:00
|
|
|
static int le_read_supported_states(int s, int argc, char *argv[]);
|
2015-04-18 04:53:17 +00:00
|
|
|
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[]);
|
2020-04-24 08:07:59 +00:00
|
|
|
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[]);
|
2020-05-11 15:32:32 +00:00
|
|
|
static int le_scan(int s, int argc, char *argv[]);
|
|
|
|
static void handle_le_event(ng_hci_event_pkt_t* e, bool verbose);
|
2020-05-19 13:44:32 +00:00
|
|
|
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[]);
|
2020-05-26 15:46:18 +00:00
|
|
|
static int le_connect(int s, int argc, char *argv[]);
|
|
|
|
static void handle_le_connection_event(ng_hci_event_pkt_t* e, bool verbose);
|
2020-06-10 05:01:00 +00:00
|
|
|
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);
|
2020-07-08 03:57:47 +00:00
|
|
|
static int le_rand(int s, int argc, char *argv[]);
|
2015-04-18 04:53:17 +00:00
|
|
|
|
2015-04-18 06:48:03 +00:00
|
|
|
static int
|
|
|
|
le_set_scan_param(int s, int argc, char *argv[])
|
2015-04-18 04:53:17 +00:00
|
|
|
{
|
|
|
|
int type;
|
|
|
|
int interval;
|
|
|
|
int window;
|
|
|
|
int adrtype;
|
2015-04-18 06:48:03 +00:00
|
|
|
int policy;
|
2020-04-28 13:28:58 +00:00
|
|
|
int n;
|
2015-04-18 04:53:17 +00:00
|
|
|
|
|
|
|
ng_hci_le_set_scan_parameters_cp cp;
|
|
|
|
ng_hci_le_set_scan_parameters_rp rp;
|
|
|
|
|
2015-04-18 06:48:03 +00:00
|
|
|
if (argc != 5)
|
2020-04-28 13:28:58 +00:00
|
|
|
return (USAGE);
|
2015-04-18 04:53:17 +00:00
|
|
|
|
2015-04-18 06:48:03 +00:00
|
|
|
if (strcmp(argv[0], "active") == 0)
|
2015-04-18 04:53:17 +00:00
|
|
|
type = 1;
|
2015-04-18 06:48:03 +00:00
|
|
|
else if (strcmp(argv[0], "passive") == 0)
|
2015-04-18 04:53:17 +00:00
|
|
|
type = 0;
|
2015-04-18 06:48:03 +00:00
|
|
|
else
|
2020-04-28 13:28:58 +00:00
|
|
|
return (USAGE);
|
2015-04-18 04:53:17 +00:00
|
|
|
|
|
|
|
interval = (int)(atof(argv[1])/0.625);
|
|
|
|
interval = (interval < 4)? 4: interval;
|
|
|
|
window = (int)(atof(argv[2])/0.625);
|
|
|
|
window = (window < 4) ? 4 : interval;
|
|
|
|
|
2015-04-18 06:48:03 +00:00
|
|
|
if (strcmp(argv[3], "public") == 0)
|
2015-04-18 04:53:17 +00:00
|
|
|
adrtype = 0;
|
2015-09-09 13:24:39 +00:00
|
|
|
else if (strcmp(argv[3], "random") == 0)
|
2015-04-18 04:53:17 +00:00
|
|
|
adrtype = 1;
|
2015-04-18 06:48:03 +00:00
|
|
|
else
|
2020-04-28 13:28:58 +00:00
|
|
|
return (USAGE);
|
2015-04-18 04:53:17 +00:00
|
|
|
|
2015-04-18 06:48:03 +00:00
|
|
|
if (strcmp(argv[4], "all") == 0)
|
2015-04-18 04:53:17 +00:00
|
|
|
policy = 0;
|
2015-04-18 06:48:03 +00:00
|
|
|
else if (strcmp(argv[4], "whitelist") == 0)
|
2015-04-18 04:53:17 +00:00
|
|
|
policy = 1;
|
2015-04-18 06:48:03 +00:00
|
|
|
else
|
2020-04-28 13:28:58 +00:00
|
|
|
return (USAGE);
|
2015-04-18 04:53:17 +00:00
|
|
|
|
|
|
|
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);
|
2020-04-28 13:28:58 +00:00
|
|
|
|
|
|
|
if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE,
|
2015-04-18 06:48:03 +00:00
|
|
|
NG_HCI_OCF_LE_SET_SCAN_PARAMETERS),
|
2020-04-28 13:28:58 +00:00
|
|
|
(void *)&cp, sizeof(cp), (void *)&rp, &n) == ERROR)
|
|
|
|
return (ERROR);
|
2015-04-18 04:53:17 +00:00
|
|
|
|
2020-04-28 13:28:58 +00:00
|
|
|
if (rp.status != 0x00) {
|
|
|
|
fprintf(stdout, "Status: %s [%#02x]\n",
|
|
|
|
hci_status2str(rp.status), rp.status);
|
|
|
|
return (FAILED);
|
|
|
|
}
|
|
|
|
|
|
|
|
return (OK);
|
2015-04-18 04:53:17 +00:00
|
|
|
}
|
|
|
|
|
2015-04-18 06:48:03 +00:00
|
|
|
static int
|
|
|
|
le_set_scan_enable(int s, int argc, char *argv[])
|
2015-04-18 04:53:17 +00:00
|
|
|
{
|
|
|
|
ng_hci_le_set_scan_enable_cp cp;
|
|
|
|
ng_hci_le_set_scan_enable_rp rp;
|
2020-04-28 13:28:58 +00:00
|
|
|
int n, enable = 0;
|
2015-04-18 04:53:17 +00:00
|
|
|
|
2015-04-18 06:48:03 +00:00
|
|
|
if (argc != 1)
|
2020-04-28 13:28:58 +00:00
|
|
|
return (USAGE);
|
2015-04-18 04:53:17 +00:00
|
|
|
|
2015-04-18 06:48:03 +00:00
|
|
|
if (strcmp(argv[0], "enable") == 0)
|
2015-04-18 04:53:17 +00:00
|
|
|
enable = 1;
|
2015-04-18 06:48:03 +00:00
|
|
|
else if (strcmp(argv[0], "disable") != 0)
|
2020-04-28 13:28:58 +00:00
|
|
|
return (USAGE);
|
2015-04-18 06:48:03 +00:00
|
|
|
|
2015-04-18 04:53:17 +00:00
|
|
|
n = sizeof(rp);
|
|
|
|
cp.le_scan_enable = enable;
|
|
|
|
cp.filter_duplicates = 0;
|
2020-04-28 13:28:58 +00:00
|
|
|
if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE,
|
2015-04-18 06:48:03 +00:00
|
|
|
NG_HCI_OCF_LE_SET_SCAN_ENABLE),
|
2020-04-28 13:28:58 +00:00
|
|
|
(void *)&cp, sizeof(cp),
|
|
|
|
(void *)&rp, &n) == ERROR)
|
|
|
|
return (ERROR);
|
2015-04-18 04:53:17 +00:00
|
|
|
|
2020-04-28 13:28:58 +00:00
|
|
|
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");
|
2015-04-18 06:48:03 +00:00
|
|
|
|
2020-04-28 13:28:58 +00:00
|
|
|
return (OK);
|
2015-04-18 04:53:17 +00:00
|
|
|
}
|
2015-04-18 06:48:03 +00:00
|
|
|
|
|
|
|
static int
|
|
|
|
parse_param(int argc, char *argv[], char *buf, int *len)
|
2015-04-18 04:53:17 +00:00
|
|
|
{
|
|
|
|
char *buflast = buf + (*len);
|
|
|
|
char *curbuf = buf;
|
|
|
|
char *token,*lenpos;
|
|
|
|
int ch;
|
|
|
|
int datalen;
|
|
|
|
uint16_t value;
|
|
|
|
optreset = 1;
|
|
|
|
optind = 0;
|
2015-04-18 06:48:03 +00:00
|
|
|
while ((ch = getopt(argc, argv , "n:f:u:")) != -1) {
|
2015-04-18 04:53:17 +00:00
|
|
|
switch(ch){
|
|
|
|
case 'n':
|
|
|
|
datalen = strlen(optarg);
|
2015-04-18 06:48:03 +00:00
|
|
|
if ((curbuf + datalen + 2) >= buflast)
|
2015-04-18 04:53:17 +00:00
|
|
|
goto done;
|
|
|
|
curbuf[0] = datalen + 1;
|
|
|
|
curbuf[1] = 8;
|
|
|
|
curbuf += 2;
|
|
|
|
memcpy(curbuf, optarg, datalen);
|
|
|
|
curbuf += datalen;
|
|
|
|
break;
|
|
|
|
case 'f':
|
2015-04-18 06:48:03 +00:00
|
|
|
if (curbuf+3 > buflast)
|
2015-04-18 04:53:17 +00:00
|
|
|
goto done;
|
|
|
|
curbuf[0] = 2;
|
|
|
|
curbuf[1] = 1;
|
2020-04-26 08:31:08 +00:00
|
|
|
curbuf[2] = (uint8_t)strtol(optarg, NULL, 16);
|
2015-04-18 04:53:17 +00:00
|
|
|
curbuf += 3;
|
|
|
|
break;
|
|
|
|
case 'u':
|
2015-04-18 06:48:03 +00:00
|
|
|
if ((buf+2) >= buflast)
|
2015-04-18 04:53:17 +00:00
|
|
|
goto done;
|
2020-04-26 08:31:08 +00:00
|
|
|
lenpos = curbuf;
|
2015-04-18 04:53:17 +00:00
|
|
|
curbuf[1] = 2;
|
|
|
|
*lenpos = 1;
|
|
|
|
curbuf += 2;
|
2015-04-18 06:48:03 +00:00
|
|
|
while ((token = strsep(&optarg, ",")) != NULL) {
|
2015-04-18 04:53:17 +00:00
|
|
|
value = strtol(token, NULL, 16);
|
2015-04-18 06:48:03 +00:00
|
|
|
if ((curbuf+2) >= buflast)
|
2015-04-18 04:53:17 +00:00
|
|
|
break;
|
|
|
|
curbuf[0] = value &0xff;
|
|
|
|
curbuf[1] = (value>>8)&0xff;
|
|
|
|
curbuf += 2;
|
2020-04-26 08:31:08 +00:00
|
|
|
*lenpos += 2;
|
2015-04-18 04:53:17 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
done:
|
|
|
|
*len = curbuf - buf;
|
|
|
|
|
2020-04-28 13:28:58 +00:00
|
|
|
return (OK);
|
2015-04-18 04:53:17 +00:00
|
|
|
}
|
|
|
|
|
2015-04-18 06:48:03 +00:00
|
|
|
static int
|
|
|
|
le_set_scan_response(int s, int argc, char *argv[])
|
2015-04-18 04:53:17 +00:00
|
|
|
{
|
|
|
|
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];
|
2015-04-18 06:48:03 +00:00
|
|
|
|
2015-04-18 04:53:17 +00:00
|
|
|
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);
|
2020-04-28 13:28:58 +00:00
|
|
|
if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE,
|
2015-04-18 06:48:03 +00:00
|
|
|
NG_HCI_OCF_LE_SET_SCAN_RESPONSE_DATA),
|
2020-04-28 13:28:58 +00:00
|
|
|
(void *)&cp, sizeof(cp),
|
|
|
|
(void *)&rp, &n) == ERROR)
|
|
|
|
return (ERROR);
|
2015-04-18 04:53:17 +00:00
|
|
|
|
2020-04-28 13:28:58 +00:00
|
|
|
if (rp.status != 0x00) {
|
|
|
|
fprintf(stdout, "Status: %s [%#02x]\n",
|
|
|
|
hci_status2str(rp.status), rp.status);
|
|
|
|
return (FAILED);
|
|
|
|
}
|
2015-04-18 04:53:17 +00:00
|
|
|
|
2020-04-28 13:28:58 +00:00
|
|
|
return (OK);
|
2015-04-18 04:53:17 +00:00
|
|
|
}
|
|
|
|
|
2015-04-18 06:48:03 +00:00
|
|
|
static int
|
|
|
|
le_read_local_supported_features(int s, int argc ,char *argv[])
|
2015-04-18 04:53:17 +00:00
|
|
|
{
|
|
|
|
ng_hci_le_read_local_supported_features_rp rp;
|
|
|
|
int n = sizeof(rp);
|
2015-04-18 06:48:03 +00:00
|
|
|
|
2020-04-19 14:22:21 +00:00
|
|
|
union {
|
|
|
|
uint64_t raw;
|
|
|
|
uint8_t octets[8];
|
|
|
|
} le_features;
|
|
|
|
|
|
|
|
char buffer[2048];
|
|
|
|
|
|
|
|
if (hci_simple_request(s,
|
2015-04-18 06:48:03 +00:00
|
|
|
NG_HCI_OPCODE(NG_HCI_OGF_LE,
|
|
|
|
NG_HCI_OCF_LE_READ_LOCAL_SUPPORTED_FEATURES),
|
2020-04-19 14:22:21 +00:00
|
|
|
(void *)&rp, &n) == ERROR)
|
|
|
|
return (ERROR);
|
|
|
|
|
|
|
|
if (rp.status != 0x00) {
|
|
|
|
fprintf(stdout, "Status: %s [%#02x]\n",
|
|
|
|
hci_status2str(rp.status), rp.status);
|
|
|
|
return (FAILED);
|
|
|
|
}
|
2015-04-18 04:53:17 +00:00
|
|
|
|
2020-04-19 14:22:21 +00:00
|
|
|
le_features.raw = rp.le_features;
|
2015-04-18 04:53:17 +00:00
|
|
|
|
2020-04-19 14:22:21 +00:00
|
|
|
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");
|
|
|
|
|
2020-04-28 13:28:58 +00:00
|
|
|
return (OK);
|
2015-04-18 04:53:17 +00:00
|
|
|
}
|
2015-04-18 06:48:03 +00:00
|
|
|
|
|
|
|
static int
|
2020-04-20 13:44:14 +00:00
|
|
|
le_read_supported_states(int s, int argc, char *argv[])
|
2015-04-18 04:53:17 +00:00
|
|
|
{
|
2020-04-20 13:44:14 +00:00
|
|
|
ng_hci_le_read_supported_states_rp rp;
|
2015-04-18 04:53:17 +00:00
|
|
|
int n = sizeof(rp);
|
|
|
|
|
2020-04-20 13:44:14 +00:00
|
|
|
if (hci_simple_request(s, NG_HCI_OPCODE(
|
2015-04-18 06:48:03 +00:00
|
|
|
NG_HCI_OGF_LE,
|
2020-04-20 13:44:14 +00:00
|
|
|
NG_HCI_OCF_LE_READ_SUPPORTED_STATES),
|
|
|
|
(void *)&rp, &n) == ERROR)
|
|
|
|
return (ERROR);
|
2015-04-18 04:53:17 +00:00
|
|
|
|
2020-04-20 13:44:14 +00:00
|
|
|
if (rp.status != 0x00) {
|
|
|
|
fprintf(stdout, "Status: %s [%#02x]\n",
|
|
|
|
hci_status2str(rp.status), rp.status);
|
|
|
|
return (FAILED);
|
|
|
|
}
|
2015-04-18 04:53:17 +00:00
|
|
|
|
2020-04-20 13:44:14 +00:00
|
|
|
fprintf(stdout, "LE States: %jx\n", rp.le_states);
|
|
|
|
|
|
|
|
return (OK);
|
2015-04-18 06:48:03 +00:00
|
|
|
}
|
2015-04-18 04:53:17 +00:00
|
|
|
|
2015-04-18 06:48:03 +00:00
|
|
|
static int
|
|
|
|
set_le_event_mask(int s, uint64_t mask)
|
2015-04-18 04:53:17 +00:00
|
|
|
{
|
|
|
|
ng_hci_le_set_event_mask_cp semc;
|
|
|
|
ng_hci_le_set_event_mask_rp rp;
|
2020-04-28 13:28:58 +00:00
|
|
|
int i, n;
|
2015-04-18 04:53:17 +00:00
|
|
|
|
|
|
|
n = sizeof(rp);
|
|
|
|
|
2015-04-18 06:48:03 +00:00
|
|
|
for (i=0; i < NG_HCI_LE_EVENT_MASK_SIZE; i++) {
|
2015-04-18 04:53:17 +00:00
|
|
|
semc.event_mask[i] = mask&0xff;
|
2015-04-18 06:48:03 +00:00
|
|
|
mask >>= 8;
|
2015-04-18 04:53:17 +00:00
|
|
|
}
|
2020-04-28 13:28:58 +00:00
|
|
|
if(hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_LE,
|
2015-04-18 06:48:03 +00:00
|
|
|
NG_HCI_OCF_LE_SET_EVENT_MASK),
|
2020-04-28 13:28:58 +00:00
|
|
|
(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);
|
|
|
|
}
|
2015-04-18 04:53:17 +00:00
|
|
|
|
2020-04-28 13:28:58 +00:00
|
|
|
return (OK);
|
2015-04-18 04:53:17 +00:00
|
|
|
}
|
|
|
|
|
2015-04-18 06:48:03 +00:00
|
|
|
static int
|
|
|
|
set_event_mask(int s, uint64_t mask)
|
2015-04-18 04:53:17 +00:00
|
|
|
{
|
|
|
|
ng_hci_set_event_mask_cp semc;
|
|
|
|
ng_hci_set_event_mask_rp rp;
|
2020-04-28 13:28:58 +00:00
|
|
|
int i, n;
|
2015-04-18 04:53:17 +00:00
|
|
|
|
|
|
|
n = sizeof(rp);
|
|
|
|
|
2015-04-18 06:48:03 +00:00
|
|
|
for (i=0; i < NG_HCI_EVENT_MASK_SIZE; i++) {
|
2015-04-18 04:53:17 +00:00
|
|
|
semc.event_mask[i] = mask&0xff;
|
2015-04-18 06:48:03 +00:00
|
|
|
mask >>= 8;
|
2015-04-18 04:53:17 +00:00
|
|
|
}
|
2020-04-28 13:28:58 +00:00
|
|
|
if (hci_request(s, NG_HCI_OPCODE(NG_HCI_OGF_HC_BASEBAND,
|
2015-04-18 06:48:03 +00:00
|
|
|
NG_HCI_OCF_SET_EVENT_MASK),
|
2020-04-28 13:28:58 +00:00
|
|
|
(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);
|
|
|
|
}
|
2015-04-18 04:53:17 +00:00
|
|
|
|
2020-04-28 13:28:58 +00:00
|
|
|
return (OK);
|
2015-04-18 04:53:17 +00:00
|
|
|
}
|
|
|
|
|
2015-04-18 06:48:03 +00:00
|
|
|
static
|
|
|
|
int le_enable(int s, int argc, char *argv[])
|
2015-04-18 04:53:17 +00:00
|
|
|
{
|
2020-04-28 13:28:58 +00:00
|
|
|
int result;
|
|
|
|
|
2015-04-18 06:48:03 +00:00
|
|
|
if (argc != 1)
|
2020-04-28 13:28:58 +00:00
|
|
|
return (USAGE);
|
2015-04-18 04:53:17 +00:00
|
|
|
|
2015-04-18 06:48:03 +00:00
|
|
|
if (strcasecmp(argv[0], "enable") == 0) {
|
2020-04-28 13:28:58 +00:00
|
|
|
result = set_event_mask(s, NG_HCI_EVENT_MASK_DEFAULT |
|
2015-04-18 04:53:17 +00:00
|
|
|
NG_HCI_EVENT_MASK_LE);
|
2020-04-28 13:28:58 +00:00
|
|
|
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);
|
2015-04-18 04:53:17 +00:00
|
|
|
}
|
|
|
|
|
2020-04-24 08:07:59 +00:00
|
|
|
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;
|
2020-04-25 00:57:48 +00:00
|
|
|
memcpy(cp.advertising_data, buf, len);
|
2020-04-24 08:07:59 +00:00
|
|
|
|
|
|
|
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);
|
|
|
|
}
|
2020-04-28 16:00:34 +00:00
|
|
|
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);
|
|
|
|
}
|
2020-04-24 08:07:59 +00:00
|
|
|
|
2020-05-11 15:32:32 +00:00
|
|
|
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");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-05-19 13:44:32 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2020-05-26 15:46:18 +00:00
|
|
|
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,
|
2020-05-28 13:48:33 +00:00
|
|
|
"Master clock accuracy: %s\n",
|
2020-05-26 15:46:18 +00:00
|
|
|
hci_mc_accuracy2str(
|
|
|
|
conn_event->master_clock_accuracy));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-06-10 05:01:00 +00:00
|
|
|
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)));
|
|
|
|
}
|
|
|
|
} /* handle_le_remote_features_event */
|
|
|
|
|
2020-07-08 03:57:47 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2020-06-10 05:01:00 +00:00
|
|
|
|
|
|
|
|
2015-04-18 06:48:03 +00:00
|
|
|
struct hci_command le_commands[] = {
|
|
|
|
{
|
|
|
|
"le_enable",
|
|
|
|
"le_enable [enable|disable] \n"
|
|
|
|
"Enable LE event ",
|
|
|
|
&le_enable,
|
|
|
|
},
|
2015-04-18 04:53:17 +00:00
|
|
|
{
|
|
|
|
"le_read_local_supported_features",
|
|
|
|
"le_read_local_supported_features\n"
|
|
|
|
"read local supported features mask",
|
|
|
|
&le_read_local_supported_features,
|
|
|
|
},
|
|
|
|
{
|
2020-04-20 13:44:14 +00:00
|
|
|
"le_read_supported_states",
|
|
|
|
"le_read_supported_states\n"
|
2015-04-18 04:53:17 +00:00
|
|
|
"read supported status"
|
|
|
|
,
|
2020-04-20 13:44:14 +00:00
|
|
|
&le_read_supported_states,
|
2015-04-18 04:53:17 +00:00
|
|
|
},
|
|
|
|
{
|
|
|
|
"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
|
|
|
|
},
|
2020-04-24 08:07:59 +00:00
|
|
|
{
|
|
|
|
"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
|
|
|
|
},
|
2020-04-28 16:00:34 +00:00
|
|
|
{
|
|
|
|
"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
|
|
|
|
},
|
2020-05-11 15:32:32 +00:00
|
|
|
{
|
|
|
|
"le_scan",
|
|
|
|
"le_scan [-a] [-v] [-n number_of_scans]\n"
|
|
|
|
"Do an LE scan",
|
|
|
|
&le_scan
|
|
|
|
},
|
2020-05-19 13:44:32 +00:00
|
|
|
{
|
|
|
|
"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
|
|
|
|
},
|
2020-05-26 15:46:18 +00:00
|
|
|
{
|
|
|
|
"le_connect",
|
|
|
|
"le_connect -a address [-t public|random] [-v]\n"
|
|
|
|
"Connect to an LE device",
|
|
|
|
&le_connect
|
|
|
|
},
|
2020-06-10 05:01:00 +00:00
|
|
|
{
|
|
|
|
"le_read_channel_map",
|
|
|
|
"le_read_channel_map <connection_handle>\n"
|
|
|
|
"Read the channel map for a connection",
|
|
|
|
&le_read_channel_map
|
|
|
|
},
|
|
|
|
{
|
|
|
|
"le_read_remote_features",
|
|
|
|
"le_read_remote_features <connection_handle>\n"
|
|
|
|
"Read supported features for the device\n"
|
|
|
|
"identified by the connection handle",
|
|
|
|
&le_read_remote_features
|
|
|
|
},
|
2020-07-08 03:57:47 +00:00
|
|
|
{
|
|
|
|
"le_rand",
|
|
|
|
"le_rand\n"
|
|
|
|
"Generate 64 bits of random data",
|
|
|
|
&le_rand
|
|
|
|
},
|
2023-05-04 22:01:31 +00:00
|
|
|
{
|
|
|
|
NULL,
|
|
|
|
}
|
2015-04-18 04:53:17 +00:00
|
|
|
};
|