ping_channel.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_CHANNEL_H
#define PING_CHANNEL_H
 
#include <asiolink/asio_wrapper.h>
#include <asiolink/io_address.h>
#include <asiolink/io_service.h>
#include <util/watch_socket.h>
#include <icmp_msg.h>
#include <icmp_socket.h>
#include <ping_context.h>
 
#include <boost/scoped_ptr.hpp>
#include <boost/enable_shared_from_this.hpp>
 
#include <iostream>
#include <mutex>
 
namespace isc {
namespace ping_check {

typedef std::function<void(boost::system::error_code ec, size_t length)> SocketCallbackFunction;

class SocketCallback {
public:
    explicit inline SocketCallback(SocketCallbackFunction socket_callback)
        : callback_(socket_callback) {
    };

    inline void operator()(boost::system::error_code ec, size_t length = 0) {
        if (ec.value() == boost::asio::error::operation_aborted) {
            return;
        }
 
        callback_(ec, length);
    };
 
private:
    SocketCallbackFunction callback_;
};

typedef ICMPSocket<SocketCallback> PingSocket;

typedef boost::shared_ptr<PingSocket> PingSocketPtr;

typedef std::function<PingContextPtr()> NextToSendCallback;

typedef std::function<void(PingContextPtr context)> UpdateToSendCallback;

typedef std::function<void(ICMPMsgPtr& echo, bool send_failed)> EchoSentCallback;

typedef std::function<void(ICMPMsgPtr& reply)> ReplyReceivedCallback;

typedef std::function<void()> ShutdownCallback;

class PingChannel : public boost::enable_shared_from_this<PingChannel> {
public:
    PingChannel(asiolink::IOServicePtr& io_service,
                NextToSendCallback next_to_send_cb,
                UpdateToSendCallback update_to_send_cb,
                EchoSentCallback echo_sent_cb,
                ReplyReceivedCallback reply_received_cb,
                ShutdownCallback shutdown_cb = ShutdownCallback());

    virtual ~PingChannel();

    void open();

    bool isOpen() const;
 
    // @brief Schedules the next send.
    //
    // If the socket is not currently sending it posts a call to @c sendNext()
    // to the channel's IOService.
    virtual void startSend();
 
    // @brief Schedules the next read.
    //
    // If the socket is not currently reading it posts a call to @c doRead()
    // to the channel's IOService.
    void startRead();

    void close();

    asiolink::IOServicePtr getIOService() {
        return (io_service_);
    }
 
protected:
    virtual void asyncReceive(void* data, size_t length, size_t offset,
                              asiolink::IOEndpoint* endpoint, SocketCallback& callback);

    virtual void asyncSend(void* data, size_t length, asiolink::IOEndpoint* endpoint,
                          SocketCallback& callback);
 
protected:
    void doRead();

    void socketReadCallback(boost::system::error_code ec, size_t length);

    virtual void sendNext();

    void socketWriteCallback(ICMPMsgPtr echo_sent, boost::system::error_code ec,
                             size_t length);

    void stopChannel();

    static uint32_t nextEchoInstanceNum();

    bool canSend() {
        return (socket_ && socket_->isOpen() && !stopping_ && !sending_);
    }

    bool canRead() {
        return (socket_ && socket_->isOpen() && !stopping_ && !reading_);
    }

    size_t getInputBufSize() const;

    unsigned char* getInputBufData();

    asiolink::IOServicePtr io_service_;

    NextToSendCallback next_to_send_cb_;

    UpdateToSendCallback update_to_send_cb_;

    EchoSentCallback echo_sent_cb_;

    ReplyReceivedCallback reply_received_cb_;

    ShutdownCallback shutdown_cb_;

    PingSocketPtr socket_;

    std::vector<uint8_t> input_buf_;

    ICMPEndpoint reply_endpoint_;

    bool reading_;

    bool sending_;

    bool stopping_;

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

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

    bool single_threaded_;

    util::WatchSocketPtr watch_socket_;

    int registered_write_fd_;

    int registered_read_fd_;
};

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