Packet.h

Go to the documentation of this file.

#ifndef PACKETPP_PACKET
#define PACKETPP_PACKET
 
#include "RawPacket.h"
#include "Layer.h"
#include <vector>
 
 
namespace pcpp
{
 
    class Packet
    {
        friend class Layer;
    private:
        RawPacket* m_RawPacket;
        Layer* m_FirstLayer;
        Layer* m_LastLayer;
        uint64_t m_ProtocolTypes;
        size_t m_MaxPacketLen;
        bool m_FreeRawPacket;
 
    public:
 
        Packet(size_t maxPacketLen = 1);
 
        Packet(RawPacket* rawPacket, bool freeRawPacket = false, ProtocolType parseUntil = UnknownProtocol, OsiModelLayer parseUntilLayer = OsiModelLayerUnknown);
 
        Packet(RawPacket* rawPacket, ProtocolType parseUntil);
 
        Packet(RawPacket* rawPacket, OsiModelLayer parseUntilLayer);
 
        virtual ~Packet();
 
        Packet(const Packet& other);
 
        Packet& operator=(const Packet& other);
 
        RawPacket* getRawPacket() const { return m_RawPacket; }
 
        void setRawPacket(RawPacket* rawPacket, bool freeRawPacket, ProtocolType parseUntil = UnknownProtocol, OsiModelLayer parseUntilLayer = OsiModelLayerUnknown);
 
        RawPacket* getRawPacketReadOnly() const { return m_RawPacket; }
 
        Layer* getFirstLayer() const { return m_FirstLayer; }
 
        Layer* getLastLayer() const { return m_LastLayer; }
 
        bool addLayer(Layer* newLayer, bool ownInPacket = false);
 
        bool insertLayer(Layer* prevLayer, Layer* newLayer, bool ownInPacket = false);
 
 
        bool removeLayer(ProtocolType layerType, int index = 0);
 
        bool removeFirstLayer();
 
        bool removeLastLayer();
 
        bool removeAllLayersAfter(Layer* layer);
 
        Layer* detachLayer(ProtocolType layerType, int index = 0);
 
        bool detachLayer(Layer* layer);
 
        Layer* getLayerOfType(ProtocolType layerType, int index = 0) const;
 
        template<class TLayer>
        TLayer* getLayerOfType() const;
 
        template<class TLayer>
        TLayer* getNextLayerOfType(Layer* after) const;
 
        bool isPacketOfType(ProtocolType protocolType) const { return m_ProtocolTypes & protocolType; }
 
        void computeCalculateFields();
 
        std::string toString(bool timeAsLocalTime = true);
 
        void toStringList(std::vector<std::string>& result, bool timeAsLocalTime = true) const;
 
    private:
        void copyDataFrom(const Packet& other);
 
        void destructPacketData();
 
        bool extendLayer(Layer* layer, int offsetInLayer, size_t numOfBytesToExtend);
        bool shortenLayer(Layer* layer, int offsetInLayer, size_t numOfBytesToShorten);
 
        void reallocateRawData(size_t newSize);
 
        bool removeLayer(Layer* layer, bool tryToDelete);
 
        std::string printPacketInfo(bool timeAsLocalTime) const;
 
        Layer* createFirstLayer(LinkLayerType linkType);
    };
 
    template<class TLayer>
    TLayer* Packet::getLayerOfType() const
    {
        if (dynamic_cast<TLayer*>(m_FirstLayer) != NULL)
            return (TLayer*)m_FirstLayer;
 
        return getNextLayerOfType<TLayer>(m_FirstLayer);
    }
 
    template<class TLayer>
    TLayer* Packet::getNextLayerOfType(Layer* after) const
    {
        if (after == NULL)
            return NULL;
 
        Layer* curLayer = after->getNextLayer();
        while ((curLayer != NULL) && (dynamic_cast<TLayer*>(curLayer) == NULL))
        {
            curLayer = curLayer->getNextLayer();
        }
 
        return (TLayer*)curLayer;
    }
 
} // namespace pcpp
 
#endif /* PACKETPP_PACKET */