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 {
        /* Packet failed to decrypt */
        EPACKET_AUTH_FAILURE = 0,
        /* Packet is encrypted for remote device */
        EPACKET_AUTH_REMOTE_ENCRYPTED = 0,
        EPACKET_AUTH_NETWORK = 1,
        EPACKET_AUTH_DEVICE = 2,
} __packed;
 
/* Interface specific addresses */
union epacket_interface_address {
        /* Bluetooth LE address */
        bt_addr_le_t bluetooth;
};
 
/* Empty interface address */
#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);
 
/* Metadata for packets that will be transmitted */
struct epacket_tx_metadata {
#ifdef CONFIG_EPACKET_BUFFERS_TX_DELAYABLE_WORK
        struct k_work_delayable dwork;
#endif
        /* Callback run when TX completes */
        epacket_tx_done_cb tx_done;
        /* Context provided to @a tx_done */
        void *tx_done_user_data;
        /* Authentication level of packet */
        enum epacket_auth auth;
        /* Packet type */
        enum infuse_type type;
        /* Key identifier to use to encrypt packet for the auth level */
        uint32_t key_identifier;
        /* Flags to apply to packet */
        uint16_t flags;
        /* Sequence number used for packet */
        uint16_t sequence;
        /* Interface specific address */
        union epacket_interface_address interface_address;
};
 
/* Metadata for packets that have been received */
struct epacket_rx_metadata {
        /* Device ID in packet */
        uint64_t packet_device_id;
        /* Local time packet was received */
        k_ticks_t rx_timestamp;
        /* GPS time in packet */
        uint32_t packet_gps_time;
        /* Key ID used by packet */
        uint32_t key_identifier;
        /* Authentication level of packet */
        enum epacket_auth auth;
        /* Type of packet */
        enum infuse_type type;
        /* Flags associated with packet */
        uint16_t flags;
        /* ePacket interface packet was received on */
        const struct device *interface;
        /* Numerical ID for interface */
        enum epacket_interface_id interface_id;
        /* Interface specific address */
        union epacket_interface_address interface_address;
        /* RSSI of packet (0 = 0dBm, 20 = 20dBm, etc) */
        int16_t rssi;
        /* Sequence number of packet */
        uint16_t sequence;
};
 
/* Global ePacket flags */
enum epacket_flags {
        /* Bit 15: Encryption Type */
        EPACKET_FLAGS_ENCRYPTION_DEVICE = BIT(15),
        EPACKET_FLAGS_ENCRYPTION_NETWORK = 0,
        /* Bit 14: Transmitting device requests an ACK */
        EPACKET_FLAGS_ACK_REQUEST = BIT(14),
        /* Bit 13: Device can forward data to the cloud */
        EPACKET_FLAGS_CLOUD_FORWARDING = BIT(13),
        /* Bit 12: Device sends its own data to the cloud */
        EPACKET_FLAGS_CLOUD_SELF = BIT(12),
        /* Bits 8-11: Reserved */
        /* Bits 0-7: Interface specific */
        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 {
        /*    Bit 16: 1 when packet is still encrypted
         *            0 when packet is decrypted
         * Bits 0-15: Total length of headers + data
         */
        uint16_t len_encrypted;
        /* Received packet signal strength (0 - val) */
        uint8_t rssi;
        /* Value from `EPACKET_INTERFACE_*` */
        uint8_t interface;
} __packed;

struct epacket_received_decrypted_header {
        /* Device ID in the packet */
        uint64_t device_id;
        /* GPS time in the packet */
        uint32_t gps_time;
        /* Packet type */
        uint8_t type;
        /* Packet flags */
        uint16_t flags;
        /* Sequence number */
        uint16_t sequence;
        /* ID associated with the key */
        uint8_t key_id[3];
} __packed;

struct epacket_forward_header {
        /* Total length of this header + payload */
        uint16_t length;
        /* Value from `EPACKET_INTERFACE_*` */
        uint8_t interface;
        /* Destination interface address + packet bytes */
        uint8_t destination_payload[];
} __packed;
 
enum epacket_forward_auto_conn_flags {
        /* Automatically disconnect on the first received INFUSE_RPC_RSP */
        EPACKET_FORWARD_AUTO_CONN_SINGLE_RPC = BIT(0),
        /* Subscribe to data while connected */
        EPACKET_FORWARD_AUTO_CONN_SUB_DATA = BIT(1),
        /* Send a INFUSE_EPACKET_CONN_TERMINATED on connection terminated */
        EPACKET_FORWARD_AUTO_CONN_DC_NOTIFICATION = BIT(2),
        /* Prioritise uplink throughput to the connection associated with this request */
        EPACKET_FORWARD_AUTO_CONN_PRIORITISE_UPLINK = BIT(3),
} __packed;

struct epacket_forward_auto_conn_header {
        /* Total length of this header + payload */
        uint16_t length;
        /* Value from `EPACKET_INTERFACE_*` */
        uint8_t interface;
        /* Value from `EPACKET_FORWARD_AUTO_CONN_` */
        uint8_t flags;
        /* Connection timeout (seconds) */
        uint8_t conn_timeout;
        /* Connection idle timeout (seconds) */
        uint8_t conn_idle_timeout;
        /* Unconditional connection timeout (seconds) */
        uint8_t conn_absolute_timeout;
        /* Destination interface address + packet bytes */
        uint8_t destination_payload[];
} __packed;

struct epacket_conn_terminated {
        /* Value from `EPACKET_INTERFACE_*` */
        uint8_t interface;
        /* Reason that interface disconnected */
        int16_t reason;
        /* Interface address that disconnected */
        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 (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_ */