ping.hpp

Go to the documentation of this file.

 
#ifndef JOIN_FABRIC_PING_HPP
#define JOIN_FABRIC_PING_HPP
 
// libjoin.
#include <join/datagram_socket.hpp>
#include <join/ip_address.hpp>
#include <join/condition.hpp>
#include <join/reactor.hpp>
 
// C++.
#include <unordered_map>
#include <functional>
#include <chrono>
#include <memory>
#include <string>
 
// C.
#include <netinet/in.h>
 
namespace join
{
    struct PingAnswer
    {
        IpAddress from;
 
        std::chrono::microseconds rtt{0};
 
        int ttl = 0;
 
        int size = 0;
 
        uint32_t mtu = 0;
 
        bool expired = false;
 
        std::string error;
 
        std::error_code code;
    };
 
    class PingStats
    {
    public:
        PingStats () = default;
 
        PingStats (const std::string& device, const IpAddress& source, const std::string& host, int size,
                   std::chrono::milliseconds interval, int hop, int df);
 
        PingStats (const PingStats& other) = default;
 
        PingStats& operator= (const PingStats& other) = default;
 
        PingStats (PingStats&& other) = default;
 
        PingStats& operator= (PingStats&& other) = default;
 
        ~PingStats () = default;
 
        const std::string& device () const noexcept
        {
            return _device;
        }
 
        const IpAddress& source () const noexcept
        {
            return _source;
        }
 
        const std::string& host () const noexcept
        {
            return _host;
        }
 
        const IpAddress& address () const noexcept
        {
            return _address;
        }
 
        int size () const noexcept
        {
            return _size;
        }
 
        std::chrono::milliseconds interval () const noexcept
        {
            return _interval;
        }
 
        const IpAddress& from () const noexcept
        {
            return _answer.from;
        }
 
        uint16_t sequence () const noexcept
        {
            return _sequence;
        }
 
        int hop () const noexcept
        {
            return _hop;
        }
 
        int df () const noexcept
        {
            return _df;
        }
 
        int route () const noexcept
        {
            return _route;
        }
 
        int ttl () const noexcept
        {
            return _answer.ttl;
        }
 
        int packetSize () const noexcept
        {
            return _answer.size;
        }
 
        std::chrono::microseconds rtt () const noexcept
        {
            return _answer.rtt;
        }
 
        bool expired () const noexcept
        {
            return _answer.expired;
        }
 
        uint32_t mtu () const noexcept
        {
            return _answer.mtu;
        }
 
        const std::string& error () const noexcept
        {
            return _answer.error;
        }
 
        const std::error_code& code () const noexcept
        {
            return _answer.code;
        }
 
        uint32_t sent () const noexcept
        {
            return _sent;
        }
 
        uint32_t received () const noexcept
        {
            return _received;
        }
 
        double loss () const noexcept
        {
            return _sent ? ((_sent - _received) * 100.0) / _sent : 0.0;
        }
 
        std::chrono::microseconds min () const noexcept
        {
            return std::chrono::microseconds (_min);
        }
 
        std::chrono::microseconds max () const noexcept
        {
            return std::chrono::microseconds (_max);
        }
 
        std::chrono::microseconds avg () const noexcept
        {
            return std::chrono::microseconds (static_cast<uint64_t> (_mean));
        }
 
        std::chrono::microseconds mdev () const noexcept;
 
        std::chrono::microseconds total () const noexcept
        {
            return std::chrono::duration_cast<std::chrono::microseconds> (_stop - _start);
        }
 
        void reset () noexcept;
 
    private:
        void sample (std::chrono::microseconds rtt) noexcept;
 
        std::string _device;
 
        IpAddress _source;
 
        std::string _host;
 
        IpAddress _address;
 
        int _size = 0;
 
        std::chrono::milliseconds _interval{0};
 
        uint16_t _sequence = 0;
 
        int _hop = 0;
 
        int _df = IP_PMTUDISC_DONT;
 
        int _route = 0;
 
        PingAnswer _answer;
 
        uint32_t _sent = 0;
 
        uint32_t _received = 0;
 
        uint32_t _samples = 0;
 
        uint64_t _min = 0;
 
        uint64_t _max = 0;
 
        double _mean = 0.0;
 
        double _m2 = 0.0;
 
        std::chrono::steady_clock::time_point _start;
 
