26const IOAddress DEFAULT_ADDRESS(
"0.0.0.0");
 
   33    : 
Pkt(transid, DEFAULT_ADDRESS, DEFAULT_ADDRESS, DHCP4_SERVER_PORT, DHCP4_CLIENT_PORT),
 
 
   44    : 
Pkt(
data, 
len, DEFAULT_ADDRESS, DEFAULT_ADDRESS, DHCP4_SERVER_PORT, DHCP4_CLIENT_PORT),
 
 
   64        length += it.second->len();
 
 
   86        size_t hw_len = 
hwaddr_->hwaddr_.size();
 
  114            vector<uint8_t> zeros(hw_len, 0);
 
 
  157                  << buffer_in.
getLength() << 
" received, at least " 
  178    hw_addr.resize(hlen);
 
  195    if (magic != DHCP_OPTIONS_COOKIE) {
 
  200    vector<uint8_t> opts_buffer;
 
 
  241    boost::shared_ptr<OptionInt<uint8_t> > type_opt =
 
  242        boost::dynamic_pointer_cast<OptionInt<uint8_t> >(
generic);
 
  244        return (type_opt->getValue());
 
  248    return (generic->getUint8());
 
 
  266        boost::shared_ptr<OptionInt<uint8_t> > type_opt =
 
  267            boost::dynamic_pointer_cast<OptionInt<uint8_t> >(opt);
 
  269            type_opt->setValue(dhcp_type);
 
  271            opt->setUint8(dhcp_type);
 
 
  283    static const char* DHCPDISCOVER_NAME = 
"DHCPDISCOVER";
 
  284    static const char* DHCPOFFER_NAME = 
"DHCPOFFER";
 
  285    static const char* DHCPREQUEST_NAME = 
"DHCPREQUEST";
 
  286    static const char* DHCPDECLINE_NAME = 
"DHCPDECLINE";
 
  287    static const char* DHCPACK_NAME = 
"DHCPACK";
 
  288    static const char* DHCPNAK_NAME = 
"DHCPNAK";
 
  289    static const char* DHCPRELEASE_NAME = 
"DHCPRELEASE";
 
  290    static const char* DHCPINFORM_NAME = 
"DHCPINFORM";
 
  291    static const char* DHCPLEASEQUERY_NAME = 
"DHCPLEASEQUERY";
 
  292    static const char* DHCPLEASEUNASSIGNED_NAME = 
"DHCPLEASEUNASSIGNED";
 
  293    static const char* DHCPLEASEUNKNOWN_NAME = 
"DHCPLEASEUNKNOWN";
 
  294    static const char* DHCPLEASEACTIVE_NAME = 
"DHCPLEASEACTIVE";
 
  295    static const char* DHCPBULKLEASEQUERY_NAME = 
"DHCPBULKLEASEQUERY";
 
  296    static const char* DHCPLEASEQUERYDONE_NAME = 
"DHCPLEASEQUERYDONE";
 
  297    static const char* DHCPLEASEQUERYSTATUS_NAME = 
"DHCPLEASEQUERYSTATUS";
 
  298    static const char* DHCPTLS_NAME = 
"DHCPTLS";
 
  299    static const char* UNKNOWN_NAME = 
"UNKNOWN";
 
  303            return (DHCPDISCOVER_NAME);
 
  306            return (DHCPOFFER_NAME);
 
  309            return (DHCPREQUEST_NAME);
 
  312            return (DHCPDECLINE_NAME);
 
  315            return (DHCPACK_NAME);
 
  318            return (DHCPNAK_NAME);
 
  321            return (DHCPRELEASE_NAME);
 
  324            return (DHCPINFORM_NAME);
 
  327            return (DHCPLEASEQUERY_NAME);
 
  330            return (DHCPLEASEUNASSIGNED_NAME);
 
  333            return (DHCPLEASEUNKNOWN_NAME);
 
  336            return (DHCPLEASEACTIVE_NAME);
 
  339            return (DHCPBULKLEASEQUERY_NAME);
 
  342            return (DHCPLEASEQUERYDONE_NAME);
 
  345            return (DHCPLEASEQUERYSTATUS_NAME);
 
  348            return (DHCPTLS_NAME);
 
  353    return (UNKNOWN_NAME);
 
 
  377            suffix = 
" (malformed client-id)";
 
  381    std::ostringstream label;
 
  388        label << 
" (malformed hw address)";
 
  393    return (label.str());
 
 
  398                const uint32_t transid) {
 
  404    label << 
", tid=0x" << hex << transid << dec;
 
  406    return (label.str());
 
 
  412    label << 
"[" << (hwaddr ? hwaddr->toText() : 
"no hwaddr info")
 
  413          << 
"], cid=[" << (client_id ? client_id->toText() : 
"no info")
 
  416    return (label.str());
 
 
  432        tmp << 
getName(msg_type) << 
" (" << 
static_cast<int>(msg_type) << 
")";
 
  438    tmp << 
", trans_id=0x" << hex << 
transid_ << dec;
 
  441        tmp << 
"," << endl << 
"options:";
 
  444                tmp << endl << opt.second->toText(2);
 
  446                tmp << 
"(unknown)" << endl;
 
  451        tmp << 
"," << endl << 
"message contains no options";
 
 
  459                const std::vector<uint8_t>& mac_addr) {
 
  460    setHWAddrMember(htype, hlen, mac_addr, 
hwaddr_);
 
 
  473Pkt4::setHWAddrMember(
const uint8_t htype, 
const uint8_t hlen,
 
  474                      const std::vector<uint8_t>& mac_addr,
 
  482    } 
else if (mac_addr.empty() && (hlen > 0) ) {
 
  489    hw_addr.reset(
new HWAddr(mac_addr, htype));
 
  494                      const std::vector<uint8_t>& mac_addr) {
 
 
  513    } 
else if (sname == NULL) {
 
  517    std::copy(sname, (sname + snameLen), 
sname_);
 
 
  529                  << 
") too long, Max " << 
MAX_FILE_LEN << 
" supported.");
 
  531    } 
