icmpv6.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_ICMPV6_H
#define TINS_ICMPV6_H

#include <vector>
#include <tins/macros.h>
#include <tins/pdu.h>
#include <tins/ipv6_address.h>
#include <tins/pdu_option.h>
#include <tins/endianness.h>
#include <tins/small_uint.h>
#include <tins/hw_address.h>
#include <tins/small_uint.h>
#include <tins/icmp_extension.h>
#include <tins/cxxstd.h>

namespace Tins {
namespace Memory {

class InputMemoryStream;
class OutputMemoryStream;

} // memory

class TINS_API ICMPv6 : public PDU {
public:
    static const PDU::PDUType pdu_flag = PDU::ICMPv6;
    
    enum Types {
        DEST_UNREACHABLE = 1,
        PACKET_TOOBIG = 2,
        TIME_EXCEEDED = 3,
        PARAM_PROBLEM = 4,
        ECHO_REQUEST = 128,
        ECHO_REPLY = 129,
        MGM_QUERY = 130,
        MGM_REPORT = 131,
        MGM_REDUCTION = 132,
        ROUTER_SOLICIT = 133,
        ROUTER_ADVERT = 134,
        NEIGHBOUR_SOLICIT = 135,
        NEIGHBOUR_ADVERT = 136,
        REDIRECT = 137,
        ROUTER_RENUMBER = 138,
        NI_QUERY = 139,
        NI_REPLY = 140,
        MLD2_REPORT = 143,
        DHAAD_REQUEST = 144,
        DHAAD_REPLY = 145,
        MOBILE_PREFIX_SOLICIT = 146,
        MOBILE_PREFIX_ADVERT = 147,
        CERT_PATH_SOLICIT = 148,
        CERT_PATH_ADVERT = 149,
        MULTICAST_ROUTER_ADVERT = 151,
        MULTICAST_ROUTER_SOLICIT = 152,
        MULTICAST_ROUTER_TERMINATE = 153,
        RPL_CONTROL_MSG = 155
    };
    
    enum OptionTypes {
        SOURCE_ADDRESS = 1,
        TARGET_ADDRESS,
        PREFIX_INFO,
        REDIRECT_HEADER,
        MTU,
        NBMA_SHORT_LIMIT,
        ADVERT_INTERVAL,
        HOME_AGENT_INFO,
        S_ADDRESS_LIST,
        T_ADDRESS_LIST,
        CGA,
        RSA_SIGN,
        TIMESTAMP,
        NONCE,
        TRUST_ANCHOR,
        CERTIFICATE,
        IP_PREFIX,
        NEW_ROUTER_PREFIX,
        LINK_ADDRESS,
        NAACK,
        MAP = 23,
        ROUTE_INFO,
        RECURSIVE_DNS_SERV,
        RA_FLAGS_EXT,
        HANDOVER_KEY_REQ,
        HANDOVER_KEY_REPLY,
        HANDOVER_ASSIST_INFO,
        MOBILE_NODE_ID,
        DNS_SEARCH_LIST,
        PROXY_SIGNATURE,
        ADDRESS_REG,
        SIXLOWPAN_CONTEXT,
        AUTHORITATIVE_BORDER_ROUTER,
        CARD_REQUEST = 138,
        CARD_REPLY
    };
    
    typedef IPv6Address ipaddress_type;
    
    typedef HWAddress<6> hwaddress_type;
    
    typedef PDUOption<uint8_t, ICMPv6> option;
    
    typedef std::vector<option> options_type;
    
    typedef std::vector<uint16_t> new_ha_info_type;
    
    struct addr_list_type {
        typedef std::vector<ipaddress_type> addresses_type;
        
        uint8_t reserved[6];
        addresses_type addresses;
        
        addr_list_type(const addresses_type& addresses = addresses_type())
        : addresses(addresses) {
            std::fill(reserved, reserved + sizeof(reserved), 0);
        }
        
        static addr_list_type from_option(const option& opt);
    };
    
    typedef std::vector<uint8_t> nonce_type;
    
    typedef std::pair<uint16_t, uint32_t> mtu_type;
    
    struct naack_type {
        uint8_t code, status;
        uint8_t reserved[4];
        
        naack_type(uint8_t code = 0, uint8_t status = 0)
        : code(code), status(status) {
            std::fill(reserved, reserved + 4, 0);
        }
        
        static naack_type from_option(const option& opt);
    };
    
