[PATCH v5 0/1] MR3518: wininet: unify timeout values closer to hInternet

[Jacob Pfeiffer (＠Cthuflu)]

Also: Add new timeouts to NETCON calls impacted by change

Timeout values are able to be set on all hInternet handles, so they should be able to set in a unified way.

Submitting what I have so far for review. 

Known TODO: Tests, verify timeouts are set where NETCON is used, verify ULONG vs DWORD usage rules.

--
  v5: wininet: unify timeout values closer to hInternet
 
https://gitlab.winehq.org/wine/wine/-/merge_requests/3518

[PATCH v5 1/1] wininet: unify timeout values closer to hInternet

[Jacob Pfeiffer]

From: Jacob Pfeiffer <jacob(a)pfeiffer.codes>

---
 dlls/wininet/http.c           |  86 ++--------
 dlls/wininet/internet.c       | 291 ++++++++++++++++++++++++++++++----
 dlls/wininet/internet.h       |  12 +-
 dlls/wininet/tests/internet.c | 184 ++++++++++++++++++++-
 4 files changed, 452 insertions(+), 121 deletions(-)

diff --git a/dlls/wininet/http.c b/dlls/wininet/http.c
index 9a20a877cdc..c0f1e13bfa8 100644
--- a/dlls/wininet/http.c
+++ b/dlls/wininet/http.c
@@ -2280,11 +2280,11 @@ static DWORD HTTPREQ_QueryOption(object_header_t *hdr, DWORD option, void *buffe
         return err;
     }
     case INTERNET_OPTION_CONNECT_TIMEOUT:
-        if (*size < sizeof(DWORD))
+        if (*size < sizeof(ULONG))
             return ERROR_INSUFFICIENT_BUFFER;
 
