Ошибка winhttp 12002 время ожидания операции истекло

I using System.net.HTTPClient on Berlin Update 2 for download big files (>500 MB) from AWS S3 with this unit:

unit AcHTTPClient;

interface

uses
  System.Net.URLClient, System.net.HTTPClient;

type
  TAcHTTPProgress = procedure(const Sender: TObject; AStartPosition : Int64; AEndPosition: Int64; AContentLength: Int64; AReadCount: Int64; ATimeStart : Int64; ATime : Int64; var Abort: Boolean) of object;
  TAcHTTPClient = class
    private
      FOnProgress:     TAcHTTPProgress;
      FHTTPClient:     THTTPClient;
      FTimeStart:      cardinal;
      FCancelDownload: boolean;
      FStartPosition:  Int64;
      FEndPosition:    Int64;
      FContentLength:  Int64;
    private
      procedure   SetProxySettings(AProxySettings: TProxySettings);
      function    GetProxySettings : TProxySettings;
      procedure   OnReceiveDataEvent(const Sender: TObject; AContentLength: Int64; AReadCount: Int64; var Abort: Boolean);
    public
      constructor Create;
      destructor  Destroy; override;
      property    ProxySettings : TProxySettings read FProxySettings write SetProxySettings;
      property    OnProgress : TAcHTTPProgress read FOnProgress write FOnProgress;
      property    CancelDownload : boolean read FCancelDownload write FCancelDownload;
      function    Download(const ASrcUrl : string; const ADestFileName : string): Boolean;
  end;

implementation

uses
  System.Classes, System.SysUtils, Winapi.Windows;

constructor TAcHTTPClient.Create;
// -----------------------------------------------------------------------------
// Constructor
begin
  inherited Create;

  // create an THTTPClient
  FHTTPClient := THTTPClient.Create;
  FHTTPClient.OnReceiveData := OnReceiveDataEvent;

  // setting the timeouts
  FHTTPClient.ConnectionTimeout :=  5000;
  FHTTPClient.ResponseTimeout   := 15000;

  // initialize the class variables
  FCancelDownload := false;
  FOnProgress     := nil;
  FEndPosition    := -1;
  FStartPosition  := -1;
  FContentLength  := -1;
end;


destructor TAcHTTPClient.Destroy;
// -----------------------------------------------------------------------------
// Destructor
begin
  FHTTPClient.free;

  inherited Destroy;
end;


procedure TAcHTTPClient.SetProxySettings(AProxySettings: TProxySettings);
// -----------------------------------------------------------------------------
// Set FHTTPClient.ProxySettings with AProxySettings
begin
  FHTTPClient.ProxySettings := AProxySettings;
end;


function TAcHTTPClient.GetProxySettings : TProxySettings;
// -----------------------------------------------------------------------------
// Get FHTTPClient.ProxySettings
begin
  Result := FHTTPClient.ProxySettings;
end;


procedure TAcHTTPClient.OnReceiveDataEvent(const Sender: TObject; AContentLength: Int64; AReadCount: Int64; var Abort: Boolean);
// -----------------------------------------------------------------------------
// HTTPClient.OnReceiveDataEvent become OnProgress
begin
  Abort := CancelDownload;

  if Assigned(OnProgress) then
    OnProgress(Sender, FStartPosition, FEndPosition, AContentLength, AReadCount, FTimeStart, GetTickCount,  Abort);
end;


function TAcHTTPClient.Download(const ASrcUrl : string; const ADestFileName : string): Boolean;
// -----------------------------------------------------------------------------
// Download a file from ASrcUrl and store to ADestFileName
var
  aResponse:           IHTTPResponse;
  aFileStream:         TFileStream;
  aTempFilename:       string;
  aAcceptRanges:       boolean;
  aTempFilenameExists: boolean;
