pktlab.h

Go to the documentation of this file.

// pktlab.h
// General utilities for pktlab.
//
 
#ifndef _PKTLAB_H_
#define _PKTLAB_H_
 
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <time.h>
 
#include <arpa/inet.h>
#include <sys/time.h>
#include <sys/uio.h>
 
//
// GENERAL CONSTANTS
//
 
#define PKTLAB_IP4_ADDR_LEN PKTLAB_IPV4_WO_MSK_ADDR_LEN
#define PKTLAB_IP4_MASK_LEN \
    (PKTLAB_IPV4_W_MSK_ADDR_LEN-PKTLAB_IPV4_W_MSK_ADDR_LEN)
#define PKTLAB_IP6_ADDR_LEN PKTLAB_IPV6_ADDR_LEN
 
#define PKTLAB_IPV4_W_MSK_ADDR_LEN 8
#define PKTLAB_IPV4_WO_MSK_ADDR_LEN 4
#define PKTLAB_IPV6_ADDR_LEN 16
 
#define PKTLAB_ADDRLEN_MAX PKTLAB_IP6_ADDR_LEN
#define PKTLAB_PORTLEN_MAX 2
 
#define PKTLAB_DEFAULT_ADDR_STR "127.0.0.1"
 
#define PKTLAB_DEFAULT_EXP_PORT_STR "20556"
 
#define PKTLAB_DEFAULT_PUB_PORT_STR "20556"
 
#define PKTLAB_DEFAULT_SUB_PORT_STR "20557"
 
#define PKTLAB_DEFAULT_PROXY_SETUP_PORT_STR "20557"
 
#define PKTLAB_DEFAULT_SPEC_STR \
    PKTLAB_DEFAULT_ADDR_STR ":" PKTLAB_DEFAULT_EXP_PORT_STR
 
#define PKTLAB_MAX_SKT_CNT      0x100
 
#define PKTLAB_MAX_LADDR_CNT    0x100
 
#define PKTLAB_MAX_LDNSADDR_CNT 0x10
 
#define PKTLAB_SHA256_DIGEST_LEN   32
#define PKTLAB_ED25519_SIG_LEN     64
 
//
// TIME-RELATED DECLARATIONS & DEFINITIONS
//
 
typedef uint64_t pktlab_time_t;
 
#define PKTLAB_TICKS_PER_SECOND UINT64_C(1000000000)
#define PKTLAB_TIME_MAX         UINT64_MAX
 
extern pktlab_time_t pktlab_time_now(void);
 
static inline pktlab_time_t pktlab_time_sec(uint_fast32_t sec);
 
static inline pktlab_time_t pktlab_timeval_to_time(const struct timeval * tv);
 
static inline pktlab_time_t pktlab_timespec_to_time(const struct timespec * tp);
 
static inline void pktlab_time_to_timeval(pktlab_time_t t, struct timeval * tv);
 
static inline void pktlab_time_to_timespec(pktlab_time_t t, struct timespec * tp);
 
static inline uint_fast32_t pktlab_time_to_unix_time(pktlab_time_t t);
 
extern pktlab_time_t pktlab_tm_to_time(const struct tm * tm);
 
//
// XDESCR/DATTR-RELATED DECLARATIONS & DEFINITIONS
//
 
#define PKTLAB_NAMEVALUE_PAIR_SEP      '='
#define PKTLAB_NAMEVALUE_PAIR_END      ';'
 
#define PKTLAB_NAMEVALUE_NAMELEN_MIN   0x1
 
#define PKTLAB_NAMEVALUE_NAMELEN_MAX   0x20
 
#define PKTLAB_NAMEVALUE_VALUELEN_MIN  0x1
 
#define PKTLAB_NAMEVALUE_VALUELEN_MAX  0x100
 
struct pktlab_namevalue_pair {
    const char * name;
    const char * value;
    uint_fast32_t namelen;
    uint_fast32_t valuelen;
};
 
struct pktlab_aux_field {
    struct pktlab_namevalue_pair pair;
    bool optional;
};
 
extern int pktlab_decode_xdescr (
    const char * xdescr, uint_fast32_t xdescrlen,
    struct pktlab_namevalue_pair ** pairs, uint_fast32_t * paircnt);
extern int pktlab_encode_xdescr (
    const struct pktlab_namevalue_pair * pairs, uint_fast32_t paircnt,
    char * buf, uint_fast32_t buflen, uint_fast32_t * used);
 
extern int pktlab_decode_dattr (
    const char * dattr, uint_fast32_t dattrlen,
    struct pktlab_namevalue_pair ** pairs, uint_fast32_t * paircnt);
extern int pktlab_encode_dattr (
    const struct pktlab_namevalue_pair * pairs, uint_fast32_t paircnt,
    char * buf, uint_fast32_t buflen, uint_fast32_t * used);
 
extern bool pktlab_xdescr_dattr_match (
    const char * xdescr, uint_fast32_t xdescrlen,
    const char * dattr, uint_fast32_t dattrlen);
 
//
// CHANNEL-RELATED DECLARATIONS & DEFINITIONS
//
 
#define PKTLAB_CHANNELID_LEN_MIN 1
#define PKTLAB_CHANNELID_LEN_MAX PKTLAB_SHA256_DIGEST_LEN
 
struct pktlab_channel {
    void * channel;
    uint_fast32_t channellen;
    struct pktlab_channel * next;
};
 
extern int pktlab_encode_chlist (
    const struct pktlab_channel * channels,
    void ** chlistptr, uint_fast32_t * chlistlen);
extern int pktlab_decode_chlist (
    const void * chlistptr, uint_fast32_t chlistlen,
    struct pktlab_channel ** channels);
 
extern void pktlab_free_channels (
    struct pktlab_channel * channels);
 
//
// PROGRAM-RELATED DECLARATIONS & DEFINITIONS
//
 
enum pktlab_prog_type {
    PKTLAB_EBPF = 0x0,  
    PKTLAB_WASM = 0x1,  
};
 
struct pktlab_ebpf_instr {
    uint8_t  opcode;     
    uint8_t  dstreg:4;   
    uint8_t  srcreg:4;   
    uint16_t offset;     
    uint32_t imm;        
};
 
#define PKTLAB_EBPF_INSTR_LEN sizeof(struct pktlab_ebpf_instr)
 
#define PKTLAB_ENC_EBPF_INSTR_LEN 8
 
extern int pktlab_encode_program (
    enum pktlab_prog_type type,
    const void * prog, uint_fast32_t proglen,
    void ** buf, uint_fast32_t * buflen);
 
extern int pktlab_decode_program (
    const void * buf, uint_fast32_t buflen,
    enum pktlab_prog_type * type,
    void ** prog, uint_fast32_t * proglen);
 
extern int pktlab_get_program_digest (
    const void * data, uint_fast32_t datalen, uint8_t * digest);
 
extern int pktlab_load_program (
    const char * data, uint_fast32_t datalen,
    enum pktlab_prog_type type,
    void ** prog, uint_fast32_t * proglen,
    uint_fast32_t * errlineno);
 
//
// URI-RELATED DECLARATIONS & DEFINITIONS
//
 
enum pktlab_uri_type {
    EXP_URI_TYPE       = 0,   
    BROKER_URI_TYPE    = 1,   
    MALFORMED_URI_TYPE = -1,  
};
 
struct pktlab_uri {
    enum pktlab_uri_type type;      
    union {
        struct {
            const char * ptr;
            uint_fast32_t len;
        } malformed;                
        struct {
            const char * host;
            uint_fast32_t hostlen;
            uint16_t port;
        } uri;                      
    };
};
 
extern int pktlab_parse_uri (
    struct pktlab_uri * restrict uri_info,
    const void * restrict ptr, uint_fast32_t len);
 
