Default Win32 transport to WinHTTP and harden request lifetimes

.github/scripts/run-with-timeout.ps1

@@ -0,0 +1,253 @@
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory = $true)]
+    [ValidateNotNullOrEmpty()]
+    [string]$FilePath,
+
+    [ValidateRange(1, 86400)]
+    [int]$TimeoutSeconds = 600,
+
+    [ValidateRange(1, 16)]
+    [int]$ProcessCount = 1,
+
+    [ValidateNotNullOrEmpty()]
+    [string]$DiagnosticsDirectory = "test-diagnostics",
+
+    [ValidateNotNullOrEmpty()]
+    [string]$Label = [System.IO.Path]::GetFileNameWithoutExtension($FilePath),
+
+    [string]$ProcessArguments = ""
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+
+if (-not ("RunWithTimeout.NativeMethods" -as [type])) {
+    Add-Type -TypeDefinition @"
+namespace RunWithTimeout
+{
+    using System;
+    using System.Runtime.InteropServices;
+
+    public static class NativeMethods
+    {
+        [DllImport("kernel32.dll", SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        public static extern bool IsWow64Process(
+            IntPtr processHandle,
+            [MarshalAs(UnmanagedType.Bool)] out bool wow64Process);
+    }
+}
+"@
+}
+
+function Stop-RunningProcess {
+    param(
+        [Parameter(Mandatory = $true)]
+        [System.Diagnostics.Process]$Process
+    )
+
+    if (-not $Process.HasExited) {
+        try {
+            Stop-Process -Id $Process.Id
+        }
+        catch {
+            $Process.Refresh()
+            if (-not $Process.HasExited) {
+                throw
+            }
+        }
+        $Process.WaitForExit()
+    }
+}
+
+function Get-DumpSystemDirectory {
+    param(
+        [Parameter(Mandatory = $true)]
+        [System.Diagnostics.Process]$Process
+    )
+
+    if (-not [Environment]::Is64BitOperatingSystem) {
+        return (Join-Path $env:WINDIR "System32")
+    }
+
+    $isWow64 = $false
+    if (-not [RunWithTimeout.NativeMethods]::IsWow64Process($Process.Handle, [ref]$isWow64)) {
+        $errorCode = [Runtime.InteropServices.Marshal]::GetLastWin32Error()
+        throw "Unable to determine the architecture of process $($Process.Id) (Win32 error $errorCode)."
+    }
+
+    if ($isWow64) {
+        return (Join-Path $env:WINDIR "SysWOW64")
+    }
+
+    if (-not [Environment]::Is64BitProcess) {
+        return (Join-Path $env:WINDIR "Sysnative")
+    }
+
+    return (Join-Path $env:WINDIR "System32")
+}
+
+function Save-ProcessDump {
+    param(
+        [Parameter(Mandatory = $true)]
+        [System.Diagnostics.Process]$Process,
+
+        [Parameter(Mandatory = $true)]
+        [string]$DumpPath
+    )
+
+    $dumpProcess = $null
+    $procdump = Get-Command procdump.exe -ErrorAction SilentlyContinue
+    if ($null -ne $procdump) {
+        # A minidump contains the thread stacks and module list needed for a
+        # deadlock diagnosis without copying arbitrary process memory into CI
+        # artifacts.
+        $arguments = "-accepteula -mm $($Process.Id) `"$DumpPath`""
+        $dumpProcess = Start-Process -FilePath $procdump.Source -ArgumentList $arguments -PassThru -NoNewWindow
+    }
+    else {
+        # The dump writer must match the target process architecture. A
+        # 64-bit helper cannot reliably capture Win32 thread context, and a
+        # 32-bit helper cannot inspect a 64-bit target.
+        $systemDirectory = Get-DumpSystemDirectory -Process $Process
+        $powershell = Join-Path $systemDirectory "WindowsPowerShell\v1.0\powershell.exe"
+        $dumpScript = Join-Path $PSScriptRoot "write-minidump.ps1"
+        $arguments = "-NoLogo -NoProfile -ExecutionPolicy Bypass -File `"$dumpScript`" -ProcessId $($Process.Id) -DumpPath `"$DumpPath`""
+        $dumpProcess = Start-Process -FilePath $powershell -ArgumentList $arguments -PassThru -NoNewWindow
+    }
+
+    if (-not $dumpProcess.WaitForExit(30000)) {
+        Stop-RunningProcess -Process $dumpProcess
+        throw "Timed out while capturing dump for process $($Process.Id)."
+    }
+    $dumpProcess.WaitForExit()
+    $dumpProcess.Refresh()
+
+    if ($dumpProcess.ExitCode -ne 0) {
+        throw "Dump capture for process $($Process.Id) exited with code $($dumpProcess.ExitCode)."
+    }
+
+    if (-not (Test-Path -LiteralPath $DumpPath -PathType Leaf)) {
+        throw "Dump capture for process $($Process.Id) did not create $DumpPath."
+    }
+
+    $dumpFile = Get-Item -LiteralPath $DumpPath -ErrorAction SilentlyContinue
+    if ($null -eq $dumpFile -or $dumpFile.Length -eq 0) {
+        throw "Dump capture for process $($Process.Id) created an empty dump."
+    }
+}
+
+$resolvedFilePath = (Resolve-Path -LiteralPath $FilePath).Path
+$resolvedDiagnosticsDirectory = [System.IO.Path]::GetFullPath($DiagnosticsDirectory)
+New-Item -ItemType Directory -Path $resolvedDiagnosticsDirectory -Force | Out-Null
+
+$safeLabel = $Label -replace '[^A-Za-z0-9_.-]', '_'
+$statusPath = Join-Path $resolvedDiagnosticsDirectory "$safeLabel-status.txt"
+$startedAt = Get-Date
+@(
+    "Command: $resolvedFilePath"
+    "Arguments: $ProcessArguments"
+    "Process count: $ProcessCount"
+    "Timeout seconds: $TimeoutSeconds"
+    "Started: $($startedAt.ToString('o'))"
+) | Set-Content -LiteralPath $statusPath
+
+$processes = @()
+try {
+    for ($index = 0; $index -lt $ProcessCount; $index++) {
+        $startInfo = New-Object System.Diagnostics.ProcessStartInfo
+        $startInfo.FileName = $resolvedFilePath
+        $startInfo.Arguments = $ProcessArguments
+        $startInfo.UseShellExecute = $false
+
+        $process = New-Object System.Diagnostics.Process
+        $process.StartInfo = $startInfo
+        if (-not $process.Start()) {
+            throw "Failed to start $resolvedFilePath."
+        }
+        $processes += $process
+    }
+}
+catch {
+    foreach ($process in $processes) {
+        Stop-RunningProcess -Process $process
+    }
+    throw
+}
+
+$deadline = $startedAt.AddSeconds($TimeoutSeconds)
+while ($true) {
+    $failedProcess = $null
+    $failedExitCode = 0
+    $running = @()
+    foreach ($process in $processes) {
+        if ($process.HasExited) {
+            # WaitForExit() populates ExitCode reliably for processes that can
+            # finish before the first polling iteration.
+            $process.WaitForExit()
+            $process.Refresh()
+            if ($process.ExitCode -ne 0 -and $null -eq $failedProcess) {
+                $failedProcess = $process
+                $failedExitCode = $process.ExitCode
+            }
+        }
+        else {
+            $running += $process
+        }
+    }
+
+    if ($null -ne $failedProcess) {
+        foreach ($process in $processes) {
+            Stop-RunningProcess -Process $process
+        }
+        Add-Content -LiteralPath $statusPath -Value @(
+            "Completed: $((Get-Date).ToString('o'))"
+            "Result: failed"
+            "Exit code: $failedExitCode"
+        )
+        exit $failedExitCode
+    }
+
+    if ($running.Count -eq 0) {
+        Add-Content -LiteralPath $statusPath -Value @(
+            "Completed: $((Get-Date).ToString('o'))"
+            "Result: passed"
+            "Exit code: 0"
+        )
+        exit 0
+    }
+
+    if ((Get-Date) -ge $deadline) {
+        Write-Host "::error::$Label exceeded its $TimeoutSeconds-second timeout."
+        Add-Content -LiteralPath $statusPath -Value @(
+            "Completed: $((Get-Date).ToString('o'))"
+            "Result: timed out"
+            "Exit code: 124"
+        )
+
+        foreach ($process in $running) {
+            try {
+                if (-not $process.HasExited) {
+                    $detailsPath = Join-Path $resolvedDiagnosticsDirectory "$safeLabel-$($process.Id).txt"
+                    Get-Process -Id $process.Id |
+                        Format-List Id, ProcessName, StartTime, TotalProcessorTime, Threads, HandleCount |
+                        Out-File -LiteralPath $detailsPath
+
+                    $dumpPath = Join-Path $resolvedDiagnosticsDirectory "$safeLabel-$($process.Id).dmp"
+                    Save-ProcessDump -Process $process -DumpPath $dumpPath
+                    Write-Host "Captured $dumpPath"
+                }
+            }
+            catch {
+                Write-Warning $_
+            }
+            finally {
+                Stop-RunningProcess -Process $process
+            }
+        }
+        exit 124
+    }
+
+    Start-Sleep -Milliseconds 200
+}

.github/scripts/write-minidump.ps1

@@ -0,0 +1,63 @@
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory = $true)]
+    [ValidateRange(1, [int]::MaxValue)]
+    [int]$ProcessId,
+
+    [Parameter(Mandatory = $true)]
+    [ValidateNotNullOrEmpty()]
+    [string]$DumpPath
+)
+
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Stop"
+
+Add-Type -TypeDefinition @"
+namespace WriteMiniDump
+{
+    using System;
+    using System.Runtime.InteropServices;
+    using Microsoft.Win32.SafeHandles;
+
+    public static class NativeMethods
+    {
+        [DllImport("dbghelp.dll", SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        public static extern bool MiniDumpWriteDump(
+            IntPtr processHandle,
+            uint processId,
+            SafeFileHandle fileHandle,
+            uint dumpType,
+            IntPtr exceptionParameters,
+            IntPtr userStreamParameters,
+            IntPtr callbackParameters);
+    }
+}
+"@
+
+$process = Get-Process -Id $ProcessId
+$resolvedDumpPath = [System.IO.Path]::GetFullPath($DumpPath)
+$dumpStream = [System.IO.File]::Open(
+    $resolvedDumpPath,
+    [System.IO.FileMode]::Create,
+    [System.IO.FileAccess]::Write,
+    [System.IO.FileShare]::None)
+
+try {
+    $created = [WriteMiniDump.NativeMethods]::MiniDumpWriteDump(
+        $process.Handle,
+        [uint32]$process.Id,
+        $dumpStream.SafeFileHandle,
+        0,
+        [IntPtr]::Zero,
+        [IntPtr]::Zero,
+        [IntPtr]::Zero)
+    if (-not $created) {
+        $errorCode = [Runtime.InteropServices.Marshal]::GetLastWin32Error()
+        throw "MiniDumpWriteDump failed for process $ProcessId (Win32 error $errorCode)."
+    }
+}
+finally {
+    $dumpStream.Dispose()
+    $process.Dispose()
+}

.github/workflows/build-android.yml

@@ -50,6 +50,8 @@ jobs:
         java-version: '17'
     - name: Setup Android SDK
       uses: android-actions/setup-android@9fc6c4e9069bf8d3d10b2204b1fb8f6ef7065407 # v3.2.2
+      with:
+        packages: platform-tools
     - name: Install NDK
       run: |
         java -version

.github/workflows/build-windows-vs2022.yaml

@@ -34,7 +34,6 @@ jobs:
       env:
         SKIP_ARM_BUILD: 1
         SKIP_ARM64_BUILD: 1
-        SKIP_NET40_BUILD: 1
         PlatformToolset: v143
         VSTOOLS_VERSION: vs2022
       shell: cmd

.github/workflows/codeql-analysis.yml

@@ -132,6 +132,8 @@ jobs:
         java-version: '17'
     - name: Setup Android SDK
       uses: android-actions/setup-android@9fc6c4e9069bf8d3d10b2204b1fb8f6ef7065407 # v3.2.2
+      with:
+        packages: platform-tools
     - name: Install NDK
       run: |
         java -version

.github/workflows/test-vcpkg.yml

@@ -24,7 +24,11 @@ concurrency:
 jobs:
   windows:
     runs-on: windows-latest
-    name: Windows (x64-windows-static)
+    name: Windows (x64-windows-static, ${{ matrix.transport }})
+    strategy:
+      fail-fast: false
+      matrix:
+        transport: [WinHTTP, WinInet]
     steps:
     - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4.4.0
 
@@ -35,7 +39,12 @@ jobs:
       shell: pwsh
 
     - name: Run vcpkg port test
-      run: .\tests\vcpkg\test-vcpkg-windows.ps1 -VcpkgRoot "${{ runner.temp }}\vcpkg"
+      run: |
+        $arguments = @{ VcpkgRoot = "${{ runner.temp }}\vcpkg" }
+        if ("${{ matrix.transport }}" -eq "WinInet") {
+          $arguments.WinInet = $true
+        }
+        .\tests\vcpkg\test-vcpkg-windows.ps1 @arguments
       shell: pwsh
 
   linux: