TextBasedProtocol.h

Go to the documentation of this file.

#ifndef PACKETPP_TEXT_BASED_PROTOCOL_LAYER
#define PACKETPP_TEXT_BASED_PROTOCOL_LAYER

#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();

    HeaderField* getFieldByName(std::string fieldName, int index = 0) const;

    HeaderField* getFirstField() const { return m_FieldList; }

    HeaderField* getNextField(HeaderField* prevField) const { if (prevField != NULL) return prevField->getNextField(); else return NULL; }

    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

    virtual void parseNextLayer();

    size_t getHeaderLen() const;

    virtual void computeCalculateFields();

protected:
    TextBasedProtocolMessage(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet);
    TextBasedProtocolMessage() : m_FieldList(NULL), m_LastField(NULL), m_FieldsOffset(0) {}

    // copy c'tor
    TextBasedProtocolMessage(const TextBasedProtocolMessage& other);
    TextBasedProtocolMessage& operator=(const TextBasedProtocolMessage& other);

    void copyDataFrom(const TextBasedProtocolMessage& other);

    void parseFields();
    void shiftFieldsOffset(HeaderField* fromField, int numOfBytesToShift);

    // abstract methods
    virtual char getHeaderFieldNameValueSeparator() const = 0;
    virtual bool spacesAllowedBetweenHeaderFieldNameAndValue() const = 0;

    HeaderField* m_FieldList;
    HeaderField* m_LastField;
    int m_FieldsOffset;
    std::multimap<std::string, HeaderField*> m_FieldNameToFieldMap;
};


}


#endif // PACKETPP_TEXT_BASED_PROTOCOL_LAYER