pdu_option.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_PDU_OPTION_H
#define TINS_PDU_OPTION_H

#include <vector>
#include <string>
#include <cstring>
#include <stdint.h>
#include <tins/exceptions.h>
#include <tins/detail/type_traits.h>

namespace Tins {

class IPv4Address;
class IPv6Address;
template <size_t n>
class HWAddress;

template <typename OptionType, typename PDUType>
class PDUOption;

namespace Internals {
    namespace Converters {
        uint8_t convert(const uint8_t* ptr, uint32_t data_size, PDU::endian_type endian,
                        type_to_type<uint8_t>);
        int8_t convert(const uint8_t* ptr, uint32_t data_size, PDU::endian_type endian,
                        type_to_type<int8_t>);
        uint16_t convert(const uint8_t* ptr, uint32_t data_size, PDU::endian_type endian,
                         type_to_type<uint16_t>);
        uint32_t convert(const uint8_t* ptr, uint32_t data_size, PDU::endian_type endian,
                         type_to_type<uint32_t>);
        uint64_t convert(const uint8_t* ptr, uint32_t data_size, PDU::endian_type endian,
                         type_to_type<uint64_t>);
        HWAddress<6> convert(const uint8_t* ptr, uint32_t data_size,
                             PDU::endian_type endian, type_to_type<HWAddress<6> >);
        IPv4Address convert(const uint8_t* ptr, uint32_t data_size,
                            PDU::endian_type endian, type_to_type<IPv4Address>);
        IPv6Address convert(const uint8_t* ptr, uint32_t data_size, PDU::endian_type endian,
                            type_to_type<IPv6Address>);
        std::string convert(const uint8_t* ptr, uint32_t data_size,
                            PDU::endian_type endian, type_to_type<std::string>);
        std::vector<float> convert(const uint8_t* ptr, uint32_t data_size,
                                   PDU::endian_type endian, type_to_type<std::vector<float> >);
        std::vector<uint8_t> convert(const uint8_t* ptr, uint32_t data_size,
                                     PDU::endian_type endian, type_to_type<std::vector<uint8_t> >);
        std::vector<uint16_t> convert(const uint8_t* ptr, uint32_t data_size,
                                      PDU::endian_type endian,
                                      type_to_type<std::vector<uint16_t> >);
        std::vector<uint32_t> convert(const uint8_t* ptr, uint32_t data_size,
                                      PDU::endian_type endian,
                                      type_to_type<std::vector<uint32_t> >);
        std::vector<IPv4Address> convert(const uint8_t* ptr, uint32_t data_size,
                                         PDU::endian_type endian,
                                         type_to_type<std::vector<IPv4Address> >);
        std::vector<IPv6Address> convert(const uint8_t* ptr, uint32_t data_size,
                                         PDU::endian_type endian,
                                         type_to_type<std::vector<IPv6Address> >);
        std::vector<std::pair<uint8_t, uint8_t> > convert(const uint8_t* ptr, uint32_t data_size,
                                                          PDU::endian_type endian,
                                        type_to_type<std::vector<std::pair<uint8_t, uint8_t> > >);
        std::pair<uint8_t, uint8_t> convert(const uint8_t* ptr, uint32_t data_size,
                                            PDU::endian_type endian,
                                            type_to_type<std::pair<uint8_t, uint8_t> >);
        std::pair<uint16_t, uint32_t> convert(const uint8_t* ptr, uint32_t data_size,
                                              PDU::endian_type endian,
                                              type_to_type<std::pair<uint16_t, uint32_t> >);
        std::pair<uint32_t, uint32_t> convert(const uint8_t* ptr, uint32_t data_size,
                                              PDU::endian_type endian,
                                              type_to_type<std::pair<uint32_t, uint32_t> >);
    } // Converters
    
    struct converter {
        template <typename T, typename X, typename PDUType>
        static T do_convert(const PDUOption<X, PDUType>& opt, type_to_type<T>) {
            return T::from_option(opt);
        }

