buffer.hpp

Go to the documentation of this file.

//    OpenVPN -- An application to securely tunnel IP networks
//               over a single port, with support for SSL/TLS-based
//               session authentication and key exchange,
//               packet encryption, packet authentication, and
//               packet compression.
//
//    Copyright (C) 2012- OpenVPN Inc.
//
//    SPDX-License-Identifier: MPL-2.0 OR AGPL-3.0-only WITH openvpn3-openssl-exception
//
 
// These templates define the fundamental data buffer classes used by the
// OpenVPN core.  Normally OpenVPN uses buffers of unsigned chars, but the
// templatization of the classes would allow buffers of other types to
// be defined.
//
// Fundamentally a buffer is an object with 4 fields:
//
// 1. a pointer to underlying data array
// 2. the capacity of the underlying data array
// 3. an offset into the data array
// 4. the size of the referenced data within the array
//
// The BufferType template is the lowest-level buffer class template.  It refers
// to a buffer but without any notion of ownership of the underlying data.
//
// The BufferAllocatedType template is a higher-level template that inherits
// from BufferType but which asserts ownership over the resources of the buffer --
// for example, it will free the underlying buffer in its destructor.
//
// Since most of the time, we want our buffers to be made out of unsigned chars,
// some typedefs at the end of the file define common instantations for the
// BufferType and BufferAllocatedType templates.
//
// Buffer            : a simple buffer of unsigned char without ownership semantics
// ConstBuffer       : like buffer but where the data pointed to by the buffer is read-only
// BufferAllocated   : an allocated Buffer with ownership semantics
// BufferPtr         : a smart, reference-counted pointer to a BufferAllocatedRc
 
#pragma once
 
#include <string>
#include <cstdlib> // defines std::abort()
#include <cstring>
#include <algorithm>
#include <type_traits> // for std::is_nothrow_move_constructible_v, std::remove_const, std::enable_if_t, and std::is_const_v
 
#ifndef OPENVPN_NO_IO
#include <openvpn/io/io.hpp>
#endif
 
#include <openvpn/common/size.hpp>
#include <openvpn/common/exception.hpp>
#include <openvpn/common/rc.hpp>
#include <openvpn/buffer/bufclamp.hpp>
#include <openvpn/common/make_rc.hpp>
#include <openvpn/common/intrinsic_type.hpp>
 
#ifdef OPENVPN_BUFFER_ABORT
#define OPENVPN_BUFFER_THROW(exc) \
    {                             \
        std::abort();             \
    }
#else
#define OPENVPN_BUFFER_THROW(exc)                    \
    {                                                \
        throw BufferException(BufferException::exc); \
    }
#endif
 
namespace openvpn {
//  ===============================================================================================
//  special-purpose exception class for Buffer classes
//  ===============================================================================================
 
class BufferException : public std::exception
{
  public:
    enum Status
    {
        buffer_full,
        buffer_headroom,
        buffer_underflow,
        buffer_overflow,
        buffer_offset,
        buffer_index,
        buffer_const_index,
        buffer_push_front_headroom,
        buffer_no_reset_impl,
        buffer_pop_back,
        buffer_set_size,
        buffer_range,
    };
 
    explicit BufferException(Status status)
        : status_(status)
    {
    }
 
    BufferException(Status status, const std::string &msg)
        : status_(status),
          msg_(std::string(status_string(status)) + " : " + msg)
    {
    }
 
    const char *what() const noexcept override
    {
        if (!msg_.empty())
            return msg_.c_str();
        return status_string(status_);
    }
 
    Status status() const
    {
        return status_;
    }
    virtual ~BufferException() noexcept = default;
 
  private:
    static const char *status_string(const Status status)
    {
        switch (status)
        {
        case buffer_full:
            return "buffer_full";
        case buffer_headroom:
            return "buffer_headroom";
        case buffer_underflow:
            return "buffer_underflow";
        case buffer_overflow:
            return "buffer_overflow";
        case buffer_offset:
            return "buffer_offset";
        case buffer_index:
            return "buffer_index";
        case buffer_const_index:
            return "buffer_const_index";
        case buffer_push_front_headroom:
            return "buffer_push_front_headroom";
        case buffer_no_reset_impl:
            return "buffer_no_reset_impl";
        case buffer_pop_back:
            return "buffer_pop_back";
        case buffer_set_size:
            return "buffer_set_size";
        case buffer_range:
            return "buffer_range";
        default:
            return "buffer_???";
        }
    }
 
    Status status_;
    std::string msg_;
};
 
//  ===============================================================================================
//  ===============================================================================================
 
template <typename T>
class BufferAllocatedType;
 
template <typename T>
class BufferType;
 
// Allocation and security for the buffer
struct BufferFlags : IntrinsicType<BufferFlags, unsigned int>
{
    using IntrinsicType<BufferFlags, unsigned int>::IntrinsicType;
};
 
//  ===============================================================================================
//  class ConstBufferType
//  ===============================================================================================
template <typename T>
class ConstBufferType
{
  public:
    using value_type = T;
    using type = T *;
    using const_type = const T *;
    using NCT = typename std::remove_const_t<T>;
 
