types.h

Go to the documentation of this file.

/* SPDX-License-Identifier: LGPL-3.0-or-later
   SPDX-FileCopyrightText: Copyright © 2021 Erez Geva <ErezGeva2@gmail.com> */
 
#ifndef __PTPMGMT_TYPES_H
#define __PTPMGMT_TYPES_H
 
#ifdef __cplusplus
#include <map>
#include "bin.h"
#include "mngIds.h"
 
__PTPMGMT_NAMESPACE_BEGIN
 
#ifndef INT48_MIN
const int64_t INT48_MIN = -INT64_C(0x7fffffffffff) - 1;
#endif
#ifndef INT48_MAX
const int64_t INT48_MAX = INT64_C(0x7fffffffffff);
#endif
#ifndef UINT48_MAX
const uint64_t UINT48_MAX = UINT64_C(0xffffffffffff);
#endif
 
typedef uint8_t Nibble_t;
typedef uint8_t UInteger8_t;
typedef uint16_t UInteger16_t;
typedef uint32_t UInteger32_t;
typedef uint64_t UInteger48_t;
const size_t sizeof_UInteger48_t = 6;
typedef uint64_t UInteger64_t;
typedef int8_t   Integer8_t;
typedef int16_t  Integer16_t;
typedef int32_t  Integer32_t;
typedef int64_t Integer48_t;
const size_t sizeof_Integer48_t = 6;
typedef int64_t Integer64_t;
typedef uint8_t Octet_t;
typedef double Float64_t;
typedef long double float_seconds;
typedef long double float_nanoseconds;
 
