buffer.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_BUFFER_HEADER
#define LIBFILEZILLA_BUFFER_HEADER
 
#include "libfilezilla.hpp"
 
#include <vector>
#include <type_traits>
#include <cstdint>

 
namespace fz {

enum class buffer_wipe_policy {
    normal,
    wipe_on_release
};

template<buffer_wipe_policy Policy>
class basic_buffer
{
public:
    using value_type = unsigned char;
 
    basic_buffer() noexcept = default;

    explicit basic_buffer(size_t capacity);
 
    explicit basic_buffer(std::string_view const& data);
 
    basic_buffer(basic_buffer const& buf);
    basic_buffer(basic_buffer && buf) noexcept;
 
    basic_buffer& operator=(basic_buffer const& buf);
    basic_buffer& operator=(basic_buffer && buf) noexcept;
 
    basic_buffer& operator=(std::string_view const& v);
 
protected:
    ~basic_buffer();
 
public:
    unsigned char const* get() const { return pos_; }
    unsigned char* get() { return pos_; }

    unsigned char* data() { return pos_; }
    unsigned char const* data() const { return pos_; }

    unsigned char* get(size_t write_size);

    void add(size_t added);

    template<typename T, std::enable_if_t<std::is_signed_v<T>, int> = 0>
    void add(T added) {
        if (added > 0) {
            add(static_cast<size_t>(added));
        }
    }

    void consume(size_t consumed);
 
    size_t size() const { return size_; }

    void clear();
 
    void clear_and_free();

    void append(unsigned char const* data, size_t len);
    void append(std::string_view const& str);
    void append(std::basic_string_view<uint8_t> const& data);
    void append(std::vector<uint8_t> const& data);
    void append(basic_buffer const& b);
    void append(unsigned char v);
    void append(size_t len, unsigned char c);
 
    void push_back(unsigned char v) {
        return append(v);
    }
 
    basic_buffer& operator+=(unsigned char v) {
        append(v);
        return *this;
    }
    basic_buffer& operator+=(std::string_view const& str) {
        append(str);
        return *this;
    }
    basic_buffer& operator+=(std::vector<uint8_t> const& data) {
        append(data);
        return *this;
    }
    basic_buffer& operator+=(basic_buffer const& b) {
        append(b);
        return *this;
    }
 
    bool empty() const { return size_ == 0; }
    explicit operator bool() const {
        return size_ != 0;
    }
 
    size_t capacity() const { return capacity_; }
    void reserve(size_t capacity);
 
    void resize(size_t size);

    unsigned char operator[](size_t i) const { return pos_[i]; }
    unsigned char & operator[](size_t i) { return pos_[i]; }
 
    bool operator==(basic_buffer const& rhs) const {
        return *this == rhs.to_view();
    }
 
    bool operator==(std::string_view const& rhs) const;
 
    bool operator!=(basic_buffer const& rhs) const {
        return !(*this == rhs);
    }
    bool operator!=(std::string_view const& rhs) const {
        return !(*this == rhs);
    }
 
    std::string_view to_view() const;
 
    void wipe();
    void wipe_unused();
 
private:
 
    // Invariants:
    //   size_ <= capacity_
    //   data_ <= pos_
    //   pos_ <= data_ + capacity_
    //   pos_ + size_ <= data_ + capacity_
    unsigned char* data_{};
    unsigned char* pos_{};
    size_t size_{};
    size_t capacity_{};
};
 
#if BUILDING_LIBFILEZILLA
extern template class FZ_PUBLIC_SYMBOL basic_buffer<buffer_wipe_policy::normal>;
extern template class FZ_PUBLIC_SYMBOL basic_buffer<buffer_wipe_policy::wipe_on_release>;
#endif
 
class FZ_PUBLIC_SYMBOL buffer final : public basic_buffer<buffer_wipe_policy::normal>
{
public:
    using basic_buffer::basic_buffer;
    using basic_buffer::operator=;
};

class FZ_PUBLIC_SYMBOL secure_buffer final : public basic_buffer<buffer_wipe_policy::wipe_on_release>
{
public:
    using basic_buffer::basic_buffer;
    using basic_buffer::operator=;
};
 
inline void wipe(buffer & b) {
    b.wipe();
}
 
inline void wipe_unused(buffer & b) {
    b.wipe_unused();
}
 
inline void wipe(secure_buffer & b) {
    b.wipe();
}
 
inline void wipe_unused(secure_buffer & b) {
    b.wipe_unused();
}
 
}
 
#endif