begin
  Result         := false;
  FEndPosition   := -1;
  FStartPosition := -1;
  FContentLength := -1;

  aResponse   := nil;
  aFileStream := nil;
  try
    // raise an exception if the file already exists on ADestFileName 
    if FileExists(ADestFileName) then
      raise Exception.Create(Format('the file %s alredy exists', [ADestFileName]));

    // reset the CancelDownload property
    CancelDownload := false;

    // set the time start of the download
    FTimeStart := GetTickCount;

    // until the download is incomplete the ADestFileName has *.parts extension 
    aTempFilename := ADestFileName + '.parts';

    // get the header from the server for aSrcUrl
    aResponse := FHTTPClient.Head(aSrcUrl);

    // checks if the response StatusCode is 2XX (aka OK) 
    if (aResponse.StatusCode < 200) or (aResponse.StatusCode > 299) then
      raise Exception.Create(Format('Server error %d: %s', [aResponse.StatusCode, aResponse.StatusText]));

    // checks if the server accept bytes ranges 
    aAcceptRanges := SameText(aResponse.HeaderValue['Accept-Ranges'], 'bytes');

    // get the content length (aka FileSize)
    FContentLength := aResponse.ContentLength;

    // checks if a "partial" download already exists
    aTempFilenameExists := FileExists(aTempFilename);

    // if a "partial" download already exists
    if aTempFilenameExists then
    begin
      // re-utilize the same file stream, with position on the end of the stream
      aFileStream := TFileStream.Create(aTempFilename, fmOpenWrite or fmShareDenyNone);
      aFileStream.Seek(0, TSeekOrigin.soEnd);
    end else begin
      // create a new file stream, with the position on the beginning of the stream
      aFileStream := TFileStream.Create(aTempFilename, fmCreate);
      aFileStream.Seek(0, TSeekOrigin.soBeginning);
    end;

    // if the server doesn't accept bytes ranges, always start to write at beginning of the stream
    if not(aAcceptRanges) then
      aFileStream.Seek(0, TSeekOrigin.soBeginning);

    // set the range of the request (from the stream position to server content length)
    FStartPosition := aFileStream.Position;
    FEndPosition   := FContentLength;

    // if the range is incomplete (the FStartPosition is less than FEndPosition)
    if (FEndPosition > 0) and (FStartPosition < FEndPosition) then
    begin
      // ... and if a starting point is present
      if FStartPosition > 0 then
      begin
        // makes a bytes range request from FStartPosition to FEndPosition
        aResponse := FHTTPClient.GetRange(aSrcUrl, FStartPosition, FEndPosition, aFileStream);
      end else begin
        // makes a canonical GET request
        aResponse := FHTTPClient.Get(aSrcUrl, aFileStream);
      end;

      // check if the response StatusCode is 2XX (aka OK) 
      if (aResponse.StatusCode < 200) or (aResponse.StatusCode > 299) then
        raise Exception.Create(Format('Server error %d: %s', [aResponse.StatusCode, aResponse.StatusText]));
    end;

    // if the FileStream.Size is equal to server ContentLength, the download is completed!
    if (aFileStream.Size > 0) and (aFileStream.Size = FContentLength) then begin

      // free the FileStream otherwise doesn't renames the "partial file" into the DestFileName
      FreeAndNil(aFileStream);

      // renames the aTempFilename file into the ADestFileName 
      Result := RenameFile(aTempFilename, ADestFileName);

      // What?
      if not(Result) then
        raise Exception.Create(Format('RenameFile from %s to %s: %s', [aTempFilename, ADestFileName, SysErrorMessage(GetLastError)]));
    end;
  finally
    if aFileStream <> nil then aFileStream.Free;
    aResponse := nil;
  end;
end;

end.

sometime i see this exception:

Error reading data: (12002) The operation timed out

i have found this error string into System.NetConsts.pas:

SNetHttpRequestReadDataError = 'Error reading data: (%d) %s';

and the error is raised into System.Net.HttpClient.Win.pas (see @SNetHttpRequestReadDataError):

procedure TWinHTTPResponse.DoReadData(const AStream: TStream);
var
  LSize: Cardinal;
  LDownloaded: Cardinal;
  LBuffer: TBytes;
  LExpected, LReaded: Int64;
  LStatusCode: Integer;
  Abort: Boolean;
begin
  LReaded := 0;
  LExpected := GetContentLength;
  if LExpected = 0 then
    LExpected := -1;
  LStatusCode := GetStatusCode;
  Abort := False;
  FRequestLink.DoReceiveDataProgress(LStatusCode, LExpected, LReaded, Abort);
  if not Abort then
    repeat
      // Get the size of readed data in LSize
      if not WinHttpQueryDataAvailable(FWRequest, @LSize) then
        raise ENetHTTPResponseException.CreateResFmt(@SNetHttpRequestReadDataError, [GetLastError, SysErrorMessage(GetLastError, FWinHttpHandle)]);

      if LSize = 0 then
        Break;

      SetLength(LBuffer, LSize + 1);

      if not WinHttpReadData(FWRequest, LBuffer[0], LSize, @LDownloaded) then
        raise ENetHTTPResponseException.CreateResFmt(@SNetHttpRequestReadDataError, [GetLastError, SysErrorMessage(GetLastError, FWinHttpHandle)]);

      // This condition should never be reached since WinHttpQueryDataAvailable
      // reported that there are bits to read.
      if LDownloaded = 0 then
        Break;

      AStream.WriteBuffer(LBuffer, LDownloaded);
      LReaded := LReaded + LDownloaded;
      FRequestLink.DoReceiveDataProgress(LStatusCode, LExpected, LReaded, Abort);
    until (LSize = 0) or Abort;
