packet.h

Go to the documentation of this file.

 
#ifndef INFUSE_SDK_INCLUDE_INFUSE_EPACKET_PACKET_H_
#define INFUSE_SDK_INCLUDE_INFUSE_EPACKET_PACKET_H_
 
#include <stdint.h>
 
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/toolchain.h>
#include <zephyr/net_buf.h>
#include <zephyr/bluetooth/bluetooth.h>
 
#include <infuse/security_ids.h>
#include <infuse/types.h>
#include <infuse/epacket/interface.h>
 
#ifdef __cplusplus
extern "C" {
#endif


enum epacket_auth {
        EPACKET_AUTH_FAILURE = 0,
        EPACKET_AUTH_REMOTE_ENCRYPTED = 0,
        EPACKET_AUTH_NETWORK = 1,
        EPACKET_AUTH_DEVICE = 2,
} __packed;

union epacket_interface_address {
        bt_addr_le_t bluetooth;
};

#define EPACKET_ADDR_ALL ((union epacket_interface_address){0})

typedef void (*epacket_tx_done_cb)(const struct device *dev, struct net_buf *pkt, int result,
                                   void *user_data);

struct epacket_tx_metadata {
#ifdef CONFIG_EPACKET_BUFFERS_TX_DELAYABLE_WORK
        struct k_work_delayable dwork;
#endif
        const struct device *interface;
        epacket_tx_done_cb tx_done;
        void *tx_done_user_data;
        enum epacket_auth auth;
        enum infuse_type type;
        uint32_t key_identifier;
        uint16_t flags;
        uint16_t sequence;
        union epacket_interface_address interface_address;
};

struct epacket_rx_metadata {
        uint64_t packet_device_id;
        k_ticks_t rx_timestamp;
        uint32_t packet_gps_time;
        uint32_t key_identifier;
        enum epacket_auth auth;
        enum infuse_type type;
        uint16_t flags;
        const struct device *interface;
        enum epacket_interface_id interface_id;
        union epacket_interface_address interface_address;
        int16_t rssi;
        uint16_t sequence;
};

enum epacket_flags {
        EPACKET_FLAGS_ENCRYPTION_DEVICE = BIT(15),
        EPACKET_FLAGS_ENCRYPTION_NETWORK = 0,
        EPACKET_FLAGS_ACK_REQUEST = BIT(14),
        EPACKET_FLAGS_CLOUD_FORWARDING = BIT(13),
        EPACKET_FLAGS_CLOUD_SELF = BIT(12),
        /* Bits 8-11: Reserved */
        EPACKET_FLAGS_INTERFACE_MASK = 0x00FF,
};

#define EPACKET_KEY_ID_REQ_MAGIC 0x4D

struct epacket_key_ids_data {
        uint8_t device_key_id[3];
} __packed;

#define EPACKET_RATE_LIMIT_REQ_MAGIC 0x4E

struct epacket_rate_limit_req {
        uint8_t magic;
        uint8_t delay_ms;
} __packed;

struct epacket_rate_throughput_req {
        uint8_t magic;
        uint16_t target_throughput_kbps;
} __packed;

struct epacket_interface_address_bt_le {
        uint8_t type;
        uint8_t addr[6];
} __packed;
BUILD_ASSERT(sizeof(struct epacket_interface_address_bt_le) == 7);

struct epacket_received_common_header {
        uint16_t len_encrypted;
        uint8_t rssi;
        uint8_t interface;
} __packed;

struct epacket_received_decrypted_header {
        uint64_t device_id;
        uint32_t gps_time;
        uint8_t type;
        uint16_t flags;
        uint16_t sequence;
        uint8_t key_id[3];
} __packed;

struct epacket_forward_header {
        uint16_t length;
        uint8_t interface;
        uint8_t destination_payload[];
} __packed;

enum epacket_forward_auto_conn_flags {
        EPACKET_FORWARD_AUTO_CONN_SINGLE_RPC = BIT(0),
        EPACKET_FORWARD_AUTO_CONN_SUB_DATA = BIT(1),
        EPACKET_FORWARD_AUTO_CONN_DC_NOTIFICATION = BIT(2),
        EPACKET_FORWARD_AUTO_CONN_PRIORITISE_UPLINK = BIT(3),
} __packed;

struct epacket_forward_auto_conn_header {
        uint16_t length;
        uint8_t interface;
        uint8_t flags;
        uint8_t conn_timeout;
        uint8_t conn_idle_timeout;
        uint8_t conn_absolute_timeout;
        uint8_t destination_payload[];
} __packed;

struct epacket_conn_terminated {
        uint8_t interface;
        int16_t reason;
        uint8_t address[];
} __packed;

void epacket_rate_limit_reset(void);

void epacket_rate_limit_tx(k_ticks_t *last_call, uint16_t bytes_transmitted);

void epacket_global_flags_set(uint16_t flags);

uint16_t epacket_global_flags_get(void);

int epacket_num_buffers_free_tx(void);

int epacket_num_buffers_free_rx(void);

struct net_buf *epacket_alloc_tx(k_timeout_t timeout);

struct net_buf *epacket_alloc_rx(k_timeout_t timeout);

static inline struct net_buf *epacket_alloc_tx_for_interface(const struct device *dev,
                                                             k_timeout_t timeout)
{
        const struct epacket_interface_common_config *config = dev->config;
        struct net_buf *buf = epacket_alloc_tx(timeout);
        uint16_t size;
 
        if (buf == NULL) {
                return NULL;
        }
        /* Reserve space for header */
        net_buf_reserve(buf, config->header_size);
        /* Limit size based on interface */
        size = epacket_interface_max_packet_size(dev);
        if (size > (config->header_size + config->footer_size)) {
                /* Hacky reservation for footer, automatically reversed by epacket_queue */
                buf->size = size - config->footer_size;
        } else {
                /* 0 payload size */
                buf->size = config->header_size;
        }
        return buf;
}

static inline void epacket_set_tx_metadata_core(struct net_buf *buf, enum epacket_auth auth,
                                                uint32_t key_identifier, uint16_t flags,
                                                enum infuse_type type,
                                                union epacket_interface_address dest)
{
        struct epacket_tx_metadata *meta = net_buf_user_data(buf);
 
        meta->auth = auth;
        meta->key_identifier = key_identifier;
        meta->flags = epacket_global_flags_get() | flags;
        meta->type = type;
        meta->tx_done = NULL;
        meta->interface_address = dest;
}

static inline void epacket_set_tx_metadata(struct net_buf *buf, enum epacket_auth auth,
                                           uint16_t flags, enum infuse_type type,
                                           union epacket_interface_address dest)
{
        uint32_t key_id = 0x00;
 
        if (auth == EPACKET_AUTH_DEVICE) {
                key_id = infuse_security_device_key_identifier();
        } else if (auth == EPACKET_AUTH_NETWORK) {
                key_id = infuse_security_network_key_identifier();
        }
 
        epacket_set_tx_metadata_core(buf, auth, key_id, flags, type, dest);
}

static inline void epacket_set_tx_callback(struct net_buf *buf, epacket_tx_done_cb tx_done,
                                           void *user_data)
{
        struct epacket_tx_metadata *meta = net_buf_user_data(buf);
 
        meta->tx_done = tx_done;
        meta->tx_done_user_data = user_data;
}

int epacket_received_packet_append(struct net_buf *storage_buf, struct net_buf *received_buf);

 
#ifdef __cplusplus
}
#endif
 
#endif /* INFUSE_SDK_INCLUDE_INFUSE_EPACKET_PACKET_H_ */