pkt.h

Go to the documentation of this file.

// Copyright (C) 2014-2022 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 <utility>

namespace isc {

namespace dhcp {

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 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);

    const ClientClasses& getClasses(bool required = false) const {
        return (!required ? classes_ : required_classes_);
    }

    OptionBuffer data_;

protected:

    OptionPtr getNonCopiedOption(const uint16_t type) const;

public:

    OptionPtr getOption(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 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(int ifindex) {
        ifindex_ = ifindex;
    };

    void resetIndex() {
        ifindex_ = -1;
    }

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

    bool indexSet() const {
        return (ifindex_ >= 0);
    }

    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_;

    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_;

    int64_t 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);
};

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_) {
    }

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

private:

    PktType& pkt_;

    OptionCollection options_;
};

} // end of namespace isc::dhcp
} // end of namespace isc

#endif