    ConstBufferType();
 
    ConstBufferType(void *data, const size_t size, const bool filled);
 
    template <typename U = T,
              typename std::enable_if_t<!std::is_const_v<U>, int> = 0>
    ConstBufferType(const void *data, const size_t size, const bool filled);
 
    ConstBufferType(T *data, const size_t size, const bool filled);
 
    template <typename U = T,
              typename std::enable_if_t<!std::is_const_v<U>, int> = 0>
    ConstBufferType(const U *data, const size_t size, const bool filled);
 
    virtual ~ConstBufferType() = default;
 
    const auto &operator[](const size_t index) const;
 
    auto &operator[](const size_t index);
 
    void init_headroom(const size_t headroom);
 
    void reset_offset(const size_t offset);
 
    void reset_size();
 
    void reset_content();
 
    const T *c_str() const;
 
    size_t length() const;
 
    const T *c_data() const;
 
    const T *c_data_end() const;
 
    const T *c_data_raw() const;
 
    size_t capacity() const;
 
    size_t offset() const;
 
    bool defined() const;
 
    bool allocated() const;
 
    bool empty() const;
 
    size_t size() const;
 
    T pop_back();
 
    T pop_front();
 
    T front() const;
 
    T back() const;
 
    void advance(const size_t delta);
 
    bool contains_null() const;
 
    bool is_zeroed() const;
 
#ifndef OPENVPN_NO_IO
    openvpn_io::const_buffer const_buffer() const;
 
    openvpn_io::const_buffer const_buffer_clamp() const;
 
    openvpn_io::const_buffer const_buffer_limit(const size_t limit) const;
#endif
 
    void read(NCT *data, const size_t size);
 
    void read(void *data, const size_t size);
 
    auto *read_alloc(const size_t size);
 
    auto read_alloc_buf(const size_t size);
 
    size_t max_size() const;
 
    void set_size(const size_t size);
 
    void inc_size(const size_t delta);
 
    ConstBufferType range(size_t offset, size_t len) const;
 
    const T *c_index(const size_t index) const;
 
    bool operator==(const ConstBufferType &other) const;
 
    bool operator!=(const ConstBufferType &other) const;
 
  protected: // mutable implementations are only available to derived classes
    void reserve(const size_t n);
 
    T *data();
 
    T *data_end();
 
    T *data_raw();
 
    size_t remaining(const size_t tailroom = 0) const;
 
    size_t max_size_tailroom(const size_t tailroom) const;
 
    void push_back(const T &value);
 
    void push_front(const T &value);
 
    void set_trailer(const T &value);
 
    void null_terminate();
 
    T *index(const size_t index);
 
#ifndef OPENVPN_NO_IO
    openvpn_io::mutable_buffer mutable_buffer(const size_t tailroom = 0);
 
    openvpn_io::mutable_buffer mutable_buffer_append(const size_t tailroom = 0);
 
    openvpn_io::mutable_buffer mutable_buffer_clamp(const size_t tailroom = 0);
 
    openvpn_io::mutable_buffer mutable_buffer_append_clamp(const size_t tailroom = 0);
#endif
 
    void realign(size_t headroom);
 
    void write(const T *data, const size_t size);
 
    void write(const void *data, const size_t size);
 
    void prepend(const T *data, const size_t size);
 
    void prepend(const void *data, const size_t size);
 
    T *write_alloc(const size_t size);
 
    T *prepend_alloc(const size_t size);
 
    void reset(const size_t min_capacity, const BufferFlags flags);
 
    void reset(const size_t headroom, const size_t min_capacity, const BufferFlags flags);
 
    template <typename B>
    void append(const B &other);
 
    template <typename T_>
    void swap(ConstBufferType<T_> &other);
 
    void buffer_full_error(const size_t newcap, const bool allocated) const;
 
    virtual void reset_impl(const size_t min_capacity, const BufferFlags flags);
 
    virtual void resize(const size_t new_capacity);
 
    ConstBufferType(T *data, const size_t offset, const size_t size, const size_t capacity);
 
    template <typename U = T,
              typename std::enable_if_t<!std::is_const_v<U>, int> = 0>
    ConstBufferType(const U *data, const size_t offset, const size_t size, const size_t capacity);
 
  private:
    // Even though *data_ is declared as non-const, within ConstBufferType
    // we MUST always treat it as const.  But derived classes may treat it
    // as non-const as long as they passed in non-const data to begin with.
    T *data_;         // pointer to data
    size_t offset_;   // offset from data_ of beginning of T array (to allow for headroom)
    size_t size_;     // number of T objects in array starting at data_ + offset_
    size_t capacity_; // maximum number of array objects of type T for which memory is allocated, starting at data_
};
 
//  ===============================================================================================
//  class BufferType
//  ===============================================================================================
 
template <typename T>
class BufferType : public ConstBufferType<T>
{
  private:
    template <typename>
    friend class ConstBufferType;
 
