buffer.h

Go to the documentation of this file.

// Copyright (C) 2009  Internet Systems Consortium, Inc. ("ISC")
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
// AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
// PERFORMANCE OF THIS SOFTWARE.

// $Id$

#ifndef __BUFFER_H
#define __BUFFER_H 1

#include <vector>

#include "exceptions.h"

namespace isc {
namespace dns {

class InvalidBufferPosition : public Exception {
public:
    InvalidBufferPosition(const char* file, size_t line, const char* what) :
        isc::dns::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_)
            dns_throw(InvalidBufferPosition, "position is too large");
        position_ = position;
    }






    uint8_t readUint8()
    {
        if (position_ + sizeof(uint8_t) > len_) {
            dns_throw(InvalidBufferPosition, "read beyond end of buffer");
        }

        return (data_[position_++]);
    }
    uint16_t readUint16()
    {
        uint16_t data;
        const uint8_t* cp;

        if (position_ + sizeof(data) > len_) {
            dns_throw(InvalidBufferPosition, "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_) {
            dns_throw(InvalidBufferPosition, "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_) {
            dns_throw(InvalidBufferPosition, "read beyond end of buffer");
        }

        memcpy(data, &data_[position_], len);
        position_ += len;
    }

private:
    size_t position_;
    const uint8_t* data_;
    size_t len_;
};

class OutputBuffer {
public:




    OutputBuffer(size_t len) { data_.reserve(len); }



    size_t getCapacity() const { return (data_.capacity()); }
    const void* getData() const { return (&data_[0]); }
    size_t getLength() const { return (data_.size()); }
    uint8_t operator[](size_t pos) const
    {
        if (pos >= data_.size()) {
            dns_throw(InvalidBufferPosition, "read at invalid position");
        }
        return (data_[pos]);
    }








    void skip(size_t len) { data_.insert(data_.end(), len, 0); }
    void clear() { data_.clear(); }
    void writeUint8(uint8_t data) { data_.push_back(data); }

    void writeUint16(uint16_t data)
    {
        data_.push_back(static_cast<uint8_t>((data & 0xff00U) >> 8));
        data_.push_back(static_cast<uint8_t>(data & 0x00ffU));
    }
    void writeUint16At(uint16_t data, size_t pos)
    {
        if (pos + sizeof(data) >= data_.size()) {
            dns_throw(InvalidBufferPosition, "write at invalid position");
        }

        data_[pos] = static_cast<uint8_t>((data & 0xff00U) >> 8);
        data_[pos + 1] = static_cast<uint8_t>(data & 0x00ffU);
    }
    void writeUint32(uint32_t data)
    {
        data_.push_back(static_cast<uint8_t>((data & 0xff000000) >> 24));
        data_.push_back(static_cast<uint8_t>((data & 0x00ff0000) >> 16));
        data_.push_back(static_cast<uint8_t>((data & 0x0000ff00) >> 8));
        data_.push_back(static_cast<uint8_t>(data & 0x000000ff));
    }
    void writeData(const void *data, size_t len)
    {
        const uint8_t* cp = static_cast<const uint8_t*>(data);
        data_.insert(data_.end(), cp, cp + len);
    }
    
private:
    std::vector<uint8_t> data_;
};
}
}
#endif  // __BUFFER_H

// Local Variables: 
// mode: c++
// End: 

---