fix: support TCP RTT on Windows

Author: popstarfreas

.github/workflows/nodejs.yml

@@ -14,14 +14,18 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
+    - uses: pnpm/action-setup@v4
+      with:
+        version: 10.29.3
     - name: Use Node.js ${{ matrix.node-version }}
       uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
-    - name: npm install, build, and test
+        cache: pnpm
+    - name: pnpm install, build, and test
       run: |
-        npm install
-        npm run test
+        pnpm install --frozen-lockfile
+        pnpm test
       env:
         CI: true
 
@@ -35,14 +39,18 @@ jobs:
 
     steps:
     - uses: actions/checkout@v4
+    - uses: pnpm/action-setup@v4
+      with:
+        version: 10.29.3
     - name: Use Node.js ${{ matrix.node-version }}
       uses: actions/setup-node@v4
       with:
         node-version: ${{ matrix.node-version }}
+        cache: pnpm
     - name: Build native prebuild
       run: |
-        npm install
-        npm run native:prebuild
+        pnpm install --frozen-lockfile
+        pnpm native:prebuild
       env:
         CI: true
     - uses: actions/upload-artifact@v4

app/dimensions/tcprtt/nativeprovider.ts

@@ -14,6 +14,7 @@ interface NativeTcpRttResult {
 
 interface NativeTcpRttAddon {
   getTcpRttMicros(fd: number): NativeTcpRttResult;
+  getTcpRttMicrosByEndpoint?: (localAddress: string, localPort: number, remoteAddress: string, remotePort: number) => NativeTcpRttResult;
 }
 
 type SocketWithHandle = Net.Socket & {
@@ -27,6 +28,28 @@ function getSocketFd(socket: Net.Socket): number | null {
   return typeof fd === "number" && Number.isFinite(fd) ? fd : null;
 }
 
+function getSocketEndpoint(socket: Net.Socket): { localAddress: string, localPort: number, remoteAddress: string, remotePort: number } | null {
+  const localAddress = socket.localAddress;
+  const localPort = socket.localPort;
+  const remoteAddress = socket.remoteAddress;
+  const remotePort = socket.remotePort;
+  if (
+    typeof localAddress !== "string" ||
+    typeof localPort !== "number" ||
+    typeof remoteAddress !== "string" ||
+    typeof remotePort !== "number"
+  ) {
+    return null;
+  }
+
+  return {
+    localAddress,
+    localPort,
+    remoteAddress,
+    remotePort,
+  };
+}
+
 function getPackageRoot(): string {
   const dirname = path.dirname(fileURLToPath(import.meta.url));
   return path.resolve(dirname, "../../..");
@@ -55,6 +78,10 @@ class NativeTcpRttProvider implements TcpRttProvider {
       return unavailableTcpRttSample(this.loadError ?? "native TCP RTT addon unavailable");
     }
 
+    if (process.platform === "win32") {
+      return this.sampleWindows(socket);
+    }
+
     const fd = getSocketFd(socket);
     if (fd === null) {
       return unavailableTcpRttSample("socket file descriptor unavailable");
@@ -73,6 +100,30 @@ class NativeTcpRttProvider implements TcpRttProvider {
 
     return tcpInfoSample(result.rttMicros);
   }
+
+  private sampleWindows(socket: Net.Socket): TcpRttSample {
+    if (this.addon?.getTcpRttMicrosByEndpoint === undefined) {
+      return unavailableTcpRttSample("native TCP RTT addon does not support Windows endpoint lookup");
+    }
+
+    const endpoint = getSocketEndpoint(socket);
+    if (endpoint === null) {
+      return unavailableTcpRttSample("socket endpoint unavailable");
+    }
+
+    let result: NativeTcpRttResult;
+    try {
+      result = this.addon.getTcpRttMicrosByEndpoint(endpoint.localAddress, endpoint.localPort, endpoint.remoteAddress, endpoint.remotePort);
+    } catch (e) {
+      return unavailableTcpRttSample(ErrorHelper.toMessage(e));
+    }
+
+    if (!result.available || typeof result.rttMicros !== "number") {
+      return unavailableTcpRttSample(result.error ?? "TCP RTT unavailable");
+    }
+
+    return tcpInfoSample(result.rttMicros);
+  }
 }
 
 export default NativeTcpRttProvider;

makerelease.sh

@@ -12,8 +12,7 @@ cp native-addon/binding.gyp release/native-addon/binding.gyp
 cp native-addon/tcp_rtt.cc release/native-addon/tcp_rtt.cc
 if [ -d native-addon/prebuilds ]; then
   cp -r native-addon/prebuilds release/native-addon/prebuilds
-fi
-if [ -d native-addon/build/Release ]; then
+elif [ -d native-addon/build/Release ]; then
   mkdir -p release/native-addon/build
   cp -r native-addon/build/Release release/native-addon/build/Release
 fi

native-addon/binding.gyp

@@ -13,7 +13,8 @@
           "OS==\"win\"",
           {
             "libraries": [
-              "ws2_32.lib"
+              "ws2_32.lib",
+              "iphlpapi.lib"
             ]
           }
         ]

native-addon/tcp_rtt.cc

@@ -11,6 +11,9 @@
 #include <winsock2.h>
 #include <ws2tcpip.h>
 #include <mstcpip.h>
+#include <iphlpapi.h>
+#include <tcpestats.h>
+#include <vector>
 #else
 #include <errno.h>
 #include <limits.h>
@@ -59,6 +62,177 @@ static napi_value Unavailable(napi_env env, const char* error) {
   return result;
 }
 
+#if defined(_WIN32)
+static void FormatWindowsError(const char* operation, DWORD error, char* message, size_t message_size) {
+  snprintf(message, message_size, "%s failed: %lu", operation, static_cast<unsigned long>(error));
+}
+
+static bool GetStringArg(napi_env env, napi_value value, char* buffer, size_t buffer_size) {
+  size_t length = 0;
+  if (napi_get_value_string_utf8(env, value, buffer, buffer_size, &length) != napi_ok) {
+    return false;
+  }
+
+  return length > 0 && length < buffer_size;
+}
+
+static bool GetPortArg(napi_env env, napi_value value, uint16_t* port) {
+  uint32_t port_value = 0;
+  if (napi_get_value_uint32(env, value, &port_value) != napi_ok) {
+    return false;
+  }
+
+  if (port_value == 0 || port_value > 65535) {
+    return false;
+  }
+
+  *port = static_cast<uint16_t>(port_value);
+  return true;
+}
+
+static bool ParseIpv4Address(const char* address, DWORD* parsed_address) {
+  const char* normalized_address = address;
+  if (strncmp(address, "::ffff:", 7) == 0) {
+    normalized_address = address + 7;
+  }
+
+  IN_ADDR in_address;
+  if (InetPtonA(AF_INET, normalized_address, &in_address) != 1) {
+    return false;
+  }
+
+  *parsed_address = in_address.S_un.S_addr;
+  return true;
+}
+
+static bool FindTcpRowByEndpoint(
+  DWORD local_address,
+  uint16_t local_port,
+  DWORD remote_address,
+  uint16_t remote_port,
+  MIB_TCPROW* row,
+  char* error,
+  size_t error_size
+) {
+  DWORD table_size = 0;
+  DWORD result = GetTcpTable(nullptr, &table_size, FALSE);
+  if (result != ERROR_INSUFFICIENT_BUFFER) {
+    FormatWindowsError("GetTcpTable(size)", result, error, error_size);
+    return false;
+  }
+
+  std::vector<unsigned char> buffer(table_size);
+  PMIB_TCPTABLE table = reinterpret_cast<PMIB_TCPTABLE>(buffer.data());
+  result = GetTcpTable(table, &table_size, FALSE);
+  if (result != NO_ERROR) {
+    FormatWindowsError("GetTcpTable", result, error, error_size);
+    return false;
+  }
+
+  const DWORD local_port_network_order = static_cast<DWORD>(htons(local_port));
+  const DWORD remote_port_network_order = static_cast<DWORD>(htons(remote_port));
+  for (DWORD i = 0; i < table->dwNumEntries; i++) {
+    const MIB_TCPROW& candidate = table->table[i];
+    if (
+      candidate.dwLocalAddr == local_address &&
+      candidate.dwLocalPort == local_port_network_order &&
+      candidate.dwRemoteAddr == remote_address &&
+      candidate.dwRemotePort == remote_port_network_order
+    ) {
+      *row = candidate;
+      return true;
+    }
+  }
+
+  snprintf(error, error_size, "TCP connection not found in IPv4 table");
+  return false;
+}
+
+static napi_value GetTcpRttMicrosByEndpoint(napi_env env, napi_callback_info info) {
+  size_t argc = 4;
+  napi_value args[4];
+  napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
+  if (argc < 4) {
+    return Unavailable(env, "local address, local port, remote address, and remote port arguments are required");
+  }
+
+  char local_address_string[96];
+  char remote_address_string[96];
+  if (!GetStringArg(env, args[0], local_address_string, sizeof(local_address_string))) {
+    return Unavailable(env, "local address must be a non-empty string");
+  }
+
+  uint16_t local_port = 0;
+  if (!GetPortArg(env, args[1], &local_port)) {
+    return Unavailable(env, "local port must be a TCP port from 1 to 65535");
+  }
+
+  if (!GetStringArg(env, args[2], remote_address_string, sizeof(remote_address_string))) {
+    return Unavailable(env, "remote address must be a non-empty string");
+  }
+
+  uint16_t remote_port = 0;
+  if (!GetPortArg(env, args[3], &remote_port)) {
+    return Unavailable(env, "remote port must be a TCP port from 1 to 65535");
+  }
+
+  DWORD local_address = 0;
+  if (!ParseIpv4Address(local_address_string, &local_address)) {
+    return Unavailable(env, "local address is not an IPv4 address");
+  }
+
+  DWORD remote_address = 0;
+  if (!ParseIpv4Address(remote_address_string, &remote_address)) {
+    return Unavailable(env, "remote address is not an IPv4 address");
+  }
+
+  char error[128];
+  MIB_TCPROW row;
+  memset(&row, 0, sizeof(row));
+  if (!FindTcpRowByEndpoint(local_address, local_port, remote_address, remote_port, &row, error, sizeof(error))) {
+    return Unavailable(env, error);
+  }
+
+  TCP_ESTATS_FINE_RTT_RW_v0 rw;
+  memset(&rw, 0, sizeof(rw));
+  rw.EnableCollection = TRUE;
+  DWORD result = SetPerTcpConnectionEStats(
+    &row,
+    TcpConnectionEstatsFineRtt,
+    reinterpret_cast<PUCHAR>(&rw),
+    0,
+    sizeof(rw),
+    0
+  );
+  if (result != NO_ERROR) {
+    FormatWindowsError("SetPerTcpConnectionEStats(TcpConnectionEstatsFineRtt)", result, error, sizeof(error));
+    return Unavailable(env, error);
+  }
+
+  TCP_ESTATS_FINE_RTT_ROD_v0 rod;
+  memset(&rod, 0, sizeof(rod));
+  result = GetPerTcpConnectionEStats(
+    &row,
+    TcpConnectionEstatsFineRtt,
+    nullptr,
+    0,
+    0,
+    nullptr,
+    0,
+    0,
+    reinterpret_cast<PUCHAR>(&rod),
+    0,
+    sizeof(rod)
+  );
+  if (result != NO_ERROR) {
+    FormatWindowsError("GetPerTcpConnectionEStats(TcpConnectionEstatsFineRtt)", result, error, sizeof(error));
+    return Unavailable(env, error);
+  }
+
+  return Available(env, rod.SumRtt);
+}
+#endif
+
 static napi_value GetTcpRttMicros(napi_env env, napi_callback_info info) {
   size_t argc = 1;
   napi_value args[1];
@@ -127,6 +301,10 @@ static napi_value Init(napi_env env, napi_value exports) {
   napi_value fn;
   napi_create_function(env, nullptr, 0, GetTcpRttMicros, nullptr, &fn);
   napi_set_named_property(env, exports, "getTcpRttMicros", fn);
+#if defined(_WIN32)
+  napi_create_function(env, nullptr, 0, GetTcpRttMicrosByEndpoint, nullptr, &fn);
+  napi_set_named_property(env, exports, "getTcpRttMicrosByEndpoint", fn);
+#endif
   return exports;
 }
 

package.json

@@ -2,6 +2,7 @@
   "name": "@popstarfreas/dimensions",
   "version": "7.1.0-alpha.3",
   "type": "module",
+  "packageManager": "pnpm@10.29.3",
   "repository": {
     "type": "git",
     "url": "git://github.com/popstarfreas/Dimensions.git"