    struct lladdr_type {
        typedef std::vector<uint8_t> address_type;
        
        uint8_t option_code;
        address_type address;
        
        lladdr_type(uint8_t option_code = 0, 
                    const address_type& address = address_type())
        : option_code(option_code), address(address) {
            
        }
        
        lladdr_type(uint8_t option_code, const hwaddress_type& address)
        : option_code(option_code), address(address.begin(), address.end()) {
            
        }
        
        static lladdr_type from_option(const option& opt);
    };
    
    struct prefix_info_type {
        uint8_t prefix_len;
        small_uint<1> A, L;
        uint32_t valid_lifetime,
                 preferred_lifetime,
                 reserved2;
        ipaddress_type prefix;
        
        prefix_info_type(uint8_t prefix_len = 0, 
                         small_uint<1> A = 0,
                         small_uint<1> L = 0,
                         uint32_t valid_lifetime = 0, 
                         uint32_t preferred_lifetime = 0,
                         const ipaddress_type& prefix = ipaddress_type())
        : prefix_len(prefix_len), A(A), L(L), valid_lifetime(valid_lifetime),
          preferred_lifetime(preferred_lifetime), reserved2(0), prefix(prefix) { }
          
        static prefix_info_type from_option(const option& opt);
    };
    
    struct rsa_sign_type {
        typedef std::vector<uint8_t> signature_type;
        
        uint8_t key_hash[16];
        signature_type signature;
        
        template <typename RAIterator, typename ForwardIterator>
        rsa_sign_type(RAIterator hash, ForwardIterator start, ForwardIterator end)
        : signature(start, end) {
            std::copy(hash, hash + sizeof(key_hash), key_hash);
        }
        
        template <typename RAIterator>
        rsa_sign_type(RAIterator hash, const signature_type& sign)
        : signature(sign) {
            std::copy(hash, hash + sizeof(key_hash), key_hash);
        }
        
        rsa_sign_type() {
            std::fill(key_hash, key_hash + sizeof(key_hash), 0);
        }

        static rsa_sign_type from_option(const option& opt);
    };
    
    struct ip_prefix_type {
        uint8_t option_code, prefix_len;
        ipaddress_type address;
        
        ip_prefix_type(uint8_t option_code = 0,
                       uint8_t prefix_len = 0,
                       const ipaddress_type& address = ipaddress_type())
        : option_code(option_code), prefix_len(prefix_len), address(address)
        {}

        static ip_prefix_type from_option(const option& opt);
    };
    
    struct map_type {
        small_uint<4> dist, pref;
        small_uint<1> r;
        uint32_t valid_lifetime;
        ipaddress_type address;
        
        map_type(small_uint<4> dist = 0,
                 small_uint<4> pref = 0, 
                 small_uint<1> r = 0, 
                 uint32_t valid_lifetime = 0, 
                 const ipaddress_type& address = ipaddress_type())
        : dist(dist), pref(pref), r(r), valid_lifetime(valid_lifetime),
          address(address) { }

        static map_type from_option(const option& opt);
    };
    
    struct route_info_type {
        typedef std::vector<uint8_t> prefix_type;
        
        uint8_t prefix_len;
        small_uint<2> pref;
        uint32_t route_lifetime;
        prefix_type prefix;
        
        route_info_type(uint8_t prefix_len = 0, 
                        small_uint<2> pref = 0, 
                        uint32_t route_lifetime = 0,
                        const prefix_type& prefix = prefix_type())
        : prefix_len(prefix_len), pref(pref), route_lifetime(route_lifetime),
          prefix(prefix) { }

        static route_info_type from_option(const option& opt);
    };
    
    struct recursive_dns_type {
        typedef std::vector<ipaddress_type> servers_type;
        
        uint32_t lifetime;
        servers_type servers;
        
        recursive_dns_type(uint32_t lifetime = 0, 
                           const servers_type& servers = servers_type())
        : lifetime(lifetime), servers(servers) {}

        static recursive_dns_type from_option(const option& opt);
    };
    
    struct handover_key_req_type {
        typedef std::vector<uint8_t> key_type;
        
        small_uint<4> AT;
        key_type key;
        
        handover_key_req_type(small_uint<4> AT = 0,
                              const key_type& key = key_type())
        : AT(AT), key(key) { }

        static handover_key_req_type from_option(const option& opt);
    };
    
    struct handover_key_reply_type : handover_key_req_type {
        uint16_t lifetime;
        
