libdhcp++.h

Go to the documentation of this file.

// Copyright (C) 2011-2023 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 LIBDHCP_H
#define LIBDHCP_H
 
#include <dhcp/option_definition.h>
#include <dhcp/option_space_container.h>
#include <dhcp/option_space.h>
#include <dhcp/pkt4.h>
#include <dhcp/pkt6.h>
#include <util/buffer.h>
#include <util/staged_value.h>
 
#include <iostream>
#include <stdint.h>
#include <string>
 
namespace isc {
namespace dhcp {
 
typedef ScopedPktOptionsCopy<Pkt4> ScopedPkt4OptionsCopy;
typedef ScopedPktOptionsCopy<Pkt6> ScopedPkt6OptionsCopy;
typedef std::shared_ptr<ScopedSubOptionsCopy> ScopedOptionsCopyPtr;
typedef std::vector<ScopedOptionsCopyPtr> ScopedOptionsCopyContainer;
 
struct ManagedScopedOptionsCopyContainer {
    ManagedScopedOptionsCopyContainer() {
    }
 
    ~ManagedScopedOptionsCopyContainer() {
        // Destroy the scoped options in same order so that parent options
        // (stored last) are kept alive longer.
        for (auto& scoped : scoped_options_) {
            scoped.reset();
        }
    }
 
    ScopedOptionsCopyContainer scoped_options_;
};
 
class LibDHCP {
 
public:
 
    typedef std::map<unsigned short, Option::Factory*> FactoryMap;
 
    static const OptionDefContainerPtr getOptionDefs(const std::string& space);
 
    static OptionDefinitionPtr getOptionDef(const std::string& space,
                                            const uint16_t code);
 
    static OptionDefinitionPtr getOptionDef(const std::string& space,
                                            const std::string& name);
 
    static OptionDefinitionPtr getVendorOptionDef(const Option::Universe u,
                                                  const uint32_t vendor_id,
                                                  const uint16_t code);
 
    static OptionDefinitionPtr getVendorOptionDef(const Option::Universe u,
                                                  const uint32_t vendor_id,
                                                  const std::string& name);
 
 
    static OptionDefinitionPtr getRuntimeOptionDef(const std::string& space,
                                                   const uint16_t code);
 
    static OptionDefinitionPtr getRuntimeOptionDef(const std::string& space,
                                                   const std::string& name);
 
    static OptionDefContainerPtr getRuntimeOptionDefs(const std::string& space);
 
    static OptionDefinitionPtr getLastResortOptionDef(const std::string& space,
                                                      const uint16_t code);
 
    static OptionDefinitionPtr getLastResortOptionDef(const std::string& space,
                                                      const std::string& name);
 
    static OptionDefContainerPtr getLastResortOptionDefs(const std::string& space);
 
    static bool shouldDeferOptionUnpack(const std::string& space,
                                        const uint16_t code);
 
    static isc::dhcp::OptionPtr optionFactory(isc::dhcp::Option::Universe u,
                                              uint16_t type,
                                              const OptionBuffer& buf);
 
    static void packOptions4(isc::util::OutputBuffer& buf,
                             const isc::dhcp::OptionCollection& options,
                             bool top = false, bool check = true);
 
    static bool splitOptions4(isc::dhcp::OptionCollection& options,
                              ScopedOptionsCopyContainer& scopedOptions,
                              uint32_t used = 0);
 
    static void packOptions6(isc::util::OutputBuffer& buf,
                             const isc::dhcp::OptionCollection& options);
 
    static size_t unpackOptions6(const OptionBuffer& buf,
                                 const std::string& option_space,
                                 isc::dhcp::OptionCollection& options,
                                 size_t* relay_msg_offset = 0,
                                 size_t* relay_msg_len = 0);
 
    static bool fuseOptions4(isc::dhcp::OptionCollection& options);
 
    static void extendVendorOptions4(isc::dhcp::OptionCollection& options);
 
    static size_t unpackOptions4(const OptionBuffer& buf,
                                 const std::string& option_space,
                                 isc::dhcp::OptionCollection& options,
                                 std::list<uint16_t>& deferred,
                                 bool flexible_pad_end = false);
 
    static void OptionFactoryRegister(Option::Universe u,
                                      uint16_t type,
                                      Option::Factory * factory);
 
    static const OptionDefContainerPtr getVendorOptionDefs(Option::Universe u,
                                                           const uint32_t vendor_id);
 
    static size_t unpackVendorOptions6(const uint32_t vendor_id,
                                       const OptionBuffer& buf,
                                       isc::dhcp::OptionCollection& options);
 
    static size_t unpackVendorOptions4(const uint32_t vendor_id,
                                       const OptionBuffer& buf,
                                       isc::dhcp::OptionCollection& options);
 
 
    static void setRuntimeOptionDefs(const OptionDefSpaceContainer& defs);
 
    static void clearRuntimeOptionDefs();
 
    static void revertRuntimeOptionDefs();
 
    static void commitRuntimeOptionDefs();
 
    static uint32_t optionSpaceToVendorId(const std::string& option_space);
 
private:
 
    static bool initOptionDefs();
 
    static bool initialized_;
 
    static FactoryMap v4factories_;
 
    static FactoryMap v6factories_;
 
    static OptionDefContainers option_defs_;
 
    static util::StagedValue<OptionDefSpaceContainer> runtime_option_defs_;
};
 
}
}
 
#endif // LIBDHCP_H