//
// ENDPOINT-VMEM-RELATED DECLARATIONS & DEFINITIONS
//
 
// endpoint vmem field address/len macros
//
 
// current pkt
#define PKTLAB_VMEMADDR_CURPKT                  (0x0)
#define PKTLAB_VMEMADDR_CURPKT_DATA             (PKTLAB_VMEMADDR_CURPKT)
#define PKTLAB_VMEMADDR_CURPKT_LEN              (PKTLAB_VMEMADDR_CURPKT+0x1000000)
#define PKTLAB_VMEMADDR_CURPKT_SKTID            (PKTLAB_VMEMADDR_CURPKT+0x1000010)
 
#define PKTLAB_VMEMADDR_CURPKT_SL               (0x1000011)
#define PKTLAB_VMEMADDR_CURPKT_DATA_FL          (sizeof(uint8_t)*0x1000000)
#define PKTLAB_VMEMADDR_CURPKT_LEN_FL           (sizeof(uint32_t))
#define PKTLAB_VMEMADDR_CURPKT_SKTID_FL         (sizeof(uint8_t))
 
// system param
#define PKTLAB_VMEMADDR_SYSPARAM                (0x10000000)
#define PKTLAB_VMEMADDR_SYSPARAM_IP4NO          (PKTLAB_VMEMADDR_SYSPARAM)
#define PKTLAB_VMEMADDR_SYSPARAM_IP6NO          (PKTLAB_VMEMADDR_SYSPARAM+0x1)
#define PKTLAB_VMEMADDR_SYSPARAM_TRANSSUP       (PKTLAB_VMEMADDR_SYSPARAM+0x2)
#define PKTLAB_VMEMADDR_SYSPARAM_BUFMAXDUP      (PKTLAB_VMEMADDR_SYSPARAM+0x6)
#define PKTLAB_VMEMADDR_SYSPARAM_IP4LS          (PKTLAB_VMEMADDR_SYSPARAM+0x100)
#define PKTLAB_VMEMADDR_SYSPARAM_IP6LS          (PKTLAB_VMEMADDR_SYSPARAM+0x1000)
#define PKTLAB_VMEMADDR_SYSPARAM_TIME           (PKTLAB_VMEMADDR_SYSPARAM+0x10000)
#define PKTLAB_VMEMADDR_SYSPARAM_BUFMAX         (PKTLAB_VMEMADDR_SYSPARAM+0x10010)
#define PKTLAB_VMEMADDR_SYSPARAM_BUFUSED        (PKTLAB_VMEMADDR_SYSPARAM+0x10014)
#define PKTLAB_VMEMADDR_SYSPARAM_IP4DNSNO       (PKTLAB_VMEMADDR_SYSPARAM+0x20000)
#define PKTLAB_VMEMADDR_SYSPARAM_IP6DNSNO       (PKTLAB_VMEMADDR_SYSPARAM+0x20001)
#define PKTLAB_VMEMADDR_SYSPARAM_IP4DNSLS       (PKTLAB_VMEMADDR_SYSPARAM+0x20010)
#define PKTLAB_VMEMADDR_SYSPARAM_IP6DNSLS       (PKTLAB_VMEMADDR_SYSPARAM+0x20100)
#define PKTLAB_VMEMADDR_SYSPARAM_IP4HDRMOD      (PKTLAB_VMEMADDR_SYSPARAM+0x20200)
#define PKTLAB_VMEMADDR_SYSPARAM_IP6HDRMOD      (PKTLAB_VMEMADDR_SYSPARAM+0x20210)
#define PKTLAB_VMEMADDR_SYSPARAM_HOSTID         (PKTLAB_VMEMADDR_SYSPARAM+0x30000)
#define PKTLAB_VMEMADDR_SYSPARAM_LATLONG        (PKTLAB_VMEMADDR_SYSPARAM+0x30100)
#define PKTLAB_VMEMADDR_SYSPARAM_OSINFO         (PKTLAB_VMEMADDR_SYSPARAM+0x30200)
 
#define PKTLAB_VMEMADDR_SYSPARAM_SL             (0x30400)
#define PKTLAB_VMEMADDR_SYSPARAM_IP4NO_FL       (sizeof(uint8_t))
#define PKTLAB_VMEMADDR_SYSPARAM_IP6NO_FL       (sizeof(uint8_t))
#define PKTLAB_VMEMADDR_SYSPARAM_TRANSSUP_FL    (sizeof(uint32_t))
#define PKTLAB_VMEMADDR_SYSPARAM_IP4LS_FL       (sizeof(uint8_t)*PKTLAB_IPV4_W_MSK_ADDR_LEN*0x100)
#define PKTLAB_VMEMADDR_SYSPARAM_IP6LS_FL       (sizeof(uint8_t)*PKTLAB_IPV6_ADDR_LEN*0x100)
#define PKTLAB_VMEMADDR_SYSPARAM_TIME_FL        (sizeof(pktlab_time_t))
#define PKTLAB_VMEMADDR_SYSPARAM_BUFMAX_FL      (sizeof(uint32_t))
#define PKTLAB_VMEMADDR_SYSPARAM_BUFUSED_FL     (sizeof(uint32_t))
#define PKTLAB_VMEMADDR_SYSPARAM_IP4DNSNO_FL    (sizeof(uint8_t))
#define PKTLAB_VMEMADDR_SYSPARAM_IP6DNSNO_FL    (sizeof(uint8_t))
#define PKTLAB_VMEMADDR_SYSPARAM_IP4DNSLS_FL    (sizeof(uint8_t)*PKTLAB_IPV4_WO_MSK_ADDR_LEN*0x10)
#define PKTLAB_VMEMADDR_SYSPARAM_IP6DNSLS_FL    (sizeof(uint8_t)*PKTLAB_IPV6_ADDR_LEN*0x10)
#define PKTLAB_VMEMADDR_SYSPARAM_IP4HDRMOD_FL   (sizeof(uint8_t)*0xC)
#define PKTLAB_VMEMADDR_SYSPARAM_IP6HDRMOD_FL   (sizeof(uint8_t)*0x8)
#define PKTLAB_VMEMADDR_SYSPARAM_HOSTID_FL      (sizeof(char)*0x100)
#define PKTLAB_VMEMADDR_SYSPARAM_LATLONG_FL     (sizeof(char)*0x40)
#define PKTLAB_VMEMADDR_SYSPARAM_OSINFO_FL      (sizeof(char)*0x200)
 
// skt info
#define PKTLAB_VMEMADDR_SKTINFO                 (0x20000000)
#define PKTLAB_VMEMADDR_SKTINFO_BLKLEN          (0x400)
#define PKTLAB_VMEMADDR_SKTINFO_FAMILY          (0x0)
#define PKTLAB_VMEMADDR_SKTINFO_PROTO           (0x1)
#define PKTLAB_VMEMADDR_SKTINFO_STAT            (0x2)
#define PKTLAB_VMEMADDR_SKTINFO_LADDR           (0x10)
#define PKTLAB_VMEMADDR_SKTINFO_RADDR           (0x20)
#define PKTLAB_VMEMADDR_SKTINFO_LPORT           (0x30)
#define PKTLAB_VMEMADDR_SKTINFO_RPORT           (0x32)
#define PKTLAB_VMEMADDR_SKTINFO_RBUFSZ          (0x40)
#define PKTLAB_VMEMADDR_SKTINFO_RBUFUSED        (0x44)
#define PKTLAB_VMEMADDR_SKTINFO_DROPSTAT        (0x50)
#define PKTLAB_VMEMADDR_SKTINFO_NSENDERR        (0x60)
#define PKTLAB_VMEMADDR_SKTINFO_NSENDERRTAG     (0x61)
#define PKTLAB_VMEMADDR_SKTINFO_NOTIFMASK       (0x70)
#define PKTLAB_VMEMADDR_SKTINFO_CTFL            (0x100)
 
