dhcp6_srv.h

Go to the documentation of this file.

// Copyright (C) 2011-2022 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 run_one();

    void processPacketAndSendResponse(Pkt6Ptr& query);

    void processPacketAndSendResponseNoThrow(Pkt6Ptr& query);

    void sendResponseNoThrow(hooks::CalloutHandlePtr& callout_handle,
                             Pkt6Ptr& query, Pkt6Ptr& rsp);

    void processPacket(Pkt6Ptr& query, Pkt6Ptr& rsp);

    void processDhcp6Query(Pkt6Ptr& query, Pkt6Ptr& rsp);

    void processDhcp6QueryAndSendResponse(Pkt6Ptr& query, Pkt6Ptr& rsp);

    void shutdown() override;


    uint16_t getServerPort() const {
        return (server_port_);
    }

    void startD2();

    void stopD2();

    virtual void d2ClientErrorHandler(const dhcp_ddns::
                                      NameChangeSender::Result result,
                                      dhcp_ddns::NameChangeRequestPtr& ncr);

    void discardPackets();

    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::Subnet6Ptr 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 Subnet6Ptr& 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 requiredClassify(const Pkt6Ptr& pkt, AllocEngine::ClientContext6& ctx);

    static HWAddrPtr getMAC(const Pkt6Ptr& pkt);

    void processRSOO(const Pkt6Ptr& query, const Pkt6Ptr& rsp);

    void initContext(const Pkt6Ptr& pkt,
                     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 Subnet6Ptr orig_subnet);
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;

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);

    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