pkt.h

Go to the documentation of this file.

// Copyright (C) 2014-2026 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef PKT_H
#define PKT_H
 
#include <asiolink/io_address.h>
#include <util/buffer.h>
#include <dhcp/option.h>
#include <dhcp/hwaddr.h>
#include <dhcp/classify.h>
#include <hooks/callout_handle_associate.h>
 
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/shared_ptr.hpp>
 
#include <limits>
#include <utility>
#include <vector>
 
namespace isc {
 
namespace dhcp {

constexpr unsigned int UNSET_IFINDEX = std::numeric_limits<unsigned int>::max();

template<typename PktType>
class ScopedEnableOptionsCopy {
public:

    typedef boost::shared_ptr<PktType> PktTypePtr;

    ScopedEnableOptionsCopy(const PktTypePtr& pkt1,
                            const PktTypePtr& pkt2 = PktTypePtr())
        : pkts_(pkt1, pkt2) {
        if (pkt1) {
            pkt1->setCopyRetrievedOptions(true);
        }
        if (pkt2) {
            pkt2->setCopyRetrievedOptions(true);
        }
    }

    ~ScopedEnableOptionsCopy() {
        if (pkts_.first) {
            pkts_.first->setCopyRetrievedOptions(false);
        }
        if (pkts_.second) {
            pkts_.second->setCopyRetrievedOptions(false);
        }
    }
 
private:

    std::pair<PktTypePtr, PktTypePtr> pkts_;
};
 

class PktEvent {
public:
    static const std::string SOCKET_RECEIVED;

    static const std::string BUFFER_READ;

    static const std::string RESPONSE_SENT;

    PktEvent(const std::string& label, boost::posix_time::ptime timestamp)
        : label_(label), timestamp_(timestamp) {
    }

    ~PktEvent() = default;

    static boost::posix_time::ptime now() {
        return (boost::posix_time::microsec_clock::universal_time());
    }

    static boost::posix_time::ptime& EMPTY_TIME() {
        static boost::posix_time::ptime empty_time;
        return (empty_time);
    }

    static boost::posix_time::ptime& MIN_TIME() {
        static auto min_time = boost::posix_time::ptime(boost::posix_time::min_date_time);
        return (min_time);
    }

    static boost::posix_time::ptime& MAX_TIME() {
        static auto max_time = boost::posix_time::ptime(boost::posix_time::max_date_time);
        return (max_time);
    }

    std::string label_;

    boost::posix_time::ptime timestamp_;
};

class Pkt : public hooks::CalloutHandleAssociate {
protected:

    Pkt(uint32_t transid, const isc::asiolink::IOAddress& local_addr,
        const isc::asiolink::IOAddress& remote_addr, uint16_t local_port,
        uint16_t remote_port);

    Pkt(const uint8_t* buf, uint32_t len,
        const isc::asiolink::IOAddress& local_addr,
        const isc::asiolink::IOAddress& remote_addr, uint16_t local_port,
        uint16_t remote_port);
 
public:

    virtual void pack() = 0;

    virtual void unpack() = 0;

    isc::util::OutputBuffer& getBuffer() {
        return (buffer_out_);
    }

    virtual void addOption(const OptionPtr& opt);

    bool delOption(uint16_t type);

    virtual std::string getLabel() const {
        isc_throw(NotImplemented, "Pkt::getLabel()");
    }

    virtual std::string toText(bool verbose = false) const = 0;

    virtual size_t len() = 0;

    virtual uint8_t getType() const = 0;

    virtual void setType(uint8_t type) = 0;

    virtual const char* getName() const = 0;

    void setTransid(uint32_t transid) {
        transid_ = transid;
    }

    uint32_t getTransid() const {
        return (transid_);
    }

    bool inClass(const isc::dhcp::ClientClass& client_class);

    void addClass(const isc::dhcp::ClientClass& client_class);

    void addAdditionalClass(const isc::dhcp::ClientClass& client_class);

    void addSubClass(const isc::dhcp::ClientClass& class_def,
                     const isc::dhcp::ClientClass& subclass);

    const ClientClasses& getClasses() const {
        return (classes_);
    }

    const ClientClasses& getAdditionalClasses() const {
        return (additional_classes_);
    }

    const SubClassRelationContainer& getSubClassesRelations() const {
        return (subclasses_);
    }

    void copyClasses(const Pkt& other);

    OptionBuffer data_;
 
protected:

    OptionPtr getNonCopiedOption(const uint16_t type) const;

    OptionCollection getNonCopiedOptions(const uint16_t opt_type) const;
 
public:

    OptionCollection cloneOptions();

    OptionPtr getOption(const uint16_t type);

    isc::dhcp::OptionCollection getOptions(const uint16_t type);

    virtual void setCopyRetrievedOptions(const bool copy) {
        copy_retrieved_options_ = copy;
    }

    bool isCopyRetrievedOptions() const {
        return (copy_retrieved_options_);
    }

