dhcp6_srv.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 DHCPV6_SRV_H
#define DHCPV6_SRV_H
 
#include <asiolink/io_service.h>
#include <dhcp/dhcp6.h>
#include <dhcp/duid.h>
#include <dhcp/option.h>
#include <dhcp/option_string.h>
#include <dhcp/option6_client_fqdn.h>
#include <dhcp/option6_ia.h>
#include <dhcp/option_custom.h>
#include <dhcp/option_definition.h>
#include <dhcp_ddns/ncr_msg.h>
#include <dhcp/pkt6.h>
#include <dhcpsrv/alloc_engine.h>
#include <dhcpsrv/callout_handle_store.h>
#include <dhcpsrv/cb_ctl_dhcp6.h>
#include <dhcpsrv/cfg_option.h>
#include <dhcpsrv/d2_client_mgr.h>
#include <dhcpsrv/network_state.h>
#include <dhcpsrv/subnet.h>
#include <hooks/callout_handle.h>
#include <process/daemon.h>
 
#include <functional>
#include <iostream>
#include <queue>
 
// Undefine the macro OPTIONAL which is defined in some operating
// systems but conflicts with a member of the RequirementLevel enum in
// the server class.
 
#ifdef OPTIONAL
#undef OPTIONAL
#endif
 
namespace isc {
namespace dhcp {
 
class DHCPv6DiscardMessageError : public Exception {
public:
    DHCPv6DiscardMessageError(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) { }
};
 
class Dhcpv6Srv : public process::Daemon {
private:
 
    asiolink::IOServicePtr io_service_;
 
public:
    typedef enum {
        FORBIDDEN,
        MANDATORY,
        OPTIONAL
    } RequirementLevel;
 
    static const size_t MIN_MAC_LEN = 6;
 
    Dhcpv6Srv(uint16_t server_port = DHCP6_SERVER_PORT,
              uint16_t client_port = 0);
 
    virtual ~Dhcpv6Srv();
 
    bool inTestMode() const {
        return (server_port_ == 0);
    }
 
    asiolink::IOServicePtr& getIOService() {
        return (io_service_);
    }
 
    NetworkStatePtr& getNetworkState() {
        return (network_state_);
    }
 
    CBControlDHCPv6Ptr getCBControl() const {
        return (cb_control_);
    }
 
    static std::string getVersion(bool extended);
 
    OptionPtr getServerID() { return serverid_; }
 
    int run();
 
    void runOne();
 
    void processPacketAndSendResponse(Pkt6Ptr query);
 
    void processPacketAndSendResponseNoThrow(Pkt6Ptr query);
 
    void sendResponseNoThrow(hooks::CalloutHandlePtr& callout_handle,
                             Pkt6Ptr query, Pkt6Ptr& rsp,
                             ConstSubnet6Ptr& subnet);
 
    Pkt6Ptr processPacket(Pkt6Ptr query);
 
    Pkt6Ptr processDhcp6Query(Pkt6Ptr query);
 
    void processDhcp6QueryAndSendResponse(Pkt6Ptr query);
 
    Pkt6Ptr processLocalizedQuery6(AllocEngine::ClientContext6& ctx);
 
    void processLocalizedQuery6AndSendResponse(Pkt6Ptr query,
                                               AllocEngine::ClientContext6& ctx);
 
    void processLocalizedQuery6AndSendResponse(Pkt6Ptr query);
 
    void shutdown() override;
 
 
 
    uint16_t getServerPort() const;
 
    void startD2();
 
    void stopD2();
 
    virtual void d2ClientErrorHandler(const dhcp_ddns::
                                      NameChangeSender::Result result,
                                      dhcp_ddns::NameChangeRequestPtr& ncr);
 
    void discardPackets();
 
    void initContext0(const Pkt6Ptr& query,
                      AllocEngine::ClientContext6& ctx);
 
    bool earlyGHRLookup(const Pkt6Ptr& query,
                        AllocEngine::ClientContext6& ctx);
 
    static void setHostIdentifiers(AllocEngine::ClientContext6& ctx);
 
protected:
 
