ping_context.h

Go to the documentation of this file.

// Copyright (C) 2023-2026 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_CONTEXT_H
#define PING_CONTEXT_H
 
#include <dhcp/pkt4.h>
#include <dhcpsrv/lease.h>
#include <hooks/parking_lots.h>
 
#include <chrono>
#include <cstdint>
 
namespace isc {
namespace ping_check {

using TimeStamp = std::chrono::time_point<std::chrono::system_clock>;

class PingContext {
public:

    enum State : uint16_t {
        NEW,                  // Newly created
        WAITING_TO_SEND,      // Waiting to send next ECHO REQUEST
        SENDING,              // Next ECHO REQUEST is being sent
        WAITING_FOR_REPLY,    // ECHO REQUEST sent, Waiting for reply or timeout
        TARGET_FREE,          // Target has been deemed free to offer.
        TARGET_IN_USE         // Target has been deemed in-use, do not offer
    };

    static State stringToState(const std::string& state_str);

    static std::string stateToString(const State& state);

    PingContext(isc::dhcp::Lease4Ptr& lease, isc::dhcp::Pkt4Ptr& query,
                uint32_t min_echos = 1, uint32_t reply_timeout = 100,
                isc::hooks::ParkingLotHandlePtr& parking_lot = EMPTY_LOT());

    virtual ~PingContext() = default;

    static TimeStamp now();

    static const TimeStamp& EMPTY_TIME() {
        static TimeStamp empty_time;
        return (empty_time);
    }

    static const TimeStamp& MIN_TIME() {
        static TimeStamp min_time = std::chrono::system_clock::time_point::min();
        return (min_time);
    }

    static hooks::ParkingLotHandlePtr& EMPTY_LOT() {
        static hooks::ParkingLotHandlePtr empty_lot(0);
        return (empty_lot);
    }

    const isc::asiolink::IOAddress& getTarget() const;

    uint32_t getMinEchos() const;

    void setMinEchos(uint32_t value);

    uint32_t getReplyTimeout() const;

    void setReplyTimeout(uint32_t value);

    uint32_t getEchosSent() const;

    void setEchosSent(uint32_t value);

    const TimeStamp& getLastEchoSentTime() const;

    void setLastEchoSentTime(const TimeStamp& value);

    const TimeStamp& getSendWaitStart() const;

    void setSendWaitStart(const TimeStamp& value);

    bool isWaitingToSend() const;

    const TimeStamp& getNextExpiry() const;

    void setNextExpiry(const TimeStamp& value);

    bool isWaitingForReply() const;

    const TimeStamp& getCreatedTime() const;

    State getState() const;

    void setState(const State& value);

    isc::dhcp::Pkt4Ptr getQuery() const;

    isc::dhcp::Lease4Ptr getLease() const;

    void beginWaitingToSend(const TimeStamp& begin_time = PingContext::now());

    void beginWaitingForReply(const TimeStamp& begin_time = PingContext::now());

    isc::hooks::ParkingLotHandlePtr getParkingLot() {
        return (parking_lot_);
    };
 
private:
    uint32_t min_echos_ = 0;

    uint32_t reply_timeout_ = 0;

    uint32_t echos_sent_ = 0;

    TimeStamp last_echo_sent_time_;

    TimeStamp send_wait_start_;

    TimeStamp next_expiry_;

    TimeStamp created_time_;

    isc::dhcp::Lease4Ptr lease_;

    isc::dhcp::Pkt4Ptr query_;

    State state_;

    isc::hooks::ParkingLotHandlePtr parking_lot_;
};

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