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 "proc.h"
#include "sig.h"
 
__PTPMGMT_NAMESPACE_BEGIN
 
struct MsgProc;
class Message;
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 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 */
    std::vector<std::unique_ptr<BaseSigTlv>> m_sigTlvs;
    /* hold signalling TLVs type */
    std::vector<tlvType_e> m_sigTlvsType;
    /* 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;  
    HMAC_Key         *m_hmac = nullptr; 
    /* 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;
 
    /* Map to all management IDs */
    static const ManagementId_t mng_all_vals[];
 
    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
     * The size is determined by the m_dataSend content
     */
    ssize_t dataFieldSize(const BaseMngTlv *data) const;
    static bool verifyTlv(mng_vals_e tlv_id, const BaseMngTlv *tlv);
 
  public:
    Message();
    ~Message();
    Message(const MsgParams &prms);
    const MsgParams &getParams() const { return m_prms; }
    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() { m_haveAuth = false; return true; }
    int usedAuthSppID() const { return m_haveAuth ? m_sppID : -1; }
    uint32_t usedAuthKeyID() const { return m_haveAuth ? m_keyID : 0; }
    const SaFile &getSa() const { return m_sa; }
    bool haveAuth() const { return m_haveAuth; }
    mng_vals_e getTlvId() const { return m_replayTlv_id; }
    mng_vals_e getBuildTlvId() const { return m_tlv_id; }
    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) { return (flags & F_LI_61) != 0; }
    static bool is_LI_59(uint8_t flags) { return (flags & F_LI_59) != 0; }
    static bool is_UTCV(uint8_t flags) { return (flags & F_UTCV) != 0; }
    static bool is_PTP(uint8_t flags) { return (flags & F_PTP) != 0; }
    static bool is_TTRA(uint8_t flags) { return (flags & F_TTRA) != 0; }
    static bool is_FTRA(uint8_t flags) { return (flags & F_FTRA) != 0; }
    static bool isEmpty(mng_vals_e id);
    bool isValidId(mng_vals_e id);
    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)
    { return build(buf.get(), buf.size(), sequence); }
    actionField_e getSendAction() const { return m_sendAction; }
    size_t getMsgLen() const { return m_msgLen; }
    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 { return m_replyAction; }
    bool isUnicast() const { return m_isUnicast; }
    uint8_t getPTPProfileSpecific() const { return m_PTPProfileSpecific; }
    uint16_t getSequence() const { return m_sequence; }
    const PortIdentity_t &getPeer() const { return m_peer; }
    const PortIdentity_t &getTarget() const { return m_target; }
    uint32_t getSdoId() const { return m_sdoId; }
    uint8_t getDomainNumber() const { return m_domainNumber; }
    uint8_t getVersionPTP() const { return m_versionPTP; }
    uint8_t getMinorVersionPTP() const { return m_minorVersionPTP; }
    const BaseMngTlv *getData() const { return m_dataGet.get(); }
    const BaseMngTlv *getSendData() const { return m_dataSend; }
    managementErrorId_e getErrId() const { return m_errorId; }
    const std::string &getErrDisplay() const { return m_errorDisplay.textField; }
    const char *getErrDisplay_c() const { return m_errorDisplay.string(); }
    bool isLastMsgSig() const { return m_type == Signaling; }
    bool isLastMsgSMPTE() const;
    msgType_e getType() const { return m_type; }
    tlvType_e getMngType() const { return m_mngType; }
    bool traversSigTlvs(const std::function<bool (const Message &msg,
            tlvType_e tlvType, const BaseSigTlv *tlv)> callback) const;
    bool traversSigTlvsCl(MessageSigTlvCallback &callback);
    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;
};
 
__PTPMGMT_NAMESPACE_END
#else /* __cplusplus */
#include "c/msg.h"
#endif /* __cplusplus */
 
#endif /* __PTPMGMT_MSG_H */