pkt.h

Go to the documentation of this file.

// Copyright (C) 2014-2024 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>
 
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() 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,
                  bool required = false);
 
    void addSubClass(const isc::dhcp::ClientClass& class_def,
                     const isc::dhcp::ClientClass& subclass);
 
    const ClientClasses& getClasses(bool required = false) const {
        return (!required ? classes_ : required_classes_);
    }
 
    const SubClassRelationContainer& getSubClassesRelations() const {
        return (subclasses_);
    }
 
    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 required_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