        template <typename U, typename X, typename PDUType>
        static U do_convert(const PDUOption<X, PDUType>& opt, type_to_type<uint8_t> type) {
            return Converters::convert(opt.data_ptr(), opt.data_size(),
                                       PDUType::endianness, type);
        }

        template <typename U, typename X, typename PDUType>
        static U do_convert(const PDUOption<X, PDUType>& opt, type_to_type<int8_t> type) {
            return Converters::convert(opt.data_ptr(), opt.data_size(),
                                       PDUType::endianness, type);
        }

        template <typename U, typename X, typename PDUType>
        static U do_convert(const PDUOption<X, PDUType>& opt, type_to_type<uint16_t> type) {
            return Converters::convert(opt.data_ptr(), opt.data_size(),
                                       PDUType::endianness, type);
        }

        template <typename U, typename X, typename PDUType>
        static U do_convert(const PDUOption<X, PDUType>& opt, type_to_type<uint32_t> type) {
            return Converters::convert(opt.data_ptr(), opt.data_size(),
                                       PDUType::endianness, type);
        }

        template <typename U, typename X, typename PDUType>
        static U do_convert(const PDUOption<X, PDUType>& opt, type_to_type<uint64_t> type) {
            return Converters::convert(opt.data_ptr(), opt.data_size(),
                                       PDUType::endianness, type);
        }

        template <typename U, typename X, typename PDUType>
        static U do_convert(const PDUOption<X, PDUType>& opt, type_to_type<HWAddress<6> > type) {
            return Converters::convert(opt.data_ptr(), opt.data_size(),
                                       PDUType::endianness, type);
        }

        template <typename U, typename X, typename PDUType>
        static U do_convert(const PDUOption<X, PDUType>& opt, type_to_type<IPv4Address> type) {
            return Converters::convert(opt.data_ptr(), opt.data_size(),
                                       PDUType::endianness, type);
        }

        template <typename U, typename X, typename PDUType>
        static U do_convert(const PDUOption<X, PDUType>& opt, type_to_type<IPv6Address> type) {
            return Converters::convert(opt.data_ptr(), opt.data_size(),
                                       PDUType::endianness, type);
        }

        template <typename U, typename X, typename PDUType>
        static U do_convert(const PDUOption<X, PDUType>& opt,
                            type_to_type<std::string> type) {
            return Converters::convert(opt.data_ptr(), opt.data_size(),
                                       PDUType::endianness, type);
        }

        template <typename U, typename X, typename PDUType, typename Z>
        static U do_convert(const PDUOption<X, PDUType>& opt,
                            type_to_type<std::vector<Z> > type) {
            return Converters::convert(opt.data_ptr(), opt.data_size(),
                                       PDUType::endianness, type);
        }

        template <typename U, typename X, typename PDUType, typename Z, typename W>
        static U do_convert(const PDUOption<X, PDUType>& opt,
                            type_to_type<std::pair<Z, W> > type) {
            return Converters::convert(opt.data_ptr(), opt.data_size(),
                                       PDUType::endianness, type);
        }

        template <typename T, typename X, typename PDUType>
        static T convert(const PDUOption<X, PDUType>& opt) {
            return do_convert<T>(opt, type_to_type<T>());
        }
    };
}

template <typename OptionType, typename PDUType>
class PDUOption {
private:
    static const int small_buffer_size = 8;
public:
    typedef uint8_t data_type;
    typedef OptionType option_type;

    PDUOption(option_type opt = option_type(), 
              size_t length = 0,
              const data_type* data = 0) 
    : option_(opt), size_(static_cast<uint16_t>(length)), real_size_(0) {
        if (data != 0) {
            set_payload_contents(data, data + length);
        }
    }
    
    PDUOption(const PDUOption& rhs) {
        real_size_ = 0;
        *this = rhs;
    }
    
    #if TINS_IS_CXX11

    PDUOption(PDUOption&& rhs) TINS_NOEXCEPT {
        real_size_ = 0;
        *this = std::move(rhs);
    }
    