    void updateTimestamp();

    const boost::posix_time::ptime& getTimestamp() const {
        return timestamp_;
    }

    void setTimestamp(boost::posix_time::ptime& timestamp) {
        timestamp_ = timestamp;
    }

    void addPktEvent(const std::string& label,
                     const boost::posix_time::ptime& timestamp = PktEvent::now());

    void addPktEvent(const std::string& label, const struct timeval& timestamp);

    void setPktEvent(const std::string& label,
                     const boost::posix_time::ptime& timestamp = PktEvent::now());

    void clearPktEvents();

    boost::posix_time::ptime getPktEventTime(const std::string& label) const;

    const std::list<PktEvent>& getPktEvents() {
        return (events_);
    }

    std::string dumpPktEvents(bool verbose = false) const;

    void repack();

    void setRemoteAddr(const isc::asiolink::IOAddress& remote) {
        remote_addr_ = remote;
    }

    const isc::asiolink::IOAddress& getRemoteAddr() const {
        return (remote_addr_);
    }

    void setLocalAddr(const isc::asiolink::IOAddress& local) {
        local_addr_ = local;
    }

    const isc::asiolink::IOAddress& getLocalAddr() const {
        return (local_addr_);
    }

    void setLocalPort(uint16_t local) {
        local_port_ = local;
    }

    uint16_t getLocalPort() const {
        return (local_port_);
    }

    void setRemotePort(uint16_t remote) {
        remote_port_ = remote;
    }

    uint16_t getRemotePort() const {
        return (remote_port_);
    }

    void setIndex(const unsigned int ifindex) {
        ifindex_ = ifindex;
    }

    void resetIndex() {
        ifindex_ = UNSET_IFINDEX;
    }

    int getIndex() const {
        return (ifindex_);
    }

    bool indexSet() const {
        return (ifindex_ != UNSET_IFINDEX);
    }

    std::string getIface() const {
        return (iface_);
    }

    void setIface(const std::string& iface) {
        iface_ = iface;
    }

    void setRemoteHWAddr(const HWAddrPtr& hw_addr);

    void setRemoteHWAddr(const uint8_t htype, const uint8_t hlen,
                         const std::vector<uint8_t>& hw_addr);

    HWAddrPtr getRemoteHWAddr() const {
        return (remote_hwaddr_);
    }

    HWAddrPtr getMAC(uint32_t hw_addr_src);

    virtual ~Pkt() {
    }

    ClientClasses classes_;

    ClientClasses additional_classes_;

    SubClassRelationContainer subclasses_;

    isc::dhcp::OptionCollection options_;
 
protected:

    virtual HWAddrPtr getMACFromSrcLinkLocalAddr() = 0;

    virtual HWAddrPtr getMACFromIPv6RelayOpt() = 0;

    virtual HWAddrPtr getMACFromDUID() = 0;

    virtual HWAddrPtr getMACFromRemoteIdRelayOption() = 0;

    HWAddrPtr
    getMACFromIPv6(const isc::asiolink::IOAddress& addr);

    virtual HWAddrPtr getMACFromDocsisModem() = 0;

    virtual HWAddrPtr getMACFromDocsisCMTS() = 0;

    uint32_t transid_;

    std::string iface_;

    unsigned int ifindex_;

    isc::asiolink::IOAddress local_addr_;

    isc::asiolink::IOAddress remote_addr_;

    uint16_t local_port_;

    uint16_t remote_port_;

    isc::util::OutputBuffer buffer_out_;

    bool copy_retrieved_options_;

    boost::posix_time::ptime timestamp_;
 
    // remote HW address (src if receiving packet, dst if sending packet)
    HWAddrPtr remote_hwaddr_;
 
private:

    virtual void setHWAddrMember(const uint8_t htype, const uint8_t hlen,
                                 const std::vector<uint8_t>& hw_addr,
                                 HWAddrPtr& storage);

    std::list<PktEvent> events_;
};

typedef boost::shared_ptr<isc::dhcp::Pkt> PktPtr;

class ScopedSubOptionsCopy {
public:

    ScopedSubOptionsCopy(const OptionPtr& opt) : option_(opt) {
        if (opt) {
            options_ = opt->getMutableOptions();
        }
    }

    ~ScopedSubOptionsCopy() {
        if (option_) {
            option_->getMutableOptions() = options_;
        }
    }
 
private:

    OptionPtr option_;

    OptionCollection options_;
};

template<typename PktType>
class ScopedPktOptionsCopy {
public:

    ScopedPktOptionsCopy(PktType& pkt) : pkt_(pkt), options_(pkt.options_) {
        pkt_.options_ = pkt_.cloneOptions();
    }

    ~ScopedPktOptionsCopy() {
        pkt_.options_ = options_;
    }
 
private:

    PktType& pkt_;

    OptionCollection options_;
};
 
} // end of namespace isc::dhcp
} // end of namespace isc
 
#endif