pkt6.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 PKT6_H
#define PKT6_H
 
#include <asiolink/io_address.h>
#include <dhcp/duid.h>
#include <dhcp/option.h>
#include <dhcp/pkt.h>
 
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/shared_array.hpp>
#include <boost/shared_ptr.hpp>
 
#include <iostream>
#include <set>
 
#include <time.h>
 
namespace isc {
 
namespace dhcp {
 
class Pkt6;
 
typedef boost::shared_ptr<Pkt6> Pkt6Ptr;
 
class Pkt6 : public Pkt {
public:
    const static size_t DHCPV6_PKT_HDR_LEN = 4;
 
    const static size_t DHCPV6_RELAY_HDR_LEN = 34;
 
    enum DHCPv6Proto {
        UDP = 0, // most packets are UDP
        TCP = 1  // there are TCP DHCPv6 packets (bulk leasequery, failover)
    };
 
    enum RelaySearchOrder {
        RELAY_SEARCH_FROM_CLIENT = 1,
        RELAY_SEARCH_FROM_SERVER = 2,
        RELAY_GET_FIRST = 3,
        RELAY_GET_LAST = 4
    };
 
    struct RelayInfo {
 
        RelayInfo();
 
        std::string toText() const;
 
        uint8_t   msg_type_;               
        uint8_t   hop_count_;              
        isc::asiolink::IOAddress linkaddr_;
        isc::asiolink::IOAddress peeraddr_;
 
        uint16_t  relay_msg_len_;
 
        isc::dhcp::OptionCollection options_;
    };
 
    Pkt6(uint8_t msg_type,
         uint32_t transid,
         DHCPv6Proto proto = UDP);
 
    Pkt6(const uint8_t* buf, uint32_t len, DHCPv6Proto proto = UDP);
 
    virtual void pack();
 
    virtual void unpack();
 
    DHCPv6Proto getProto();
 
    void setProto(DHCPv6Proto proto = UDP) {
        proto_ = proto;
    }
 
    static std::string makeLabel(const DuidPtr duid, const uint32_t transid,
                                 const HWAddrPtr& hwaddr);
 
    static std::string makeLabel(const DuidPtr duid, const HWAddrPtr& hwaddr);
 
    virtual std::string getLabel() const;
 
    virtual std::string toText() const;
 
    virtual size_t len();
 
    virtual uint8_t getType() const { return (msg_type_); }
 
    virtual void setType(uint8_t type) { msg_type_=type; };
 
    DuidPtr getClientId() const;
 
 
protected:
 
    OptionPtr getNonCopiedRelayOption(const uint16_t opt_type,
                                      const uint8_t relay_level) const;
 
public:
 
    OptionPtr getRelayOption(uint16_t option_code, uint8_t nesting_level);
 
private:
 
    void prepareGetAnyRelayOption(const RelaySearchOrder& order,
                                  int& start, int& end, int& direction) const;
 
protected:
 
    OptionPtr getNonCopiedAnyRelayOption(const uint16_t option_code,
                                         const RelaySearchOrder& order) const;
 
public:
 
    OptionPtr getAnyRelayOption(const uint16_t option_code,
                                const RelaySearchOrder& order);
 
    const isc::asiolink::IOAddress&
    getRelay6LinkAddress(uint8_t relay_level) const;
 
    const isc::asiolink::IOAddress&
    getRelay6PeerAddress(uint8_t relay_level) const;
 
protected:
 
    OptionCollection getNonCopiedOptions(const uint16_t opt_type) const;
 
public:
 
    isc::dhcp::OptionCollection getOptions(const uint16_t type);
 
    void addRelayInfo(const RelayInfo& relay);
 
    static const char* getName(const uint8_t type);
 
    const char* getName() const;
 
    void copyRelayInfo(const Pkt6Ptr& question);
 
    std::vector<RelayInfo> relay_info_;
 
protected:
 
    virtual HWAddrPtr getMACFromSrcLinkLocalAddr();
 
    //         option inserted by a relay agent (RFC6939).
    //  client-linklayer-addr option inserted by the relay agent closest to
    //  the client.
    virtual HWAddrPtr getMACFromIPv6RelayOpt();
 
    virtual HWAddrPtr getMACFromDUID();
 
    virtual HWAddrPtr getMACFromDocsisModem();
 
    virtual HWAddrPtr getMACFromDocsisCMTS();
 
    virtual HWAddrPtr getMACFromRemoteIdRelayOption();
 
    void packTCP();
 
    void packUDP();
 
    void unpackTCP();
 
    void unpackUDP();
 
    void unpackMsg(OptionBuffer::const_iterator begin,
                   OptionBuffer::const_iterator end);
 
    void unpackRelayMsg();
 
    uint16_t getRelayOverhead(const RelayInfo& relay) const;
 
    uint16_t calculateRelaySizes();
 
    uint16_t directLen() const;
 
    DHCPv6Proto proto_;
 
    uint8_t msg_type_;
 
}; // Pkt6 class
 
} // isc::dhcp namespace
 
} // isc namespace
 
#endif