dhcp4_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 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 sanity_only = false,
                                            bool allow_answer_park = true);
 
    isc::dhcp::ConstSubnet4Ptr selectSubnet4o6(const Pkt4Ptr& query,
                                               bool& drop,
                                               bool sanity_only = false,
                                               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