dhcp4_srv.h

Go to the documentation of this file.

// Copyright (C) 2011-2025 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 DHCPV4_SRV_H
#define DHCPV4_SRV_H
 
#include <asiolink/io_service.h>
#include <dhcp/dhcp4.h>
#include <dhcp/option.h>
#include <dhcp/option_string.h>
#include <dhcp/option4_client_fqdn.h>
#include <dhcp/option_custom.h>
#include <dhcp/pkt4.h>
#include <dhcp_ddns/ncr_msg.h>
#include <dhcpsrv/alloc_engine.h>
#include <dhcpsrv/callout_handle_store.h>
#include <dhcpsrv/cb_ctl_dhcp4.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 Dhcpv4Exchange {
public:
    Dhcpv4Exchange(const AllocEnginePtr& alloc_engine, const Pkt4Ptr& query,
                   AllocEngine::ClientContext4Ptr& context,
                   const ConstSubnet4Ptr& subnet, bool& drop);

    void initResponse();

    void initResponse4o6();

    Pkt4Ptr getQuery() const {
        return (query_);
    }

    Pkt4Ptr getResponse() const {
        return (resp_);
    }

    void deleteResponse() {
        resp_.reset();
    }

    AllocEngine::ClientContext4Ptr getContext() const {
        return (context_);
    }

    CfgOptionList& getCfgOptionList() {
        return (cfg_option_list_);
    }

    const CfgOptionList& getCfgOptionList() const {
        return (cfg_option_list_);
    }

    bool getIPv6OnlyPreferred() const {
        return (ipv6_only_preferred_);
    }

    void setIPv6OnlyPreferred(bool ipv6_only_preferred) {
        ipv6_only_preferred_ = ipv6_only_preferred;
    }

    void setReservedMessageFields();

    static void setHostIdentifiers(AllocEngine::ClientContext4Ptr context);

    static void removeDependentEvaluatedClasses(const Pkt4Ptr& query);

    static void setReservedClientClasses(AllocEngine::ClientContext4Ptr context);

    void conditionallySetReservedClientClasses();

    static void classifyPacket(const Pkt4Ptr& pkt);

    static void evaluateClasses(const Pkt4Ptr& pkt, bool depend_on_known);
 
private:

    static void classifyByVendor(const Pkt4Ptr& pkt);

    void copyDefaultFields();

    void copyDefaultOptions();

    AllocEnginePtr alloc_engine_;

    Pkt4Ptr query_;

    Pkt4Ptr resp_;

    AllocEngine::ClientContext4Ptr context_;

    CfgOptionList cfg_option_list_;

    bool ipv6_only_preferred_;
};

typedef boost::shared_ptr<Dhcpv4Exchange> Dhcpv4ExchangePtr;
 

class Dhcpv4Srv : public process::Daemon {
private:

    asiolink::IOServicePtr io_service_;
 
public:

    typedef enum {
        FORBIDDEN,
        MANDATORY,
        OPTIONAL
    } RequirementLevel;

    Dhcpv4Srv(uint16_t server_port = DHCP4_SERVER_PORT,
              uint16_t client_port = 0,
              const bool use_bcast = true,
              const bool direct_response_desired = true);

    virtual ~Dhcpv4Srv();

    bool inTestMode() const {
        return (server_port_ == 0);
    }

    asiolink::IOServicePtr& getIOService() {
        return (io_service_);
    }

    NetworkStatePtr& getNetworkState() {
        return (network_state_);
    }

    CBControlDHCPv4Ptr getCBControl() const {
        return (cb_control_);
    }

    static std::string getVersion(bool extended);

    int run();

    void runOne();

    void processPacketAndSendResponse(Pkt4Ptr query);

    void processPacketAndSendResponseNoThrow(Pkt4Ptr query);

    void sendResponseNoThrow(hooks::CalloutHandlePtr& callout_handle,
                             Pkt4Ptr& query, Pkt4Ptr& rsp,
                             ConstSubnet4Ptr& subnet);

    Pkt4Ptr processPacket(Pkt4Ptr query, bool allow_answer_park = true);

    Pkt4Ptr processDhcp4Query(Pkt4Ptr query, bool allow_answer_park);

    void processDhcp4QueryAndSendResponse(Pkt4Ptr query,
                                          bool allow_answer_park);

    Pkt4Ptr processLocalizedQuery4(AllocEngine::ClientContext4Ptr& ctx,
                                   bool allow_answer_park);

    void processLocalizedQuery4AndSendResponse(Pkt4Ptr query,
                                               AllocEngine::ClientContext4Ptr& ctx,
                                               bool allow_answer_park);

    void processLocalizedQuery4AndSendResponse(Pkt4Ptr query,
                                               bool allow_answer_park);

    void shutdown() override;



    uint16_t getServerPort() const;

    bool useBroadcast() const {
        return (use_bcast_);
    }


    void startD2();

    void stopD2();

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

    void discardPackets();

    bool getSendResponsesToSource() const {
        return (test_send_responses_to_source_);
    }

    void initContext0(const Pkt4Ptr& query,
                      AllocEngine::ClientContext4Ptr ctx);

    bool earlyGHRLookup(const Pkt4Ptr& query,
                        AllocEngine::ClientContext4Ptr ctx);
 
protected:



    bool accept(const Pkt4Ptr& query);

    bool acceptDirectRequest(const Pkt4Ptr& query);

    bool acceptMessageType(const Pkt4Ptr& query) const;

    bool acceptServerId(const Pkt4Ptr& pkt) const;

