ping_check_mgr.h

Go to the documentation of this file.

// Copyright (C) 2023-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 PING_CHECK_MGR_H
#define PING_CHECK_MGR_H
 
#include <asiolink/interval_timer.h>
#include <asiolink/io_address.h>
#include <asiolink/io_service.h>
#include <asiolink/io_service_thread_pool.h>
#include <cc/data.h>
#include <cc/simple_parser.h>
#include <dhcpsrv/host.h>
#include <dhcpsrv/srv_config.h>
#include <hooks/callout_handle.h>
#include <dhcp/pkt4.h>
#include <dhcpsrv/lease.h>
#include <dhcpsrv/network_state.h>
#include <ping_context_store.h>
#include <ping_channel.h>
#include <config_cache.h>
 
#include <boost/enable_shared_from_this.hpp>
 
#include <mutex>
 
namespace isc {
namespace ping_check {

typedef boost::shared_ptr<PingContextStore> PingContextStorePtr;

class PingCheckMgr : public boost::enable_shared_from_this<PingCheckMgr> {
public:
    explicit PingCheckMgr();

    PingCheckMgr(uint32_t num_threads,
                 uint32_t min_echos = 1,
                 uint32_t reply_timeout = 100);

    virtual ~PingCheckMgr();

    void configure(data::ConstElementPtr params);

    void updateSubnetConfig(dhcp::SrvConfigPtr server_config);

    virtual PingChannelPtr createChannel(asiolink::IOServicePtr io_service);

    void startPing(dhcp::Lease4Ptr& lease, dhcp::Pkt4Ptr& query,
                   hooks::ParkingLotHandlePtr& parking_lot,
                   const PingCheckConfigPtr& config);

    void startPing(dhcp::Lease4Ptr& lease, dhcp::Pkt4Ptr& query,
                   hooks::ParkingLotHandlePtr& parking_lot);

    virtual bool nextToSend(asiolink::IOAddress& next);

    virtual void sendCompleted(const ICMPMsgPtr& echo, bool send_failed);

    virtual void replyReceived(const ICMPMsgPtr& reply);

    void handleEchoReply(const ICMPMsgPtr& echo_reply);

    void handleTargetUnreachable(const ICMPMsgPtr& unreachable);

    void finishFree(const PingContextPtr& context);

    void doNextEcho(const PingContextPtr& context);

    virtual void channelShutdown();

    virtual size_t processExpiredSince(const TimeStamp& since = PingContext::now());

    TimeStamp getNextExpiry();

    virtual void setNextExpiration();

    virtual void setNextExpirationInternal();

    void cancelExpirationTimer();

    void cancelExpirationTimerInternal();

    virtual void expirationTimedOut();

    virtual hooks::CalloutHandle::CalloutNextStep shouldPing(dhcp::Lease4Ptr& lease,
                                                             dhcp::Pkt4Ptr& query,
                                                             dhcp::Lease4Ptr& old_lease,
                                                             dhcp::ConstHostPtr host,
                                                             const PingCheckConfigPtr& config);

    void checkPermissions();

    void startService(dhcp::NetworkStatePtr network_state);

    void stopService(bool finish_free = false);

    void start();

    void startSingleThreaded();

    void pause();

    void resume();

    void flush(bool finish_free = false);

    void stop();

    bool isRunning();

    bool isStopped();

    bool isPaused();

    bool checkSuspended();

    bool checkSuspendedInternal();

    const PingCheckConfigPtr getGlobalConfig() const;

    const PingCheckConfigPtr getScopedConfig(dhcp::Lease4Ptr& lease);

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

    void setIOService(isc::asiolink::IOServicePtr io_service) {
        io_service_ = io_service;
    }
 
protected:

    isc::asiolink::IOServicePtr io_service_;

    asiolink::IoServiceThreadPoolPtr thread_pool_;

    PingContextStorePtr store_;

    PingChannelPtr channel_;

    ConfigCachePtr config_cache_;

    dhcp::NetworkStatePtr network_state_;

    TimeStamp next_expiry_;

    asiolink::IntervalTimerPtr expiration_timer_;

    const boost::scoped_ptr<std::mutex> mutex_;

    bool suspended_;
};

typedef boost::shared_ptr<PingCheckMgr> PingCheckMgrPtr;
 
} // end of namespace ping_check
} // end of namespace isc
 
#endif