Packet.h

Go to the documentation of this file.

#pragma once
 
#include "RawPacket.h"
#include "Layer.h"
#include <vector>
 
 
namespace pcpp
{
    struct PacketParseOptions
    {
        ProtocolTypeFamily parseUntilProtocol = UnknownProtocol;
 
        OsiModelLayer parseUntilLayer = OsiModelLayerUnknown;
    };
 
    class Packet
    {
        friend class Layer;
 
    private:
        RawPacket* m_RawPacket;
        Layer* m_FirstLayer;
        Layer* m_LastLayer;
        size_t m_MaxPacketLen;
        bool m_FreeRawPacket;
        bool m_CanReallocateData;
 
    public:
        explicit Packet(size_t maxPacketLen = 1, LinkLayerType linkType = LINKTYPE_ETHERNET);
 
        Packet(uint8_t* buffer, size_t bufferSize, LinkLayerType linkType = LINKTYPE_ETHERNET);
 
        explicit Packet(RawPacket* rawPacket, bool freeRawPacket = false, ProtocolType parseUntil = UnknownProtocol,
                        OsiModelLayer parseUntilLayer = OsiModelLayerUnknown);
 
        explicit Packet(RawPacket* rawPacket, ProtocolType parseUntil);
 
        explicit Packet(RawPacket* rawPacket, ProtocolTypeFamily parseUntilFamily);
 
        explicit 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, ProtocolTypeFamily parseUntil = UnknownProtocol,
                          OsiModelLayer parseUntilLayer = OsiModelLayerUnknown);
 
        void parsePacket(PacketParseOptions options, bool incrementalParsing = true);
 
        const 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;
 
        bool isPacketOfType(ProtocolTypeFamily protocolTypeFamily) const;
 
        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();
        void destroyAllLayers();
 
        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 <typename TLayer, typename NextLayerFn>
        static TLayer* searchLayerStackForType(Layer* startLayer, NextLayerFn nextLayerFn, bool skipFirst);
    };  // class Packet
 
    // implementation of inline methods
 
    template <class TLayer> TLayer* Packet::getLayerOfType(bool reverse) const
    {
        if (!reverse)
        {
            return searchLayerStackForType<TLayer>(
                m_FirstLayer, [](Layer* layer) { return layer->getNextLayer(); }, false);
        }
 
        // lookup in reverse order
        return searchLayerStackForType<TLayer>(m_LastLayer, [](Layer* layer) { return layer->getPrevLayer(); }, false);
    }
 
    template <class TLayer> TLayer* Packet::getNextLayerOfType(Layer* curLayer) const
    {
        return searchLayerStackForType<TLayer>(curLayer, [](Layer* layer) { return layer->getNextLayer(); }, true);
    }
 
    template <class TLayer> TLayer* Packet::getPrevLayerOfType(Layer* curLayer) const
    {
        return searchLayerStackForType<TLayer>(curLayer, [](Layer* layer) { return layer->getPrevLayer(); }, true);
    }
 
    template <typename TLayer, typename NextLayerFn>
    TLayer* Packet::searchLayerStackForType(Layer* curLayer, NextLayerFn nextLayerFn, bool skipFirst)
    {
        if (curLayer == nullptr)
            return nullptr;
 
        if (skipFirst)
        {
            curLayer = nextLayerFn(curLayer);
        }
 
        while (curLayer != nullptr)
        {
            auto* curLayerCasted = dynamic_cast<TLayer*>(curLayer);
            if (curLayerCasted != nullptr)
                return curLayerCasted;
 
            curLayer = nextLayerFn(curLayer);
        }
 
        return nullptr;
    }
 
    inline std::ostream& operator<<(std::ostream& os, const pcpp::Packet& packet)
    {
        os << packet.toString();
        return os;
    }
}  // namespace pcpp