end;

What caused this error?

Hi,

I’m trying to configure the the client side WinHTTP connect/send/receive timeout on Windows 7/2008. However they don’t seem to take effect.

Instead WinHttpSendRequest comes back with 12002 always after 21 seconds when trying with a fake IP as destination (not sure how else to simulate).

It may worth mentioning that I tried both by using WinHttpSetTimeouts and by setting each option individually with WinHttpSetOption with no difference.

The results of my quick test look like this:

WinHttpUsageExample.exe «10.20.30.40» 50 (timeout in secs)

default WINHTTP_OPTION_RESOLVE_TIMEOUT: -1
default WINHTTP_OPTION_CONNECT_TIMEOUT: 60000
default WINHTTP_OPTION_SEND_TIMEOUT: 30000
default WINHTTP_OPTION_RECEIVE_TIMEOUT: 30000
——————————————————————————-

current WINHTTP_OPTION_RESOLVE_TIMEOUT: 50000
current WINHTTP_OPTION_CONNECT_TIMEOUT: 50000
current WINHTTP_OPTION_SEND_TIMEOUT: 50000
current WINHTTP_OPTION_RECEIVE_TIMEOUT: 50000
——————————————————————————-

Before WinHttpSendRequest time is 16:36:28
After WinHttpSendRequest time is 16:36:49, errno: 12002
Error 12002 has occurred.

Could this be a WinHTTP bug?

Am I not simulating correctly? How to then?

Could it be in this case that the ERROR_WINHTTP_TIMEOUT is returned as result of lower tcp level timeout(s) expiration (not mentioned in WinHTTP doc)?

Pretty much in the dark here. Any help would be highly appreciated.

Cheers,
Bogdan

Also, in case one may be curious, here’s the source of my small test program:

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <windows.h>
#include <winhttp.h>
#include <time.h>

static wchar_t* charToWChar(const char* text)
{
    size_t size = strlen(text) + 1;
    wchar_t* wa = new wchar_t[size];
    mbstowcs(wa,text,size);
    return wa;
}

