NtpLayer.h

Go to the documentation of this file.

#ifndef PACKETPP_NTP_LAYER
#define PACKETPP_NTP_LAYER

#include "Logger.h"
#include "Layer.h"
#include "IpAddress.h"


namespace pcpp
{
    class NtpLayer : public Layer
    {
    private:
#pragma pack(push, 1)
        struct ntp_header
        {
#if (BYTE_ORDER == LITTLE_ENDIAN)
            uint8_t mode:3,
            version:3,
            leapIndicator:2;
#else
            uint8_t leapIndicator:2,
            version:3,
            mode:3;
#endif
            uint8_t stratum;
            int8_t pollInterval,
            precision;
            uint32_t rootDelay,
            rootDispersion,
            referenceIdentifier;
            uint64_t referenceTimestamp,
            originTimestamp,
            receiveTimestamp,
            transmitTimestamp;
        };
#pragma pack(pop)

#pragma pack(push, 1)
        struct ntp_v3_auth
        {
            uint32_t keyID;
            uint8_t dgst[8]; // 64 bit DES based
        };
#pragma pack(pop)

#pragma pack(push, 1)
        struct ntp_v4_auth_md5
        {
            uint32_t keyID;
            uint8_t dgst[16];
        };
#pragma pack(pop)

#pragma pack(push, 1)
        struct ntp_v4_auth_sha1
        {
            uint32_t keyID;
            uint8_t dgst[20];
        };
#pragma pack(pop)

        ntp_header *getNtpHeader() const { return (ntp_header *)m_Data; }

    public:
        enum LeapIndicator
        {
            NoWarning = 0,
            Last61Secs,
            Last59Secs,
            Unknown
        };

        enum Mode
        {
            Reserved = 0,
            SymActive,
            SymPassive,
            Client,
            Server,
            Broadcast,
            Control,
            PrivateUse
        };

        enum ClockSource
        {
            // NTPv4

            GOES = ('G') | ('O' << 8) | ('E' << 16) | ('S' << 24),
            GPS = ('G') | ('P' << 8) | ('S' << 16),
            GAL = ('G') | ('A' << 8) | ('L' << 16),
            PPS = ('P') | ('P' << 8) | ('S' << 16),
            IRIG = ('I') | ('R' << 8) | ('I' << 16) | ('G' << 24),
            WWVB = ('W') | ('W' << 8) | ('V' << 16) | ('B' << 24),
            DCF = ('D') | ('C' << 8) | ('F' << 16),
            HBG = ('H') | ('B' << 8) | ('G' << 16),
            MSF = ('M') | ('S' << 8) | ('F' << 16),
            JJY = ('J') | ('J' << 8) | ('Y' << 16),
            LORC = ('L') | ('O' << 8) | ('R' << 16) | ('C' << 24),
            TDF = ('T') | ('D' << 8) | ('F' << 16),
            CHU = ('C') | ('H' << 8) | ('U' << 16),
            WWV = ('W') | ('W' << 8) | ('V' << 16),
            WWVH = ('W') | ('W' << 8) | ('V' << 16) | ('H' << 24),
            NIST = ('N') | ('I' << 8) | ('S' << 16) | ('T' << 24),
            ACTS = ('A') | ('C' << 8) | ('T' << 16) | ('S' << 24),
            USNO = ('U') | ('S' << 8) | ('N' << 16) | ('O' << 24),
            PTB = ('P') | ('T' << 8) | ('B' << 16),
            DCFa = ('D') | ('C' << 8) | ('F' << 16) | ('a' << 24),
            DCFp = ('D') | ('C' << 8) | ('F' << 16) | ('p' << 24),
            GPSs = ('G') | ('P' << 8) | ('S' << 16) | ('s' << 24),
            GPSi = ('G') | ('P' << 8) | ('S' << 16) | ('i' << 24),
            GLNs = ('G') | ('L' << 8) | ('N' << 16) | ('s' << 24),
            GLNi = ('G') | ('L' << 8) | ('N' << 16) | ('i' << 24),
            LCL = ('L') | ('C' << 8) | ('L' << 16),
            LOCL = ('L') | ('O' << 8) | ('C' << 16) | ('L' << 24),

