pkt4.h

Go to the documentation of this file.

// Copyright (C) 2011-2021 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 PKT4_H
#define PKT4_H

#include <asiolink/io_address.h>
#include <dhcp/duid.h>
#include <util/buffer.h>
#include <dhcp/option.h>
#include <dhcp/classify.h>
#include <dhcp/pkt.h>

#include <boost/shared_ptr.hpp>

#include <iostream>
#include <vector>
#include <set>
#include <list>

#include <time.h>

namespace isc {

namespace dhcp {

class Pkt4 : public Pkt {
public:

    const static size_t MAX_CHADDR_LEN = 16;

    const static size_t MAX_SNAME_LEN = 64;

    const static size_t MAX_FILE_LEN = 128;

    const static size_t DHCPV4_PKT_HDR_LEN = 236;

    const static uint16_t FLAG_BROADCAST_MASK = 0x8000;

    Pkt4(uint8_t msg_type, uint32_t transid);

    Pkt4(const uint8_t* data, size_t len);

    virtual void pack();

    virtual void unpack();

    std::string getLabel() const;

    static std::string makeLabel(const HWAddrPtr& hwaddr,
                                 const ClientIdPtr& client_id,
                                 const uint32_t transid);

    static std::string makeLabel(const HWAddrPtr& hwaddr, const ClientIdPtr& client_id);

    std::string toText() const;

    size_t len();

    void setHops(uint8_t hops) { hops_ = hops; };

    uint8_t getHops() const { return (hops_); };

    // Note: There's no need to manipulate OP field directly,
    // thus no setOp() method. See op_ comment.

    uint8_t getOp() const { return (op_); };

    void setSecs(uint16_t secs) { secs_ = secs; };

    uint16_t getSecs() const { return (secs_); };

    void setFlags(uint16_t flags) { flags_ = flags; };

    uint16_t getFlags() const { return (flags_); };

    const isc::asiolink::IOAddress&
    getCiaddr() const { return (ciaddr_); };

    void
    setCiaddr(const isc::asiolink::IOAddress& ciaddr) { ciaddr_ = ciaddr; };

    const isc::asiolink::IOAddress&
    getSiaddr() const { return (siaddr_); };

    void
    setSiaddr(const isc::asiolink::IOAddress& siaddr) { siaddr_ = siaddr; };

    const isc::asiolink::IOAddress&
    getYiaddr() const { return (yiaddr_); };

    void
    setYiaddr(const isc::asiolink::IOAddress& yiaddr) { yiaddr_ = yiaddr; };

    const isc::asiolink::IOAddress&
    getGiaddr() const { return (giaddr_); };

    void
    setGiaddr(const isc::asiolink::IOAddress& giaddr) { giaddr_ = giaddr; };

    uint8_t getType() const;

    void setType(uint8_t type);

    static const char* getName(const uint8_t type);

    const char* getName() const;

    const OptionBuffer
    getSname() const { return (std::vector<uint8_t>(sname_, &sname_[MAX_SNAME_LEN])); };

    void setSname(const uint8_t* sname, size_t sname_len);

    const OptionBuffer
    getFile() const { return (std::vector<uint8_t>(file_, &file_[MAX_FILE_LEN])); };

    void
    setFile(const uint8_t* file, size_t file_len);

    void setHWAddr(uint8_t htype, uint8_t hlen,
                   const std::vector<uint8_t>& mac_addr);

    void setHWAddr(const HWAddrPtr& addr);

    uint8_t
    getHtype() const;

    uint8_t
    getHlen() const;

    HWAddrPtr getHWAddr() const { return (hwaddr_); }

    virtual void
    addOption(const OptionPtr& opt);

    void setLocalHWAddr(const uint8_t htype, const uint8_t hlen,
                        const std::vector<uint8_t>& mac_addr);

    void setLocalHWAddr(const HWAddrPtr& addr);

    HWAddrPtr getLocalHWAddr() const {
        return (local_hwaddr_);
    }

    std::list<uint16_t>& getDeferredOptions() {
        return (deferred_options_);
    }

    bool isRelayed() const;

    virtual bool isDhcp4o6() const {
        return (false);
    }

private:

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

protected:

    uint8_t
    DHCPTypeToBootpType(uint8_t dhcpType);

    virtual HWAddrPtr getMACFromSrcLinkLocalAddr() {
        return (HWAddrPtr());
    }

    virtual HWAddrPtr getMACFromIPv6RelayOpt() {
        return (HWAddrPtr());
    }

    virtual HWAddrPtr getMACFromDocsisModem() {
        return (HWAddrPtr());
    }

    virtual HWAddrPtr getMACFromDUID(){
        return (HWAddrPtr());
    }

    virtual HWAddrPtr getMACFromDocsisCMTS() {
        return (HWAddrPtr());
    }

    virtual HWAddrPtr getMACFromRemoteIdRelayOption(){
        return(HWAddrPtr());
    }

    HWAddrPtr local_hwaddr_;

    // @brief List of deferred option codes
    std::list<uint16_t> deferred_options_;

    uint8_t op_;

    HWAddrPtr hwaddr_;

    uint8_t hops_;

    uint16_t secs_;

    uint16_t flags_;

    isc::asiolink::IOAddress ciaddr_;

    isc::asiolink::IOAddress yiaddr_;

    isc::asiolink::IOAddress siaddr_;

    isc::asiolink::IOAddress giaddr_;

    uint8_t sname_[MAX_SNAME_LEN];

    uint8_t file_[MAX_FILE_LEN];

    // end of real DHCPv4 fields
}; // Pkt4 class

typedef boost::shared_ptr<Pkt4> Pkt4Ptr;

} // isc::dhcp namespace

} // isc namespace

#endif