    void setPacketStatisticsDefaults();
 
    bool testServerID(const Pkt6Ptr& pkt);
 
    bool testUnicast(const Pkt6Ptr& pkt) const;
 
    bool sanityCheck(const Pkt6Ptr& pkt);
 
    void sanityCheck(const Pkt6Ptr& pkt, RequirementLevel clientid,
                     RequirementLevel serverid);
 
    void sanityCheckDUID(const OptionPtr& opt, const std::string& opt_name);
 
    Pkt6Ptr processSolicit(AllocEngine::ClientContext6& ctx);
 
    Pkt6Ptr processRequest(AllocEngine::ClientContext6& ctx);
 
    Pkt6Ptr processRenew(AllocEngine::ClientContext6& ctx);
 
    Pkt6Ptr processRebind(AllocEngine::ClientContext6& ctx);
 
    Pkt6Ptr processConfirm(AllocEngine::ClientContext6& ctx);
 
    Pkt6Ptr processRelease(AllocEngine::ClientContext6& ctx);
 
    Pkt6Ptr processDecline(AllocEngine::ClientContext6& ctx);
 
    Pkt6Ptr processInfRequest(AllocEngine::ClientContext6& ctx);
 
    void processDhcp4Query(const Pkt6Ptr& dhcp4_query);
 
    isc::dhcp::ConstSubnet6Ptr selectSubnet(const Pkt6Ptr& question, bool& drop);
 
    OptionPtr assignIA_NA(const isc::dhcp::Pkt6Ptr& query,
                          AllocEngine::ClientContext6& ctx,
                          Option6IAPtr ia);
 
    OptionPtr assignIA_PD(const Pkt6Ptr& query,
                          AllocEngine::ClientContext6& ctx,
                          boost::shared_ptr<Option6IA> ia);
 
    OptionPtr extendIA_NA(const Pkt6Ptr& query,
                          AllocEngine::ClientContext6& ctx,
                          Option6IAPtr ia);
 
    OptionPtr extendIA_PD(const Pkt6Ptr& query,
                          AllocEngine::ClientContext6& ctx,
                          Option6IAPtr ia);
 
    OptionPtr releaseIA_NA(const DuidPtr& duid, const Pkt6Ptr& query,
                           int& general_status,
                           boost::shared_ptr<Option6IA> ia,
                           Lease6Ptr& old_lease);
 
    OptionPtr releaseIA_PD(const DuidPtr& duid, const Pkt6Ptr& query,
                           int& general_status,
                           boost::shared_ptr<Option6IA> ia,
                           Lease6Ptr& old_lease);
 
    void copyClientOptions(const Pkt6Ptr& question, Pkt6Ptr& answer);
 
    void buildCfgOptionList(const Pkt6Ptr& question,
                            AllocEngine::ClientContext6& ctx,
                            CfgOptionList& co_list);
 
    void appendDefaultOptions(const Pkt6Ptr& question, Pkt6Ptr& answer,
                              const CfgOptionList& co_list);
 
    void appendRequestedOptions(const Pkt6Ptr& question, Pkt6Ptr& answer,
                                const CfgOptionList& co_list);
 
    void appendRequestedVendorOptions(const Pkt6Ptr& question, Pkt6Ptr& answer,
                                      AllocEngine::ClientContext6& ctx,
                                      const CfgOptionList& co_list);
 
    void assignLeases(const Pkt6Ptr& question, Pkt6Ptr& answer,
                      AllocEngine::ClientContext6& ctx);
 
    void processClientFqdn(const Pkt6Ptr& question, const Pkt6Ptr& answer,
                           AllocEngine::ClientContext6& ctx);
 
    void createNameChangeRequests(const Pkt6Ptr& answer,
                                  AllocEngine::ClientContext6& ctx);
 
    void extendLeases(const Pkt6Ptr& query, Pkt6Ptr& reply,
                      AllocEngine::ClientContext6& ctx);
 
    void setTeeTimes(uint32_t preferred_lft,
                     const ConstSubnet6Ptr& subnet,
                     Option6IAPtr& resp);
 