            // NTPv3

            DCN = ('D') | ('C' << 8) | ('N' << 16),
            TSP = ('T') | ('S' << 8) | ('P' << 16),
            DTS = ('D') | ('T' << 8) | ('S' << 16),
            ATOM = ('A') | ('T' << 8) | ('O' << 16) | ('M' << 24),
            VLF = ('V') | ('L' << 8) | ('F' << 16)

        };

        NtpLayer(uint8_t *data, size_t dataLen, Layer *prevLayer, Packet *packet) : Layer(data, dataLen, prevLayer, packet) { m_Protocol = NTP; }

        NtpLayer();

        LeapIndicator getLeapIndicator() const;

        void setLeapIndicator(LeapIndicator val);

        uint8_t getVersion() const;

        void setVersion(uint8_t val);

        Mode getMode() const;

        std::string getModeString() const;

        void setMode(Mode val);

        uint8_t getStratum() const;

        void setStratum(uint8_t val);

        int8_t getPollInterval() const;

        void setPollInterval(int8_t val);

        double getPollIntervalInSecs() const;

        int8_t getPrecision() const;

        void setPrecision(int8_t val);

        double getPrecisionInSecs() const;

        uint32_t getRootDelay() const;

        void setRootDelay(uint32_t val);

        double getRootDelayInSecs() const;

        void setRootDelayInSecs(double val);

        uint32_t getRootDispersion() const;

        void setRootDispersion(uint32_t val);

        double getRootDispersionInSecs() const;

        void setRootDispersionInSecs(double val);

        uint32_t getReferenceIdentifier() const;

        void setReferenceIdentifier(IPv4Address val);

        void setReferenceIdentifier(ClockSource val);

        std::string getReferenceIdentifierString() const;

        uint64_t getReferenceTimestamp() const;

        void setReferenceTimestamp(uint64_t val);

        double getReferenceTimestampInSecs() const;

        void setReferenceTimestampInSecs(double val);

        std::string getReferenceTimestampAsString();

        uint64_t getOriginTimestamp() const;

        void setOriginTimestamp(uint64_t val);

        double getOriginTimestampInSecs() const;

        void setOriginTimestampInSecs(double val);

        std::string getOriginTimestampAsString();

        uint64_t getReceiveTimestamp() const;

        void setReceiveTimestamp(uint64_t val);

        double getReceiveTimestampInSecs() const;

        void setReceiveTimestampInSecs(double val);

        std::string getReceiveTimestampAsString();

        uint64_t getTransmitTimestamp() const;

        void setTransmitTimestamp(uint64_t val);

        double getTransmitTimestampInSecs() const;

        void setTransmitTimestampInSecs(double val);

        std::string getTransmitTimestampAsString();

        uint32_t getKeyID() const;

        std::string getDigest() const;

        static double convertFromShortFormat(const uint32_t val);

        static double convertFromTimestampFormat(const uint64_t val);

        static uint32_t convertToShortFormat(const double val);

        static uint64_t convertToTimestampFormat(const double val);

        static std::string convertToIsoFormat(const double timestamp);

        static std::string convertToIsoFormat(const uint64_t timestampInNTPformat);

        static bool isDataValid(const uint8_t *data, size_t dataSize);

        static bool isNTPPort(uint16_t port) { return port == 123; }

        // overridden methods

        void parseNextLayer() {}

        size_t getHeaderLen() const { return m_DataLen; }

        void computeCalculateFields() {}

        OsiModelLayer getOsiModelLayer() const { return OsiModelApplicationLayer; }

        std::string toString() const;
    };

} // namespace pcpp

#endif /* PACKETPP_NTP_LAYER */