  public:
    using ConstBufferType<T>::empty;
    using ConstBufferType<T>::capacity;
    using ConstBufferType<T>::offset;
    using ConstBufferType<T>::back;
    using ConstBufferType<T>::init_headroom;
    using ConstBufferType<T>::operator[];
    using ConstBufferType<T>::reserve;
    using ConstBufferType<T>::data;
    using ConstBufferType<T>::data_end;
    using ConstBufferType<T>::data_raw;
    using ConstBufferType<T>::remaining;
    using ConstBufferType<T>::max_size_tailroom;
    using ConstBufferType<T>::push_back;
    using ConstBufferType<T>::push_front;
    using ConstBufferType<T>::set_trailer;
    using ConstBufferType<T>::null_terminate;
    using ConstBufferType<T>::index;
#ifndef OPENVPN_NO_IO
    using ConstBufferType<T>::mutable_buffer;
    using ConstBufferType<T>::mutable_buffer_append;
    using ConstBufferType<T>::mutable_buffer_clamp;
    using ConstBufferType<T>::mutable_buffer_append_clamp;
#endif
    using ConstBufferType<T>::realign;
    using ConstBufferType<T>::write;
    using ConstBufferType<T>::prepend;
    using ConstBufferType<T>::write_alloc;
    using ConstBufferType<T>::prepend_alloc;
    using ConstBufferType<T>::reset;
    using ConstBufferType<T>::append;
    using ConstBufferType<T>::reset_impl;
    using ConstBufferType<T>::resize;
    using ConstBufferType<T>::buffer_full_error;
 
    BufferType() = default;
 
    BufferType(void *data, const size_t size, const bool filled)
        : ConstBufferType<T>(data, size, filled) {};
 
    BufferType(T *data, const size_t size, const bool filled)
        : ConstBufferType<T>(data, size, filled) {};
 
  protected:
    BufferType(T *data, const size_t offset, const size_t size, const size_t capacity)
        : ConstBufferType<T>(data, offset, size, capacity) {};
};
 
//  ===============================================================================================
//  class BufferAllocatedType
//  ===============================================================================================
 
// Flag constants
namespace BufAllocFlags {
constexpr BufferFlags NO_FLAGS(0U);            
constexpr BufferFlags CONSTRUCT_ZERO(1U << 0); 
constexpr BufferFlags DESTRUCT_ZERO(1U << 1);  
constexpr BufferFlags GROW(1U << 2);           
constexpr BufferFlags ARRAY(1U << 3);          
} // namespace BufAllocFlags
 
template <typename T>
class BufferAllocatedType : public BufferType<T>
{
  private:
    // Friend to all specializations of this template allows access to other.data_
    template <typename>
    friend class BufferAllocatedType;
 
  public:
    using BufferType<T>::init_headroom;
    using BufferType<T>::buffer_full_error;
    using BufferType<T>::size;
    using BufferType<T>::capacity;
    using BufferType<T>::offset;
    using BufferType<T>::data_raw;
    using BufferType<T>::c_data_raw;
    using BufferType<T>::data;
    using BufferType<T>::c_data;
    using BufferType<T>::swap;
 
    BufferAllocatedType();
 
    explicit BufferAllocatedType(const size_t capacity,
                                 const BufferFlags flags = BufAllocFlags::NO_FLAGS);
 
    explicit BufferAllocatedType(const T *data, const size_t size, const BufferFlags flags);
 
    BufferAllocatedType(const BufferAllocatedType &other);
 
    template <typename T_>
    BufferAllocatedType(const BufferType<T_> &other,
                        const BufferFlags flags = BufAllocFlags::NO_FLAGS);
 
    void operator=(const BufferAllocatedType &other);
 
    void init(const size_t capacity, const BufferFlags flags = BufAllocFlags::NO_FLAGS);
 
    void init(const T *data, const size_t size, const BufferFlags flags);
 
    void realloc(const size_t newcap);
 
    BufferAllocatedType &realign(const size_t headroom);
 
    void reset(const size_t min_capacity, const BufferFlags flags = BufAllocFlags::NO_FLAGS);
 
    void reset(const size_t headroom,
               const size_t min_capacity,
               const BufferFlags flags = BufAllocFlags::NO_FLAGS);
 
    template <typename T_>
    void move(BufferAllocatedType<T_> &other);
 
    template <typename T_>
    void swap(BufferAllocatedType<T_> &other);
 
    template <typename T_>
    BufferAllocatedType(BufferAllocatedType<T_> &&other) noexcept;
 
    BufferAllocatedType &operator=(BufferAllocatedType &&other) noexcept;
 
    void clear();
 
    bool test_flags(const BufferFlags flags) const noexcept;
 
    void add_flags(const BufferFlags flags);
 
    void clear_flags(const BufferFlags flags);
 
    ~BufferAllocatedType();
 
    BufferAllocatedType(const size_t offset,
                        const size_t size,
                        const size_t capacity,
                        const BufferFlags flags);
 
