addr.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2019 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef ZEPHYR_INCLUDE_BLUETOOTH_ADDR_H_
#define ZEPHYR_INCLUDE_BLUETOOTH_ADDR_H_
 
#include <stdint.h>
#include <string.h>
 
#include <zephyr/sys/printk.h>
 
#ifdef __cplusplus
extern "C" {
#endif

 
#define BT_ADDR_LE_PUBLIC       0x00
#define BT_ADDR_LE_RANDOM       0x01
#define BT_ADDR_LE_PUBLIC_ID    0x02
#define BT_ADDR_LE_RANDOM_ID    0x03
#define BT_ADDR_LE_UNRESOLVED   0xFE /* Resolvable Private Address
                                      * (Controller unable to resolve)
                                      */
#define BT_ADDR_LE_ANONYMOUS    0xFF /* No address provided
                                      * (anonymous advertisement)
                                      */

/** Length in bytes of a standard Bluetooth address */
#define BT_ADDR_SIZE 6


typedef struct {
        uint8_t  val[BT_ADDR_SIZE];
} bt_addr_t;
/**/

/** Length in bytes of an LE Bluetooth address. Not packed, so no sizeof() */
#define BT_ADDR_LE_SIZE 7

typedef struct {
        uint8_t      type;
        bt_addr_t a;
} bt_addr_le_t;
 
/* Global Bluetooth address constants defined in bluetooth/common/addr.c */
extern const bt_addr_t bt_addr_any;
extern const bt_addr_t bt_addr_none;
extern const bt_addr_le_t bt_addr_le_any;
extern const bt_addr_le_t bt_addr_le_none;

#define BT_ADDR_ANY     (&bt_addr_any)
#define BT_ADDR_NONE    (&bt_addr_none)
#define BT_ADDR_LE_ANY  (&bt_addr_le_any)
#define BT_ADDR_LE_NONE (&bt_addr_le_none)

 *  @param b Second Bluetooth device address to compare
 *
 *  @return negative value if @a a < @a b, 0 if @a a == @a b, else positive
 */
static inline int bt_addr_cmp(const bt_addr_t *a, const bt_addr_t *b)
{
        return memcmp(a, b, sizeof(*a));
}

 *
 *  @retval true if the two addresses are equal
 *  @retval false otherwise
 */
static inline bool bt_addr_eq(const bt_addr_t *a, const bt_addr_t *b)
{
        return bt_addr_cmp(a, b) == 0;
}

 *  @return negative value if @a a < @a b, 0 if @a a == @a b, else positive
 *
 *  @sa bt_addr_le_eq
 */
static inline int bt_addr_le_cmp(const bt_addr_le_t *a, const bt_addr_le_t *b)
{
        return memcmp(a, b, sizeof(*a));
}

 *
 *  @retval true if the two addresses are equal
 *  @retval false otherwise
 */
static inline bool bt_addr_le_eq(const bt_addr_le_t *a, const bt_addr_le_t *b)
{
        return bt_addr_le_cmp(a, b) == 0;
}

 *
 *  @param dst Bluetooth device address destination buffer.
 *  @param src Bluetooth device address source buffer.
 */
static inline void bt_addr_copy(bt_addr_t *dst, const bt_addr_t *src)
{
        memcpy(dst, src, sizeof(*dst));
}

 *
 *  @param dst Bluetooth LE device address destination buffer.
 *  @param src Bluetooth LE device address source buffer.
 */
static inline void bt_addr_le_copy(bt_addr_le_t *dst, const bt_addr_le_t *src)
{
        memcpy(dst, src, sizeof(*dst));
}

 *  @param dst Bluetooth LE device address destination buffer.
 *  @param src Bluetooth device address source buffer.
 *  @param src_type Bluetooth device address source type.
 */
static inline void bt_addr_le_copy_addr(bt_addr_le_t *dst, const bt_addr_t *src, uint8_t src_type)
{
        bt_addr_copy(&dst->a, src);
        dst->type = src_type;
}

#define BT_ADDR_IS_RPA(a)     (((a)->val[5] & 0xc0) == 0x40)
#define BT_ADDR_IS_NRPA(a)    (((a)->val[5] & 0xc0) == 0x00)
#define BT_ADDR_IS_STATIC(a)  (((a)->val[5] & 0xc0) == 0xc0)

#define BT_ADDR_SET_RPA(a)    ((a)->val[5] = (((a)->val[5] & 0x3f) | 0x40))
#define BT_ADDR_SET_NRPA(a)   ((a)->val[5] &= 0x3f)
#define BT_ADDR_SET_STATIC(a) ((a)->val[5] |= 0xc0)

int bt_addr_le_create_nrpa(bt_addr_le_t *addr);

int bt_addr_le_create_static(bt_addr_le_t *addr);

 *  @param addr Bluetooth LE device address.
 *
 *  @return true if address is a random private resolvable address.
 */
static inline bool bt_addr_le_is_rpa(const bt_addr_le_t *addr)
{
        if (addr->type != BT_ADDR_LE_RANDOM) {
                return false;
        }
 
        return BT_ADDR_IS_RPA(&addr->a);
}

 *  @param addr Bluetooth LE device address.
 *
 *  @return true if address is a valid identity address.
 */
static inline bool bt_addr_le_is_identity(const bt_addr_le_t *addr)
{
        if (addr->type == BT_ADDR_LE_PUBLIC) {
                return true;
        }
 
        return BT_ADDR_IS_STATIC(&addr->a);
}

#define BT_ADDR_STR_LEN 18

#define BT_ADDR_LE_STR_LEN 30

 *  BT_ADDR_STR_LEN about recommended value.
 *
 *  @return Number of successfully formatted bytes from binary address.
 */
static inline int bt_addr_to_str(const bt_addr_t *addr, char *str, size_t len)
{
        return snprintk(str, len, "%02X:%02X:%02X:%02X:%02X:%02X",
                        addr->val[5], addr->val[4], addr->val[3],
                        addr->val[2], addr->val[1], addr->val[0]);
}

 *  BT_ADDR_LE_STR_LEN about recommended value.
 *
 *  @return Number of successfully formatted bytes from binary address.
 */
static inline int bt_addr_le_to_str(const bt_addr_le_t *addr, char *str,
                                    size_t len)
{
        char type[10];
 
        switch (addr->type) {
        case BT_ADDR_LE_PUBLIC:
                strcpy(type, "public");
                break;
        case BT_ADDR_LE_RANDOM:
                strcpy(type, "random");
                break;
        case BT_ADDR_LE_PUBLIC_ID:
                strcpy(type, "public-id");
                break;
        case BT_ADDR_LE_RANDOM_ID:
                strcpy(type, "random-id");
                break;
        default:
                snprintk(type, sizeof(type), "0x%02x", addr->type);
                break;
        }
 
        return snprintk(str, len, "%02X:%02X:%02X:%02X:%02X:%02X (%s)",
                        addr->a.val[5], addr->a.val[4], addr->a.val[3],
                        addr->a.val[2], addr->a.val[1], addr->a.val[0], type);
}

struct bt_addr_tmp_str {
        char str[BT_ADDR_STR_LEN];
};
 
struct bt_addr_tmp_str bt_addr_tmp_str(const bt_addr_t *addr);
 
struct bt_addr_le_tmp_str {
        char str[BT_ADDR_LE_STR_LEN];
};
 
struct bt_addr_le_tmp_str bt_addr_le_tmp_str(const bt_addr_le_t *addr);

#define bt_addr_str(_addr) bt_addr_tmp_str(_addr).str

#define bt_addr_le_str(_addr) bt_addr_le_tmp_str(_addr).str

int bt_addr_from_str(const char *str, bt_addr_t *addr);

int bt_addr_le_from_str(const char *str, const char *type, bt_addr_le_t *addr);

int bt_addr_le_rpa_resolve(uint8_t id, const bt_addr_le_t *addr, bt_addr_le_t *resolved_addr);

 
#ifdef __cplusplus
}
#endif
 
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_ADDR_H_ */