e2sarHeaders.hpp

#ifndef E2SARHEADERSHPP
#define E2SARHEADERSHPP
 
#include <boost/tuple/tuple.hpp>
#include "portable_endian.h"
 
namespace e2sar
{
    using EventNum_t = u_int64_t;
    using UnixTimeNano_t = u_int64_t;
    using UnixTimeMicro_t = u_int64_t;
    using EventRate_t = u_int32_t;
 
    constexpr u_int8_t rehdrVersion = 1;
    constexpr u_int8_t rehdrVersionNibble = rehdrVersion << 4; // shifted up by 4 bits to be in the upper nibble
    /*
        The Reassembly Header. You should always use the provided methods to set
        and interrogate fields as the structure maintains Big-Endian order
        internally.
    */
    struct REHdr
    {
        u_int8_t preamble[2] {rehdrVersionNibble, 0}; // 4 bit version + reserved
        u_int16_t dataId{0};   // source identifier
        u_int32_t bufferOffset{0};
        u_int32_t bufferLength{0}; // this is event length, not the length of the buffer being sent
        EventNum_t eventNum{0};
 
        inline void set(u_int16_t data_id, u_int32_t buff_off, u_int32_t buff_len, EventNum_t event_num)
        {
            dataId = htobe16(data_id);
            bufferOffset = htobe32(buff_off);
            bufferLength = htobe32(buff_len);
            eventNum = htobe64(event_num);
        }
 
        inline EventNum_t get_eventNum() const
        {
            return be64toh(eventNum);
        }
 
        inline u_int32_t get_bufferLength() const
        {
            return be32toh(bufferLength);
        }
 
        inline u_int32_t get_bufferOffset() const
        {
            return be32toh(bufferOffset);
        }
 
        inline u_int16_t get_dataId() const
        {
            return be16toh(dataId);
        }
 
        inline const boost::tuple<u_int16_t, u_int32_t, u_int32_t, EventNum_t> get_Fields() const 
        {
            return boost::make_tuple(get_dataId(), get_bufferOffset(), get_bufferLength(), get_eventNum());
        }
    } __attribute__((__packed__));
 
    constexpr u_int8_t lbhdrVersion = 2;
    struct LBHdr
    {
        char preamble[2] {'L', 'B'};
        u_int8_t version{lbhdrVersion};
        u_int8_t nextProto{rehdrVersion};
        u_int16_t rsvd{0};
        u_int16_t entropy{0};
        EventNum_t eventNum{0L};
 
        inline void set(u_int16_t ent, EventNum_t event_num) 
        {
            entropy = htobe16(ent);
            eventNum = htobe64(event_num);
        }
 
        u_int8_t get_version() const
        {
            return version;
        }
 
        u_int8_t get_nextProto() const 
        {
            return nextProto;
        }
 
        u_int16_t get_entropy() const
        {
            return be16toh(entropy);
        }
 
        EventNum_t get_eventNum() const
        {
            return be64toh(eventNum);
        }
 
        const boost::tuple<u_int8_t, u_int8_t, u_int16_t, EventNum_t> get_Fields() const 
        {
            return boost::make_tuple(version, nextProto, get_entropy(), get_eventNum());
        }
    } __attribute__((__packed__));
 
    // for memory allocation purposes we need them concatenated
    struct LBREHdr {
        struct LBHdr lb;
        struct REHdr re;
    } __attribute__((__packed__));
 
    constexpr u_int8_t synchdrVersion = 2;
    struct SyncHdr
    {
        char preamble[2] {'L', 'C'};
        u_int8_t version{synchdrVersion};
        u_int8_t rsvd{0};
        u_int32_t eventSrcId{0};
        EventNum_t eventNumber{0LL};
        EventRate_t avgEventRateHz{0};
        UnixTimeNano_t unixTimeNano{0LL};
 
        inline void set(u_int32_t esid, EventNum_t event_num, EventRate_t avg_rate, UnixTimeNano_t ut)
        {
            eventSrcId = htobe32(esid);
            eventNumber = htobe64(event_num);
            avgEventRateHz = htobe32(avg_rate);
            unixTimeNano = htobe64(ut);
        }
 
        inline u_int32_t get_eventSrcId() const
        {
            return be32toh(eventSrcId);
        }
        inline EventNum_t get_eventNumber() const
        {
            return be64toh(eventNumber);
        }
        inline u_int32_t get_avgEventRateHz() const 
        {
            return be32toh(avgEventRateHz);
        }
        inline UnixTimeNano_t get_unixTimeNano() const 
        {
            return be64toh(unixTimeNano);
        }
        const boost::tuple<u_int32_t, EventNum_t, u_int32_t, UnixTimeNano_t> get_Fields() const 
        {
            return boost::make_tuple(get_eventSrcId(), get_eventNumber(), get_avgEventRateHz(), get_unixTimeNano());
        }
    } __attribute__((__packed__));
 
    // various useful header lengths
    constexpr size_t IP_HDRLEN = 20;
    constexpr size_t UDP_HDRLEN = 8;
    constexpr size_t TOTAL_HDR_LEN{IP_HDRLEN + UDP_HDRLEN + sizeof(LBHdr) + sizeof(REHdr)};
}
 
#endif