int main(int argc, char* argv[])
{
  DWORD dwSize = 0;
  DWORD dwDownloaded = 0;
  LPSTR pszOutBuffer;
  BOOL  bResults = FALSE;
  HINTERNET  hSession = NULL,
             hConnect = NULL,
             hRequest = NULL;

  DWORD timeoutval = 0;
  DWORD size = sizeof(DWORD);
  wchar_t *httpserver = NULL;  
  char timeStr [9];    

  if(argc < 3)
  {
          printf( «usage: WinHttpUsageExample.exe <http server name/address> <winhttp global timeout in seconds>n»);

          return 0;
  }

  // Use WinHttpOpen to obtain a session handle.
  hSession = WinHttpOpen( L»WinHTTP Example/1.0″,  
                          WINHTTP_ACCESS_TYPE_DEFAULT_PROXY,

                          WINHTTP_NO_PROXY_NAME,

                          WINHTTP_NO_PROXY_BYPASS, 0 );

  WinHttpQueryOption(hSession, WINHTTP_OPTION_RESOLVE_TIMEOUT, &timeoutval, &size);

  printf(«default WINHTTP_OPTION_RESOLVE_TIMEOUT: %dn», timeoutval);

  WinHttpQueryOption(hSession, WINHTTP_OPTION_CONNECT_TIMEOUT, &timeoutval, &size);

  printf(«default WINHTTP_OPTION_CONNECT_TIMEOUT: %dn», timeoutval);

  WinHttpQueryOption(hSession, WINHTTP_OPTION_SEND_TIMEOUT, &timeoutval, &size);

  printf(«default WINHTTP_OPTION_SEND_TIMEOUT: %dn», timeoutval);

  WinHttpQueryOption(hSession, WINHTTP_OPTION_RECEIVE_TIMEOUT, &timeoutval, &size);

  printf(«default WINHTTP_OPTION_RECEIVE_TIMEOUT: %dn», timeoutval);

  printf( «——————————————————————————-n»);

  timeoutval = atol(argv[2]) * 1000; //convert seconds to milliseconds
  httpserver = charToWChar( argv[1] ); // convert the string type

  /* Use WinHttpSetTimeouts to set a new time-out values (resolve, connect, send, receive) */

  if (!WinHttpSetTimeouts( hSession, timeoutval, timeoutval, timeoutval, timeoutval))

  {
       printf(«Error %u in WinHttpSetTimeouts.n», GetLastError());

  }

  // Specify an HTTP server.
  if( hSession )
    hConnect = WinHttpConnect( hSession, httpserver,
                               INTERNET_DEFAULT_HTTPS_PORT, 0 );

  // Create an HTTP request handle.
  if( hConnect )
    hRequest = WinHttpOpenRequest( hConnect, L»GET», NULL,
                                   NULL, WINHTTP_NO_REFERER,

                                   WINHTTP_DEFAULT_ACCEPT_TYPES,

                                   WINHTTP_FLAG_SECURE );

  WinHttpQueryOption(hRequest, WINHTTP_OPTION_RESOLVE_TIMEOUT, &timeoutval, &size);

  printf(«current WINHTTP_OPTION_RESOLVE_TIMEOUT: %dn», timeoutval);

  WinHttpQueryOption(hRequest, WINHTTP_OPTION_CONNECT_TIMEOUT, &timeoutval, &size);

  printf(«current WINHTTP_OPTION_CONNECT_TIMEOUT: %dn», timeoutval);

  WinHttpQueryOption(hRequest, WINHTTP_OPTION_SEND_TIMEOUT, &timeoutval, &size);

  printf(«current WINHTTP_OPTION_SEND_TIMEOUT: %dn», timeoutval);

  WinHttpQueryOption(hRequest, WINHTTP_OPTION_RECEIVE_TIMEOUT, &timeoutval, &size);

  printf(«current WINHTTP_OPTION_RECEIVE_TIMEOUT: %dn», timeoutval);  

  printf( «——————————————————————————-n»);

  _strtime_s( timeStr );
  printf( «Before WinHttpSendRequest time is %s n», timeStr);  

  // Send a request.
  if( hRequest )
  {
          bResults = WinHttpSendRequest( hRequest,

                                   WINHTTP_NO_ADDITIONAL_HEADERS, 0,

                                   WINHTTP_NO_REQUEST_DATA, 0,

                                   0, 0 );

          _strtime_s( timeStr );
          printf( «After WinHttpSendRequest time is %s, errno: %d n», timeStr, GetLastError( ));

  }

 
  // Receive response
  if( bResults )
  {
        bResults = WinHttpReceiveResponse( hRequest, NULL );

        _strtime_s( timeStr );
        printf( «Afer WinHttpReceiveResponse time is %s, errno: %d n», timeStr, GetLastError( ));

  }

  // Keep checking for data until there is nothing left.
  if( bResults )
  {
    do
    {
      // Check for available data.
      dwSize = 0;
      if( !WinHttpQueryDataAvailable( hRequest, &dwSize ) )
        printf( «Error %u in WinHttpQueryDataAvailable.n»,

                GetLastError( ) );

      // Allocate space for the buffer.
      pszOutBuffer = new char[dwSize+1];
      if( !pszOutBuffer )
      {
        printf( «Out of memoryn» );
        dwSize=0;
      }
      else
      {
        // Read the data.
        ZeroMemory( pszOutBuffer, dwSize+1 );

        if( !WinHttpReadData( hRequest, (LPVOID)pszOutBuffer,

                              dwSize, &dwDownloaded ) )

          printf( «Error %u in WinHttpReadData.n», GetLastError( ) );

        else
          printf( «%s», pszOutBuffer );

        // Free the memory allocated to the buffer.
        delete [] pszOutBuffer;
      }
    } while( dwSize > 0 );
  }

 
  // Report any errors.
  if( !bResults )
    printf( «Error %d has occurred.n», GetLastError( ) );

  // Close any open handles.
  if( hRequest ) WinHttpCloseHandle( hRequest );
  if( hConnect ) WinHttpCloseHandle( hConnect );
  if( hSession ) WinHttpCloseHandle( hSession );

 
  return 0;
}

@ras0219-msft is it ok that vcpkg is still broken when installed behind a proxy?

A clean vcpkg installation on windows fails to download powershell, 7-zip and nuget just at the beginning, when installing your first library.

Subsequent downloads are working (they still often fail for no apparent reason at all) , the first three nope and I have to download them manually from a browser and move them inside the vcpkg/downloads folder.
I still didn’t inspect why, but these downloads are done in a different way (broken, it seems), because they are totally not tested for proxy support. Also the fact that proxy support is so weak that usually I prefer to do the «download-only» part on the WSL side is depressing (same pc, same proxy, somehow the linux part is more proxy resilient), so that I don’t fear of finding the update stopped because one of the library failed to download (never happened when not using proxy).

Just to let you know, vcpkg on windows is the only program that gives me any problem with «dropped internet connection», so i’d not declare our proxy as guilty. Also, even when vcpkg is failing repeatedly, any browser installed can download the tar.gz with no problem, and as I said also the WSL version can, without any annoyance.

Please fix it. For any enterprise adoption of vcpkg, a proper proxy support is a deal breaker. It’s still far from being here.