buffer.h

Go to the documentation of this file.

// Copyright (C) 2009-2024 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef BUFFER_H
#define BUFFER_H
 
#include <exceptions/exceptions.h>
 
#include <cstdint>
#include <cstdlib>
#include <cstring>
#include <vector>
 
#include <boost/shared_ptr.hpp>
 
namespace isc {
namespace util {
 
class InputBuffer {
public:
    InputBuffer(const void* data, size_t len)
        : base_(static_cast<const uint8_t*>(data)), current_(base_),
          end_(base_ + len) {
    }
 
    size_t getLength() const {
        return (static_cast<size_t>(end_ - base_));
    }
 
    size_t getPosition() const {
        return (static_cast<size_t>(current_ - base_));
    }
 
    void setPosition(size_t position) {
        if (base_ + position > end_) {
            isc_throw(OutOfRange,
                      "InputBuffer::setPosition position is too large");
        }
 
        current_ = base_ + position;
    }
 
    uint8_t peekUint8() {
        if (current_ + sizeof(uint8_t) > end_) {
            isc_throw(OutOfRange,
                      "InputBuffer::peekUint8 read beyond end of buffer");
        }
 
        return (*current_);
    }
 
    uint8_t readUint8() {
        uint8_t ret = peekUint8();
        current_ += sizeof(uint8_t);
 
        return (ret);
    }
 
    uint16_t peekUint16() {
        if (current_ + sizeof(uint16_t) > end_) {
            isc_throw(OutOfRange,
                      "InputBuffer::peekUint16 read beyond end of buffer");
        }
 
        uint16_t ret;
        ret = (static_cast<uint16_t>(current_[0])) << 8;
        ret |= (static_cast<uint16_t>(current_[1]));
 
        return (ret);
    }
 
    uint16_t readUint16() {
        uint16_t ret = peekUint16();
        current_ += sizeof(uint16_t);
 
        return (ret);
    }
 
    uint32_t peekUint32() {
        if (current_ + sizeof(uint32_t) > end_) {
            isc_throw(OutOfRange,
                      "InputBuffer::peekUint32 read beyond end of buffer");
        }
 
        uint32_t ret;
        ret = (static_cast<uint32_t>(current_[0])) << 24;
        ret |= (static_cast<uint32_t>(current_[1])) << 16;
        ret |= (static_cast<uint32_t>(current_[2])) << 8;
        ret |= (static_cast<uint32_t>(current_[3]));
 
        return (ret);
    }
 
    uint32_t readUint32() {
        uint32_t ret = peekUint32();
        current_ += sizeof(uint32_t);
 
        return (ret);
    }
 
    void peekData(void* data, size_t len) {
        if (current_ + len > end_) {
            isc_throw(OutOfRange,
                      "InputBuffer::peekData read beyond end of buffer");
        }
 
        static_cast<void>(std::memmove(data, current_, len));
    }
 
    void readData(void* data, size_t len) {
        peekData(data, len);
        current_ += len;
    }
 
    void peekVector(std::vector<uint8_t>& data, size_t len) {
        if (current_ + len > end_) {
            isc_throw(OutOfRange,
                      "InputBuffer::peekVector read beyond end of buffer");
        }
 
        data.resize(len);
        peekData(&data[0], len);
    }
 
    void readVector(std::vector<uint8_t>& data, size_t len) {
        peekVector(data, len);
        current_ += len;
    }
 
private:
    const uint8_t* base_;
 
    const uint8_t* current_;
 
    const uint8_t* end_;
};
 
typedef boost::shared_ptr<InputBuffer> InputBufferPtr;
 
class OutputBuffer {
public:
    explicit OutputBuffer(size_t len) : buffer_() {
        if (len != 0) {
            buffer_.reserve(len);
        }
    }
 
    OutputBuffer(const OutputBuffer& other) : buffer_(other.buffer_) {
        size_t len = other.buffer_.capacity();
        if (len != 0) {
            buffer_.reserve(len);
        }
    }
 
    ~OutputBuffer() = default;
 
