ip.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_IP_H
#define TINS_IP_H

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

namespace Tins {
namespace Memory {

class OutputMemoryStream;

} // Memory

class TINS_API IP : public PDU {
public:
    static const PDU::PDUType pdu_flag = PDU::IP;

    typedef IPv4Address address_type;

    enum Flags {
        FLAG_RESERVED = 4,
        DONT_FRAGMENT = 2,
        MORE_FRAGMENTS = 1
    };

    enum OptionClass {
        CONTROL = 0,
        MEASUREMENT = 2
    };

    enum OptionNumber {
        END = 0,
        NOOP = 1,
        SEC = 2,
        LSRR = 3,
        TIMESTAMP = 4,
        EXTSEC = 5,
        RR = 7,
        SID = 8,
        SSRR = 9,
        MTUPROBE = 11,
        MTUREPLY = 12,
        EIP = 17,
        TR = 18,
        ADDEXT = 19,
        RTRALT = 20,
        SDB = 21,
        DPS = 23,
        UMP = 24,
        QS = 25
    };
    
    TINS_BEGIN_PACK
    struct option_identifier {
    #if TINS_IS_LITTLE_ENDIAN
        uint8_t number:5,
                op_class:2,
                copied:1;
    #elif TINS_IS_BIG_ENDIAN
        uint8_t copied:1,
                op_class:2,
                number:5;
    #endif

        option_identifier() 
        #if TINS_IS_LITTLE_ENDIAN
        : number(0), op_class(0), copied(0) {}
        #else
        : copied(0), op_class(0), number(0) {}
        #endif
        
        option_identifier(uint8_t value) 
        #if TINS_IS_LITTLE_ENDIAN
        : number(value & 0x1f), 
          op_class((value >> 5) & 0x03), 
          copied((value >> 7) & 0x01) {}
        #elif TINS_IS_BIG_ENDIAN
        : copied((value >> 7) & 0x01),
          op_class((value >> 5) & 0x03), 
          number(value & 0x1f) {}
        #endif
        
        option_identifier(OptionNumber number, OptionClass op_class,
          small_uint<1> copied) 
        #if TINS_IS_LITTLE_ENDIAN
        : number(number), op_class(op_class), copied(copied) {}
        #else
        : copied(copied), op_class(op_class), number(number) {}
        #endif
        
        bool operator==(const option_identifier& rhs) const {
            return number == rhs.number && op_class == rhs.op_class && copied == rhs.copied;
        }
    } TINS_END_PACK;
    
    typedef PDUOption<option_identifier, IP> option;

    struct security_type {
        uint16_t security, compartments;
        uint16_t handling_restrictions;
        small_uint<24> transmission_control;
        
        security_type(uint16_t sec = 0, 
                      uint16_t comp = 0,
                      uint16_t hand_res = 0,
                      small_uint<24> tcc = 0)
        : security(sec), compartments(comp), 
          handling_restrictions(hand_res), transmission_control(tcc) { }
        
        static security_type from_option(const option& opt);
    };
    
    struct generic_route_option_type {
        typedef std::vector<address_type> routes_type;
        
        uint8_t pointer;
        routes_type routes;
        
        generic_route_option_type(uint8_t ptr = 0, routes_type rts = routes_type())
        : pointer(ptr), routes(rts) {}
        
        static generic_route_option_type from_option(const option& opt);
    };
    
    typedef generic_route_option_type lsrr_type;
    
    typedef generic_route_option_type ssrr_type;
    
    typedef generic_route_option_type record_route_type;

    typedef std::vector<option> options_type;

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

    IP(address_type ip_dst = address_type(), 
       address_type ip_src = address_type());

    IP(const uint8_t* buffer, uint32_t total_sz);

    /* Getters */

    small_uint<4> head_len() const {
        return this->header_.ihl;
    }

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

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

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

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

    small_uint<13> fragment_offset() const {
        return Endian::be_to_host(header_.frag_off) & 0x1fff;
    }

    Flags flags() const {
        return static_cast<Flags>(Endian::be_to_host(header_.frag_off) >> 13);
    }

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

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

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

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

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

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

    /* Setters */

    void tos(uint8_t new_tos);

    void id(uint16_t new_id);

    TINS_DEPRECATED(void frag_off(uint16_t new_frag_off));
    
    void fragment_offset(small_uint<13> new_frag_off);

    void flags(Flags new_flags);

    void ttl(uint8_t new_ttl);

    void protocol(uint8_t new_protocol);

    void src_addr(address_type ip);

    void dst_addr(address_type ip);
    
    void version(small_uint<4> ver);

    void add_option(const option& opt);
    
    #if TINS_IS_CXX11

        void add_option(option &&opt) {
            options_.push_back(std::move(opt));
        }

        template<typename... Args>
        void add_option(Args&&... args) {
            options_.emplace_back(std::forward<Args>(args)...);
        }
    #endif

    bool remove_option(option_identifier id);

    const option* search_option(option_identifier id) const;

    // Option setters
    
    void eol();

    void noop();

    void security(const security_type& data);
    
    void lsrr(const lsrr_type& data) {
        add_route_option(131, data);
    }
    
    void ssrr(const ssrr_type& data) {
        add_route_option(137, data);
    }
    
    void record_route(const record_route_type& data) {
        add_route_option(7, data);
    }
    
    void stream_identifier(uint16_t stream_id);
    
    // Option getters
    
    security_type security() const;
    
    lsrr_type lsrr() const {
        return search_route_option(131);
    }
    
    ssrr_type ssrr() const {
        return search_route_option(137);
    }
    
    record_route_type record_route() const {
        return search_route_option(7);
    }

    uint16_t stream_identifier() const;

    /* Virtual methods */

    uint32_t header_size() const;

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

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

    PDU* recv_response(PacketSender& sender, const NetworkInterface &);

    bool is_fragmented() const;

    PDUType pdu_type() const {
        return pdu_flag;
    }

    IP* clone() const {
        return new IP(*this);
    }
private:
    static const uint8_t DEFAULT_TTL;

    TINS_BEGIN_PACK
    struct ip_header {
    #if TINS_IS_LITTLE_ENDIAN
        uint8_t ihl:4,
                version:4;
    #else
        uint8_t version:4,
                ihl:4;
    #endif
        uint8_t tos;
        uint16_t tot_len;
        uint16_t id;
        uint16_t frag_off;
        uint8_t ttl;
        uint8_t protocol;
        uint16_t check;
        uint32_t saddr;
        uint32_t daddr;
    } TINS_END_PACK;

    void head_len(small_uint<4> new_head_len);
    void tot_len(uint16_t new_tot_len);

    void prepare_for_serialize();
    uint32_t calculate_options_size() const;
    uint32_t pad_options_size(uint32_t size) const;
    void init_ip_fields();
    void write_serialization(uint8_t* buffer, uint32_t total_sz);
    void write_option(const option& opt, Memory::OutputMemoryStream& stream);
    void add_route_option(option_identifier id, const generic_route_option_type& data);
    generic_route_option_type search_route_option(option_identifier id) const;
    void checksum(uint16_t new_check);
    options_type::const_iterator search_option_iterator(option_identifier id) const;
    options_type::iterator search_option_iterator(option_identifier id);

    options_type options_;
    ip_header header_;
};

} // Tins

#endif // TINS_IP_H