dhcpv6.h

/*
 * Copyright (c) 2017, Matias Fontanini
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 * 
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * * Redistributions in binary form must reproduce the above
 *   copyright notice, this list of conditions and the following disclaimer
 *   in the documentation and/or other materials provided with the
 *   distribution.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#ifndef TINS_DHCPV6_H
#define TINS_DHCPV6_H

#include <cstring>
#include <tins/pdu.h>
#include <tins/macros.h>
#include <tins/endianness.h>
#include <tins/small_uint.h>
#include <tins/ipv6_address.h>
#include <tins/pdu_option.h>

namespace Tins {
namespace Memory  {

class OutputMemoryStream;

} // Memory

class TINS_API DHCPv6 : public PDU {
public:
    typedef PDUOption<uint16_t, DHCPv6> option;

    enum MessageType {
        SOLICIT = 1,
        ADVERTISE,
        REQUEST,
        CONFIRM,
        RENEW,
        REBIND,
        REPLY,
        RELEASE,
        DECLINE,
        RECONFIGURE,
        INFO_REQUEST,
        RELAY_FORWARD,
        RELAY_REPLY,
        LEASE_QUERY,
        LEASE_QUERY_REPLY,
        LEASE_QUERY_DONE,
        LEASE_QUERY_DATA
    };
    
    enum OptionTypes {
        CLIENTID = 1, 
        SERVERID, 
        IA_NA, 
        IA_TA, 
        IA_ADDR, 
        OPTION_REQUEST, 
        PREFERENCE, 
        ELAPSED_TIME, 
        RELAY_MSG, 
        AUTH = 11, 
        UNICAST, 
        STATUS_CODE, 
        RAPID_COMMIT, 
        USER_CLASS, 
        VENDOR_CLASS, 
        VENDOR_OPTS, 
        INTERFACE_ID, 
        RECONF_MSG, 
        RECONF_ACCEPT, 
        SIP_SERVER_D, 
        SIP_SERVER_A, 
        DNS_SERVERS, 
        DOMAIN_LIST, 
        IA_PD, 
        IAPREFIX, 
        NIS_SERVERS, 
        NISP_SERVERS, 
        NIS_DOMAIN_NAME, 
        NISP_DOMAIN_NAME, 
        SNTP_SERVERS, 
        INFORMATION_REFRESH_TIME, 
        BCMCS_SERVER_D, 
        BCMCS_SERVER_A, 
        GEOCONF_CIVIC = 36, 
        REMOTE_ID, 
        SUBSCRIBER_ID, 
        CLIENT_FQDN, 
        PANA_AGENT, 
        NEW_POSIX_TIMEZONE, 
        NEW_TZDB_TIMEZONE, 
        ERO, 
        LQ_QUERY, 
        CLIENT_DATA, 
        CLT_TIME, 
        LQ_RELAY_DATA, 
        LQ_CLIENT_LINK, 
        MIP6_HNIDF, 
        MIP6_VDINF, 
        V6_LOST, 
        CAPWAP_AC_V6, 
        RELAY_ID, 
        NTP_SERVER, 
        V6_ACCESS_DOMAIN, 
        SIP_UA_CS_LIST, 
        BOOTFILE_URL, 
        BOOTFILE_PARAM, 
        CLIENT_ARCH_TYPE, 
        NII, 
        GEOLOCATION, 
        AFTR_NAME, 
        ERP_LOCAL_DOMAIN_NAME, 
        RSOO, 
        PD_EXCLUDE, 
        VSS, 
        MIP6_IDINF, 
        MIP6_UDINF, 
        MIP6_HNP, 
        MIP6_HAA, 
        MIP6_HAF, 
        RDNSS_SELECTION, 
        KRB_PRINCIPAL_NAME, 
        KRB_REALM_NAME, 
        KRB_DEFAULT_REALM_NAME, 
        KRB_KDC
    };

    typedef std::vector<option> options_type;

    typedef IPv6Address ipaddress_type;
    
    static const PDU::PDUType pdu_flag = PDU::DHCPv6;

    struct ia_na_type {
        typedef std::vector<uint8_t> options_type;
        
        uint32_t id, t1, t2;
        options_type options;
        
        ia_na_type(uint32_t id = 0, uint32_t t1 = 0, uint32_t t2 = 0,
          const options_type& options = options_type())
        : id(id), t1(t1), t2(t2), options(options) {}

        static ia_na_type from_option(const option& opt);
    };
    
    struct ia_ta_type {
        typedef std::vector<uint8_t> options_type;
        
        uint32_t id;
        options_type options;
        
        ia_ta_type(uint32_t id = 0,
          const options_type& options = options_type())
        : id(id), options(options) {}

        static ia_ta_type from_option(const option& opt);
    };

    struct ia_address_type {
        typedef std::vector<uint8_t> options_type;
        
        ipaddress_type address;
        uint32_t preferred_lifetime, valid_lifetime;
        options_type options;
        
        ia_address_type(ipaddress_type address = ipaddress_type(), 
          uint32_t preferred_lifetime = 0, uint32_t valid_lifetime = 0, 
          const options_type& options = options_type())
        : address(address), preferred_lifetime(preferred_lifetime), 
          valid_lifetime(valid_lifetime), options(options) {}

        static ia_address_type from_option(const option& opt);
    };
    
    struct authentication_type {
        typedef std::vector<uint8_t> auth_info_type;
        
        uint8_t protocol, algorithm, rdm;
        uint64_t replay_detection;
        auth_info_type auth_info;
        
        authentication_type(uint8_t protocol = 0, uint8_t algorithm = 0,
          uint8_t rdm = 0, uint64_t replay_detection = 0,
          const auth_info_type& auth_info = auth_info_type())
        : protocol(protocol), algorithm(algorithm), rdm(rdm),
        replay_detection(replay_detection), auth_info(auth_info) {}

        static authentication_type from_option(const option& opt);
    };
    
    struct status_code_type {
        uint16_t code;
        std::string message;
        
        status_code_type(uint16_t code = 0, const std::string& message = "")
        : code(code), message(message) { }

        static status_code_type from_option(const option& opt);
    };
    
    struct vendor_info_type {
        typedef std::vector<uint8_t> data_type;
        
        uint32_t enterprise_number;
        data_type data;
        
        vendor_info_type(uint32_t enterprise_number = 0, 
          const data_type& data = data_type())
        : enterprise_number(enterprise_number), data(data) { }

        static vendor_info_type from_option(const option& opt);
    };
    
    
    typedef std::vector<uint8_t> class_option_data_type;
    
    //typedef std::vector<class_option_data_type> user_class_type;
    struct user_class_type {
        typedef std::vector<class_option_data_type> data_type;
        data_type data;

        user_class_type(const data_type& data = data_type())
        : data(data) { }

        static user_class_type from_option(const option& opt);
    };
    
    struct vendor_class_type {
        typedef std::vector<class_option_data_type> class_data_type;
        
        uint32_t enterprise_number;
        class_data_type vendor_class_data;
        
        vendor_class_type(uint32_t enterprise_number = 0, 
          const class_data_type& vendor_class_data = class_data_type())
        : enterprise_number(enterprise_number), 
        vendor_class_data(vendor_class_data) { }

        static vendor_class_type from_option(const option& opt);
    };
    
    struct duid_llt {
        static const uint16_t duid_id = 1;
        typedef std::vector<uint8_t> lladdress_type;
        
        uint16_t hw_type;
        uint32_t time;
        lladdress_type lladdress;
        
        duid_llt(uint16_t hw_type = 0, uint32_t time = 0,
          const lladdress_type& lladdress = lladdress_type())
        : hw_type(hw_type), time(time), lladdress(lladdress) {}
        
        PDU::serialization_type serialize() const;
        
        static duid_llt from_bytes(const uint8_t* buffer, uint32_t total_sz);
    };
    
    struct duid_en {
        static const uint16_t duid_id = 2;
        typedef std::vector<uint8_t> identifier_type;
        
        uint32_t enterprise_number;
        identifier_type identifier;
        
        duid_en(uint32_t enterprise_number = 0,
          const identifier_type& identifier = identifier_type())
        : enterprise_number(enterprise_number), identifier(identifier) {}
        
        PDU::serialization_type serialize() const;
        
        static duid_en from_bytes(const uint8_t* buffer, uint32_t total_sz);
    };
    
    struct duid_ll {
        static const uint16_t duid_id = 3;
        typedef std::vector<uint8_t> lladdress_type;
        
        uint16_t hw_type;
        lladdress_type lladdress;
        
        duid_ll(uint16_t hw_type = 0, 
          const lladdress_type& lladdress = lladdress_type())
        : hw_type(hw_type), lladdress(lladdress) {}
        
        PDU::serialization_type serialize() const;
        
        static duid_ll from_bytes(const uint8_t* buffer, uint32_t total_sz);
    };
    
    struct duid_type {
        typedef PDU::serialization_type data_type;
        
        uint16_t id;
        data_type data;
        
        duid_type(uint16_t id = 0, const data_type& data = data_type())
        : id(id), data(data) {}
        
        duid_type(const duid_llt& identifier)
        : id(duid_llt::duid_id), data(identifier.serialize()) {}
        
        duid_type(const duid_en& identifier)
        : id(duid_en::duid_id), data(identifier.serialize()) {}
        
        duid_type(const duid_ll& identifier)
        : id(duid_ll::duid_id), data(identifier.serialize()) {}

        static duid_type from_option(const option& opt);
    };
        
    typedef std::vector<uint16_t> option_request_type;
    
    typedef std::vector<uint8_t> relay_msg_type;
    
    typedef std::vector<uint8_t> interface_id_type;

    static metadata extract_metadata(const uint8_t *buffer, uint32_t total_sz);

    DHCPv6();
    
    DHCPv6(const uint8_t* buffer, uint32_t total_sz);

    // Getters
    
    MessageType msg_type() const { 
        return static_cast<MessageType>(header_data_[0]); 
    }
    
    uint8_t hop_count() const {
        return header_data_[1];
    }
    
    small_uint<24> transaction_id() const { 
        return (header_data_[1] << 16) | (header_data_[2] << 8) | header_data_[3];
    }

    const ipaddress_type& peer_address() const {
        return peer_addr_;
    }
    
    const ipaddress_type& link_address() const {
        return link_addr_;
    }
    
    const options_type& options() const {
        return options_;
    }

    // Setters
    void msg_type(MessageType type);
    
    void hop_count(uint8_t count);
    
    void transaction_id(small_uint<24> id);
    
    void peer_address(const ipaddress_type& addr);
    
    void link_address(const ipaddress_type& addr);
    
    // Option getters
    
    ia_na_type ia_na() const;
    
    ia_ta_type ia_ta() const;
    
    ia_address_type ia_address() const;
    
    option_request_type option_request() const;
    
    uint8_t preference() const;
    
    uint16_t elapsed_time() const;
    
    relay_msg_type relay_message() const;
    
    authentication_type authentication() const;
    
    ipaddress_type server_unicast() const;
    
    status_code_type status_code() const;
    
    bool has_rapid_commit() const;
    
    user_class_type user_class() const;
    
    vendor_class_type vendor_class() const;
    
    vendor_info_type vendor_info() const;
    
    interface_id_type interface_id() const;

    uint8_t reconfigure_msg() const;
    
    bool has_reconfigure_accept() const;
    
    duid_type client_id() const;
    
    duid_type server_id() const;
    
    // Option setters
    
    void ia_na(const ia_na_type& value);
    
    void ia_ta(const ia_ta_type& value);
    
    void ia_address(const ia_address_type& value);
    
    void option_request(const option_request_type& value);
    
    void preference(uint8_t value);
    
    void elapsed_time(uint16_t value);
    
    void relay_message(const relay_msg_type& value);
    
    void authentication(const authentication_type& value);
    
    void server_unicast(const ipaddress_type& value);
    
    void status_code(const status_code_type& value);
    
    void rapid_commit();
    
    void user_class(const user_class_type& value);
    
    void vendor_class(const vendor_class_type& value);
    
    void vendor_info(const vendor_info_type& value);
    
    void interface_id(const interface_id_type& value);
    
    void reconfigure_msg(uint8_t value);
    
    void reconfigure_accept();
    
    void client_id(const duid_type& value);
    
    void server_id(const duid_type& value);
    
    // Other stuff
    
    bool is_relay_message() const;
    
    void add_option(const option& opt);
    
    bool remove_option(OptionTypes type);

    const option* search_option(OptionTypes type) const;

    // PDU stuff
    
    uint32_t header_size() const;
    
    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
    
    PDUType pdu_type() const { 
        return pdu_flag;
    }
    
    DHCPv6* clone() const {
        return new DHCPv6(*this);
    }
private:
    void write_serialization(uint8_t* buffer, uint32_t total_sz);
    void write_option(const option& option, Memory::OutputMemoryStream& stream) const;
    options_type::const_iterator search_option_iterator(OptionTypes type) const;
    options_type::iterator search_option_iterator(OptionTypes type);
    
    template <template <typename> class Functor>
    const option* safe_search_option(OptionTypes opt, uint32_t size) const {
        const option* option = search_option(opt);
        if (!option || Functor<uint32_t>()(option->data_size(), size)) {
            throw option_not_found();
        }
        return option;
    }

    template<typename T>
    T search_and_convert(OptionTypes opt) const {
        const option* option = search_option(opt);
        if (!option) {
            throw option_not_found();
        }
        return option->to<T>();
    }

    uint8_t header_data_[4];
    uint32_t options_size_;
    ipaddress_type link_addr_, peer_addr_;
    options_type options_;
};

} // Tins

#endif // TINS_DHCPV6_H