    static void sanityCheck(const Pkt4Ptr& query);

    static void sanityCheck(const Pkt4Ptr& query, RequirementLevel serverid);

    Pkt4Ptr processDiscover(Pkt4Ptr& discover, AllocEngine::ClientContext4Ptr& context);

    Pkt4Ptr processRequest(Pkt4Ptr& request, AllocEngine::ClientContext4Ptr& context);

    void processRelease(Pkt4Ptr& release, AllocEngine::ClientContext4Ptr& context);

    void processDecline(Pkt4Ptr& decline, AllocEngine::ClientContext4Ptr& context);

    Pkt4Ptr processInform(Pkt4Ptr& inform, AllocEngine::ClientContext4Ptr& context);

    void buildCfgOptionList(Dhcpv4Exchange& ex);

    void appendRequestedOptions(Dhcpv4Exchange& ex);

    void appendRequestedVendorOptions(Dhcpv4Exchange& ex);

    bool assignZero(ConstSubnet4Ptr& subnet,
                    const ClientClasses& client_classes);

    void assignLease(Dhcpv4Exchange& ex);

    void postAllocateNameUpdate(const AllocEngine::ClientContext4Ptr& ctx,
                                const Lease4Ptr& lease, const Pkt4Ptr& query,
                                const Pkt4Ptr& resp, bool client_name_changed);

    void setTeeTimes(const Lease4Ptr& lease,
                     const ConstSubnet4Ptr& subnet,
                     Pkt4Ptr resp);

    void appendBasicOptions(Dhcpv4Exchange& ex);

    void setFixedFields(Dhcpv4Exchange& ex);

    void processClientName(Dhcpv4Exchange& ex);

    void setPacketStatisticsDefaults();

    void setSendResponsesToSource(bool value) {
        test_send_responses_to_source_ = value;
    }

    void serverDecline(hooks::CalloutHandlePtr& callout_handle, Pkt4Ptr& query,
                       Lease4Ptr lease, bool lease_exists);

    void serverDeclineNoThrow(hooks::CalloutHandlePtr& callout_handle, Pkt4Ptr& query,
                              Lease4Ptr lease, bool lease_exists);
 
public:

    static const std::string VENDOR_CLASS_PREFIX;
 
private:
    void processClientFqdnOption(Dhcpv4Exchange& ex);

    void processHostnameOption(Dhcpv4Exchange& ex);

    void declineLease(const Lease4Ptr& lease, const Pkt4Ptr& decline,
                      AllocEngine::ClientContext4Ptr& context);
 
protected:

    void createNameChangeRequests(const Lease4Ptr& lease,
                                  const Lease4Ptr& old_lease,
                                  const DdnsParams& ddns_params);

    void renewLease(const Pkt4Ptr& renew, Pkt4Ptr& reply);

    static void appendServerID(Dhcpv4Exchange& ex);

    static uint16_t checkRelayPort(const Dhcpv4Exchange& ex);

    void adjustIfaceData(Dhcpv4Exchange& ex);

    void adjustRemoteAddr(Dhcpv4Exchange& ex);

    static std::string srvidToString(const OptionPtr& opt);

    isc::dhcp::ConstSubnet4Ptr selectSubnet(const Pkt4Ptr& query,
                                            bool& drop,
                                            bool allow_answer_park = true);

    isc::dhcp::ConstSubnet4Ptr selectSubnet4o6(const Pkt4Ptr& query,
                                               bool& drop,
                                               bool allow_answer_park = true);

    virtual Pkt4Ptr receivePacket(int timeout);

    virtual void sendPacket(const Pkt4Ptr& pkt);

    void classifyPacket(const Pkt4Ptr& pkt);

    void recoverStashedAgentOption(const Pkt4Ptr& query);
 
protected:

    void evaluateAdditionalClasses(Dhcpv4Exchange& ex);

    void deferredUnpack(Pkt4Ptr& query);

    void processPacketPktSend(hooks::CalloutHandlePtr& callout_handle,
                              Pkt4Ptr& query, Pkt4Ptr& rsp,
                              ConstSubnet4Ptr& subnet);

    void processPacketBufferSend(hooks::CalloutHandlePtr& callout_handle,
                                 Pkt4Ptr& rsp);
 
private:

    void classifyByVendor(const Pkt4Ptr& pkt);

    static OptionPtr getNetmaskOption(const ConstSubnet4Ptr& subnet);

    static std::tuple<bool, uint32_t> parkingLimitExceeded(std::string const& hook_label);
 
protected:

    uint16_t server_port_;

    uint16_t client_port_;

    volatile bool shutdown_;

    boost::shared_ptr<AllocEngine> alloc_engine_;

    bool use_bcast_;

    NetworkStatePtr network_state_;

    CBControlDHCPv4Ptr cb_control_;
 
private:

    bool test_send_responses_to_source_;
 
public:


    static void processStatsReceived(const Pkt4Ptr& query);

    static void processStatsSent(const Pkt4Ptr& response);

    static int getHookIndexBuffer4Receive();

    static int getHookIndexPkt4Receive();

    static int getHookIndexSubnet4Select();

    static int getHookIndexLease4Release();

    static int getHookIndexPkt4Send();

    static int getHookIndexBuffer4Send();

    static int getHookIndexLease4Decline();

    std::list<std::list<std::string>> jsonPathsToRedact() const final override;
};
 
}  // namespace dhcp
}  // namespace isc
 
#endif // DHCP4_SRV_H