enum MNG_PARSE_ERROR_e {
    MNG_PARSE_ERROR_OK,
    MNG_PARSE_ERROR_MSG,
    MNG_PARSE_ERROR_SIG,
    MNG_PARSE_ERROR_SMPTE,
    MNG_PARSE_ERROR_INVALID_ID,
    MNG_PARSE_ERROR_INVALID_TLV,
    MNG_PARSE_ERROR_MISMATCH_TLV,
    MNG_PARSE_ERROR_SIZE_MISS,
    MNG_PARSE_ERROR_TOO_SMALL,
    MNG_PARSE_ERROR_SIZE,
    MNG_PARSE_ERROR_VAL,
    MNG_PARSE_ERROR_HEADER,
    MNG_PARSE_ERROR_ACTION,
    MNG_PARSE_ERROR_UNSUPPORT,
    MNG_PARSE_ERROR_MEM,
    MNG_PARSE_ERROR_AUTH,
    MNG_PARSE_ERROR_AUTH_NONE,
    MNG_PARSE_ERROR_AUTH_WRONG,
    MNG_PARSE_ERROR_AUTH_NOKEY,
};
enum msgType_e : Nibble_t {
    /* Event messages */
    Sync                    = 0,
    Delay_Req               = 1,
    Pdelay_Req              = 2,
    Pdelay_Resp             = 3,
    /* General messages */
    Follow_Up               = 0x8,
    Delay_Resp              = 0x9,
    Pdelay_Resp_Follow_Up   = 0xa,
    Announce                = 0xb,
    Signaling               = 0xc,
    Management              = 0xd,
};
enum tlvType_e : uint16_t {
    MANAGEMENT                              = 0x0001,
    MANAGEMENT_ERROR_STATUS                 = 0x0002,
    ORGANIZATION_EXTENSION                  = 0x0003,
    REQUEST_UNICAST_TRANSMISSION            = 0x0004,
    GRANT_UNICAST_TRANSMISSION              = 0x0005,
    CANCEL_UNICAST_TRANSMISSION             = 0x0006,
    ACKNOWLEDGE_CANCEL_UNICAST_TRANSMISSION = 0x0007,
    PATH_TRACE                              = 0x0008,
    ALTERNATE_TIME_OFFSET_INDICATOR         = 0x0009,
    /* Obsolete valuse 2000, 2001, 2002, 2003 */
    ORGANIZATION_EXTENSION_PROPAGATE        = 0x4000,
    ENHANCED_ACCURACY_METRICS               = 0x4001,
    ORGANIZATION_EXTENSION_DO_NOT_PROPAGATE = 0x8000,
    L1_SYNC                                 = 0x8001,
    PORT_COMMUNICATION_AVAILABILITY         = 0x8002,
    PROTOCOL_ADDRESS                        = 0x8003,
    SLAVE_RX_SYNC_TIMING_DATA               = 0x8004,
    SLAVE_RX_SYNC_COMPUTED_DATA             = 0x8005,
    SLAVE_TX_EVENT_TIMESTAMPS               = 0x8006,
    CUMULATIVE_RATE_RATIO                   = 0x8007,
    TLV_PAD                                 = 0x8008,
    AUTHENTICATION                          = 0x8009,
    SLAVE_DELAY_TIMING_DATA_NP              = 0x7f00,
};
enum actionField_e : uint8_t {
    GET = 0,            
    SET = 1,            
    RESPONSE = 2,       
    COMMAND = 3,        
    ACKNOWLEDGE = 4,    
};
enum managementErrorId_e : uint16_t {
    RESPONSE_TOO_BIG = 0x0001, 
    NO_SUCH_ID       = 0x0002, 
    WRONG_LENGTH     = 0x0003, 
    WRONG_VALUE      = 0x0004, 
    NOT_SETABLE      = 0x0005, 
    NOT_SUPPORTED    = 0x0006, 
    GENERAL_ERROR    = 0xfffe, 
};
enum clockType_e : uint16_t {
    ordinaryClock       = 0x8000, 
    boundaryClock       = 0x4000, 
    p2pTransparentClock = 0x2000, 
    e2eTransparentClock = 0x1000, 
    managementClock     = 0x0800, 
};
enum networkProtocol_e : uint16_t {
    UDP_IPv4   = 1, 
    UDP_IPv6   = 2, 
    IEEE_802_3 = 3, 
    DeviceNet  = 4, 
    ControlNet = 5, 
    PROFINET   = 6, 
};
enum clockAccuracy_e : uint8_t {
    Accurate_within_1ps   = 0x17, 
    Accurate_within_2_5ps = 0x18, 
    Accurate_within_10ps  = 0x19, 
    Accurate_within_25ps  = 0x1a, 
    Accurate_within_100ps = 0x1b, 
    Accurate_within_250ps = 0x1c, 
    Accurate_within_1ns   = 0x1d, 
    Accurate_within_2_5ns = 0x1e, 
    Accurate_within_10ns  = 0x1f, 
    Accurate_within_25ns  = 0x20, 
    Accurate_within_100ns = 0x21, 
    Accurate_within_250ns = 0x22, 
    Accurate_within_1us   = 0x23, 
    Accurate_within_2_5us = 0x24, 
    Accurate_within_10us  = 0x25, 
    Accurate_within_25us  = 0x26, 
    Accurate_within_100us = 0x27, 
    Accurate_within_250us = 0x28, 
    Accurate_within_1ms   = 0x29, 
    Accurate_within_2_5ms = 0x2a, 
    Accurate_within_10ms  = 0x2b, 
    Accurate_within_25ms  = 0x2c, 
    Accurate_within_100ms = 0x2d, 
    Accurate_within_250ms = 0x2e, 
    Accurate_within_1s    = 0x2f, 
    Accurate_within_10s   = 0x30, 
    Accurate_more_10s     = 0x31, 
    Accurate_Unknown      = 0xfe, 
};
enum faultRecord_e : uint8_t {
    F_Emergency     = 0x00, 
    F_Alert         = 0x01, 
    F_Critical      = 0x02, 
    F_Error         = 0x03, 
    F_Warning       = 0x04, 
    F_Notice        = 0x05, 
    F_Informational = 0x06, 
    F_Debug         = 0x07, 
};
enum timeSource_e : uint8_t {
    ATOMIC_CLOCK        = 0x10, 
    GNSS                = 0x20, 
    GPS                 = 0x20, 
    TERRESTRIAL_RADIO   = 0x30, 
    SERIAL_TIME_CODE    = 0x39, 
    PTP                 = 0x40, 
    NTP                 = 0x50, 
    HAND_SET            = 0x60, 
    OTHER               = 0x90, 
    INTERNAL_OSCILLATOR = 0xa0, 
};
enum portState_e : uint8_t {
    INITIALIZING         = 1, 
    FAULTY               = 2, 
    DISABLED             = 3, 
    LISTENING            = 4, 
    PRE_MASTER           = 5, 
    PRE_TIME_TRANSMITTER = 5, 
    MASTER               = 6, 
    TIME_TRANSMITTER     = 6, 
    PASSIVE              = 7, 
    UNCALIBRATED         = 8, 
    SLAVE                = 9, 
    TIME_RECEIVER        = 9, 
};
enum delayMechanism_e : uint8_t {
    AUTO          = 0,
    E2E           = 1,
    P2P           = 2,
    NO_MECHANISM  = 0xfe,
    COMMON_P2P    = 3,
    SPECIAL       = 4,
};
enum implementSpecific_e {
    noImplementSpecific, 
    linuxptp,            
};
enum SMPTEmasterLockingStatus_e : uint8_t {
    SMPTE_NOT_IN_USE   = 0, 
    SMPTE_FREE_RUN     = 1, 
    SMPTE_COLD_LOCKING = 2,
    SMPTE_WARM_LOCKING = 3,
    SMPTE_LOCKED       = 4, 
};
enum linuxptpTimeStamp_e : uint8_t {
    TS_SOFTWARE,
    TS_HARDWARE,
    TS_LEGACY_HW,
    TS_ONESTEP,
    TS_P2P1STEP,
};
enum linuxptpPowerProfileVersion_e : uint16_t {
    IEEE_C37_238_VERSION_NONE,
    IEEE_C37_238_VERSION_2011,
    IEEE_C37_238_VERSION_2017,
};
enum linuxptpUnicastState_e : uint8_t {
    UC_WAIT, 
    UC_HAVE_ANN, 
    UC_NEED_SYDY, 
    UC_HAVE_SYDY, 
};
enum : uint8_t {
    F_LI_61 = (1 << 0),
    F_LI_59 = (1 << 1),
    F_UTCV  = (1 << 2),
    F_PTP   = (1 << 3),
    F_TTRA  = (1 << 4),
    F_FTRA  = (1 << 5),
};
struct TimeInterval_t {
    Integer64_t scaledNanoseconds; 
    static size_t size() { return sizeof scaledNanoseconds; }
    float_nanoseconds getInterval() const {
        return (float_nanoseconds)scaledNanoseconds / 0x10000;
    }
    int64_t getIntervalInt() const;
};
struct Timestamp_t {
    UInteger48_t secondsField; 
    UInteger32_t nanosecondsField; 
    Timestamp_t() : secondsField(0), nanosecondsField(0) {}
    Timestamp_t(int64_t secs, uint32_t nsecs) : secondsField(secs),
        nanosecondsField(nsecs) {}
    static size_t size() { return sizeof_UInteger48_t + sizeof nanosecondsField; }
    std::string string() const;
    operator std::string() const { return string(); }
 
