main.h

Go to the documentation of this file.

 
/*
 * Copyright (c) 2017 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#ifndef ZEPHYR_INCLUDE_BLUETOOTH_MESH_MAIN_H_
#define ZEPHYR_INCLUDE_BLUETOOTH_MESH_MAIN_H_
 
#include <stdbool.h>
#include <stdint.h>
 
#include <zephyr/kernel.h>
#include <zephyr/sys/iterable_sections.h>

 
#ifdef __cplusplus
extern "C" {
#endif

enum {
        BT_MESH_PROV_AUTH_CMAC_AES128_AES_CCM,
        BT_MESH_PROV_AUTH_HMAC_SHA256_AES_CCM,
};

enum {
        BT_MESH_STATIC_OOB_AVAILABLE = BIT(0), 
        BT_MESH_OOB_AUTH_REQUIRED    = BIT(1)  
};

typedef enum {
        BT_MESH_NO_OUTPUT       = 0,
        BT_MESH_BLINK           = BIT(0),   
        BT_MESH_BEEP            = BIT(1),   
        BT_MESH_VIBRATE         = BIT(2),   
        BT_MESH_DISPLAY_NUMBER  = BIT(3),   
        BT_MESH_DISPLAY_STRING  = BIT(4),   
} bt_mesh_output_action_t;

typedef enum {
        BT_MESH_NO_INPUT      = 0,
        BT_MESH_PUSH          = BIT(0),     
        BT_MESH_TWIST         = BIT(1),    
        BT_MESH_ENTER_NUMBER  = BIT(2),     
        BT_MESH_ENTER_STRING  = BIT(3),     
} bt_mesh_input_action_t;

typedef enum {
        BT_MESH_PROV_ADV    = BIT(0),        
        BT_MESH_PROV_GATT   = BIT(1),       
        BT_MESH_PROV_REMOTE = BIT(2),     
} bt_mesh_prov_bearer_t;

typedef enum {
        BT_MESH_PROV_OOB_OTHER       = BIT(0),   
        BT_MESH_PROV_OOB_URI         = BIT(1),   
        BT_MESH_PROV_OOB_2D_CODE     = BIT(2),   
        BT_MESH_PROV_OOB_BAR_CODE    = BIT(3),   
        BT_MESH_PROV_OOB_NFC         = BIT(4),   
        BT_MESH_PROV_OOB_NUMBER      = BIT(5),   
        BT_MESH_PROV_OOB_STRING      = BIT(6),   
        BT_MESH_PROV_OOB_CERTIFICATE = BIT(7),   
        BT_MESH_PROV_OOB_RECORDS     = BIT(8),   
        /* 9 - 10 are reserved */
        BT_MESH_PROV_OOB_ON_BOX      = BIT(11),  
        BT_MESH_PROV_OOB_IN_BOX      = BIT(12),  
        BT_MESH_PROV_OOB_ON_PAPER    = BIT(13),  
        BT_MESH_PROV_OOB_IN_MANUAL   = BIT(14),  
        BT_MESH_PROV_OOB_ON_DEV      = BIT(15),  
} bt_mesh_prov_oob_info_t;

struct bt_mesh_dev_capabilities {
        uint8_t elem_count;

        uint16_t algorithms;

        uint8_t pub_key_type;

        uint8_t oob_type;

        bt_mesh_output_action_t output_actions;

        bt_mesh_input_action_t input_actions;

        uint8_t output_size;

        uint8_t input_size;
};

struct bt_mesh_prov {
        const uint8_t *uuid;

        const char *uri;

        bt_mesh_prov_oob_info_t oob_info;

        const uint8_t *public_key_be;
        const uint8_t *private_key_be;

        const uint8_t *static_val;
        uint8_t        static_val_len;

        uint8_t        output_size;
        uint16_t       output_actions;

        uint8_t        input_size;
        uint16_t       input_actions;

        void         (*capabilities)(const struct bt_mesh_dev_capabilities *cap);
 
#if defined CONFIG_BT_MESH_PROV_OOB_API_LEGACY
        int         (*output_number)(bt_mesh_output_action_t act, uint32_t num) __deprecated;
#else
        int         (*output_numeric)(bt_mesh_output_action_t act, uint8_t *numeric, size_t size);
#endif

        int         (*output_string)(const char *str);

        int         (*input)(bt_mesh_input_action_t act, uint8_t size);

        void        (*input_complete)(void);

        void        (*unprovisioned_beacon)(uint8_t uuid[16],
                                            bt_mesh_prov_oob_info_t oob_info,
                                            uint32_t *uri_hash);

        void        (*unprovisioned_beacon_gatt)(uint8_t uuid[16],
                                                 bt_mesh_prov_oob_info_t oob_info);

        void        (*link_open)(bt_mesh_prov_bearer_t bearer);

        void        (*link_close)(bt_mesh_prov_bearer_t bearer);

        void        (*complete)(uint16_t net_idx, uint16_t addr);

        void        (*reprovisioned)(uint16_t addr);

        void        (*node_added)(uint16_t net_idx, uint8_t uuid[16], uint16_t addr,
                                  uint8_t num_elem);

        void        (*reset)(void);
};
 
struct bt_mesh_rpr_cli;
struct bt_mesh_rpr_node;

int bt_mesh_input_string(const char *str);
 