    OutputBuffer& operator=(const OutputBuffer& other) {
        if (this != &other) {
            // Not self-assignment.
            buffer_ = other.buffer_;
            size_t len = other.buffer_.capacity();
            if (len != 0) {
                buffer_.reserve(len);
            }
        }
 
        return (*this);
    }
 
    size_t getCapacity() const {
        return (buffer_.capacity());
    }
 
    const uint8_t* getData() const {
        if (!buffer_.empty()) {
            return (&buffer_[0]);
        } else {
            return (0);
        }
    }
 
    const void* getDataAsVoidPtr() const {
        return (static_cast<const void*>(getData()));
    }
 
    size_t getLength() const {
        return (buffer_.size());
    }
 
    uint8_t operator[](size_t position) const {
        if (position >= buffer_.size()) {
            isc_throw(OutOfRange,
                      "OutputBuffer::[]: pos (" << position
                      << ") >= size (" << buffer_.size() << ")");
        }
 
        return (buffer_[position]);
    }
 
    const std::vector<uint8_t>& getVector() const {
        return (buffer_);
    }
 
    void skip(size_t len) {
        buffer_.resize(buffer_.size() + len);
    }
 
    void trim(size_t len) {
        if (len > buffer_.size()) {
            isc_throw(OutOfRange,
                      "OutputBuffer::trim length too large from output buffer");
        }
 
        buffer_.resize(buffer_.size() - len);
    }
 
    void clear() {
        buffer_.clear();
    }
 
    void writeUint8(uint8_t data) {
        buffer_.push_back(data);
    }
 
    void writeUint8At(uint8_t data, size_t position) {
        if (position + sizeof(data) > buffer_.size()) {
            isc_throw(OutOfRange,
                      "OutputBuffer::writeUint8At write at invalid position");
        }
 
        buffer_[position] = data;
    }
 
    void writeUint16(uint16_t data) {
        buffer_.push_back(static_cast<uint8_t>((data & 0xff00U) >> 8));
        buffer_.push_back(static_cast<uint8_t>(data & 0x00ffU));
    }
 
    void writeUint16At(uint16_t data, size_t position) {
        if (position + sizeof(data) > buffer_.size()) {
            isc_throw(OutOfRange,
                      "OutputBuffer::writeUint16At write at invalid position");
        }
 
        buffer_[position] = static_cast<uint8_t>((data & 0xff00U) >> 8);
        buffer_[position + 1] = static_cast<uint8_t>(data & 0x00ffU);
    }
 
    void writeUint32(uint32_t data) {
        buffer_.push_back(static_cast<uint8_t>((data & 0xff000000) >> 24));
        buffer_.push_back(static_cast<uint8_t>((data & 0x00ff0000) >> 16));
        buffer_.push_back(static_cast<uint8_t>((data & 0x0000ff00) >> 8));
        buffer_.push_back(static_cast<uint8_t>(data & 0x000000ff));
    }
 
    void writeUint64(uint64_t data) {
        buffer_.push_back(static_cast<uint8_t>((data & 0xff00000000000000) >> 56));
        buffer_.push_back(static_cast<uint8_t>((data & 0x00ff000000000000) >> 48));
        buffer_.push_back(static_cast<uint8_t>((data & 0x0000ff0000000000) >> 40));
        buffer_.push_back(static_cast<uint8_t>((data & 0x000000ff00000000) >> 32));
        buffer_.push_back(static_cast<uint8_t>((data & 0x00000000ff000000) >> 24));
        buffer_.push_back(static_cast<uint8_t>((data & 0x0000000000ff0000) >> 16));
        buffer_.push_back(static_cast<uint8_t>((data & 0x000000000000ff00) >> 8));
        buffer_.push_back(static_cast<uint8_t>(data & 0x00000000000000ff));
    }
 
    void writeData(const void* data, size_t len) {
        if (len == 0) {
            return;
        }
 
        const uint8_t* ptr = static_cast<const uint8_t*>(data);
        buffer_.insert(buffer_.end(), ptr, ptr + len);
    }
 
private:
    std::vector<uint8_t> buffer_;
};
 
typedef boost::shared_ptr<OutputBuffer> OutputBufferPtr;
 
}  // namespace util
}  // namespace isc
 
#endif  // BUFFER_H