pkt4.h

Go to the documentation of this file.

// Copyright (C) 2011-2017 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/option.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