msg.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_MSG_H
#define __PTPMGMT_MSG_H
 
#ifdef __cplusplus
#include <functional>
#include "cfg.h"
#include "buf.h"
#include "mngTlvs.h"
#include "sigTlvs.h"
 
__PTPMGMT_NAMESPACE_BEGIN
 
struct MsgProc;
class Message;
class MessageSigTlvs;
struct HMAC_Key;
 
class MessageSigTlvCallback
{
  public:
    MessageSigTlvCallback() = default;
    virtual ~MessageSigTlvCallback() = default;
    virtual bool callback(const Message &msg, tlvType_e tlvType,
        const BaseSigTlv *tlv) = 0;
};
class MessageSigTlv
{
  private:
    std::unique_ptr<BaseSigTlv> m_tlv; 
    tlvType_e m_tlvType; 
  protected:
    friend class MessageSigTlvs;
    MessageSigTlv(BaseSigTlv *tlv, tlvType_e tlvType);
  public:
    MessageSigTlv(const MessageSigTlv &other);
    #ifndef SWIG
    MessageSigTlv(MessageSigTlv &&other);
    #endif /* SWIG */
    tlvType_e tlvType() const;
    const BaseSigTlv *tlv() const;
};
class MessageSigTlvs
{
  private:
    /* Parent class */
    Message &m_msg;
    /* hold signalling TLVs */
    std::vector<MessageSigTlv> m_tlvs;
  protected:
    friend class Message;
    bool m_lastSig = false; /* indicate last parse was signaling */
    MessageSigTlvs(Message &m) : m_msg(m) {};
    void clearToUse() { m_tlvs.clear(); m_lastSig = true; }
    const MANAGEMENT_t *getMng(size_t position) const;
    void push(tlvType_e tlvType, BaseSigTlv *tlv);
 
  public:
    #ifndef SWIG
    class iterator
    {
      private:
        std::vector<MessageSigTlv>::const_iterator it;
      protected:
        iterator(const std::vector<MessageSigTlv>::const_iterator &it);
        friend class MessageSigTlvs;
      public:
        /* iterator need to support these following operators */
        iterator &operator++(); /* prefix increment */
        iterator &operator++(int); /* postfix increment */
        const MessageSigTlv &operator*();
        bool operator!=(iterator &o);
    };
    #endif /* SWIG */
    MessageSigTlvs(const MessageSigTlvs &other);
    bool traverse(const std::function<bool (const Message &msg,
            tlvType_e tlvType, const BaseSigTlv *tlv)> &callback) const;
    bool traverse(MessageSigTlvCallback &callback) const;
    size_t size() const;
    const BaseSigTlv *get(size_t position) const;
    tlvType_e getType(size_t position) const;
    mng_vals_e getTlvId(size_t position) const;
    const BaseMngTlv *getMngTlv(size_t position) const;
    const MessageSigTlv &getTlv(size_t position) const;
    #ifndef SWIG
    MessageSigTlvs(MessageSigTlvs &&other);
    iterator begin() const;
    iterator end() const;
    #endif /* SWIG */
};
 
class Message
{
  private:
 
    /* build parameters */
    actionField_e     m_sendAction = GET;
    size_t            m_msgLen = 0;
    const BaseMngTlv *m_dataSend = nullptr;
    mng_vals_e        m_tlv_id = NULL_PTP_MANAGEMENT; /* managementId */
 
    /* parsing parameters */
    uint16_t          m_sequence = 0;
    bool              m_isUnicast = true;
    uint8_t           m_PTPProfileSpecific = 0;
    actionField_e     m_replyAction = RESPONSE;
    mng_vals_e        m_replayTlv_id = NULL_PTP_MANAGEMENT; /* managementId */
    uint32_t          m_sdoId = 0; /* parsed message sdoId (transportSpecific) */
    msgType_e         m_type = Management; /* parsed message type */
    tlvType_e         m_mngType = MANAGEMENT; /* parsed management message type */
    uint8_t           m_domainNumber = 0; /* parsed message domainNumber*/
    uint8_t           m_versionPTP = 2; /* parsed message ptp version */
    uint8_t           m_minorVersionPTP = 1; /* parsed message ptp version */
    /* hold signalling TLVs */
    MessageSigTlvs m_sigTlvs;
    /* parsed management TLV */
    std::unique_ptr<BaseMngTlv> m_dataGet;
 
    /* Generic */
    MsgParams         m_prms;
 
    /* Authentication TLV */
    uint32_t          m_keyID = 0; 
    uint8_t           m_sppID = -1; 
    SaFile            m_sa; 
    bool              m_haveAuth = false;  
    std::unique_ptr<HMAC_Key> m_hmac; 
    /* parsing parameters */
    PortIdentity_t    m_peer; /* parsed message peer port id */
    PortIdentity_t    m_target; /* parsed message target port id */
 
    /* For error messages */
    managementErrorId_e m_errorId = (managementErrorId_e)0;
    PTPText_t m_errorDisplay;
 