else if (
file == NULL) {
 
 
  567                  << 
static_cast<int>(dhcpType) );
 
 
  593                  << 
" already present in this message.");
 
 
  606    std::ostringstream label;
 
  608    hwaddr_ ? label << 
hwaddr_->toText(
false) : label << 
"(undefined)";
 
  609    return (label.str());
 
 
A generic exception that is thrown if a parameter given to a method is considered invalid in that con...
This is a base class for exceptions thrown from the DNS library module.
virtual const char * what() const
Returns a C-style character string of the cause of the exception.
A generic exception that is thrown if a function is called in a prohibited way.
A generic exception that is thrown if a parameter given to a method or function is considered invalid...
A generic exception that is thrown if a parameter given to a method would refer to or modify out-of-r...
A generic exception that is thrown when an unexpected error condition occurs.
The IOAddress class represents an IP addresses (version agnostic)
Holds Client identifier or client IPv4 address.
static size_t unpackOptions4(const OptionBuffer &buf, const std::string &option_space, isc::dhcp::OptionCollection &options, std::list< uint16_t > &deferred, bool flexible_pad_end=false)
Parses provided buffer as DHCPv4 options and creates Option objects.
static void extendVendorOptions4(isc::dhcp::OptionCollection &options)
Extend vendor options from fused options in multiple OptionVendor or OptionVendorClass options and ad...
static void packOptions4(isc::util::OutputBuffer &buf, const isc::dhcp::OptionCollection &options, bool top=false, bool check=true)
Stores DHCPv4 options in a buffer.
static bool splitOptions4(isc::dhcp::OptionCollection &options, ScopedOptionsCopyContainer &scopedOptions, uint32_t used=0)
Split long options in multiple options with the same option code (RFC3396).
Forward declaration to OptionInt.
virtual void addOption(const OptionPtr &opt)
Add an option.
std::string toText() const
Returns text representation of the packet.
virtual void unpack()
Parses on-wire form of DHCPv4 packet.
std::list< uint16_t > deferred_options_
HWAddrPtr hwaddr_
link-layer address and hardware information represents 3 fields: htype (hardware type,...
const char * getName() const
Returns name of the DHCP message.
HWAddrPtr local_hwaddr_
local HW address (dst if receiving packet, src if sending packet)
static const size_t MAX_CHADDR_LEN
length of the CHADDR field in DHCPv4 message
void setLocalHWAddr(const uint8_t htype, const uint8_t hlen, const std::vector< uint8_t > &mac_addr)
Sets local HW address.
std::string getHWAddrLabel() const
Returns text representation of the hardware address.
uint8_t DHCPTypeToBootpType(uint8_t dhcpType)
converts DHCP message type to BOOTP op type
std::string getLabel() const
Returns text representation of the primary packet identifiers.
virtual void pack()
Prepares on-wire format of DHCPv4 packet.
isc::asiolink::IOAddress giaddr_
giaddr field (32 bits): Gateway IP address
uint8_t file_[MAX_FILE_LEN]
file field (128 bytes)
uint8_t op_
message operation code
uint8_t hops_
Number of relay agents traversed.
void setSname(const uint8_t *sname, size_t sname_len)
Sets sname field.
Pkt4(uint8_t msg_type, uint32_t transid)
Constructor, used in replying to a message.
uint8_t getHlen() const
Returns hlen field.
static const size_t DHCPV4_PKT_HDR_LEN
specifies DHCPv4 packet header length (fixed part)
bool isRelayed() const
Checks if a DHCPv4 message has been relayed.
void setFile(const uint8_t *file, size_t file_len)
Sets file field.
static const size_t MAX_SNAME_LEN
length of the SNAME field in DHCPv4 message
static std::string makeLabel(const HWAddrPtr &hwaddr, const ClientIdPtr &client_id, const uint32_t transid)
Returns text representation of the given packet identifiers.
uint8_t getType() const
Returns DHCP message type (e.g.
void setType(uint8_t type)
Sets DHCP message type (e.g.
isc::asiolink::IOAddress siaddr_
siaddr field (32 bits): next server IP address in boot process(e.g.TFTP)
size_t len()
Returns the size of the required buffer to build the packet.
uint16_t secs_
elapsed (number of seconds since beginning of transmission)
isc::asiolink::IOAddress ciaddr_
ciaddr field (32 bits): Client's IP address
isc::asiolink::IOAddress yiaddr_
yiaddr field (32 bits): Client's IP address ("your"), set by server
uint8_t sname_[MAX_SNAME_LEN]
sname field (64 bytes)
void setHWAddr(uint8_t htype, uint8_t hlen, const std::vector< uint8_t > &mac_addr)
Sets hardware address.
uint8_t getHtype() const
Returns htype field.
static const char * getName(const uint8_t type)
Returns name of the DHCP message for a given type number.
static const size_t MAX_FILE_LEN
length of the FILE field in DHCPv4 message
isc::asiolink::IOAddress remote_addr_
Remote IP address.
uint16_t local_port_
local TDP or UDP port
uint32_t transid_
Transaction-id (32 bits for v4, 24 bits for v6)
isc::asiolink::IOAddress local_addr_
Local IP (v4 or v6) address.
OptionBuffer data_
Unparsed data (in received packets).
uint16_t remote_port_
remote TCP or UDP port
isc::dhcp::OptionCollection options_
Collection of options present in this message.
isc::util::OutputBuffer buffer_out_
Output buffer (used during message transmission)
Pkt(uint32_t transid, const isc::asiolink::IOAddress &local_addr, const isc::asiolink::IOAddress &remote_addr, uint16_t local_port, uint16_t remote_port)
Constructor.
OptionPtr getNonCopiedOption(const uint16_t type) const
Returns the first option of specified type without copying.
virtual void addOption(const OptionPtr &opt)
Adds an option to this packet.
#define isc_throw(type, stream)
A shortcut macro to insert known values into exception arguments.
ScopedPktOptionsCopy< Pkt4 > ScopedPkt4OptionsCopy
A pointer to a ScopedPktOptionsCopy object instantiated using Pkt4.
@ DHO_DHCP_CLIENT_IDENTIFIER
boost::shared_ptr< HWAddr > HWAddrPtr
Shared pointer to a hardware address structure.
boost::shared_ptr< ClientId > ClientIdPtr
Shared pointer to a Client ID.
@ DHCP_NOTYPE
Message Type option missing.
@ HTYPE_UNDEFINED
not specified or undefined
boost::shared_ptr< Option > OptionPtr
Defines the logger used by the top-level component of kea-lfc.
#define DHCP4_OPTION_SPACE
global std option spaces
Hardware type that represents information from DHCPv4 packet.
ScopedOptionsCopyContainer scoped_options_
The container.