WakeOnLanLayer.h

Go to the documentation of this file.

#pragma once
 
#include "IpAddress.h"
#include "Layer.h"
#include "MacAddress.h"
 
 
namespace pcpp
{
    class WakeOnLanLayer : public Layer
    {
    private:
        void init(uint16_t len);
 
    public:
#pragma pack(push, 1)
        struct wol_header
        {
            uint8_t sync[6];
            uint8_t addrBody[6 * 16];
        };
#pragma pack(pop)
        static_assert(sizeof(wol_header) == 102, "wol_header size is not 102 bytes");
 
        WakeOnLanLayer(uint8_t* data, size_t dataLen, Layer* prevLayer, Packet* packet)
            : Layer(data, dataLen, prevLayer, packet, WakeOnLan)
        {}
 
        explicit WakeOnLanLayer(const pcpp::MacAddress& targetAddr);
 
        WakeOnLanLayer(const pcpp::MacAddress& targetAddr, uint8_t* password, uint8_t len);
 
        WakeOnLanLayer(const pcpp::MacAddress& targetAddr, const pcpp::MacAddress& password);
 
        WakeOnLanLayer(const pcpp::MacAddress& targetAddr, const IPv4Address& password);
 
        inline wol_header* getWakeOnLanHeader() const
        {
            return reinterpret_cast<wol_header*>(m_Data);
        }
 
        pcpp::MacAddress getTargetAddr() const;
 
        void setTargetAddr(const pcpp::MacAddress& targetAddr);
 
        std::string getPassword() const;
 
        bool setPassword(const uint8_t* password, uint8_t len);
 
        bool setPassword(const std::string& password);
 
        bool setPassword(const MacAddress& addr);
 
        bool setPassword(const IPv4Address& addr);
 
        static bool isWakeOnLanPort(uint16_t port)
        {
            return (port == 0) || (port == 7) || (port == 9);
        }
 
        static bool isDataValid(const uint8_t* data, size_t dataSize);
 
        // overridden methods
 
        void parseNextLayer() override
        {}
 
        size_t getHeaderLen() const override
        {
            return m_DataLen;
        }
 
        void computeCalculateFields() override
        {}
 
        OsiModelLayer getOsiModelLayer() const override
        {
            return OsiModelDataLinkLayer;
        }
 
        std::string toString() const override;
 
        struct SerializedFields : Layer::SerializedFields
        {
            static std::vector<FieldDescriptor> all()
            {
                auto result = Layer::SerializedFields::all();
                std::initializer_list<FieldDescriptor> extra{ TargetAddress, Password };
                std::copy(extra.begin(), extra.end(), std::back_inserter(result));
                return result;
            }
 
            static const FieldDescriptor TargetAddress;
 
            static const FieldDescriptor Password;
        };
 
    protected:
        void serializeLayer(ObjectScope& serializer) const override;
    };
}  // namespace pcpp