option.h

Go to the documentation of this file.

// Copyright (C) 2011-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 OPTION_H
#define OPTION_H
 
#include <util/buffer.h>
 
#include <boost/shared_ptr.hpp>
 
#include <map>
#include <string>
#include <vector>
 
namespace isc {
namespace dhcp {
 
typedef std::vector<uint8_t> OptionBuffer;
 
typedef OptionBuffer::iterator OptionBufferIter;
 
typedef OptionBuffer::const_iterator OptionBufferConstIter;
 
typedef boost::shared_ptr<OptionBuffer> OptionBufferPtr;
 
class Option;
typedef boost::shared_ptr<Option> OptionPtr;
 
typedef std::multimap<unsigned int, OptionPtr> OptionCollection;
 
typedef boost::shared_ptr<OptionCollection> OptionCollectionPtr;
 
class SkipRemainingOptionsError : public Exception {
public:
    SkipRemainingOptionsError (const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};
 
class SkipThisOptionError : public Exception {
public:
    SkipThisOptionError (const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};
 
class OptionParseError : public Exception {
public:
    OptionParseError (const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};
 
class Option {
public:
    const static size_t OPTION4_HDR_LEN = 2;
 
    const static size_t OPTION6_HDR_LEN = 4;
 
    enum Universe { V4, V6 };
 
 
    typedef OptionPtr Factory(Option::Universe u, uint16_t type, const OptionBuffer& buf);
 
    static OptionPtr factory(Option::Universe u,
                             uint16_t type,
                             const OptionBuffer& buf);
 
    static OptionPtr factory(Option::Universe u, uint16_t type) {
        return factory(u, type, OptionBuffer());
    }
 
    Option(Universe u, uint16_t type);
 
    Option(Universe u, uint16_t type, const OptionBuffer& data);
 
    Option(Universe u, uint16_t type, OptionBufferConstIter first,
           OptionBufferConstIter last);
 
    Option(const Option& source);
 
    static OptionPtr create(Universe u, uint16_t type);
 
    static OptionPtr create(Universe u, uint16_t type, const OptionBuffer& data);
 
    Option& operator=(const Option& rhs);
 
    virtual OptionPtr clone() const;
 
    Universe getUniverse() const {
        return (universe_);
    }
 
    virtual void pack(isc::util::OutputBuffer& buf, bool check = true) const;
 
    virtual void unpack(OptionBufferConstIter begin,
                        OptionBufferConstIter end);
 
    virtual std::string toText(int indent = 0) const;
 
    virtual std::string toString() const;
 
    virtual std::vector<uint8_t> toBinary(const bool include_header = false) const;
 
    virtual std::string toHexString(const bool include_header = false) const;
 
    uint16_t getType() const {
        return (type_);
    }
 
    virtual uint16_t len() const;
 
    virtual uint16_t getHeaderLen() const;
 
    virtual bool valid() const;
 
    virtual const OptionBuffer& getData() const {
        return (data_);
    }
 
    void addOption(OptionPtr opt);
 
    OptionPtr getOption(uint16_t type) const;
 
    const OptionCollection& getOptions() const {
        return (options_);
    }
 
    OptionCollection& getMutableOptions() {
        return (options_);
    }
 
    void getOptionsCopy(OptionCollection& options_copy) const;
 
    bool delOption(uint16_t type);
 
    uint8_t getUint8() const;
 
    uint16_t getUint16() const;
 
    uint32_t getUint32() const;
 
    void setUint8(uint8_t value);
 
    void setUint16(uint16_t value);
 
    void setUint32(uint32_t value);
 
    template<typename InputIterator>
    void setData(InputIterator first, InputIterator last) {
        data_.assign(first, last);
    }
 
    void setEncapsulatedSpace(const std::string& encapsulated_space) {
        encapsulated_space_ = encapsulated_space;
    }
 
    std::string getEncapsulatedSpace() const {
        return (encapsulated_space_);
    }
 
    virtual ~Option();
 
    bool equals(const OptionPtr& other) const;
 
    virtual bool equals(const Option& other) const;
 
    static bool lenient_parsing_;
 
protected:
 
    template<typename OptionType>
    OptionPtr cloneInternal() const {
        const OptionType* cast_this = dynamic_cast<const OptionType*>(this);
        if (cast_this) {
            return (boost::shared_ptr<OptionType>(new OptionType(*cast_this)));
        }
        return (OptionPtr());
    }
 
    void packHeader(isc::util::OutputBuffer& buf, bool check = true) const;
 
    void packOptions(isc::util::OutputBuffer& buf, bool check = true) const;
 
    void unpackOptions(const OptionBuffer& buf);
 
    std::string headerToText(const int indent = 0,
                             const std::string& type_name = "") const;
 
    std::string suboptionsToText(const int indent = 0) const;
 
    void check() const;
 
    Universe universe_;
 
    uint16_t type_;
 
    OptionBuffer data_;
 
    OptionCollection options_;
 
    std::string encapsulated_space_;
 
};
 
} // namespace isc::dhcp
} // namespace isc
 
#endif // OPTION_H