pkt6.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 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() {
        return (proto_);
    }

    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