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(std::string newValue);
 
    bool isEndOfHeader() const { return m_IsEndOfHeaderField; }
 
private:
    HeaderField(std::string name, std::string value, char nameValueSeperator, bool spacesAllowedBetweenNameAndValue);
    HeaderField(TextBasedProtocolMessage* TextBasedProtocolMessage, int offsetInMessage, char nameValueSeperator, bool spacesAllowedBetweenNameAndValue);
 
    char* getData() const;
    void setNextField(HeaderField* nextField);
    HeaderField *getNextField() const;
    void initNewField(std::string name, 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_NameValueSeperator;
    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