static void ipsp_connected(struct bt_l2cap_chan *chan)
{
struct bt_context *ctxt = CHAN_CTXT(chan);
struct bt_conn_info info;
#if defined(CONFIG_NET_DEBUG_L2_BLUETOOTH)
char src[BT_ADDR_LE_STR_LEN];
char dst[BT_ADDR_LE_STR_LEN];
#endif
bt_conn_get_info(chan->conn, &info);
#if defined(CONFIG_NET_DEBUG_L2_BLUETOOTH)
bt_addr_le_to_str(info.le.src, src, sizeof(src));
bt_addr_le_to_str(info.le.dst, dst, sizeof(dst));
NET_DBG("Channel %p Source %s connected to Destination %s", chan,
src, dst);
#endif
/* Swap bytes since net APIs expect big endian address */
sys_memcpy_swap(ctxt->src.val, info.le.src->a.val, sizeof(ctxt->src));
sys_memcpy_swap(ctxt->dst.val, info.le.dst->a.val, sizeof(ctxt->dst));
net_if_set_link_addr(ctxt->iface, ctxt->src.val, sizeof(ctxt->src.val));
/* Set iface up */
net_if_up(ctxt->iface);
}
static void identity_resolved(struct bt_conn *conn, const bt_addr_le_t *rpa,
const bt_addr_le_t *identity)
{
char addr_identity[BT_ADDR_LE_STR_LEN];
char addr_rpa[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(identity, addr_identity, sizeof(addr_identity));
bt_addr_le_to_str(rpa, addr_rpa, sizeof(addr_rpa));
printk("Identity resolved %s -> %s\n", addr_rpa, addr_identity);
}
static void connected(struct bt_conn *conn, uint8_t conn_err)
{
char addr[BT_ADDR_LE_STR_LEN];
int err;
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (conn_err) {
printk("Failed to connect to %s (%u)\n", addr, conn_err);
return;
}
printk("Connected: %s\n", addr);
if (conn == default_conn) {
uuid.val = BT_UUID_HRS_VAL;
discover_params.uuid = &uuid.uuid;
discover_params.func = discover_func;
discover_params.start_handle = 0x0001;
discover_params.end_handle = 0xffff;
discover_params.type = BT_GATT_DISCOVER_PRIMARY;
err = bt_gatt_discover(default_conn, &discover_params);
if (err) {
printk("Discover failed(err %d)\n", err);
return;
}
}
}
static const char *bt_addr_le_str(const bt_addr_le_t *addr)
{
static char str[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(addr, str, sizeof(str));
return str;
}
static void auth_passkey_display(struct bt_conn *conn, unsigned int passkey)
{
char addr[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
printk("Passkey for %s: %u\n", addr, passkey);
}
static void security_changed(struct bt_conn *conn, bt_security_t level)
{
char addr[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
printk("Security changed: %s level %u\n", addr, level);
}
static void disconnected(struct bt_conn *conn, uint8_t reason)
{
char addr[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
printk("Disconnected from %s (reason %u)\n", addr, reason);
}
static void auth_cancel(struct bt_conn *conn)
{
char addr[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
printk("Pairing cancelled: %s\n", addr);
}
static void ipsp_connected(struct bt_l2cap_chan *chan)
{
struct bt_context *ctxt = CHAN_CTXT(chan);
struct bt_conn_info info;
struct net_linkaddr ll;
struct in6_addr in6;
#if defined(CONFIG_NET_DEBUG_L2_BLUETOOTH)
char src[BT_ADDR_LE_STR_LEN];
char dst[BT_ADDR_LE_STR_LEN];
#endif
bt_conn_get_info(chan->conn, &info);
#if defined(CONFIG_NET_DEBUG_L2_BLUETOOTH)
bt_addr_le_to_str(info.le.src, src, sizeof(src));
bt_addr_le_to_str(info.le.dst, dst, sizeof(dst));
NET_DBG("Channel %p Source %s connected to Destination %s", chan,
src, dst);
#endif
/* Swap bytes since net APIs expect big endian address */
sys_memcpy_swap(ctxt->src.val, info.le.src->a.val, sizeof(ctxt->src));
sys_memcpy_swap(ctxt->dst.val, info.le.dst->a.val, sizeof(ctxt->dst));
net_if_set_link_addr(ctxt->iface, ctxt->src.val, sizeof(ctxt->src.val),
NET_LINK_BLUETOOTH);
ll.addr = ctxt->dst.val;
ll.len = sizeof(ctxt->dst.val);
/* Add remote link-local address to the nbr cache to avoid sending ns:
* https://tools.ietf.org/html/rfc7668#section-3.2.3
* A Bluetooth LE 6LN MUST NOT register its link-local address.
*/
net_ipv6_addr_create_iid(&in6, &ll);
net_ipv6_nbr_add(ctxt->iface, &in6, &ll, false,
NET_IPV6_NBR_STATE_REACHABLE);
/* Set iface up */
net_if_up(ctxt->iface);
}
const char *bt_addr_le_str(const bt_addr_le_t *addr)
{
static char bufs[2][27];
static u8_t cur;
char *str;
str = bufs[cur++];
cur %= ARRAY_SIZE(bufs);
bt_addr_le_to_str(addr, str, sizeof(bufs[cur]));
return str;
}
static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t type,
const uint8_t *ad, uint8_t len)
{
char dev[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(addr, dev, sizeof(dev));
printk("[DEVICE]: %s, AD evt type %u, AD data len %u, RSSI %i\n",
dev, type, len, rssi);
/* We're only interested in connectable events */
if (type == BT_LE_ADV_IND || type == BT_LE_ADV_DIRECT_IND) {
/* TODO: Move this to a place it can be shared */
ad_parse(ad, len, eir_found, (void *)addr);
}
}
void ble_central_device_found(const bt_addr_le_t *addr,
int8_t rssi,
uint8_t type,
const uint8_t *ad,
uint8_t len)
{
char dev[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(addr, dev, sizeof(dev));
pr_debug(LOG_MODULE_BLE, "[DEVICE]: %s, AD evt type %u, AD data len %u, RSSI %i\n",
dev, type, len, rssi);
BLECentralRole::instance()->handleDeviceFound(addr, rssi, type,
ad, len);
}
static void connected(struct bt_conn *conn, uint8_t err)
{
char addr[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
if (err) {
printk("Failed to connect to %s (%u)\n", addr, err);
return;
}
printk("Connected %s\n", addr);
if (bt_conn_security(conn, BT_SECURITY_FIPS)) {
printk("Failed to set security\n");
}
}
static void device_found(const bt_addr_le_t *addr, int8_t rssi, uint8_t evtype,
const uint8_t *ad, uint8_t len)
{
char le_addr[BT_ADDR_LE_STR_LEN];
char name[30];
memset(name, 0, sizeof(name));
while (len) {
if (len < 2) {
break;
};
/* Look for early termination */
if (!ad[0]) {
break;
}
/* Check if field length is correct */
if (ad[0] > len - 1) {
break;
}
switch (ad[1]) {
case AD_SHORT_NAME:
case AD_COMPLETE_NAME:
if (ad[0] > sizeof(name) - 1) {
memcpy(name, &ad[2], sizeof(name) - 1);
} else {
memcpy(name, &ad[2], ad[0] - 1);
}
break;
default:
break;
}
/* Parse next AD Structure */
len -= ad[0] + 1;
ad += ad[0] + 1;
}
bt_addr_le_to_str(addr, le_addr, sizeof(le_addr));
printk("[DEVICE]: %s, AD evt type %u, RSSI %i %s\n", le_addr, evtype,
rssi, name);
}
static void disconnected(struct bt_conn *conn, u8_t reason)
{
#if defined(CONFIG_NET_DEBUG_L2_BLUETOOTH)
char addr[BT_ADDR_LE_STR_LEN];
#endif
if (conn != default_conn) {
return;
}
#if defined(CONFIG_NET_DEBUG_L2_BLUETOOTH)
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
NET_DBG("Disconnected: %s (reason %u)\n", addr, reason);
#endif
bt_conn_unref(default_conn);
default_conn = NULL;
}
static void connected(struct bt_conn *conn, u8_t err)
{
if (err) {
#if defined(CONFIG_NET_DEBUG_L2_BLUETOOTH)
char addr[BT_ADDR_LE_STR_LEN];
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
NET_ERR("Failed to connect to %s (%u)\n", addr, err);
#endif
return;
}
if (conn != default_conn) {
return;
}
bt_l2cap_chan_connect(conn, &bt_context_data.ipsp_chan.chan,
L2CAP_IPSP_PSM);
}
static void conn_addr_str(struct bt_conn *conn, char *addr, size_t len)
{
struct bt_conn_info info;
if (bt_conn_get_info(conn, &info) < 0) {
addr[0] = '\0';
return;
}
switch (info.type) {
#if defined(CONFIG_BLUETOOTH_BREDR)
case BT_CONN_TYPE_BR:
bt_addr_to_str(info.br.dst, addr, len);
break;
#endif
case BT_CONN_TYPE_LE:
bt_addr_le_to_str(info.le.dst, addr, len);
break;
}
}
static const char *current_prompt(void)
{
static char str[BT_ADDR_LE_STR_LEN + 2];
static struct bt_conn_info info;
if (!default_conn) {
return NULL;
}
if (bt_conn_get_info(default_conn, &info) < 0) {
return NULL;
}
if (info.type != BT_CONN_TYPE_LE) {
return NULL;
}
bt_addr_le_to_str(info.le.dst, str, sizeof(str) - 2);
strcat(str, "> ");
return str;
}
static void disconnected(struct bt_conn *conn, uint8_t reason)
{
char addr[BT_ADDR_LE_STR_LEN];
int err;
bt_addr_le_to_str(bt_conn_get_dst(conn), addr, sizeof(addr));
printk("Disconnected: %s (reason %u)\n", addr, reason);
if (default_conn != conn) {
return;
}
bt_conn_unref(default_conn);
default_conn = NULL;
/* This demo doesn't require active scan */
err = bt_le_scan_start(BT_LE_SCAN_PASSIVE, device_found);
if (err) {
printk("Scanning failed to start (err %d)\n", err);
}
}
static bool eir_found(u8_t type, const u8_t *data, u8_t data_len,
void *user_data)
{
int i;
#if defined(CONFIG_NET_DEBUG_L2_BLUETOOTH)
bt_addr_le_t *addr = user_data;
char dev[BT_ADDR_LE_STR_LEN];
#endif
if (type != BT_DATA_UUID16_SOME && type != BT_DATA_UUID16_ALL) {
return false;
}
if (data_len % sizeof(u16_t) != 0) {
NET_ERR("AD malformed\n");
return false;
}
for (i = 0; i < data_len; i += sizeof(u16_t)) {
u16_t u16;
memcpy(&u16, &data[i], sizeof(u16));
if (sys_le16_to_cpu(u16) != BT_UUID_IPSS_VAL) {
continue;
}
#if defined(CONFIG_NET_DEBUG_L2_BLUETOOTH)
bt_addr_le_to_str(addr, dev, sizeof(dev));
NET_DBG("[DEVICE]: %s", dev);
#endif
/* TODO: Notify device address found */
net_mgmt_event_notify(NET_EVENT_BT_SCAN_RESULT,
bt_context_data.iface);
return true;
}
return false;
}