    void releaseLeases(const Pkt6Ptr& release, Pkt6Ptr& reply,
                       AllocEngine::ClientContext6& ctx);
 
    static std::string duidToString(const OptionPtr& opt);
 
    virtual Pkt6Ptr receivePacket(int timeout);
 
    virtual void sendPacket(const Pkt6Ptr& pkt);
 
    void classifyPacket(const Pkt6Ptr& pkt);
 
    void evaluateClasses(const Pkt6Ptr& pkt, bool depend_on_known);
 
    static void removeDependentEvaluatedClasses(const Pkt6Ptr& pkt);
 
    void setReservedClientClasses(const Pkt6Ptr& pkt,
                                  const AllocEngine::ClientContext6& ctx);
 
    void conditionallySetReservedClientClasses(const Pkt6Ptr& pkt,
                                               const AllocEngine::ClientContext6& ctx);
 
    void evaluateAdditionalClasses(const Pkt6Ptr& pkt, AllocEngine::ClientContext6& ctx);
 
    static HWAddrPtr getMAC(const Pkt6Ptr& pkt);
 
    void processRSOO(const Pkt6Ptr& query, const Pkt6Ptr& rsp);
 
    void initContext(AllocEngine::ClientContext6& ctx, bool& drop);
 
    static const std::string VENDOR_CLASS_PREFIX;
 
    bool declineLeases(const Pkt6Ptr& decline, Pkt6Ptr& reply,
                       AllocEngine::ClientContext6& ctx);
 
    OptionPtr
    declineIA(const Pkt6Ptr& decline, const DuidPtr& duid, int& general_status,
              boost::shared_ptr<Option6IA> ia, Lease6Collection& new_leases);
 
    bool declineLease(const Pkt6Ptr& decline, const Lease6Ptr lease,
                      boost::shared_ptr<Option6IA> ia_rsp);
 
    void setStatusCode(boost::shared_ptr<Option6IA>& container,
                       const OptionPtr& status);
 
    //
    void checkDynamicSubnetChange(const Pkt6Ptr& question, Pkt6Ptr& answer,
                                  AllocEngine::ClientContext6& ctx,
                                  const ConstSubnet6Ptr orig_subnet);
 
    OptionPtr getPDExclude(const AllocEngine::ClientContext6& ctx,
                           const Lease6Ptr& lease);
 
public:
 
 
    static uint16_t checkRelaySourcePort(const Pkt6Ptr& query);
 
private:
 
    void classifyByVendor(const Pkt6Ptr& pkt);
 
    void updateReservedFqdn(AllocEngine::ClientContext6& ctx,
                            const Pkt6Ptr& answer);
 
    void generateFqdn(const Pkt6Ptr& answer,
                      AllocEngine::ClientContext6& ctx);
 
    static void processStatsReceived(const Pkt6Ptr& query);
 
    bool requestedInORO(const Pkt6Ptr& query, const uint16_t code) const;
 
    static std::tuple<bool, uint32_t> parkingLimitExceeded(std::string const& hook_label);
 
protected:
    uint16_t server_port_;
 
    uint16_t client_port_;
 
public:
 
 
    static void processStatsSent(const Pkt6Ptr& response);
 
    static int getHookIndexBuffer6Send();
 
    void processPacketBufferSend(hooks::CalloutHandlePtr& callout_handle,
                                 Pkt6Ptr& rsp);
 
    std::list<std::list<std::string>> jsonPathsToRedact() const final override;
 
protected:
 
    OptionPtr serverid_;
 
    volatile bool shutdown_;
 
    void processPacketPktSend(hooks::CalloutHandlePtr& callout_handle,
                              Pkt6Ptr& query, Pkt6Ptr& rsp,
                              ConstSubnet6Ptr& subnet);
 
    boost::shared_ptr<AllocEngine> alloc_engine_;
 
    std::queue<isc::dhcp_ddns::NameChangeRequest> name_change_reqs_;
 
    NetworkStatePtr network_state_;
 
    CBControlDHCPv6Ptr cb_control_;
};
 
}  // namespace dhcp
}  // namespace isc
 
#endif // DHCP6_SRV_H