TextBasedProtocol.h

Go to the documentation of this file.

#pragma once
 
#include <map>
#include "Layer.h"
 
 
namespace pcpp
{
 
#define PCPP_END_OF_TEXT_BASED_PROTOCOL_HEADER ""
 
    class TextBasedProtocolMessage;
 
    // -------- Class HeaderField -----------------
 
    class HeaderField
    {
        friend class TextBasedProtocolMessage;
 
    public:
        ~HeaderField();
 
        HeaderField(const HeaderField& other);
 
        HeaderField& operator=(const HeaderField& other);
 
        size_t getFieldSize() const
        {
            return m_FieldSize;
        }
 
        std::string getFieldName() const;
 
        std::string getFieldValue() const;
 
        bool setFieldValue(const std::string& newValue);
 
        bool isEndOfHeader() const
        {
            return m_IsEndOfHeaderField;
        }
 
    private:
        HeaderField(const std::string& name, const std::string& value, char nameValueSeparator,
                    bool spacesAllowedBetweenNameAndValue);
        HeaderField(TextBasedProtocolMessage* TextBasedProtocolMessage, int offsetInMessage, char nameValueSeparator,
                    bool spacesAllowedBetweenNameAndValue);
 
        char* getData() const;
        void setNextField(HeaderField* nextField);
        HeaderField* getNextField() const;
        void initNewField(const std::string& name, const std::string& value);
        void attachToTextBasedProtocolMessage(TextBasedProtocolMessage* message, int fieldOffsetInMessage);
 
        uint8_t* m_NewFieldData;
        TextBasedProtocolMessage* m_TextBasedProtocolMessage;
        int m_NameOffsetInMessage;
        size_t m_FieldNameSize;
        int m_ValueOffsetInMessage;
        size_t m_FieldValueSize;
        size_t m_FieldSize;
        HeaderField* m_NextField;
        bool m_IsEndOfHeaderField;
        char m_NameValueSeparator;
        bool m_SpacesAllowedBetweenNameAndValue;
    };
 
    // -------- Class TextBasedProtocolMessage -----------------
 
    class TextBasedProtocolMessage : public Layer
    {
        friend class HeaderField;
 
    public:
        ~TextBasedProtocolMessage() override;
 
        HeaderField* getFieldByName(std::string fieldName, int index = 0) const;
 
        HeaderField* getFirstField() const
        {
            return m_FieldList;
        }
 
        HeaderField* getNextField(HeaderField* prevField) const
        {
            if (prevField != nullptr)
                return prevField->getNextField();
            else
                return nullptr;
        }
 
        int getFieldCount() const;
 
        virtual HeaderField* addField(const std::string& fieldName, const std::string& fieldValue);
 
        virtual HeaderField* addField(const HeaderField& newField);
 
        HeaderField* addEndOfHeader();
 
        virtual HeaderField* insertField(HeaderField* prevField, const std::string& fieldName,
                                         const std::string& fieldValue);
 
        virtual HeaderField* insertField(std::string prevFieldName, const std::string& fieldName,
                                         const std::string& fieldValue);
 
        virtual HeaderField* insertField(HeaderField* prevField, const HeaderField& newField);
 
        bool removeField(HeaderField* fieldToRemove);
 
        bool removeField(std::string fieldName, int index = 0);
 
        bool isHeaderComplete() const;
 
        // implement Layer's abstract methods
 
        void parseNextLayer() override;
 
        size_t getHeaderLen() const override;
 
        void computeCalculateFields() override;
 
    protected:
        TextBasedProtocolMessage(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet,
                                 ProtocolType protocol);
        TextBasedProtocolMessage() : m_FieldList(nullptr), m_LastField(nullptr), m_FieldsOffset(0)
        {}
 
        // copy c'tor
        TextBasedProtocolMessage(const TextBasedProtocolMessage& other);
        TextBasedProtocolMessage& operator=(const TextBasedProtocolMessage& other);
 
        void copyDataFrom(const TextBasedProtocolMessage& other);
 
        void setFieldsOffset(int fieldsOffset);
        void parseFields();
 
        void shiftFieldsOffset(int numOfBytesToShift);
 
        void shiftFieldsOffset(HeaderField* fromField, int numOfBytesToShift);
 
        // abstract methods
        virtual char getHeaderFieldNameValueSeparator() const = 0;
        virtual bool spacesAllowedBetweenHeaderFieldNameAndValue() const = 0;
 
    private:
        void validateFieldsOffset(int offset) const;
 
        HeaderField* m_FieldList;
        HeaderField* m_LastField;
        int m_FieldsOffset;
        std::multimap<std::string, HeaderField*> m_FieldNameToFieldMap;
    };
}  // namespace pcpp