#define PKTLAB_VMEMADDR_SKTINFO_SL              (PKTLAB_VMEMADDR_SKTINFO_BLKLEN*0x100)
#define PKTLAB_VMEMADDR_SKTINFO_PROTO_FL        (sizeof(uint8_t))
#define PKTLAB_VMEMADDR_SKTINFO_STAT_FL         (sizeof(int8_t))
#define PKTLAB_VMEMADDR_SKTINFO_LADDR_FL        (sizeof(uint8_t)*PKTLAB_ADDRLEN_MAX)
#define PKTLAB_VMEMADDR_SKTINFO_RADDR_FL        (sizeof(uint8_t)*PKTLAB_ADDRLEN_MAX)
#define PKTLAB_VMEMADDR_SKTINFO_LPORT_FL        (sizeof(uint16_t))
#define PKTLAB_VMEMADDR_SKTINFO_RPORT_FL        (sizeof(uint16_t))
#define PKTLAB_VMEMADDR_SKTINFO_RBUFSZ_FL       (sizeof(uint32_t))
#define PKTLAB_VMEMADDR_SKTINFO_RBUFUSED_FL     (sizeof(uint32_t))
#define PKTLAB_VMEMADDR_SKTINFO_DROPSTAT_FL     (sizeof(uint32_t)*2)
#define PKTLAB_VMEMADDR_SKTINFO_NSENDERR_FL     (sizeof(int8_t))
#define PKTLAB_VMEMADDR_SKTINFO_NSENDERRTAG_FL  (sizeof(uint16_t))
#define PKTLAB_VMEMADDR_SKTINFO_NOTIFMASK_FL    (sizeof(uint16_t))
#define PKTLAB_VMEMADDR_SKTINFO_CTFL_FL         (sizeof(uint8_t)*0x80)
 
// other segments
#define PKTLAB_VMEMADDR_NSENDTSTP               (0x30000000)
#define PKTLAB_VMEMADDR_MONSCRATCH              (0x40000000)
#define PKTLAB_VMEMADDR_MONPERSIST              (0x50000000)
 
#define PKTLAB_VMEMADDR_NSENDTSTP_SL            (sizeof(pktlab_time_t)*0x10000)
#define PKTLAB_VMEMADDR_MONSCRATCH_SL           (sizeof(uint8_t)*0x10000000)
#define PKTLAB_VMEMADDR_MONPERSIST_SL           (sizeof(uint8_t)*0x10000000)
 
// endpoint supported (trans)proto field (TRANSSUP) proto bit indices
//
 
#define PKTLAB_RAW_SUP_BIT_INDX 0
#define PKTLAB_TCP_SUP_BIT_INDX 1
#define PKTLAB_UDP_SUP_BIT_INDX 2
 
// endpoint raw socket pkts OS header field modification behavior (IP4HDRMOD/IP6HDRMOD) values
//
 
enum pktlab_rawhdr_info {
    PKTLAB_RAWHDR_NOCHG     = 0,
    PKTLAB_RAWHDR_CHG       = 1,
    PKTLAB_RAWHDR_0FILL     = 2
};
 
// endpoint skt info skt state field (STAT) values
//
 
enum pktlab_socket_state {
    PKTLAB_SKTST_FREE        = 0,
    PKTLAB_SKTST_OPENING     = 1,
    PKTLAB_SKTST_OPEN        = 2,
    PKTLAB_SKTST_EOF         = 3,
    PKTLAB_SKTST_WFIN        = 4,
    PKTLAB_SKTST_END         = 5,
    PKTLAB_SKTST_REFUSED     = -1,
    PKTLAB_SKTST_RESET       = -2,
    PKTLAB_SKTST_TIMEDOUT    = -3,
    PKTLAB_SKTST_UNREACH     = -4,
    PKTLAB_SKTST_UNKFAULT    = -128
};
 
// endpoint skt info skt nsend err field (NSENDERR) values
//
 
enum pktlab_nsend_err {
    PKTLAB_NSEND_SUCCESS    = 0,
    PKTLAB_NSEND_NORES      = 1,
    PKTLAB_NSEND_BADPKT     = 2,
    PKTLAB_NSEND_TIMEDOUT   = 3,
    PKTLAB_NSEND_RESET      = 4,
    PKTLAB_NSEND_UNREACH    = 5,
    PKTLAB_NSEND_WFIN       = 6,
    PKTLAB_NSEND_UNKFAULT   = 127
};
 
// endpoint skt info skt notification mask (NOTIFMASK) indices
//
 
#define PKTLAB_NOTIFMASK_NTAG    (0x1 << 1)
#define PKTLAB_NOTIFMASK_NSTAT   (0x1 << 2)
#define PKTLAB_NOTIFMASK_NDATA   (0x1 << 3)
#define PKTLAB_NOTIFMASK_NDROP   (0x1 << 4)
#define PKTLAB_NOTIFMASK_NBLOCK  (0x1 << 5)
 
// endpoint vmem impl. utilities
//
 
struct pktlab_vmem_region; // forward declaration
 
typedef void (*pktlab_vmem_reader_t) (
    const struct pktlab_vmem_region * restrict rgn,
    uint_fast32_t off, uint_fast32_t len, void * restrict dst);
 
typedef void (*pktlab_vmem_writer_t) (
    const struct pktlab_vmem_region * restrict rgn,
    uint_fast32_t off, uint_fast32_t len, const void * restrict src);
 
struct pktlab_vmem_region {
    uint32_t start, end;
    pktlab_vmem_reader_t read;
    pktlab_vmem_writer_t write;
    uintptr_t aux;
};
 
extern void pktlab_vmem_read (
    const struct pktlab_vmem_region * restrict rgn, uint_fast32_t rgncnt,
    uint_fast32_t addr, uint_fast32_t len, void * restrict dst);
 
extern void pktlab_vmem_write (
    const struct pktlab_vmem_region * restrict rgn, uint_fast32_t rgncnt,
    uint_fast32_t addr, uint_fast32_t len, const void * restrict src);
 
extern void pktlab_buffer_reader (
    const struct pktlab_vmem_region * restrict rgn,
    uint_fast32_t addr, uint_fast32_t len, void * restrict dst);
 
extern void pktlab_buffer_writer (
    const struct pktlab_vmem_region * restrict rgn,
    uint_fast32_t addr, uint_fast32_t len, const void * restrict src);
 
//
// MESSAGE-RELATED DECLARATIONS & DEFINITIONS
//
 
// message length restriction values
//
 
#define PKTLAB_MREAD_MAX            UINT32_C(0x10000)
#define PKTLAB_NDATA_MAX            UINT32_C(0x10000)
 
// message family and proto constants
//
 
#define PKTLAB_IP4_PROTO            0x4
#define PKTLAB_IP6_PROTO            0x6
 
#define PKTLAB_RAW_PROTO            0x00
#define PKTLAB_TCP_PROTO            0x06
#define PKTLAB_UDP_PROTO            0x11
 
// nctl command type
//
 
#define PKTLAB_NCTL_TCP_FIN         0x1
 
// nstat code values
//
 
#define PKTLAB_TCPEV_ESTABLISHED    0x0
#define PKTLAB_TCPEV_RESET          0x1
#define PKTLAB_TCPEV_TIMEOUT        0x2
#define PKTLAB_TCPEV_PEERCLOSED     0x3
#define PKTLAB_TCPEV_UNKNOWN        0xFF
 
// message type values
//
 
