option.h

Go to the documentation of this file.

// Copyright (C) 2011-2026 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 <cstdint>
#include <map>
#include <string>
#include <vector>
 
#include <boost/shared_ptr.hpp>
 
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 : uint16_t { 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, size_t rec_level = 0);

    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