        handover_key_reply_type(uint16_t lifetime = 0, 
                                small_uint<4> AT = 0,
                                const key_type& key = key_type())
        : handover_key_req_type(AT, key), lifetime(lifetime) { }

        static handover_key_reply_type from_option(const option& opt);
    };
    
    struct handover_assist_info_type {
        typedef std::vector<uint8_t> hai_type;
        
        uint8_t option_code;
        hai_type hai;
        
        handover_assist_info_type(uint8_t option_code=0, 
                                  const hai_type& hai = hai_type())
        : option_code(option_code), hai(hai) { }

        static handover_assist_info_type from_option(const option& opt);
    };
    
    struct mobile_node_id_type {
        typedef std::vector<uint8_t> mn_type;
        
        uint8_t option_code;
        mn_type mn;
        
        mobile_node_id_type(uint8_t option_code=0, 
                            const mn_type& mn = mn_type())
        : option_code(option_code), mn(mn) { }

        static mobile_node_id_type from_option(const option& opt);
    };
    
    struct dns_search_list_type {
        typedef std::vector<std::string> domains_type;
        
        uint32_t lifetime;
        domains_type domains;
        
        dns_search_list_type(uint32_t lifetime = 0,
                             const domains_type& domains = domains_type())
        : lifetime(lifetime), domains(domains) { }

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

    struct timestamp_type {
        uint8_t reserved[6];
        uint64_t timestamp;

        timestamp_type(uint64_t timestamp = 0)
        : timestamp(timestamp) {
            std::fill(reserved, reserved + sizeof(reserved), 0);
        }

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

    struct shortcut_limit_type {
        uint8_t limit, reserved1;
        uint32_t reserved2;

        shortcut_limit_type(uint8_t limit = 0)
        : limit(limit), reserved1(), reserved2() {

        }

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

    struct new_advert_interval_type {
        uint16_t reserved;
        uint32_t interval;

        new_advert_interval_type(uint32_t interval = 0)
        : reserved(), interval(interval) {

        }

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

    struct multicast_address_record {
        typedef std::vector<ipaddress_type> sources_type;
        typedef std::vector<uint8_t> aux_data_type;

        multicast_address_record(uint8_t type = 0) : type(type) { }

        multicast_address_record(const uint8_t* buffer, uint32_t total_sz);
        void serialize(uint8_t* buffer, uint32_t total_sz) const;
        uint32_t size() const;

        uint8_t type;
        ipaddress_type multicast_address;
        sources_type sources;
        aux_data_type aux_data;
    };

    /*
     * The type used to store all multicast address records in a packet
     */
    typedef std::vector<multicast_address_record> multicast_address_records_list;

    /*
     * The type used to store all source address (from Multicast 
     * Listener Query messages) in a packet 
     */
    typedef std::vector<ipaddress_type> sources_list;

    ICMPv6(Types tp = ECHO_REQUEST);
    
    ICMPv6(const uint8_t* buffer, uint32_t total_sz);
    
    // Getters

    Types type() const {
        return static_cast<Types>(header_.type);
    }

    uint8_t code() const {
        return header_.code;
    }

    uint16_t checksum() const {
        return Endian::be_to_host(header_.cksum);
    }

    uint16_t identifier() const {
        return Endian::be_to_host(header_.u_echo.identifier);
    }

    uint16_t sequence() const {
        return Endian::be_to_host(header_.u_echo.sequence);
    }

    small_uint<1> override() const {
        return header_.u_nd_advt.override;
    }

    small_uint<1> solicited() const {
        return header_.u_nd_advt.solicited;
    }

    small_uint<1> router() const {
        return header_.u_nd_advt.router;
    }

    uint8_t hop_limit() const {
        return header_.u_nd_ra.hop_limit;
    }

    uint16_t maximum_response_code() const {
        return Endian::be_to_host(header_.u_echo.identifier);
    }

    small_uint<2> router_pref() const {
        return header_.u_nd_ra.router_pref;
    }

    small_uint<1> home_agent() const {
        return header_.u_nd_ra.home_agent;
    }

    small_uint<1> other() const {
        return header_.u_nd_ra.other;
    }

    small_uint<1> managed() const {
        return header_.u_nd_ra.managed;
    }

    uint16_t router_lifetime() const {
        return Endian::be_to_host(header_.u_nd_ra.router_lifetime);
    }
    
    uint32_t reachable_time() const {
        return Endian::be_to_host(reach_time_);
    }
    