enum pktlab_message_type {
    PKTLAB_UNDEF_MESSAGE        = 0x00,
 
    // Requests 0x20 - 0x3F
    PKTLAB_CDATA_MESSAGE        = 0x20,
    PKTLAB_START_MESSAGE        = 0x21,
    PKTLAB_END_MESSAGE          = 0x22,
    PKTLAB_YIELD_MESSAGE        = 0X23,
    PKTLAB_CONT_MESSAGE         = 0X24,
 
    PKTLAB_MREAD_MESSAGE        = 0x28,
    PKTLAB_MWRITE_MESSAGE       = 0x29,
    PKTLAB_NOPEN_MESSAGE        = 0x2A,
    PKTLAB_NCLOSE_MESSAGE       = 0x2B,
    PKTLAB_NSEND_MESSAGE        = 0x2C,
    PKTLAB_NCAP_MESSAGE         = 0x2D,
    PKTLAB_NCTL_MESSAGE         = 0x2E,
 
    // publisher to broker request
    PKTLAB_XCERT_MESSAGE        = 0x30,
    PKTLAB_XPUB_MESSAGE         = 0x31,
 
    // endpoint to broker request
    PKTLAB_XSUB_MESSAGE         = 0x38,
 
    // Responses 0x40 - 0x5F
    PKTLAB_RESULT_MESSAGE       = 0x40,
    PKTLAB_MDATA_MESSAGE        = 0x41,
 
    // Notifications 0x60 - 0x7F
    PKTLAB_NTAG_MESSAGE         = 0x60,
    PKTLAB_NSTAT_MESSAGE        = 0x61,
    PKTLAB_NDATA_MESSAGE        = 0x62,
    PKTLAB_NDROP_MESSAGE        = 0x63,
    PKTLAB_NBLOCK_MESSAGE       = 0x64,
 
    PKTLAB_SUSPD_MESSAGE        = 0x68,
    PKTLAB_RESUMD_MESSAGE       = 0x69,
 
    PKTLAB_XNOTIFY_MESSAGE      = 0x70,
 
    // Proxy requests 0x80 - 0x8F
    PKTLAB_XREG_MESSAGE         = 0x80,
 
    // Private Use 0x90 - 0xff
};
 
// result message errid values
//
 
enum pktlab_status {
    PKTLAB_SUCCESS          = 0,
 
    PKTLAB_ECTLBADMSG       = 0x10,
    PKTLAB_ECTLNOTSUP       = 0x11,
    PKTLAB_ECTLMONREJ       = 0x12,
    PKTLAB_ECTLMONUKN       = 0x13,
 
    PKTLAB_ECRTBADHDAT      = 0x20,
    PKTLAB_ECRTNOHDAT       = 0x21,
    PKTLAB_ECRTBADFRM       = 0x22,
    PKTLAB_ECRTNOSPACE      = 0x23,
    PKTLAB_ECRTBADHINT      = 0x24,
 
    PKTLAB_ESYSNOBUFS       = 0x30,
    PKTLAB_ESYSNOPERM       = 0x31,
    PKTLAB_ESKTINUSE        = 0x32,
    PKTLAB_ESKTNOTOPEN      = 0x33,
    PKTLAB_ESKTNOPRFAM      = 0x34,
    PKTLAB_ESKTNOPROTO      = 0x35,
    PKTLAB_ESKTNOADDR       = 0x36,
    PKTLAB_ESKTNOMATCH      = 0x37,
    PKTLAB_ESKTBADFILT      = 0x38,
    PKTLAB_ESKTPKTDENY      = 0x39,
    PKTLAB_ESKTOPNDENY      = 0x3A,
 
    PKTLAB_ETCPNOPORT       = 0x40,
    PKTLAB_EPKTNOTSENT      = 0x41,
    PKTLAB_EUDPNOPORT       = 0x42,
    PKTLAB_EPKTTRUNC        = 0x43,
    PKTLAB_ENORES           = 0x44,
 
    PKTLAB_EMEMBADADR       = 0x48,
 
    PKTLAB_EPUBBADCHL       = 0x50,
    PKTLAB_EPUBBADCHN       = 0x51,
    PKTLAB_EPUBBADADDR      = 0x52,
    PKTLAB_EPUBBADPR        = 0x53,
    PKTLAB_EPUBBADXD        = 0x54,
 
    PKTLAB_ESUBBADCHL       = 0x60,
    PKTLAB_ESUBBADCHN       = 0x61,
    PKTLAB_ESUBBADDA        = 0x62,
 
    PKTLAB_EUNKFAULT        = 0xFFFF
};
 
// cdata message hint values
//
 
#define PKTLAB_CDATA_HINT_FILTER       "filter"
#define PKTLAB_CDATA_HINT_MONITOR      "monitor"
 
// message value structure
//
 
struct pktlab_message {
    enum pktlab_message_type type;
 
    union {
        struct {
            const void * ptr;
            uint32_t len;
            bool malformed;
        } raw;
 
        struct {
            const void * hintptr;
            const void * dataptr;
            uint8_t hintlen;
            uint32_t datalen;
        } cdata;
 
        struct {
        } start;
 
        struct {
        } end;
 
        struct {
            pktlab_time_t rhint;
        } yield;
 
        struct {
        } cont;
 
        struct {
            uint16_t errid;
            union {
                struct {
                    uint16_t indx;
                    uint16_t errid;
                } monrej;
                struct {
                    uint16_t indx;
                } monukn;
            };
        } result;
 
        struct {
            uint32_t addr, len;
            const void * ptr;
        } mdata;
 
        struct {
            uint32_t addr, len;
        } mread;
 
        struct {
            uint32_t addr, len;
            const void * ptr;
        } mwrite;
 
        struct {
            uint8_t sktid;
            uint8_t family;
            uint8_t proto;
            uint32_t rbufsz;
 
            uint8_t laddrlen;
            uint8_t lportlen;
            uint8_t raddrlen;
            uint8_t rportlen;
            const void* laddrptr;
            const void* lportptr;
            const void* raddrptr;
            const void* rportptr;
        } nopen;
 
        struct {
            uint8_t sktid;
        } nclose;
 
        struct {
            uint8_t sktid;
            uint8_t family;
            uint8_t proto;
            pktlab_time_t time;
            uint16_t tag;
            union {
                struct {
                    uint8_t raddrlen;
                    const void* raddrptr;
                    uint8_t rportlen;
                    const void* rportptr;
                } udp;
            };
            uint32_t len;
            const void * ptr;
        } nsend;
 
        struct {
            uint8_t sktid;
            uint8_t family;
            uint8_t proto;
            pktlab_time_t endtime;
            const void * filter;
            uint32_t filterlen;
        } ncap;
 
        struct {
            uint8_t sktid;
            uint8_t family;
            uint8_t proto;
            pktlab_time_t time;
            union {
                struct {
                    uint8_t command;
                } tcp;
            };
        } nctl;
 
        struct {
            uint8_t sktid;
            uint16_t tag;
            pktlab_time_t time;
            uint16_t errid;
        } ntag;
 
        struct {
            uint8_t sktid;
            uint8_t family;
            uint8_t proto;
            pktlab_time_t time;
            uint8_t code;
            union {
                struct {
                    uint8_t raddrlen;
                    const void* raddrptr;
                    uint8_t rportlen;
                    const void* rportptr;
                } tcp_established;
            };
        } nstat;
 
        struct {
            uint8_t sktid;
            uint8_t family;
            uint8_t proto;
            pktlab_time_t time;
            union {
                struct {
                    uint8_t raddrlen;
                    const void* raddrptr;
                    uint8_t rportlen;
                    const void* rportptr;
                } udp;
            };
            const void * ptr;
            uint32_t len;
        } ndata;
 
