opaque_data_tuple.h

Go to the documentation of this file.

// Copyright (C) 2014-2017 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 OPAQUE_DATA_TUPLE_H
#define OPAQUE_DATA_TUPLE_H
 
#include <util/buffer.h>
#include <util/io_utilities.h>
#include <iostream>
#include <iterator>
#include <string>
#include <vector>
 
namespace isc {
namespace dhcp {
 
class OpaqueDataTupleError : public Exception {
public:
    OpaqueDataTupleError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { };
};
 
 
class OpaqueDataTuple {
public:
 
    enum LengthFieldType {
        LENGTH_1_BYTE,
        LENGTH_2_BYTES
    };
 
    typedef std::vector<uint8_t> Buffer;
 
    OpaqueDataTuple(LengthFieldType length_field_type);
 
    template<typename InputIterator>
    OpaqueDataTuple(LengthFieldType length_field_type, InputIterator begin,
                    InputIterator end)
        : length_field_type_(length_field_type) {
        unpack(begin, end);
    }
 
    template<typename InputIterator>
    void append(InputIterator data, const size_t len) {
        data_.insert(data_.end(), data, data + len);
    }
 
    void append(const std::string& text);
 
    template<typename InputIterator>
    void assign(InputIterator data, const size_t len) {
        data_.assign(data, data + len);
    }
 
    void assign(const std::string& text);
 
    void clear();
 
    bool equals(const std::string& other) const;
 
    LengthFieldType getLengthFieldType() const {
        return (length_field_type_);
    }
 
    size_t getLength() const {
        return (data_.size());
    }
 
    size_t getTotalLength() const {
        return (getDataFieldSize() + getLength());
    }
 
    const Buffer& getData() const {
        return (data_);
    }
 
    std::string getText() const;
 
    void pack(isc::util::OutputBuffer& buf) const;
 
    template<typename InputIterator>
    void unpack(InputIterator begin, InputIterator end) {
        Buffer buf(begin, end);
        // The buffer must at least hold the size of the data.
        if (std::distance(begin, end) < getDataFieldSize()) {
            isc_throw(OpaqueDataTupleError,
                      "unable to parse the opaque data tuple, the buffer"
                      " length is " << std::distance(begin, end)
                      << ", expected at least " << getDataFieldSize());
        }
        // Read the data length from the length field, depending on the
        // size of the data field (1 or 2 bytes).
        size_t len = getDataFieldSize() == 1 ? *begin :
            isc::util::readUint16(&(*begin), std::distance(begin, end));
        // Now that we have the expected data size, let's check that the
        // reminder of the buffer is long enough.
        begin += getDataFieldSize();
        if (std::distance(begin, end) < len) {
            isc_throw(OpaqueDataTupleError,
                      "unable to parse the opaque data tuple, the buffer"
                      " length is " << std::distance(begin, end)
                      << ", but the length of the tuple in the length field"
                      " is " << len);
        }
        // The buffer length is long enough to read the desired amount of data.
        assign(begin, len);
    }
 
    //{@
 
    OpaqueDataTuple& operator=(const std::string& other);
 
    bool operator==(const std::string& other) const;
 
    bool operator!=(const std::string& other);
 
    int getDataFieldSize() const;
 
private:
 
    Buffer data_;
    LengthFieldType length_field_type_;
};
 
typedef boost::shared_ptr<OpaqueDataTuple> OpaqueDataTuplePtr;
 
std::ostream& operator<<(std::ostream& os, const OpaqueDataTuple& tuple);
 
std::istream& operator>>(std::istream& is, OpaqueDataTuple& tuple);
 
} // namespace isc::dhcp
} // namespace isc
 
#endif