    #ifndef SWIG /* standard C++ structures converting */
    Timestamp_t(const timespec &ts) {
        secondsField = ts.tv_sec;
        nanosecondsField = ts.tv_nsec;
    }
    operator timespec() const { timespec ts; toTimespec(ts); return ts; }
    void toTimespec(timespec &ts) const {
        ts.tv_sec = secondsField;
        ts.tv_nsec = nanosecondsField;
    }
    Timestamp_t(const timeval &tv);
    operator timeval() const { timeval tv; toTimeval(tv); return tv; }
    void toTimeval(timeval &tv) const;
    #endif /* SWIG */
    Timestamp_t(float_seconds seconds) {fromFloat(seconds);}
    void fromFloat(float_seconds seconds);
    operator float_seconds() const { return toFloat(); }
    float_seconds toFloat() const;
    void fromNanoseconds(uint64_t nanoseconds);
    uint64_t toNanoseconds() const;
    bool operator==(const Timestamp_t &ts) const { return eq(ts); }
    bool eq(const Timestamp_t &ts) const {
        return secondsField == ts.secondsField &&
            nanosecondsField == ts.nanosecondsField;
    }
    bool operator==(float_seconds seconds) const { return eq(seconds); }
    bool eq(float_seconds seconds) const;
    bool operator<(const Timestamp_t &ts) const { return less(ts); }
    bool less(const Timestamp_t &ts) const {
        return secondsField < ts.secondsField ||
            (secondsField == ts.secondsField &&
                nanosecondsField < ts.nanosecondsField);
    }
    bool operator<(float_seconds seconds) const { return less(seconds); }
    bool less(float_seconds seconds) const;
    Timestamp_t &operator+(const Timestamp_t &ts) { return add(ts); }
    Timestamp_t &operator+=(const Timestamp_t &ts) { return add(ts); }
    Timestamp_t &add(const Timestamp_t &ts);
    Timestamp_t &operator+(float_seconds seconds) { return add(seconds); }
    Timestamp_t &operator+=(float_seconds seconds) { return add(seconds); }
    Timestamp_t &add(float_seconds seconds);
    Timestamp_t &operator-(const Timestamp_t &ts) { return subt(ts); }
    Timestamp_t &operator-=(const Timestamp_t &ts) { return subt(ts); }
    Timestamp_t &subt(const Timestamp_t &ts);
    Timestamp_t &operator-(float_seconds seconds) { return add(-seconds); }
    Timestamp_t &operator-=(float_seconds seconds) { return add(-seconds); }
    Timestamp_t &subt(float_seconds seconds) { return add(-seconds); }
};
struct ClockIdentity_t {
    Octet_t v[8]; 
    static size_t size() { return sizeof v; }
    std::string string() const;
    void clear(int val = 0) {memset(v, val, 8);}
    bool operator==(const ClockIdentity_t &rhs) const { return eq(rhs); }
    bool eq(const ClockIdentity_t &rhs) const {
        return memcmp(v, rhs.v, size()) == 0;
    }
    bool operator<(const ClockIdentity_t &rhs) const { return less(rhs); }
    bool less(const ClockIdentity_t &rhs) const {
        return memcmp(v, rhs.v, size()) < 0;
    }
    bool operator==(const Binary &bin) const { return eq(bin); }
    bool eq(const Binary &bin) const {
        return bin.size() == size() &&
            memcmp(v, bin.get(), size()) == 0;
    }
};
struct PortIdentity_t {
    ClockIdentity_t clockIdentity; 
    UInteger16_t portNumber; 
    static size_t size() { return ClockIdentity_t::size() + sizeof portNumber; }
    std::string string() const;
    void clear() {clockIdentity.clear(); portNumber = 0;}
    bool operator==(const PortIdentity_t &rhs) const { return eq(rhs); }
    bool eq(const PortIdentity_t &rhs) const {
        return clockIdentity == rhs.clockIdentity && portNumber == rhs.portNumber;
    }
    bool operator<(const PortIdentity_t &rhs) const { return less(rhs); }
    bool less(const PortIdentity_t &rhs) const;
};
struct PortAddress_t {
    networkProtocol_e networkProtocol; 
    UInteger16_t addressLength;
    Binary addressField; 
    size_t size() const {
        return sizeof networkProtocol + sizeof addressLength +
            addressField.length();
    }
    std::string string() const;
    bool operator==(const PortAddress_t &rhs) const { return eq(rhs); }
    bool eq(const PortAddress_t &rhs) const {
        return networkProtocol == rhs.networkProtocol &&
            addressField == rhs.addressField;
    }
    bool operator<(const PortAddress_t &rhs) const { return less(rhs); }
    bool less(const PortAddress_t &rhs) const;
};
struct ClockQuality_t {
    UInteger8_t clockClass; 
    clockAccuracy_e clockAccuracy; 
    uint16_t offsetScaledLogVariance; 
    static size_t size() {
        return sizeof clockClass + sizeof clockAccuracy +
            sizeof offsetScaledLogVariance;
    }
};
struct PTPText_t {
    uint8_t lengthField;
    std::string textField; 
    size_t size() const { return sizeof lengthField + textField.length(); }
    const char *string() const { return textField.c_str(); }
};
struct FaultRecord_t {
    uint16_t faultRecordLength; 
    Timestamp_t faultTime; 
    faultRecord_e severityCode; 
    PTPText_t faultName; 
    PTPText_t faultValue; 
    PTPText_t faultDescription; 
    size_t size() const {
        return sizeof faultRecordLength + faultTime.size() + sizeof severityCode +
            faultName.size() + faultValue.size() + faultDescription.size();
    }
};
struct AcceptableMaster_t {
    PortIdentity_t acceptablePortIdentity; 
    uint8_t alternatePriority1; 
    static size_t size() {
        return PortIdentity_t::size() + sizeof alternatePriority1;
    }
};
struct ManagementId_t {
    uint16_t value;   
    uint8_t scope;   
    uint8_t allowed; 
    ssize_t size;
};
 