    uint32_t retransmit_timer() const {
        return Endian::be_to_host(retrans_timer_);
    }
    
    const ipaddress_type& target_addr() const {
        return target_address_;
    }
    
    const ipaddress_type& dest_addr() const {
        return dest_address_;
    }

    const ipaddress_type& multicast_addr() const {
        return multicast_address_;
    }

    const options_type& options() const {
        return options_;
    }

    uint8_t length() const { 
        return header_.rfc4884.length;
    }

    const multicast_address_records_list& multicast_address_records() const {
        return multicast_records_;
    }

    const sources_list& sources() const {
        return sources_;
    }

    small_uint<1> supress() const {
        return mlqm_.supress;
    }

    small_uint<3> qrv() const {
        return mlqm_.qrv;
    }

    uint8_t qqic() const {
        return mlqm_.qqic;
    }

    // Setters

    void type(Types new_type);

    void code(uint8_t new_code);

    void checksum(uint16_t new_cksum);

    void identifier(uint16_t new_identifier);

    void sequence(uint16_t new_sequence);

    void override(small_uint<1> new_override);

    void solicited(small_uint<1> new_solicited);

    void router(small_uint<1> new_router);

    void hop_limit(uint8_t new_hop_limit);

    void maximum_response_code(uint16_t maximum_response_code);

    void router_pref(small_uint<2> new_router_pref);

    void home_agent(small_uint<1> new_home_agent);

    void other(small_uint<1> new_other);

    void managed(small_uint<1> new_managed);

    void router_lifetime(uint16_t new_router_lifetime);
    
    void target_addr(const ipaddress_type& new_target_addr);
    
    void dest_addr(const ipaddress_type& new_dest_addr);

    void multicast_addr(const ipaddress_type& new_multicast_addr);

    void reachable_time(uint32_t new_reachable_time);
    
    void retransmit_timer(uint32_t new_retrans_timer);

    void multicast_address_records(const multicast_address_records_list& records);

    void sources(const sources_list& new_sources);

    void supress(small_uint<1> value);

    void qrv(small_uint<3> value);

    void qqic(uint8_t value);

    PDUType pdu_type() const { return pdu_flag; }

    bool has_target_addr() const {
        return type() == NEIGHBOUR_SOLICIT || 
               type() == NEIGHBOUR_ADVERT || 
               type() == REDIRECT;
    }
    
    bool has_dest_addr() const {
        return type() == REDIRECT;
    }
    
    void add_option(const option& option);
    
    #if TINS_IS_CXX11

        void add_option(option &&option) {
            internal_add_option(option);
            options_.push_back(std::move(option));
        }
    #endif

    bool remove_option(OptionTypes type);

    uint32_t header_size() const;

    uint32_t trailer_size() const;
    
    const ICMPExtensionsStructure& extensions() const {
        return extensions_;
    }

    ICMPExtensionsStructure& extensions() {
        return extensions_;
    }

    bool has_extensions() const {
        return !extensions_.extensions().empty();
    }

    void use_length_field(bool value);

    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;

    const option* search_option(OptionTypes type) const;

    ICMPv6* clone() const {
        return new ICMPv6(*this);
    }

    void use_mldv2(bool value);
    
    // ****************************************************************
    //                          Option setters
    // ****************************************************************
    
    void source_link_layer_addr(const hwaddress_type& addr);
    
    void target_link_layer_addr(const hwaddress_type& addr);
    
    void prefix_info(prefix_info_type info);
    
    void redirect_header(const byte_array& data);
    
    void mtu(const mtu_type& value);
    
    void shortcut_limit(const shortcut_limit_type& value);
    
    void new_advert_interval(const new_advert_interval_type& value);
    
    void new_home_agent_info(const new_ha_info_type& value);
    
    void source_addr_list(const addr_list_type& value);
    
    void target_addr_list(const addr_list_type& value);
    
    void rsa_signature(const rsa_sign_type& value);
    
    void timestamp(const timestamp_type& value);
    
    void nonce(const nonce_type& value);
    
    void ip_prefix(const ip_prefix_type& value);

    void link_layer_addr(lladdr_type value);

    void naack(const naack_type& value);
    
    void map(const map_type& value);
    
    void route_info(const route_info_type& value);
    
    void recursive_dns_servers(const recursive_dns_type& value);
    
    void handover_key_request(const handover_key_req_type& value);
    
