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;
        bool m_CanReallocateData;

    public:

        explicit Packet(size_t maxPacketLen = 1);

        Packet(uint8_t* buffer, size_t bufferSize);

        explicit Packet(RawPacket* rawPacket, bool freeRawPacket = false, ProtocolType parseUntil = UnknownProtocol, OsiModelLayer parseUntilLayer = OsiModelLayerUnknown);

        Packet(RawPacket* rawPacket, ProtocolType parseUntil);

        Packet(RawPacket* rawPacket, OsiModelLayer parseUntilLayer);

        virtual ~Packet() { destructPacketData(); }

        Packet(const Packet& other) { copyDataFrom(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) { return insertLayer(m_LastLayer, newLayer, ownInPacket); }

        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) { return removeLayer(layer, false); }

        Layer* getLayerOfType(ProtocolType layerType, int index = 0) const;

        template<class TLayer>
        TLayer* getLayerOfType(bool reverseOrder = false) const;

        template<class TLayer>
        TLayer* getNextLayerOfType(Layer* startLayer) const;

        template<class TLayer>
        TLayer* getPrevLayerOfType(Layer* startLayer) const;

        bool isPacketOfType(ProtocolType protocolType) const { return m_ProtocolTypes & protocolType; }

        void computeCalculateFields();

        std::string toString(bool timeAsLocalTime = true) const;

        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);
    }; // class Packet


    // implementation of inline methods

    template<class TLayer>
    TLayer* Packet::getLayerOfType(bool reverse) const
    {
        if (!reverse)
        {
            if (dynamic_cast<TLayer*>(getFirstLayer()) != NULL)
                return dynamic_cast<TLayer*>(getFirstLayer());

            return getNextLayerOfType<TLayer>(getFirstLayer());
        }

        // lookup in reverse order
        if (dynamic_cast<TLayer*>(getLastLayer()) != NULL)
            return dynamic_cast<TLayer*>(getLastLayer());

        return getPrevLayerOfType<TLayer>(getLastLayer());
    }

    template<class TLayer>
    TLayer* Packet::getNextLayerOfType(Layer* curLayer) const
    {
        if (curLayer == NULL)
            return NULL;

        curLayer = curLayer->getNextLayer();
        while ((curLayer != NULL) && (dynamic_cast<TLayer*>(curLayer) == NULL))
        {
            curLayer = curLayer->getNextLayer();
        }

        return dynamic_cast<TLayer*>(curLayer);
    }

    template<class TLayer>
    TLayer* Packet::getPrevLayerOfType(Layer* curLayer) const
    {
        if (curLayer == NULL)
            return NULL;

        curLayer = curLayer->getPrevLayer();
        while (curLayer != NULL && dynamic_cast<TLayer*>(curLayer) == NULL)
        {
            curLayer = curLayer->getPrevLayer();
        }

        return dynamic_cast<TLayer*>(curLayer);
    }

} // namespace pcpp

inline std::ostream& operator<<(std::ostream& os, const pcpp::Packet& packet)
{
    os << packet.toString();
    return os;
}

#endif /* PACKETPP_PACKET */