proc.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_PROC_H
#define __PTPMGMT_PROC_H
 
#ifdef __cplusplus
#include <vector>
#include <cstdlib>
#include "types.h"
 
__PTPMGMT_NAMESPACE_BEGIN
 
struct CLOCK_DESCRIPTION_t : public BaseMngTlv {
    uint16_t clockType; 
    PTPText_t physicalLayerProtocol; 
    UInteger16_t physicalAddressLength; 
    Binary physicalAddress; 
    PortAddress_t protocolAddress; 
    Octet_t manufacturerIdentity[3]; 
    PTPText_t productDescription; 
    PTPText_t revisionData; 
    PTPText_t userDescription; 
    Octet_t profileIdentity[6]; 
};
struct USER_DESCRIPTION_t : public BaseMngTlv {
    PTPText_t userDescription; 
};
const uint16_t INITIALIZE_EVENT = 0x0000;
struct INITIALIZE_t : public BaseMngTlv {
    uint16_t initializationKey; 
};
struct FAULT_LOG_t : public BaseMngTlv {
    UInteger16_t numberOfFaultRecords; 
    std::vector<FaultRecord_t> faultRecords; 
};
struct DEFAULT_DATA_SET_t : public BaseMngTlv {
    uint8_t flags;
    const uint8_t flagsMask = 0x3; 
    UInteger16_t numberPorts; 
    UInteger8_t priority1; 
    ClockQuality_t clockQuality; 
    UInteger8_t priority2; 
    ClockIdentity_t clockIdentity; 
    UInteger8_t domainNumber; 
};
struct CURRENT_DATA_SET_t : public BaseMngTlv {
    UInteger16_t stepsRemoved; 
    TimeInterval_t offsetFromMaster;
    TimeInterval_t meanPathDelay;
};
struct PARENT_DATA_SET_t : public BaseMngTlv {
    PortIdentity_t parentPortIdentity; 
    uint8_t flags;
    const uint8_t flagsMask = 0x1; 
    UInteger16_t observedParentOffsetScaledLogVariance;
    Integer32_t observedParentClockPhaseChangeRate;
    UInteger8_t grandmasterPriority1; 
    ClockQuality_t grandmasterClockQuality;
    UInteger8_t grandmasterPriority2; 
    ClockIdentity_t grandmasterIdentity; 
};
struct TIME_PROPERTIES_DATA_SET_t : public BaseMngTlv {
    Integer16_t currentUtcOffset; 
    uint8_t flags;
    const uint8_t flagsMask = 0x3f; 
    timeSource_e timeSource; 
};
struct PORT_DATA_SET_t : public BaseMngTlv {
    PortIdentity_t portIdentity; 
    portState_e portState; 
    Integer8_t logMinDelayReqInterval;
    TimeInterval_t peerMeanPathDelay; 
    Integer8_t logAnnounceInterval;
    UInteger8_t announceReceiptTimeout;
    Integer8_t logSyncInterval;
    delayMechanism_e delayMechanism;
    Integer8_t logMinPdelayReqInterval;
    Nibble_t versionNumber;
};
struct PRIORITY1_t : public BaseMngTlv {
    UInteger8_t priority1; 
};
struct PRIORITY2_t : public BaseMngTlv {
    UInteger8_t priority2; 
};
struct DOMAIN_t : public BaseMngTlv {
    UInteger8_t domainNumber; 
};
struct SLAVE_ONLY_t : public BaseMngTlv {
    uint8_t flags;
    const uint8_t flagsMask = 0x1; 
};
struct LOG_ANNOUNCE_INTERVAL_t : public BaseMngTlv {
    Integer8_t logAnnounceInterval;
};
struct ANNOUNCE_RECEIPT_TIMEOUT_t : public BaseMngTlv {
    UInteger8_t announceReceiptTimeout;
};
struct LOG_SYNC_INTERVAL_t : public BaseMngTlv {
    Integer8_t logSyncInterval;
};
struct VERSION_NUMBER_t : public BaseMngTlv {
    Nibble_t versionNumber;
};
struct TIME_t : public BaseMngTlv {
    Timestamp_t currentTime; 
};
struct CLOCK_ACCURACY_t : public BaseMngTlv {
    clockAccuracy_e clockAccuracy; 
};
struct UTC_PROPERTIES_t : public BaseMngTlv {
    Integer16_t currentUtcOffset; 
    uint8_t flags;
    const uint8_t flagsMask = 0x7; 
};
struct TRACEABILITY_PROPERTIES_t : public BaseMngTlv {
    uint8_t flags;
    const uint8_t flagsMask = 0x30; 
};
struct TIMESCALE_PROPERTIES_t : public BaseMngTlv {
    uint8_t flags;
    const uint8_t flagsMask = 0x8; 
    timeSource_e timeSource; 
};
struct UNICAST_NEGOTIATION_ENABLE_t : public BaseMngTlv {
    uint8_t flags;
    const uint8_t flagsMask = 0x1; 
};
struct PATH_TRACE_LIST_t : public BaseMngTlv {
    std::vector<ClockIdentity_t> pathSequence; 
};
struct PATH_TRACE_ENABLE_t : public BaseMngTlv {
    uint8_t flags;
    const uint8_t flagsMask = 0x1; 
};
struct GRANDMASTER_CLUSTER_TABLE_t : public BaseMngTlv {
    Integer8_t logQueryInterval;
    UInteger8_t actualTableSize; 
    std::vector<PortAddress_t> PortAddress;
};
struct UNICAST_MASTER_TABLE_t : public BaseMngTlv {
    Integer8_t logQueryInterval;
    UInteger16_t actualTableSize; 
    std::vector<PortAddress_t> PortAddress;
};
struct UNICAST_MASTER_MAX_TABLE_SIZE_t : public BaseMngTlv {
    UInteger16_t maxTableSize;
};
struct ACCEPTABLE_MASTER_TABLE_t : public BaseMngTlv {
    Integer16_t actualTableSize; 
    std::vector<AcceptableMaster_t> list;
};
struct ACCEPTABLE_MASTER_TABLE_ENABLED_t : public BaseMngTlv {
    uint8_t flags;
    const uint8_t flagsMask = 0x1; 
};
struct ACCEPTABLE_MASTER_MAX_TABLE_SIZE_t : public BaseMngTlv {
    UInteger16_t maxTableSize;
};
struct ALTERNATE_MASTER_t : public BaseMngTlv {
    uint8_t flags;
    const uint8_t flagsMask = 0x1; 
    Integer8_t logAlternateMulticastSyncInterval;
    UInteger8_t numberOfAlternateMasters;
};
struct ALTERNATE_TIME_OFFSET_ENABLE_t : public BaseMngTlv {
    UInteger8_t keyField; 
    uint8_t flags;
    const uint8_t flagsMask = 0x1; 
};
struct ALTERNATE_TIME_OFFSET_NAME_t : public BaseMngTlv {
    UInteger8_t keyField; 
    PTPText_t displayName;
};
struct ALTERNATE_TIME_OFFSET_MAX_KEY_t : public BaseMngTlv {
    UInteger8_t maxKey; 
};
struct ALTERNATE_TIME_OFFSET_PROPERTIES_t : public BaseMngTlv {
    UInteger8_t keyField; 
    Integer32_t currentOffset; 
    Integer32_t jumpSeconds; 
    UInteger48_t timeOfNextJump; 
};
struct TRANSPARENT_CLOCK_PORT_DATA_SET_t : public BaseMngTlv {
    PortIdentity_t portIdentity; 
    uint8_t flags;
    const uint8_t flagsMask = 0x1; 
    Integer8_t logMinPdelayReqInterval;
    TimeInterval_t peerMeanPathDelay; 
};
struct LOG_MIN_PDELAY_REQ_INTERVAL_t : public BaseMngTlv {
    Integer8_t logMinPdelayReqInterval;
};
struct TRANSPARENT_CLOCK_DEFAULT_DATA_SET_t : public BaseMngTlv {
    ClockIdentity_t clockIdentity; 
    UInteger16_t numberPorts; 
    delayMechanism_e delayMechanism;
    UInteger8_t primaryDomain; 
};
struct PRIMARY_DOMAIN_t : public BaseMngTlv {
    UInteger8_t primaryDomain; 
};
struct DELAY_MECHANISM_t : public BaseMngTlv {
    delayMechanism_e delayMechanism;
};
struct EXTERNAL_PORT_CONFIGURATION_ENABLED_t : public BaseMngTlv {
    uint8_t flags;
    const uint8_t flagsMask = 0x1; 
};
struct MASTER_ONLY_t : public BaseMngTlv {
    uint8_t flags;
    const uint8_t flagsMask = 0x1; 
};
struct HOLDOVER_UPGRADE_ENABLE_t : public BaseMngTlv {
    uint8_t flags;
    const uint8_t flagsMask = 0x1; 
};
struct EXT_PORT_CONFIG_PORT_DATA_SET_t : public BaseMngTlv {
    uint8_t flags;
    const uint8_t flagsMask = 0x1; 
    portState_e desiredState; 
};
const float_nanoseconds P41 = 1ULL << 41;
struct TIME_STATUS_NP_t : public BaseMngTlv {
    int64_t master_offset; 
    int64_t ingress_time;  
    Integer32_t cumulativeScaledRateOffset;
    Integer32_t scaledLastGmPhaseChange;
    UInteger16_t gmTimeBaseIndicator;
    uint16_t nanoseconds_msb;
    uint64_t nanoseconds_lsb;
    uint16_t fractional_nanoseconds;
    Integer32_t gmPresent; 
    ClockIdentity_t gmIdentity; 
};
struct GRANDMASTER_SETTINGS_NP_t : public BaseMngTlv {
    ClockQuality_t clockQuality; 
    Integer16_t currentUtcOffset; 
    uint8_t flags;
    const uint8_t flagsMask = 0x3f; 
    timeSource_e timeSource; 
};
struct PORT_DATA_SET_NP_t : public BaseMngTlv {
    UInteger32_t neighborPropDelayThresh;
    Integer32_t asCapable; 
};
const int EVENT_BITMASK_CNT = 64;
const int NOTIFY_PORT_STATE = 0;
const int NOTIFY_TIME_SYNC = 1;
const int NOTIFY_PARENT_DATA_SET = 2;
const int NOTIFY_CMLDS = 3;
struct SUBSCRIBE_EVENTS_NP_t : public BaseMngTlv {
    uint16_t duration; 
    uint8_t bitmask[EVENT_BITMASK_CNT]; 
    SUBSCRIBE_EVENTS_NP_t() : bitmask{0} {}
    void setEvent(int event) {
        std::div_t d;
        if(div_event(event, d))
            bitmask[d.quot] |= d.rem;
    }
    void clearEvent(int event) {
        std::div_t d;
        if(div_event(event, d))
            bitmask[d.quot] &= ~d.rem;
    }
    void clearAll() {
        memset(bitmask, 0, EVENT_BITMASK_CNT);
    }
    bool getEvent(int event) const {
        std::div_t d;
        if(div_event(event, d))
            return (bitmask[d.quot] & d.rem) > 0;
        return false;
    }
    static std::div_t div_event(int event) {
        std::div_t d;
        div_event_wo(event, d);
        return d;
    }
  private:
    static void div_event_wo(int event, std::div_t &d) {
        d = div(event, 8);
        d.rem = 1 << d.rem;
    }
    static bool div_event(int event, std::div_t &d) {
        if(event < 0 || event >= EVENT_BITMASK_CNT)
            return false;
        div_event_wo(event, d);
        return true;
    }
};
struct PORT_PROPERTIES_NP_t : public BaseMngTlv {
    PortIdentity_t portIdentity; 
    portState_e portState; 
    linuxptpTimeStamp_e timestamping;
    PTPText_t interface; 
};
const int MAX_MESSAGE_TYPES = 16;
const int STAT_SYNC = 0;
const int STAT_DELAY_REQ = 1;
const int STAT_PDELAY_REQ = 2;
const int STAT_PDELAY_RESP = 3;
const int STAT_FOLLOW_UP = 8;
const int STAT_DELAY_RESP = 9;
const int STAT_PDELAY_RESP_FOLLOW_UP = 10;
const int STAT_ANNOUNCE = 11;
const int STAT_SIGNALING = 12;
const int STAT_MANAGEMENT = 13;
struct PORT_STATS_NP_t : public BaseMngTlv {
    PortIdentity_t portIdentity; 
    uint64_t rxMsgType[MAX_MESSAGE_TYPES];
    uint64_t txMsgType[MAX_MESSAGE_TYPES];
};
const uint8_t SYNC_UNCERTAIN_FALSE = 0;
const uint8_t SYNC_UNCERTAIN_TRUE = 1;
const uint8_t SYNC_UNCERTAIN_DONTCARE = 0xff;
struct SYNCHRONIZATION_UNCERTAIN_NP_t : public BaseMngTlv {
    uint8_t val;
};
struct PORT_SERVICE_STATS_NP_t : public BaseMngTlv {
    PortIdentity_t portIdentity; 
    uint64_t announce_timeout; 
    uint64_t sync_timeout; 
    uint64_t delay_timeout; 
    uint64_t unicast_service_timeout;
    uint64_t unicast_request_timeout;
    uint64_t master_announce_timeout;
    uint64_t master_sync_timeout; 
    uint64_t qualification_timeout; 
    uint64_t sync_mismatch; 
    uint64_t followup_mismatch; 
};
struct UNICAST_MASTER_TABLE_NP_t : public BaseMngTlv {
    Integer16_t actualTableSize; 
    std::vector<LinuxptpUnicastMaster_t> unicastMasters;
};
struct PORT_HWCLOCK_NP_t : public BaseMngTlv {
    PortIdentity_t portIdentity; 
    Integer32_t phc_index; 
    UInteger8_t flags; 
};
struct POWER_PROFILE_SETTINGS_NP_t : public BaseMngTlv {
    linuxptpPowerProfileVersion_e version;
    UInteger16_t grandmasterID; 
    UInteger32_t grandmasterTimeInaccuracy; 
    UInteger32_t networkTimeInaccuracy; 
    UInteger32_t totalTimeInaccuracy; 
};
struct CMLDS_INFO_NP_t : public BaseMngTlv {
    TimeInterval_t meanLinkDelay; 
    Integer32_t scaledNeighborRateRatio;
    uint32_t as_capable; 
};
 
__PTPMGMT_NAMESPACE_END
#else /* __cplusplus */
#include "c/proc.h"
#endif /* __cplusplus */
 
#endif /* __PTPMGMT_PROC_H */