    void reset_impl(const size_t min_capacity, const BufferFlags flags) override;
 
    void resize(const size_t new_capacity) override;
 
    void realloc_(const size_t newcap, size_t new_offset);
 
    void free_data();
 
  private:
    BufferFlags flags_;
};
 
//  ===============================================================================================
//  ConstBufferType<T> member function definitions
//  ===============================================================================================
 
template <typename T>
ConstBufferType<T>::ConstBufferType()
{
    static_assert(std::is_nothrow_move_constructible_v<ConstBufferType>,
                  "class ConstBufferType not noexcept move constructable");
    data_ = nullptr;
    offset_ = size_ = capacity_ = 0;
}
 
template <typename T>
ConstBufferType<T>::ConstBufferType(void *data, const size_t size, const bool filled)
    : ConstBufferType((T *)data, size, filled){};
 
template <typename T>
template <typename U, typename std::enable_if_t<!std::is_const_v<U>, int>>
ConstBufferType<T>::ConstBufferType(const void *data, const size_t size, const bool filled)
    : ConstBufferType(const_cast<void *>(data), size, filled){};
 
template <typename T>
ConstBufferType<T>::ConstBufferType(T *data, const size_t size, const bool filled)
    : data_(data),
      offset_(0),
      size_(filled ? size : 0),
      capacity_(size){};
 
template <typename T>
template <typename U, typename std::enable_if_t<!std::is_const_v<U>, int>>
ConstBufferType<T>::ConstBufferType(const U *data, const size_t size, const bool filled)
    : ConstBufferType(const_cast<U *>(data), size, filled){};
 
template <typename T>
const auto &ConstBufferType<T>::operator[](const size_t index) const
{
    if (index >= size_)
        OPENVPN_BUFFER_THROW(buffer_const_index);
    return c_data()[index];
}
 
template <typename T>
auto &ConstBufferType<T>::operator[](const size_t index)
{
    if (index >= size_)
        OPENVPN_BUFFER_THROW(buffer_const_index);
    if constexpr (std::is_same_v<ConstBufferType<T>, decltype(*this)>)
        return c_data()[index];
    else
        return data()[index];
}
 
template <typename T>
void ConstBufferType<T>::init_headroom(const size_t headroom)
{
    if (headroom > capacity_)
        OPENVPN_BUFFER_THROW(buffer_headroom);
    offset_ = headroom;
    size_ = 0;
}
 
template <typename T>
void ConstBufferType<T>::reset_offset(const size_t offset)
{
    const size_t size = size_ + offset_ - offset;
    if (offset > capacity_ || size > capacity_ || offset + size > capacity_)
        OPENVPN_BUFFER_THROW(buffer_offset);
    offset_ = offset;
    size_ = size;
}
 
template <typename T>
void ConstBufferType<T>::reset_size()
{
    size_ = 0;
}
 
template <typename T>
void ConstBufferType<T>::reset_content()
{
    offset_ = size_ = 0;
}
 
template <typename T>
const T *ConstBufferType<T>::c_str() const
{
    return c_data();
}
 
template <typename T>
size_t ConstBufferType<T>::length() const
{
    return size();
}
 
template <typename T>
const T *ConstBufferType<T>::c_data() const
{
    return data_ + offset_;
}
 
template <typename T>
const T *ConstBufferType<T>::c_data_end() const
{
    return data_ + offset_ + size_;
}
 
template <typename T>
const T *ConstBufferType<T>::c_data_raw() const
{
    return data_;
}
 
template <typename T>
size_t ConstBufferType<T>::capacity() const
{
    return capacity_;
}
 
template <typename T>
size_t ConstBufferType<T>::offset() const
{
    return offset_;
}
 
template <typename T>
bool ConstBufferType<T>::defined() const
{
    return size_ > 0;
}
 
template <typename T>
bool ConstBufferType<T>::allocated() const
{
    return data_ != nullptr;
}
 
template <typename T>
bool ConstBufferType<T>::empty() const
{
    return !size_;
}
 
template <typename T>
size_t ConstBufferType<T>::size() const
{
    return size_;
}
 
template <typename T>
T ConstBufferType<T>::pop_back()
{
    if (!size_)
        OPENVPN_BUFFER_THROW(buffer_pop_back);
    return *(c_data() + (--size_));
}
 
template <typename T>
T ConstBufferType<T>::pop_front()
{
    T ret = (*this)[0];
    ++offset_;
    --size_;
    return ret;
}
 
template <typename T>
T ConstBufferType<T>::front() const
{
    return (*this)[0];
}
 
template <typename T>
T ConstBufferType<T>::back() const
{
    return (*this)[size_ - 1];
}
 
template <typename T>
void ConstBufferType<T>::advance(const size_t delta)
{
    if (delta > size_)
        OPENVPN_BUFFER_THROW(buffer_overflow);
    offset_ += delta;
    size_ -= delta;
}
 
template <typename T>
bool ConstBufferType<T>::contains_null() const
{
    const T *end = c_data_end();
    for (const T *p = c_data(); p < end; ++p)
    {
        if (!*p)
            return true;
    }
    return false;
}
 
template <typename T>
bool ConstBufferType<T>::is_zeroed() const
{
    const T *end = c_data_end();
    for (const T *p = c_data(); p < end; ++p)
    {
        if (*p)
            return false;
    }
    return true;
}
 
#ifndef OPENVPN_NO_IO
 
template <typename T>
openvpn_io::const_buffer ConstBufferType<T>::const_buffer() const
{
    return openvpn_io::const_buffer(c_data(), size());
}
 
template <typename T>
openvpn_io::const_buffer ConstBufferType<T>::const_buffer_clamp() const
{
    return openvpn_io::const_buffer(c_data(), buf_clamp_write(size()));
}
 
template <typename T>
openvpn_io::const_buffer ConstBufferType<T>::const_buffer_limit(const size_t limit) const
{
    return openvpn_io::const_buffer(c_data(), std::min(buf_clamp_write(size()), limit));
}
#endif
 
template <typename T>
void ConstBufferType<T>::read(NCT *data, const size_t size)
{
    std::memcpy(data, read_alloc(size), size * sizeof(T));
}
 
template <typename T>
void ConstBufferType<T>::read(void *data, const size_t size)
{
    read((NCT *)data, size);
}
 
template <typename T>
auto *ConstBufferType<T>::read_alloc(const size_t size)
{
    if (size <= size_)
    {
        using retT = std::conditional_t<std::is_same_v<decltype(*this), ConstBufferType<T>>, const value_type, value_type>;
        retT *ret;
        if constexpr (std::is_const_v<retT>)
            ret = c_data();
        else
            ret = data();
        offset_ += size;
        size_ -= size;
        return ret;
    }
    OPENVPN_BUFFER_THROW(buffer_underflow);
}
 
template <typename T>
auto ConstBufferType<T>::read_alloc_buf(const size_t size)
{
    if (size <= size_)
    {
        using retT = std::conditional_t<std::is_same_v<decltype(*this), ConstBufferType<T>>, ConstBufferType<T>, BufferType<T>>;
        retT ret(data_, offset_, size, capacity_);
        offset_ += size;
        size_ -= size;
        return ret;
    }
    OPENVPN_BUFFER_THROW(buffer_underflow);
}
 
template <typename T>
size_t ConstBufferType<T>::max_size() const
{
    const size_t r = capacity_ - offset_;
    return r <= capacity_ ? r : 0;
}
 
template <typename T>
void ConstBufferType<T>::set_size(const size_t size)
{
    if (size > max_size())
        OPENVPN_BUFFER_THROW(buffer_set_size);
    size_ = size;
}
 
template <typename T>
void ConstBufferType<T>::inc_size(const size_t delta)
{
    set_size(size_ + delta);
}
 
template <typename T>
ConstBufferType<T> ConstBufferType<T>::range(size_t offset, size_t len) const
{
    if (offset + len > size())
    {
        if (offset < size())
            len = size() - offset;
        else
            len = 0;
    }
    return ConstBufferType(c_data(), offset, len, len);
}
 
template <typename T>
const T *ConstBufferType<T>::c_index(const size_t index) const
{
    if (index >= size_)
        OPENVPN_BUFFER_THROW(buffer_const_index);
    return &c_data()[index];
}
 
template <typename T>
template <typename T_>
void ConstBufferType<T>::swap(ConstBufferType<T_> &other)
{
    std::swap(other.data_, data_);
    std::swap(other.offset_, offset_);
    std::swap(other.size_, size_);
    std::swap(other.capacity_, capacity_);
}
 
template <typename T>
bool ConstBufferType<T>::operator==(const ConstBufferType &other) const
{
    if (size_ != other.size_)
        return false;
    return std::memcmp(c_data(), other.c_data(), size_) == 0;
}
 
template <typename T>
bool ConstBufferType<T>::operator!=(const ConstBufferType &other) const
{
    return !(*this == other);
}
 
template <typename T>
void ConstBufferType<T>::reserve(const size_t n)
{
    if (n > capacity_)
        resize(n);
}
 
template <typename T>
T *ConstBufferType<T>::data()
{
    return data_ + offset_;
}
 
template <typename T>
T *ConstBufferType<T>::data_end()
{
    return data_ + offset_ + size_;
}
 
template <typename T>
T *ConstBufferType<T>::data_raw()
{
    return data_;
}
 
template <typename T>
size_t ConstBufferType<T>::remaining(const size_t tailroom) const
{
    const size_t r = capacity_ - (offset_ + size_ + tailroom);
    return r <= capacity_ ? r : 0;
}
 
template <typename T>
size_t ConstBufferType<T>::max_size_tailroom(const size_t tailroom) const
{
    const size_t r = capacity_ - (offset_ + tailroom);
    return r <= capacity_ ? r : 0;
}
 
template <typename T>
void ConstBufferType<T>::push_back(const T &value)
{
    if (!remaining())
        resize(offset_ + size_ + 1);
    *(data() + size_++) = value;
}
 
template <typename T>
void ConstBufferType<T>::push_front(const T &value)
{
    if (!offset_)
        OPENVPN_BUFFER_THROW(buffer_push_front_headroom);
    --offset_;
    ++size_;
    *data() = value;
}
 
template <typename T>
void ConstBufferType<T>::set_trailer(const T &value)
{
    if (!remaining())
        resize(offset_ + size_ + 1);
    *(data() + size_) = value;
}
 
template <typename T>
void ConstBufferType<T>::null_terminate()
{
    if (empty() || back())
        push_back(0);
}
 
template <typename T>
T *ConstBufferType<T>::index(const size_t index)
{
    if (index >= size_)
        OPENVPN_BUFFER_THROW(buffer_index);
    return &data()[index];
}
 
 
#ifndef OPENVPN_NO_IO
 
template <typename T>
openvpn_io::mutable_buffer ConstBufferType<T>::mutable_buffer(const size_t tailroom)
{
    return openvpn_io::mutable_buffer(data(), max_size_tailroom(tailroom));
}
 
template <typename T>
openvpn_io::mutable_buffer ConstBufferType<T>::mutable_buffer_append(const size_t tailroom)
{
    return openvpn_io::mutable_buffer(data_end(), remaining(tailroom));
}
 
template <typename T>
openvpn_io::mutable_buffer ConstBufferType<T>::mutable_buffer_clamp(const size_t tailroom)
{
    return openvpn_io::mutable_buffer(data(), buf_clamp_read(max_size_tailroom(tailroom)));
}
 
template <typename T>
openvpn_io::mutable_buffer ConstBufferType<T>::mutable_buffer_append_clamp(const size_t tailroom)
{
    return openvpn_io::mutable_buffer(data_end(), buf_clamp_read(remaining(tailroom)));
}
#endif
 
template <typename T>
void ConstBufferType<T>::realign(size_t headroom)
{
    if (headroom != offset_)
    {
        if (headroom + size_ > capacity_)
            OPENVPN_BUFFER_THROW(buffer_headroom);
        std::memmove(data_ + headroom, data_ + offset_, size_);
        offset_ = headroom;
    }
}
 
template <typename T>
void ConstBufferType<T>::write(const T *data, const size_t size)
{
    std::memcpy(write_alloc(size), data, size * sizeof(T));
}
 
template <typename T>
void ConstBufferType<T>::write(const void *data, const size_t size)
{
    write((const T *)data, size);
}
 
template <typename T>
void ConstBufferType<T>::prepend(const T *data, const size_t size)
{
    std::memcpy(prepend_alloc(size), data, size * sizeof(T));
}
 
template <typename T>
void ConstBufferType<T>::prepend(const void *data, const size_t size)
{
    prepend((const T *)data, size);
}
 
template <typename T>
T *ConstBufferType<T>::write_alloc(const size_t size)
{
    if (size > remaining())
        resize(offset_ + size_ + size);
    T *ret = data() + size_;
    size_ += size;
    return ret;
}
 
template <typename T>
T *ConstBufferType<T>::prepend_alloc(const size_t request_size)
{
    if (request_size > offset())
        realign(request_size);
 
    offset_ -= request_size;
    size_ += request_size;
 
    return data();
}
 
template <typename T>
void ConstBufferType<T>::reset(const size_t min_capacity, const BufferFlags flags)
{
    if (min_capacity > capacity_)
        reset_impl(min_capacity, flags);
}
 
template <typename T>
void ConstBufferType<T>::reset(const size_t headroom,
                               const size_t min_capacity,
                               const BufferFlags flags)
{
    reset(min_capacity, flags);
    init_headroom(headroom);
}
 
template <typename T>
template <typename B>
void ConstBufferType<T>::append(const B &other)
{
    write(other.c_data(), other.size());
}
 
template <typename T>
void ConstBufferType<T>::reset_impl(const size_t min_capacity, const BufferFlags flags)
{
    OPENVPN_BUFFER_THROW(buffer_no_reset_impl);
}
 
template <typename T>
void ConstBufferType<T>::resize(const size_t new_capacity)
{
    if (new_capacity > capacity_)
        buffer_full_error(new_capacity, false);
}
 
template <typename T>
void ConstBufferType<T>::buffer_full_error(const size_t newcap, const bool allocated) const
{
#ifdef OPENVPN_BUFFER_ABORT
    std::abort();
#else
    throw BufferException(BufferException::buffer_full, "allocated=" + std::to_string(allocated) + " size=" + std::to_string(size_) + " offset=" + std::to_string(offset_) + " capacity=" + std::to_string(capacity_) + " newcap=" + std::to_string(newcap));
#endif
}
 
template <typename T>
ConstBufferType<T>::ConstBufferType(T *data, const size_t offset, const size_t size, const size_t capacity)
    : data_(data), offset_(offset), size_(size), capacity_(capacity){};
 
template <typename T>
template <typename U, typename std::enable_if_t<!std::is_const_v<U>, int>>
ConstBufferType<T>::ConstBufferType(const U *data, const size_t offset, const size_t size, const size_t capacity)
    : ConstBufferType(const_cast<U *>(data), offset, size, capacity){};
 
//  ===============================================================================================
//  BufferAllocatedType<T> member function definitions
//  ===============================================================================================
 
template <typename T>
BufferAllocatedType<T>::BufferAllocatedType(const size_t offset,
                                            const size_t size,
                                            const size_t capacity,
                                            const BufferFlags flags)
    : BufferType<T>(capacity ? new T[capacity] : nullptr, offset, size, capacity), flags_(flags)
{
    if (flags & BufAllocFlags::CONSTRUCT_ZERO)
        std::memset(data_raw(), 0, capacity * sizeof(T));
}
 
template <typename T>
BufferAllocatedType<T>::BufferAllocatedType()
    : BufferAllocatedType(0, 0, 0, BufAllocFlags::NO_FLAGS)
{
    static_assert(std::is_nothrow_move_constructible_v<BufferAllocatedType>,
                  "class BufferAllocatedType not noexcept move constructable");
}
 
template <typename T>
BufferAllocatedType<T>::BufferAllocatedType(const size_t capacity,
                                            const BufferFlags flags)
    : BufferAllocatedType(0,
                          (flags & BufAllocFlags::ARRAY ? capacity : 0),
                          capacity,
                          flags){};
 
template <typename T>
BufferAllocatedType<T>::BufferAllocatedType(const T *data,
                                            const size_t size,
                                            const BufferFlags flags)
    : BufferAllocatedType(0, size, size, flags)
{
    if (size && data)
        std::memcpy(data_raw(), data, size * sizeof(T));
}
 
template <typename T>
BufferAllocatedType<T>::BufferAllocatedType(const BufferAllocatedType &other)
    : BufferAllocatedType(other.offset(), other.size(), other.capacity(), other.flags_)
{
    if (size())
        std::memcpy(data(), other.c_data(), size() * sizeof(T));
}
 
template <typename T>
template <typename T_>
BufferAllocatedType<T>::BufferAllocatedType(const BufferType<T_> &other,
                                            const BufferFlags flags)
    : BufferAllocatedType(other.offset(), other.size(), other.capacity(), flags)
{
    static_assert(sizeof(T) == sizeof(T_), "size inconsistency");
    if (size())
        std::memcpy(data(), other.c_data(), size() * sizeof(T));
}
 
template <typename T>
void BufferAllocatedType<T>::operator=(const BufferAllocatedType &other)
{
    if (this != &other)
    {
        auto tempBuffer = BufferAllocatedType(other.offset(),
                                              other.size(),
                                              other.capacity(),
                                              other.flags_);
        if (other.size())
            std::memcpy(tempBuffer.data(), other.c_data(), tempBuffer.size() * sizeof(T));
        swap(tempBuffer);
    }
}
 
template <typename T>
void BufferAllocatedType<T>::init(const size_t capacity, const BufferFlags flags)
{
    auto tempBuffer = BufferAllocatedType(capacity, flags);
    swap(tempBuffer);
}
 
template <typename T>
void BufferAllocatedType<T>::init(const T *data, const size_t size, const BufferFlags flags)
{
    auto tempBuffer = BufferAllocatedType(data, size, flags);
    swap(tempBuffer);
}
 
template <typename T>
void BufferAllocatedType<T>::realloc(const size_t newcap)
{
    if (newcap > capacity())
        realloc_(newcap, offset());
}
 
template <typename T>
BufferAllocatedType<T> &BufferAllocatedType<T>::realign(const size_t headroom)
{
    if (headroom != offset())
    {
        if (headroom + size() > capacity())
            realloc_(headroom + size(), headroom);
        else
            BufferType<T>::realign(headroom);
    }
    return *this;
}
 
template <typename T>
void BufferAllocatedType<T>::reset(const size_t min_capacity, const BufferFlags flags)
{
    if (min_capacity > capacity())
        init(min_capacity, flags);
}
 
template <typename T>
void BufferAllocatedType<T>::reset(const size_t headroom,
                                   const size_t min_capacity,
                                   const BufferFlags flags)
{
    reset(min_capacity, flags);
    init_headroom(headroom);
}
 
template <typename T>
template <typename T_>
void BufferAllocatedType<T>::move(BufferAllocatedType<T_> &other)
{
    auto temp = BufferAllocatedType();
    swap(other);
    other.swap(temp);
}
 
template <typename T>
template <typename T_>
void BufferAllocatedType<T>::swap(BufferAllocatedType<T_> &other)
{
    BufferType<T>::swap(other);
    std::swap(flags_, other.flags_);
}
 
template <typename T>
template <typename T_>
BufferAllocatedType<T>::BufferAllocatedType(BufferAllocatedType<T_> &&other) noexcept
    : BufferAllocatedType()
{
    move(other);
}
 
template <typename T>
BufferAllocatedType<T> &BufferAllocatedType<T>::operator=(BufferAllocatedType &&other) noexcept
{
    if (this != &other)
    {
        move(other);
    }
    return *this;
}
 
template <typename T>
void BufferAllocatedType<T>::clear()
{
    auto tempBuffer = BufferAllocatedType(0, 0, 0, BufAllocFlags::NO_FLAGS);
    swap(tempBuffer);
}
 
template <typename T>
bool BufferAllocatedType<T>::test_flags(const BufferFlags flags) const noexcept
{
    return flags_ & flags;
}
 
template <typename T>
void BufferAllocatedType<T>::add_flags(const BufferFlags flags)
{
    flags_ |= flags;
}
 
template <typename T>
void BufferAllocatedType<T>::clear_flags(const BufferFlags flags)
{
    flags_ &= ~flags;
}
 
template <typename T>
BufferAllocatedType<T>::~BufferAllocatedType()
{
    if (data_raw())
        free_data();
}
 
template <typename T>
void BufferAllocatedType<T>::reset_impl(const size_t min_capacity, const BufferFlags flags)
{
    init(min_capacity, flags);
}
 
template <typename T>
void BufferAllocatedType<T>::resize(const size_t new_capacity)
{
    const size_t newcap = std::max(new_capacity, capacity() * 2);
    if (newcap > capacity())
    {
        if (flags_ & BufAllocFlags::GROW)
            realloc_(newcap, offset());
        else
            buffer_full_error(newcap, true);
    }
}
 
template <typename T>
void BufferAllocatedType<T>::realloc_(const size_t newcap, size_t new_offset)
{
    auto tempBuffer = BufferAllocatedType(new_offset, size(), newcap, flags_);
    if (size())
        std::memcpy(tempBuffer.data(), c_data(), size() * sizeof(T));
    swap(tempBuffer);
}
 
template <typename T>
void BufferAllocatedType<T>::free_data()
{
    if (size() && (flags_ & BufAllocFlags::DESTRUCT_ZERO))
        std::memset(data_raw(), 0, capacity() * sizeof(T));
    delete[] data_raw();
}
 
//  ===============================================================================================
//  specializations of BufferType for unsigned char
//  ===============================================================================================
 
using Buffer = BufferType<unsigned char>;
using ConstBuffer = ConstBufferType<unsigned char>;
using BufferAllocated = BufferAllocatedType<unsigned char>;
using BufferAllocatedRc = RcEnable<BufferAllocated, RC<thread_unsafe_refcount>>;
using BufferPtr = RCPtr<BufferAllocatedRc>;
 
//  ===============================================================================================
//  BufferAllocated + RC  with thread-safe refcount
//  ===============================================================================================
 
using BufferAllocatedTS = RcEnable<BufferAllocated, RC<thread_safe_refcount>>;
using BufferPtrTS = RCPtr<BufferAllocatedTS>;
 
// ===============================================================================================
// Deduction guide - needed to deduce converting ctor
// ===============================================================================================
 
template <typename T_>
BufferAllocatedType(const BufferType<T_> &, BufferFlags) -> BufferAllocatedType<unsigned char>;
 
//  ===============================================================================================
//  cast BufferType<T> to ConstBufferType<T>
//  ===============================================================================================
 
template <typename T>
inline ConstBufferType<T> &const_buffer_ref(BufferType<T> &src)
{
    return src;
}
 
template <typename T>
inline const ConstBufferType<T> &const_buffer_ref(const BufferType<T> &src)
{
    return src;
}
 
//  ===============================================================================================
//  Buffer related utilities - consider moving to a separate file
//  ===============================================================================================
 
template <typename AlignT, typename T>
inline AlignT *align_as(BufferAllocatedType<T> &buf) // TODO: Could be implemented noexcept
{
    /* The standard requires that alignof(T) is a power of 2, and that any allocation will be
       aligned to at least alignof(std::max_align_t), so I assume offset zero in a buffer is
       aligned and therefore there is no need to check for alignment of the buffer itself.
 
       This means a suitable address exists in the first alignof(std::max_align_t) so we never have
       to increase the offset at all. This is a simplification that might not hold in all cases,
       but it is a reasonable assumption for now. Given that, we can just align the buffer by
       masking out the lower bits of the current data address (computation of align_ptr below)
       and then realign the buffer to that address if needed. This will preserve as much of the
       headroom as possible.
    */
    auto data_ptr = reinterpret_cast<uintptr_t>(buf.c_data());         // Current data address in integral form
    auto align_ptr = data_ptr & ~(alignof(AlignT) - 1);                // 'Previous' aligned address
    auto raw_data_ptr = reinterpret_cast<uintptr_t>(buf.c_data_raw()); // Start of allocated buffer
 
    if (align_ptr != data_ptr && align_ptr >= raw_data_ptr)
        buf.realign(align_ptr - raw_data_ptr);
 
    return reinterpret_cast<AlignT *>(buf.data()); // unsigned char is type accessible by all types
}
 
} // namespace openvpn