        std::chrono::steady_clock::time_point _stop;
 
        friend class Ping;
    };
 
    class Ping : public EventHandler
    {
    public:
        using PingNotify = std::function<void (const PingStats&)>;
 
        PingNotify onStart;
 
        PingNotify onSuccess;
 
        PingNotify onFailure;
 
        PingNotify onHop;
 
        PingNotify onStop;
 
        explicit Ping (int ttl = _defaultTtl, Reactor& reactor = ReactorThread::reactor ());
 
        explicit Ping (const std::string& device, int ttl = _defaultTtl, Reactor& reactor = ReactorThread::reactor ());
 
        Ping (const Ping& other) = delete;
 
        Ping& operator= (const Ping& other) = delete;
 
        Ping (Ping&& other) = delete;
 
        Ping& operator= (Ping&& other) = delete;
 
        ~Ping () = default;
 
        int ping (const IpAddress& source, const std::string& destination, int size = _defaultSize, int count = 1,
                  std::chrono::milliseconds interval = std::chrono::milliseconds (500), int df = IP_PMTUDISC_DONT,
                  std::chrono::milliseconds timeout = std::chrono::seconds (5));
 
        static int ping4 (const std::string& destination, int size = _defaultSize, int count = 1,
                          std::chrono::milliseconds interval = std::chrono::milliseconds (500), int ttl = _defaultTtl,
                          int df = IP_PMTUDISC_DONT, std::chrono::milliseconds timeout = std::chrono::seconds (5));
 
        static int ping6 (const std::string& destination, int size = _defaultSize, int count = 1,
                          std::chrono::milliseconds interval = std::chrono::milliseconds (500), int ttl = _defaultTtl,
                          int df = IP_PMTUDISC_DONT, std::chrono::milliseconds timeout = std::chrono::seconds (5));
 
        int pathMtu (const IpAddress& source, const std::string& destination,
                     std::chrono::milliseconds timeout = std::chrono::seconds (5));
 
        int trace (const IpAddress& source, const std::string& destination, int maxHops = _defaultMaxHops,
                   int probes = _defaultProbes, int size = _defaultSize, int df = IP_PMTUDISC_DONT,
                   std::chrono::milliseconds timeout = std::chrono::seconds (5));
 
        static const char* message (int family, uint8_t type, uint8_t code) noexcept;
 
    protected:
        static bool isFatal (const PingStats& stats, uint32_t transmitted);
 
        static int headerSize (const PingStats& stats);
 
        int open (Icmp::Socket& socket, PingStats& stats);
 
        static int setFilter (Icmp::Socket& socket, PingStats& stats);
 
        void close (Icmp::Socket& socket);
 
        int echo (Icmp::Socket& socket, PingStats& stats, std::chrono::milliseconds timeout);
 
        void onReadable (int fd) override final;
 
        void onError (int fd) override final;
 
        static void notify (const PingNotify& function, const PingStats& stats);
 
        static int fail (PingStats& stats, const std::error_code& code, const std::string& error);
 
#ifdef DEBUG
        static void defaultOnStart (const PingStats& stats);
 
        static void defaultOnSuccess (const PingStats& stats);
 
        static void defaultOnFailure (const PingStats& stats);
 
        static void defaultOnStop (const PingStats& stats);
#endif
 
        static constexpr int _defaultTtl = 60;
 
        static constexpr int _defaultSize = 56;
 
        static constexpr int _defaultMaxHops = 30;
 
        static constexpr int _defaultProbes = 3;
 
        static constexpr int _icmpHeaderSize = 8;
 
        static constexpr size_t _bufferSize = 65535;
 
        static constexpr int _maxMtuProbes = 30;
 
        static constexpr int _retryDelay = 200;
 
        static constexpr int _dumpSize = 64;
 
        struct PendingRequest
        {
            Condition cond;
 
            std::chrono::steady_clock::time_point sent;
 
            PingAnswer answer;
 
            bool answered = false;
        };
 
        std::unordered_map<uint16_t, std::unique_ptr<PendingRequest>> _pending;
 
        Mutex _syncMutex;
 
        std::unique_ptr<char[]> _buffer;
 
        const std::string _device;
 
        const uint16_t _identity;
 
        uint16_t _sequence = 0;
 
        const int _ttl;
 
        Reactor& _reactor;
    };
}
 
#endif