        struct {
            uint8_t sktid;
            uint8_t family;
            uint8_t proto;
            pktlab_time_t tfirst, tlast;
            uint32_t unitcnt, bytecnt;
        } ndrop;
 
        struct {
            uint8_t sktid;
            uint8_t family;
            uint8_t proto;
            uint16_t monindx;
            uint16_t monerrid;
            pktlab_time_t time;
        } nblock;
 
        struct {
            const void * derptr;
            uint32_t derlen;
        } xcert;
 
        struct {
            const void * chlistptr;
            uint32_t chlistlen;
            const void * eopkey;
            const void * xdescrptr;
            uint32_t xdescrlen;
        } xpub;
 
        struct {
            const void * chlistptr;
            uint32_t chlistlen;
            const void * eopkey;
            const void * dattrptr;
            uint32_t dattrlen;
        } xsub;
 
        struct {
        } suspd;
 
        struct {
        } resumd;
 
        struct {
            const void * channelptr;
            uint8_t channellen;
            const void * xdescrptr;
            uint32_t xdescrlen;
        } xnotify;
 
        struct {
            const void * snikeyptr;
            uint32_t snikeylen;
        } xreg;
    };
};
 
// message encoding/decoding utilities
//
 
#define PKTLAB_HLEN          4
 
extern size_t pktlab_decode_message (
    struct pktlab_message * restrict msg,
    const void * restrict ptr, size_t len);
 
#define PKTLAB_ENCODE_IOVCNT 5
 
#define PKTLAB_ENCODE_BUFSZ  (PKTLAB_HLEN+32) // note: ndrop msg is 27 bytes long
 
extern int pktlab_encode_message (
    const struct pktlab_message * restrict msg,
    void * restrict buf, struct iovec * restrict iov);
 
// Functions of the form create_XXX_message create a message of the given
// type with the given parameters. They combine memory allocation and
// pktlab_message structure initialization into one call.
 
extern struct pktlab_message * pktlab_create_result_message(enum pktlab_status status);
 
extern struct pktlab_message * pktlab_create_monrej_result_message(uint16_t monindx, uint16_t monerrid);
 
extern struct pktlab_message * pktlab_create_monukn_result_message(uint16_t monindx);
 
//
// READER-RELATED DECLARATIONS & DEFINITIONS
//
 
struct pktlab_reader; // opaque
 
typedef ssize_t (*pktlab_read_t) (void * aux, void * buf, size_t buflen);
 
extern struct pktlab_reader * pktlab_create_reader(pktlab_read_t read, void * aux);
extern void pktlab_close_reader(struct pktlab_reader * r);
extern void * pktlab_reader_readaux(const struct pktlab_reader * r);
 
extern int pktlab_read_message (
    struct pktlab_reader * restrict r,
    struct pktlab_message ** restrict msgptr);
 
//
// WRITER-RELATED DECLARATIONS & DEFINITIONS
//
 
struct pktlab_writer; // opaque
 
typedef ssize_t (*pktlab_write_t) (void * aux, const void * buf, size_t nbyte);
 
extern struct pktlab_writer * pktlab_create_writer(pktlab_write_t write, void * aux);
extern void pktlab_close_writer(struct pktlab_writer * w);
extern int pktlab_flush_writer(struct pktlab_writer * w);
extern size_t pktlab_writer_unsent(const struct pktlab_writer * w);
 
extern void * pktlab_writer_writeaux(const struct pktlab_writer * w);
 
extern int pktlab_write_message (
    struct pktlab_writer * restrict w,
    const struct pktlab_message * restrict msg);
 
//
// MESSAGE-FORMATING FUNCTION DECLARATIONS
//
 
// TODO: formating support
// The pktlab_format_message function formats a message as an ASCII string.
// On entry, buf must be a pointer to a buffer of size bufsz and msg much
// be a valid message. On return, buf will contain up to bufsz bytes of the
// textual representation of the message. The string is terminating with a
// '\0' character (unless bufsz == 0). The number of characters that would
// be necessary to represent the message completely (excluding the
// terminaing '\0' character) is returned.
 
// extern int pktlab_format_message (
//  char * restrict buf, size_t bufsz,
//  const struct pktlab_message * restrict msg);
 
// extern int pktlab_parse_message (
//  const char * restrict str,
//  struct pktlab_message * restrict msg, void ** restrict data);
 
// extern int pktlab_print_message (
//  FILE * restrict file, const struct pktlab_message * restrict msg);
 
// extern int pktlab_scan_message (
//  FILE * restrict file,
//  struct pktlab_message * restrict msg, void ** restrict data);
 
// extern const char * pktlab_status_name(enum pktlab_status status);
// extern const char * pktlab_status_descr(enum pktlab_status status);
// extern const char * pktlab_msgtype_name(enum pktlab_message_type type);
 
extern const char * pktlab_sktstate_name(enum pktlab_socket_state state);
 
//
// KEY-RELATED DECLARATIONS & DEFINITIONS
//
 
#define PKTLAB_PUBLICKEY_LEN       32
 
#define PKTLAB_PRIVATEKEY_LEN      32
 
#define PKTLAB_KEYID_LEN           PKTLAB_SHA256_DIGEST_LEN
 
#define PKTLAB_SIGNATURE_LEN       PKTLAB_ED25519_SIG_LEN
 
struct pktlab_publickey;      // opaque
 
extern struct pktlab_publickey * pktlab_create_publickey(void);
extern int pktlab_load_publickey_pem (
    const char * pem, uint_fast32_t pemlen,
    struct pktlab_publickey * k);
extern int pktlab_load_publickey_der (
    const uint8_t * der, uint_fast32_t derlen,
    struct pktlab_publickey * k);
extern int pktlab_load_publickey_raw (
    const uint8_t * bytes, uint_fast32_t len,
    struct pktlab_publickey * k);
extern int pktlab_cleanup_publickey(struct pktlab_publickey * k);
extern int pktlab_get_publickey_bytes (
    const struct pktlab_publickey * k,
    void * buf, uint_fast32_t buflen);
 
extern int pktlab_get_key_identifier (
    const struct pktlab_publickey * k,
    void * buf, uint_fast32_t buflen);
 
struct pktlab_privatekey;     // opaque
 
extern struct pktlab_privatekey * pktlab_create_privatekey(void);
extern int pktlab_load_privatekey_pem (
    const char * pem, uint_fast32_t pemlen,
    const char * passphrase, struct pktlab_privatekey * k);
extern int pktlab_load_privatekey_der (
    const uint8_t * der, uint_fast32_t derlen,
    const char * passphrase, struct pktlab_privatekey * k);
extern int pktlab_load_privatekey_raw (
    const uint8_t * bytes, uint_fast32_t len,
    struct pktlab_privatekey * k);
extern int pktlab_cleanup_privatekey(struct pktlab_privatekey * k);
extern int pktlab_get_privatekey_bytes (
    const struct pktlab_privatekey * k,
    void * buf, uint_fast32_t buflen);
 
extern struct pktlab_publickey * pktlab_get_publickey_from_privatekey (
    const struct pktlab_privatekey * k);
 
//
// CERTIFICATE-RELATED DECLARATIONS & DEFINITIONS
//
 
enum pktlab_cert_type {
    PKTLAB_CERT_SUBCMD    = 0,
    PKTLAB_CERT_PUBCMD    = 1,
    PKTLAB_CERT_EXPPRIV   = 2,
    PKTLAB_CERT_DELPRIV   = 3,
    PKTLAB_CERT_AGENT     = 4,
    PKTLAB_CERT_UNKNOWN   = 127
};
 
