buffer.h

Go to the documentation of this file.

// Copyright (C) 2009-2022 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 1
 
#include <stdlib.h>
#include <cstring>
#include <vector>
 
#include <stdint.h>
 
#include <exceptions/exceptions.h>
 
#include <boost/shared_ptr.hpp>
 
namespace isc {
namespace util {
 
class InvalidBufferPosition : public Exception {
public:
    InvalidBufferPosition(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
class InputBuffer {
public:
 
 
    InputBuffer(const void* data, size_t len) :
        position_(0), data_(static_cast<const uint8_t*>(data)), len_(len) {}
 
 
 
    size_t getLength() const { return (len_); }
    size_t getPosition() const { return (position_); }
 
 
 
    void setPosition(size_t position) {
        if (position > len_) {
            throwError("position is too large");
        }
        position_ = position;
    }
 
 
 
    uint8_t readUint8() {
        if (position_ + sizeof(uint8_t) > len_) {
            throwError("read beyond end of buffer");
        }
 
        return (data_[position_++]);
    }
    uint16_t readUint16() {
        uint16_t data;
        const uint8_t* cp;
 
        if (position_ + sizeof(data) > len_) {
            throwError("read beyond end of buffer");
        }
 
        cp = &data_[position_];
        data = ((unsigned int)(cp[0])) << 8;
        data |= ((unsigned int)(cp[1]));
        position_ += sizeof(data);
 
        return (data);
    }
    uint32_t readUint32() {
        uint32_t data;
        const uint8_t* cp;
 
        if (position_ + sizeof(data) > len_) {
            throwError("read beyond end of buffer");
        }
 
        cp = &data_[position_];
        data = ((unsigned int)(cp[0])) << 24;
        data |= ((unsigned int)(cp[1])) << 16;
        data |= ((unsigned int)(cp[2])) << 8;
        data |= ((unsigned int)(cp[3]));
        position_ += sizeof(data);
 
        return (data);
    }
    void readData(void* data, size_t len) {
        if (position_ + len > len_) {
            throwError("read beyond end of buffer");
        }
 
        static_cast<void>(std::memmove(data, &data_[position_], len));
        position_ += len;
    }
 
    void readVector(std::vector<uint8_t>& data, size_t len) {
        if (position_ + len > len_) {
            throwError("read beyond end of buffer");
        }
 
        data.resize(len);
        readData(&data[0], len);
    }
 
private:
    static void throwError(const char* msg) {
        isc_throw(InvalidBufferPosition, msg);
    }
 
    size_t position_;
 
    // XXX: The following must be private, but for a short term workaround with
    // Boost.Python binding, we changed it to protected.  We should soon
    // revisit it.
protected:
    const uint8_t* data_;
    size_t len_;
};
 
class OutputBuffer {
public:
 
 
    OutputBuffer(size_t len) :
        buffer_(NULL),
        size_(0),
        allocated_(len)
    {
        // We use malloc and free instead of C++ new[] and delete[].
        // This way we can use realloc, which may in fact do it without a copy.
        if (allocated_ != 0) {
            buffer_ = static_cast<uint8_t*>(malloc(allocated_));
            if (buffer_ == NULL) {
                throw std::bad_alloc();
            }
        }
    }
 
    OutputBuffer(const OutputBuffer& other) :
        buffer_(NULL),
        size_(other.size_),
        allocated_(other.allocated_)
    {
        if (allocated_ != 0) {
            buffer_ = static_cast<uint8_t*>(malloc(allocated_));
            if (buffer_ == NULL) {
                throw std::bad_alloc();
            }
            static_cast<void>(std::memmove(buffer_, other.buffer_, other.size_));
        }
    }
 
    ~OutputBuffer() {
        free(buffer_);
    }
 
    OutputBuffer& operator =(const OutputBuffer& other) {
        if (this != &other) {
            // Not self-assignment.
            if (other.allocated_ != 0) {
 
                // There is something in the source object, so allocate memory
                // and copy it.  The pointer to the allocated memory is placed
                // in a temporary variable so that if the allocation fails and
                // an exception is thrown, the destination object ("this") is
                // unchanged.
                uint8_t* newbuff = static_cast<uint8_t*>(malloc(other.allocated_));
                if (newbuff == NULL) {
                    throw std::bad_alloc();
                }
 
                // Memory allocated, update the source object and copy data
                // across.
                free(buffer_);
                buffer_ = newbuff;
                static_cast<void>(std::memmove(buffer_, other.buffer_, other.size_));
 
            } else {
 
                // Nothing allocated in the source object, so zero the buffer
                // in the destination.
                free(buffer_);
                buffer_ = NULL;
            }
 
            // Update the other member variables.
            size_ = other.size_;
            allocated_ = other.allocated_;
        }
        return (*this);
    }
 
 
 
    size_t getCapacity() const { return (allocated_); }
    const void* getData() const { return (buffer_); }
    size_t getLength() const { return (size_); }
    uint8_t operator[](size_t pos) const {
        if (pos >= size_) {
            isc_throw(InvalidBufferPosition,
                      "[]: pos (" << pos << ") >= size (" << size_ << ")");
        }
        return (buffer_[pos]);
    }
 
 
 
    void skip(size_t len) {
        ensureAllocated(size_ + len);
        size_ += len;
    }
 
    void trim(size_t len) {
        if (len > size_) {
            isc_throw(OutOfRange, "trimming too large from output buffer");
        }
        size_ -= len;
    }
    void clear() { size_ = 0; }
 
    void wipe() {
        if (buffer_ != NULL) {
            static_cast<void>(std::memset(buffer_, 0, allocated_));
        }
        size_ = 0;
    }
 
    void writeUint8(uint8_t data) {
        ensureAllocated(size_ + 1);
        buffer_[size_ ++] = data;
    }
 
    void writeUint8At(uint8_t data, size_t pos) {
        if (pos + sizeof(data) > size_) {
            isc_throw(InvalidBufferPosition, "write at invalid position");
        }
        buffer_[pos] = data;
    }
 
    void writeUint16(uint16_t data) {
        ensureAllocated(size_ + sizeof(data));
        buffer_[size_ ++] = static_cast<uint8_t>((data & 0xff00U) >> 8);
        buffer_[size_ ++] = static_cast<uint8_t>(data & 0x00ffU);
    }
 
    void writeUint16At(uint16_t data, size_t pos) {
        if (pos + sizeof(data) > size_) {
            isc_throw(InvalidBufferPosition, "write at invalid position");
        }
 
        buffer_[pos] = static_cast<uint8_t>((data & 0xff00U) >> 8);
        buffer_[pos + 1] = static_cast<uint8_t>(data & 0x00ffU);
    }
 
    void writeUint32(uint32_t data) {
        ensureAllocated(size_ + sizeof(data));
        buffer_[size_ ++] = static_cast<uint8_t>((data & 0xff000000) >> 24);
        buffer_[size_ ++] = static_cast<uint8_t>((data & 0x00ff0000) >> 16);
        buffer_[size_ ++] = static_cast<uint8_t>((data & 0x0000ff00) >> 8);
        buffer_[size_ ++] = static_cast<uint8_t>(data & 0x000000ff);
    }
 
    void writeUint64(uint64_t data) {
        ensureAllocated(size_ + sizeof(data));
        buffer_[size_ ++] = static_cast<uint8_t>((data & 0xff00000000000000) >> 56);
        buffer_[size_ ++] = static_cast<uint8_t>((data & 0x00ff000000000000) >> 48);
        buffer_[size_ ++] = static_cast<uint8_t>((data & 0x0000ff0000000000) >> 40);
        buffer_[size_ ++] = static_cast<uint8_t>((data & 0x000000ff00000000) >> 32);
        buffer_[size_ ++] = static_cast<uint8_t>((data & 0x00000000ff000000) >> 24);
        buffer_[size_ ++] = static_cast<uint8_t>((data & 0x0000000000ff0000) >> 16);
        buffer_[size_ ++] = static_cast<uint8_t>((data & 0x000000000000ff00) >> 8);
        buffer_[size_ ++] = static_cast<uint8_t>(data &  0x00000000000000ff);
    }
 
    void writeData(const void *data, size_t len) {
        if (len == 0) {
            return;
        }
 
        ensureAllocated(size_ + len);
        static_cast<void>(std::memmove(buffer_ + size_, data, len));
        size_ += len;
    }
 
private:
    uint8_t* buffer_;
    size_t size_;
    size_t allocated_;
 
    void ensureAllocated(size_t needed_size) {
        if (allocated_ < needed_size) {
            // Guess some bigger size
            size_t new_size = (allocated_ == 0) ? 1024 : allocated_;
            while (new_size < needed_size) {
                new_size *= 2;
            }
            // Allocate bigger space.  Note that buffer_ may be NULL,
            // in which case realloc acts as malloc.
            uint8_t* new_buffer_(static_cast<uint8_t*>(realloc(buffer_,
                new_size)));
            if (new_buffer_ == NULL) {
                // If it fails, the original block is left intact by it
                throw std::bad_alloc();
            }
            buffer_ = new_buffer_;
            allocated_ = new_size;
        }
    }
};
 
typedef boost::shared_ptr<InputBuffer> InputBufferPtr;
typedef boost::shared_ptr<OutputBuffer> OutputBufferPtr;
 
} // namespace util
} // namespace isc
#endif  // BUFFER_H
 
// Local Variables:
// mode: c++
// End: