Program.cs

using System.Net;
using System.Net.Sockets;
using System.Runtime.InteropServices;
using System.Text.Json;
using System.Text.Json.Serialization;

if (args.Length == 0)
{
    Console.Error.WriteLine("Usage: PingMoni <target> [-i <interval_ms>] [-o <log_dir>] [-h|--help]");
    Console.Error.WriteLine("Run 'PingMoni --help' for detailed options.");
    return 1;
}

if (args.Any(a => a is "-h" or "--help" or "/?"))
{
    PrintHelp();
    return 0;
}

var target = args[0];
var interval = 1000;
var appDir = Path.GetDirectoryName(Environment.ProcessPath) ?? AppContext.BaseDirectory;
var logDir = Path.Combine(appDir, "PingmoniLogs");

for (var i = 1; i < args.Length; i++)
{
    if ((args[i] == "-i" || args[i] == "--interval") && i + 1 < args.Length)
    {
        if (int.TryParse(args[i + 1], out var val) && val > 0)
        {
            interval = val;
            i++;
        }
        else
        {
            Console.Error.WriteLine($"Warning: invalid interval value '{args[i + 1]}', using default {interval}ms.");
            i++;
        }
    }
    else if ((args[i] == "-o" || args[i] == "--output") && i + 1 < args.Length)
    {
        logDir = args[i + 1];
        i++;
    }
    else
    {
        Console.Error.WriteLine($"Warning: unknown argument '{args[i]}' ignored.");
        if (i + 1 < args.Length && !args[i + 1].StartsWith('-'))
            i++;
    }
}

Directory.CreateDirectory(logDir);

var safeTarget = SanitizeFileName(target);

using var cts = new CancellationTokenSource();

Console.CancelKeyPress += (_, e) =>
{
    e.Cancel = true;
    cts.Cancel();
};

var icmpHandle = NativeMethods.IcmpCreateFile();
if (icmpHandle == IntPtr.Zero || icmpHandle == NativeMethods.InvalidHandleValue)
{
    Console.Error.WriteLine("Failed to create ICMP handle. Try running as administrator.");
    return 1;
}

try
{
    bool isDirectIp = IPAddress.TryParse(target, out var parsedIp);
    uint ipAddr = 0;
    DateTime lastDnsResolve = DateTime.MinValue;
    var dnsRefreshInterval = TimeSpan.FromMinutes(5);

    if (isDirectIp)
    {
        ipAddr = BitConverter.ToUInt32(parsedIp!.GetAddressBytes(), 0);
    }
    else
    {
        var (dnsOk, initialIp) = await TryResolveDnsAsync(target, cts.Token);
        if (!dnsOk)
        {
            Console.Error.WriteLine("Initial DNS resolution failed. Exiting.");
            return 1;
        }
        ipAddr = initialIp;
        lastDnsResolve = DateTime.UtcNow;
    }

    var sendData = new byte[32];
    System.Security.Cryptography.RandomNumberGenerator.Fill(sendData);
    var sendOpts = new IpOptionInformation { Ttl = 128, Tos = 0, Flags = 0, OptionsSize = 0, OptionsData = IntPtr.Zero };
    var replyBuf = new byte[1024];
    var ttlOffset = RuntimeInformation.ProcessArchitecture == Architecture.X64 ? 24 : 20;

    await using var logWriter = new LogWriter(logDir, safeTarget);
    var nextPing = DateTime.UtcNow;

    while (!cts.IsCancellationRequested)
    {
        if (!isDirectIp && (DateTime.UtcNow - lastDnsResolve) > dnsRefreshInterval)
        {
            var (dnsOk, newIp) = await TryResolveDnsAsync(target, cts.Token);
            if (dnsOk)
            {
                ipAddr = newIp;
                lastDnsResolve = DateTime.UtcNow;
            }
        }

        var now = DateTime.Now;
        var ts = now.ToString("yyyy-MM-dd HH:mm:ss.fff");

        var reply = NativeMethods.IcmpSendEcho(
            icmpHandle, ipAddr, sendData, (ushort)sendData.Length,
            ref sendOpts, replyBuf, (uint)replyBuf.Length, 4000);

        int lastError = Marshal.GetLastPInvokeError();

        if (reply > 0)
        {
            uint status = BitConverter.ToUInt32(replyBuf, 4);
            uint rtt = BitConverter.ToUInt32(replyBuf, 8);
            ushort dataSize = BitConverter.ToUInt16(replyBuf, 12);
            byte ttl = replyBuf[ttlOffset];

            var success = status == 0;
            var entry = new PingEntry
            {
                Timestamp = ts,
                Target = target,
                Latency = (int)rtt,
                Status = success ? "success" : "failure",
                Details = new PingDetails
                {
                    Bytes = dataSize,
                    Ttl = ttl
                }
            };

            var line = JsonSerializer.Serialize(entry, AppJsonContext.Default.PingEntry);
            await logWriter.WriteAsync(line);

            var replyAddr = new IPAddress(BitConverter.GetBytes(BitConverter.ToUInt32(replyBuf, 0)));
            if (success)
                Console.WriteLine($"[{ts}] Reply from {replyAddr}: bytes={dataSize} time={rtt}ms TTL={ttl}");
            else
                Console.WriteLine($"[{ts}] Reply from {replyAddr}: status={status}");
        }
        else
        {
            var entry = new PingEntry
            {
                Timestamp = ts,
                Target = target,
                Latency = 0,
                Status = "failure",
                Details = new PingDetails
                {
                    Bytes = 0,
                    Ttl = 0
                }
            };

            var line = JsonSerializer.Serialize(entry, AppJsonContext.Default.PingEntry);
            await logWriter.WriteAsync(line);

            Console.WriteLine($"[{ts}] Request timed out. (error={lastError})");
        }

        nextPing = nextPing.AddMilliseconds(interval);
        var delay = nextPing - DateTime.UtcNow;
        if (delay > TimeSpan.Zero)
        {
            try
            {
                await Task.Delay(delay, cts.Token);
            }
            catch (OperationCanceledException)
            {
                break;
            }
        }
        else
        {
            nextPing = DateTime.UtcNow;
        }
    }
}
finally
{
    NativeMethods.IcmpCloseHandle(icmpHandle);
}

return 0;

static async Task<(bool Success, uint IpAddress)> TryResolveDnsAsync(string targetHost, CancellationToken token)
{
    try
    {
        var hostEntry = await Dns.GetHostEntryAsync(targetHost, token);
        var ipv4 = hostEntry.AddressList.FirstOrDefault(a => a.AddressFamily == AddressFamily.InterNetwork);
        if (ipv4 == null)
        {
            Console.Error.WriteLine($"[{DateTime.Now:yyyy-MM-dd HH:mm:ss}] Warning: Failed to resolve IPv4 address for '{targetHost}'.");
            return (false, 0);
        }
        var ip = BitConverter.ToUInt32(ipv4.GetAddressBytes(), 0);
        return (true, ip);
    }
    catch (Exception ex)
    {
        Console.Error.WriteLine($"[{DateTime.Now:yyyy-MM-dd HH:mm:ss}] Warning: DNS resolution failed for '{targetHost}': {ex.Message}");
        return (false, 0);
    }
}

static string SanitizeFileName(string name)
{
    var invalidChars = Path.GetInvalidFileNameChars();
    var sanitized = new System.Text.StringBuilder(name.Length);
    foreach (var ch in name)
    {
        sanitized.Append(invalidChars.Contains(ch) ? '_' : ch);
    }
    return sanitized.ToString();
}