    bool allowedAction(mng_vals_e id, actionField_e action);
    /* val in network order */
    static bool findTlvId(uint16_t val, mng_vals_e &rid, implementSpecific_e spec);
    bool checkReplyAction(uint8_t actionField);
    /* parse signalling message */
    MNG_PARSE_ERROR_e parseSig(const void *buf, MsgProc *);
    /* parse authentication message */
    MNG_PARSE_ERROR_e parseAuth(const void *buf, const void *auth, ssize_t left,
        bool check = false);
    /*
     * dataFieldSize() for sending SET/COMMAND
     * Get dataField of current build management ID
     * For id with non fixed size
     * @param[in] tlv to size
     * The size is determined by the m_dataSend content
     */
    ssize_t dataFieldSize(const BaseMngTlv *tlv) const;
    static bool verifyTlv(mng_vals_e tlv_id, const BaseMngTlv *tlv);
 
  public:
    Message();
    ~Message();
    Message(const MsgParams &prms);
    const MsgParams &getParams() const;
    bool updateParams(const MsgParams &prms);
    bool useAuth(const ConfigFile &cfg, const std::string &section = "");
    bool useAuth(const SaFile &sa, uint8_t spp, uint32_t key);
    bool changeAuth(uint8_t spp, uint32_t key);
    bool changeAuth(uint32_t key);
    bool disableAuth();
    int usedAuthSppID() const;
    uint32_t usedAuthKeyID() const;
    const SaFile &getSa() const;
    bool haveAuth() const;
    mng_vals_e getTlvId() const;
    mng_vals_e getBuildTlvId() const;
    void setAllClocks();
    bool isAllClocks() const;
    bool useConfig(const ConfigFile &cfg, const std::string &section = "");
    static const char *err2str_c(MNG_PARSE_ERROR_e err);
 
    static const char *type2str_c(msgType_e type);
    static const char *tlv2str_c(tlvType_e type);
    static const char *act2str_c(actionField_e action);
    static const char *mng2str_c(mng_vals_e id);
    static const bool findMngID(const std::string &str, mng_vals_e &id,
        bool exact = true);
    static const char *errId2str_c(managementErrorId_e err);
    static const char *clkType2str_c(clockType_e type);
    static const char *netProt2str_c(networkProtocol_e protocol);
    static const char *clockAcc2str_c(clockAccuracy_e value);
    static const char *faultRec2str_c(faultRecord_e code);
    static const char *timeSrc2str_c(timeSource_e type);
    static const bool findTimeSrc(const std::string &str, timeSource_e &type,
        bool exact = true);
    static const char *portState2str_c(portState_e state);
    static const bool findPortState(const std::string &str, portState_e &state,
        bool caseSens = true);
    static const char *delayMech2str_c(delayMechanism_e type);
    static const bool findDelayMech(const std::string &str, delayMechanism_e &type,
        bool exact = true);
    static const char *smpteLck2str_c(SMPTEmasterLockingStatus_e state);
    static const char *ts2str_c(linuxptpTimeStamp_e type);
    static const char *pwr2str_c(linuxptpPowerProfileVersion_e ver);
    static const char *us2str_c(linuxptpUnicastState_e state);
    static bool is_LI_61(uint8_t flags);
    static bool is_LI_59(uint8_t flags);
    static bool is_UTCV(uint8_t flags);
    static bool is_PTP(uint8_t flags);
    static bool is_TTRA(uint8_t flags);
    static bool is_FTRA(uint8_t flags);
    static bool isEmpty(mng_vals_e id);
    bool isValidId(mng_vals_e id) const;
    bool setAction(actionField_e actionField, mng_vals_e tlv_id,
        const BaseMngTlv *dataSend = nullptr);
    void clearData();
    MNG_PARSE_ERROR_e build(void *buf, size_t bufSize, uint16_t sequence);
    MNG_PARSE_ERROR_e build(Buf &buf, uint16_t sequence);
    actionField_e getSendAction() const;
    size_t getMsgLen() const;
    ssize_t getMsgPlanedLen() const;
    /* Parsed message functions */
    MNG_PARSE_ERROR_e parse(const void *buf, ssize_t msgSize);
    MNG_PARSE_ERROR_e parse(const Buf &buf, ssize_t msgSize);
    actionField_e getReplyAction() const;
    bool isUnicast() const;
    uint8_t getPTPProfileSpecific() const;
    uint16_t getSequence() const;
    const PortIdentity_t &getPeer() const;
    const PortIdentity_t &getTarget() const;
    uint32_t getSdoId() const;
    uint8_t getDomainNumber() const;
    uint8_t getVersionPTP() const;
    uint8_t getMinorVersionPTP() const;
    const BaseMngTlv *getData() const;
    const BaseMngTlv *getSendData() const;
    managementErrorId_e getErrId() const;
    const std::string &getErrDisplay() const;
    const char *getErrDisplay_c() const;
    bool isLastMsgSig() const;
    bool isLastMsgSMPTE() const;
    msgType_e getType() const;
    tlvType_e getMngType() const;
    bool traversSigTlvs(const std::function<bool (const Message &msg,
            tlvType_e tlvType, const BaseSigTlv *tlv)> callback) const;
    bool traversSigTlvsCl(MessageSigTlvCallback &callback) const;
    size_t getSigTlvsCount() const;
    const BaseSigTlv *getSigTlv(size_t position) const;
    tlvType_e getSigTlvType(size_t position) const;
    mng_vals_e getSigMngTlvType(size_t position) const;
    const BaseMngTlv *getSigMngTlv(size_t position) const;
    const MessageSigTlvs &getSigTlvs() const;
};
 
__PTPMGMT_NAMESPACE_END
#else /* __cplusplus */
#include "c/msg.h"
#endif /* __cplusplus */
 
#endif /* __PTPMGMT_MSG_H */