    void handover_key_reply(const handover_key_reply_type& value);
    
    void handover_assist_info(const handover_assist_info_type& value);
    
    void mobile_node_identifier(const mobile_node_id_type& value);
    
    void dns_search_list(const dns_search_list_type& value);
    
    // ****************************************************************
    //                          Option getters
    // ****************************************************************
    
    hwaddress_type source_link_layer_addr() const;
    
    hwaddress_type target_link_layer_addr() const;
        
    prefix_info_type prefix_info() const;
    
    byte_array redirect_header() const;
    
    mtu_type mtu() const;
    
    shortcut_limit_type shortcut_limit() const;
    
    new_advert_interval_type new_advert_interval() const;
    
    new_ha_info_type new_home_agent_info() const;
    
    addr_list_type source_addr_list() const;
    
    addr_list_type target_addr_list() const;
    
    rsa_sign_type rsa_signature() const;
    
    timestamp_type timestamp() const;
    
    nonce_type nonce() const;
    
    ip_prefix_type ip_prefix() const;
    
    lladdr_type link_layer_addr() const;
    
    naack_type naack() const;
    
    map_type map() const;
    
    route_info_type route_info() const;
    
    recursive_dns_type recursive_dns_servers() const;
    
    handover_key_req_type handover_key_request() const;
    
    handover_key_reply_type handover_key_reply() const;
    
    handover_assist_info_type handover_assist_info() const;
    
    mobile_node_id_type mobile_node_identifier() const;
    
    dns_search_list_type dns_search_list() const;
private:
    TINS_BEGIN_PACK
    struct icmp6_header {
        uint8_t type;
        uint8_t code;
        uint16_t cksum;
        union {
            struct {
                uint16_t identifier;
                uint16_t sequence;
            } u_echo;
            
            struct {
        #if TINS_IS_LITTLE_ENDIAN
            uint32_t reserved:5,
                     override:1,
                     solicited:1,
                     router:1,
                     reserved2:24;
        #else
            uint32_t router:1,
                     solicited:1,
                     override:1,
                     reserved:29;
        #endif                      
            } u_nd_advt;
            struct {
                uint8_t hop_limit;
        #if TINS_IS_LITTLE_ENDIAN
                uint8_t reserved:3,
                        router_pref:2,
                        home_agent:1,
                        other:1,
                        managed:1;
        #else
                uint8_t managed:1,
                        other:1,
                        home_agent:1,
                        router_pref:2,
                        reserved:3;
        #endif
                uint16_t router_lifetime;
            } u_nd_ra;
            struct {
                uint8_t length;
                uint8_t unused[3];
            } rfc4884;
            // Multicast Listener Report Message (mld2)
            struct {
                uint16_t reserved;
                uint16_t record_count;
            } mlrm2;
        };
    } TINS_END_PACK;

    TINS_BEGIN_PACK
    struct multicast_listener_query_message_fields {
        uint8_t reserved:4,
                supress:1,
                qrv:3;
        uint8_t qqic;
    } TINS_END_PACK;
    
    void internal_add_option(const option& option);
    void write_serialization(uint8_t* buffer, uint32_t total_sz);
    bool has_options() const;
    void write_option(const option& opt, Memory::OutputMemoryStream& stream);
    void parse_options(Memory::InputMemoryStream& stream);
    void add_addr_list(uint8_t type, const addr_list_type& value);
    addr_list_type search_addr_list(OptionTypes type) const;
    options_type::const_iterator search_option_iterator(OptionTypes type) const;
    options_type::iterator search_option_iterator(OptionTypes type);
    void try_parse_extensions(Memory::InputMemoryStream& stream);
    bool are_extensions_allowed() const;
    uint32_t get_adjusted_inner_pdu_size() const;
    uint8_t get_option_padding(uint32_t data_size);

    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 type) const {
        const option* opt = search_option(type);
        if (!opt) {
            throw option_not_found();
        }
        return opt->to<T>();
    }

    icmp6_header header_;
    ipaddress_type target_address_;
    ipaddress_type dest_address_;
    ipaddress_type multicast_address_;
    options_type options_;
    uint32_t options_size_;
    uint32_t reach_time_, retrans_timer_;
    multicast_address_records_list multicast_records_;
    multicast_listener_query_message_fields mlqm_;
    sources_list sources_;
    ICMPExtensionsStructure extensions_;
    bool use_mldv2_;
};

} // Tins

#endif // TINS_ICMPV6_H