static void PrintHelp()
{
    Console.WriteLine("""
PingMoni - Lightweight ICMP Network Monitoring Tool

Usage:
  PingMoni <target> [options]

Arguments:
  <target>             IP address or hostname to ping (e.g. 192.168.1.1 or www.bing.com)

Options:
  -i, --interval <ms>  Ping interval in milliseconds (default: 1000)
  -o, --output <dir>   Directory path to store daily JSON log files
                       (default: <ExeDir>\PingmoniLogs)
  -h, --help           Show this help message and exit

Examples:
  PingMoni www.bing.com
  PingMoni 192.168.1.1 -i 500
  PingMoni 10.0.0.1 -i 2000 -o D:\NetworkLogs
""");
}

class LogWriter : IAsyncDisposable
{
    private readonly string _logDir;
    private readonly string _safeTarget;
    private string _currentDateStr = "";
    private StreamWriter? _writer;

    public LogWriter(string logDir, string safeTarget)
    {
        _logDir = logDir;
        _safeTarget = safeTarget;
    }

    public async Task WriteAsync(string line)
    {
        var today = DateTime.Now.ToString("yyyy-MM-dd");
        if (_writer == null || _currentDateStr != today)
        {
            await RotateFileAsync(today);
        }

        if (_writer != null)
        {
            try
            {
                await _writer.WriteLineAsync(line);
            }
            catch (Exception ex)
            {
                Console.Error.WriteLine($"Failed to write log: {ex.Message}");
            }
        }
    }

    private async Task RotateFileAsync(string today)
    {
        if (_writer != null)
        {
            try
            {
                await _writer.DisposeAsync();
            }
            catch { }
            _writer = null;
        }

        _currentDateStr = today;
        var filePath = Path.Combine(_logDir, $"{_safeTarget}_{today}.log");
        try
        {
            var stream = new FileStream(filePath, FileMode.Append, FileAccess.Write, FileShare.ReadWrite, 4096, useAsync: true);
            _writer = new StreamWriter(stream, System.Text.Encoding.UTF8) { AutoFlush = true };
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine($"Failed to open log file '{filePath}': {ex.Message}");
        }
    }

    public async ValueTask DisposeAsync()
    {
        if (_writer != null)
        {
            try
            {
                await _writer.DisposeAsync();
            }
            catch { }
            _writer = null;
        }
    }
}

[StructLayout(LayoutKind.Sequential)]
struct IpOptionInformation
{
    public byte Ttl;
    public byte Tos;
    public byte Flags;
    public byte OptionsSize;
    public IntPtr OptionsData;
}

static class NativeMethods
{
    public static readonly IntPtr InvalidHandleValue = new IntPtr(-1);

    [DllImport("iphlpapi.dll", SetLastError = true)]
    public static extern IntPtr IcmpCreateFile();

    [DllImport("iphlpapi.dll", SetLastError = true)]
    public static extern bool IcmpCloseHandle(IntPtr handle);

    [DllImport("iphlpapi.dll", SetLastError = true)]
    public static extern uint IcmpSendEcho(
        IntPtr icmpHandle,
        uint destinationAddress,
        byte[] requestData,
        ushort requestSize,
        ref IpOptionInformation requestOptions,
        byte[] replyBuffer,
        uint replySize,
        uint timeout);
}

[JsonSourceGenerationOptions(PropertyNamingPolicy = JsonKnownNamingPolicy.CamelCase)]
[JsonSerializable(typeof(PingEntry))]
[JsonSerializable(typeof(PingDetails))]
internal partial class AppJsonContext : JsonSerializerContext
{
}

record PingEntry
{
    [JsonPropertyOrder(1)]
    public string Timestamp { get; init; } = "";
    [JsonPropertyOrder(2)]
    public string Target { get; init; } = "";
    [JsonPropertyOrder(3)]
    public int Latency { get; init; }
    [JsonPropertyOrder(4)]
    public string Status { get; init; } = "";
    [JsonPropertyOrder(5)]
    public PingDetails Details { get; init; } = new();
}

record PingDetails
{
    [JsonPropertyOrder(1)]
    public int Bytes { get; init; }
    [JsonPropertyOrder(2)]
    public int Ttl { get; init; }
}