    PDUOption& operator=(PDUOption&& rhs) TINS_NOEXCEPT {
        option_ = rhs.option_;
        size_ = rhs.size_;
        if (real_size_ > small_buffer_size) {
            delete[] payload_.big_buffer_ptr;
        }
        real_size_ = rhs.real_size_;
        if (real_size_ > small_buffer_size) {
            payload_.big_buffer_ptr = 0;
            std::swap(payload_.big_buffer_ptr, rhs.payload_.big_buffer_ptr);
            rhs.real_size_ = 0;
        }
        else {
            std::memcpy(payload_.small_buffer, rhs.data_ptr(), rhs.data_size());
        }
        return *this;
    }
    
    #endif // TINS_IS_CXX11
    
    PDUOption& operator=(const PDUOption& rhs) {
        option_ = rhs.option_;
        size_ = rhs.size_;
        if (real_size_ > small_buffer_size) {
            delete[] payload_.big_buffer_ptr;
        }
        real_size_ = rhs.real_size_;
        set_payload_contents(rhs.data_ptr(), rhs.data_ptr() + rhs.data_size());
        return* this;
    }
    
    ~PDUOption() {
        if (real_size_ > small_buffer_size) {
            delete[] payload_.big_buffer_ptr;
        }
    }
    
    template<typename ForwardIterator>
    PDUOption(option_type opt, ForwardIterator start, ForwardIterator end) 
    : option_(opt), size_(static_cast<uint16_t>(std::distance(start, end))) {
        set_payload_contents(start, end);
    }
    
    template<typename ForwardIterator>
    PDUOption(option_type opt, uint16_t length, ForwardIterator start, ForwardIterator end) 
    : option_(opt), size_(length) {
        set_payload_contents(start, end);
    }
    
    option_type option() const {
        return option_;
    }
    
    void option(option_type opt) {
        option_ = opt;
    }
    
    const data_type* data_ptr() const {
        return real_size_ <= small_buffer_size ?
               payload_.small_buffer : 
               payload_.big_buffer_ptr;
    }
    
    size_t data_size() const {
        return real_size_;
    }
    
    size_t length_field() const {
        return size_;
    }
    
    template<typename T>
    T to() const {
        return Internals::converter::convert<T>(*this);
    }
private:
    template<typename ForwardIterator>
    void set_payload_contents(ForwardIterator start, ForwardIterator end) {
        size_t total_size = std::distance(start, end);
        if (total_size > 65535) {
            throw option_payload_too_large();
        }
        real_size_ = static_cast<uint16_t>(total_size);
        if (real_size_ <= small_buffer_size) {
            if (total_size > 0) {
                std::memcpy(payload_.small_buffer, &*start, total_size);
            }
        }
        else {
            payload_.big_buffer_ptr = new data_type[real_size_];
            uint8_t* ptr = payload_.big_buffer_ptr;
            while (start < end) {
                *ptr = *start;
                ++ptr;
                ++start;
            }
        }
    }

    option_type option_;
    uint16_t size_, real_size_;
    union {
        data_type small_buffer[small_buffer_size];
        data_type* big_buffer_ptr;
    } payload_;
};

namespace Internals {
/*
 * \cond
 */

template <typename Option, typename Container>
typename Container::iterator find_option(Container& cont, typename Option::option_type type) {
    typename Container::iterator iter;
    for (iter = cont.begin(); iter != cont.end(); ++iter) {
        if (iter->option() == type) {
            break;
        }
    }
    return iter;
}

template <typename Option, typename Container>
typename Container::const_iterator find_option_const(const Container& cont,
                                                     typename Option::option_type type) {
    typename Container::const_iterator iter;
    for (iter = cont.begin(); iter != cont.end(); ++iter) {
        if (iter->option() == type) {
            break;
        }
    }
    return iter;
}

/*
 * \endcond
 */
} // Internals

} // namespace Tins
#endif // TINS_PDU_OPTION_H