subnet.h

/*
 * Copyright (c) 2020 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef _BLUETOOTH_MESH_SUBNET_H_
#define _BLUETOOTH_MESH_SUBNET_H_
 
#include <stdint.h>
#include <sys/types.h>
#include "../include/mesh/glue.h"
#define BT_MESH_NET_FLAG_KR       BIT(0)
#define BT_MESH_NET_FLAG_IVU      BIT(1)
 
#define BT_MESH_KR_NORMAL         0x00
#define BT_MESH_KR_PHASE_1        0x01
#define BT_MESH_KR_PHASE_2        0x02
#define BT_MESH_KR_PHASE_3        0x03
 
#define SUBNET_KEY_TX_IDX(sub) ((sub)->kr_phase == BT_MESH_KR_PHASE_2)
 
struct bt_mesh_net_rx;
enum bt_mesh_key_evt;
 
struct bt_mesh_net_cred {
    uint8_t nid;         /* NID */
    uint8_t enc[16];     /* EncKey */
    uint8_t privacy[16]; /* PrivacyKey */
};
 
struct bt_mesh_subnet {
    uint32_t beacon_sent;        /* Timestamp of last sent beacon */
    uint8_t  beacons_last;       /* Number of beacons during last
                      * observation window
                      */
    uint8_t  beacons_cur;        /* Number of beacons observed during
                      * currently ongoing window.
                      */
 
    uint8_t  beacon_cache[21];   /* Cached last authenticated beacon */
 
    uint16_t net_idx;            /* NetKeyIndex */
 
    uint8_t  kr_phase;           /* Key Refresh Phase */
 
    uint8_t  node_id;            /* Node Identity State */
    uint32_t node_id_start;      /* Node Identity started timestamp */
 
    uint8_t  auth[8];            /* Beacon Authentication Value */
 
    struct bt_mesh_subnet_keys {
        bool valid;
        uint8_t net[16];       /* NetKey */
        struct bt_mesh_net_cred msg;
        uint8_t net_id[8];     /* Network ID */
    #if defined(CONFIG_BT_MESH_GATT_PROXY)
        uint8_t identity[16];  /* IdentityKey */
    #endif
        uint8_t beacon[16];    /* BeaconKey */
    } keys[2];
};
 
#ifdef CONFIG_BT_MESH_GATT_PROXY
extern void (*bt_mesh_subnet_cb_list[5]) (struct bt_mesh_subnet *sub,
                                          enum bt_mesh_key_evt evt);
#else
extern void (*bt_mesh_subnet_cb_list[4]) (struct bt_mesh_subnet *sub,
                                          enum bt_mesh_key_evt evt);
#endif
 
struct bt_mesh_subnet_cb {
    void (*evt_handler)(struct bt_mesh_subnet *subnet,
                enum bt_mesh_key_evt evt);
};
 
void bt_mesh_net_keys_reset(void);
 
struct bt_mesh_subnet *bt_mesh_subnet_find(int (*cb)(struct bt_mesh_subnet *sub,
                             void *cb_data),
                       void *cb_data);
 
size_t bt_mesh_subnet_foreach(void (*cb)(struct bt_mesh_subnet *sub));
 
struct bt_mesh_subnet *bt_mesh_subnet_next(struct bt_mesh_subnet *sub);
 
struct bt_mesh_subnet *bt_mesh_subnet_get(uint16_t net_idx);
 
int bt_mesh_subnet_set(uint16_t net_idx, uint8_t kr_phase,
               const uint8_t key[16], const uint8_t new_key[16]);
 
int bt_mesh_friend_cred_create(struct bt_mesh_net_cred *cred,
                   uint16_t lpn_addr, uint16_t frnd_addr,
                   uint16_t lpn_counter, uint16_t frnd_counter,
                   const uint8_t key[16]);
 
bool bt_mesh_net_cred_find(struct bt_mesh_net_rx *rx, struct os_mbuf *in,
               struct os_mbuf *out,
               bool (*cb)(struct bt_mesh_net_rx *rx,
                      struct os_mbuf *in,
                      struct os_mbuf *out,
                      const struct bt_mesh_net_cred *cred));
 
uint8_t bt_mesh_net_flags(struct bt_mesh_subnet *sub);
 
void bt_mesh_kr_update(struct bt_mesh_subnet *sub, bool kr_flag, bool new_key);
 
static inline bool
bt_mesh_subnet_has_new_key(const struct bt_mesh_subnet *sub)
{
    return sub->kr_phase != BT_MESH_KR_NORMAL;
}
 
void bt_mesh_subnet_store(uint16_t net_idx);
 
void bt_mesh_subnet_pending_store(void);
void bt_mesh_net_key_init(void);
#endif /* _BLUETOOTH_MESH_SUBNET_H_ */