network_quality.hpp

Go to the documentation of this file.

/*
 * BastionGuard™
 * Copyright (C) 2025–2026 Calogero Scarnà
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 *
 * BastionGuard™ is a trademark of Calogero Scarnà.
 * The BastionGuard™ name and branding are not licensed under the GPL.
 */
 
#pragma once
#include <atomic>
#include <string>
#include <cmath>
#include <algorithm>
 
 
struct NetQuality {
    std::atomic<double> ewma_rtt_ms{50.0};
    std::atomic<double> ewma_loss{0.0};
    std::atomic<int>    samples{3};
 
 
    void update_sample(double rtt_ms, bool success) {
        const double alpha = 0.55;
        int s = samples.fetch_add(1, std::memory_order_relaxed) + 1;
 
        double prev_rtt  = ewma_rtt_ms.load(std::memory_order_relaxed);
        double prev_loss = ewma_loss.load(std::memory_order_relaxed);
 
 
        rtt_ms = std::clamp(rtt_ms, 1.0, 2000.0);
 
        double new_rtt  = alpha * rtt_ms + (1.0 - alpha) * prev_rtt;
        double new_loss = alpha * (success ? 0.0 : 1.0) + (1.0 - alpha) * prev_loss;
 
        ewma_rtt_ms.store(new_rtt, std::memory_order_relaxed);
        ewma_loss.store(new_loss, std::memory_order_relaxed);
    }
 
 
    std::string classify_network() const {
        double rtt  = ewma_rtt_ms.load(std::memory_order_relaxed);
        double loss = ewma_loss.load(std::memory_order_relaxed);
 
        if (samples.load(std::memory_order_relaxed) < 3)
            return "bootstrap";
 
        if (rtt < 25.0 && loss < 0.005)
            return "fiber-ftth";
        if (rtt < 50.0 && loss < 0.008)
            return "ethernet";
        if (rtt < 120.0 && loss < 0.015)
            return "wifi";
        if (rtt < 200.0 && loss < 0.03)
            return "dsl/adsl";
        if (rtt < 400.0 && loss < 0.05)
            return "fwa-4g";
        if (rtt < 700.0 && loss < 0.08)
            return "5g";
        return "unstable";
    }
 
 
    int recommended_dns_timeout() const {
        std::string net = classify_network();
        if (net == "fiber-ftth") return 60;
        if (net == "ethernet")   return 80;
        if (net == "wifi")       return 120;
        if (net == "dsl/adsl")   return 160;
        if (net == "fwa-4g")     return 200;
        if (net == "5g")         return 150;
        if (net == "bootstrap")  return 100;
        return 250;
    }
 
 
    int recommended_https_timeout() const {
        std::string net = classify_network();
        if (net == "fiber-ftth") return 400;
        if (net == "ethernet")   return 600;
        if (net == "wifi")       return 900;
        if (net == "dsl/adsl")   return 1200;
        if (net == "fwa-4g")     return 1500;
        if (net == "5g")         return 1100;
        if (net == "bootstrap")  return 800;
        return 1800;
    }
 
 
    bool is_mobile_like() const {
        double rtt  = ewma_rtt_ms.load(std::memory_order_relaxed);
        double loss = ewma_loss.load(std::memory_order_relaxed);
        return (rtt > 250.0) || (loss > 0.05);
    }
 
 
    double rtt_ms() const { return ewma_rtt_ms.load(std::memory_order_relaxed); }
    double loss()   const { return ewma_loss.load(std::memory_order_relaxed); }
};
 
 
extern NetQuality g_net_quality;