enum pktlab_del_type {
    PKTLAB_DEL_TYPE_EXPPRIV    = 0x1,
    PKTLAB_DEL_TYPE_REPPRIV    = 0x2,
    PKTLAB_DEL_TYPE_NOT_PRSENT = 0x0,
};
 
#define PKTLAB_FILTER_DIGEST_LEN   PKTLAB_SHA256_DIGEST_LEN
#define PKTLAB_MONITOR_DIGEST_LEN  PKTLAB_SHA256_DIGEST_LEN
 
enum pktlab_decode_rst {
    PKTLAB_DECODE_SUCCESS              =  0,  
    PKTLAB_DECODE_INVAL                =  1,  
    PKTLAB_DECODE_BAD_SIGALG           =  2,  
    PKTLAB_DECODE_BAD_SIGNATURE        =  3,  
    PKTLAB_DECODE_BAD_X509_VER         =  4,  
    PKTLAB_DECODE_USING_UNUSED_FIELD   =  5,  
    PKTLAB_DECODE_BAD_CERT_TYPE        =  6,  
    PKTLAB_DECODE_BAD_KEYUSAGE         =  7,  
    PKTLAB_DECODE_BAD_SERIAL           =  8,  
    PKTLAB_DECODE_BAD_VALIDITY         =  9,  
    PKTLAB_DECODE_BAD_SUBJ_PUBKEY      = 10,  
    PKTLAB_DECODE_BAD_AID              = 11,  
    PKTLAB_DECODE_BAD_SID              = 12,  
    PKTLAB_DECODE_BAD_BC               = 13,  
    PKTLAB_DECODE_BAD_CERT_INFO        = 14,  
    PKTLAB_DECODE_BAD_CERT_LIMIT       = 15,  
    PKTLAB_DECODE_BAD_PRIORITY         = 16,  
    PKTLAB_DECODE_BAD_MONITOR_DIGESTS  = 17,  
    PKTLAB_DECODE_BAD_DEL_TYPE         = 18,  
    PKTLAB_DECODE_BAD_AUX_INFO         = 19,  
    PKTLAB_DECODE_BAD_CERT_DESC        = 20,  
    PKTLAB_DECODE_BAD_VALID_DEST       = 21,  
    PKTLAB_DECODE_BAD_SRC_IP_SPOOFING  = 22,  
    PKTLAB_DECODE_BAD_MAX_BURST_RATE   = 23,  
    PKTLAB_DECODE_UNKNOWN_FAULT        = 127  
};
 
struct pktlab_valid_dest {
    int prfam;
    uint8_t ip_address[PKTLAB_ADDRLEN_MAX];
    uint8_t network_mask[PKTLAB_ADDRLEN_MAX];
    struct pktlab_valid_dest * next;
};
 
struct pktlab_burst_rate {
    pktlab_time_t win;               // sliding time window (duration)
    uint64_t cnt;                    // maximum count in the time window
    struct pktlab_burst_rate * next; // next record in linked list
};
 
struct pktlab_decoded_certificate {
    uint8_t * serialno;
    uint32_t serialno_len;
 
    pktlab_time_t valid_not_before;
    pktlab_time_t valid_not_after;
 
    uint8_t publickey[PKTLAB_PUBLICKEY_LEN];
 
    uint8_t authority_key_id[PKTLAB_KEYID_LEN];
    uint8_t subject_key_id[PKTLAB_KEYID_LEN];
 
    int_fast32_t pathlen; // -1 for no restriction
 
    char * cert_info;
    char * cert_limit;
};
 
struct pktlab_cert_detail {
    uint8_t * serialno;
    uint32_t serialno_len;
 
    uint8_t authority_key_id[PKTLAB_KEYID_LEN];
 
    struct {
        enum pktlab_cert_type cert_type;
        enum pktlab_del_type del_type;
        char * cert_desc;
        struct pktlab_aux_field * aux_info;
        uint_fast32_t aux_info_count;
    } info;
    struct {
        uint8_t * monitor_digests;
        uint_fast32_t monitor_digests_count;
        uint64_t max_num_priority;
        bool max_num_priority_present;
        uint64_t max_socket_count;
        bool max_socket_count_present;
        uint64_t max_exp_period;
        bool max_exp_period_present;
        uint64_t max_send_byte;
        bool max_send_byte_present;
        uint64_t max_send_pkt;
        bool max_send_pkt_present;
        uint64_t max_recv_byte;
        bool max_recv_byte_present;
        uint64_t max_recv_pkt;
        bool max_recv_pkt_present;
        bool src_ip_spoofing;
        bool src_ip_spoofing_present;
        struct pktlab_burst_rate * max_burst_rate_byte;
        struct pktlab_burst_rate * max_burst_rate_pkt;
        struct pktlab_valid_dest * valid_dest;
        struct pktlab_aux_field * aux_limit;
        uint_fast32_t aux_limit_count;
    } limit;
    struct pktlab_cert_detail * next; // NULL if no more
};
 
// TODO: register OID with IANA at https://pen.iana.org/pen/PenApplication.page; also fix this
// pktlab extension OIDs
#define PKTLAB_EXT_CERT_INFO           "1.2.3.1"
#define PKTLAB_EXT_CERT_LIMIT          "1.2.3.3"
 
// pktlab certificate type string (present in cert)
#define PKTLAB_CERTTYPE_STR_SUBCMD     "subcmd"
#define PKTLAB_CERTTYPE_STR_PUBCMD     "pubcmd"
#define PKTLAB_CERTTYPE_STR_EXPPRIV    "exppriv"
#define PKTLAB_CERTTYPE_STR_DELPRIV    "delpriv"
#define PKTLAB_CERTTYPE_STR_AGENT      "agent"
#define PKTLAB_CERTTYPE_STR_UNKNOWN    "unknown"
 
// utilities for loading and decoding pktlab certificates
//
 
struct pktlab_certificate; // opaque
 
extern struct pktlab_certificate * pktlab_create_cert(void);
 
extern int pktlab_load_cert_pem (
    const char * pem, uint_fast32_t pemlen,
    struct pktlab_certificate * cert);
extern int pktlab_load_cert_der (
    const uint8_t * der, uint_fast32_t derlen,
    struct pktlab_certificate * cert);
extern int pktlab_get_cert_der (
    const struct pktlab_certificate * cert,
    void ** der, uint_fast32_t * derlen);
extern int pktlab_decode_certificate (
    const struct pktlab_certificate * cert,
    const struct pktlab_publickey * signkey,
    struct pktlab_decoded_certificate ** decoded_cert);
 
extern int pktlab_decode_cert_detail (
    const struct pktlab_certificate * cert,
    const struct pktlab_publickey * signkey,
    struct pktlab_cert_detail ** ptr);
 
extern int pktlab_decoded_cert_get_cert_type (
    const struct pktlab_decoded_certificate * decoded_cert,
    enum pktlab_cert_type * cert_type);
 
extern int pktlab_verify_certificate_signature (
    const struct pktlab_certificate * cert,
    const struct pktlab_publickey * signkey);
extern int pktlab_cleanup_cert(struct pktlab_certificate * cert);
 
extern int pktlab_cleanup_detail_ls(struct pktlab_cert_detail * head);
 
extern const char * pktlab_cert_type_name(int cert_type);
extern int pktlab_cert_type_name_to_id(const char * name);
 
extern int pktlab_get_agent_key (
    const struct pktlab_certificate * agent_cert,
    uint8_t * agent_pubkey);
 
// utilities for verifying pktlab certificate chains
//
 
enum pktlab_auth_mode {
    PKTLAB_CONTROLLER_AUTH_ENDPOINT  = 0,  
    PKTLAB_ENDPOINT_AUTH_CONTROLLER  = 1,  
    PKTLAB_AUTH_AGENT                = 2,  
    PKTLAB_NO_VERIFY                 = 127 
};
 