enum MsgParams_RcvAuth_e : uint8_t {
    RCV_AUTH_NONE = 0, 
    RCV_AUTH_MNG = (1 << 0),
    RCV_AUTH_SIG_LAST = (1 << 1),
    RCV_AUTH_SIG_ALL = (1 << 2),
    RCV_AUTH_ALL = 0x7, 
    RCV_AUTH_IGNORE = (1 << 3),
};
 
struct MsgParams {
    uint8_t transportSpecific; 
    uint8_t domainNumber; 
    uint8_t boundaryHops; 
    uint8_t minorVersion; 
    bool isUnicast; 
    implementSpecific_e implementSpecific;
    PortIdentity_t target; 
    PortIdentity_t self_id; 
    bool useZeroGet; 
    bool rcvSignaling; 
    bool filterSignaling; 
    bool rcvSMPTEOrg; 
    bool sendAuth;
    uint8_t rcvAuth;
    MsgParams();
    void allowSigTlv(tlvType_e type);
    void removeSigTlv(tlvType_e type);
    bool isSigTlv(tlvType_e type) const;
    size_t countSigTlvs() const;
  private:
    std::map<tlvType_e, bool> allowSigTlvs;
};
struct BaseMngTlv {
    virtual ~BaseMngTlv() = default;
};
struct BaseSigTlv {
    virtual ~BaseSigTlv() = default;
};
struct LinuxptpUnicastMaster_t {
    PortIdentity_t portIdentity; 
    ClockQuality_t clockQuality; 
    uint8_t selected; 
    linuxptpUnicastState_e portState;
    UInteger8_t priority1; 
    UInteger8_t priority2; 
    PortAddress_t portAddress; 
    size_t size() const {
        return portIdentity.size() + clockQuality.size() +
            sizeof selected + sizeof portState + sizeof priority1 +
            sizeof priority2 + portAddress.size();
    }
};
 
__PTPMGMT_NAMESPACE_END
#else /* __cplusplus */
#include "c/types.h"
#endif /* __cplusplus */
 
#endif /* __PTPMGMT_TYPES_H */