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