enum pktlab_verify_rst {
    PKTLAB_VERIFY_SUCCESS                  = 0,  
    PKTLAB_VERIFY_INVAL                    = 1,  
    PKTLAB_VERIFY_BAD_CERT                 = 2,  
    PKTLAB_VERIFY_NOT_ENOUGH_CERT          = 3,  
    PKTLAB_VERIFY_TOO_MANY_CERT            = 4,  
    PKTLAB_VERIFY_UNEXPECTED_CERT          = 5,  
    PKTLAB_VERIFY_EXPIRED_CERT             = 6,  
    PKTLAB_VERIFY_NO_MATCHING_SIGN_KEY     = 7,  
    PKTLAB_VERIFY_PATHLEN_EXCEEDED         = 8,  
    PKTLAB_VERIFY_END_OF_PHASES            = 9,  
    PKTLAB_VERIFY_BAD_DEL_TYPE             = 10, 
    PKTLAB_VERIFY_UNKNOWN_FAULT            = 127 
};
 
extern int pktlab_verify_cert_chain (
    int auth_mode,
    struct pktlab_certificate ** cert_ls,
    struct pktlab_publickey ** root_ls,
    struct pktlab_certificate *** verified_cert_ls,
    uint_fast32_t certnum,
    uint_fast32_t rootnum,
    uint_fast32_t * verified_certnum,
    uint_fast32_t * used_root_indx);
 
// utilities for extracting setup info from cert chain
//
 
enum pktlab_parse_cert_chain_rst {
    PKTLAB_PARSE_CHAIN_SUCCESS        = 0,
    PKTLAB_PARSE_CHAIN_INVAL          = 1,
    PKTLAB_PARSE_CHAIN_BAD_CHAIN      = 2,
    PKTLAB_PARSE_CHAIN_BAD_KEY        = 3,
    PKTLAB_PARSE_CHAIN_UNKNOWN_FAULT  = 127,
};
 
extern int pktlab_parse_endpoint_rep_cert_chain (
    struct pktlab_certificate ** cert_ls,
    uint_fast32_t certnum, const uint8_t * endpoint_key,
    struct pktlab_publickey * root_eop_key,
    uint8_t ** subable_channels, uint_fast32_t * channelnum);
 
extern int pktlab_parse_controller_exp_cert_chain (
    struct pktlab_certificate ** cert_ls,
    uint_fast32_t certnum,
    const uint8_t * controller_key,
    struct pktlab_publickey * trusted_eop_key,
    struct pktlab_cert_detail ** cert_details,
    uint8_t * subable_channel);
 
//
// BYTE/ADDRESS INVARIANT MEMORY ACCESS FUNCTION DECLARATIONS
//
 
static inline uint_fast8_t pktlab_get8(const void * ptr);
static inline uint_fast16_t pktlab_get16b(const void * ptr);
static inline uint_fast16_t pktlab_get16l(const void * ptr);
static inline uint_fast32_t pktlab_get24b(const void * ptr);
static inline uint_fast32_t pktlab_get24l(const void * ptr);
static inline uint_fast32_t pktlab_get32b(const void * ptr);
static inline uint_fast32_t pktlab_get32l(const void * ptr);
static inline uint_fast64_t pktlab_get64b(const void * ptr);
static inline uint_fast64_t pktlab_get64l(const void * ptr);
 
#define pktlab_get16n pktlab_get16b
#define pktlab_get24n pktlab_get24b
#define pktlab_get32n pktlab_get32b
#define pktlab_get64n pktlab_get64b
 
static inline void pktlab_set8(void * ptr, uint_fast8_t val);
static inline void pktlab_set16b(void * ptr, uint_fast16_t val);
static inline void pktlab_set16l(void * ptr, uint_fast16_t val);
static inline void pktlab_set24b(void * ptr, uint_fast32_t val);
static inline void pktlab_set24l(void * ptr, uint_fast32_t val);
static inline void pktlab_set32b(void * ptr, uint_fast32_t val);
static inline void pktlab_set32l(void * ptr, uint_fast32_t val);
static inline void pktlab_set64b(void * ptr, uint_fast64_t val);
static inline void pktlab_set64l(void * ptr, uint_fast64_t val);
 
#define pktlab_set16n pktlab_set16b
#define pktlab_set24n pktlab_set24b
#define pktlab_set32n pktlab_set32b
#define pktlab_set64n pktlab_set64b
 
//
// BYTE ORDER CONVERSION FUNCTION DECLARATIONS
//
 
static inline uint_fast16_t pktlab_hton16(uint_fast16_t x);
static inline uint_fast32_t pktlab_hton32(uint_fast32_t x);
static inline uint_fast64_t pktlab_hton64(uint_fast64_t x);
static inline uint_fast16_t pktlab_ntoh16(uint_fast16_t x);
static inline uint_fast32_t pktlab_ntoh32(uint_fast32_t x);
static inline uint_fast64_t pktlab_ntoh64(uint_fast64_t x);
 
//
// BIT ACCESS FUNCTION DECLARATIONS
//
 
static inline bool pktlab_getbit8(uint_fast8_t bits, uint_fast8_t pos);
static inline bool pktlab_getbit16(uint_fast16_t bits, uint_fast8_t pos);
static inline bool pktlab_getbit32(uint_fast32_t bits, uint_fast8_t pos);
static inline bool pktlab_getbit64(uint_fast64_t bits, uint_fast8_t pos);
 
static inline uint_fast8_t pktlab_setbit8(uint_fast8_t bits, uint_fast8_t pos);
static inline uint_fast16_t pktlab_setbit16(uint_fast16_t bits, uint_fast8_t pos);
static inline uint_fast32_t pktlab_setbit32(uint_fast32_t bits, uint_fast8_t pos);
static inline uint_fast64_t pktlab_setbit64(uint_fast64_t bits, uint_fast8_t pos);
 
static inline uint_fast8_t pktlab_clrbit8(uint_fast8_t bits, uint_fast8_t pos);
static inline uint_fast16_t pktlab_clrbit16(uint_fast16_t bits, uint_fast8_t pos);
static inline uint_fast32_t pktlab_clrbit32(uint_fast32_t bits, uint_fast8_t pos);
static inline uint_fast64_t pktlab_clrbit64(uint_fast64_t bits, uint_fast8_t pos);
 
//
// INLINE FUNCTION DEFINITIONS
//
 
static inline pktlab_time_t pktlab_time_sec(uint_fast32_t sec) {
    return (uint64_t) sec * PKTLAB_TICKS_PER_SECOND;
}
 
static inline pktlab_time_t pktlab_timeval_to_time(const struct timeval * tv) {
    return (uint64_t) tv->tv_sec * PKTLAB_TICKS_PER_SECOND
        + (uint64_t) tv->tv_usec * PKTLAB_TICKS_PER_SECOND / 1000000;
}
 
static inline pktlab_time_t pktlab_timespec_to_time(const struct timespec * tp) {
    return (uint64_t) tp->tv_sec * PKTLAB_TICKS_PER_SECOND + (uint64_t) tp->tv_nsec;
}
 
static inline void pktlab_time_to_timeval (
    pktlab_time_t t, struct timeval * tv)
{
    const uint64_t t_us = t / (PKTLAB_TICKS_PER_SECOND / 1000000);
    tv->tv_sec = t_us / 1000000;
    tv->tv_usec = t_us % 1000000;
}
 
static inline void pktlab_time_to_timespec (
    pktlab_time_t t, struct timespec * tp)
{
    tp->tv_sec = t / PKTLAB_TICKS_PER_SECOND;
    tp->tv_nsec = t % PKTLAB_TICKS_PER_SECOND;
}
 
