ipv6.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_IPV6_h
#define TINS_IPV6_h

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

namespace Tins {
namespace Memory {

class OutputMemoryStream;

} // Memory

class PacketSender;
    
class TINS_API IPv6 : public PDU {
public:
    static const PDU::PDUType pdu_flag = PDU::IPv6;
    
    typedef IPv6Address address_type;
    
    typedef PDUOption<uint8_t, IPv6> ext_header;
    
    typedef std::vector<ext_header> headers_type;

    typedef std::pair<uint8_t, std::vector<uint8_t> > header_option_type;

    enum ExtensionHeader {
        HOP_BY_HOP = 0,
        DESTINATION_ROUTING_OPTIONS = 60,
        ROUTING = 43,
        FRAGMENT = 44,
        AUTHENTICATION = 51,
        SECURITY_ENCAPSULATION = 50,
        DESTINATION_OPTIONS = 60,
        MOBILITY = 135,
        NO_NEXT_HEADER = 59
    };

    enum OptionType {
        PAD_1 = 0,
        PAD_N = 1,
        JUMBO_PAYLOAD = 0xC2,
    };

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

    /*
     * \brief The type used to store Hop-By-Hop Extension Headers
     */
    struct hop_by_hop_header {
        std::vector<header_option_type> options;

        static hop_by_hop_header from_extension_header(const ext_header& hdr);
    };

    /*
     * \brief The type used to store Destination Routing Extension Headers
     */
    struct destination_routing_header {
        std::vector<header_option_type> options;

        static destination_routing_header from_extension_header(const ext_header& hdr);
    };

    struct routing_header {
        uint8_t routing_type;
        uint8_t segments_left;
        std::vector<uint8_t> data;

        static routing_header from_extension_header(const ext_header& hdr);
    };

    struct fragment_header {
        uint16_t fragment_offset;
        bool more_fragments;
        uint32_t identification;

        static fragment_header from_extension_header(const ext_header& hdr);
    };

    IPv6(address_type ip_dst = address_type(), 
         address_type ip_src = address_type(), 
         PDU* child = 0);

    IPv6(const uint8_t* buffer, uint32_t total_sz);

    // Getters

    small_uint<4> version() const {
        return header_.version;
    }

    uint8_t traffic_class() const {
        #if TINS_IS_LITTLE_ENDIAN
        return ((header_.traffic_class << 4) & 0xf0) | 
                ((header_.flow_label[0] >> 4) & 0x0f);
        #else
        return header_.traffic_class;
        #endif
    }

    small_uint<20> flow_label() const {
        #if TINS_IS_LITTLE_ENDIAN
        return ((header_.flow_label[0] & 0x0f) << 16)
                | (header_.flow_label[1] << 8)
                | (header_.flow_label[2]);
        #else
        return header_.flow_label;
        #endif
    }

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

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

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

    address_type src_addr() const {
        return header_.src_addr;
    }

    address_type dst_addr() const {
        return header_.dst_addr;
    }

    const headers_type& headers() const {
        return ext_headers_;
    }

    // Setters

    void version(small_uint<4> new_version);

    void traffic_class(uint8_t new_traffic_class);

    void flow_label(small_uint<20> new_flow_label);

    void payload_length(uint16_t new_payload_length);

    void next_header(uint8_t new_next_header);

    void hop_limit(uint8_t new_hop_limit);

    void src_addr(const address_type& new_src_addr);

    void dst_addr(const address_type& new_dst_addr);
    
    uint32_t header_size() const;
    
    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;
    
    IPv6* clone() const {
        return new IPv6(*this);
    }
    
    PDUType pdu_type() const { return pdu_flag; }
    
    #ifndef BSD

    void send(PacketSender& sender, const NetworkInterface &);

    PDU* recv_response(PacketSender& sender, const NetworkInterface &);
    #endif
    
    TINS_DEPRECATED(void add_ext_header(const ext_header& header));
    
    void add_header(const ext_header& header);

    #if TINS_IS_CXX11

    void add_header(ext_header&& header) {
        ext_headers_.emplace_back(std::move(header));
    }

    template <typename... Args>
    void add_header(Args&&... args) {
        ext_headers_.emplace_back(std::forward<Args>(args)...);
    }

    #endif // TINS_IS_CXX11

    const ext_header* search_header(ExtensionHeader id) const;
private:
    void write_serialization(uint8_t* buffer, uint32_t total_sz);
    void set_last_next_header(uint8_t value);
    uint32_t calculate_headers_size() const;
    static void write_header(const ext_header& header, Memory::OutputMemoryStream& stream);
    static bool is_extension_header(uint8_t header_id);
    static uint32_t get_padding_size(const ext_header& header);
    static std::vector<header_option_type> parse_header_options(const uint8_t* data, size_t size);

    TINS_BEGIN_PACK
    struct ipv6_header {
        #if TINS_IS_BIG_ENDIAN
        uint32_t version:4,
                traffic_class:8,
                flow_label:20;
        uint32_t payload_length:16,
                next_header:8,
                hop_limit:8;
        #else
        uint8_t traffic_class:4,
                version:4;
        uint8_t flow_label[3];
        uint16_t payload_length;
        uint8_t next_header;
        uint8_t hop_limit;
        #endif
        uint8_t src_addr[16], dst_addr[16];
    } TINS_END_PACK;

    ipv6_header header_;
    headers_type ext_headers_;
    uint8_t next_header_;
};
}

#endif // TINS_IPV6_h