dhcp4_srv.h

Go to the documentation of this file.

// Copyright (C) 2011-2018 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/pkt4.h>
#include <dhcp/option.h>
#include <dhcp/option_string.h>
#include <dhcp/option4_client_fqdn.h>
#include <dhcp/option_custom.h>
#include <dhcp_ddns/ncr_msg.h>
#include <dhcpsrv/alloc_engine.h>
#include <dhcpsrv/cfg_option.h>
#include <dhcpsrv/callout_handle_store.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 <boost/noncopyable.hpp>
 
#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);
 
    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();
 
    void setReservedClientClasses();
 
private:
 
    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 port = DHCP4_SERVER_PORT,
              const bool use_bcast = true,
              const bool direct_response_desired = true);
 
    virtual ~Dhcpv4Srv();
 
    asiolink::IOServicePtr& getIOService() {
        return (io_service_);
    }
 
    NetworkStatePtr& getNetworkState() {
        return (network_state_);
    }
 
    static std::string getVersion(bool extended);
 
    bool run();
 
    void run_one();
 
    void processPacket(Pkt4Ptr& query, Pkt4Ptr& rsp,
                       bool allow_packet_park = true);
 
 
    void shutdown();
 
 
    uint16_t getPort() const {
        return (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();
 
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 appendBasicOptions(Dhcpv4Exchange& ex);
 
    void setFixedFields(Dhcpv4Exchange& ex);
 
    void processClientName(Dhcpv4Exchange& ex);
 
    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);
 
    void renewLease(const Pkt4Ptr& renew, Pkt4Ptr& reply);
 
    static void appendServerID(Dhcpv4Exchange& ex);
 
    static uint16_t checkRelayPort(const Dhcpv4Exchange& ex);
 
    static void adjustIfaceData(Dhcpv4Exchange& ex);
 
    static 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;
 
    volatile bool shutdown_;
 
    virtual Pkt4Ptr receivePacket(int timeout);
 
    virtual void sendPacket(const Pkt4Ptr& pkt);
 
    void classifyPacket(const Pkt4Ptr& pkt);
 
public:
 
    static void evaluateClasses(const Pkt4Ptr& pkt, bool depend_on_known);
 
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);
 
    boost::shared_ptr<AllocEngine> alloc_engine_;
 
private:
 
    void classifyByVendor(const Pkt4Ptr& pkt);
 
    static OptionPtr getNetmaskOption(const Subnet4Ptr& subnet);
 
    uint16_t port_;  
    bool use_bcast_; 
 
protected:
 
    NetworkStatePtr network_state_;
 
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();
};
 
}; // namespace isc::dhcp
}; // namespace isc
 
#endif // DHCP4_SRV_H