dhcp4_srv.h

Go to the documentation of this file.

// Copyright (C) 2011-2021 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,
                   const Subnet4Ptr& 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_);
    }

    void setReservedMessageFields();

    static void setReservedClientClasses(AllocEngine::ClientContext4Ptr context);

    void conditionallySetReservedClientClasses();

    static void classifyPacket(const Pkt4Ptr& pkt);

private:

    static void classifyByVendor(const Pkt4Ptr& pkt);

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

    void copyDefaultFields();

    void copyDefaultOptions();

    void setHostIdentifiers();

    AllocEnginePtr alloc_engine_;

    Pkt4Ptr query_;

    Pkt4Ptr resp_;

    AllocEngine::ClientContext4Ptr context_;

    CfgOptionList cfg_option_list_;
};

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

    void processPacketAndSendResponse(Pkt4Ptr& query);

    void processPacketAndSendResponseNoThrow(Pkt4Ptr& query);

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

    void processPacket(Pkt4Ptr& query, Pkt4Ptr& rsp,
                       bool allow_packet_park = true);

    void processDhcp4Query(Pkt4Ptr& query, Pkt4Ptr& rsp,
                           bool allow_packet_park);

    void processDhcp4QueryAndSendResponse(Pkt4Ptr& query, Pkt4Ptr& rsp,
                                          bool allow_packet_park);

    void shutdown() override;


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

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

protected:


    bool accept(const Pkt4Ptr& query) const;

    bool acceptDirectRequest(const Pkt4Ptr& query) const;

    bool acceptMessageType(const Pkt4Ptr& query) const;

    bool acceptServerId(const Pkt4Ptr& pkt) const;

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

    Pkt4Ptr processDiscover(Pkt4Ptr& discover);

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

    void buildCfgOptionList(Dhcpv4Exchange& ex);

    void appendRequestedOptions(Dhcpv4Exchange& ex);

    void appendRequestedVendorOptions(Dhcpv4Exchange& ex);

    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 Subnet4Ptr& 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;
    }

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::Subnet4Ptr selectSubnet(const Pkt4Ptr& query,
                                       bool& drop,
                                       bool sanity_only = false) const;

    isc::dhcp::Subnet4Ptr selectSubnet4o6(const Pkt4Ptr& query,
                                          bool& drop,
                                          bool sanity_only = false) const;

    virtual Pkt4Ptr receivePacket(int timeout);

    virtual void sendPacket(const Pkt4Ptr& pkt);

    void classifyPacket(const Pkt4Ptr& pkt);

protected:

    void requiredClassify(Dhcpv4Exchange& ex);

    void deferredUnpack(Pkt4Ptr& query);

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

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

private:

    void classifyByVendor(const Pkt4Ptr& pkt);

    static OptionPtr getNetmaskOption(const Subnet4Ptr& subnet);

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