-        *size = sizeof(DWORD);
-        *(DWORD *)buffer = req->connect_timeout;
+        *size = sizeof(ULONG);
+        *(ULONG *)buffer = hdr->connect_timeout;
         return ERROR_SUCCESS;
     case INTERNET_OPTION_REQUEST_FLAGS: {
         DWORD flags = 0;
@@ -2363,20 +2363,6 @@ static DWORD HTTPREQ_SetOption(object_header_t *hdr, DWORD option, void *buffer,
             req->netconn->security_flags |= flags;
         return ERROR_SUCCESS;
     }
-    case INTERNET_OPTION_CONNECT_TIMEOUT:
-        if (!buffer || size != sizeof(DWORD)) return ERROR_INVALID_PARAMETER;
-        req->connect_timeout = *(DWORD *)buffer;
-        return ERROR_SUCCESS;
-
-    case INTERNET_OPTION_SEND_TIMEOUT:
-        if (!buffer || size != sizeof(DWORD)) return ERROR_INVALID_PARAMETER;
-        req->send_timeout = *(DWORD *)buffer;
-        return ERROR_SUCCESS;
-
-    case INTERNET_OPTION_RECEIVE_TIMEOUT:
-        if (!buffer || size != sizeof(DWORD)) return ERROR_INVALID_PARAMETER;
-        req->receive_timeout = *(DWORD *)buffer;
-        return ERROR_SUCCESS;
 
     case INTERNET_OPTION_USERNAME:
         free(req->session->userName);
@@ -3461,9 +3447,9 @@ static DWORD HTTP_HttpOpenRequestW(http_session_t *session,
 
     request->netconn_stream.data_stream.vtbl = &netconn_stream_vtbl;
     request->data_stream = &request->netconn_stream.data_stream;
-    request->connect_timeout = session->connect_timeout;
-    request->send_timeout = session->send_timeout;
-    request->receive_timeout = session->receive_timeout;
+    request->hdr.connect_timeout = session->hdr.connect_timeout;
+    request->hdr.send_timeout = session->hdr.send_timeout;
+    request->hdr.receive_timeout = session->hdr.receive_timeout;
 
     InitializeCriticalSectionEx( &request->headers_section, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO );
     request->headers_section.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": http_request_t.headers_section");
@@ -4946,7 +4932,7 @@ static DWORD open_http_connection(http_request_t *request, BOOL *reusing)
 
     res = create_netconn(request->proxy ? request->proxy : request->server, request->security_flags,
                          (request->hdr.ErrorMask & INTERNET_ERROR_MASK_COMBINED_SEC_CERT) != 0,
-                         request->connect_timeout, &netconn);
+                         request->hdr.connect_timeout, &netconn);
     if(res != ERROR_SUCCESS) {
         ERR("create_netconn failed: %lu\n", res);
         return res;
@@ -5140,7 +5126,7 @@ static DWORD HTTP_HttpSendRequestW(http_request_t *request, LPCWSTR lpszHeaders,
         INTERNET_SendCallback(&request->hdr, request->hdr.dwContext,
                               INTERNET_STATUS_SENDING_REQUEST, NULL, 0);
 
-        NETCON_set_timeout( request->netconn, TRUE, request->send_timeout );
+        NETCON_set_timeout( request->netconn, TRUE, request->hdr.send_timeout );
         res = NETCON_send(request->netconn, ascii_req, len, 0, &cnt);
         free(ascii_req);
         if(res != ERROR_SUCCESS) {
@@ -5820,7 +5806,6 @@ static void HTTPSESSION_Destroy(object_header_t *hdr)
 
 static DWORD HTTPSESSION_QueryOption(object_header_t *hdr, DWORD option, void *buffer, DWORD *size, BOOL unicode)
 {
-    http_session_t *ses = (http_session_t *)hdr;
 
     switch(option) {
     case INTERNET_OPTION_HANDLE_TYPE:
@@ -5832,35 +5817,6 @@ static DWORD HTTPSESSION_QueryOption(object_header_t *hdr, DWORD option, void *b
         *size = sizeof(DWORD);
         *(DWORD*)buffer = INTERNET_HANDLE_TYPE_CONNECT_HTTP;
         return ERROR_SUCCESS;
-    case INTERNET_OPTION_CONNECT_TIMEOUT:
-        TRACE("INTERNET_OPTION_CONNECT_TIMEOUT\n");
-
-        if (*size < sizeof(DWORD))
-            return ERROR_INSUFFICIENT_BUFFER;
-
-        *size = sizeof(DWORD);
-        *(DWORD *)buffer = ses->connect_timeout;
-        return ERROR_SUCCESS;
-
-    case INTERNET_OPTION_SEND_TIMEOUT:
-        TRACE("INTERNET_OPTION_SEND_TIMEOUT\n");
-
-        if (*size < sizeof(DWORD))
-            return ERROR_INSUFFICIENT_BUFFER;
-
-        *size = sizeof(DWORD);
-        *(DWORD *)buffer = ses->send_timeout;
-        return ERROR_SUCCESS;
-
-    case INTERNET_OPTION_RECEIVE_TIMEOUT:
-        TRACE("INTERNET_OPTION_RECEIVE_TIMEOUT\n");
-
-        if (*size < sizeof(DWORD))
-            return ERROR_INSUFFICIENT_BUFFER;
-
-        *size = sizeof(DWORD);
-        *(DWORD *)buffer = ses->receive_timeout;
-        return ERROR_SUCCESS;
     }
 
     return INET_QueryOption(hdr, option, buffer, size, unicode);
@@ -5895,24 +5851,6 @@ static DWORD HTTPSESSION_SetOption(object_header_t *hdr, DWORD option, void *buf
         if (!(ses->appInfo->proxyPassword = wcsdup(buffer))) return ERROR_OUTOFMEMORY;
         return ERROR_SUCCESS;
     }
-    case INTERNET_OPTION_CONNECT_TIMEOUT:
-    {
-        if (!buffer || size != sizeof(DWORD)) return ERROR_INVALID_PARAMETER;
-        ses->connect_timeout = *(DWORD *)buffer;
-        return ERROR_SUCCESS;
-    }
-    case INTERNET_OPTION_SEND_TIMEOUT:
-    {
-        if (!buffer || size != sizeof(DWORD)) return ERROR_INVALID_PARAMETER;
-        ses->send_timeout = *(DWORD *)buffer;
-        return ERROR_SUCCESS;
-    }
-    case INTERNET_OPTION_RECEIVE_TIMEOUT:
-    {
-        if (!buffer || size != sizeof(DWORD)) return ERROR_INVALID_PARAMETER;
-        ses->receive_timeout = *(DWORD *)buffer;
-        return ERROR_SUCCESS;
-    }
     default: break;
     }
 
@@ -5979,9 +5917,9 @@ DWORD HTTP_Connect(appinfo_t *hIC, LPCWSTR lpszServerName,
         session->userName = wcsdup(lpszUserName);
     session->password = wcsdup(lpszPassword);
     session->hostPort = serverPort;
-    session->connect_timeout = hIC->connect_timeout;
-    session->send_timeout = 0;
-    session->receive_timeout = 0;
+    session->hdr.connect_timeout = hIC->hdr.connect_timeout;
+    session->hdr.send_timeout = hIC->hdr.send_timeout;
+    session->hdr.receive_timeout = hIC->hdr.receive_timeout;
 
     /* Don't send a handle created callback if this handle was created with InternetOpenUrl */
     if (!(session->hdr.dwInternalFlags & INET_OPENURL))
@@ -6057,7 +5995,7 @@ static DWORD HTTP_GetResponseHeaders(http_request_t *request, INT *len)
     /* clear old response headers (eg. from a redirect response) */
     HTTP_clear_response_headers( request );
 
-    NETCON_set_timeout( request->netconn, FALSE, request->receive_timeout );
+    NETCON_set_timeout( request->netconn, FALSE, request->hdr.receive_timeout );
     do {
         /*
          * We should first receive 'HTTP/1.x nnn OK' where nnn is the status code.
diff --git a/dlls/wininet/internet.c b/dlls/wininet/internet.c
index fe016e29cd5..4fac560f2e6 100644
--- a/dlls/wininet/internet.c
+++ b/dlls/wininet/internet.c
@@ -106,6 +106,11 @@ typedef struct {
 
 static ULONG max_conns = 2, max_1_0_conns = 4;
 static ULONG connect_timeout = 60000;
+static ULONG send_timeout = 60000;
+static ULONG receive_timeout = 60000;
+static ULONG data_send_timeout = 60000;
+static ULONG data_receive_timeout = 60000;
+
 
 static const WCHAR szInternetSettings[] =
     L"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings";
@@ -174,6 +179,17 @@ void *alloc_object(object_header_t *parent, const object_vtbl_t *vtbl, size_t si
     if(parent) {
         ret->lpfnStatusCB = parent->lpfnStatusCB;
         ret->dwInternalFlags = parent->dwInternalFlags & INET_CALLBACKW;
+        ret->connect_timeout = parent->connect_timeout;
+        ret->send_timeout = parent->send_timeout;
+        ret->receive_timeout = parent->receive_timeout;
+        ret->data_send_timeout = parent->data_send_timeout;
+        ret->data_receive_timeout = parent->data_receive_timeout;
+    } else {
+        ret->connect_timeout = connect_timeout;
+        ret->send_timeout = send_timeout;
+        ret->receive_timeout = receive_timeout;
+        ret->data_send_timeout = data_send_timeout;
+        ret->data_receive_timeout = data_receive_timeout;
     }
 
     return ret;
@@ -1147,17 +1163,6 @@ static DWORD APPINFO_QueryOption(object_header_t *hdr, DWORD option, void *buffe
             return ERROR_SUCCESS;
         }
 
-    case INTERNET_OPTION_CONNECT_TIMEOUT:
-        TRACE("INTERNET_OPTION_CONNECT_TIMEOUT\n");
-
-        if (*size < sizeof(ULONG))
-            return ERROR_INSUFFICIENT_BUFFER;
-
-        *(ULONG*)buffer = ai->connect_timeout;
-        *size = sizeof(ULONG);
-
-        return ERROR_SUCCESS;
-
     case INTERNET_OPTION_PER_CONNECTION_OPTION: {
         INTERNET_PER_CONN_OPTION_LISTW *con = buffer;
         INTERNET_PER_CONN_OPTION_LISTA *conA = buffer;
@@ -1241,16 +1246,6 @@ static DWORD APPINFO_SetOption(object_header_t *hdr, DWORD option, void *buf, DW
     appinfo_t *ai = (appinfo_t*)hdr;
 
     switch(option) {
-    case INTERNET_OPTION_CONNECT_TIMEOUT:
-        TRACE("INTERNET_OPTION_CONNECT_TIMEOUT\n");
-
-        if(size != sizeof(connect_timeout))
-            return ERROR_INTERNET_BAD_OPTION_LENGTH;
-        if(!*(ULONG*)buf)
-            return ERROR_BAD_ARGUMENTS;
-
-        ai->connect_timeout = *(ULONG*)buf;
-        return ERROR_SUCCESS;
     case INTERNET_OPTION_USER_AGENT:
         free(ai->agent);
         if (!(ai->agent = wcsdup(buf))) return ERROR_OUTOFMEMORY;
@@ -1381,7 +1376,6 @@ HINTERNET WINAPI InternetOpenW(LPCWSTR lpszAgent, DWORD dwAccessType,
     lpwai->accessType = dwAccessType;
     lpwai->proxyUsername = NULL;
     lpwai->proxyPassword = NULL;
-    lpwai->connect_timeout = connect_timeout;
 
     lpwai->agent = wcsdup(lpszAgent);
     if(dwAccessType == INTERNET_OPEN_TYPE_PRECONFIG)
@@ -3091,6 +3085,50 @@ static DWORD query_global_option(DWORD option, void *buffer, DWORD *size, BOOL u
         *(ULONG*)buffer = connect_timeout;
         *size = sizeof(ULONG);
 
+        return ERROR_SUCCESS;
+
+    case INTERNET_OPTION_SEND_TIMEOUT:
+        TRACE("INTERNET_OPTION_SEND_TIMEOUT\n");
+
+        if (*size < sizeof(ULONG))
+            return ERROR_INSUFFICIENT_BUFFER;
+
+        *(ULONG*)buffer = send_timeout;
+        *size = sizeof(ULONG);
+
+        return ERROR_SUCCESS;
+
+    case INTERNET_OPTION_RECEIVE_TIMEOUT:
+        TRACE("INTERNET_OPTION_RECEIVE_TIMEOUT\n");
+
+        if (*size < sizeof(ULONG))
+            return ERROR_INSUFFICIENT_BUFFER;
+
+        *(ULONG*)buffer = receive_timeout;
+        *size = sizeof(ULONG);
+
+        return ERROR_SUCCESS;
+
+    case INTERNET_OPTION_DATA_SEND_TIMEOUT:
+        TRACE("INTERNET_OPTION_DATA_SEND_TIMEOUT\n");
+
+        if (*size < sizeof(ULONG))
+            return ERROR_INSUFFICIENT_BUFFER;
+
+        *(ULONG*)buffer = data_send_timeout;
+        *size = sizeof(ULONG);
+
+        return ERROR_SUCCESS;
+
+    case INTERNET_OPTION_DATA_RECEIVE_TIMEOUT:
+        TRACE("INTERNET_OPTION_DATA_RECEIVE_TIMEOUT\n");
+
+        if (*size < sizeof(ULONG))
+            return ERROR_INSUFFICIENT_BUFFER;
+
+        *(ULONG*)buffer = data_receive_timeout;
+        *size = sizeof(ULONG);
+
         return ERROR_SUCCESS;
     }
 
@@ -3125,6 +3163,57 @@ DWORD INET_QueryOption(object_header_t *hdr, DWORD option, void *buffer, DWORD *
     case INTERNET_OPTION_MAX_CONNS_PER_1_0_SERVER:
         WARN("Called on global option %lu\n", option);
         return ERROR_INTERNET_INVALID_OPERATION;
+
+    case INTERNET_OPTION_CONNECT_TIMEOUT:
+        TRACE("INTERNET_OPTION_CONNECT_TIMEOUT\n");
+
+        if (*size < sizeof(ULONG))
+            return ERROR_INSUFFICIENT_BUFFER;
+
+        *(ULONG*)buffer = hdr->connect_timeout;
+        *size = sizeof(ULONG);
+
+        return ERROR_SUCCESS;
+
+    case INTERNET_OPTION_SEND_TIMEOUT:
+        TRACE("INTERNET_OPTION_SEND_TIMEOUT\n");
+
+        if (*size < sizeof(ULONG))
+            return ERROR_INSUFFICIENT_BUFFER;
+
+        *size = sizeof(ULONG);
+        *(ULONG *)buffer = hdr->send_timeout;
+        return ERROR_SUCCESS;
+
+    case INTERNET_OPTION_RECEIVE_TIMEOUT:
+        TRACE("INTERNET_OPTION_RECEIVE_TIMEOUT\n");
+
+        if (*size < sizeof(ULONG))
+            return ERROR_INSUFFICIENT_BUFFER;
+
+        *size = sizeof(ULONG);
+        *(ULONG *)buffer = hdr->receive_timeout;
+        return ERROR_SUCCESS;
+
+    case INTERNET_OPTION_DATA_SEND_TIMEOUT:
+        TRACE("INTERNET_OPTION_DATA_SEND_TIMEOUT\n");
+
+        if (*size < sizeof(ULONG))
+            return ERROR_INSUFFICIENT_BUFFER;
+
+        *size = sizeof(ULONG);
+        *(ULONG *)buffer = hdr->data_send_timeout;
+        return ERROR_SUCCESS;
+
+    case INTERNET_OPTION_DATA_RECEIVE_TIMEOUT:
+        TRACE("INTERNET_OPTION_DATA_RECEIVE_TIMEOUT\n");
+
+        if (*size < sizeof(ULONG))
+            return ERROR_INSUFFICIENT_BUFFER;
+
+        *size = sizeof(ULONG);
+        *(ULONG *)buffer = hdr->data_receive_timeout;
+        return ERROR_SUCCESS;
     }
 
     /* FIXME: we shouldn't call it here */
@@ -3213,6 +3302,26 @@ DWORD INET_SetOption(object_header_t *hdr, DWORD option, void *buf, DWORD size)
         return ERROR_INTERNET_INVALID_OPERATION;
     case INTERNET_OPTION_REFRESH:
         return ERROR_INTERNET_INCORRECT_HANDLE_TYPE;
+    case INTERNET_OPTION_CONNECT_TIMEOUT:
+        if (!buf || size != sizeof(ULONG)) return ERROR_INVALID_PARAMETER;
+        hdr->connect_timeout = *(ULONG *)buf;
+        return ERROR_SUCCESS;
+    case INTERNET_OPTION_SEND_TIMEOUT:
+        if (!buf || size != sizeof(ULONG)) return ERROR_INVALID_PARAMETER;
+        hdr->send_timeout = *(ULONG *)buf;
+        return ERROR_SUCCESS;
+    case INTERNET_OPTION_RECEIVE_TIMEOUT:
+        if (!buf || size != sizeof(ULONG)) return ERROR_INVALID_PARAMETER;
+        hdr->receive_timeout = *(ULONG *)buf;
+        return ERROR_SUCCESS;
+    case INTERNET_OPTION_DATA_SEND_TIMEOUT:
+        if (!buf || size != sizeof(ULONG)) return ERROR_INVALID_PARAMETER;
+        hdr->data_send_timeout = *(ULONG *)buf;
+        return ERROR_SUCCESS;
+    case INTERNET_OPTION_DATA_RECEIVE_TIMEOUT:
+        if (!buf || size != sizeof(ULONG)) return ERROR_INVALID_PARAMETER;
+        hdr->data_receive_timeout = *(ULONG *)buf;
+        return ERROR_SUCCESS;
     }
 
     return ERROR_INTERNET_INVALID_OPTION;
@@ -3258,6 +3367,50 @@ static DWORD set_global_option(DWORD option, void *buf, DWORD size)
         connect_timeout = *(ULONG*)buf;
         return ERROR_SUCCESS;
 
+    case INTERNET_OPTION_SEND_TIMEOUT:
+        TRACE("INTERNET_OPTION_SEND_TIMEOUT\n");
+
+        if(size != sizeof(send_timeout))
+            return ERROR_INTERNET_BAD_OPTION_LENGTH;
+        if(!*(ULONG*)buf)
+            return ERROR_BAD_ARGUMENTS;
+
+        send_timeout = *(ULONG*)buf;
+        return ERROR_SUCCESS;
+
+    case INTERNET_OPTION_RECEIVE_TIMEOUT:
+        TRACE("INTERNET_OPTION_RECEIVE_TIMEOUT\n");
+
+        if(size != sizeof(receive_timeout))
+            return ERROR_INTERNET_BAD_OPTION_LENGTH;
+        if(!*(ULONG*)buf)
+            return ERROR_BAD_ARGUMENTS;
+
+        receive_timeout = *(ULONG*)buf;
+        return ERROR_SUCCESS;
+
+    case INTERNET_OPTION_DATA_SEND_TIMEOUT:
+        TRACE("INTERNET_OPTION_DATA_SEND_TIMEOUT\n");
+
+        if(size != sizeof(data_send_timeout))
+            return ERROR_INTERNET_BAD_OPTION_LENGTH;
+        if(!*(ULONG*)buf)
+            return ERROR_BAD_ARGUMENTS;
+
+        data_send_timeout = *(ULONG*)buf;
+        return ERROR_SUCCESS;
+
+    case INTERNET_OPTION_DATA_RECEIVE_TIMEOUT:
+        TRACE("INTERNET_OPTION_DATA_RECEIVE_TIMEOUT\n");
+
+        if(size != sizeof(data_receive_timeout))
+            return ERROR_INTERNET_BAD_OPTION_LENGTH;
+        if(!*(ULONG*)buf)
+            return ERROR_BAD_ARGUMENTS;
+
+        data_receive_timeout = *(ULONG*)buf;
+        return ERROR_SUCCESS;
+
     case INTERNET_OPTION_SUPPRESS_BEHAVIOR:
         FIXME("INTERNET_OPTION_SUPPRESS_BEHAVIOR stub\n");
 
@@ -3384,17 +3537,41 @@ BOOL WINAPI InternetSetOptionW(HINTERNET hInternet, DWORD dwOption,
       }
       break;
     case INTERNET_OPTION_CONNECT_TIMEOUT:
-      {
-        ULONG connecttimeout = *(ULONG *)lpBuffer;
-        FIXME("Option INTERNET_OPTION_CONNECT_TIMEOUT (%ld): STUB\n", connecttimeout);
-      }
-      break;
+    {
+        if (!lpwhh)
+        {
+            SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
+            return FALSE;
+        }
+        if (!lpBuffer || dwBufferLength != sizeof(ULONG))
+        {
+            SetLastError(ERROR_INVALID_PARAMETER);
+            ret = FALSE;
+        }
+        else
+        {
+            lpwhh->connect_timeout = *(ULONG *)lpBuffer;
+        }
+        break;
+    }
     case INTERNET_OPTION_DATA_RECEIVE_TIMEOUT:
-      {
-        ULONG receivetimeout = *(ULONG *)lpBuffer;
-        FIXME("Option INTERNET_OPTION_DATA_RECEIVE_TIMEOUT (%ld): STUB\n", receivetimeout);
-      }
-      break;
+    {
+        if (!lpwhh)
+        {
+            SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
+            return FALSE;
+        }
+        if (!lpBuffer || dwBufferLength != sizeof(ULONG))
+        {
+            SetLastError(ERROR_INVALID_PARAMETER);
+            ret = FALSE;
+        }
+        else
+        {
+            lpwhh->data_receive_timeout = *(ULONG *)lpBuffer;
+        }
+        break;
+    }
     case INTERNET_OPTION_RESET_URLCACHE_SESSION:
         FIXME("Option INTERNET_OPTION_RESET_URLCACHE_SESSION: STUB\n");
         break;
@@ -3413,11 +3590,57 @@ BOOL WINAPI InternetSetOptionW(HINTERNET hInternet, DWORD dwOption,
         FIXME("Option INTERNET_OPTION_IGNORE_OFFLINE: STUB\n");
         break;
     case INTERNET_OPTION_SEND_TIMEOUT:
+    {
+        if (!lpwhh)
+        {
+            SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
+            return FALSE;
+        }
+        if (!lpBuffer || dwBufferLength != sizeof(ULONG))
+        {
+            SetLastError(ERROR_INVALID_PARAMETER);
+            ret = FALSE;
+        }
+        else
+        {
+            lpwhh->send_timeout = *(ULONG *)lpBuffer;
+        }
+        break;
+    }
     case INTERNET_OPTION_RECEIVE_TIMEOUT:
+    {
+        if (!lpwhh)
+        {
+            SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
+            return FALSE;
+        }
+        if (!lpBuffer || dwBufferLength != sizeof(ULONG))
+        {
+            SetLastError(ERROR_INVALID_PARAMETER);
+            ret = FALSE;
+        }
+        else
+        {
+            lpwhh->receive_timeout = *(ULONG *)lpBuffer;
+        }
+        break;
+    }
     case INTERNET_OPTION_DATA_SEND_TIMEOUT:
     {
-        ULONG timeout = *(ULONG *)lpBuffer;
-        FIXME("INTERNET_OPTION_SEND/RECEIVE_TIMEOUT/DATA_SEND_TIMEOUT %ld\n", timeout);
+        if (!lpwhh)
+        {
+            SetLastError(ERROR_INTERNET_INCORRECT_HANDLE_TYPE);
+            return FALSE;
+        }
+        if (!lpBuffer || dwBufferLength != sizeof(ULONG))
+        {
+            SetLastError(ERROR_INVALID_PARAMETER);
+            ret = FALSE;
+        }
+        else
+        {
+            lpwhh->data_send_timeout = *(ULONG *)lpBuffer;
+        }
         break;
     }
     case INTERNET_OPTION_CONNECT_RETRIES:
diff --git a/dlls/wininet/internet.h b/dlls/wininet/internet.h
index b5be0523188..f77cadc730f 100644
--- a/dlls/wininet/internet.h
+++ b/dlls/wininet/internet.h
@@ -240,6 +240,11 @@ struct _object_header_t
     WH_TYPE htype;
     const object_vtbl_t *vtbl;
     HINTERNET hInternet;
+    ULONG  connect_timeout;
+    ULONG  send_timeout;
+    ULONG  receive_timeout;
+    ULONG  data_send_timeout;
+    ULONG  data_receive_timeout;
     BOOL valid_handle;
     DWORD  dwFlags;
     DWORD_PTR dwContext;
@@ -262,7 +267,6 @@ typedef struct
     LPWSTR  proxyUsername;
     LPWSTR  proxyPassword;
     DWORD   accessType;
-    DWORD   connect_timeout;
 } appinfo_t;
 
 typedef struct
@@ -273,9 +277,6 @@ typedef struct
     LPWSTR  userName;
     LPWSTR  password;
     INTERNET_PORT hostPort; /* the final destination port of the request */
-    DWORD connect_timeout;
-    DWORD send_timeout;
-    DWORD receive_timeout;
 } http_session_t;
 
 #define HDR_ISREQUEST		0x0001
@@ -317,9 +318,6 @@ typedef struct
     LPWSTR verb;
     netconn_t *netconn;
     DWORD security_flags;
-    DWORD connect_timeout;
-    DWORD send_timeout;
-    DWORD receive_timeout;
     LPWSTR version;
     DWORD status_code;
     LPWSTR statusText;
diff --git a/dlls/wininet/tests/internet.c b/dlls/wininet/tests/internet.c
index b1216d63de7..c432de9e488 100644
--- a/dlls/wininet/tests/internet.c
+++ b/dlls/wininet/tests/internet.c
@@ -282,13 +282,59 @@ static void test_InternetQueryOptionA(void)
 
   InternetCloseHandle(hinet);
 
+  /* Connect timeout */
   val = 12345;
   res = InternetSetOptionA(NULL, INTERNET_OPTION_CONNECT_TIMEOUT, &val, sizeof(val));
   ok(res, "InternetSetOptionA(INTERNET_OPTION_CONNECT_TIMEOUT) failed (%lu)\n", GetLastError());
 
   len = sizeof(val);
   res = InternetQueryOptionA(NULL, INTERNET_OPTION_CONNECT_TIMEOUT, &val, &len);
-  ok(res, "InternetQueryOptionA failed %ld)\n", GetLastError());
+  ok(res, "InternetQueryOptionA(INTERNET_OPTION_CONNECT_TIMEOUT) failed %ld)\n", GetLastError());
+  ok(val == 12345, "val = %ld\n", val);
+  ok(len == sizeof(val), "len = %ld\n", len);
+
+  /* Receive Timeout */
+  val = 54321;
+  res = InternetSetOptionA(NULL, INTERNET_OPTION_RECEIVE_TIMEOUT, &val, sizeof(val));
+  ok(res, "InternetSetOptionA(INTERNET_OPTION_RECEIVE_TIMEOUT) failed (%lu)\n", GetLastError());
+
+  len = sizeof(val);
+  res = InternetQueryOptionA(NULL, INTERNET_OPTION_RECEIVE_TIMEOUT, &val, &len);
+  ok(res, "InternetQueryOptionA(INTERNET_OPTION_RECEIVE_TIMEOUT) failed %ld)\n", GetLastError());
+  ok(val == 54321, "val = %ld\n", val);
+  ok(len == sizeof(val), "len = %ld\n", len);
+
+  /* Send Timeout */
+  val = 12345;
+  res = InternetSetOptionA(NULL, INTERNET_OPTION_SEND_TIMEOUT, &val, sizeof(val));
+  ok(res, "InternetSetOptionA(INTERNET_OPTION_SEND_TIMEOUT) failed (%lu)\n", GetLastError());
+
+  len = sizeof(val);
+  res = InternetQueryOptionA(NULL, INTERNET_OPTION_SEND_TIMEOUT, &val, &len);
+  ok(res, "InternetQueryOptionA(INTERNET_OPTION_SEND_TIMEOUT) failed %ld)\n", GetLastError());
+  ok(val == 12345, "val = %ld\n", val);
+  ok(len == sizeof(val), "len = %ld\n", len);
+
+  /* Data Receive Timeout */
+  val = 54321;
+  res = InternetSetOptionA(NULL, INTERNET_OPTION_RECEIVE_TIMEOUT, &val, sizeof(val));
+  ok(res, "InternetSetOptionA(INTERNET_OPTION_RECEIVE_TIMEOUT) failed (%lu)\n", GetLastError());
+
+  len = sizeof(val);
+  res = InternetQueryOptionA(NULL, INTERNET_OPTION_RECEIVE_TIMEOUT, &val, &len);
+  ok(res, "InternetQueryOptionA(INTERNET_OPTION_RECEIVE_TIMEOUT) failed %ld)\n", GetLastError());
+  ok(val == 54321, "val = %ld\n", val);
+  ok(len == sizeof(val), "len = %ld\n", len);
+
+  /* Data Send Timeout */
+  val = 12345;
+  res = InternetSetOptionA(NULL, INTERNET_OPTION_DATA_SEND_TIMEOUT, &val, sizeof(val));
+  ok(res, "InternetSetOptionA(INTERNET_OPTION_DATA_SEND_TIMEOUT) failed (%lu)\n", GetLastError());
+
+  val = 0xdeadbeef;
+  len = sizeof(val);
+  res = InternetQueryOptionA(NULL, INTERNET_OPTION_DATA_SEND_TIMEOUT, &val, &len);
+  ok(res, "InternetQueryOptionA(INTERNET_OPTION_DATA_SEND_TIMEOUT) failed %ld)\n", GetLastError());
   ok(val == 12345, "val = %ld\n", val);
   ok(len == sizeof(val), "len = %ld\n", len);
 
@@ -308,6 +354,7 @@ static void test_InternetQueryOptionA(void)
   ok(!res, "InternetQueryOptionA(INTERNET_OPTION_MAX_CONNS_PER_SERVER) succeeded\n");
   ok(GetLastError() == ERROR_INTERNET_INVALID_OPERATION, "GetLastError() = %lu\n", GetLastError());
 
+  /* Connect Timeout */
   val = 2;
   res = InternetSetOptionA(hinet, INTERNET_OPTION_MAX_CONNS_PER_SERVER, &val, sizeof(val));
   ok(!res, "InternetSetOptionA(INTERNET_OPTION_MAX_CONNS_PER_SERVER) succeeded\n");
@@ -315,7 +362,7 @@ static void test_InternetQueryOptionA(void)
 
   len = sizeof(val);
   res = InternetQueryOptionA(hinet, INTERNET_OPTION_CONNECT_TIMEOUT, &val, &len);
-  ok(res, "InternetQueryOptionA failed %ld)\n", GetLastError());
+  ok(res, "InternetQueryOptionA(INTERNET_OPTION_CONNECT_TIMEOUT) failed %ld)\n", GetLastError());
   ok(val == 12345, "val = %ld\n", val);
   ok(len == sizeof(val), "len = %ld\n", len);
 
@@ -325,16 +372,141 @@ static void test_InternetQueryOptionA(void)
 
   len = sizeof(val);
   res = InternetQueryOptionA(hinet, INTERNET_OPTION_CONNECT_TIMEOUT, &val, &len);
-  ok(res, "InternetQueryOptionA failed %ld)\n", GetLastError());
+  ok(res, "InternetQueryOptionA(INTERNET_OPTION_CONNECT_TIMEOUT) failed %ld)\n", GetLastError());
   ok(val == 1, "val = %ld\n", val);
   ok(len == sizeof(val), "len = %ld\n", len);
 
+  /* Receive Timeout */
+  val = 60;
+  res = InternetSetOptionA(hinet, INTERNET_OPTION_RECEIVE_TIMEOUT, &val, sizeof(val));
+  ok(res, "InternetSetOptionA(INTERNET_OPTION_RECEIVE_TIMEOUT) failed (%lu)\n", GetLastError());
+
   len = sizeof(val);
-  res = InternetQueryOptionA(NULL, INTERNET_OPTION_CONNECT_TIMEOUT, &val, &len);
-  ok(res, "InternetQueryOptionA failed %ld)\n", GetLastError());
-  ok(val == 12345, "val = %ld\n", val);
+  res = InternetQueryOptionA(hinet, INTERNET_OPTION_RECEIVE_TIMEOUT, &val, &len);
+  ok(res, "InternetQueryOptionA(INTERNET_OPTION_RECEIVE_TIMEOUT) failed %ld)\n", GetLastError());
+  ok(val == 60, "val = %ld\n", val);
   ok(len == sizeof(val), "len = %ld\n", len);
 
+  /* Send Timeout */
+  val = 120;
+  res = InternetSetOptionA(hinet, INTERNET_OPTION_SEND_TIMEOUT, &val, sizeof(val));
+  ok(res, "InternetSetOptionA(INTERNET_OPTION_SEND_TIMEOUT) failed (%lu)\n", GetLastError());
+
+  len = sizeof(val);
+  res = InternetQueryOptionA(hinet, INTERNET_OPTION_SEND_TIMEOUT, &val, &len);
+  ok(res, "InternetQueryOptionA(INTERNET_OPTION_SEND_TIMEOUT) failed %ld)\n", GetLastError());
+  ok(val == 120, "val = %ld\n", val);
+  ok(len == sizeof(val), "len = %ld\n", len);
+
+  /* Data Receive Timeout */
+  val = 60;
+  res = InternetSetOptionA(hinet, INTERNET_OPTION_DATA_RECEIVE_TIMEOUT, &val, sizeof(val));
+  ok(res, "InternetSetOptionA(INTERNET_OPTION_DATA_RECEIVE_TIMEOUT) failed (%lu)\n", GetLastError());
+
+  len = sizeof(val);
+  res = InternetQueryOptionA(hinet, INTERNET_OPTION_DATA_RECEIVE_TIMEOUT, &val, &len);
+  ok(res, "InternetQueryOptionA(INTERNET_OPTION_DATA_RECEIVE_TIMEOUT) failed %ld)\n", GetLastError());
+  ok(val == 60, "val = %ld\n", val);
+  ok(len == sizeof(val), "len = %ld\n", len);
+
+  /* Data Send Timeout */
+  val = 120;
+  res = InternetSetOptionA(hinet, INTERNET_OPTION_DATA_SEND_TIMEOUT, &val, sizeof(val));
+  ok(res, "InternetSetOptionA(INTERNET_OPTION_DATA_SEND_TIMEOUT) failed (%lu)\n", GetLastError());
+
+  len = sizeof(val);
+  res = InternetQueryOptionA(hinet, INTERNET_OPTION_DATA_SEND_TIMEOUT, &val, &len);
+  ok(res, "InternetQueryOptionA(INTERNET_OPTION_DATA_SEND_TIMEOUT) failed %ld)\n", GetLastError());
+  ok(val == 120, "val = %ld\n", val);
+  ok(len == sizeof(val), "len = %ld\n", len);
+
+  /* Timeout inheritance */
+  val = 15000;
+  len = sizeof(val);
+  res = InternetSetOptionA(hinet, INTERNET_OPTION_CONNECT_TIMEOUT, &val, sizeof(val));
+  ok(res, "InternetSetOptionA(INTERNET_OPTION_CONNECT_TIMEOUT) failed (%lu)\n", GetLastError());
+  res = InternetSetOptionA(hinet, INTERNET_OPTION_SEND_TIMEOUT, &val, sizeof(val));
+  ok(res, "InternetSetOptionA(INTERNET_OPTION_SEND_TIMEOUT) failed (%lu)\n", GetLastError());
+  res = InternetSetOptionA(hinet, INTERNET_OPTION_RECEIVE_TIMEOUT, &val, sizeof(val));
+  ok(res, "InternetSetOptionA(INTERNET_OPTION_RECEIVE_TIMEOUT) failed (%lu)\n", GetLastError());
+  res = InternetSetOptionA(hinet, INTERNET_OPTION_DATA_SEND_TIMEOUT, &val, sizeof(val));
+  ok(res, "InternetSetOptionA(INTERNET_OPTION_DATA_SEND_TIMEOUT) failed (%lu)\n", GetLastError());
+  res = InternetSetOptionA(hinet, INTERNET_OPTION_DATA_RECEIVE_TIMEOUT, &val, sizeof(val));
+  ok(res, "InternetSetOptionA(INTERNET_OPTION_DATA_RECEIVE_TIMEOUT) failed (%lu)\n", GetLastError());
+
+  hurl = InternetConnectA(hinet,"www.winehq.org",INTERNET_DEFAULT_HTTP_PORT,NULL,NULL,INTERNET_SERVICE_HTTP,0,0);
+
+  val = 0xdeadbeef;
+  res = InternetQueryOptionA(hurl, INTERNET_OPTION_CONNECT_TIMEOUT, &val, &len);
+  ok(val == 15000, "failed to inherit INTERNET_OPTION_CONNECT_TIMEOUT on child connection (found %ld) - Error: %ld)\n", val, GetLastError());
+
+  val = 0xdeadbeef;
+  res = InternetQueryOptionA(hurl, INTERNET_OPTION_SEND_TIMEOUT, &val, &len);
+  ok(val == 15000, "failed to inherit INTERNET_OPTION_SEND_TIMEOUT on child connection (found %ld) - Error: %ld)\n", val, GetLastError());
+
+  val = 0xdeadbeef;
+  res = InternetQueryOptionA(hurl, INTERNET_OPTION_RECEIVE_TIMEOUT, &val, &len);
+  ok(val == 15000, "failed to inherit INTERNET_OPTION_RECEIVE_TIMEOUT on child connection (found %ld) - Error: %ld)\n", val, GetLastError());
+
+  val = 0xdeadbeef;
+  res = InternetQueryOptionA(hurl, INTERNET_OPTION_DATA_SEND_TIMEOUT, &val, &len);
+  ok(val == 15000, "failed to inherit INTERNET_OPTION_DATA_SEND_TIMEOUTt on child connection (found %ld) - Error: %ld)\n", val, GetLastError());
+
+  val = 0xdeadbeef;
+  res = InternetQueryOptionA(hurl, INTERNET_OPTION_DATA_RECEIVE_TIMEOUT, &val, &len);
+  ok(val == 15000, "failed to inherit INTERNET_OPTION_DATA_RECEIVE_TIMEOUT on child connection (found %ld) - Error: %ld)\n", val, GetLastError());
+
+  val = 12345;
+  res = InternetSetOptionA(hinet, INTERNET_OPTION_CONNECT_TIMEOUT, &val, sizeof(val));
+  ok(res, "InternetSetOptionA(INTERNET_OPTION_CONNECT_TIMEOUT) failed (%lu)\n", GetLastError());
+
+  val = 0xdeadbeef;
+  res = InternetQueryOptionA(hurl, INTERNET_OPTION_CONNECT_TIMEOUT, &val, &len);
+  ok(val == 15000, "Connection handle inherited value (INTERNET_OPTION_CONNECT_TIMEOUT) as %ld\n", val);
+  res = InternetQueryOptionA(hinet, INTERNET_OPTION_CONNECT_TIMEOUT, &val, &len);
+  ok(val == 12345, "Parent handle set from inherited value (INTERNET_OPTION_CONNECT_TIMEOUT) as %ld\n", val);
+
+  val = 12345;
+  res = InternetSetOptionA(hinet, INTERNET_OPTION_SEND_TIMEOUT, &val, sizeof(val));
+  ok(res, "InternetSetOptionA(INTERNET_OPTION_SEND_TIMEOUT) failed (%lu)\n", GetLastError());
+
+  val = 0xdeadbeef;
+  res = InternetQueryOptionA(hurl, INTERNET_OPTION_SEND_TIMEOUT, &val, &len);
+  ok(val == 15000, "Connection handle inherited value (INTERNET_OPTION_SEND_TIMEOUT) as %ld\n", val);
+  res = InternetQueryOptionA(hinet, INTERNET_OPTION_SEND_TIMEOUT, &val, &len);
+  ok(val == 12345, "Parent handle set from inherited value (INTERNET_OPTION_SEND_TIMEOUT) as %ld\n", val);
+
+  val = 12345;
+  res = InternetSetOptionA(hinet, INTERNET_OPTION_RECEIVE_TIMEOUT, &val, sizeof(val));
+  ok(res, "InternetSetOptionA(INTERNET_OPTION_RECEIVE_TIMEOUT) failed (%lu)\n", GetLastError());
+
+  val = 0xdeadbeef;
+  res = InternetQueryOptionA(hurl, INTERNET_OPTION_RECEIVE_TIMEOUT, &val, &len);
+  ok(val == 15000, "Connection handle inherited value (INTERNET_OPTION_RECEIVE_TIMEOUT) as %ld\n", val);
+  res = InternetQueryOptionA(hinet, INTERNET_OPTION_RECEIVE_TIMEOUT, &val, &len);
+  ok(val == 12345, "Parent handle set from inherited value (INTERNET_OPTION_RECEIVE_TIMEOUT) as %ld\n", val);
+
+  val = 12345;
+  res = InternetSetOptionA(hinet, INTERNET_OPTION_DATA_SEND_TIMEOUT, &val, sizeof(val));
+  ok(res, "InternetSetOptionA(INTERNET_OPTION_DATA_SEND_TIMEOUT) failed (%lu)\n", GetLastError());
+
+  val = 0xdeadbeef;
+  res = InternetQueryOptionA(hurl, INTERNET_OPTION_DATA_SEND_TIMEOUT, &val, &len);
+  ok(val == 15000, "Connection handle inherited value (INTERNET_OPTION_DATA_SEND_TIMEOUT) as %ld\n", val);
+  res = InternetQueryOptionA(hinet, INTERNET_OPTION_DATA_SEND_TIMEOUT, &val, &len);
+  ok(val == 12345, "Parent handle set from inherited value (INTERNET_OPTION_DATA_SEND_TIMEOUT) as %ld\n", val);
+
+  val = 12345;
+  res = InternetSetOptionA(hinet, INTERNET_OPTION_DATA_RECEIVE_TIMEOUT, &val, sizeof(val));
+  ok(res, "InternetSetOptionA(INTERNET_OPTION_DATA_RECEIVE_TIMEOUT) failed (%lu)\n", GetLastError());
+
+  val = 0xdeadbeef;
+  res = InternetQueryOptionA(hurl, INTERNET_OPTION_DATA_RECEIVE_TIMEOUT, &val, &len);
+  ok(val == 15000, "Connection handle inherited value (INTERNET_OPTION_DATA_RECEIVE_TIMEOUT) as %ld\n", val);
+  res = InternetQueryOptionA(hinet, INTERNET_OPTION_DATA_RECEIVE_TIMEOUT, &val, &len);
+  ok(val == 12345, "Parent handle set from inherited value (INTERNET_OPTION_DATA_RECEIVE_TIMEOUT) as %ld\n", val);
+
+  InternetCloseHandle(hurl);
   InternetCloseHandle(hinet);
 }
 
-- 
GitLab

https://gitlab.winehq.org/wine/wine/-/merge_requests/3518