From 8330f075f4f5c2973cdfa2757725d5487ba8ce23 Mon Sep 17 00:00:00 2001
From: Astabol <pritamhalder02@gmail.com>
Date: Sat, 28 Dec 2024 10:31:29 +0000
Subject: [PATCH 1/7] Introduced iostream; migrated to std::cout except
 formatted float value;

---
 src/quicreach.cpp | 70 +++++++++++++++++++++++------------------------
 1 file changed, 35 insertions(+), 35 deletions(-)

diff --git a/src/quicreach.cpp b/src/quicreach.cpp
index 4f0fd99..756a5ec 100644
--- a/src/quicreach.cpp
+++ b/src/quicreach.cpp
@@ -10,6 +10,7 @@
 #define QUICREACH_VERSION_ONLY 1
 
 #include <stdio.h>
+#include <iostream>
 #include <thread>
 #include <vector>
 #include <mutex>
@@ -121,23 +122,22 @@ void AddHostName(char* arg) {
 
 bool ParseConfig(int argc, char **argv) {
     if (argc < 2 || !strcmp(argv[1], "-?") || !strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")) {
-        printf("usage: quicreach <hostname(s)> [options...]\n"
-               " -a, --alpn <alpn>      The ALPN to use for the handshake (def=h3)\n"
-               " -b, --built-in-val     Use built-in TLS validation logic\n"
-               " -c, --csv <file>       Writes CSV results to the given file\n"
-               " -h, --help             Prints this help text\n"
-               " -i, --ip <address>     The IP address to use\n"
-               " -l, --parallel <num>   The numer of parallel hosts to test at once (def=1)\n"
-               " -m, --mtu <mtu>        The initial (IPv6) MTU to use (def=1288)\n"
-               " -p, --port <port>      The UDP port to use (def=443)\n"
-               " -r, --req-all          Require all hostnames to succeed\n"
-               " -R, --repeat <time>    Repeat the requests event N milliseconds\n"
-               " -s, --stats            Print connection statistics\n"
-               " -S, --source <address> Specify a source IP address\n"
-               " -t, --timeout <time>   Timeout in milliseconds to wait for each handshake\n"
-               " -u, --unsecure         Allows unsecure connections\n"
-               " -v, --version          Prints out the version\n"
-              );
+        std::cout << "usage: quicreach <hostname(s)> [options...]\n"
+                  << " -a, --alpn <alpn>      The ALPN to use for the handshake (def=h3)\n"
+                  << " -b, --built-in-val     Use built-in TLS validation logic\n"
+                  << " -c, --csv <file>       Writes CSV results to the given file\n"
+                  << " -h, --help             Prints this help text\n"
+                  << " -i, --ip <address>     The IP address to use\n"
+                  << " -l, --parallel <num>   The numer of parallel hosts to test at once (def=1)\n"
+                  << " -m, --mtu <mtu>        The initial (IPv6) MTU to use (def=1288)\n"
+                  << " -p, --port <port>      The UDP port to use (def=443)\n"
+                  << " -r, --req-all          Require all hostnames to succeed\n"
+                  << " -R, --repeat <time>    Repeat the requests event N milliseconds\n"
+                  << " -s, --stats            Print connection statistics\n"
+                  << " -S, --source <address> Specify a source IP address\n"
+                  << " -t, --timeout <time>   Timeout in milliseconds to wait for each handshake\n"
+                  << " -u, --unsecure         Allows unsecure connections\n"
+                  << " -v, --version          Prints out the version\n";
         return false;
     }
 
@@ -146,59 +146,59 @@ bool ParseConfig(int argc, char **argv) {
             AddHostName(argv[i]);
 
         } else if (!strcmp(argv[i], "--alpn") || !strcmp(argv[i], "-a")) {
-            if (++i >= argc) { printf("Missing ALPN string\n"); return false; }
+            if (++i >= argc) { std::cout << "Missing ALPN string\n"; return false; }
             Config.Alpn = argv[i];
 
         } else if (!strcmp(argv[i], "--built-in-val") || !strcmp(argv[i], "-b")) {
             Config.CredFlags |= QUIC_CREDENTIAL_FLAG_USE_TLS_BUILTIN_CERTIFICATE_VALIDATION;
 
         } else if (!strcmp(argv[i], "--csv") || !strcmp(argv[i], "-c")) {
-            if (++i >= argc) { printf("Missing file name\n"); return false; }
+            if (++i >= argc) { std::cout << "Missing file name\n"; return false; }
             Config.OutCsvFile = argv[i];
 
         } else if (!strcmp(argv[i], "--mtu") || !strcmp(argv[i], "-m")) {
-            if (++i >= argc) { printf("Missing MTU value\n"); return false; }
+            if (++i >= argc) { std::cout << "Missing MTU value\n"; return false; }
             Config.Settings.SetMinimumMtu((uint16_t)atoi(argv[i]));
 
         } else if (!strcmp(argv[i], "--ip") || !strcmp(argv[i], "-i")) {
-            if (++i >= argc) { printf("Missing IP address\n"); return false; }
+            if (++i >= argc) { std::cout << "Missing IP address\n"; return false; }
             if (!QuicAddrFromString(argv[i], 0, &Config.Address.SockAddr)) {
-                printf("Invalid address arg\n"); return false;
+                std::cout << "Invalid address arg\n"; return false;
             }
 
         } else if (!strcmp(argv[i], "--parallel") || !strcmp(argv[i], "-l")) {
-            if (++i >= argc) { printf("Missing parallel number\n"); return false; }
+            if (++i >= argc) { std::cout << "Missing parallel number\n"; return false; }
             Config.Parallel = (uint32_t)atoi(argv[i]);
 
         } else if (!strcmp(argv[i], "--port") || !strcmp(argv[i], "-p")) {
-            if (++i >= argc) { printf("Missing port number\n"); return false; }
+            if (++i >= argc) { std::cout << "Missing port number\n"; return false; }
             Config.Port = (uint16_t)atoi(argv[i]);
 
         } else if (!strcmp(argv[i], "--stats") || !strcmp(argv[i], "-s")) {
             Config.PrintStatistics = true;
 
         } else if (!strcmp(argv[i], "--source") || !strcmp(argv[i], "-S")) {
-            if (++i >= argc) { printf("Missing source address\n"); return false; }
+            if (++i >= argc) { std::cout << "Missing source address\n"; return false; }
             if (!QuicAddrFromString(argv[i], 0, &Config.SourceAddress.SockAddr)) {
-                printf("Invalid source address arg\n"); return false;
+                std::cout << "Invalid source address arg\n"; return false;
             }
 
         } else if (!strcmp(argv[i], "--req-all") || !strcmp(argv[i], "-r")) {
             Config.RequireAll = true;
 
         } else if (!strcmp(argv[i], "--repeat") || !strcmp(argv[i], "-R")) {
-            if (++i >= argc) { printf("Missing repeat arg\n"); return false; }
+            if (++i >= argc) { std::cout << "Missing repeat arg\n"; return false; }
             Config.Repeat = (uint32_t)atoi(argv[i]);
 
         } else if (!strcmp(argv[i], "--timeout") || !strcmp(argv[i], "-t")) {
-            if (++i >= argc) { printf("Missing timeout arg\n"); return false; }
+            if (++i >= argc) { std::cout << "Missing timeout arg\n"; return false; }
             Config.Timeout = (uint32_t)atoi(argv[i]);
 
         } else if (!strcmp(argv[i], "--unsecure") || !strcmp(argv[i], "-u")) {
             Config.CredFlags |= QUIC_CREDENTIAL_FLAG_NO_CERTIFICATE_VALIDATION;
 
         } else if (!strcmp(argv[i], "--version") || !strcmp(argv[i], "-v")) {
-            printf("quicreach " QUICREACH_VERSION "\n");
+            std::cout << "quicreach " QUICREACH_VERSION "\n";
         }
     }
 
@@ -321,7 +321,7 @@ void DumpResultsToFile() {
     if (!File) {
         File = fopen(Config.OutCsvFile, "a"); // Open an existing file
         if (!File) {
-            printf("Failed to open output file: %s\n", Config.OutCsvFile);
+            std::cout << "Failed to open output file: " << Config.OutCsvFile << std::endl;;
             return;
         }
     } else {
@@ -335,7 +335,7 @@ void DumpResultsToFile() {
         Results.TotalCount.load(), Results.ReachableCount.load(), Results.TooMuchCount.load(), Results.MultiRttCount.load(),
         Results.RetryCount.load(), Results.IPv6Count.load(), Results.Quicv2Count.load(), Results.WayTooMuchCount.load());
     fclose(File);
-    printf("\nOutput written to %s\n", Config.OutCsvFile);
+    std::cout << "\nOutput written to " << Config.OutCsvFile << std::endl;
 }
 
 // TODO:
@@ -345,7 +345,7 @@ void DumpResultsToFile() {
 bool TestReachability() {
     MsQuicRegistration Registration("quicreach");
     MsQuicConfiguration Configuration(Registration, Config.Alpn, Config.Settings, MsQuicCredentialConfig(Config.CredFlags));
-    if (!Configuration.IsValid()) { printf("Configuration initializtion failed!\n"); return false; }
+    if (!Configuration.IsValid()) { std::cout << "Configuration initializtion failed!\n"; return false; }
     Configuration.SetVersionSettings(VersionSettings);
     Configuration.SetVersionNegotiationExtEnabled();
 
@@ -372,7 +372,7 @@ bool TestReachability() {
 
     if (Config.PrintStatistics) {
         if (Results.ReachableCount > 1) {
-            printf("\n");
+            std::cout << std::endl;
             printf("%4u domain(s) attempted\n", (uint32_t)Config.HostNames.size());
             printf("%4u domain(s) reachable\n", Results.ReachableCount.load());
             if (Results.MultiRttCount)
@@ -401,13 +401,13 @@ int QUIC_CALL main(int argc, char **argv) {
 
     MsQuic = new (std::nothrow) MsQuicApi();
     if (QUIC_FAILED(MsQuic->GetInitStatus())) {
-        printf("MsQuicApi failed, 0x%x\n", MsQuic->GetInitStatus());
+        std::cout << "MsQuicApi failed, 0x" << MsQuic->GetInitStatus() << std::endl;
         return 1;
     }
 
     bool Result = TestReachability();
     if (!Config.PrintStatistics) {
-        printf("%s\n", Result ? "Success" : "Failure");
+        std::cout << (Result ? "Success" : "Failure") << std::endl;
     }
     delete MsQuic;
     return Result ? 0 : 1;

From 5c949083a2e7a72c40ef83e008c589ebdde0b1c5 Mon Sep 17 00:00:00 2001
From: Astabol <pritamhalder02@gmail.com>
Date: Sat, 28 Dec 2024 20:08:16 +0000
Subject: [PATCH 2/7] introduced <iomanip> for formatting std::cout; Migrated
 formatted output from printf to std::cout;

---
 src/quicreach.cpp | 48 +++++++++++++++++++++++------------------------
 1 file changed, 23 insertions(+), 25 deletions(-)

diff --git a/src/quicreach.cpp b/src/quicreach.cpp
index 756a5ec..fc8335e 100644
--- a/src/quicreach.cpp
+++ b/src/quicreach.cpp
@@ -11,6 +11,7 @@
 
 #include <stdio.h>
 #include <iostream>
+#include <iomanip> /* This Header is Included for Formating Output */
 #include <thread>
 #include <vector>
 #include <mutex>
@@ -291,27 +292,24 @@ struct ReachConnection : public MsQuicConnection {
             QUIC_ADDR_STR AddrStr;
             QuicAddrToString(&RemoteAddr.SockAddr, &AddrStr);
             unique_lock<mutex> lock(Results.Mutex);
-            printf("%30s   %3u.%03u ms   %3u.%03u ms   %3u.%03u ms   %u:%u %u:%u (%2.1fx)  %4u   %4u     %s   %20s   %s\n",
-                HostName,
-                Stats.Rtt / 1000, Stats.Rtt % 1000,
-                InitialTime / 1000, InitialTime % 1000,
-                HandshakeTime / 1000, HandshakeTime % 1000,
-                (uint32_t)Stats.SendTotalPackets,
-                (uint32_t)Stats.RecvTotalPackets,
-                (uint32_t)Stats.SendTotalBytes,
-                (uint32_t)Stats.RecvTotalBytes,
-                Amplification,
-                Stats.HandshakeClientFlight1Bytes,
-                Stats.HandshakeServerFlight1Bytes,
-                Version == QUIC_VERSION_1 ? "v1" : "v2",
-                AddrStr.Address,
-                HandshakeTags);
+            std::cout << std::setw(30) << HostName << "   "
+                      << std::setw(3) << Stats.Rtt / 1000 << "." << std::setfill('0') << std::setw(3) << Stats.Rtt % 1000 << std::setfill(' ') << " ms" << "   "
+                      << std::setw(3) << InitialTime / 1000 << "." << std::setfill('0') << std::setw(3) << InitialTime % 1000 << std::setfill(' ') << " ms" << "   "
+                      << std::setw(3) << HandshakeTime / 1000 << "." << std::setfill('0') << std::setw(3) << HandshakeTime % 1000 << std::setfill(' ') << " ms" << "   "
+                      << (uint32_t)Stats.SendTotalPackets << ":" << (uint32_t)Stats.RecvTotalPackets << " "
+                      << (uint32_t)Stats.SendTotalBytes << ":" << (uint32_t)Stats.RecvTotalBytes << " "
+                      << "(" << std::fixed << std::setprecision(1) << Amplification << "x)" << "  "
+                      << std::setw(4) << Stats.HandshakeClientFlight1Bytes << "   "
+                      << std::setw(4) << Stats.HandshakeServerFlight1Bytes << "     "
+                      << (Version == QUIC_VERSION_1 ? "v1" : "v2") << "   "
+                      << std::setw(20) << AddrStr.Address << "   "
+                      << HandshakeTags << std::endl;
         }
     }
     void OnUnreachable() {
         if (Config.PrintStatistics) {
             unique_lock<mutex> lock(Results.Mutex);
-            printf("%30s\n", HostName);
+            std::cout << std::setw(30) << HostName << std::endl;
         }
     }
 };
@@ -350,7 +348,7 @@ bool TestReachability() {
     Configuration.SetVersionNegotiationExtEnabled();
 
     if (Config.PrintStatistics)
-        printf("%30s          RTT       TIME_I       TIME_H              SEND:RECV    C1     S1    VER                     IP\n", "SERVER");
+        std::cout << setw(30) << "SERVER" << "          RTT       TIME_I       TIME_H              SEND:RECV    C1     S1    VER                     IP\n";
 
     do {
         for (auto HostName : Config.HostNames) {
@@ -373,20 +371,20 @@ bool TestReachability() {
     if (Config.PrintStatistics) {
         if (Results.ReachableCount > 1) {
             std::cout << std::endl;
-            printf("%4u domain(s) attempted\n", (uint32_t)Config.HostNames.size());
-            printf("%4u domain(s) reachable\n", Results.ReachableCount.load());
+            std::cout << std::setw(4) << (uint32_t)Config.HostNames.size() << " domain(s) attempted\n";
+            std::cout << std::setw(4) << Results.ReachableCount.load() << " domain(s) reachable\n";
             if (Results.MultiRttCount)
-                printf("%4u domain(s) required multiple round trips (*)\n", Results.MultiRttCount.load());
+                std::cout << std::setw(4) << Results.MultiRttCount.load() << " domain(s) required multiple round trips (*)\n";
             if (Results.TooMuchCount)
-                printf("%4u domain(s) exceeded amplification limits (!)\n", Results.TooMuchCount.load());
+                std::cout << std::setw(4) << Results.TooMuchCount.load() << " domain(s) exceeded amplification limits (!)\n";
             if (Results.WayTooMuchCount)
-                printf("%4u domain(s) well exceeded amplification limits (5x)\n", Results.WayTooMuchCount.load());
+                std::cout << std::setw(4) << Results.WayTooMuchCount.load() << " domain(s) well exceeded amplification limits (5x)\n";
             if (Results.RetryCount)
-                printf("%4u domain(s) sent RETRY packets (R)\n", Results.RetryCount.load());
+                std::cout << std::setw(4) << Results.RetryCount.load() << " domain(s) sent RETRY packets (R)\n";
             if (Results.IPv6Count)
-                printf("%4u domain(s) used IPv6\n", Results.IPv6Count.load());
+                std::cout << std::setw(4) << Results.IPv6Count.load() << " domain(s) used IPv6\n";
             if (Results.Quicv2Count)
-                printf("%4u domain(s) used QUIC v2\n", Results.Quicv2Count.load());
+                std::cout << std::setw(4) << Results.Quicv2Count.load() << " domain(s) used QUIC v2\n";
         }
     }
 

From 5e500e2dc98046f955f8b021372b5497f80d1d64 Mon Sep 17 00:00:00 2001
From: Astabol <pritamhalder02@gmail.com>
Date: Sun, 29 Dec 2024 11:14:29 +0000
Subject: [PATCH 3/7] Removed "using namespace std"; Have to use thenamespace
 std explicitly;

---
 src/quicreach.cpp | 36 +++++++++++++++++-------------------
 1 file changed, 17 insertions(+), 19 deletions(-)

diff --git a/src/quicreach.cpp b/src/quicreach.cpp
index fc8335e..120b990 100644
--- a/src/quicreach.cpp
+++ b/src/quicreach.cpp
@@ -27,8 +27,6 @@
 #define QUIC_CALL
 #endif
 
-using namespace std;
-
 const MsQuicApi* MsQuic;
 
 // TODO - Make these public?
@@ -67,37 +65,37 @@ struct ReachConfig {
 } Config;
 
 struct ReachResults {
-    atomic<uint32_t> TotalCount {0};
-    atomic<uint32_t> ReachableCount {0};
-    atomic<uint32_t> TooMuchCount {0};
-    atomic<uint32_t> WayTooMuchCount {0};
-    atomic<uint32_t> MultiRttCount {0};
-    atomic<uint32_t> RetryCount {0};
-    atomic<uint32_t> IPv6Count {0};
-    atomic<uint32_t> Quicv2Count {0};
+    std::atomic<uint32_t> TotalCount {0};
+    std::atomic<uint32_t> ReachableCount {0};
+    std::atomic<uint32_t> TooMuchCount {0};
+    std::atomic<uint32_t> WayTooMuchCount {0};
+    std::atomic<uint32_t> MultiRttCount {0};
+    std::atomic<uint32_t> RetryCount {0};
+    std::atomic<uint32_t> IPv6Count {0};
+    std::atomic<uint32_t> Quicv2Count {0};
     // Number of currently active connections.
     uint32_t ActiveCount {0};
     // Synchronization for active count.
-    mutex Mutex;
-    condition_variable NotifyEvent;
+    std::mutex Mutex;
+    std::condition_variable NotifyEvent;
     void WaitForActiveCount() {
         while (ActiveCount >= Config.Parallel) {
-            unique_lock<mutex> lock(Mutex);
+            std::unique_lock<std::mutex> lock(Mutex);
             NotifyEvent.wait(lock, [this]() { return ActiveCount < Config.Parallel; });
         }
     }
     void WaitForAll() {
         while (ActiveCount) {
-            unique_lock<mutex> lock(Mutex);
+            std::unique_lock<std::mutex> lock(Mutex);
             NotifyEvent.wait(lock, [this]() { return ActiveCount == 0; });
         }
     }
     void IncActive() {
-        lock_guard<mutex> lock(Mutex);
+        std::lock_guard<std::mutex> lock(Mutex);
         ++ActiveCount;
     }
     void DecActive() {
-        unique_lock<mutex> lock(Mutex);
+        std::unique_lock<std::mutex> lock(Mutex);
         ActiveCount--;
         NotifyEvent.notify_all();
     }
@@ -291,7 +289,7 @@ struct ReachConnection : public MsQuicConnection {
                 '\0'};
             QUIC_ADDR_STR AddrStr;
             QuicAddrToString(&RemoteAddr.SockAddr, &AddrStr);
-            unique_lock<mutex> lock(Results.Mutex);
+            std::unique_lock<std::mutex> lock(Results.Mutex);
             std::cout << std::setw(30) << HostName << "   "
                       << std::setw(3) << Stats.Rtt / 1000 << "." << std::setfill('0') << std::setw(3) << Stats.Rtt % 1000 << std::setfill(' ') << " ms" << "   "
                       << std::setw(3) << InitialTime / 1000 << "." << std::setfill('0') << std::setw(3) << InitialTime % 1000 << std::setfill(' ') << " ms" << "   "
@@ -308,7 +306,7 @@ struct ReachConnection : public MsQuicConnection {
     }
     void OnUnreachable() {
         if (Config.PrintStatistics) {
-            unique_lock<mutex> lock(Results.Mutex);
+            std::unique_lock<std::mutex> lock(Results.Mutex);
             std::cout << std::setw(30) << HostName << std::endl;
         }
     }
@@ -348,7 +346,7 @@ bool TestReachability() {
     Configuration.SetVersionNegotiationExtEnabled();
 
     if (Config.PrintStatistics)
-        std::cout << setw(30) << "SERVER" << "          RTT       TIME_I       TIME_H              SEND:RECV    C1     S1    VER                     IP\n";
+        std::cout << std::setw(30) << "SERVER" << "          RTT       TIME_I       TIME_H              SEND:RECV    C1     S1    VER                     IP\n";
 
     do {
         for (auto HostName : Config.HostNames) {

From b52c60b3d71ca087cd4ddf0498d35f24c1d723da Mon Sep 17 00:00:00 2001
From: Astabol <pritamhalder02@gmail.com>
Date: Mon, 30 Dec 2024 20:38:51 +0000
Subject: [PATCH 4/7] Fixed Hexadecimal Output

---
 src/quicreach.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/quicreach.cpp b/src/quicreach.cpp
index 120b990..29803a5 100644
--- a/src/quicreach.cpp
+++ b/src/quicreach.cpp
@@ -397,7 +397,7 @@ int QUIC_CALL main(int argc, char **argv) {
 
     MsQuic = new (std::nothrow) MsQuicApi();
     if (QUIC_FAILED(MsQuic->GetInitStatus())) {
-        std::cout << "MsQuicApi failed, 0x" << MsQuic->GetInitStatus() << std::endl;
+        std::cout << "MsQuicApi failed, 0x" << std::hex << MsQuic->GetInitStatus() << std::dec << std::endl;
         return 1;
     }
 

From 12cbe4580e3bfe70f1ff9a05ec65420ffbcd3a74 Mon Sep 17 00:00:00 2001
From: Astabol <pritamhalder02@gmail.com>
Date: Thu, 2 Jan 2025 18:31:41 +0000
Subject: [PATCH 5/7] Revert "Fixed Hexadecimal Output"

This reverts commit b52c60b3d71ca087cd4ddf0498d35f24c1d723da.
---
 src/quicreach.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/quicreach.cpp b/src/quicreach.cpp
index 29803a5..120b990 100644
--- a/src/quicreach.cpp
+++ b/src/quicreach.cpp
@@ -397,7 +397,7 @@ int QUIC_CALL main(int argc, char **argv) {
 
     MsQuic = new (std::nothrow) MsQuicApi();
     if (QUIC_FAILED(MsQuic->GetInitStatus())) {
-        std::cout << "MsQuicApi failed, 0x" << std::hex << MsQuic->GetInitStatus() << std::dec << std::endl;
+        std::cout << "MsQuicApi failed, 0x" << MsQuic->GetInitStatus() << std::endl;
         return 1;
     }
 

From 028e0f8a96a94b0a3592ca08eadecba523fedbc6 Mon Sep 17 00:00:00 2001
From: Astabol <pritamhalder02@gmail.com>
Date: Thu, 2 Jan 2025 18:34:22 +0000
Subject: [PATCH 6/7] Revert "introduced <iomanip> for formatting std::cout;
 Migrated formatted output from printf to std::cout;"

This reverts commit 5c949083a2e7a72c40ef83e008c589ebdde0b1c5.
---
 src/quicreach.cpp | 48 ++++++++++++++++++++++++-----------------------
 1 file changed, 25 insertions(+), 23 deletions(-)

diff --git a/src/quicreach.cpp b/src/quicreach.cpp
index 120b990..0207615 100644
--- a/src/quicreach.cpp
+++ b/src/quicreach.cpp
@@ -11,7 +11,6 @@
 
 #include <stdio.h>
 #include <iostream>
-#include <iomanip> /* This Header is Included for Formating Output */
 #include <thread>
 #include <vector>
 #include <mutex>
@@ -290,24 +289,27 @@ struct ReachConnection : public MsQuicConnection {
             QUIC_ADDR_STR AddrStr;
             QuicAddrToString(&RemoteAddr.SockAddr, &AddrStr);
             std::unique_lock<std::mutex> lock(Results.Mutex);
-            std::cout << std::setw(30) << HostName << "   "
-                      << std::setw(3) << Stats.Rtt / 1000 << "." << std::setfill('0') << std::setw(3) << Stats.Rtt % 1000 << std::setfill(' ') << " ms" << "   "
-                      << std::setw(3) << InitialTime / 1000 << "." << std::setfill('0') << std::setw(3) << InitialTime % 1000 << std::setfill(' ') << " ms" << "   "
-                      << std::setw(3) << HandshakeTime / 1000 << "." << std::setfill('0') << std::setw(3) << HandshakeTime % 1000 << std::setfill(' ') << " ms" << "   "
-                      << (uint32_t)Stats.SendTotalPackets << ":" << (uint32_t)Stats.RecvTotalPackets << " "
-                      << (uint32_t)Stats.SendTotalBytes << ":" << (uint32_t)Stats.RecvTotalBytes << " "
-                      << "(" << std::fixed << std::setprecision(1) << Amplification << "x)" << "  "
-                      << std::setw(4) << Stats.HandshakeClientFlight1Bytes << "   "
-                      << std::setw(4) << Stats.HandshakeServerFlight1Bytes << "     "
-                      << (Version == QUIC_VERSION_1 ? "v1" : "v2") << "   "
-                      << std::setw(20) << AddrStr.Address << "   "
-                      << HandshakeTags << std::endl;
+            printf("%30s   %3u.%03u ms   %3u.%03u ms   %3u.%03u ms   %u:%u %u:%u (%2.1fx)  %4u   %4u     %s   %20s   %s\n",
+                HostName,
+                Stats.Rtt / 1000, Stats.Rtt % 1000,
+                InitialTime / 1000, InitialTime % 1000,
+                HandshakeTime / 1000, HandshakeTime % 1000,
+                (uint32_t)Stats.SendTotalPackets,
+                (uint32_t)Stats.RecvTotalPackets,
+                (uint32_t)Stats.SendTotalBytes,
+                (uint32_t)Stats.RecvTotalBytes,
+                Amplification,
+                Stats.HandshakeClientFlight1Bytes,
+                Stats.HandshakeServerFlight1Bytes,
+                Version == QUIC_VERSION_1 ? "v1" : "v2",
+                AddrStr.Address,
+                HandshakeTags);
         }
     }
     void OnUnreachable() {
         if (Config.PrintStatistics) {
             std::unique_lock<std::mutex> lock(Results.Mutex);
-            std::cout << std::setw(30) << HostName << std::endl;
+            printf("%30s\n", HostName);
         }
     }
 };
@@ -346,7 +348,7 @@ bool TestReachability() {
     Configuration.SetVersionNegotiationExtEnabled();
 
     if (Config.PrintStatistics)
-        std::cout << std::setw(30) << "SERVER" << "          RTT       TIME_I       TIME_H              SEND:RECV    C1     S1    VER                     IP\n";
+        printf("%30s          RTT       TIME_I       TIME_H              SEND:RECV    C1     S1    VER                     IP\n", "SERVER");
 
     do {
         for (auto HostName : Config.HostNames) {
@@ -369,20 +371,20 @@ bool TestReachability() {
     if (Config.PrintStatistics) {
         if (Results.ReachableCount > 1) {
             std::cout << std::endl;
-            std::cout << std::setw(4) << (uint32_t)Config.HostNames.size() << " domain(s) attempted\n";
-            std::cout << std::setw(4) << Results.ReachableCount.load() << " domain(s) reachable\n";
+            printf("%4u domain(s) attempted\n", (uint32_t)Config.HostNames.size());
+            printf("%4u domain(s) reachable\n", Results.ReachableCount.load());
             if (Results.MultiRttCount)
-                std::cout << std::setw(4) << Results.MultiRttCount.load() << " domain(s) required multiple round trips (*)\n";
+                printf("%4u domain(s) required multiple round trips (*)\n", Results.MultiRttCount.load());
             if (Results.TooMuchCount)
-                std::cout << std::setw(4) << Results.TooMuchCount.load() << " domain(s) exceeded amplification limits (!)\n";
+                printf("%4u domain(s) exceeded amplification limits (!)\n", Results.TooMuchCount.load());
             if (Results.WayTooMuchCount)
-                std::cout << std::setw(4) << Results.WayTooMuchCount.load() << " domain(s) well exceeded amplification limits (5x)\n";
+                printf("%4u domain(s) well exceeded amplification limits (5x)\n", Results.WayTooMuchCount.load());
             if (Results.RetryCount)
-                std::cout << std::setw(4) << Results.RetryCount.load() << " domain(s) sent RETRY packets (R)\n";
+                printf("%4u domain(s) sent RETRY packets (R)\n", Results.RetryCount.load());
             if (Results.IPv6Count)
-                std::cout << std::setw(4) << Results.IPv6Count.load() << " domain(s) used IPv6\n";
+                printf("%4u domain(s) used IPv6\n", Results.IPv6Count.load());
             if (Results.Quicv2Count)
-                std::cout << std::setw(4) << Results.Quicv2Count.load() << " domain(s) used QUIC v2\n";
+                printf("%4u domain(s) used QUIC v2\n", Results.Quicv2Count.load());
         }
     }
 

From a42ece47e8df3b4665c38290e7a94f64cbae3c4d Mon Sep 17 00:00:00 2001
From: Astabol <pritamhalder02@gmail.com>
Date: Thu, 2 Jan 2025 18:34:45 +0000
Subject: [PATCH 7/7] Revert "Introduced iostream; migrated to std::cout except
 formatted float value;"

This reverts commit 8330f075f4f5c2973cdfa2757725d5487ba8ce23.
---
 src/quicreach.cpp | 70 +++++++++++++++++++++++------------------------
 1 file changed, 35 insertions(+), 35 deletions(-)

diff --git a/src/quicreach.cpp b/src/quicreach.cpp
index 0207615..e5a0812 100644
--- a/src/quicreach.cpp
+++ b/src/quicreach.cpp
@@ -10,7 +10,6 @@
 #define QUICREACH_VERSION_ONLY 1
 
 #include <stdio.h>
-#include <iostream>
 #include <thread>
 #include <vector>
 #include <mutex>
@@ -120,22 +119,23 @@ void AddHostName(char* arg) {
 
 bool ParseConfig(int argc, char **argv) {
     if (argc < 2 || !strcmp(argv[1], "-?") || !strcmp(argv[1], "-h") || !strcmp(argv[1], "--help")) {
-        std::cout << "usage: quicreach <hostname(s)> [options...]\n"
-                  << " -a, --alpn <alpn>      The ALPN to use for the handshake (def=h3)\n"
-                  << " -b, --built-in-val     Use built-in TLS validation logic\n"
-                  << " -c, --csv <file>       Writes CSV results to the given file\n"
-                  << " -h, --help             Prints this help text\n"
-                  << " -i, --ip <address>     The IP address to use\n"
-                  << " -l, --parallel <num>   The numer of parallel hosts to test at once (def=1)\n"
-                  << " -m, --mtu <mtu>        The initial (IPv6) MTU to use (def=1288)\n"
-                  << " -p, --port <port>      The UDP port to use (def=443)\n"
-                  << " -r, --req-all          Require all hostnames to succeed\n"
-                  << " -R, --repeat <time>    Repeat the requests event N milliseconds\n"
-                  << " -s, --stats            Print connection statistics\n"
-                  << " -S, --source <address> Specify a source IP address\n"
-                  << " -t, --timeout <time>   Timeout in milliseconds to wait for each handshake\n"
-                  << " -u, --unsecure         Allows unsecure connections\n"
-                  << " -v, --version          Prints out the version\n";
+        printf("usage: quicreach <hostname(s)> [options...]\n"
+               " -a, --alpn <alpn>      The ALPN to use for the handshake (def=h3)\n"
+               " -b, --built-in-val     Use built-in TLS validation logic\n"
+               " -c, --csv <file>       Writes CSV results to the given file\n"
+               " -h, --help             Prints this help text\n"
+               " -i, --ip <address>     The IP address to use\n"
+               " -l, --parallel <num>   The numer of parallel hosts to test at once (def=1)\n"
+               " -m, --mtu <mtu>        The initial (IPv6) MTU to use (def=1288)\n"
+               " -p, --port <port>      The UDP port to use (def=443)\n"
+               " -r, --req-all          Require all hostnames to succeed\n"
+               " -R, --repeat <time>    Repeat the requests event N milliseconds\n"
+               " -s, --stats            Print connection statistics\n"
+               " -S, --source <address> Specify a source IP address\n"
+               " -t, --timeout <time>   Timeout in milliseconds to wait for each handshake\n"
+               " -u, --unsecure         Allows unsecure connections\n"
+               " -v, --version          Prints out the version\n"
+              );
         return false;
     }
 
@@ -144,59 +144,59 @@ bool ParseConfig(int argc, char **argv) {
             AddHostName(argv[i]);
 
         } else if (!strcmp(argv[i], "--alpn") || !strcmp(argv[i], "-a")) {
-            if (++i >= argc) { std::cout << "Missing ALPN string\n"; return false; }
+            if (++i >= argc) { printf("Missing ALPN string\n"); return false; }
             Config.Alpn = argv[i];
 
         } else if (!strcmp(argv[i], "--built-in-val") || !strcmp(argv[i], "-b")) {
             Config.CredFlags |= QUIC_CREDENTIAL_FLAG_USE_TLS_BUILTIN_CERTIFICATE_VALIDATION;
 
         } else if (!strcmp(argv[i], "--csv") || !strcmp(argv[i], "-c")) {
-            if (++i >= argc) { std::cout << "Missing file name\n"; return false; }
+            if (++i >= argc) { printf("Missing file name\n"); return false; }
             Config.OutCsvFile = argv[i];
 
         } else if (!strcmp(argv[i], "--mtu") || !strcmp(argv[i], "-m")) {
-            if (++i >= argc) { std::cout << "Missing MTU value\n"; return false; }
+            if (++i >= argc) { printf("Missing MTU value\n"); return false; }
             Config.Settings.SetMinimumMtu((uint16_t)atoi(argv[i]));
 
         } else if (!strcmp(argv[i], "--ip") || !strcmp(argv[i], "-i")) {
-            if (++i >= argc) { std::cout << "Missing IP address\n"; return false; }
+            if (++i >= argc) { printf("Missing IP address\n"); return false; }
             if (!QuicAddrFromString(argv[i], 0, &Config.Address.SockAddr)) {
-                std::cout << "Invalid address arg\n"; return false;
+                printf("Invalid address arg\n"); return false;
             }
 
         } else if (!strcmp(argv[i], "--parallel") || !strcmp(argv[i], "-l")) {
-            if (++i >= argc) { std::cout << "Missing parallel number\n"; return false; }
+            if (++i >= argc) { printf("Missing parallel number\n"); return false; }
             Config.Parallel = (uint32_t)atoi(argv[i]);
 
         } else if (!strcmp(argv[i], "--port") || !strcmp(argv[i], "-p")) {
-            if (++i >= argc) { std::cout << "Missing port number\n"; return false; }
+            if (++i >= argc) { printf("Missing port number\n"); return false; }
             Config.Port = (uint16_t)atoi(argv[i]);
 
         } else if (!strcmp(argv[i], "--stats") || !strcmp(argv[i], "-s")) {
             Config.PrintStatistics = true;
 
         } else if (!strcmp(argv[i], "--source") || !strcmp(argv[i], "-S")) {
-            if (++i >= argc) { std::cout << "Missing source address\n"; return false; }
+            if (++i >= argc) { printf("Missing source address\n"); return false; }
             if (!QuicAddrFromString(argv[i], 0, &Config.SourceAddress.SockAddr)) {
-                std::cout << "Invalid source address arg\n"; return false;
+                printf("Invalid source address arg\n"); return false;
             }
 
         } else if (!strcmp(argv[i], "--req-all") || !strcmp(argv[i], "-r")) {
             Config.RequireAll = true;
 
         } else if (!strcmp(argv[i], "--repeat") || !strcmp(argv[i], "-R")) {
-            if (++i >= argc) { std::cout << "Missing repeat arg\n"; return false; }
+            if (++i >= argc) { printf("Missing repeat arg\n"); return false; }
             Config.Repeat = (uint32_t)atoi(argv[i]);
 
         } else if (!strcmp(argv[i], "--timeout") || !strcmp(argv[i], "-t")) {
-            if (++i >= argc) { std::cout << "Missing timeout arg\n"; return false; }
+            if (++i >= argc) { printf("Missing timeout arg\n"); return false; }
             Config.Timeout = (uint32_t)atoi(argv[i]);
 
         } else if (!strcmp(argv[i], "--unsecure") || !strcmp(argv[i], "-u")) {
             Config.CredFlags |= QUIC_CREDENTIAL_FLAG_NO_CERTIFICATE_VALIDATION;
 
         } else if (!strcmp(argv[i], "--version") || !strcmp(argv[i], "-v")) {
-            std::cout << "quicreach " QUICREACH_VERSION "\n";
+            printf("quicreach " QUICREACH_VERSION "\n");
         }
     }
 
@@ -319,7 +319,7 @@ void DumpResultsToFile() {
     if (!File) {
         File = fopen(Config.OutCsvFile, "a"); // Open an existing file
         if (!File) {
-            std::cout << "Failed to open output file: " << Config.OutCsvFile << std::endl;;
+            printf("Failed to open output file: %s\n", Config.OutCsvFile);
             return;
         }
     } else {
@@ -333,7 +333,7 @@ void DumpResultsToFile() {
         Results.TotalCount.load(), Results.ReachableCount.load(), Results.TooMuchCount.load(), Results.MultiRttCount.load(),
         Results.RetryCount.load(), Results.IPv6Count.load(), Results.Quicv2Count.load(), Results.WayTooMuchCount.load());
     fclose(File);
-    std::cout << "\nOutput written to " << Config.OutCsvFile << std::endl;
+    printf("\nOutput written to %s\n", Config.OutCsvFile);
 }
 
 // TODO:
@@ -343,7 +343,7 @@ void DumpResultsToFile() {
 bool TestReachability() {
     MsQuicRegistration Registration("quicreach");
     MsQuicConfiguration Configuration(Registration, Config.Alpn, Config.Settings, MsQuicCredentialConfig(Config.CredFlags));
-    if (!Configuration.IsValid()) { std::cout << "Configuration initializtion failed!\n"; return false; }
+    if (!Configuration.IsValid()) { printf("Configuration initializtion failed!\n"); return false; }
     Configuration.SetVersionSettings(VersionSettings);
     Configuration.SetVersionNegotiationExtEnabled();
 
@@ -370,7 +370,7 @@ bool TestReachability() {
 
     if (Config.PrintStatistics) {
         if (Results.ReachableCount > 1) {
-            std::cout << std::endl;
+            printf("\n");
             printf("%4u domain(s) attempted\n", (uint32_t)Config.HostNames.size());
             printf("%4u domain(s) reachable\n", Results.ReachableCount.load());
             if (Results.MultiRttCount)
@@ -399,13 +399,13 @@ int QUIC_CALL main(int argc, char **argv) {
 
     MsQuic = new (std::nothrow) MsQuicApi();
     if (QUIC_FAILED(MsQuic->GetInitStatus())) {
-        std::cout << "MsQuicApi failed, 0x" << MsQuic->GetInitStatus() << std::endl;
+        printf("MsQuicApi failed, 0x%x\n", MsQuic->GetInitStatus());
         return 1;
     }
 
     bool Result = TestReachability();
     if (!Config.PrintStatistics) {
-        std::cout << (Result ? "Success" : "Failure") << std::endl;
+        printf("%s\n", Result ? "Success" : "Failure");
     }
     delete MsQuic;
     return Result ? 0 : 1;