#if defined CONFIG_BT_MESH_PROV_OOB_API_LEGACY
__deprecated int bt_mesh_input_number(uint32_t num);
#endif

int bt_mesh_input_numeric(uint8_t *numeric, size_t size);

int bt_mesh_prov_remote_pub_key_set(const uint8_t public_key[64]);

int bt_mesh_auth_method_set_input(bt_mesh_input_action_t action, uint8_t size);

int bt_mesh_auth_method_set_output(bt_mesh_output_action_t action, uint8_t size);

int bt_mesh_auth_method_set_static(const uint8_t *static_val, uint8_t size);

int bt_mesh_auth_method_set_none(void);

int bt_mesh_prov_enable(bt_mesh_prov_bearer_t bearers);

int bt_mesh_prov_disable(bt_mesh_prov_bearer_t bearers);

int bt_mesh_provision(const uint8_t net_key[16], uint16_t net_idx,
                      uint8_t flags, uint32_t iv_index, uint16_t addr,
                      const uint8_t dev_key[16]);

int bt_mesh_provision_adv(const uint8_t uuid[16], uint16_t net_idx, uint16_t addr,
                          uint8_t attention_duration);

int bt_mesh_provision_gatt(const uint8_t uuid[16], uint16_t net_idx, uint16_t addr,
                           uint8_t attention_duration);

int bt_mesh_provision_remote(struct bt_mesh_rpr_cli *cli,
                             const struct bt_mesh_rpr_node *srv,
                             const uint8_t uuid[16], uint16_t net_idx,
                             uint16_t addr);

int bt_mesh_reprovision_remote(struct bt_mesh_rpr_cli *cli,
                               struct bt_mesh_rpr_node *srv,
                               uint16_t addr, bool comp_change);

bool bt_mesh_is_provisioned(void);



#define BT_MESH_NET_PRIMARY                 0x000

#define BT_MESH_FEAT_RELAY                  BIT(0)
#define BT_MESH_FEAT_PROXY                  BIT(1)
#define BT_MESH_FEAT_FRIEND                 BIT(2)
#define BT_MESH_FEAT_LOW_POWER              BIT(3)
#define BT_MESH_FEAT_SUPPORTED              (BT_MESH_FEAT_RELAY |   \
                                             BT_MESH_FEAT_PROXY |   \
                                             BT_MESH_FEAT_FRIEND |  \
                                             BT_MESH_FEAT_LOW_POWER)

int bt_mesh_init(const struct bt_mesh_prov *prov,
                 const struct bt_mesh_comp *comp);

void bt_mesh_reset(void);

int bt_mesh_suspend(void);

int bt_mesh_resume(void);

void bt_mesh_iv_update_test(bool enable);

bool bt_mesh_iv_update(void);

int bt_mesh_lpn_set(bool enable);

int bt_mesh_lpn_poll(void);

struct bt_mesh_lpn_cb {
        void (*established)(uint16_t net_idx, uint16_t friend_addr,
                            uint8_t queue_size, uint8_t recv_window);

        void (*terminated)(uint16_t net_idx, uint16_t friend_addr);

        void (*polled)(uint16_t net_idx, uint16_t friend_addr, bool retry);
};

#define BT_MESH_LPN_CB_DEFINE(_name)                                  \
        static const STRUCT_SECTION_ITERABLE(bt_mesh_lpn_cb,          \
                                             _CONCAT(bt_mesh_lpn_cb_, \
                                                     _name))

struct bt_mesh_friend_cb {
        void (*established)(uint16_t net_idx, uint16_t lpn_addr,
                            uint8_t recv_delay, uint32_t polltimeout);

        void (*terminated)(uint16_t net_idx, uint16_t lpn_addr);

        void (*polled)(uint16_t net_idx, uint16_t lpn_addr);
};

#define BT_MESH_FRIEND_CB_DEFINE(_name)                                  \
        static const STRUCT_SECTION_ITERABLE(bt_mesh_friend_cb,          \
                                             _CONCAT(bt_mesh_friend_cb_, \
                                                     _name))
#if defined(CONFIG_BT_TESTING)
struct bt_mesh_snb {
        uint8_t flags;

        uint64_t net_id;

        uint32_t iv_idx;

        uint64_t auth_val;
};
 
struct bt_mesh_prb {
        uint8_t random[13];

        uint8_t flags;

        uint32_t iv_idx;

        uint64_t auth_tag;
};

struct bt_mesh_beacon_cb {
        void (*snb_received)(const struct bt_mesh_snb *snb);

        void (*priv_received)(const struct bt_mesh_prb *prb);
};

#define BT_MESH_BEACON_CB_DEFINE(_name)                                  \
        static const STRUCT_SECTION_ITERABLE(bt_mesh_beacon_cb,          \
                                             _CONCAT(bt_mesh_beacon_cb_, \
                                                     _name))
#endif

int bt_mesh_friend_terminate(uint16_t lpn_addr);

void bt_mesh_rpl_pending_store(uint16_t addr);

const uint8_t *bt_mesh_va_uuid_get(uint16_t addr, const uint8_t *uuid, uint16_t *retaddr);
 
#ifdef __cplusplus
}
#endif

 
#endif /* ZEPHYR_INCLUDE_BLUETOOTH_MESH_MAIN_H_ */