static inline uint_fast32_t pktlab_time_to_unix_time(pktlab_time_t t) {
    return t / PKTLAB_TICKS_PER_SECOND;
}
 
static inline uint_fast8_t pktlab_get8(const void * ptr) {
    return *(const uint8_t*)ptr;
}
 
static inline uint_fast16_t pktlab_get16b(const void * ptr) {
    const uint8_t * u8ptr = ptr;
    uint_fast16_t val;
 
    val = (uint_fast16_t) u8ptr[0] << 8;
    val |= u8ptr[1];
    return val;
}
 
static inline uint_fast16_t pktlab_get16l(const void * ptr) {
    const uint8_t * u8ptr = ptr;
    uint_fast16_t val;
 
    val = (uint_fast16_t) u8ptr[1] << 8;
    val |= u8ptr[0];
    return val;
}
 
static inline uint_fast32_t pktlab_get24b(const void * ptr) {
    const uint8_t * u8ptr = ptr;
    uint_fast32_t val;
 
    val = (uint_fast32_t) u8ptr[0] << 16;
    val |= (uint_fast16_t) u8ptr[1] << 8;
    val |= u8ptr[2];
    return val;
}
 
static inline uint_fast32_t pktlab_get24l(const void * ptr) {
    const uint8_t * u8ptr = ptr;
    uint_fast32_t val;
 
    val = (uint_fast32_t) u8ptr[2] << 16;
    val |= (uint_fast16_t) u8ptr[1] << 8;
    val |= u8ptr[0];
    return val;
}
 
static inline uint_fast32_t pktlab_get32b(const void * ptr) {
    uint_fast32_t val;
 
    val = (uint_fast32_t) pktlab_get16b(ptr) << 16;
    val |= pktlab_get16b(ptr+2);
    return val;
}
 
static inline uint_fast32_t pktlab_get32l(const void * ptr) {
    uint_fast32_t val;
 
    val = (uint_fast32_t) pktlab_get16l(ptr+2) << 16;
    val |= pktlab_get16l(ptr);
    return val;
}
 
static inline uint_fast64_t pktlab_get64b(const void * ptr) {
    uint_fast64_t val;
 
    val = (uint_fast64_t) pktlab_get32b(ptr) << 32;
    val |= pktlab_get32b(ptr+4);
    return val;
}
 
static inline uint_fast64_t pktlab_get64l(const void * ptr) {
    uint_fast64_t val;
 
    val = (uint_fast64_t) pktlab_get32l(ptr+4) << 32;
    val |= pktlab_get32l(ptr);
    return val;
}
 
static inline void pktlab_set8(void * ptr, uint_fast8_t val) {
    *(uint8_t*)ptr = val;
}
 
static inline void pktlab_set16b(void * ptr, uint_fast16_t val) {
    uint8_t * u8ptr = ptr;
    u8ptr[0] = val >> 8;
    u8ptr[1] = val >> 0;
}
 
static inline void pktlab_set16l(void * ptr, uint_fast16_t val) {
    uint8_t * u8ptr = ptr;
    u8ptr[1] = val >> 8;
    u8ptr[0] = val >> 0;
}
 
static inline void pktlab_set24b(void * ptr, uint_fast32_t val) {
    uint8_t * u8ptr = ptr;
    u8ptr[0] = val >> 16;
    u8ptr[1] = val >> 8;
    u8ptr[2] = val >> 0;
}
 
static inline void pktlab_set24l(void * ptr, uint_fast32_t val) {
    uint8_t * u8ptr = ptr;
    u8ptr[2] = val >> 16;
    u8ptr[1] = val >> 8;
    u8ptr[0] = val >> 0;
}
 
static inline void pktlab_set32b(void * ptr, uint_fast32_t val) {
    pktlab_set16b(ptr, val >> 16);
    pktlab_set16b(ptr+2, val);
}
 
static inline void pktlab_set32l(void * ptr, uint_fast32_t val) {
    pktlab_set16l(ptr+2, val >> 16);
    pktlab_set16l(ptr, val);
}
 
static inline void pktlab_set64b(void * ptr, uint_fast64_t val) {
    pktlab_set32b(ptr, val >> 32);
    pktlab_set32b(ptr+4, val);
}
 
static inline void pktlab_set64l(void * ptr, uint_fast64_t val) {
    pktlab_set32l(ptr+4, val >> 32);
    pktlab_set32l(ptr, val);
}
 
static inline uint_fast16_t pktlab_hton16(uint_fast16_t x) {
    return htons(x);
}
 
static inline uint_fast32_t pktlab_hton32(uint_fast32_t x) {
    return htonl(x);
}
 
static inline uint_fast64_t pktlab_hton64(uint_fast64_t x) {
    uint_fast32_t hi, lo;
 
    hi = x >> 32;
    lo = x & UINT32_C(0xffffffff);
    return ((uint_fast64_t) pktlab_hton32(lo) << 32) | pktlab_hton32(hi);
}
 
static inline uint_fast16_t pktlab_ntoh16(uint_fast16_t x) {
    return ntohs(x);
}
 
static inline uint_fast32_t pktlab_ntoh32(uint_fast32_t x) {
    return ntohl(x);
}
 
static inline uint_fast64_t pktlab_ntoh64(uint_fast64_t x) {
    uint_fast32_t hi, lo;
 
    lo = pktlab_ntoh32(x >> 32);
    hi = pktlab_ntoh32(x & UINT32_C(0xffffffff));
    return ((uint_fast64_t) hi << 32) | lo;
}
 
static inline bool pktlab_getbit8(uint_fast8_t bits, uint_fast8_t pos) {
    return pktlab_getbit64(bits, pos);
}
 
static inline bool pktlab_getbit16(uint_fast16_t bits, uint_fast8_t pos) {
    return pktlab_getbit64(bits, pos);
}
 
static inline bool pktlab_getbit32(uint_fast32_t bits, uint_fast8_t pos) {
    return pktlab_getbit64(bits, pos);
}
 
static inline bool pktlab_getbit64(uint_fast64_t bits, uint_fast8_t pos) {
    return (pos >= 0x40) ? false : (bits & ((uint_fast64_t) 1 << pos));
}
 
 
static inline uint_fast8_t pktlab_setbit8(uint_fast8_t bits, uint_fast8_t pos) {
    return pktlab_setbit64(bits, pos);
}
 
static inline uint_fast16_t pktlab_setbit16(uint_fast16_t bits, uint_fast8_t pos) {
    return pktlab_setbit64(bits, pos);
}
 
static inline uint_fast32_t pktlab_setbit32(uint_fast32_t bits, uint_fast8_t pos) {
    return pktlab_setbit64(bits, pos);
}
 
static inline uint_fast64_t pktlab_setbit64(uint_fast64_t bits, uint_fast8_t pos) {
    return (pos >= 0x40) ? bits : (bits | ((uint_fast64_t) 1 << pos));
}
 
 
static inline uint_fast8_t pktlab_clrbit8(uint_fast8_t bits, uint_fast8_t pos) {
    return pktlab_clrbit64(bits, pos);
}
 
static inline uint_fast16_t pktlab_clrbit16(uint_fast16_t bits, uint_fast8_t pos) {
    return pktlab_clrbit64(bits, pos);
}
 
static inline uint_fast32_t pktlab_clrbit32(uint_fast32_t bits, uint_fast8_t pos) {
    return pktlab_clrbit64(bits, pos);
}
 
static inline uint_fast64_t pktlab_clrbit64(uint_fast64_t bits, uint_fast8_t pos) {
    return (pos >= 0x40) ? bits : (bits & ~((uint_fast64_t) 1 << pos));
}
 
#endif