1 /* 2 * Wininet - HTTP tests 3 * 4 * Copyright 2002 Aric Stewart 5 * Copyright 2004 Mike McCormack 6 * Copyright 2005 Hans Leidekker 7 * 8 * This library is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU Lesser General Public 10 * License as published by the Free Software Foundation; either 11 * version 2.1 of the License, or (at your option) any later version. 12 * 13 * This library is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * Lesser General Public License for more details. 17 * 18 * You should have received a copy of the GNU Lesser General Public 19 * License along with this library; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA 21 */ 22 23 #include <stdarg.h> 24 #include <stdio.h> 25 #include <stdlib.h> 26 #include <limits.h> 27 28 #include "windef.h" 29 #include "winbase.h" 30 #include "wininet.h" 31 #include "winineti.h" 32 #include "winsock2.h" 33 34 #include "wine/test.h" 35 36 /* Undocumented security flags */ 37 #define _SECURITY_FLAG_CERT_REV_FAILED 0x00800000 38 #define _SECURITY_FLAG_CERT_INVALID_CA 0x01000000 39 #define _SECURITY_FLAG_CERT_INVALID_CN 0x02000000 40 #define _SECURITY_FLAG_CERT_INVALID_DATE 0x04000000 41 42 #define TEST_URL "http://test.winehq.org/tests/hello.html" 43 44 static BOOL first_connection_to_test_url = TRUE; 45 46 /* Adapted from dlls/urlmon/tests/protocol.c */ 47 48 #define SET_EXPECT2(status, num) \ 49 expect[status] = num 50 51 #define SET_EXPECT(status) \ 52 SET_EXPECT2(status, 1) 53 54 #define SET_OPTIONAL2(status, num) \ 55 optional[status] = num 56 57 #define SET_OPTIONAL(status) \ 58 SET_OPTIONAL2(status, 1) 59 60 /* SET_WINE_ALLOW's should be used with an appropriate 61 * todo_wine CHECK_NOTIFIED at a later point in the code */ 62 #define SET_WINE_ALLOW2(status, num) \ 63 wine_allow[status] = num 64 65 #define SET_WINE_ALLOW(status) \ 66 SET_WINE_ALLOW2(status, 1) 67 68 #define CHECK_EXPECT(status) \ 69 do { \ 70 if (!expect[status] && !optional[status] && wine_allow[status]) \ 71 { \ 72 todo_wine ok(expect[status], "unexpected status %d (%s)\n", status, \ 73 status < MAX_INTERNET_STATUS && status_string[status] ? \ 74 status_string[status] : "unknown"); \ 75 wine_allow[status]--; \ 76 } \ 77 else \ 78 { \ 79 ok(expect[status] || optional[status], "unexpected status %d (%s)\n", status, \ 80 status < MAX_INTERNET_STATUS && status_string[status] ? \ 81 status_string[status] : "unknown"); \ 82 if (expect[status]) expect[status]--; \ 83 else if(optional[status]) optional[status]--; \ 84 } \ 85 notified[status]++; \ 86 }while(0) 87 88 /* CLEAR_NOTIFIED used in cases when notification behavior 89 * differs between Windows versions */ 90 #define CLEAR_NOTIFIED(status) \ 91 expect[status] = optional[status] = wine_allow[status] = notified[status] = 0; 92 93 #define CHECK_NOTIFIED2(status, num) \ 94 do { \ 95 ok(notified[status] + optional[status] == (num), \ 96 "expected status %d (%s) %d times, received %d times\n", \ 97 status, status < MAX_INTERNET_STATUS && status_string[status] ? \ 98 status_string[status] : "unknown", (num), notified[status]); \ 99 CLEAR_NOTIFIED(status); \ 100 }while(0) 101 102 #define CHECK_NOTIFIED(status) \ 103 CHECK_NOTIFIED2(status, 1) 104 105 #define CHECK_NOT_NOTIFIED(status) \ 106 CHECK_NOTIFIED2(status, 0) 107 108 #define MAX_INTERNET_STATUS (INTERNET_STATUS_COOKIE_HISTORY+1) 109 static int expect[MAX_INTERNET_STATUS], optional[MAX_INTERNET_STATUS], 110 wine_allow[MAX_INTERNET_STATUS], notified[MAX_INTERNET_STATUS]; 111 static const char *status_string[MAX_INTERNET_STATUS]; 112 113 static HANDLE complete_event, conn_close_event, conn_wait_event, server_req_rec_event, request_sent_event; 114 static DWORD req_error; 115 static BOOL is_ie7plus = TRUE; 116 117 #define TESTF_REDIRECT 0x01 118 #define TESTF_COMPRESSED 0x02 119 #define TESTF_CHUNKED 0x04 120 121 typedef struct { 122 const char *url; 123 const char *redirected_url; 124 const char *host; 125 const char *path; 126 const char *headers; 127 DWORD flags; 128 const char *post_data; 129 const char *content; 130 } test_data_t; 131 132 static const test_data_t test_data[] = { 133 { 134 "http://test.winehq.org/tests/data.php", 135 "http://test.winehq.org/tests/data.php", 136 "test.winehq.org", 137 "/tests/data.php", 138 "", 139 TESTF_CHUNKED 140 }, 141 { 142 "http://test.winehq.org/tests/redirect", 143 "http://test.winehq.org/tests/hello.html", 144 "test.winehq.org", 145 "/tests/redirect", 146 "", 147 TESTF_REDIRECT 148 }, 149 { 150 "http://test.winehq.org/tests/gzip.php", 151 "http://test.winehq.org/tests/gzip.php", 152 "test.winehq.org", 153 "/tests/gzip.php", 154 "Accept-Encoding: gzip, deflate", 155 TESTF_COMPRESSED 156 }, 157 { 158 "http://test.winehq.org/tests/post.php", 159 "http://test.winehq.org/tests/post.php", 160 "test.winehq.org", 161 "/tests/post.php", 162 "Content-Type: application/x-www-form-urlencoded", 163 0, 164 "mode=Test", 165 "mode => Test\n" 166 } 167 }; 168 169 static INTERNET_STATUS_CALLBACK (WINAPI *pInternetSetStatusCallbackA)(HINTERNET ,INTERNET_STATUS_CALLBACK); 170 static INTERNET_STATUS_CALLBACK (WINAPI *pInternetSetStatusCallbackW)(HINTERNET ,INTERNET_STATUS_CALLBACK); 171 static BOOL (WINAPI *pInternetGetSecurityInfoByURLA)(LPSTR,PCCERT_CHAIN_CONTEXT*,DWORD*); 172 173 static int strcmp_wa(LPCWSTR strw, const char *stra) 174 { 175 WCHAR buf[512]; 176 MultiByteToWideChar(CP_ACP, 0, stra, -1, buf, ARRAY_SIZE(buf)); 177 return lstrcmpW(strw, buf); 178 } 179 180 static BOOL proxy_active(void) 181 { 182 HKEY internet_settings; 183 DWORD proxy_enable; 184 DWORD size; 185 186 if (RegOpenKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings", 187 0, KEY_QUERY_VALUE, &internet_settings) != ERROR_SUCCESS) 188 return FALSE; 189 190 size = sizeof(DWORD); 191 if (RegQueryValueExA(internet_settings, "ProxyEnable", NULL, NULL, (LPBYTE) &proxy_enable, &size) != ERROR_SUCCESS) 192 proxy_enable = 0; 193 194 RegCloseKey(internet_settings); 195 196 return proxy_enable != 0; 197 } 198 199 static void init_events(void) 200 { 201 complete_event = CreateEventW(NULL, FALSE, FALSE, NULL); 202 conn_close_event = CreateEventW(NULL, FALSE, FALSE, NULL); 203 conn_wait_event = CreateEventW(NULL, FALSE, FALSE, NULL); 204 server_req_rec_event = CreateEventW(NULL, FALSE, FALSE, NULL); 205 request_sent_event = CreateEventW(NULL, FALSE, FALSE, NULL); 206 } 207 208 static void free_events(void) 209 { 210 CloseHandle(complete_event); 211 CloseHandle(conn_close_event); 212 CloseHandle(conn_wait_event); 213 CloseHandle(server_req_rec_event); 214 CloseHandle(request_sent_event); 215 } 216 217 static void reset_events(void) 218 { 219 ResetEvent(complete_event); 220 ResetEvent(conn_close_event); 221 ResetEvent(conn_wait_event); 222 ResetEvent(server_req_rec_event); 223 ResetEvent(request_sent_event); 224 } 225 226 #define test_status_code(a,b) _test_status_code(__LINE__,a,b, FALSE) 227 #define test_status_code_todo(a,b) _test_status_code(__LINE__,a,b, TRUE) 228 static void _test_status_code(unsigned line, HINTERNET req, DWORD excode, BOOL is_todo) 229 { 230 DWORD code, size, index; 231 char exbuf[12], bufa[10]; 232 WCHAR bufw[10]; 233 BOOL res; 234 235 code = 0xdeadbeef; 236 size = sizeof(code); 237 res = HttpQueryInfoA(req, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &code, &size, NULL); 238 ok_(__FILE__,line)(res, "[1] HttpQueryInfoA(HTTP_QUERY_STATUS_CODE|number) failed: %u\n", GetLastError()); 239 todo_wine_if (is_todo) 240 ok_(__FILE__,line)(code == excode, "code = %d, expected %d\n", code, excode); 241 ok_(__FILE__,line)(size == sizeof(code), "size = %u\n", size); 242 243 code = 0xdeadbeef; 244 index = 0; 245 size = sizeof(code); 246 res = HttpQueryInfoA(req, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &code, &size, &index); 247 ok_(__FILE__,line)(res, "[2] HttpQueryInfoA(HTTP_QUERY_STATUS_CODE|number index) failed: %u\n", GetLastError()); 248 ok_(__FILE__,line)(!index, "index = %d, expected 0\n", index); 249 ok_(__FILE__,line)(size == sizeof(code), "size = %u\n", size); 250 251 sprintf(exbuf, "%u", excode); 252 253 size = sizeof(bufa); 254 res = HttpQueryInfoA(req, HTTP_QUERY_STATUS_CODE, bufa, &size, NULL); 255 ok_(__FILE__,line)(res, "[3] HttpQueryInfoA(HTTP_QUERY_STATUS_CODE) failed: %u\n", GetLastError()); 256 todo_wine_if (is_todo) 257 ok_(__FILE__,line)(!strcmp(bufa, exbuf), "unexpected status code %s, expected %s\n", bufa, exbuf); 258 ok_(__FILE__,line)(size == strlen(exbuf), "unexpected size %d for \"%s\"\n", size, exbuf); 259 260 size = 0; 261 res = HttpQueryInfoA(req, HTTP_QUERY_STATUS_CODE, NULL, &size, NULL); 262 ok_(__FILE__,line)(!res && GetLastError() == ERROR_INSUFFICIENT_BUFFER, 263 "[4] HttpQueryInfoA(HTTP_QUERY_STATUS_CODE) failed: %u\n", GetLastError()); 264 ok_(__FILE__,line)(size == strlen(exbuf)+1, "unexpected size %d for \"%s\"\n", size, exbuf); 265 266 size = sizeof(bufw); 267 res = HttpQueryInfoW(req, HTTP_QUERY_STATUS_CODE, bufw, &size, NULL); 268 ok_(__FILE__,line)(res, "[5] HttpQueryInfoW(HTTP_QUERY_STATUS_CODE) failed: %u\n", GetLastError()); 269 todo_wine_if (is_todo) 270 ok_(__FILE__,line)(!strcmp_wa(bufw, exbuf), "unexpected status code %s, expected %s\n", bufa, exbuf); 271 ok_(__FILE__,line)(size == strlen(exbuf)*sizeof(WCHAR), "unexpected size %d for \"%s\"\n", size, exbuf); 272 273 size = 0; 274 res = HttpQueryInfoW(req, HTTP_QUERY_STATUS_CODE, bufw, &size, NULL); 275 ok_(__FILE__,line)(!res && GetLastError() == ERROR_INSUFFICIENT_BUFFER, 276 "[6] HttpQueryInfoW(HTTP_QUERY_STATUS_CODE) failed: %u\n", GetLastError()); 277 ok_(__FILE__,line)(size == (strlen(exbuf)+1)*sizeof(WCHAR), "unexpected size %d for \"%s\"\n", size, exbuf); 278 279 if(0) { 280 size = sizeof(bufw); 281 res = HttpQueryInfoW(req, HTTP_QUERY_STATUS_CODE, NULL, &size, NULL); 282 ok(!res && GetLastError() == ERROR_INVALID_PARAMETER, "HttpQueryInfo(HTTP_QUERY_STATUS_CODE) failed: %u\n", GetLastError()); 283 ok(size == sizeof(bufw), "unexpected size %d\n", size); 284 } 285 286 code = 0xdeadbeef; 287 index = 1; 288 size = sizeof(code); 289 res = HttpQueryInfoA(req, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &code, &size, &index); 290 ok_(__FILE__,line)(!res && GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND, 291 "[7] HttpQueryInfoA failed: %x(%d)\n", res, GetLastError()); 292 293 code = 0xdeadbeef; 294 size = sizeof(code); 295 res = HttpQueryInfoA(req, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_REQUEST_HEADERS, &code, &size, NULL); 296 ok_(__FILE__,line)(!res && GetLastError() == ERROR_HTTP_INVALID_QUERY_REQUEST, 297 "[8] HttpQueryInfoA failed: %x(%d)\n", res, GetLastError()); 298 } 299 300 #define test_request_flags(a,b) _test_request_flags(__LINE__,a,b,FALSE) 301 #define test_request_flags_todo(a,b) _test_request_flags(__LINE__,a,b,TRUE) 302 static void _test_request_flags(unsigned line, HINTERNET req, DWORD exflags, BOOL is_todo) 303 { 304 DWORD flags, size; 305 BOOL res; 306 307 flags = 0xdeadbeef; 308 size = sizeof(flags); 309 res = InternetQueryOptionW(req, INTERNET_OPTION_REQUEST_FLAGS, &flags, &size); 310 ok_(__FILE__,line)(res, "InternetQueryOptionW(INTERNET_OPTION_REQUEST_FLAGS) failed: %u\n", GetLastError()); 311 312 /* FIXME: Remove once we have INTERNET_REQFLAG_CACHE_WRITE_DISABLED implementation */ 313 flags &= ~INTERNET_REQFLAG_CACHE_WRITE_DISABLED; 314 todo_wine_if (is_todo) 315 ok_(__FILE__,line)(flags == exflags, "flags = %x, expected %x\n", flags, exflags); 316 } 317 318 #define test_request_url(a,b) _test_request_url(__LINE__,a,b) 319 static void _test_request_url(unsigned line, HINTERNET req, const char *expected_url) 320 { 321 char buf[INTERNET_MAX_URL_LENGTH]; 322 DWORD size = sizeof(buf); 323 BOOL res; 324 325 res = InternetQueryOptionA(req, INTERNET_OPTION_URL, buf, &size); 326 ok_(__FILE__,line)(res, "InternetQueryOptionA(INTERNET_OPTION_URL) failed: %u\n", GetLastError()); 327 ok_(__FILE__,line)(size == strlen(expected_url), "size = %u\n", size); 328 ok_(__FILE__,line)(!strcmp(buf, expected_url), "unexpected URL %s, expected %s\n", buf, expected_url); 329 } 330 331 #define test_http_version(a) _test_http_version(__LINE__,a) 332 static void _test_http_version(unsigned line, HINTERNET req) 333 { 334 HTTP_VERSION_INFO v = {0xdeadbeef, 0xdeadbeef}; 335 DWORD size; 336 BOOL res; 337 338 size = sizeof(v); 339 res = InternetQueryOptionW(req, INTERNET_OPTION_HTTP_VERSION, &v, &size); 340 ok_(__FILE__,line)(res, "InternetQueryOptionW(INTERNET_OPTION_HTTP_VERSION) failed: %u\n", GetLastError()); 341 ok_(__FILE__,line)(v.dwMajorVersion == 1, "dwMajorVersion = %d\n", v.dwMajorVersion); 342 ok_(__FILE__,line)(v.dwMinorVersion == 1, "dwMinorVersion = %d\n", v.dwMinorVersion); 343 } 344 345 static int close_handle_cnt; 346 347 static VOID WINAPI callback( 348 HINTERNET hInternet, 349 DWORD_PTR dwContext, 350 DWORD dwInternetStatus, 351 LPVOID lpvStatusInformation, 352 DWORD dwStatusInformationLength 353 ) 354 { 355 ros_skip_flaky 356 CHECK_EXPECT(dwInternetStatus); 357 switch (dwInternetStatus) 358 { 359 case INTERNET_STATUS_RESOLVING_NAME: 360 if(winetest_debug > 1) 361 trace("%04x:Callback %p 0x%lx INTERNET_STATUS_RESOLVING_NAME \"%s\" %d\n", 362 GetCurrentThreadId(), hInternet, dwContext, 363 (LPCSTR)lpvStatusInformation,dwStatusInformationLength); 364 *(LPSTR)lpvStatusInformation = '\0'; 365 break; 366 case INTERNET_STATUS_NAME_RESOLVED: 367 if(winetest_debug > 1) 368 trace("%04x:Callback %p 0x%lx INTERNET_STATUS_NAME_RESOLVED \"%s\" %d\n", 369 GetCurrentThreadId(), hInternet, dwContext, 370 (LPCSTR)lpvStatusInformation,dwStatusInformationLength); 371 *(LPSTR)lpvStatusInformation = '\0'; 372 break; 373 case INTERNET_STATUS_CONNECTING_TO_SERVER: 374 if(winetest_debug > 1) 375 trace("%04x:Callback %p 0x%lx INTERNET_STATUS_CONNECTING_TO_SERVER \"%s\" %d\n", 376 GetCurrentThreadId(), hInternet, dwContext, 377 (LPCSTR)lpvStatusInformation,dwStatusInformationLength); 378 ok(dwStatusInformationLength == strlen(lpvStatusInformation)+1, "unexpected size %u\n", 379 dwStatusInformationLength); 380 *(LPSTR)lpvStatusInformation = '\0'; 381 break; 382 case INTERNET_STATUS_CONNECTED_TO_SERVER: 383 if(winetest_debug > 1) 384 trace("%04x:Callback %p 0x%lx INTERNET_STATUS_CONNECTED_TO_SERVER \"%s\" %d\n", 385 GetCurrentThreadId(), hInternet, dwContext, 386 (LPCSTR)lpvStatusInformation,dwStatusInformationLength); 387 ok(dwStatusInformationLength == strlen(lpvStatusInformation)+1, "unexpected size %u\n", 388 dwStatusInformationLength); 389 *(LPSTR)lpvStatusInformation = '\0'; 390 break; 391 case INTERNET_STATUS_SENDING_REQUEST: 392 if(winetest_debug > 1) 393 trace("%04x:Callback %p 0x%lx INTERNET_STATUS_SENDING_REQUEST %p %d\n", 394 GetCurrentThreadId(), hInternet, dwContext, 395 lpvStatusInformation,dwStatusInformationLength); 396 break; 397 case INTERNET_STATUS_REQUEST_SENT: 398 ok(dwStatusInformationLength == sizeof(DWORD), 399 "info length should be sizeof(DWORD) instead of %d\n", 400 dwStatusInformationLength); 401 if(winetest_debug > 1) 402 trace("%04x:Callback %p 0x%lx INTERNET_STATUS_REQUEST_SENT 0x%x %d\n", 403 GetCurrentThreadId(), hInternet, dwContext, 404 *(DWORD *)lpvStatusInformation,dwStatusInformationLength); 405 break; 406 case INTERNET_STATUS_RECEIVING_RESPONSE: 407 if(winetest_debug > 1) 408 trace("%04x:Callback %p 0x%lx INTERNET_STATUS_RECEIVING_RESPONSE %p %d\n", 409 GetCurrentThreadId(), hInternet, dwContext, 410 lpvStatusInformation,dwStatusInformationLength); 411 break; 412 case INTERNET_STATUS_RESPONSE_RECEIVED: 413 ok(dwStatusInformationLength == sizeof(DWORD), 414 "info length should be sizeof(DWORD) instead of %d\n", 415 dwStatusInformationLength); 416 if(winetest_debug > 1) 417 trace("%04x:Callback %p 0x%lx INTERNET_STATUS_RESPONSE_RECEIVED 0x%x %d\n", 418 GetCurrentThreadId(), hInternet, dwContext, 419 *(DWORD *)lpvStatusInformation,dwStatusInformationLength); 420 break; 421 case INTERNET_STATUS_CTL_RESPONSE_RECEIVED: 422 if(winetest_debug > 1) 423 trace("%04x:Callback %p 0x%lx INTERNET_STATUS_CTL_RESPONSE_RECEIVED %p %d\n", 424 GetCurrentThreadId(), hInternet,dwContext, 425 lpvStatusInformation,dwStatusInformationLength); 426 break; 427 case INTERNET_STATUS_PREFETCH: 428 if(winetest_debug > 1) 429 trace("%04x:Callback %p 0x%lx INTERNET_STATUS_PREFETCH %p %d\n", 430 GetCurrentThreadId(), hInternet, dwContext, 431 lpvStatusInformation,dwStatusInformationLength); 432 break; 433 case INTERNET_STATUS_CLOSING_CONNECTION: 434 if(winetest_debug > 1) 435 trace("%04x:Callback %p 0x%lx INTERNET_STATUS_CLOSING_CONNECTION %p %d\n", 436 GetCurrentThreadId(), hInternet, dwContext, 437 lpvStatusInformation,dwStatusInformationLength); 438 break; 439 case INTERNET_STATUS_CONNECTION_CLOSED: 440 if(winetest_debug > 1) 441 trace("%04x:Callback %p 0x%lx INTERNET_STATUS_CONNECTION_CLOSED %p %d\n", 442 GetCurrentThreadId(), hInternet, dwContext, 443 lpvStatusInformation,dwStatusInformationLength); 444 break; 445 case INTERNET_STATUS_HANDLE_CREATED: 446 ok(dwStatusInformationLength == sizeof(HINTERNET), 447 "info length should be sizeof(HINTERNET) instead of %d\n", 448 dwStatusInformationLength); 449 if(winetest_debug > 1) 450 trace("%04x:Callback %p 0x%lx INTERNET_STATUS_HANDLE_CREATED %p %d\n", 451 GetCurrentThreadId(), hInternet, dwContext, 452 *(HINTERNET *)lpvStatusInformation,dwStatusInformationLength); 453 CLEAR_NOTIFIED(INTERNET_STATUS_DETECTING_PROXY); 454 SET_EXPECT(INTERNET_STATUS_DETECTING_PROXY); 455 break; 456 case INTERNET_STATUS_HANDLE_CLOSING: 457 ok(dwStatusInformationLength == sizeof(HINTERNET), 458 "info length should be sizeof(HINTERNET) instead of %d\n", 459 dwStatusInformationLength); 460 if(winetest_debug > 1) 461 trace("%04x:Callback %p 0x%lx INTERNET_STATUS_HANDLE_CLOSING %p %d\n", 462 GetCurrentThreadId(), hInternet, dwContext, 463 *(HINTERNET *)lpvStatusInformation, dwStatusInformationLength); 464 if(!InterlockedDecrement(&close_handle_cnt)) 465 SetEvent(complete_event); 466 break; 467 case INTERNET_STATUS_REQUEST_COMPLETE: 468 { 469 INTERNET_ASYNC_RESULT *iar = (INTERNET_ASYNC_RESULT *)lpvStatusInformation; 470 ok(dwStatusInformationLength == sizeof(INTERNET_ASYNC_RESULT), 471 "info length should be sizeof(INTERNET_ASYNC_RESULT) instead of %d\n", 472 dwStatusInformationLength); 473 ok(iar->dwResult == 1 || iar->dwResult == 0, "iar->dwResult = %ld\n", iar->dwResult); 474 if(winetest_debug > 1) 475 trace("%04x:Callback %p 0x%lx INTERNET_STATUS_REQUEST_COMPLETE {%ld,%d} %d\n", 476 GetCurrentThreadId(), hInternet, dwContext, 477 iar->dwResult,iar->dwError,dwStatusInformationLength); 478 req_error = iar->dwError; 479 if(!close_handle_cnt) 480 SetEvent(complete_event); 481 break; 482 } 483 case INTERNET_STATUS_REDIRECT: 484 if(winetest_debug > 1) 485 trace("%04x:Callback %p 0x%lx INTERNET_STATUS_REDIRECT \"%s\" %d\n", 486 GetCurrentThreadId(), hInternet, dwContext, 487 (LPCSTR)lpvStatusInformation, dwStatusInformationLength); 488 *(LPSTR)lpvStatusInformation = '\0'; 489 CLEAR_NOTIFIED(INTERNET_STATUS_DETECTING_PROXY); 490 SET_EXPECT(INTERNET_STATUS_DETECTING_PROXY); 491 break; 492 case INTERNET_STATUS_INTERMEDIATE_RESPONSE: 493 if(winetest_debug > 1) 494 trace("%04x:Callback %p 0x%lx INTERNET_STATUS_INTERMEDIATE_RESPONSE %p %d\n", 495 GetCurrentThreadId(), hInternet, dwContext, 496 lpvStatusInformation, dwStatusInformationLength); 497 break; 498 default: 499 if(winetest_debug > 1) 500 trace("%04x:Callback %p 0x%lx %d %p %d\n", 501 GetCurrentThreadId(), hInternet, dwContext, dwInternetStatus, 502 lpvStatusInformation, dwStatusInformationLength); 503 } 504 } 505 506 typedef struct { 507 HINTERNET session; 508 HINTERNET connection; 509 HINTERNET request; 510 } test_request_t; 511 512 #define open_simple_request(a,b,c,d,e) _open_simple_request(__LINE__,a,b,c,d,e) 513 static void _open_simple_request(unsigned line, test_request_t *req, const char *host, 514 int port, const char *verb, const char *url) 515 { 516 req->session = InternetOpenA(NULL, INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0); 517 ok_(__FILE__,line)(req->session != NULL, "InternetOpenA failed: %u\n", GetLastError()); 518 519 req->connection = InternetConnectA(req->session, host, port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); 520 ok_(__FILE__,line)(req->connection != NULL, "InternetConnectA failed: %u\n", GetLastError()); 521 522 req->request = HttpOpenRequestA(req->connection, verb, url, NULL, NULL, NULL, 0, 0); 523 ok_(__FILE__,line)(req->request != NULL, "HttpOpenRequest failed: %u\n", GetLastError()); 524 } 525 526 #define close_request(a) _close_request(__LINE__,a) 527 static void _close_request(unsigned line, test_request_t *req) 528 { 529 BOOL ret; 530 531 ret = InternetCloseHandle(req->request); 532 ok_(__FILE__,line)(ret, "InternetCloseHandle(request) failed: %u\n", GetLastError()); 533 ret = InternetCloseHandle(req->connection); 534 ok_(__FILE__,line)(ret, "InternetCloseHandle(connection) failed: %u\n", GetLastError()); 535 ret = InternetCloseHandle(req->session); 536 ok_(__FILE__,line)(ret, "InternetCloseHandle(session) failed: %u\n", GetLastError()); 537 } 538 539 #define receive_simple_request(a,b,c) _receive_simple_request(__LINE__,a,b,c) 540 static DWORD _receive_simple_request(unsigned line, HINTERNET req, char *buf, size_t buf_size) 541 { 542 DWORD read = 0; 543 BOOL ret; 544 545 ret = InternetReadFile(req, buf, buf_size, &read); 546 ok_(__FILE__,line)(ret, "InternetReadFile failed: %u\n", GetLastError()); 547 548 return read; 549 } 550 551 static void close_async_handle(HINTERNET handle, int handle_cnt) 552 { 553 BOOL res; 554 555 close_handle_cnt = handle_cnt; 556 557 SET_EXPECT2(INTERNET_STATUS_HANDLE_CLOSING, handle_cnt); 558 res = InternetCloseHandle(handle); 559 ok(res, "InternetCloseHandle failed: %u\n", GetLastError()); 560 WaitForSingleObject(complete_event, INFINITE); 561 CHECK_NOTIFIED2(INTERNET_STATUS_HANDLE_CLOSING, handle_cnt); 562 } 563 564 static void InternetReadFile_test(int flags, const test_data_t *test) 565 { 566 char *post_data = NULL; 567 BOOL res, on_async = TRUE; 568 CHAR buffer[4000]; 569 WCHAR wbuffer[4000]; 570 DWORD length, length2, index, exlen = 0, post_len = 0; 571 const char *types[2] = { "*", NULL }; 572 HINTERNET hi, hic = 0, hor = 0; 573 574 trace("Starting InternetReadFile test with flags 0x%x on url %s\n",flags,test->url); 575 reset_events(); 576 577 trace("InternetOpenA <--\n"); 578 hi = InternetOpenA((test->flags & TESTF_COMPRESSED) ? "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0)" : "", 579 INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, flags); 580 ok((hi != 0x0),"InternetOpen failed with error %u\n", GetLastError()); 581 trace("InternetOpenA -->\n"); 582 583 if (hi == 0x0) goto abort; 584 585 pInternetSetStatusCallbackA(hi,&callback); 586 587 SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED); 588 589 trace("InternetConnectA <--\n"); 590 hic=InternetConnectA(hi, test->host, INTERNET_INVALID_PORT_NUMBER, 591 NULL, NULL, INTERNET_SERVICE_HTTP, 0x0, 0xdeadbeef); 592 ok((hic != 0x0),"InternetConnect failed with error %u\n", GetLastError()); 593 trace("InternetConnectA -->\n"); 594 595 if (hic == 0x0) goto abort; 596 597 CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED); 598 SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED); 599 600 trace("HttpOpenRequestA <--\n"); 601 hor = HttpOpenRequestA(hic, test->post_data ? "POST" : "GET", test->path, NULL, NULL, types, 602 INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_RELOAD, 603 0xdeadbead); 604 if (hor == 0x0 && GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED) { 605 /* 606 * If the internet name can't be resolved we are probably behind 607 * a firewall or in some other way not directly connected to the 608 * Internet. Not enough reason to fail the test. Just ignore and 609 * abort. 610 */ 611 } else { 612 ok((hor != 0x0),"HttpOpenRequest failed with error %u\n", GetLastError()); 613 } 614 trace("HttpOpenRequestA -->\n"); 615 616 if (hor == 0x0) goto abort; 617 618 test_request_flags(hor, INTERNET_REQFLAG_NO_HEADERS); 619 test_request_url(hor, test->url); 620 621 length = sizeof(buffer); 622 res = HttpQueryInfoA(hor, HTTP_QUERY_RAW_HEADERS, buffer, &length, 0x0); 623 ok(res, "HttpQueryInfoA(HTTP_QUERY_RAW_HEADERS) failed with error %d\n", GetLastError()); 624 ok(length == 0 || (length == 1 && !*buffer) /* win10 */, "HTTP_QUERY_RAW_HEADERS: expected length 0, but got %d\n", length); 625 ok(!strcmp(buffer, ""), "HTTP_QUERY_RAW_HEADERS: expected string \"\", but got \"%s\"\n", buffer); 626 627 CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED); 628 CHECK_NOT_NOTIFIED(INTERNET_STATUS_RESOLVING_NAME); 629 CHECK_NOT_NOTIFIED(INTERNET_STATUS_NAME_RESOLVED); 630 SET_OPTIONAL2(INTERNET_STATUS_COOKIE_SENT,2); 631 SET_OPTIONAL2(INTERNET_STATUS_COOKIE_RECEIVED,2); 632 if (first_connection_to_test_url) 633 { 634 SET_EXPECT(INTERNET_STATUS_RESOLVING_NAME); 635 SET_EXPECT(INTERNET_STATUS_NAME_RESOLVED); 636 } 637 SET_EXPECT(INTERNET_STATUS_CONNECTING_TO_SERVER); 638 SET_EXPECT(INTERNET_STATUS_CONNECTED_TO_SERVER); 639 SET_EXPECT2(INTERNET_STATUS_SENDING_REQUEST, (test->flags & TESTF_REDIRECT) ? 2 : 1); 640 SET_EXPECT2(INTERNET_STATUS_REQUEST_SENT, (test->flags & TESTF_REDIRECT) ? 2 : 1); 641 SET_EXPECT2(INTERNET_STATUS_RECEIVING_RESPONSE, (test->flags & TESTF_REDIRECT) ? 2 : 1); 642 SET_EXPECT2(INTERNET_STATUS_RESPONSE_RECEIVED, (test->flags & TESTF_REDIRECT) ? 2 : 1); 643 if(test->flags & TESTF_REDIRECT) { 644 SET_OPTIONAL2(INTERNET_STATUS_CLOSING_CONNECTION, 2); 645 SET_OPTIONAL2(INTERNET_STATUS_CONNECTION_CLOSED, 2); 646 } 647 SET_EXPECT(INTERNET_STATUS_REDIRECT); 648 SET_OPTIONAL(INTERNET_STATUS_CONNECTING_TO_SERVER); 649 SET_OPTIONAL(INTERNET_STATUS_CONNECTED_TO_SERVER); 650 if (flags & INTERNET_FLAG_ASYNC) 651 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 652 653 if(test->flags & TESTF_COMPRESSED) { 654 BOOL b = TRUE; 655 656 res = InternetSetOptionA(hor, INTERNET_OPTION_HTTP_DECODING, &b, sizeof(b)); 657 ok(res || broken(!res && GetLastError() == ERROR_INTERNET_INVALID_OPTION), 658 "InternetSetOption failed: %u\n", GetLastError()); 659 if(!res) 660 goto abort; 661 } 662 663 test_status_code(hor, 0); 664 665 trace("HttpSendRequestA -->\n"); 666 if(test->post_data) { 667 post_len = strlen(test->post_data); 668 post_data = HeapAlloc(GetProcessHeap(), 0, post_len); 669 memcpy(post_data, test->post_data, post_len); 670 } 671 SetLastError(0xdeadbeef); 672 res = HttpSendRequestA(hor, test->headers, -1, post_data, post_len); 673 if (flags & INTERNET_FLAG_ASYNC) 674 ok(!res && (GetLastError() == ERROR_IO_PENDING), 675 "Asynchronous HttpSendRequest NOT returning 0 with error ERROR_IO_PENDING\n"); 676 else 677 ok(res || (GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED), 678 "Synchronous HttpSendRequest returning 0, error %u\n", GetLastError()); 679 trace("HttpSendRequestA <--\n"); 680 681 if (flags & INTERNET_FLAG_ASYNC) { 682 WaitForSingleObject(complete_event, INFINITE); 683 ok(req_error == ERROR_SUCCESS, "req_error = %u\n", req_error); 684 } 685 HeapFree(GetProcessHeap(), 0, post_data); 686 687 CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_SENT); 688 CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_RECEIVED); 689 if (first_connection_to_test_url) 690 { 691 if (! proxy_active()) 692 { 693 CHECK_NOTIFIED(INTERNET_STATUS_RESOLVING_NAME); 694 CHECK_NOTIFIED(INTERNET_STATUS_NAME_RESOLVED); 695 } 696 else 697 { 698 CLEAR_NOTIFIED(INTERNET_STATUS_RESOLVING_NAME); 699 CLEAR_NOTIFIED(INTERNET_STATUS_NAME_RESOLVED); 700 } 701 } 702 else 703 { 704 CHECK_NOT_NOTIFIED(INTERNET_STATUS_RESOLVING_NAME); 705 CHECK_NOT_NOTIFIED(INTERNET_STATUS_NAME_RESOLVED); 706 } 707 CHECK_NOTIFIED2(INTERNET_STATUS_SENDING_REQUEST, (test->flags & TESTF_REDIRECT) ? 2 : 1); 708 CHECK_NOTIFIED2(INTERNET_STATUS_REQUEST_SENT, (test->flags & TESTF_REDIRECT) ? 2 : 1); 709 CHECK_NOTIFIED2(INTERNET_STATUS_RECEIVING_RESPONSE, (test->flags & TESTF_REDIRECT) ? 2 : 1); 710 CHECK_NOTIFIED2(INTERNET_STATUS_RESPONSE_RECEIVED, (test->flags & TESTF_REDIRECT) ? 2 : 1); 711 if(test->flags & TESTF_REDIRECT) 712 CHECK_NOTIFIED(INTERNET_STATUS_REDIRECT); 713 if (flags & INTERNET_FLAG_ASYNC) 714 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 715 /* Sent on WinXP only if first_connection_to_test_url is TRUE, on Win98 always sent */ 716 CLEAR_NOTIFIED(INTERNET_STATUS_CONNECTING_TO_SERVER); 717 CLEAR_NOTIFIED(INTERNET_STATUS_CONNECTED_TO_SERVER); 718 719 test_request_flags(hor, 0); 720 721 length = 100; 722 res = InternetQueryOptionA(hor,INTERNET_OPTION_URL,buffer,&length); 723 ok(res, "InternetQueryOptionA(INTERNET_OPTION_URL) failed with error %d\n", GetLastError()); 724 725 length = sizeof(buffer)-2; 726 memset(buffer, 0x77, sizeof(buffer)); 727 SetLastError(0xdeadbeef); 728 res = HttpQueryInfoA(hor,HTTP_QUERY_RAW_HEADERS,buffer,&length,0x0); 729 ok(res, "HttpQueryInfoA(HTTP_QUERY_RAW_HEADERS) failed with error %d\n", GetLastError()); 730 ok(GetLastError() == 0 || 731 broken(GetLastError() == 0xdeadbeef /* XP/W2K3 */), "Last Error not reset %u\n", GetLastError()); 732 /* show that the function writes data past the length returned */ 733 ok(buffer[length-2], "Expected any header character, got 0x00\n"); 734 ok(!buffer[length-1], "Expected 0x00, got %02X\n", buffer[length-1]); 735 ok(!buffer[length], "Expected 0x00, got %02X\n", buffer[length]); 736 ok(buffer[length+1] == 0x77, "Expected 0x77, got %02X\n", buffer[length+1]); 737 738 length2 = length; 739 res = HttpQueryInfoA(hor,HTTP_QUERY_RAW_HEADERS,buffer,&length2,0x0); 740 ok(!res, "Expected 0x00, got %d\n", res); 741 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Unexpected last error: %d\n", GetLastError()); 742 ok(length2 == length+1, "Expected %d, got %d\n", length+1, length2); 743 /* the in length of the buffer must be +1 but the length returned does not count this */ 744 length2 = length+1; 745 memset(buffer, 0x77, sizeof(buffer)); 746 res = HttpQueryInfoA(hor,HTTP_QUERY_RAW_HEADERS,buffer,&length2,0x0); 747 ok(res, "HttpQueryInfoA(HTTP_QUERY_RAW_HEADERS) failed with error %d\n", GetLastError()); 748 ok(buffer[length2] == 0x00, "Expected 0x00, got %02X\n", buffer[length2]); 749 ok(buffer[length2+1] == 0x77, "Expected 0x77, got %02X\n", buffer[length2+1]); 750 ok(length2 == length, "Value should not have changed: %d != %d\n", length2, length); 751 752 length = sizeof(wbuffer)-2*sizeof(WCHAR); 753 memset(wbuffer, 0x77, sizeof(wbuffer)); 754 res = HttpQueryInfoW(hor, HTTP_QUERY_RAW_HEADERS, wbuffer, &length, 0x0); 755 ok(res, "HttpQueryInfoW(HTTP_QUERY_RAW_HEADERS) failed with error %d\n", GetLastError()); 756 ok(length % sizeof(WCHAR) == 0, "Expected that length is a multiple of sizeof(WCHAR), got %d.\n", length); 757 length /= sizeof(WCHAR); 758 /* show that the function writes data past the length returned */ 759 ok(wbuffer[length-2], "Expected any header character, got 0x0000\n"); 760 ok(!wbuffer[length-1], "Expected 0x0000, got %04X\n", wbuffer[length-1]); 761 ok(!wbuffer[length], "Expected 0x0000, got %04X\n", wbuffer[length]); 762 ok(wbuffer[length+1] == 0x7777 || broken(wbuffer[length+1] != 0x7777), 763 "Expected 0x7777, got %04X\n", wbuffer[length+1]); 764 765 length2 = length*sizeof(WCHAR); 766 res = HttpQueryInfoW(hor,HTTP_QUERY_RAW_HEADERS,wbuffer,&length2,0x0); 767 ok(!res, "Expected 0x00, got %d\n", res); 768 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Unexpected last error: %d\n", GetLastError()); 769 ok(length2 % sizeof(WCHAR) == 0, "Expected that length is a multiple of sizeof(WCHAR), got %d.\n", length2); 770 length2 /= sizeof(WCHAR); 771 ok(length2 == length+1, "Expected %d, got %d\n", length+1, length2); 772 /* the in length of the buffer must be +1 but the length returned does not count this */ 773 length2 = (length+1)*sizeof(WCHAR); 774 memset(wbuffer, 0x77, sizeof(wbuffer)); 775 res = HttpQueryInfoW(hor,HTTP_QUERY_RAW_HEADERS,wbuffer,&length2,0x0); 776 ok(res, "HttpQueryInfoW(HTTP_QUERY_RAW_HEADERS) failed with error %d\n", GetLastError()); 777 ok(length2 % sizeof(WCHAR) == 0, "Expected that length is a multiple of sizeof(WCHAR), got %d.\n", length2); 778 length2 /= sizeof(WCHAR); 779 ok(!wbuffer[length2], "Expected 0x0000, got %04X\n", wbuffer[length2]); 780 ok(wbuffer[length2+1] == 0x7777, "Expected 0x7777, got %04X\n", wbuffer[length2+1]); 781 ok(length2 == length, "Value should not have changed: %d != %d\n", length2, length); 782 783 test_request_url(hor, test->redirected_url); 784 785 index = 0; 786 length = 0; 787 SetLastError(0xdeadbeef); 788 ok(HttpQueryInfoA(hor,HTTP_QUERY_CONTENT_LENGTH,NULL,&length,&index) == FALSE,"Query worked\n"); 789 if(test->flags & TESTF_COMPRESSED) 790 ok(GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND, 791 "expected ERROR_HTTP_HEADER_NOT_FOUND, got %u\n", GetLastError()); 792 ok(index == 0, "Index was incremented\n"); 793 794 index = 0; 795 length = 16; 796 res = HttpQueryInfoA(hor,HTTP_QUERY_CONTENT_LENGTH,&buffer,&length,&index); 797 trace("Option HTTP_QUERY_CONTENT_LENGTH -> %i %s (%u)\n",res,buffer,GetLastError()); 798 if(test->flags & TESTF_COMPRESSED) 799 ok(!res && GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND, 800 "expected ERROR_HTTP_HEADER_NOT_FOUND, got %x (%u)\n", res, GetLastError()); 801 ok(!res || index == 1, "Index was not incremented although result is %x (index = %u)\n", res, index); 802 803 length = 100; 804 res = HttpQueryInfoA(hor,HTTP_QUERY_CONTENT_TYPE,buffer,&length,0x0); 805 buffer[length]=0; 806 trace("Option HTTP_QUERY_CONTENT_TYPE -> %i %s\n",res,buffer); 807 808 length = 100; 809 res = HttpQueryInfoA(hor,HTTP_QUERY_CONTENT_ENCODING,buffer,&length,0x0); 810 buffer[length]=0; 811 trace("Option HTTP_QUERY_CONTENT_ENCODING -> %i %s\n",res,buffer); 812 813 SetLastError(0xdeadbeef); 814 res = InternetReadFile(NULL, buffer, 100, &length); 815 ok(!res, "InternetReadFile should have failed\n"); 816 ok(GetLastError() == ERROR_INVALID_HANDLE, 817 "InternetReadFile should have set last error to ERROR_INVALID_HANDLE instead of %u\n", 818 GetLastError()); 819 820 length = 100; 821 if(winetest_debug > 1) 822 trace("Entering Query loop\n"); 823 824 while (TRUE) 825 { 826 if (flags & INTERNET_FLAG_ASYNC) 827 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 828 829 /* IE11 calls those in InternetQueryDataAvailable call. */ 830 SET_OPTIONAL(INTERNET_STATUS_RECEIVING_RESPONSE); 831 SET_OPTIONAL(INTERNET_STATUS_RESPONSE_RECEIVED); 832 833 length = 0; 834 res = InternetQueryDataAvailable(hor,&length,0x0,0x0); 835 836 CLEAR_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 837 838 if (flags & INTERNET_FLAG_ASYNC) 839 { 840 if (res) 841 { 842 CHECK_NOT_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 843 if(exlen) { 844 ok(length >= exlen, "length %u < exlen %u\n", length, exlen); 845 exlen = 0; 846 } 847 } 848 else if (GetLastError() == ERROR_IO_PENDING) 849 { 850 if(winetest_debug > 1) 851 trace("pending\n"); 852 /* on some tests, InternetQueryDataAvailable returns non-zero length and ERROR_IO_PENDING */ 853 if(!(test->flags & TESTF_CHUNKED)) 854 ok(!length, "InternetQueryDataAvailable returned ERROR_IO_PENDING and %u length\n", length); 855 WaitForSingleObject(complete_event, INFINITE); 856 exlen = length; 857 ok(exlen, "length = 0\n"); 858 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 859 CLEAR_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED); 860 ok(req_error, "req_error = 0\n"); 861 continue; 862 }else { 863 ok(0, "InternetQueryDataAvailable failed: %u\n", GetLastError()); 864 } 865 }else { 866 ok(res, "InternetQueryDataAvailable failed: %u\n", GetLastError()); 867 } 868 CLEAR_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED); 869 870 if(winetest_debug > 1) 871 trace("length %u\n", length); 872 if(test->flags & TESTF_CHUNKED) 873 ok(length <= 8192, "length = %d, expected <= 8192\n", length); 874 if (length) 875 { 876 char *buffer; 877 buffer = HeapAlloc(GetProcessHeap(),0,length+1); 878 879 res = InternetReadFile(hor,buffer,length,&length); 880 881 buffer[length]=0; 882 883 if(winetest_debug > 1) 884 trace("ReadFile -> %s %i\n", res ? "TRUE" : "FALSE", length); 885 886 if(test->content) 887 ok(!strcmp(buffer, test->content), "buffer = '%s', expected '%s'\n", buffer, test->content); 888 HeapFree(GetProcessHeap(),0,buffer); 889 }else { 890 ok(!on_async, "Returned zero size in response to request complete\n"); 891 break; 892 } 893 on_async = FALSE; 894 } 895 if(test->flags & TESTF_REDIRECT) { 896 CHECK_NOTIFIED2(INTERNET_STATUS_CLOSING_CONNECTION, 2); 897 CHECK_NOTIFIED2(INTERNET_STATUS_CONNECTION_CLOSED, 2); 898 } 899 abort: 900 if(winetest_debug > 1) 901 trace("aborting\n"); 902 close_async_handle(hi, 2); 903 first_connection_to_test_url = FALSE; 904 } 905 906 static void InternetReadFile_chunked_test(void) 907 { 908 BOOL res; 909 CHAR buffer[4000]; 910 DWORD length, got; 911 const char *types[2] = { "*", NULL }; 912 HINTERNET hi, hic = 0, hor = 0; 913 914 trace("Starting InternetReadFile chunked test\n"); 915 916 trace("InternetOpenA <--\n"); 917 hi = InternetOpenA("", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0); 918 ok((hi != 0x0),"InternetOpen failed with error %u\n", GetLastError()); 919 trace("InternetOpenA -->\n"); 920 921 if (hi == 0x0) goto abort; 922 923 trace("InternetConnectA <--\n"); 924 hic=InternetConnectA(hi, "test.winehq.org", INTERNET_INVALID_PORT_NUMBER, 925 NULL, NULL, INTERNET_SERVICE_HTTP, 0x0, 0xdeadbeef); 926 ok((hic != 0x0),"InternetConnect failed with error %u\n", GetLastError()); 927 trace("InternetConnectA -->\n"); 928 929 if (hic == 0x0) goto abort; 930 931 trace("HttpOpenRequestA <--\n"); 932 hor = HttpOpenRequestA(hic, "GET", "/tests/chunked", NULL, NULL, types, 933 INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_RELOAD, 934 0xdeadbead); 935 if (hor == 0x0 && GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED) { 936 /* 937 * If the internet name can't be resolved we are probably behind 938 * a firewall or in some other way not directly connected to the 939 * Internet. Not enough reason to fail the test. Just ignore and 940 * abort. 941 */ 942 } else { 943 ok((hor != 0x0),"HttpOpenRequest failed with error %u\n", GetLastError()); 944 } 945 trace("HttpOpenRequestA -->\n"); 946 947 if (hor == 0x0) goto abort; 948 949 trace("HttpSendRequestA -->\n"); 950 SetLastError(0xdeadbeef); 951 res = HttpSendRequestA(hor, "", -1, NULL, 0); 952 ok(res || (GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED), 953 "Synchronous HttpSendRequest returning 0, error %u\n", GetLastError()); 954 trace("HttpSendRequestA <--\n"); 955 956 test_request_flags(hor, 0); 957 958 length = 100; 959 res = HttpQueryInfoA(hor,HTTP_QUERY_CONTENT_TYPE,buffer,&length,0x0); 960 buffer[length]=0; 961 trace("Option CONTENT_TYPE -> %i %s\n",res,buffer); 962 963 SetLastError( 0xdeadbeef ); 964 length = 100; 965 res = HttpQueryInfoA(hor,HTTP_QUERY_TRANSFER_ENCODING,buffer,&length,0x0); 966 buffer[length]=0; 967 trace("Option TRANSFER_ENCODING -> %i %s\n",res,buffer); 968 ok( res || ( proxy_active() && GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND ), 969 "Failed to get TRANSFER_ENCODING option, error %u\n", GetLastError() ); 970 ok( !strcmp( buffer, "chunked" ) || ( ! res && proxy_active() && GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND ), 971 "Wrong transfer encoding '%s'\n", buffer ); 972 973 SetLastError( 0xdeadbeef ); 974 length = 16; 975 res = HttpQueryInfoA(hor,HTTP_QUERY_CONTENT_LENGTH,&buffer,&length,0x0); 976 ok( !res, "Found CONTENT_LENGTH option '%s'\n", buffer ); 977 ok( GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND, "Wrong error %u\n", GetLastError() ); 978 979 length = 100; 980 trace("Entering Query loop\n"); 981 982 while (TRUE) 983 { 984 res = InternetQueryDataAvailable(hor,&length,0x0,0x0); 985 ok(!(!res && length != 0),"InternetQueryDataAvailable failed with non-zero length\n"); 986 ok(res, "InternetQueryDataAvailable failed, error %d\n", GetLastError()); 987 trace("got %u available\n",length); 988 if (length) 989 { 990 char *buffer = HeapAlloc(GetProcessHeap(),0,length+1); 991 992 SetLastError(0xdeadbeef); 993 res = InternetReadFile(hor,buffer,length,&got); 994 ok(GetLastError() == 0 || 995 broken(GetLastError() == 0xdeadbeef /* XP/W2K3 */), "Last Error not reset %u\n", GetLastError()); 996 997 buffer[got]=0; 998 trace("ReadFile -> %i %i\n",res,got); 999 ok( length == got, "only got %u of %u available\n", got, length ); 1000 ok( buffer[got-1] == '\n', "received partial line '%s'\n", buffer ); 1001 1002 HeapFree(GetProcessHeap(),0,buffer); 1003 if (!got) break; 1004 } 1005 if (length == 0) 1006 { 1007 got = 0xdeadbeef; 1008 SetLastError(0xdeadbeef); 1009 res = InternetReadFile( hor, buffer, 1, &got ); 1010 ok( res, "InternetReadFile failed: %u\n", GetLastError() ); 1011 ok(GetLastError() == 0 || 1012 broken(GetLastError() == 0xdeadbeef /* XP/W2K3 */), "Last Error not reset %u\n", GetLastError()); 1013 ok( !got, "got %u\n", got ); 1014 break; 1015 } 1016 } 1017 abort: 1018 trace("aborting\n"); 1019 if (hor != 0x0) { 1020 res = InternetCloseHandle(hor); 1021 ok (res, "InternetCloseHandle of handle opened by HttpOpenRequestA failed\n"); 1022 } 1023 if (hi != 0x0) { 1024 res = InternetCloseHandle(hi); 1025 ok (res, "InternetCloseHandle of handle opened by InternetOpenA failed\n"); 1026 } 1027 } 1028 1029 static void InternetReadFileExA_test(int flags) 1030 { 1031 DWORD rc; 1032 DWORD length; 1033 const char *types[2] = { "*", NULL }; 1034 HINTERNET hi, hic = 0, hor = 0; 1035 INTERNET_BUFFERSA inetbuffers; 1036 1037 trace("Starting InternetReadFileExA test with flags 0x%x\n",flags); 1038 reset_events(); 1039 1040 trace("InternetOpenA <--\n"); 1041 hi = InternetOpenA("", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, flags); 1042 ok((hi != 0x0),"InternetOpen failed with error %u\n", GetLastError()); 1043 trace("InternetOpenA -->\n"); 1044 1045 if (hi == 0x0) goto abort; 1046 1047 pInternetSetStatusCallbackA(hi,&callback); 1048 1049 SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED); 1050 1051 trace("InternetConnectA <--\n"); 1052 hic=InternetConnectA(hi, "test.winehq.org", INTERNET_INVALID_PORT_NUMBER, 1053 NULL, NULL, INTERNET_SERVICE_HTTP, 0x0, 0xdeadbeef); 1054 ok((hic != 0x0),"InternetConnect failed with error %u\n", GetLastError()); 1055 trace("InternetConnectA -->\n"); 1056 1057 if (hic == 0x0) goto abort; 1058 1059 CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED); 1060 SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED); 1061 1062 trace("HttpOpenRequestA <--\n"); 1063 hor = HttpOpenRequestA(hic, "GET", "/tests/redirect", NULL, NULL, types, 1064 INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_RELOAD, 1065 0xdeadbead); 1066 if (hor == 0x0 && GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED) { 1067 /* 1068 * If the internet name can't be resolved we are probably behind 1069 * a firewall or in some other way not directly connected to the 1070 * Internet. Not enough reason to fail the test. Just ignore and 1071 * abort. 1072 */ 1073 } else { 1074 ok((hor != 0x0),"HttpOpenRequest failed with error %u\n", GetLastError()); 1075 } 1076 trace("HttpOpenRequestA -->\n"); 1077 1078 if (hor == 0x0) goto abort; 1079 1080 CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED); 1081 CHECK_NOT_NOTIFIED(INTERNET_STATUS_RESOLVING_NAME); 1082 CHECK_NOT_NOTIFIED(INTERNET_STATUS_NAME_RESOLVED); 1083 if (first_connection_to_test_url) 1084 { 1085 SET_EXPECT(INTERNET_STATUS_RESOLVING_NAME); 1086 SET_EXPECT(INTERNET_STATUS_NAME_RESOLVED); 1087 } 1088 SET_OPTIONAL2(INTERNET_STATUS_COOKIE_SENT, 2); 1089 SET_EXPECT(INTERNET_STATUS_CONNECTING_TO_SERVER); 1090 SET_EXPECT(INTERNET_STATUS_CONNECTED_TO_SERVER); 1091 SET_EXPECT2(INTERNET_STATUS_SENDING_REQUEST, 2); 1092 SET_EXPECT2(INTERNET_STATUS_REQUEST_SENT, 2); 1093 SET_EXPECT2(INTERNET_STATUS_RECEIVING_RESPONSE, 2); 1094 SET_EXPECT2(INTERNET_STATUS_RESPONSE_RECEIVED, 2); 1095 SET_OPTIONAL2(INTERNET_STATUS_CLOSING_CONNECTION, 2); 1096 SET_OPTIONAL2(INTERNET_STATUS_CONNECTION_CLOSED, 2); 1097 SET_EXPECT(INTERNET_STATUS_REDIRECT); 1098 SET_OPTIONAL(INTERNET_STATUS_CONNECTING_TO_SERVER); 1099 SET_OPTIONAL(INTERNET_STATUS_CONNECTED_TO_SERVER); 1100 if (flags & INTERNET_FLAG_ASYNC) 1101 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 1102 else 1103 SET_WINE_ALLOW(INTERNET_STATUS_REQUEST_COMPLETE); 1104 1105 trace("HttpSendRequestA -->\n"); 1106 SetLastError(0xdeadbeef); 1107 rc = HttpSendRequestA(hor, "", -1, NULL, 0); 1108 if (flags & INTERNET_FLAG_ASYNC) 1109 ok(((rc == 0)&&(GetLastError() == ERROR_IO_PENDING)), 1110 "Asynchronous HttpSendRequest NOT returning 0 with error ERROR_IO_PENDING\n"); 1111 else 1112 ok((rc != 0) || GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED, 1113 "Synchronous HttpSendRequest returning 0, error %u\n", GetLastError()); 1114 trace("HttpSendRequestA <--\n"); 1115 1116 if (!rc && (GetLastError() == ERROR_IO_PENDING)) { 1117 WaitForSingleObject(complete_event, INFINITE); 1118 ok(req_error == ERROR_SUCCESS, "req_error = %u\n", req_error); 1119 } 1120 1121 if (first_connection_to_test_url) 1122 { 1123 CHECK_NOTIFIED(INTERNET_STATUS_RESOLVING_NAME); 1124 CHECK_NOTIFIED(INTERNET_STATUS_NAME_RESOLVED); 1125 } 1126 else 1127 { 1128 CHECK_NOT_NOTIFIED(INTERNET_STATUS_RESOLVING_NAME); 1129 CHECK_NOT_NOTIFIED(INTERNET_STATUS_NAME_RESOLVED); 1130 } 1131 CHECK_NOTIFIED2(INTERNET_STATUS_SENDING_REQUEST, 2); 1132 CHECK_NOTIFIED2(INTERNET_STATUS_REQUEST_SENT, 2); 1133 CHECK_NOTIFIED2(INTERNET_STATUS_RECEIVING_RESPONSE, 2); 1134 CHECK_NOTIFIED2(INTERNET_STATUS_RESPONSE_RECEIVED, 2); 1135 CHECK_NOTIFIED2(INTERNET_STATUS_CLOSING_CONNECTION, 2); 1136 CHECK_NOTIFIED2(INTERNET_STATUS_CONNECTION_CLOSED, 2); 1137 CHECK_NOTIFIED(INTERNET_STATUS_REDIRECT); 1138 if (flags & INTERNET_FLAG_ASYNC) 1139 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 1140 else 1141 todo_wine CHECK_NOT_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 1142 CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_SENT); 1143 /* Sent on WinXP only if first_connection_to_test_url is TRUE, on Win98 always sent */ 1144 CLEAR_NOTIFIED(INTERNET_STATUS_CONNECTING_TO_SERVER); 1145 CLEAR_NOTIFIED(INTERNET_STATUS_CONNECTED_TO_SERVER); 1146 1147 if(is_ie7plus) { 1148 rc = InternetReadFileExW(hor, NULL, 0, 0xdeadcafe); 1149 ok(!rc && (GetLastError() == ERROR_INVALID_PARAMETER), 1150 "InternetReadFileEx should have failed with ERROR_INVALID_PARAMETER instead of %s, %u\n", 1151 rc ? "TRUE" : "FALSE", GetLastError()); 1152 } 1153 1154 /* tests invalid dwStructSize */ 1155 inetbuffers.dwStructSize = sizeof(inetbuffers)+1; 1156 inetbuffers.lpcszHeader = NULL; 1157 inetbuffers.dwHeadersLength = 0; 1158 inetbuffers.dwBufferLength = 10; 1159 inetbuffers.lpvBuffer = HeapAlloc(GetProcessHeap(), 0, 10); 1160 inetbuffers.dwOffsetHigh = 1234; 1161 inetbuffers.dwOffsetLow = 5678; 1162 rc = InternetReadFileExA(hor, &inetbuffers, 0, 0xdeadcafe); 1163 ok(!rc && (GetLastError() == ERROR_INVALID_PARAMETER), 1164 "InternetReadFileEx should have failed with ERROR_INVALID_PARAMETER instead of %s, %u\n", 1165 rc ? "TRUE" : "FALSE", GetLastError()); 1166 HeapFree(GetProcessHeap(), 0, inetbuffers.lpvBuffer); 1167 1168 test_request_flags(hor, 0); 1169 1170 /* tests to see whether lpcszHeader is used - it isn't */ 1171 inetbuffers.dwStructSize = sizeof(inetbuffers); 1172 inetbuffers.lpcszHeader = (LPCSTR)0xdeadbeef; 1173 inetbuffers.dwHeadersLength = 255; 1174 inetbuffers.dwBufferLength = 0; 1175 inetbuffers.lpvBuffer = NULL; 1176 inetbuffers.dwOffsetHigh = 1234; 1177 inetbuffers.dwOffsetLow = 5678; 1178 rc = InternetReadFileExA(hor, &inetbuffers, 0, 0xdeadcafe); 1179 ok(rc, "InternetReadFileEx failed with error %u\n", GetLastError()); 1180 trace("read %i bytes\n", inetbuffers.dwBufferLength); 1181 1182 rc = InternetReadFileExA(NULL, &inetbuffers, 0, 0xdeadcafe); 1183 ok(!rc && (GetLastError() == ERROR_INVALID_HANDLE), 1184 "InternetReadFileEx should have failed with ERROR_INVALID_HANDLE instead of %s, %u\n", 1185 rc ? "TRUE" : "FALSE", GetLastError()); 1186 1187 length = 0; 1188 trace("Entering Query loop\n"); 1189 1190 while (TRUE) 1191 { 1192 inetbuffers.dwStructSize = sizeof(inetbuffers); 1193 inetbuffers.dwBufferLength = 1024; 1194 inetbuffers.lpvBuffer = HeapAlloc(GetProcessHeap(), 0, inetbuffers.dwBufferLength+1); 1195 inetbuffers.dwOffsetHigh = 1234; 1196 inetbuffers.dwOffsetLow = 5678; 1197 1198 SET_WINE_ALLOW(INTERNET_STATUS_RECEIVING_RESPONSE); 1199 SET_WINE_ALLOW(INTERNET_STATUS_RESPONSE_RECEIVED); 1200 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 1201 rc = InternetReadFileExA(hor, &inetbuffers, IRF_ASYNC | IRF_USE_CONTEXT, 0xcafebabe); 1202 if (!rc) 1203 { 1204 if (GetLastError() == ERROR_IO_PENDING) 1205 { 1206 trace("InternetReadFileEx -> PENDING\n"); 1207 ok(flags & INTERNET_FLAG_ASYNC, 1208 "Should not get ERROR_IO_PENDING without INTERNET_FLAG_ASYNC\n"); 1209 CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 1210 WaitForSingleObject(complete_event, INFINITE); 1211 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 1212 CHECK_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED); 1213 ok(req_error == ERROR_SUCCESS, "req_error = %u\n", req_error); 1214 } 1215 else 1216 { 1217 trace("InternetReadFileEx -> FAILED %u\n", GetLastError()); 1218 break; 1219 } 1220 } 1221 else 1222 { 1223 trace("InternetReadFileEx -> SUCCEEDED\n"); 1224 CHECK_NOT_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 1225 if (inetbuffers.dwBufferLength) 1226 { 1227 CHECK_NOT_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 1228 CHECK_NOT_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED); 1229 } 1230 else 1231 { 1232 /* Win98 still sends these when 0 bytes are read, WinXP does not */ 1233 CLEAR_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 1234 CLEAR_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED); 1235 } 1236 } 1237 1238 trace("read %i bytes\n", inetbuffers.dwBufferLength); 1239 ((char *)inetbuffers.lpvBuffer)[inetbuffers.dwBufferLength] = '\0'; 1240 1241 ok(inetbuffers.dwOffsetHigh == 1234 && inetbuffers.dwOffsetLow == 5678, 1242 "InternetReadFileEx sets offsets to 0x%x%08x\n", 1243 inetbuffers.dwOffsetHigh, inetbuffers.dwOffsetLow); 1244 1245 HeapFree(GetProcessHeap(), 0, inetbuffers.lpvBuffer); 1246 1247 if (!inetbuffers.dwBufferLength) 1248 break; 1249 1250 length += inetbuffers.dwBufferLength; 1251 } 1252 ok(length > 0, "failed to read any of the document\n"); 1253 trace("Finished. Read %d bytes\n", length); 1254 1255 abort: 1256 close_async_handle(hi, 2); 1257 first_connection_to_test_url = FALSE; 1258 } 1259 1260 static void InternetOpenUrlA_test(void) 1261 { 1262 HINTERNET myhinternet, myhttp; 1263 char buffer[0x400]; 1264 DWORD size, readbytes, totalbytes=0; 1265 BOOL ret; 1266 1267 ret = DeleteUrlCacheEntryA(TEST_URL); 1268 ok(ret || GetLastError() == ERROR_FILE_NOT_FOUND, 1269 "DeleteUrlCacheEntry returned %x, GetLastError() = %d\n", ret, GetLastError()); 1270 1271 myhinternet = InternetOpenA("Winetest",0,NULL,NULL,INTERNET_FLAG_NO_CACHE_WRITE); 1272 ok((myhinternet != 0), "InternetOpen failed, error %u\n",GetLastError()); 1273 size = 0x400; 1274 ret = InternetCanonicalizeUrlA(TEST_URL, buffer, &size,ICU_BROWSER_MODE); 1275 ok( ret, "InternetCanonicalizeUrl failed, error %u\n",GetLastError()); 1276 1277 SetLastError(0); 1278 myhttp = InternetOpenUrlA(myhinternet, TEST_URL, 0, 0, 1279 INTERNET_FLAG_RELOAD|INTERNET_FLAG_NO_CACHE_WRITE|INTERNET_FLAG_TRANSFER_BINARY,0); 1280 if (GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED) 1281 return; /* WinXP returns this when not connected to the net */ 1282 ok((myhttp != 0),"InternetOpenUrl failed, error %u\n",GetLastError()); 1283 ret = InternetReadFile(myhttp, buffer,0x400,&readbytes); 1284 ok( ret, "InternetReadFile failed, error %u\n",GetLastError()); 1285 totalbytes += readbytes; 1286 while (readbytes && InternetReadFile(myhttp, buffer,0x400,&readbytes)) 1287 totalbytes += readbytes; 1288 trace("read 0x%08x bytes\n",totalbytes); 1289 1290 InternetCloseHandle(myhttp); 1291 InternetCloseHandle(myhinternet); 1292 1293 ret = DeleteUrlCacheEntryA(TEST_URL); 1294 ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND, "INTERNET_FLAG_NO_CACHE_WRITE flag doesn't work\n"); 1295 } 1296 1297 static void HttpSendRequestEx_test(void) 1298 { 1299 HINTERNET hSession; 1300 HINTERNET hConnect; 1301 HINTERNET hRequest; 1302 1303 INTERNET_BUFFERSA BufferIn; 1304 DWORD dwBytesWritten, dwBytesRead, error; 1305 CHAR szBuffer[256]; 1306 int i; 1307 BOOL ret; 1308 1309 static char szPostData[] = "mode=Test"; 1310 static const char szContentType[] = "Content-Type: application/x-www-form-urlencoded"; 1311 1312 hSession = InternetOpenA("Wine Regression Test", 1313 INTERNET_OPEN_TYPE_PRECONFIG,NULL,NULL,0); 1314 ok( hSession != NULL ,"Unable to open Internet session\n"); 1315 hConnect = InternetConnectA(hSession, "test.winehq.org", 1316 INTERNET_DEFAULT_HTTP_PORT, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 1317 0); 1318 ok( hConnect != NULL, "Unable to connect to http://test.winehq.org\n"); 1319 hRequest = HttpOpenRequestA(hConnect, "POST", "/tests/post.php", 1320 NULL, NULL, NULL, INTERNET_FLAG_NO_CACHE_WRITE, 0); 1321 if (!hRequest && GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED) 1322 { 1323 skip( "Network unreachable, skipping test\n" ); 1324 goto done; 1325 } 1326 ok( hRequest != NULL, "Failed to open request handle err %u\n", GetLastError()); 1327 1328 test_request_flags(hRequest, INTERNET_REQFLAG_NO_HEADERS); 1329 1330 BufferIn.dwStructSize = sizeof(BufferIn); 1331 BufferIn.Next = (INTERNET_BUFFERSA*)0xdeadcab; 1332 BufferIn.lpcszHeader = szContentType; 1333 BufferIn.dwHeadersLength = sizeof(szContentType)-1; 1334 BufferIn.dwHeadersTotal = sizeof(szContentType)-1; 1335 BufferIn.lpvBuffer = szPostData; 1336 BufferIn.dwBufferLength = 3; 1337 BufferIn.dwBufferTotal = sizeof(szPostData)-1; 1338 BufferIn.dwOffsetLow = 0; 1339 BufferIn.dwOffsetHigh = 0; 1340 1341 SetLastError(0xdeadbeef); 1342 ret = HttpSendRequestExA(hRequest, &BufferIn, NULL, 0 ,0); 1343 error = GetLastError(); 1344 ok(ret, "HttpSendRequestEx Failed with error %u\n", error); 1345 ok(error == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", error); 1346 1347 test_request_flags(hRequest, INTERNET_REQFLAG_NO_HEADERS); 1348 1349 for (i = 3; szPostData[i]; i++) 1350 ok(InternetWriteFile(hRequest, &szPostData[i], 1, &dwBytesWritten), 1351 "InternetWriteFile failed\n"); 1352 1353 test_request_flags(hRequest, INTERNET_REQFLAG_NO_HEADERS); 1354 1355 ok(HttpEndRequestA(hRequest, NULL, 0, 0), "HttpEndRequest Failed\n"); 1356 1357 test_request_flags(hRequest, 0); 1358 1359 ok(InternetReadFile(hRequest, szBuffer, 255, &dwBytesRead), 1360 "Unable to read response\n"); 1361 szBuffer[dwBytesRead] = 0; 1362 1363 ok(dwBytesRead == 13,"Read %u bytes instead of 13\n",dwBytesRead); 1364 ok(strncmp(szBuffer,"mode => Test\n",dwBytesRead)==0 || broken(proxy_active()),"Got string %s\n",szBuffer); 1365 1366 ok(InternetCloseHandle(hRequest), "Close request handle failed\n"); 1367 done: 1368 ok(InternetCloseHandle(hConnect), "Close connect handle failed\n"); 1369 ok(InternetCloseHandle(hSession), "Close session handle failed\n"); 1370 } 1371 1372 static void InternetOpenRequest_test(void) 1373 { 1374 HINTERNET session, connect, request; 1375 static const char *types[] = { "*", "", NULL }; 1376 static const WCHAR slash[] = {'/', 0}, any[] = {'*', 0}, empty[] = {0}; 1377 static const WCHAR *typesW[] = { any, empty, NULL }; 1378 BOOL ret; 1379 1380 session = InternetOpenA("Wine Regression Test", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0); 1381 ok(session != NULL ,"Unable to open Internet session\n"); 1382 1383 connect = InternetConnectA(session, NULL, INTERNET_DEFAULT_HTTP_PORT, NULL, NULL, 1384 INTERNET_SERVICE_HTTP, 0, 0); 1385 ok(connect == NULL, "InternetConnectA should have failed\n"); 1386 ok(GetLastError() == ERROR_INVALID_PARAMETER, "InternetConnectA with NULL server named should have failed with ERROR_INVALID_PARAMETER instead of %d\n", GetLastError()); 1387 1388 connect = InternetConnectA(session, "", INTERNET_DEFAULT_HTTP_PORT, NULL, NULL, 1389 INTERNET_SERVICE_HTTP, 0, 0); 1390 ok(connect == NULL, "InternetConnectA should have failed\n"); 1391 ok(GetLastError() == ERROR_INVALID_PARAMETER, "InternetConnectA with blank server named should have failed with ERROR_INVALID_PARAMETER instead of %d\n", GetLastError()); 1392 1393 connect = InternetConnectA(session, "test.winehq.org", INTERNET_DEFAULT_HTTP_PORT, NULL, NULL, 1394 INTERNET_SERVICE_HTTP, 0, 0); 1395 ok(connect != NULL, "Unable to connect to http://test.winehq.org with error %d\n", GetLastError()); 1396 1397 request = HttpOpenRequestA(connect, NULL, "/", NULL, NULL, types, INTERNET_FLAG_NO_CACHE_WRITE, 0); 1398 if (!request && GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED) 1399 { 1400 skip( "Network unreachable, skipping test\n" ); 1401 goto done; 1402 } 1403 ok(request != NULL, "Failed to open request handle err %u\n", GetLastError()); 1404 1405 ret = HttpSendRequestW(request, NULL, 0, NULL, 0); 1406 ok(ret, "HttpSendRequest failed: %u\n", GetLastError()); 1407 ok(InternetCloseHandle(request), "Close request handle failed\n"); 1408 1409 request = HttpOpenRequestW(connect, NULL, slash, NULL, NULL, typesW, INTERNET_FLAG_NO_CACHE_WRITE, 0); 1410 ok(request != NULL, "Failed to open request handle err %u\n", GetLastError()); 1411 1412 ret = HttpSendRequestA(request, NULL, 0, NULL, 0); 1413 ok(ret, "HttpSendRequest failed: %u\n", GetLastError()); 1414 ok(InternetCloseHandle(request), "Close request handle failed\n"); 1415 1416 done: 1417 ok(InternetCloseHandle(connect), "Close connect handle failed\n"); 1418 ok(InternetCloseHandle(session), "Close session handle failed\n"); 1419 } 1420 1421 static void test_cache_read(void) 1422 { 1423 HINTERNET session, connection, req; 1424 FILETIME now, tomorrow, yesterday; 1425 BYTE content[1000], buf[2000]; 1426 char file_path[MAX_PATH]; 1427 ULARGE_INTEGER li; 1428 HANDLE file; 1429 DWORD size; 1430 unsigned i; 1431 BOOL res; 1432 1433 static const char cache_only_url[] = "http://test.winehq.org/tests/cache-only"; 1434 BYTE cache_headers[] = "HTTP/1.1 200 OK\r\n\r\n"; 1435 1436 trace("Testing cache read...\n"); 1437 reset_events(); 1438 1439 for(i = 0; i < sizeof(content); i++) 1440 content[i] = '0' + (i%10); 1441 1442 GetSystemTimeAsFileTime(&now); 1443 li.u.HighPart = now.dwHighDateTime; 1444 li.u.LowPart = now.dwLowDateTime; 1445 li.QuadPart += (LONGLONG)10000000 * 3600 * 24; 1446 tomorrow.dwHighDateTime = li.u.HighPart; 1447 tomorrow.dwLowDateTime = li.u.LowPart; 1448 li.QuadPart -= (LONGLONG)10000000 * 3600 * 24 * 2; 1449 yesterday.dwHighDateTime = li.u.HighPart; 1450 yesterday.dwLowDateTime = li.u.LowPart; 1451 1452 res = CreateUrlCacheEntryA(cache_only_url, sizeof(content), "", file_path, 0); 1453 ok(res, "CreateUrlCacheEntryA failed: %u\n", GetLastError()); 1454 1455 file = CreateFileA(file_path, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); 1456 ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n"); 1457 1458 WriteFile(file, content, sizeof(content), &size, NULL); 1459 CloseHandle(file); 1460 1461 res = CommitUrlCacheEntryA(cache_only_url, file_path, tomorrow, yesterday, NORMAL_CACHE_ENTRY, 1462 cache_headers, sizeof(cache_headers)-1, "", 0); 1463 ok(res, "CommitUrlCacheEntryA failed: %u\n", GetLastError()); 1464 1465 session = InternetOpenA("", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, INTERNET_FLAG_ASYNC); 1466 ok(session != NULL,"InternetOpen failed with error %u\n", GetLastError()); 1467 1468 pInternetSetStatusCallbackA(session, callback); 1469 1470 SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED); 1471 connection = InternetConnectA(session, "test.winehq.org", INTERNET_DEFAULT_HTTP_PORT, 1472 NULL, NULL, INTERNET_SERVICE_HTTP, 0x0, 0xdeadbeef); 1473 ok(connection != NULL,"InternetConnect failed with error %u\n", GetLastError()); 1474 CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED); 1475 1476 SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED); 1477 req = HttpOpenRequestA(connection, "GET", "/tests/cache-only", NULL, NULL, NULL, 0, 0xdeadbead); 1478 ok(req != NULL, "HttpOpenRequest failed: %u\n", GetLastError()); 1479 CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED); 1480 1481 SET_WINE_ALLOW(INTERNET_STATUS_CONNECTING_TO_SERVER); 1482 SET_WINE_ALLOW(INTERNET_STATUS_CONNECTED_TO_SERVER); 1483 SET_WINE_ALLOW(INTERNET_STATUS_SENDING_REQUEST); 1484 SET_WINE_ALLOW(INTERNET_STATUS_REQUEST_SENT); 1485 SET_WINE_ALLOW(INTERNET_STATUS_RECEIVING_RESPONSE); 1486 SET_WINE_ALLOW(INTERNET_STATUS_RESPONSE_RECEIVED); 1487 SET_WINE_ALLOW(INTERNET_STATUS_REQUEST_COMPLETE); 1488 1489 res = HttpSendRequestA(req, NULL, -1, NULL, 0); 1490 todo_wine 1491 ok(res, "HttpSendRequest failed: %u\n", GetLastError()); 1492 1493 if(res) { 1494 size = 0; 1495 res = InternetQueryDataAvailable(req, &size, 0, 0); 1496 ok(res, "InternetQueryDataAvailable failed: %u\n", GetLastError()); 1497 ok(size == sizeof(content), "size = %u\n", size); 1498 1499 size = sizeof(buf); 1500 res = InternetReadFile(req, buf, sizeof(buf), &size); 1501 ok(res, "InternetReadFile failed: %u\n", GetLastError()); 1502 ok(size == sizeof(content), "size = %u\n", size); 1503 ok(!memcmp(content, buf, sizeof(content)), "unexpected content\n"); 1504 } 1505 1506 close_async_handle(session, 2); 1507 1508 CLEAR_NOTIFIED(INTERNET_STATUS_CONNECTING_TO_SERVER); 1509 CLEAR_NOTIFIED(INTERNET_STATUS_CONNECTED_TO_SERVER); 1510 CLEAR_NOTIFIED(INTERNET_STATUS_SENDING_REQUEST); 1511 CLEAR_NOTIFIED(INTERNET_STATUS_REQUEST_SENT); 1512 CLEAR_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 1513 CLEAR_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED); 1514 CLEAR_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 1515 1516 res = DeleteUrlCacheEntryA(cache_only_url); 1517 ok(res, "DeleteUrlCacheEntryA failed: %u\n", GetLastError()); 1518 } 1519 1520 static void test_http_cache(void) 1521 { 1522 HINTERNET session, connect, request; 1523 char file_name[MAX_PATH], url[INTERNET_MAX_URL_LENGTH]; 1524 DWORD size, file_size; 1525 BYTE buf[100]; 1526 HANDLE file; 1527 BOOL ret; 1528 FILETIME filetime_zero = {0}; 1529 1530 static const char cached_content[] = "data read from cache"; 1531 static const char *types[] = { "*", "", NULL }; 1532 1533 session = InternetOpenA("Wine Regression Test", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0); 1534 ok(session != NULL ,"Unable to open Internet session\n"); 1535 1536 connect = InternetConnectA(session, "test.winehq.org", INTERNET_DEFAULT_HTTP_PORT, NULL, NULL, 1537 INTERNET_SERVICE_HTTP, 0, 0); 1538 ok(connect != NULL, "Unable to connect to http://test.winehq.org with error %d\n", GetLastError()); 1539 1540 request = HttpOpenRequestA(connect, NULL, "/tests/hello.html", NULL, NULL, types, INTERNET_FLAG_NEED_FILE, 0); 1541 if (!request && GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED) 1542 { 1543 skip( "Network unreachable, skipping test\n" ); 1544 1545 ok(InternetCloseHandle(connect), "Close connect handle failed\n"); 1546 ok(InternetCloseHandle(session), "Close session handle failed\n"); 1547 1548 return; 1549 } 1550 ok(request != NULL, "Failed to open request handle err %u\n", GetLastError()); 1551 1552 size = sizeof(url); 1553 ret = InternetQueryOptionA(request, INTERNET_OPTION_URL, url, &size); 1554 ok(ret, "InternetQueryOptionA(INTERNET_OPTION_URL) failed: %u\n", GetLastError()); 1555 ok(!strcmp(url, "http://test.winehq.org/tests/hello.html"), "Wrong URL %s\n", url); 1556 1557 size = sizeof(file_name); 1558 ret = InternetQueryOptionA(request, INTERNET_OPTION_DATAFILE_NAME, file_name, &size); 1559 ok(!ret, "InternetQueryOptionA(INTERNET_OPTION_DATAFILE_NAME) succeeded\n"); 1560 ok(GetLastError() == ERROR_INTERNET_ITEM_NOT_FOUND, "GetLastError()=%u\n", GetLastError()); 1561 ok(!size, "size = %d\n", size); 1562 1563 ret = HttpSendRequestA(request, NULL, 0, NULL, 0); 1564 ok(ret, "HttpSendRequest failed: %u\n", GetLastError()); 1565 1566 size = sizeof(file_name); 1567 ret = InternetQueryOptionA(request, INTERNET_OPTION_DATAFILE_NAME, file_name, &size); 1568 ok(ret, "InternetQueryOptionA(INTERNET_OPTION_DATAFILE_NAME) failed: %u\n", GetLastError()); 1569 1570 file = CreateFileA(file_name, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 1571 FILE_ATTRIBUTE_NORMAL, NULL); 1572 ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError()); 1573 file_size = GetFileSize(file, NULL); 1574 ok(file_size == 106, "file size = %u\n", file_size); 1575 1576 size = sizeof(buf); 1577 ret = InternetReadFile(request, buf, sizeof(buf), &size); 1578 ok(ret, "InternetReadFile failed: %u\n", GetLastError()); 1579 ok(size == 100, "size = %u\n", size); 1580 1581 file_size = GetFileSize(file, NULL); 1582 ok(file_size == 106, "file size = %u\n", file_size); 1583 CloseHandle(file); 1584 1585 ret = DeleteFileA(file_name); 1586 ok(!ret && GetLastError() == ERROR_SHARING_VIOLATION, "Deleting file returned %x(%u)\n", ret, GetLastError()); 1587 1588 ok(InternetCloseHandle(request), "Close request handle failed\n"); 1589 1590 file = CreateFileA(file_name, GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 1591 FILE_ATTRIBUTE_NORMAL, NULL); 1592 ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError()); 1593 ret = WriteFile(file, cached_content, sizeof(cached_content), &size, NULL); 1594 ok(ret && size, "WriteFile failed: %d, %d\n", ret, size); 1595 ret = CommitUrlCacheEntryA(url, file_name, filetime_zero, filetime_zero, NORMAL_CACHE_ENTRY, NULL, 0, NULL, 0); 1596 ok(ret, "CommitUrlCacheEntry failed: %d\n", GetLastError()); 1597 CloseHandle(file); 1598 1599 /* Send the same request, requiring it to be retrieved from the cache */ 1600 request = HttpOpenRequestA(connect, "GET", "/tests/hello.html", NULL, NULL, NULL, INTERNET_FLAG_FROM_CACHE, 0); 1601 1602 ret = HttpSendRequestA(request, NULL, 0, NULL, 0); 1603 ok(ret, "HttpSendRequest failed\n"); 1604 1605 size = sizeof(buf); 1606 ret = InternetReadFile(request, buf, sizeof(buf), &size); 1607 ok(ret, "InternetReadFile failed: %u\n", GetLastError()); 1608 ok(size == 100, "size = %u\n", size); 1609 buf[99] = 0; 1610 todo_wine ok(!strcmp((char*)buf, cached_content), "incorrect page data: %s\n", (char*)buf); 1611 1612 ok(InternetCloseHandle(request), "Close request handle failed\n"); 1613 1614 DeleteUrlCacheEntryA(url); 1615 request = HttpOpenRequestA(connect, "GET", "/tests/hello.html", NULL, NULL, NULL, INTERNET_FLAG_FROM_CACHE, 0); 1616 ret = HttpSendRequestA(request, NULL, 0, NULL, 0); 1617 todo_wine ok(!ret, "HttpSendRequest succeeded\n"); 1618 if(!ret) 1619 ok(GetLastError() == ERROR_FILE_NOT_FOUND, "GetLastError() = %d\n", GetLastError()); 1620 ok(InternetCloseHandle(request), "Close request handle failed\n"); 1621 1622 request = HttpOpenRequestA(connect, NULL, "/", NULL, NULL, types, INTERNET_FLAG_NO_CACHE_WRITE, 0); 1623 ok(request != NULL, "Failed to open request handle err %u\n", GetLastError()); 1624 1625 size = sizeof(file_name); 1626 ret = InternetQueryOptionA(request, INTERNET_OPTION_DATAFILE_NAME, file_name, &size); 1627 ok(!ret, "InternetQueryOptionA(INTERNET_OPTION_DATAFILE_NAME) succeeded\n"); 1628 ok(GetLastError() == ERROR_INTERNET_ITEM_NOT_FOUND, "GetLastError()=%u\n", GetLastError()); 1629 ok(!size, "size = %d\n", size); 1630 1631 ret = HttpSendRequestA(request, NULL, 0, NULL, 0); 1632 ok(ret, "HttpSendRequest failed: %u\n", GetLastError()); 1633 1634 size = sizeof(file_name); 1635 file_name[0] = 0; 1636 ret = InternetQueryOptionA(request, INTERNET_OPTION_DATAFILE_NAME, file_name, &size); 1637 if (ret) 1638 { 1639 file = CreateFileA(file_name, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING, 1640 FILE_ATTRIBUTE_NORMAL, NULL); 1641 ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError()); 1642 CloseHandle(file); 1643 } 1644 else 1645 { 1646 /* < IE8 */ 1647 ok(file_name[0] == 0, "Didn't expect a file name\n"); 1648 } 1649 1650 ok(InternetCloseHandle(request), "Close request handle failed\n"); 1651 ok(InternetCloseHandle(connect), "Close connect handle failed\n"); 1652 ok(InternetCloseHandle(session), "Close session handle failed\n"); 1653 1654 test_cache_read(); 1655 } 1656 1657 static void InternetLockRequestFile_test(void) 1658 { 1659 char file_name[MAX_PATH]; 1660 test_request_t req; 1661 HANDLE lock, lock2; 1662 DWORD size; 1663 BOOL ret; 1664 1665 open_simple_request(&req, "test.winehq.org", INTERNET_DEFAULT_HTTP_PORT, NULL, "/tests/hello.html"); 1666 1667 size = sizeof(file_name); 1668 ret = InternetQueryOptionA(req.request, INTERNET_OPTION_DATAFILE_NAME, file_name, &size); 1669 ok(!ret, "InternetQueryOptionA(INTERNET_OPTION_DATAFILE_NAME) succeeded\n"); 1670 ok(GetLastError() == ERROR_INTERNET_ITEM_NOT_FOUND, "GetLastError()=%u\n", GetLastError()); 1671 ok(!size, "size = %d\n", size); 1672 1673 lock = NULL; 1674 ret = InternetLockRequestFile(req.request, &lock); 1675 ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND, "InternetLockRequestFile returned: %x(%u)\n", ret, GetLastError()); 1676 1677 ret = HttpSendRequestA(req.request, NULL, 0, NULL, 0); 1678 ok(ret, "HttpSendRequest failed: %u\n", GetLastError()); 1679 1680 size = sizeof(file_name); 1681 ret = InternetQueryOptionA(req.request, INTERNET_OPTION_DATAFILE_NAME, file_name, &size); 1682 ok(ret, "InternetQueryOptionA(INTERNET_OPTION_DATAFILE_NAME) failed: %u\n", GetLastError()); 1683 1684 ret = InternetLockRequestFile(req.request, &lock); 1685 ok(ret, "InternetLockRequestFile returned: %x(%u)\n", ret, GetLastError()); 1686 ok(lock != NULL, "lock == NULL\n"); 1687 1688 ret = InternetLockRequestFile(req.request, &lock2); 1689 ok(ret, "InternetLockRequestFile returned: %x(%u)\n", ret, GetLastError()); 1690 ok(lock == lock2, "lock != lock2\n"); 1691 1692 ret = InternetUnlockRequestFile(lock2); 1693 ok(ret, "InternetUnlockRequestFile failed: %u\n", GetLastError()); 1694 1695 ret = DeleteFileA(file_name); 1696 ok(!ret && GetLastError() == ERROR_SHARING_VIOLATION, "Deleting file returned %x(%u)\n", ret, GetLastError()); 1697 1698 ok(InternetCloseHandle(req.request), "Close request handle failed\n"); 1699 1700 ret = DeleteFileA(file_name); 1701 ok(!ret && GetLastError() == ERROR_SHARING_VIOLATION, "Deleting file returned %x(%u)\n", ret, GetLastError()); 1702 1703 ret = InternetUnlockRequestFile(lock); 1704 ok(ret, "InternetUnlockRequestFile failed: %u\n", GetLastError()); 1705 1706 ret = DeleteFileA(file_name); 1707 ok(ret, "Deleting file returned %x(%u)\n", ret, GetLastError()); 1708 } 1709 1710 static void HttpHeaders_test(void) 1711 { 1712 HINTERNET hSession; 1713 HINTERNET hConnect; 1714 HINTERNET hRequest; 1715 CHAR buffer[256]; 1716 WCHAR wbuffer[256]; 1717 DWORD len = 256; 1718 DWORD oldlen; 1719 DWORD index = 0; 1720 BOOL ret; 1721 1722 hSession = InternetOpenA("Wine Regression Test", 1723 INTERNET_OPEN_TYPE_PRECONFIG,NULL,NULL,0); 1724 ok( hSession != NULL ,"Unable to open Internet session\n"); 1725 hConnect = InternetConnectA(hSession, "test.winehq.org", 1726 INTERNET_DEFAULT_HTTP_PORT, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 1727 0); 1728 ok( hConnect != NULL, "Unable to connect to http://test.winehq.org\n"); 1729 hRequest = HttpOpenRequestA(hConnect, "POST", "/tests/post.php", 1730 NULL, NULL, NULL, INTERNET_FLAG_NO_CACHE_WRITE, 0); 1731 if (!hRequest && GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED) 1732 { 1733 skip( "Network unreachable, skipping test\n" ); 1734 goto done; 1735 } 1736 ok( hRequest != NULL, "Failed to open request handle\n"); 1737 1738 index = 0; 1739 len = sizeof(buffer); 1740 strcpy(buffer,"Warning"); 1741 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, 1742 buffer,&len,&index)==0,"Warning hearder reported as Existing\n"); 1743 1744 ok(HttpAddRequestHeadersA(hRequest,"Warning:test1",-1,HTTP_ADDREQ_FLAG_ADD), 1745 "Failed to add new header\n"); 1746 1747 index = 0; 1748 len = sizeof(buffer); 1749 strcpy(buffer,"Warning"); 1750 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, 1751 buffer,&len,&index),"Unable to query header\n"); 1752 ok(index == 1, "Index was not incremented\n"); 1753 ok(strcmp(buffer,"test1")==0, "incorrect string was returned(%s)\n",buffer); 1754 ok(len == 5, "Invalid length (exp. 5, got %d)\n", len); 1755 ok((len < sizeof(buffer)) && (buffer[len] == 0), "Buffer not NULL-terminated\n"); /* len show only 5 characters but the buffer is NULL-terminated*/ 1756 len = sizeof(buffer); 1757 strcpy(buffer,"Warning"); 1758 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, 1759 buffer,&len,&index)==0,"Second Index Should Not Exist\n"); 1760 1761 index = 0; 1762 len = 5; /* could store the string but not the NULL terminator */ 1763 strcpy(buffer,"Warning"); 1764 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, 1765 buffer,&len,&index) == FALSE,"Query succeeded on a too small buffer\n"); 1766 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Unexpected last error: %d\n", GetLastError()); 1767 ok(index == 0, "Index was incremented\n"); 1768 ok(strcmp(buffer,"Warning")==0, "incorrect string was returned(%s)\n",buffer); /* string not touched */ 1769 ok(len == 6, "Invalid length (exp. 6, got %d)\n", len); /* unlike success, the length includes the NULL-terminator */ 1770 1771 /* a call with NULL will fail but will return the length */ 1772 index = 0; 1773 len = sizeof(buffer); 1774 SetLastError(0xdeadbeef); 1775 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF|HTTP_QUERY_FLAG_REQUEST_HEADERS, 1776 NULL,&len,&index) == FALSE,"Query worked\n"); 1777 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Unexpected last error: %d\n", GetLastError()); 1778 ok(len > 40, "Invalid length (exp. more than 40, got %d)\n", len); 1779 ok(index == 0, "Index was incremented\n"); 1780 1781 /* even for a len that is too small */ 1782 index = 0; 1783 len = 15; 1784 SetLastError(0xdeadbeef); 1785 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF|HTTP_QUERY_FLAG_REQUEST_HEADERS, 1786 NULL,&len,&index) == FALSE,"Query worked\n"); 1787 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Unexpected last error: %d\n", GetLastError()); 1788 ok(len > 40, "Invalid length (exp. more than 40, got %d)\n", len); 1789 ok(index == 0, "Index was incremented\n"); 1790 1791 index = 0; 1792 len = 0; 1793 SetLastError(0xdeadbeef); 1794 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF|HTTP_QUERY_FLAG_REQUEST_HEADERS, 1795 NULL,&len,&index) == FALSE,"Query worked\n"); 1796 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Unexpected last error: %d\n", GetLastError()); 1797 ok(len > 40, "Invalid length (exp. more than 40, got %d)\n", len); 1798 ok(index == 0, "Index was incremented\n"); 1799 oldlen = len; /* bytes; at least long enough to hold buffer & nul */ 1800 1801 1802 /* a working query */ 1803 index = 0; 1804 len = sizeof(buffer); 1805 memset(buffer, 'x', sizeof(buffer)); 1806 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF|HTTP_QUERY_FLAG_REQUEST_HEADERS, 1807 buffer,&len,&index),"Unable to query header\n"); 1808 ok(len + sizeof(CHAR) <= oldlen, "Result longer than advertised\n"); 1809 ok((len < sizeof(buffer)-sizeof(CHAR)) && (buffer[len/sizeof(CHAR)] == 0),"No NUL at end\n"); 1810 ok(len == strlen(buffer) * sizeof(CHAR), "Length wrong\n"); 1811 /* what's in the middle differs between Wine and Windows so currently we check only the beginning and the end */ 1812 ok(strncmp(buffer, "POST /tests/post.php HTTP/1", 25)==0, "Invalid beginning of headers string\n"); 1813 ok(strcmp(buffer + strlen(buffer) - 4, "\r\n\r\n")==0, "Invalid end of headers string\n"); 1814 ok(index == 0, "Index was incremented\n"); 1815 1816 /* Like above two tests, but for W version */ 1817 1818 index = 0; 1819 len = 0; 1820 SetLastError(0xdeadbeef); 1821 ok(HttpQueryInfoW(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF|HTTP_QUERY_FLAG_REQUEST_HEADERS, 1822 NULL,&len,&index) == FALSE,"Query worked\n"); 1823 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Unexpected last error: %d\n", GetLastError()); 1824 ok(len > 80, "Invalid length (exp. more than 80, got %d)\n", len); 1825 ok(index == 0, "Index was incremented\n"); 1826 oldlen = len; /* bytes; at least long enough to hold buffer & nul */ 1827 1828 /* a working query */ 1829 index = 0; 1830 len = sizeof(wbuffer); 1831 memset(wbuffer, 'x', sizeof(wbuffer)); 1832 ok(HttpQueryInfoW(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF|HTTP_QUERY_FLAG_REQUEST_HEADERS, 1833 wbuffer,&len,&index),"Unable to query header\n"); 1834 ok(len + sizeof(WCHAR) <= oldlen, "Result longer than advertised\n"); 1835 ok(len == lstrlenW(wbuffer) * sizeof(WCHAR), "Length wrong\n"); 1836 ok((len < sizeof(wbuffer)-sizeof(WCHAR)) && (wbuffer[len/sizeof(WCHAR)] == 0),"No NUL at end\n"); 1837 ok(index == 0, "Index was incremented\n"); 1838 1839 /* end of W version tests */ 1840 1841 /* Without HTTP_QUERY_FLAG_REQUEST_HEADERS */ 1842 index = 0; 1843 len = sizeof(buffer); 1844 memset(buffer, 'x', sizeof(buffer)); 1845 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF, 1846 buffer,&len,&index) == TRUE,"Query failed\n"); 1847 ok(len == 2 || len == 4 /* win10 */, "Expected 2 or 4, got %d\n", len); 1848 ok(memcmp(buffer, "\r\n\r\n", len) == 0, "Expected CRLF, got '%s'\n", buffer); 1849 ok(index == 0, "Index was incremented\n"); 1850 1851 ok(HttpAddRequestHeadersA(hRequest,"Warning:test2",-1,HTTP_ADDREQ_FLAG_ADD), 1852 "Failed to add duplicate header using HTTP_ADDREQ_FLAG_ADD\n"); 1853 1854 index = 0; 1855 len = sizeof(buffer); 1856 strcpy(buffer,"Warning"); 1857 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, 1858 buffer,&len,&index),"Unable to query header\n"); 1859 ok(index == 1, "Index was not incremented\n"); 1860 ok(strcmp(buffer,"test1")==0, "incorrect string was returned(%s)\n",buffer); 1861 len = sizeof(buffer); 1862 strcpy(buffer,"Warning"); 1863 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, 1864 buffer,&len,&index),"Failed to get second header\n"); 1865 ok(index == 2, "Index was not incremented\n"); 1866 ok(strcmp(buffer,"test2")==0, "incorrect string was returned(%s)\n",buffer); 1867 len = sizeof(buffer); 1868 strcpy(buffer,"Warning"); 1869 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, 1870 buffer,&len,&index)==0,"Third Header Should Not Exist\n"); 1871 1872 ok(HttpAddRequestHeadersA(hRequest,"Warning:test3",-1,HTTP_ADDREQ_FLAG_REPLACE), "Failed to replace header using HTTP_ADDREQ_FLAG_REPLACE\n"); 1873 1874 index = 0; 1875 len = sizeof(buffer); 1876 strcpy(buffer,"Warning"); 1877 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, 1878 buffer,&len,&index),"Unable to query header\n"); 1879 ok(index == 1, "Index was not incremented\n"); 1880 ok(strcmp(buffer,"test2")==0, "incorrect string was returned(%s)\n",buffer); 1881 len = sizeof(buffer); 1882 strcpy(buffer,"Warning"); 1883 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, 1884 buffer,&len,&index),"Failed to get second header\n"); 1885 ok(index == 2, "Index was not incremented\n"); 1886 ok(strcmp(buffer,"test3")==0, "incorrect string was returned(%s)\n",buffer); 1887 len = sizeof(buffer); 1888 strcpy(buffer,"Warning"); 1889 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, 1890 buffer,&len,&index)==0,"Third Header Should Not Exist\n"); 1891 1892 ok(HttpAddRequestHeadersA(hRequest,"Warning:test4",-1,HTTP_ADDREQ_FLAG_ADD_IF_NEW)==0, "HTTP_ADDREQ_FLAG_ADD_IF_NEW replaced existing header\n"); 1893 1894 index = 0; 1895 len = sizeof(buffer); 1896 strcpy(buffer,"Warning"); 1897 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, 1898 buffer,&len,&index),"Unable to query header\n"); 1899 ok(index == 1, "Index was not incremented\n"); 1900 ok(strcmp(buffer,"test2")==0, "incorrect string was returned(%s)\n",buffer); 1901 len = sizeof(buffer); 1902 strcpy(buffer,"Warning"); 1903 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, 1904 buffer,&len,&index),"Failed to get second header\n"); 1905 ok(index == 2, "Index was not incremented\n"); 1906 ok(strcmp(buffer,"test3")==0, "incorrect string was returned(%s)\n",buffer); 1907 len = sizeof(buffer); 1908 strcpy(buffer,"Warning"); 1909 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, 1910 buffer,&len,&index)==0,"Third Header Should Not Exist\n"); 1911 1912 ok(HttpAddRequestHeadersA(hRequest,"Warning:test4",-1, HTTP_ADDREQ_FLAG_COALESCE), "HTTP_ADDREQ_FLAG_COALESCE Did not work\n"); 1913 1914 index = 0; 1915 len = sizeof(buffer); 1916 strcpy(buffer,"Warning"); 1917 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, 1918 buffer,&len,&index),"Unable to query header\n"); 1919 ok(index == 1, "Index was not incremented\n"); 1920 ok(strcmp(buffer,"test2, test4")==0, "incorrect string was returned(%s)\n", buffer); 1921 len = sizeof(buffer); 1922 strcpy(buffer,"Warning"); 1923 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Failed to get second header\n"); 1924 ok(index == 2, "Index was not incremented\n"); 1925 ok(strcmp(buffer,"test3")==0, "incorrect string was returned(%s)\n",buffer); 1926 len = sizeof(buffer); 1927 strcpy(buffer,"Warning"); 1928 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index)==0,"Third Header Should Not Exist\n"); 1929 1930 ok(HttpAddRequestHeadersA(hRequest,"Warning:test5",-1, HTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA), "HTTP_ADDREQ_FLAG_COALESCE Did not work\n"); 1931 1932 index = 0; 1933 len = sizeof(buffer); 1934 strcpy(buffer,"Warning"); 1935 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Unable to query header\n"); 1936 ok(index == 1, "Index was not incremented\n"); 1937 ok(strcmp(buffer,"test2, test4, test5")==0, "incorrect string was returned(%s)\n",buffer); 1938 len = sizeof(buffer); 1939 strcpy(buffer,"Warning"); 1940 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Failed to get second header\n"); 1941 ok(index == 2, "Index was not incremented\n"); 1942 ok(strcmp(buffer,"test3")==0, "incorrect string was returned(%s)\n",buffer); 1943 len = sizeof(buffer); 1944 strcpy(buffer,"Warning"); 1945 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index)==0,"Third Header Should Not Exist\n"); 1946 1947 ok(HttpAddRequestHeadersA(hRequest,"Warning:test6",-1, HTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON), "HTTP_ADDREQ_FLAG_COALESCE Did not work\n"); 1948 1949 index = 0; 1950 len = sizeof(buffer); 1951 strcpy(buffer,"Warning"); 1952 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Unable to query header\n"); 1953 ok(index == 1, "Index was not incremented\n"); 1954 ok(strcmp(buffer,"test2, test4, test5; test6")==0, "incorrect string was returned(%s)\n",buffer); 1955 len = sizeof(buffer); 1956 strcpy(buffer,"Warning"); 1957 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Failed to get second header\n"); 1958 ok(index == 2, "Index was not incremented\n"); 1959 ok(strcmp(buffer,"test3")==0, "incorrect string was returned(%s)\n",buffer); 1960 len = sizeof(buffer); 1961 strcpy(buffer,"Warning"); 1962 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index)==0,"Third Header Should Not Exist\n"); 1963 1964 ok(HttpAddRequestHeadersA(hRequest,"Warning:test7",-1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE), "HTTP_ADDREQ_FLAG_ADD with HTTP_ADDREQ_FLAG_REPALCE Did not work\n"); 1965 1966 index = 0; 1967 len = sizeof(buffer); 1968 strcpy(buffer,"Warning"); 1969 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Unable to query header\n"); 1970 ok(index == 1, "Index was not incremented\n"); 1971 ok(strcmp(buffer,"test3")==0, "incorrect string was returned(%s)\n",buffer); 1972 len = sizeof(buffer); 1973 strcpy(buffer,"Warning"); 1974 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Failed to get second header\n"); 1975 ok(index == 2, "Index was not incremented\n"); 1976 ok(strcmp(buffer,"test7")==0, "incorrect string was returned(%s)\n",buffer); 1977 len = sizeof(buffer); 1978 strcpy(buffer,"Warning"); 1979 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index)==0,"Third Header Should Not Exist\n"); 1980 1981 /* Ensure that blank headers are ignored and don't cause a failure */ 1982 ok(HttpAddRequestHeadersA(hRequest,"\r\nBlankTest:value\r\n\r\n",-1, HTTP_ADDREQ_FLAG_ADD_IF_NEW), "Failed to add header with blank entries in list\n"); 1983 1984 index = 0; 1985 len = sizeof(buffer); 1986 strcpy(buffer,"BlankTest"); 1987 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Unable to query header\n"); 1988 ok(index == 1, "Index was not incremented\n"); 1989 ok(strcmp(buffer,"value")==0, "incorrect string was returned(%s)\n",buffer); 1990 1991 /* Ensure that malformed header separators are ignored and don't cause a failure */ 1992 ok(HttpAddRequestHeadersA(hRequest,"\r\rMalformedTest:value\n\nMalformedTestTwo: value2\rMalformedTestThree: value3\n\n\r\r\n",-1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE), 1993 "Failed to add header with malformed entries in list\n"); 1994 1995 index = 0; 1996 len = sizeof(buffer); 1997 strcpy(buffer,"MalformedTest"); 1998 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Unable to query header\n"); 1999 ok(index == 1, "Index was not incremented\n"); 2000 ok(strcmp(buffer,"value")==0, "incorrect string was returned(%s)\n",buffer); 2001 index = 0; 2002 len = sizeof(buffer); 2003 strcpy(buffer,"MalformedTestTwo"); 2004 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Unable to query header\n"); 2005 ok(index == 1, "Index was not incremented\n"); 2006 ok(strcmp(buffer,"value2")==0, "incorrect string was returned(%s)\n",buffer); 2007 index = 0; 2008 len = sizeof(buffer); 2009 strcpy(buffer,"MalformedTestThree"); 2010 ok(HttpQueryInfoA(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Unable to query header\n"); 2011 ok(index == 1, "Index was not incremented\n"); 2012 ok(strcmp(buffer,"value3")==0, "incorrect string was returned(%s)\n",buffer); 2013 2014 ret = HttpAddRequestHeadersA(hRequest, "Authorization: Basic\r\n", -1, HTTP_ADDREQ_FLAG_ADD); 2015 ok(ret, "unable to add header %u\n", GetLastError()); 2016 2017 index = 0; 2018 buffer[0] = 0; 2019 len = sizeof(buffer); 2020 ret = HttpQueryInfoA(hRequest, HTTP_QUERY_AUTHORIZATION|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &len, &index); 2021 ok(ret, "unable to query header %u\n", GetLastError()); 2022 ok(index == 1, "index was not incremented\n"); 2023 ok(!strcmp(buffer, "Basic"), "incorrect string was returned (%s)\n", buffer); 2024 2025 ret = HttpAddRequestHeadersA(hRequest, "Authorization:\r\n", -1, HTTP_ADDREQ_FLAG_REPLACE); 2026 ok(ret, "unable to remove header %u\n", GetLastError()); 2027 2028 index = 0; 2029 len = sizeof(buffer); 2030 SetLastError(0xdeadbeef); 2031 ok(!HttpQueryInfoA(hRequest, HTTP_QUERY_AUTHORIZATION|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &len, &index), 2032 "header still present\n"); 2033 ok(GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND, "got %u\n", GetLastError()); 2034 2035 ok(InternetCloseHandle(hRequest), "Close request handle failed\n"); 2036 done: 2037 ok(InternetCloseHandle(hConnect), "Close connect handle failed\n"); 2038 ok(InternetCloseHandle(hSession), "Close session handle failed\n"); 2039 } 2040 2041 static const char garbagemsg[] = 2042 "Garbage: Header\r\n"; 2043 2044 static const char contmsg[] = 2045 "HTTP/1.1 100 Continue\r\n"; 2046 2047 static const char expandcontmsg[] = 2048 "HTTP/1.1 100 Continue\r\n" 2049 "Server: winecontinue\r\n" 2050 "Tag: something witty\r\n"; 2051 2052 static const char okmsg[] = 2053 "HTTP/1.1 200 OK\r\n" 2054 "Server: winetest\r\n" 2055 "\r\n"; 2056 2057 static const char okmsg201[] = 2058 "HTTP/1.1 201 OK\r\n" 2059 "Server: winetest\r\n" 2060 "\r\n"; 2061 2062 static const char okmsg2[] = 2063 "HTTP/1.1 200 OK\r\n" 2064 "Date: Mon, 01 Dec 2008 13:44:34 GMT\r\n" 2065 "Server: winetest\r\n" 2066 "Content-Length: 0\r\n" 2067 "Set-Cookie: one\r\n" 2068 "Set-Cookie: two\r\n" 2069 "\r\n"; 2070 2071 static DWORD64 content_length; 2072 static const char largemsg[] = 2073 "HTTP/1.1 200 OK\r\n" 2074 "Content-Length: %I64u\r\n" 2075 "\r\n"; 2076 2077 static const char okmsg_cookie_path[] = 2078 "HTTP/1.1 200 OK\r\n" 2079 "Date: Mon, 01 Dec 2008 13:44:34 GMT\r\n" 2080 "Server: winetest\r\n" 2081 "Content-Length: 0\r\n" 2082 "Set-Cookie: subcookie2=data; path=/test_cookie_set_path\r\n" 2083 "\r\n"; 2084 2085 static const char okmsg_cookie[] = 2086 "HTTP/1.1 200 OK\r\n" 2087 "Date: Mon, 01 Dec 2008 13:44:34 GMT\r\n" 2088 "Server: winetest\r\n" 2089 "Content-Length: 0\r\n" 2090 "Set-Cookie: testcookie=testvalue\r\n" 2091 "\r\n"; 2092 2093 static const char notokmsg[] = 2094 "HTTP/1.1 400 Bad Request\r\n" 2095 "Server: winetest\r\n" 2096 "\r\n"; 2097 2098 static const char noauthmsg[] = 2099 "HTTP/1.1 401 Unauthorized\r\n" 2100 "Server: winetest\r\n" 2101 "Connection: close\r\n" 2102 "WWW-Authenticate: Basic realm=\"placebo\"\r\n" 2103 "\r\n"; 2104 2105 static const char noauthmsg2[] = 2106 "HTTP/1.0 401 Anonymous requests or requests on unsecure channel are not allowed\r\n" 2107 "HTTP/1.0 401 Anonymous requests or requests on unsecure channel are not allowed" 2108 "\0d`0|6\n" 2109 "Server: winetest\r\n"; 2110 2111 static const char proxymsg[] = 2112 "HTTP/1.1 407 Proxy Authentication Required\r\n" 2113 "Server: winetest\r\n" 2114 "Proxy-Connection: close\r\n" 2115 "Proxy-Authenticate: Basic realm=\"placebo\"\r\n" 2116 "\r\n"; 2117 2118 static const char page1[] = 2119 "<HTML>\r\n" 2120 "<HEAD><TITLE>wininet test page</TITLE></HEAD>\r\n" 2121 "<BODY>The quick brown fox jumped over the lazy dog<P></BODY>\r\n" 2122 "</HTML>\r\n\r\n"; 2123 2124 static const char ok_with_length[] = 2125 "HTTP/1.1 200 OK\r\n" 2126 "Connection: Keep-Alive\r\n" 2127 "Content-Length: 18\r\n\r\n" 2128 "HTTP/1.1 211 OK\r\n\r\n"; 2129 2130 static const char ok_with_length2[] = 2131 "HTTP/1.1 210 OK\r\n" 2132 "Connection: Keep-Alive\r\n" 2133 "Content-Length: 19\r\n\r\n" 2134 "HTTP/1.1 211 OK\r\n\r\n"; 2135 2136 struct server_info { 2137 HANDLE hEvent; 2138 int port; 2139 }; 2140 2141 static int test_cache_gzip; 2142 static const char *send_buffer; 2143 static int server_socket; 2144 2145 static DWORD CALLBACK server_thread(LPVOID param) 2146 { 2147 struct server_info *si = param; 2148 int r, c = -1, i, on, count = 0; 2149 SOCKET s; 2150 struct sockaddr_in sa; 2151 char *buffer; 2152 size_t buffer_size; 2153 WSADATA wsaData; 2154 int last_request = 0; 2155 char host_header[22]; 2156 char host_header_override[30]; 2157 static int test_no_cache = 0; 2158 2159 WSAStartup(MAKEWORD(1,1), &wsaData); 2160 2161 s = socket(AF_INET, SOCK_STREAM, 0); 2162 if (s == INVALID_SOCKET) 2163 return 1; 2164 2165 on = 1; 2166 setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof on); 2167 2168 memset(&sa, 0, sizeof sa); 2169 sa.sin_family = AF_INET; 2170 sa.sin_port = htons(si->port); 2171 sa.sin_addr.S_un.S_addr = inet_addr("127.0.0.1"); 2172 2173 r = bind(s, (struct sockaddr*) &sa, sizeof sa); 2174 if (r<0) 2175 return 1; 2176 2177 listen(s, 0); 2178 2179 SetEvent(si->hEvent); 2180 2181 sprintf(host_header, "Host: localhost:%d", si->port); 2182 sprintf(host_header_override, "Host: test.local:%d\r\n", si->port); 2183 buffer = HeapAlloc(GetProcessHeap(), 0, buffer_size = 1000); 2184 2185 do 2186 { 2187 if(c == -1) 2188 c = accept(s, NULL, NULL); 2189 2190 memset(buffer, 0, buffer_size); 2191 for(i=0;; i++) 2192 { 2193 if(i == buffer_size) 2194 buffer = HeapReAlloc(GetProcessHeap(), 0, buffer, buffer_size *= 2); 2195 2196 r = recv(c, buffer+i, 1, 0); 2197 if (r != 1) 2198 break; 2199 if (i<4) continue; 2200 if (buffer[i-2] == '\n' && buffer[i] == '\n' && 2201 buffer[i-3] == '\r' && buffer[i-1] == '\r') 2202 break; 2203 } 2204 if (strstr(buffer, "GET /test1")) 2205 { 2206 if (!strstr(buffer, "Content-Length: 0")) 2207 { 2208 send(c, okmsg, sizeof okmsg-1, 0); 2209 send(c, page1, sizeof page1-1, 0); 2210 } 2211 else 2212 send(c, notokmsg, sizeof notokmsg-1, 0); 2213 } 2214 if (strstr(buffer, "CONNECT ")) 2215 { 2216 if (!strstr(buffer, "Content-Length: 0")) 2217 send(c, notokmsg, sizeof notokmsg-1, 0); 2218 else 2219 send(c, proxymsg, sizeof proxymsg-1, 0); 2220 } 2221 if (strstr(buffer, "/test2")) 2222 { 2223 if (strstr(buffer, "Proxy-Authorization: Basic bWlrZToxMTAx")) 2224 { 2225 send(c, okmsg, sizeof okmsg-1, 0); 2226 send(c, page1, sizeof page1-1, 0); 2227 } 2228 else 2229 send(c, proxymsg, sizeof proxymsg-1, 0); 2230 } 2231 if (strstr(buffer, "/test3")) 2232 { 2233 if (strstr(buffer, "Authorization: Basic dXNlcjpwd2Q=")) 2234 send(c, okmsg, sizeof okmsg-1, 0); 2235 else 2236 send(c, noauthmsg, sizeof noauthmsg-1, 0); 2237 } 2238 if (strstr(buffer, "/test4")) 2239 { 2240 if (strstr(buffer, "Connection: Close")) 2241 send(c, okmsg, sizeof okmsg-1, 0); 2242 else 2243 send(c, notokmsg, sizeof notokmsg-1, 0); 2244 } 2245 if (strstr(buffer, "POST /test5") || 2246 strstr(buffer, "RPC_IN_DATA /test5") || 2247 strstr(buffer, "RPC_OUT_DATA /test5")) 2248 { 2249 if (strstr(buffer, "Content-Length: 0")) 2250 { 2251 send(c, okmsg, sizeof okmsg-1, 0); 2252 send(c, page1, sizeof page1-1, 0); 2253 } 2254 else 2255 send(c, notokmsg, sizeof notokmsg-1, 0); 2256 } 2257 if (strstr(buffer, "GET /test6")) 2258 { 2259 send(c, contmsg, sizeof contmsg-1, 0); 2260 send(c, contmsg, sizeof contmsg-1, 0); 2261 send(c, okmsg, sizeof okmsg-1, 0); 2262 send(c, page1, sizeof page1-1, 0); 2263 } 2264 if (strstr(buffer, "POST /test7")) 2265 { 2266 if (strstr(buffer, "Content-Length: 100")) 2267 { 2268 if (strstr(buffer, "POST /test7b")) 2269 recvfrom(c, buffer, buffer_size, 0, NULL, NULL); 2270 send(c, okmsg, sizeof okmsg-1, 0); 2271 send(c, page1, sizeof page1-1, 0); 2272 } 2273 else 2274 send(c, notokmsg, sizeof notokmsg-1, 0); 2275 } 2276 if (strstr(buffer, "/test8")) 2277 { 2278 if (!strstr(buffer, "Connection: Close") && 2279 strstr(buffer, "Connection: Keep-Alive") && 2280 !strstr(buffer, "Cache-Control: no-cache") && 2281 !strstr(buffer, "Pragma: no-cache") && 2282 strstr(buffer, host_header)) 2283 send(c, okmsg, sizeof okmsg-1, 0); 2284 else 2285 send(c, notokmsg, sizeof notokmsg-1, 0); 2286 } 2287 if (strstr(buffer, "/test9")) 2288 { 2289 if (!strstr(buffer, "Connection: Close") && 2290 !strstr(buffer, "Connection: Keep-Alive") && 2291 !strstr(buffer, "Cache-Control: no-cache") && 2292 !strstr(buffer, "Pragma: no-cache") && 2293 strstr(buffer, host_header)) 2294 send(c, okmsg, sizeof okmsg-1, 0); 2295 else 2296 send(c, notokmsg, sizeof notokmsg-1, 0); 2297 } 2298 if (strstr(buffer, "/testA")) 2299 { 2300 if (!strstr(buffer, "Connection: Close") && 2301 !strstr(buffer, "Connection: Keep-Alive") && 2302 (strstr(buffer, "Cache-Control: no-cache") || 2303 strstr(buffer, "Pragma: no-cache")) && 2304 strstr(buffer, host_header)) 2305 send(c, okmsg, sizeof okmsg-1, 0); 2306 else 2307 send(c, notokmsg, sizeof notokmsg-1, 0); 2308 } 2309 if (strstr(buffer, "/testC")) 2310 { 2311 if (strstr(buffer, "cookie=biscuit")) 2312 send(c, okmsg, sizeof okmsg-1, 0); 2313 else 2314 send(c, notokmsg, sizeof notokmsg-1, 0); 2315 } 2316 if (strstr(buffer, "/testD")) 2317 { 2318 send(c, okmsg2, sizeof okmsg2-1, 0); 2319 } 2320 if (strstr(buffer, "/testE")) 2321 { 2322 send(c, noauthmsg2, sizeof noauthmsg2-1, 0); 2323 } 2324 if (strstr(buffer, "GET /quit")) 2325 { 2326 send(c, okmsg, sizeof okmsg-1, 0); 2327 send(c, page1, sizeof page1-1, 0); 2328 last_request = 1; 2329 } 2330 if (strstr(buffer, "GET /testF")) 2331 { 2332 send(c, expandcontmsg, sizeof expandcontmsg-1, 0); 2333 send(c, garbagemsg, sizeof garbagemsg-1, 0); 2334 send(c, contmsg, sizeof contmsg-1, 0); 2335 send(c, garbagemsg, sizeof garbagemsg-1, 0); 2336 send(c, okmsg, sizeof okmsg-1, 0); 2337 send(c, page1, sizeof page1-1, 0); 2338 } 2339 if (strstr(buffer, "GET /testG")) 2340 { 2341 send(c, page1, sizeof page1-1, 0); 2342 } 2343 2344 if (strstr(buffer, "GET /testJ")) 2345 { 2346 if (count == 0) 2347 { 2348 count++; 2349 send(c, ok_with_length, sizeof(ok_with_length)-1, 0); 2350 } 2351 else 2352 { 2353 send(c, ok_with_length2, sizeof(ok_with_length2)-1, 0); 2354 count = 0; 2355 } 2356 } 2357 if (strstr(buffer, "GET /testH")) 2358 { 2359 send(c, ok_with_length2, sizeof(ok_with_length2)-1, 0); 2360 recvfrom(c, buffer, buffer_size, 0, NULL, NULL); 2361 send(c, ok_with_length, sizeof(ok_with_length)-1, 0); 2362 } 2363 2364 if (strstr(buffer, "GET /test_no_content")) 2365 { 2366 static const char nocontentmsg[] = "HTTP/1.1 204 No Content\r\nConnection: close\r\n\r\n"; 2367 send(c, nocontentmsg, sizeof(nocontentmsg)-1, 0); 2368 } 2369 if (strstr(buffer, "GET /test_conn_close")) 2370 { 2371 static const char conn_close_response[] = "HTTP/1.1 200 OK\r\nConnection: close\r\n\r\nsome content"; 2372 send(c, conn_close_response, sizeof(conn_close_response)-1, 0); 2373 WaitForSingleObject(conn_close_event, INFINITE); 2374 trace("closing connection\n"); 2375 } 2376 if (strstr(buffer, "GET /test_cache_control_no_cache")) 2377 { 2378 static const char no_cache_response[] = "HTTP/1.1 200 OK\r\nCache-Control: no-cache\r\n\r\nsome content"; 2379 if(!test_no_cache++) 2380 send(c, no_cache_response, sizeof(no_cache_response)-1, 0); 2381 else 2382 send(c, okmsg, sizeof(okmsg)-1, 0); 2383 } 2384 if (strstr(buffer, "GET /test_cache_control_no_store")) 2385 { 2386 static const char no_cache_response[] = "HTTP/1.1 200 OK\r\nCache-Control: junk, \t No-StOrE\r\n\r\nsome content"; 2387 send(c, no_cache_response, sizeof(no_cache_response)-1, 0); 2388 } 2389 if (strstr(buffer, "GET /test_cache_gzip")) 2390 { 2391 static const char gzip_response[] = "HTTP/1.1 200 OK\r\nContent-Encoding: gzip\r\nContent-Type: text/html\r\n\r\n" 2392 "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\x03\x4b\xaf\xca\x2c\x50\x28" 2393 "\x49\x2d\x2e\xe1\x02\x00\x62\x92\xc7\x6c\x0a\x00\x00\x00"; 2394 if(!test_cache_gzip++) 2395 send(c, gzip_response, sizeof(gzip_response), 0); 2396 else 2397 send(c, notokmsg, sizeof(notokmsg)-1, 0); 2398 } 2399 if (strstr(buffer, "HEAD /test_head")) { 2400 static const char head_response[] = 2401 "HTTP/1.1 200 OK\r\n" 2402 "Connection: Keep-Alive\r\n" 2403 "Content-Length: 100\r\n" 2404 "\r\n"; 2405 2406 send(c, head_response, sizeof(head_response), 0); 2407 continue; 2408 } 2409 if (strstr(buffer, "GET /send_from_buffer")) 2410 send(c, send_buffer, strlen(send_buffer), 0); 2411 if (strstr(buffer, "/test_cache_control_verb")) 2412 { 2413 if (!memcmp(buffer, "GET ", sizeof("GET ")-1) && 2414 !strstr(buffer, "Cache-Control: no-cache\r\n")) send(c, okmsg, sizeof(okmsg)-1, 0); 2415 else if (strstr(buffer, "Cache-Control: no-cache\r\n")) send(c, okmsg, sizeof(okmsg)-1, 0); 2416 else send(c, notokmsg, sizeof(notokmsg)-1, 0); 2417 } 2418 if (strstr(buffer, "/test_request_content_length")) 2419 { 2420 static char msg[] = "HTTP/1.1 200 OK\r\nConnection: Keep-Alive\r\n\r\n"; 2421 static int seen_content_length; 2422 2423 if (!seen_content_length) 2424 { 2425 if (strstr(buffer, "Content-Length: 0")) 2426 { 2427 seen_content_length = 1; 2428 send(c, msg, sizeof msg-1, 0); 2429 } 2430 else send(c, notokmsg, sizeof notokmsg-1, 0); 2431 WaitForSingleObject(complete_event, 5000); 2432 } 2433 else 2434 { 2435 if (strstr(buffer, "Content-Length: 0")) send(c, msg, sizeof msg-1, 0); 2436 else send(c, notokmsg, sizeof notokmsg-1, 0); 2437 WaitForSingleObject(complete_event, 5000); 2438 } 2439 } 2440 if (strstr(buffer, "GET /test_premature_disconnect")) 2441 trace("closing connection\n"); 2442 if (strstr(buffer, "HEAD /upload.txt")) 2443 { 2444 if (strstr(buffer, "Authorization: Basic dXNlcjpwd2Q=")) 2445 send(c, okmsg, sizeof okmsg-1, 0); 2446 else 2447 send(c, noauthmsg, sizeof noauthmsg-1, 0); 2448 } 2449 if (strstr(buffer, "PUT /upload2.txt")) 2450 { 2451 if (strstr(buffer, "Authorization: Basic dXNlcjpwd2Q=")) 2452 send(c, okmsg, sizeof okmsg-1, 0); 2453 else 2454 send(c, notokmsg, sizeof notokmsg-1, 0); 2455 } 2456 if (strstr(buffer, "HEAD /upload3.txt")) 2457 { 2458 if (strstr(buffer, "Authorization: Basic dXNlcjE6cHdkMQ==")) 2459 send(c, okmsg, sizeof okmsg-1, 0); 2460 else 2461 send(c, noauthmsg, sizeof noauthmsg-1, 0); 2462 } 2463 if (strstr(buffer, "HEAD /upload4.txt")) 2464 { 2465 if (strstr(buffer, "Authorization: Bearer dXNlcjE6cHdkMQ==")) 2466 send(c, okmsg, sizeof okmsg-1, 0); 2467 else if (strstr(buffer, "Authorization: Basic dXNlcjpwd2Q=")) 2468 send(c, okmsg201, sizeof okmsg-1, 0); 2469 else 2470 send(c, noauthmsg, sizeof noauthmsg-1, 0); 2471 } 2472 if (strstr(buffer, "/test_cookie_path1")) 2473 { 2474 if (strstr(buffer, "subcookie=data")) 2475 send(c, okmsg, sizeof okmsg-1, 0); 2476 else 2477 send(c, notokmsg, sizeof notokmsg-1, 0); 2478 } 2479 if (strstr(buffer, "/test_cookie_path2")) 2480 { 2481 if (strstr(buffer, "subcookie2=data")) 2482 send(c, okmsg, sizeof okmsg-1, 0); 2483 else 2484 send(c, notokmsg, sizeof notokmsg-1, 0); 2485 } 2486 if (strstr(buffer, "/test_cookie_set_path")) 2487 { 2488 send(c, okmsg_cookie_path, sizeof okmsg_cookie_path-1, 0); 2489 } 2490 if (strstr(buffer, "/test_cookie_merge")) 2491 { 2492 if (strstr(buffer, "subcookie=data") && 2493 !strstr(buffer, "manual_cookie=test")) 2494 send(c, okmsg, sizeof okmsg-1, 0); 2495 else 2496 send(c, notokmsg, sizeof notokmsg-1, 0); 2497 } 2498 if (strstr(buffer, "/test_cookie_set_host_override")) 2499 { 2500 send(c, okmsg_cookie, sizeof okmsg_cookie-1, 0); 2501 } 2502 if (strstr(buffer, "/test_cookie_check_host_override")) 2503 { 2504 if (strstr(buffer, "Cookie:") && strstr(buffer, "testcookie=testvalue")) 2505 send(c, okmsg, sizeof okmsg-1, 0); 2506 else 2507 send(c, notokmsg, sizeof notokmsg-1, 0); 2508 } 2509 if (strstr(buffer, "/test_cookie_check_different_host")) 2510 { 2511 if (!strstr(buffer, "foo") && 2512 strstr(buffer, "cookie=biscuit")) 2513 send(c, okmsg, sizeof okmsg-1, 0); 2514 else 2515 send(c, notokmsg, sizeof notokmsg-1, 0); 2516 } 2517 if (strstr(buffer, "/test_host_override")) 2518 { 2519 if (strstr(buffer, host_header_override)) 2520 send(c, okmsg, sizeof okmsg-1, 0); 2521 else 2522 send(c, notokmsg, sizeof notokmsg-1, 0); 2523 } 2524 if (strstr(buffer, "/async_read")) 2525 { 2526 const char *page1_mid = page1 + (sizeof page1 - 1)/2; 2527 const char *page1_end = page1 + sizeof page1 - 1; 2528 send(c, okmsg, sizeof okmsg-1, 0); 2529 send(c, page1, page1_mid - page1, 0); 2530 WaitForSingleObject(conn_wait_event, INFINITE); 2531 send(c, page1_mid, page1_end - page1_mid, 0); 2532 } 2533 if (strstr(buffer, "/socket")) 2534 { 2535 server_socket = c; 2536 SetEvent(server_req_rec_event); 2537 WaitForSingleObject(conn_wait_event, INFINITE); 2538 } 2539 if (strstr(buffer, "/echo_request")) 2540 { 2541 send(c, okmsg, sizeof(okmsg)-1, 0); 2542 send(c, buffer, strlen(buffer), 0); 2543 } 2544 if (strstr(buffer, "GET /test_remove_dot_segments")) 2545 { 2546 send(c, okmsg, sizeof(okmsg)-1, 0); 2547 } 2548 2549 if (strstr(buffer, "HEAD /test_large_content")) 2550 { 2551 char msg[sizeof(largemsg) + 16]; 2552 sprintf(msg, largemsg, content_length); 2553 send(c, msg, strlen(msg), 0); 2554 } 2555 if (strstr(buffer, "HEAD /test_auth_host1")) 2556 { 2557 if (strstr(buffer, "Authorization: Basic dGVzdDE6cGFzcw==")) 2558 send(c, okmsg, sizeof okmsg-1, 0); 2559 else 2560 send(c, noauthmsg, sizeof noauthmsg-1, 0); 2561 } 2562 if (strstr(buffer, "HEAD /test_auth_host2")) 2563 { 2564 if (strstr(buffer, "Authorization: Basic dGVzdDE6cGFzczI=")) 2565 send(c, okmsg, sizeof okmsg-1, 0); 2566 else 2567 send(c, noauthmsg, sizeof noauthmsg-1, 0); 2568 } 2569 shutdown(c, 2); 2570 closesocket(c); 2571 c = -1; 2572 } while (!last_request); 2573 2574 closesocket(s); 2575 HeapFree(GetProcessHeap(), 0, buffer); 2576 2577 return 0; 2578 } 2579 2580 static void test_basic_request(int port, const char *verb, const char *url) 2581 { 2582 test_request_t req; 2583 DWORD r, count, error; 2584 char buffer[0x100]; 2585 2586 trace("basic request %s %s\n", verb, url); 2587 2588 open_simple_request(&req, "localhost", port, verb, url); 2589 2590 SetLastError(0xdeadbeef); 2591 r = HttpSendRequestA(req.request, NULL, 0, NULL, 0); 2592 error = GetLastError(); 2593 ok(error == ERROR_SUCCESS || broken(error != ERROR_SUCCESS), "expected ERROR_SUCCESS, got %u\n", error); 2594 ok(r, "HttpSendRequest failed: %u\n", GetLastError()); 2595 2596 count = 0; 2597 memset(buffer, 0, sizeof buffer); 2598 SetLastError(0xdeadbeef); 2599 r = InternetReadFile(req.request, buffer, sizeof buffer, &count); 2600 ok(r, "InternetReadFile failed %u\n", GetLastError()); 2601 ok(count == sizeof page1 - 1, "count was wrong\n"); 2602 ok(!memcmp(buffer, page1, sizeof page1), "http data wrong, got: %s\n", buffer); 2603 2604 close_request(&req); 2605 } 2606 2607 static void test_proxy_indirect(int port) 2608 { 2609 test_request_t req; 2610 DWORD r, sz; 2611 char buffer[0x40]; 2612 2613 open_simple_request(&req, "localhost", port, NULL, "/test2"); 2614 2615 r = HttpSendRequestA(req.request, NULL, 0, NULL, 0); 2616 ok(r, "HttpSendRequest failed %u\n", GetLastError()); 2617 2618 sz = sizeof buffer; 2619 r = HttpQueryInfoA(req.request, HTTP_QUERY_PROXY_AUTHENTICATE, buffer, &sz, NULL); 2620 ok(r || GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND, "HttpQueryInfo failed: %d\n", GetLastError()); 2621 if (!r) 2622 { 2623 skip("missing proxy header, not testing remaining proxy headers\n"); 2624 goto out; 2625 } 2626 ok(!strcmp(buffer, "Basic realm=\"placebo\""), "proxy auth info wrong\n"); 2627 2628 test_status_code(req.request, 407); 2629 test_request_flags(req.request, 0); 2630 2631 sz = sizeof buffer; 2632 r = HttpQueryInfoA(req.request, HTTP_QUERY_STATUS_TEXT, buffer, &sz, NULL); 2633 ok(r, "HttpQueryInfo failed\n"); 2634 ok(!strcmp(buffer, "Proxy Authentication Required"), "proxy text wrong\n"); 2635 2636 sz = sizeof buffer; 2637 r = HttpQueryInfoA(req.request, HTTP_QUERY_VERSION, buffer, &sz, NULL); 2638 ok(r, "HttpQueryInfo failed\n"); 2639 ok(!strcmp(buffer, "HTTP/1.1"), "http version wrong\n"); 2640 2641 sz = sizeof buffer; 2642 r = HttpQueryInfoA(req.request, HTTP_QUERY_SERVER, buffer, &sz, NULL); 2643 ok(r, "HttpQueryInfo failed\n"); 2644 ok(!strcmp(buffer, "winetest"), "http server wrong\n"); 2645 2646 sz = sizeof buffer; 2647 r = HttpQueryInfoA(req.request, HTTP_QUERY_CONTENT_ENCODING, buffer, &sz, NULL); 2648 ok(GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND, "HttpQueryInfo should fail\n"); 2649 ok(r == FALSE, "HttpQueryInfo failed\n"); 2650 2651 out: 2652 close_request(&req); 2653 } 2654 2655 static void test_proxy_direct(int port) 2656 { 2657 HINTERNET hi, hc, hr; 2658 DWORD r, sz, error; 2659 char buffer[0x40], *url; 2660 WCHAR bufferW[0x40]; 2661 static const char url_fmt[] = "http://test.winehq.org:%u/test2"; 2662 static CHAR username[] = "mike", 2663 password[] = "1101", 2664 useragent[] = "winetest"; 2665 static const WCHAR usernameW[] = {'m','i','k','e',0}, 2666 passwordW[] = {'1','1','0','1',0}, 2667 useragentW[] = {'w','i','n','e','t','e','s','t',0}; 2668 2669 /* specify proxy type without the proxy and bypass */ 2670 SetLastError(0xdeadbeef); 2671 hi = InternetOpenW(NULL, INTERNET_OPEN_TYPE_PROXY, NULL, NULL, 0); 2672 error = GetLastError(); 2673 ok(error == ERROR_INVALID_PARAMETER || 2674 broken(error == ERROR_SUCCESS) /* WinXPProSP2 */, "got %u\n", error); 2675 ok(hi == NULL || broken(!!hi) /* WinXPProSP2 */, "open should have failed\n"); 2676 2677 sprintf(buffer, "localhost:%d\n", port); 2678 hi = InternetOpenA(NULL, INTERNET_OPEN_TYPE_PROXY, buffer, NULL, 0); 2679 ok(hi != NULL, "open failed\n"); 2680 2681 /* try connect without authorization */ 2682 hc = InternetConnectA(hi, "test.winehq.org", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); 2683 ok(hc != NULL, "connect failed\n"); 2684 2685 hr = HttpOpenRequestA(hc, NULL, "/test2", NULL, NULL, NULL, 0, 0); 2686 ok(hr != NULL, "HttpOpenRequest failed\n"); 2687 2688 sz = 0; 2689 SetLastError(0xdeadbeef); 2690 r = InternetQueryOptionA(hr, INTERNET_OPTION_PROXY_PASSWORD, NULL, &sz); 2691 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %u\n", GetLastError()); 2692 ok(!r, "unexpected success\n"); 2693 ok(sz == 1, "got %u\n", sz); 2694 2695 sz = 0; 2696 SetLastError(0xdeadbeef); 2697 r = InternetQueryOptionA(hr, INTERNET_OPTION_PROXY_USERNAME, NULL, &sz); 2698 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %u\n", GetLastError()); 2699 ok(!r, "unexpected success\n"); 2700 ok(sz == 1, "got %u\n", sz); 2701 2702 sz = sizeof(buffer); 2703 SetLastError(0xdeadbeef); 2704 r = InternetQueryOptionA(hr, INTERNET_OPTION_PROXY_PASSWORD, buffer, &sz); 2705 ok(r, "unexpected failure %u\n", GetLastError()); 2706 ok(!sz, "got %u\n", sz); 2707 2708 sz = sizeof(buffer); 2709 SetLastError(0xdeadbeef); 2710 r = InternetQueryOptionA(hr, INTERNET_OPTION_PROXY_USERNAME, buffer, &sz); 2711 ok(r, "unexpected failure %u\n", GetLastError()); 2712 ok(!sz, "got %u\n", sz); 2713 2714 sz = 0; 2715 SetLastError(0xdeadbeef); 2716 r = InternetQueryOptionA(hr, INTERNET_OPTION_PASSWORD, NULL, &sz); 2717 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %u\n", GetLastError()); 2718 ok(!r, "unexpected success\n"); 2719 ok(sz == 1, "got %u\n", sz); 2720 2721 sz = 0; 2722 SetLastError(0xdeadbeef); 2723 r = InternetQueryOptionA(hr, INTERNET_OPTION_USERNAME, NULL, &sz); 2724 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %u\n", GetLastError()); 2725 ok(!r, "unexpected success\n"); 2726 ok(sz == 1, "got %u\n", sz); 2727 2728 sz = sizeof(buffer); 2729 SetLastError(0xdeadbeef); 2730 r = InternetQueryOptionA(hr, INTERNET_OPTION_PASSWORD, buffer, &sz); 2731 ok(r, "unexpected failure %u\n", GetLastError()); 2732 ok(!sz, "got %u\n", sz); 2733 2734 sz = sizeof(buffer); 2735 SetLastError(0xdeadbeef); 2736 r = InternetQueryOptionA(hr, INTERNET_OPTION_USERNAME, buffer, &sz); 2737 ok(r, "unexpected failure %u\n", GetLastError()); 2738 ok(!sz, "got %u\n", sz); 2739 2740 sz = 0; 2741 SetLastError(0xdeadbeef); 2742 r = InternetQueryOptionA(hr, INTERNET_OPTION_URL, NULL, &sz); 2743 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %u\n", GetLastError()); 2744 ok(!r, "unexpected success\n"); 2745 ok(sz == 34, "got %u\n", sz); 2746 2747 sz = sizeof(buffer); 2748 SetLastError(0xdeadbeef); 2749 r = InternetQueryOptionA(hr, INTERNET_OPTION_URL, buffer, &sz); 2750 ok(r, "unexpected failure %u\n", GetLastError()); 2751 ok(sz == 33, "got %u\n", sz); 2752 2753 r = HttpSendRequestW(hr, NULL, 0, NULL, 0); 2754 ok(r || broken(!r), "HttpSendRequest failed %u\n", GetLastError()); 2755 if (!r) 2756 { 2757 win_skip("skipping proxy tests on broken wininet\n"); 2758 goto done; 2759 } 2760 2761 test_status_code(hr, 407); 2762 2763 /* set the user + password then try again */ 2764 r = InternetSetOptionA(hi, INTERNET_OPTION_PROXY_USERNAME, username, 4); 2765 ok(!r, "unexpected success\n"); 2766 2767 r = InternetSetOptionA(hc, INTERNET_OPTION_PROXY_USERNAME, username, 4); 2768 ok(r, "failed to set user\n"); 2769 2770 r = InternetSetOptionA(hr, INTERNET_OPTION_PROXY_USERNAME, username, 4); 2771 ok(r, "failed to set user\n"); 2772 2773 buffer[0] = 0; 2774 sz = 3; 2775 SetLastError(0xdeadbeef); 2776 r = InternetQueryOptionA(hr, INTERNET_OPTION_PROXY_USERNAME, buffer, &sz); 2777 ok(!r, "unexpected failure %u\n", GetLastError()); 2778 ok(!buffer[0], "got %s\n", buffer); 2779 ok(sz == strlen(username) + 1, "got %u\n", sz); 2780 2781 buffer[0] = 0; 2782 sz = 0; 2783 SetLastError(0xdeadbeef); 2784 r = InternetQueryOptionA(hr, INTERNET_OPTION_PROXY_USERNAME, buffer, &sz); 2785 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %u\n", GetLastError()); 2786 ok(!r, "unexpected success\n"); 2787 ok(sz == strlen(username) + 1, "got %u\n", sz); 2788 2789 bufferW[0] = 0; 2790 sz = 0; 2791 SetLastError(0xdeadbeef); 2792 r = InternetQueryOptionW(hr, INTERNET_OPTION_PROXY_USERNAME, bufferW, &sz); 2793 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %u\n", GetLastError()); 2794 ok(!r, "unexpected success\n"); 2795 ok(sz == (lstrlenW(usernameW) + 1) * sizeof(WCHAR), "got %u\n", sz); 2796 2797 buffer[0] = 0; 2798 sz = sizeof(buffer); 2799 r = InternetQueryOptionA(hr, INTERNET_OPTION_PROXY_USERNAME, buffer, &sz); 2800 ok(r, "failed to get username\n"); 2801 ok(!strcmp(buffer, username), "got %s\n", buffer); 2802 ok(sz == strlen(username), "got %u\n", sz); 2803 2804 buffer[0] = 0; 2805 sz = sizeof(bufferW); 2806 r = InternetQueryOptionW(hr, INTERNET_OPTION_PROXY_USERNAME, bufferW, &sz); 2807 ok(r, "failed to get username\n"); 2808 ok(!lstrcmpW(bufferW, usernameW), "wrong username\n"); 2809 ok(sz == lstrlenW(usernameW), "got %u\n", sz); 2810 2811 r = InternetSetOptionA(hr, INTERNET_OPTION_PROXY_USERNAME, username, 1); 2812 ok(r, "failed to set user\n"); 2813 2814 buffer[0] = 0; 2815 sz = sizeof(buffer); 2816 r = InternetQueryOptionA(hr, INTERNET_OPTION_PROXY_USERNAME, buffer, &sz); 2817 ok(r, "failed to get username\n"); 2818 ok(!strcmp(buffer, username), "got %s\n", buffer); 2819 ok(sz == strlen(username), "got %u\n", sz); 2820 2821 r = InternetSetOptionA(hi, INTERNET_OPTION_USER_AGENT, useragent, 1); 2822 ok(r, "failed to set useragent\n"); 2823 2824 buffer[0] = 0; 2825 sz = 0; 2826 SetLastError(0xdeadbeef); 2827 r = InternetQueryOptionA(hi, INTERNET_OPTION_USER_AGENT, buffer, &sz); 2828 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %u\n", GetLastError()); 2829 ok(!r, "unexpected success\n"); 2830 ok(sz == strlen(useragent) + 1, "got %u\n", sz); 2831 2832 buffer[0] = 0; 2833 sz = sizeof(buffer); 2834 r = InternetQueryOptionA(hi, INTERNET_OPTION_USER_AGENT, buffer, &sz); 2835 ok(r, "failed to get user agent\n"); 2836 ok(!strcmp(buffer, useragent), "got %s\n", buffer); 2837 ok(sz == strlen(useragent), "got %u\n", sz); 2838 2839 bufferW[0] = 0; 2840 sz = 0; 2841 SetLastError(0xdeadbeef); 2842 r = InternetQueryOptionW(hi, INTERNET_OPTION_USER_AGENT, bufferW, &sz); 2843 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %u\n", GetLastError()); 2844 ok(!r, "unexpected success\n"); 2845 ok(sz == (lstrlenW(useragentW) + 1) * sizeof(WCHAR), "got %u\n", sz); 2846 2847 bufferW[0] = 0; 2848 sz = sizeof(bufferW); 2849 r = InternetQueryOptionW(hi, INTERNET_OPTION_USER_AGENT, bufferW, &sz); 2850 ok(r, "failed to get user agent\n"); 2851 ok(!lstrcmpW(bufferW, useragentW), "wrong user agent\n"); 2852 ok(sz == lstrlenW(useragentW), "got %u\n", sz); 2853 2854 r = InternetSetOptionA(hr, INTERNET_OPTION_USERNAME, username, 1); 2855 ok(r, "failed to set user\n"); 2856 2857 buffer[0] = 0; 2858 sz = 0; 2859 SetLastError(0xdeadbeef); 2860 r = InternetQueryOptionA(hr, INTERNET_OPTION_USERNAME, buffer, &sz); 2861 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %u\n", GetLastError()); 2862 ok(!r, "unexpected success\n"); 2863 ok(sz == strlen(username) + 1, "got %u\n", sz); 2864 2865 buffer[0] = 0; 2866 sz = sizeof(buffer); 2867 r = InternetQueryOptionA(hr, INTERNET_OPTION_USERNAME, buffer, &sz); 2868 ok(r, "failed to get user\n"); 2869 ok(!strcmp(buffer, username), "got %s\n", buffer); 2870 ok(sz == strlen(username), "got %u\n", sz); 2871 2872 bufferW[0] = 0; 2873 sz = 0; 2874 SetLastError(0xdeadbeef); 2875 r = InternetQueryOptionW(hr, INTERNET_OPTION_USERNAME, bufferW, &sz); 2876 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %u\n", GetLastError()); 2877 ok(!r, "unexpected success\n"); 2878 ok(sz == (lstrlenW(usernameW) + 1) * sizeof(WCHAR), "got %u\n", sz); 2879 2880 bufferW[0] = 0; 2881 sz = sizeof(bufferW); 2882 r = InternetQueryOptionW(hr, INTERNET_OPTION_USERNAME, bufferW, &sz); 2883 ok(r, "failed to get user\n"); 2884 ok(!lstrcmpW(bufferW, usernameW), "wrong user\n"); 2885 ok(sz == lstrlenW(usernameW), "got %u\n", sz); 2886 2887 r = InternetSetOptionA(hr, INTERNET_OPTION_PASSWORD, password, 1); 2888 ok(r, "failed to set password\n"); 2889 2890 buffer[0] = 0; 2891 sz = 0; 2892 SetLastError(0xdeadbeef); 2893 r = InternetQueryOptionA(hr, INTERNET_OPTION_PASSWORD, buffer, &sz); 2894 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %u\n", GetLastError()); 2895 ok(!r, "unexpected success\n"); 2896 ok(sz == strlen(password) + 1, "got %u\n", sz); 2897 2898 buffer[0] = 0; 2899 sz = sizeof(buffer); 2900 r = InternetQueryOptionA(hr, INTERNET_OPTION_PASSWORD, buffer, &sz); 2901 ok(r, "failed to get password\n"); 2902 ok(!strcmp(buffer, password), "got %s\n", buffer); 2903 ok(sz == strlen(password), "got %u\n", sz); 2904 2905 bufferW[0] = 0; 2906 sz = 0; 2907 SetLastError(0xdeadbeef); 2908 r = InternetQueryOptionW(hr, INTERNET_OPTION_PASSWORD, bufferW, &sz); 2909 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %u\n", GetLastError()); 2910 ok(!r, "unexpected success\n"); 2911 ok(sz == (lstrlenW(passwordW) + 1) * sizeof(WCHAR), "got %u\n", sz); 2912 2913 bufferW[0] = 0; 2914 sz = sizeof(bufferW); 2915 r = InternetQueryOptionW(hr, INTERNET_OPTION_PASSWORD, bufferW, &sz); 2916 ok(r, "failed to get password\n"); 2917 ok(!lstrcmpW(bufferW, passwordW), "wrong password\n"); 2918 ok(sz == lstrlenW(passwordW), "got %u\n", sz); 2919 2920 url = HeapAlloc(GetProcessHeap(), 0, strlen(url_fmt) + 11); 2921 sprintf(url, url_fmt, port); 2922 buffer[0] = 0; 2923 sz = 0; 2924 SetLastError(0xdeadbeef); 2925 r = InternetQueryOptionA(hr, INTERNET_OPTION_URL, buffer, &sz); 2926 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %u\n", GetLastError()); 2927 ok(!r, "unexpected success\n"); 2928 ok(sz == strlen(url) + 1, "got %u\n", sz); 2929 2930 buffer[0] = 0; 2931 sz = sizeof(buffer); 2932 r = InternetQueryOptionA(hr, INTERNET_OPTION_URL, buffer, &sz); 2933 ok(r, "failed to get url\n"); 2934 ok(!strcmp(buffer, url), "got %s\n", buffer); 2935 ok(sz == strlen(url), "got %u\n", sz); 2936 2937 bufferW[0] = 0; 2938 sz = 0; 2939 SetLastError(0xdeadbeef); 2940 r = InternetQueryOptionW(hr, INTERNET_OPTION_URL, bufferW, &sz); 2941 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %u\n", GetLastError()); 2942 ok(!r, "unexpected success\n"); 2943 ok(sz == (strlen(url) + 1) * sizeof(WCHAR), "got %u\n", sz); 2944 2945 bufferW[0] = 0; 2946 sz = sizeof(bufferW); 2947 r = InternetQueryOptionW(hr, INTERNET_OPTION_URL, bufferW, &sz); 2948 ok(r, "failed to get url\n"); 2949 ok(!strcmp_wa(bufferW, url), "wrong url\n"); 2950 ok(sz == strlen(url), "got %u\n", sz); 2951 HeapFree(GetProcessHeap(), 0, url); 2952 2953 r = InternetSetOptionA(hr, INTERNET_OPTION_PROXY_PASSWORD, password, 4); 2954 ok(r, "failed to set password\n"); 2955 2956 buffer[0] = 0; 2957 sz = 0; 2958 SetLastError(0xdeadbeef); 2959 r = InternetQueryOptionA(hr, INTERNET_OPTION_PROXY_PASSWORD, buffer, &sz); 2960 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %u\n", GetLastError()); 2961 ok(!r, "unexpected success\n"); 2962 ok(sz == strlen(password) + 1, "got %u\n", sz); 2963 2964 buffer[0] = 0; 2965 sz = sizeof(buffer); 2966 r = InternetQueryOptionA(hr, INTERNET_OPTION_PROXY_PASSWORD, buffer, &sz); 2967 ok(r, "failed to get password\n"); 2968 ok(!strcmp(buffer, password), "got %s\n", buffer); 2969 ok(sz == strlen(password), "got %u\n", sz); 2970 2971 bufferW[0] = 0; 2972 sz = 0; 2973 SetLastError(0xdeadbeef); 2974 r = InternetQueryOptionW(hr, INTERNET_OPTION_PROXY_PASSWORD, bufferW, &sz); 2975 ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %u\n", GetLastError()); 2976 ok(!r, "unexpected success\n"); 2977 ok(sz == (lstrlenW(passwordW) + 1) * sizeof(WCHAR), "got %u\n", sz); 2978 2979 bufferW[0] = 0; 2980 sz = sizeof(bufferW); 2981 r = InternetQueryOptionW(hr, INTERNET_OPTION_PROXY_PASSWORD, bufferW, &sz); 2982 ok(r, "failed to get password\n"); 2983 ok(!lstrcmpW(bufferW, passwordW), "wrong password\n"); 2984 ok(sz == lstrlenW(passwordW), "got %u\n", sz); 2985 2986 r = HttpSendRequestW(hr, NULL, 0, NULL, 0); 2987 if (!r) 2988 { 2989 win_skip("skipping proxy tests on broken wininet\n"); 2990 goto done; 2991 } 2992 ok(r, "HttpSendRequest failed %u\n", GetLastError()); 2993 sz = sizeof buffer; 2994 r = HttpQueryInfoA(hr, HTTP_QUERY_STATUS_CODE, buffer, &sz, NULL); 2995 ok(r, "HttpQueryInfo failed\n"); 2996 ok(!strcmp(buffer, "200"), "proxy code wrong\n"); 2997 2998 InternetCloseHandle(hr); 2999 InternetCloseHandle(hc); 3000 InternetCloseHandle(hi); 3001 3002 sprintf(buffer, "localhost:%d\n", port); 3003 hi = InternetOpenA("winetest", INTERNET_OPEN_TYPE_PROXY, buffer, NULL, 0); 3004 ok(hi != NULL, "InternetOpen failed\n"); 3005 3006 hc = InternetConnectA(hi, "test.winehq.org", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); 3007 ok(hc != NULL, "InternetConnect failed\n"); 3008 3009 hr = HttpOpenRequestA(hc, "POST", "/test2", NULL, NULL, NULL, INTERNET_FLAG_SECURE, 0); 3010 ok(hr != NULL, "HttpOpenRequest failed\n"); 3011 3012 r = HttpSendRequestA(hr, NULL, 0, (char *)"data", sizeof("data")); 3013 ok(r, "HttpSendRequest failed %u\n", GetLastError()); 3014 3015 test_status_code(hr, 407); 3016 3017 done: 3018 InternetCloseHandle(hr); 3019 InternetCloseHandle(hc); 3020 InternetCloseHandle(hi); 3021 } 3022 3023 static void test_header_handling_order(int port) 3024 { 3025 static const char authorization[] = "Authorization: Basic dXNlcjpwd2Q="; 3026 static const char connection[] = "Connection: Close"; 3027 static const char *types[2] = { "*", NULL }; 3028 char data[32]; 3029 HINTERNET session, connect, request; 3030 DWORD size, status, data_len; 3031 BOOL ret; 3032 3033 session = InternetOpenA("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0); 3034 ok(session != NULL, "InternetOpen failed\n"); 3035 3036 connect = InternetConnectA(session, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); 3037 ok(connect != NULL, "InternetConnect failed\n"); 3038 3039 request = HttpOpenRequestA(connect, NULL, "/test3", NULL, NULL, types, INTERNET_FLAG_KEEP_CONNECTION, 0); 3040 ok(request != NULL, "HttpOpenRequest failed\n"); 3041 3042 ret = HttpAddRequestHeadersA(request, authorization, ~0u, HTTP_ADDREQ_FLAG_ADD); 3043 ok(ret, "HttpAddRequestHeaders failed\n"); 3044 3045 ret = HttpSendRequestA(request, NULL, 0, NULL, 0); 3046 ok(ret, "HttpSendRequest failed\n"); 3047 3048 test_status_code(request, 200); 3049 test_request_flags(request, 0); 3050 3051 InternetCloseHandle(request); 3052 3053 request = HttpOpenRequestA(connect, NULL, "/test4", NULL, NULL, types, INTERNET_FLAG_KEEP_CONNECTION, 0); 3054 ok(request != NULL, "HttpOpenRequest failed\n"); 3055 3056 ret = HttpSendRequestA(request, connection, ~0u, NULL, 0); 3057 ok(ret, "HttpSendRequest failed\n"); 3058 3059 status = 0; 3060 size = sizeof(status); 3061 ret = HttpQueryInfoA( request, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL ); 3062 ok(ret, "HttpQueryInfo failed\n"); 3063 ok(status == 200 || status == 400 /* IE6 */, "got status %u, expected 200 or 400\n", status); 3064 3065 InternetCloseHandle(request); 3066 InternetCloseHandle(connect); 3067 3068 connect = InternetConnectA(session, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); 3069 ok(connect != NULL, "InternetConnect failed\n"); 3070 3071 request = HttpOpenRequestA(connect, "POST", "/test7", NULL, NULL, types, INTERNET_FLAG_KEEP_CONNECTION, 0); 3072 ok(request != NULL, "HttpOpenRequest failed\n"); 3073 3074 ret = HttpAddRequestHeadersA(request, "Content-Length: 100\r\n", ~0u, HTTP_ADDREQ_FLAG_ADD_IF_NEW); 3075 ok(ret, "HttpAddRequestHeaders failed\n"); 3076 3077 ret = HttpSendRequestA(request, connection, ~0u, NULL, 0); 3078 ok(ret, "HttpSendRequest failed\n"); 3079 3080 status = 0; 3081 size = sizeof(status); 3082 ret = HttpQueryInfoA( request, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL ); 3083 ok(ret, "HttpQueryInfo failed\n"); 3084 ok(status == 200, "got status %u, expected 200\n", status); 3085 3086 InternetCloseHandle(request); 3087 InternetCloseHandle(connect); 3088 3089 connect = InternetConnectA(session, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); 3090 ok(connect != NULL, "InternetConnect failed\n"); 3091 3092 request = HttpOpenRequestA(connect, "POST", "/test7b", NULL, NULL, types, INTERNET_FLAG_KEEP_CONNECTION, 0); 3093 ok(request != NULL, "HttpOpenRequest failed\n"); 3094 3095 ret = HttpAddRequestHeadersA(request, "Content-Length: 100\r\n", ~0u, HTTP_ADDREQ_FLAG_ADD_IF_NEW); 3096 ok(ret, "HttpAddRequestHeaders failed\n"); 3097 3098 data_len = sizeof(data); 3099 memset(data, 'a', sizeof(data)); 3100 ret = HttpSendRequestA(request, NULL, 0, data, data_len); 3101 ok(ret, "HttpSendRequest failed: %u\n", GetLastError()); 3102 3103 status = 0; 3104 size = sizeof(status); 3105 ret = HttpQueryInfoA( request, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL ); 3106 ok(ret, "HttpQueryInfo failed\n"); 3107 ok(status == 200, "got status %u, expected 200\n", status); 3108 3109 InternetCloseHandle(request); 3110 InternetCloseHandle(connect); 3111 InternetCloseHandle(session); 3112 } 3113 3114 static void test_connection_header(int port) 3115 { 3116 HINTERNET ses, con, req; 3117 BOOL ret; 3118 3119 ses = InternetOpenA("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0); 3120 ok(ses != NULL, "InternetOpen failed\n"); 3121 3122 con = InternetConnectA(ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); 3123 ok(con != NULL, "InternetConnect failed\n"); 3124 3125 req = HttpOpenRequestA(con, NULL, "/test8", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0); 3126 ok(req != NULL, "HttpOpenRequest failed\n"); 3127 3128 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 3129 ok(ret, "HttpSendRequest failed\n"); 3130 3131 test_status_code(req, 200); 3132 3133 InternetCloseHandle(req); 3134 3135 req = HttpOpenRequestA(con, NULL, "/test9", NULL, NULL, NULL, 0, 0); 3136 ok(req != NULL, "HttpOpenRequest failed\n"); 3137 3138 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 3139 ok(ret, "HttpSendRequest failed\n"); 3140 3141 test_status_code(req, 200); 3142 3143 InternetCloseHandle(req); 3144 3145 req = HttpOpenRequestA(con, NULL, "/test9", NULL, NULL, NULL, INTERNET_FLAG_NO_CACHE_WRITE, 0); 3146 ok(req != NULL, "HttpOpenRequest failed\n"); 3147 3148 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 3149 ok(ret, "HttpSendRequest failed\n"); 3150 3151 test_status_code(req, 200); 3152 3153 InternetCloseHandle(req); 3154 3155 req = HttpOpenRequestA(con, "POST", "/testA", NULL, NULL, NULL, INTERNET_FLAG_NO_CACHE_WRITE, 0); 3156 ok(req != NULL, "HttpOpenRequest failed\n"); 3157 3158 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 3159 ok(ret, "HttpSendRequest failed\n"); 3160 3161 test_status_code(req, 200); 3162 3163 InternetCloseHandle(req); 3164 InternetCloseHandle(con); 3165 InternetCloseHandle(ses); 3166 } 3167 3168 static void test_header_override(int port) 3169 { 3170 char buffer[128], host_header_override[30], full_url[128]; 3171 HINTERNET ses, con, req; 3172 DWORD size, count, err; 3173 BOOL ret; 3174 3175 sprintf(host_header_override, "Host: test.local:%d\r\n", port); 3176 sprintf(full_url, "http://localhost:%d/test_host_override", port); 3177 3178 ses = InternetOpenA("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0); 3179 ok(ses != NULL, "InternetOpen failed\n"); 3180 3181 con = InternetConnectA(ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); 3182 ok(con != NULL, "InternetConnect failed\n"); 3183 3184 req = HttpOpenRequestA(con, NULL, "/test_host_override", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0); 3185 ok(req != NULL, "HttpOpenRequest failed\n"); 3186 3187 size = sizeof(buffer) - 1; 3188 count = 0; 3189 memset(buffer, 0, sizeof(buffer)); 3190 ret = HttpQueryInfoA(req, HTTP_QUERY_HOST | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, &count); 3191 err = GetLastError(); 3192 ok(!ret, "HttpQueryInfo succeeded\n"); 3193 ok(err == ERROR_HTTP_HEADER_NOT_FOUND, "Expected error ERROR_HTTP_HEADER_NOT_FOUND, got %d\n", err); 3194 3195 test_request_url(req, full_url); 3196 3197 ret = HttpAddRequestHeadersA(req, host_header_override, ~0u, HTTP_ADDREQ_FLAG_COALESCE); 3198 ok(ret, "HttpAddRequestHeaders failed\n"); 3199 3200 size = sizeof(buffer) - 1; 3201 count = 0; 3202 memset(buffer, 0, sizeof(buffer)); 3203 ret = HttpQueryInfoA(req, HTTP_QUERY_HOST | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, &count); 3204 ok(ret, "HttpQueryInfo failed\n"); 3205 3206 test_request_url(req, full_url); 3207 3208 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 3209 ok(ret, "HttpSendRequest failed\n"); 3210 3211 test_status_code(req, 200); 3212 3213 InternetCloseHandle(req); 3214 req = HttpOpenRequestA(con, NULL, "/test_host_override", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0); 3215 ok(req != NULL, "HttpOpenRequest failed\n"); 3216 3217 ret = HttpAddRequestHeadersA(req, host_header_override, ~0u, HTTP_ADDREQ_FLAG_COALESCE); 3218 ok(ret, "HttpAddRequestHeaders failed\n"); 3219 3220 ret = HttpAddRequestHeadersA(req, host_header_override, ~0u, HTTP_ADDREQ_FLAG_COALESCE); 3221 ok(ret, "HttpAddRequestHeaders failed\n"); 3222 3223 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 3224 ok(ret, "HttpSendRequest failed\n"); 3225 3226 test_status_code(req, 400); 3227 3228 InternetCloseHandle(req); 3229 req = HttpOpenRequestA(con, NULL, "/test_host_override", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0); 3230 ok(req != NULL, "HttpOpenRequest failed\n"); 3231 3232 ret = HttpAddRequestHeadersA(req, host_header_override, ~0u, HTTP_ADDREQ_FLAG_ADD); 3233 ok(ret, "HttpAddRequestHeaders failed\n"); 3234 3235 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 3236 ok(ret, "HttpSendRequest failed\n"); 3237 3238 test_status_code(req, 200); 3239 3240 InternetCloseHandle(req); 3241 req = HttpOpenRequestA(con, NULL, "/test_host_override", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0); 3242 ok(req != NULL, "HttpOpenRequest failed\n"); 3243 3244 ret = HttpAddRequestHeadersA(req, host_header_override, ~0u, HTTP_ADDREQ_FLAG_REPLACE); 3245 if(ret) { /* win10 returns success */ 3246 trace("replacing host header is supported.\n"); 3247 3248 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 3249 ok(ret, "HttpSendRequest failed\n"); 3250 3251 test_status_code(req, 200); 3252 }else { 3253 trace("replacing host header is not supported.\n"); 3254 3255 err = GetLastError(); 3256 ok(err == ERROR_HTTP_HEADER_NOT_FOUND, "Expected error ERROR_HTTP_HEADER_NOT_FOUND, got %d\n", err); 3257 3258 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 3259 ok(ret, "HttpSendRequest failed\n"); 3260 3261 test_status_code(req, 400); 3262 } 3263 3264 InternetCloseHandle(req); 3265 InternetSetCookieA("http://localhost", "cookie", "biscuit"); 3266 req = HttpOpenRequestA(con, NULL, "/testC", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0); 3267 ok(req != NULL, "HttpOpenRequest failed\n"); 3268 3269 ret = HttpAddRequestHeadersA(req, host_header_override, ~0u, HTTP_ADDREQ_FLAG_ADD); 3270 ok(ret, "HttpAddRequestHeaders failed\n"); 3271 3272 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 3273 ok(ret, "HttpSendRequest failed\n"); 3274 3275 test_status_code(req, 200); 3276 3277 InternetCloseHandle(req); 3278 req = HttpOpenRequestA(con, NULL, "/test_cookie_set_host_override", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0); 3279 ok(req != NULL, "HttpOpenRequest failed\n"); 3280 3281 ret = HttpAddRequestHeadersA(req, host_header_override, ~0u, HTTP_ADDREQ_FLAG_ADD); 3282 ok(ret, "HttpAddRequestHeaders failed\n"); 3283 3284 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 3285 ok(ret, "HttpSendRequest failed\n"); 3286 3287 test_status_code(req, 200); 3288 3289 InternetCloseHandle(req); 3290 req = HttpOpenRequestA(con, NULL, "/test_cookie_check_host_override", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0); 3291 ok(req != NULL, "HttpOpenRequest failed\n"); 3292 3293 ret = HttpAddRequestHeadersA(req, host_header_override, ~0u, HTTP_ADDREQ_FLAG_ADD); 3294 ok(ret, "HttpAddRequestHeaders failed\n"); 3295 3296 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 3297 ok(ret, "HttpSendRequest failed\n"); 3298 3299 test_status_code(req, 200); 3300 3301 InternetCloseHandle(req); 3302 req = HttpOpenRequestA(con, NULL, "/test_cookie_check_host_override", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0); 3303 ok(req != NULL, "HttpOpenRequest failed\n"); 3304 3305 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 3306 ok(ret, "HttpSendRequest failed\n"); 3307 3308 test_status_code(req, 200); 3309 3310 InternetCloseHandle(req); 3311 InternetSetCookieA("http://test.local", "foo", "bar"); 3312 req = HttpOpenRequestA(con, NULL, "/test_cookie_check_different_host", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0); 3313 ok(req != NULL, "HttpOpenRequest failed\n"); 3314 3315 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 3316 ok(ret, "HttpSendRequest failed\n"); 3317 3318 test_status_code(req, 200); 3319 3320 InternetCloseHandle(req); 3321 req = HttpOpenRequestA(con, NULL, "/test_cookie_check_different_host", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0); 3322 ok(req != NULL, "HttpOpenRequest failed\n"); 3323 3324 ret = HttpAddRequestHeadersA(req, host_header_override, ~0u, HTTP_ADDREQ_FLAG_ADD); 3325 ok(ret, "HttpAddRequestHeaders failed\n"); 3326 3327 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 3328 ok(ret, "HttpSendRequest failed\n"); 3329 3330 test_status_code(req, 200); 3331 3332 InternetCloseHandle(req); 3333 InternetCloseHandle(con); 3334 InternetCloseHandle(ses); 3335 3336 ses = InternetOpenA("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0); 3337 ok(ses != NULL, "InternetOpenA failed\n"); 3338 3339 con = InternetConnectA(ses, "localhost", port, "test1", "pass", INTERNET_SERVICE_HTTP, 0, 0); 3340 ok(con != NULL, "InternetConnectA failed %u\n", GetLastError()); 3341 3342 req = HttpOpenRequestA( con, "HEAD", "/test_auth_host1", NULL, NULL, NULL, 0, 0); 3343 ok(req != NULL, "HttpOpenRequestA failed %u\n", GetLastError()); 3344 3345 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 3346 ok(ret, "HttpSendRequestA failed %u\n", GetLastError()); 3347 3348 test_status_code(req, 200); 3349 3350 InternetCloseHandle(req); 3351 InternetCloseHandle(con); 3352 InternetCloseHandle(ses); 3353 3354 ses = InternetOpenA("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0); 3355 ok(ses != NULL, "InternetOpenA failed\n"); 3356 3357 con = InternetConnectA( ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); 3358 ok(con != NULL, "InternetConnectA failed %u\n", GetLastError()); 3359 3360 req = HttpOpenRequestA(con, "HEAD", "/test_auth_host1", NULL, NULL, NULL, 0, 0); 3361 ok(req != NULL, "HttpOpenRequestA failed %u\n", GetLastError()); 3362 3363 ret = HttpAddRequestHeadersA(req, host_header_override, ~0u, HTTP_ADDREQ_FLAG_ADD); 3364 ok(ret, "HttpAddRequestHeaders failed\n"); 3365 3366 ret = HttpSendRequestA( req, NULL, 0, NULL, 0 ); 3367 ok( ret, "HttpSendRequestA failed %u\n", GetLastError() ); 3368 3369 test_status_code(req, 200); 3370 3371 InternetCloseHandle(req); 3372 InternetCloseHandle(con); 3373 InternetCloseHandle(ses); 3374 3375 ses = InternetOpenA("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0); 3376 ok(ses != NULL, "InternetOpenA failed\n"); 3377 3378 con = InternetConnectA(ses, "localhost", port, "test1", "pass2", INTERNET_SERVICE_HTTP, 0, 0); 3379 ok(con != NULL, "InternetConnectA failed %u\n", GetLastError()); 3380 3381 req = HttpOpenRequestA(con, "HEAD", "/test_auth_host2", NULL, NULL, NULL, 0, 0); 3382 ok(req != NULL, "HttpOpenRequestA failed %u\n", GetLastError()); 3383 3384 ret = HttpAddRequestHeadersA(req, host_header_override, ~0u, HTTP_ADDREQ_FLAG_ADD); 3385 ok(ret, "HttpAddRequestHeaders failed\n"); 3386 3387 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 3388 ok(ret, "HttpSendRequestA failed %u\n", GetLastError()); 3389 3390 test_status_code(req, 200); 3391 3392 InternetCloseHandle(req); 3393 InternetCloseHandle(con); 3394 InternetCloseHandle(ses); 3395 3396 ses = InternetOpenA("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0); 3397 ok(ses != NULL, "InternetOpenA failed\n"); 3398 3399 con = InternetConnectA(ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); 3400 ok(con != NULL, "InternetConnectA failed %u\n", GetLastError()); 3401 3402 req = HttpOpenRequestA(con, "HEAD", "/test_auth_host2", NULL, NULL, NULL, 0, 0); 3403 ok(req != NULL, "HttpOpenRequestA failed %u\n", GetLastError()); 3404 3405 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 3406 ok(ret, "HttpSendRequestA failed %u\n", GetLastError()); 3407 3408 test_status_code(req, 200); 3409 3410 InternetCloseHandle(req); 3411 InternetCloseHandle(con); 3412 InternetCloseHandle(ses); 3413 } 3414 3415 static void test_connection_closing(int port) 3416 { 3417 HINTERNET session, connection, req; 3418 DWORD res; 3419 3420 reset_events(); 3421 3422 session = InternetOpenA("", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, INTERNET_FLAG_ASYNC); 3423 ok(session != NULL,"InternetOpen failed with error %u\n", GetLastError()); 3424 3425 pInternetSetStatusCallbackA(session, callback); 3426 3427 SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED); 3428 connection = InternetConnectA(session, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0x0, 0xdeadbeef); 3429 ok(connection != NULL,"InternetConnect failed with error %u\n", GetLastError()); 3430 CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED); 3431 3432 SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED); 3433 req = HttpOpenRequestA(connection, "GET", "/testJ", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0xdeadbeaf); 3434 ok(req != NULL, "HttpOpenRequest failed: %u\n", GetLastError()); 3435 CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED); 3436 3437 SET_OPTIONAL(INTERNET_STATUS_COOKIE_SENT); 3438 SET_OPTIONAL(INTERNET_STATUS_DETECTING_PROXY); 3439 SET_EXPECT(INTERNET_STATUS_CONNECTING_TO_SERVER); 3440 SET_EXPECT(INTERNET_STATUS_CONNECTED_TO_SERVER); 3441 SET_EXPECT(INTERNET_STATUS_SENDING_REQUEST); 3442 SET_EXPECT(INTERNET_STATUS_REQUEST_SENT); 3443 SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE); 3444 SET_EXPECT(INTERNET_STATUS_RESPONSE_RECEIVED); 3445 SET_OPTIONAL(INTERNET_STATUS_CLOSING_CONNECTION); 3446 SET_OPTIONAL(INTERNET_STATUS_CONNECTION_CLOSED); 3447 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 3448 3449 res = HttpSendRequestA(req, NULL, 0, NULL, 0); 3450 ok(!res && (GetLastError() == ERROR_IO_PENDING), 3451 "Asynchronous HttpSendRequest NOT returning 0 with error ERROR_IO_PENDING\n"); 3452 WaitForSingleObject(complete_event, INFINITE); 3453 ok(req_error == ERROR_SUCCESS, "req_error = %u\n", req_error); 3454 3455 CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_SENT); 3456 CLEAR_NOTIFIED(INTERNET_STATUS_DETECTING_PROXY); 3457 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTING_TO_SERVER); 3458 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTED_TO_SERVER); 3459 CHECK_NOTIFIED(INTERNET_STATUS_SENDING_REQUEST); 3460 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_SENT); 3461 CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 3462 CHECK_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED); 3463 CLEAR_NOTIFIED(INTERNET_STATUS_CLOSING_CONNECTION); 3464 CLEAR_NOTIFIED(INTERNET_STATUS_CONNECTION_CLOSED); 3465 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 3466 3467 test_status_code(req, 200); 3468 3469 SET_OPTIONAL(INTERNET_STATUS_COOKIE_SENT); 3470 SET_OPTIONAL(INTERNET_STATUS_DETECTING_PROXY); 3471 SET_EXPECT(INTERNET_STATUS_CONNECTING_TO_SERVER); 3472 SET_EXPECT(INTERNET_STATUS_CONNECTED_TO_SERVER); 3473 SET_EXPECT(INTERNET_STATUS_SENDING_REQUEST); 3474 SET_EXPECT(INTERNET_STATUS_REQUEST_SENT); 3475 SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE); 3476 SET_EXPECT(INTERNET_STATUS_RESPONSE_RECEIVED); 3477 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 3478 3479 res = HttpSendRequestA(req, NULL, 0, NULL, 0); 3480 ok(!res && (GetLastError() == ERROR_IO_PENDING), 3481 "Asynchronous HttpSendRequest NOT returning 0 with error ERROR_IO_PENDING\n"); 3482 WaitForSingleObject(complete_event, INFINITE); 3483 ok(req_error == ERROR_SUCCESS, "req_error = %u\n", req_error); 3484 3485 CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_SENT); 3486 CLEAR_NOTIFIED(INTERNET_STATUS_DETECTING_PROXY); 3487 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTING_TO_SERVER); 3488 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTED_TO_SERVER); 3489 CHECK_NOTIFIED(INTERNET_STATUS_SENDING_REQUEST); 3490 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_SENT); 3491 CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 3492 CHECK_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED); 3493 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 3494 3495 test_status_code(req, 210); 3496 3497 SET_OPTIONAL(INTERNET_STATUS_COOKIE_SENT); 3498 SET_OPTIONAL(INTERNET_STATUS_DETECTING_PROXY); 3499 SET_EXPECT(INTERNET_STATUS_CONNECTING_TO_SERVER); 3500 SET_EXPECT(INTERNET_STATUS_CONNECTED_TO_SERVER); 3501 SET_EXPECT(INTERNET_STATUS_SENDING_REQUEST); 3502 SET_EXPECT(INTERNET_STATUS_REQUEST_SENT); 3503 SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE); 3504 SET_EXPECT(INTERNET_STATUS_RESPONSE_RECEIVED); 3505 SET_OPTIONAL(INTERNET_STATUS_CLOSING_CONNECTION); 3506 SET_OPTIONAL(INTERNET_STATUS_CONNECTION_CLOSED); 3507 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 3508 3509 res = HttpSendRequestA(req, NULL, 0, NULL, 0); 3510 ok(!res && (GetLastError() == ERROR_IO_PENDING), 3511 "Asynchronous HttpSendRequest NOT returning 0 with error ERROR_IO_PENDING\n"); 3512 WaitForSingleObject(complete_event, INFINITE); 3513 ok(req_error == ERROR_SUCCESS, "req_error = %u\n", req_error); 3514 3515 CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_SENT); 3516 CLEAR_NOTIFIED(INTERNET_STATUS_DETECTING_PROXY); 3517 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTING_TO_SERVER); 3518 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTED_TO_SERVER); 3519 CHECK_NOTIFIED(INTERNET_STATUS_SENDING_REQUEST); 3520 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_SENT); 3521 CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 3522 CHECK_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED); 3523 CLEAR_NOTIFIED(INTERNET_STATUS_CLOSING_CONNECTION); 3524 CLEAR_NOTIFIED(INTERNET_STATUS_CONNECTION_CLOSED); 3525 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 3526 3527 test_status_code(req, 200); 3528 3529 SET_WINE_ALLOW(INTERNET_STATUS_CLOSING_CONNECTION); 3530 SET_WINE_ALLOW(INTERNET_STATUS_CONNECTION_CLOSED); 3531 3532 close_async_handle(session, 2); 3533 } 3534 3535 static void test_successive_HttpSendRequest(int port) 3536 { 3537 HINTERNET session, connection, req; 3538 DWORD res; 3539 3540 reset_events(); 3541 3542 session = InternetOpenA("", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, INTERNET_FLAG_ASYNC); 3543 ok(session != NULL,"InternetOpen failed with error %u\n", GetLastError()); 3544 3545 pInternetSetStatusCallbackA(session, callback); 3546 3547 SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED); 3548 connection = InternetConnectA(session, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0x0, 0xdeadbeef); 3549 ok(connection != NULL,"InternetConnect failed with error %u\n", GetLastError()); 3550 CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED); 3551 3552 SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED); 3553 req = HttpOpenRequestA(connection, "GET", "/testH", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0xdeadbeaf); 3554 ok(req != NULL, "HttpOpenRequest failed: %u\n", GetLastError()); 3555 CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED); 3556 3557 SET_OPTIONAL(INTERNET_STATUS_COOKIE_SENT); 3558 SET_OPTIONAL(INTERNET_STATUS_DETECTING_PROXY); 3559 SET_EXPECT(INTERNET_STATUS_CONNECTING_TO_SERVER); 3560 SET_EXPECT(INTERNET_STATUS_CONNECTED_TO_SERVER); 3561 SET_EXPECT(INTERNET_STATUS_SENDING_REQUEST); 3562 SET_EXPECT(INTERNET_STATUS_REQUEST_SENT); 3563 SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE); 3564 SET_EXPECT(INTERNET_STATUS_RESPONSE_RECEIVED); 3565 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 3566 3567 res = HttpSendRequestA(req, NULL, 0, NULL, 0); 3568 ok(!res && (GetLastError() == ERROR_IO_PENDING), 3569 "Asynchronous HttpSendRequest NOT returning 0 with error ERROR_IO_PENDING\n"); 3570 WaitForSingleObject(complete_event, INFINITE); 3571 ok(req_error == ERROR_SUCCESS, "req_error = %u\n", req_error); 3572 3573 CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_SENT); 3574 CLEAR_NOTIFIED(INTERNET_STATUS_DETECTING_PROXY); 3575 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTING_TO_SERVER); 3576 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTED_TO_SERVER); 3577 CHECK_NOTIFIED(INTERNET_STATUS_SENDING_REQUEST); 3578 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_SENT); 3579 CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 3580 CHECK_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED); 3581 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 3582 3583 test_status_code(req, 210); 3584 3585 SET_OPTIONAL(INTERNET_STATUS_COOKIE_SENT); 3586 SET_OPTIONAL(INTERNET_STATUS_DETECTING_PROXY); 3587 SET_EXPECT(INTERNET_STATUS_SENDING_REQUEST); 3588 SET_EXPECT(INTERNET_STATUS_REQUEST_SENT); 3589 SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE); 3590 SET_EXPECT(INTERNET_STATUS_RESPONSE_RECEIVED); 3591 SET_OPTIONAL(INTERNET_STATUS_CLOSING_CONNECTION); 3592 SET_OPTIONAL(INTERNET_STATUS_CONNECTION_CLOSED); 3593 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 3594 3595 res = HttpSendRequestA(req, NULL, 0, NULL, 0); 3596 ok(!res && (GetLastError() == ERROR_IO_PENDING), 3597 "Asynchronous HttpSendRequest NOT returning 0 with error ERROR_IO_PENDING\n"); 3598 WaitForSingleObject(complete_event, INFINITE); 3599 ok(req_error == ERROR_SUCCESS, "req_error = %u\n", req_error); 3600 3601 CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_SENT); 3602 CLEAR_NOTIFIED(INTERNET_STATUS_DETECTING_PROXY); 3603 CHECK_NOTIFIED(INTERNET_STATUS_SENDING_REQUEST); 3604 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_SENT); 3605 CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 3606 CHECK_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED); 3607 CLEAR_NOTIFIED(INTERNET_STATUS_CLOSING_CONNECTION); 3608 CLEAR_NOTIFIED(INTERNET_STATUS_CONNECTION_CLOSED); 3609 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 3610 3611 test_status_code(req, 200); 3612 3613 SET_WINE_ALLOW(INTERNET_STATUS_CLOSING_CONNECTION); 3614 SET_WINE_ALLOW(INTERNET_STATUS_CONNECTION_CLOSED); 3615 3616 close_async_handle(session, 2); 3617 } 3618 3619 static void test_no_content(int port) 3620 { 3621 HINTERNET session, connection, req; 3622 DWORD res; 3623 3624 trace("Testing 204 no content response...\n"); 3625 3626 reset_events(); 3627 3628 session = InternetOpenA("", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, INTERNET_FLAG_ASYNC); 3629 ok(session != NULL,"InternetOpen failed with error %u\n", GetLastError()); 3630 3631 pInternetSetStatusCallbackA(session, callback); 3632 3633 SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED); 3634 connection = InternetConnectA(session, "localhost", port, 3635 NULL, NULL, INTERNET_SERVICE_HTTP, 0x0, 0xdeadbeef); 3636 ok(connection != NULL,"InternetConnect failed with error %u\n", GetLastError()); 3637 CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED); 3638 3639 SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED); 3640 req = HttpOpenRequestA(connection, "GET", "/test_no_content", NULL, NULL, NULL, 3641 INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_RESYNCHRONIZE, 0xdeadbead); 3642 ok(req != NULL, "HttpOpenRequest failed: %u\n", GetLastError()); 3643 CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED); 3644 3645 SET_OPTIONAL(INTERNET_STATUS_COOKIE_SENT); 3646 SET_EXPECT(INTERNET_STATUS_CONNECTING_TO_SERVER); 3647 SET_EXPECT(INTERNET_STATUS_CONNECTED_TO_SERVER); 3648 SET_EXPECT(INTERNET_STATUS_SENDING_REQUEST); 3649 SET_EXPECT(INTERNET_STATUS_REQUEST_SENT); 3650 SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE); 3651 SET_EXPECT(INTERNET_STATUS_RESPONSE_RECEIVED); 3652 SET_EXPECT(INTERNET_STATUS_CLOSING_CONNECTION); 3653 SET_EXPECT(INTERNET_STATUS_CONNECTION_CLOSED); 3654 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 3655 3656 res = HttpSendRequestA(req, NULL, -1, NULL, 0); 3657 ok(!res && (GetLastError() == ERROR_IO_PENDING), 3658 "Asynchronous HttpSendRequest NOT returning 0 with error ERROR_IO_PENDING\n"); 3659 WaitForSingleObject(complete_event, INFINITE); 3660 ok(req_error == ERROR_SUCCESS, "req_error = %u\n", req_error); 3661 3662 CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_SENT); 3663 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTING_TO_SERVER); 3664 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTED_TO_SERVER); 3665 CHECK_NOTIFIED(INTERNET_STATUS_SENDING_REQUEST); 3666 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_SENT); 3667 CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 3668 CHECK_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED); 3669 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 3670 3671 close_async_handle(session, 2); 3672 3673 /* 3674 * The connection should be closed before closing handle. This is true for most 3675 * wininet versions (including Wine), but some old win2k versions fail to do that. 3676 */ 3677 CHECK_NOTIFIED(INTERNET_STATUS_CLOSING_CONNECTION); 3678 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTION_CLOSED); 3679 } 3680 3681 static void test_conn_close(int port) 3682 { 3683 HINTERNET session, connection, req; 3684 DWORD res, avail, size; 3685 BYTE buf[1024]; 3686 3687 trace("Testing connection close connection...\n"); 3688 3689 reset_events(); 3690 3691 session = InternetOpenA("", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, INTERNET_FLAG_ASYNC); 3692 ok(session != NULL,"InternetOpen failed with error %u\n", GetLastError()); 3693 3694 pInternetSetStatusCallbackA(session, callback); 3695 3696 SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED); 3697 connection = InternetConnectA(session, "localhost", port, 3698 NULL, NULL, INTERNET_SERVICE_HTTP, 0x0, 0xdeadbeef); 3699 ok(connection != NULL,"InternetConnect failed with error %u\n", GetLastError()); 3700 CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED); 3701 3702 SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED); 3703 req = HttpOpenRequestA(connection, "GET", "/test_conn_close", NULL, NULL, NULL, 3704 INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_RESYNCHRONIZE, 0xdeadbead); 3705 ok(req != NULL, "HttpOpenRequest failed: %u\n", GetLastError()); 3706 CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED); 3707 3708 SET_OPTIONAL(INTERNET_STATUS_COOKIE_SENT); 3709 SET_EXPECT(INTERNET_STATUS_CONNECTING_TO_SERVER); 3710 SET_EXPECT(INTERNET_STATUS_CONNECTED_TO_SERVER); 3711 SET_EXPECT(INTERNET_STATUS_SENDING_REQUEST); 3712 SET_EXPECT(INTERNET_STATUS_REQUEST_SENT); 3713 SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE); 3714 SET_EXPECT(INTERNET_STATUS_RESPONSE_RECEIVED); 3715 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 3716 3717 res = HttpSendRequestA(req, NULL, -1, NULL, 0); 3718 ok(!res && (GetLastError() == ERROR_IO_PENDING), 3719 "Asynchronous HttpSendRequest NOT returning 0 with error ERROR_IO_PENDING\n"); 3720 WaitForSingleObject(complete_event, INFINITE); 3721 ok(req_error == ERROR_SUCCESS, "req_error = %u\n", req_error); 3722 3723 CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_SENT); 3724 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTING_TO_SERVER); 3725 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTED_TO_SERVER); 3726 CHECK_NOTIFIED(INTERNET_STATUS_SENDING_REQUEST); 3727 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_SENT); 3728 CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 3729 CHECK_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED); 3730 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 3731 3732 avail = 0; 3733 res = InternetQueryDataAvailable(req, &avail, 0, 0); 3734 ok(res, "InternetQueryDataAvailable failed: %u\n", GetLastError()); 3735 ok(avail != 0, "avail = 0\n"); 3736 3737 size = 0; 3738 res = InternetReadFile(req, buf, avail, &size); 3739 ok(res, "InternetReadFile failed: %u\n", GetLastError()); 3740 3741 /* IE11 calls those in InternetQueryDataAvailable call. */ 3742 SET_OPTIONAL(INTERNET_STATUS_RECEIVING_RESPONSE); 3743 SET_OPTIONAL(INTERNET_STATUS_RESPONSE_RECEIVED); 3744 3745 res = InternetQueryDataAvailable(req, &avail, 0, 0); 3746 ok(!res && (GetLastError() == ERROR_IO_PENDING), 3747 "Asynchronous HttpSendRequest NOT returning 0 with error ERROR_IO_PENDING\n"); 3748 ok(!avail, "avail = %u, expected 0\n", avail); 3749 3750 CLEAR_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 3751 3752 SET_EXPECT(INTERNET_STATUS_CLOSING_CONNECTION); 3753 SET_EXPECT(INTERNET_STATUS_CONNECTION_CLOSED); 3754 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 3755 SetEvent(conn_close_event); 3756 WaitForSingleObject(complete_event, INFINITE); 3757 ok(req_error == ERROR_SUCCESS, "req_error = %u\n", req_error); 3758 CLEAR_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED); 3759 CHECK_NOTIFIED(INTERNET_STATUS_CLOSING_CONNECTION); 3760 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTION_CLOSED); 3761 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 3762 3763 close_async_handle(session, 2); 3764 } 3765 3766 static void test_no_cache(int port) 3767 { 3768 static const char cache_control_no_cache[] = "/test_cache_control_no_cache"; 3769 static const char cache_control_no_store[] = "/test_cache_control_no_store"; 3770 static const char cache_url_fmt[] = "http://localhost:%d%s"; 3771 3772 char cache_url[256], buf[256]; 3773 HINTERNET ses, con, req; 3774 DWORD read, size; 3775 BOOL ret; 3776 3777 trace("Testing no-cache header\n"); 3778 3779 ses = InternetOpenA("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0); 3780 ok(ses != NULL,"InternetOpen failed with error %u\n", GetLastError()); 3781 3782 con = InternetConnectA(ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); 3783 ok(con != NULL, "InternetConnect failed with error %u\n", GetLastError()); 3784 3785 req = HttpOpenRequestA(con, NULL, cache_control_no_cache, NULL, NULL, NULL, 0, 0); 3786 ok(req != NULL, "HttpOpenRequest failed\n"); 3787 3788 sprintf(cache_url, cache_url_fmt, port, cache_control_no_cache); 3789 DeleteUrlCacheEntryA(cache_url); 3790 3791 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 3792 ok(ret, "HttpSendRequest failed with error %u\n", GetLastError()); 3793 size = 0; 3794 while(InternetReadFile(req, buf, sizeof(buf), &read) && read) 3795 size += read; 3796 ok(size == 12, "read %d bytes of data\n", size); 3797 InternetCloseHandle(req); 3798 3799 req = HttpOpenRequestA(con, NULL, cache_control_no_cache, NULL, NULL, NULL, 0, 0); 3800 ok(req != NULL, "HttpOpenRequest failed\n"); 3801 3802 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 3803 ok(ret, "HttpSendRequest failed with error %u\n", GetLastError()); 3804 size = 0; 3805 while(InternetReadFile(req, buf, sizeof(buf), &read) && read) 3806 size += read; 3807 ok(size == 0, "read %d bytes of data\n", size); 3808 InternetCloseHandle(req); 3809 DeleteUrlCacheEntryA(cache_url); 3810 3811 req = HttpOpenRequestA(con, NULL, cache_control_no_store, NULL, NULL, NULL, 0, 0); 3812 ok(req != NULL, "HttpOpenRequest failed\n"); 3813 3814 sprintf(cache_url, cache_url_fmt, port, cache_control_no_store); 3815 DeleteUrlCacheEntryA(cache_url); 3816 3817 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 3818 ok(ret, "HttpSendRequest failed with error %u\n", GetLastError()); 3819 size = 0; 3820 while(InternetReadFile(req, buf, sizeof(buf), &read) && read) 3821 size += read; 3822 ok(size == 12, "read %d bytes of data\n", size); 3823 InternetCloseHandle(req); 3824 3825 ret = DeleteUrlCacheEntryA(cache_url); 3826 ok(!ret && GetLastError()==ERROR_FILE_NOT_FOUND, "cache entry should not exist\n"); 3827 3828 InternetCloseHandle(con); 3829 InternetCloseHandle(ses); 3830 } 3831 3832 static void test_cache_read_gzipped(int port) 3833 { 3834 static const char cache_url_fmt[] = "http://localhost:%d%s"; 3835 static const char get_gzip[] = "/test_cache_gzip"; 3836 static const char content[] = "gzip test\n"; 3837 static const char text_html[] = "text/html"; 3838 static const char raw_header[] = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n"; 3839 3840 HINTERNET ses, con, req; 3841 DWORD read, size; 3842 char cache_url[256], buf[256]; 3843 BOOL ret; 3844 3845 trace("Testing reading compressed content from cache\n"); 3846 3847 ses = InternetOpenA("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0); 3848 ok(ses != NULL,"InternetOpen failed with error %u\n", GetLastError()); 3849 3850 con = InternetConnectA(ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); 3851 ok(con != NULL, "InternetConnect failed with error %u\n", GetLastError()); 3852 3853 req = HttpOpenRequestA(con, NULL, get_gzip, NULL, NULL, NULL, 0, 0); 3854 ok(req != NULL, "HttpOpenRequest failed\n"); 3855 3856 ret = TRUE; 3857 ret = InternetSetOptionA(req, INTERNET_OPTION_HTTP_DECODING, &ret, sizeof(ret)); 3858 if(!ret && GetLastError()==ERROR_INTERNET_INVALID_OPTION) { 3859 win_skip("INTERNET_OPTION_HTTP_DECODING not supported\n"); 3860 InternetCloseHandle(req); 3861 InternetCloseHandle(con); 3862 InternetCloseHandle(ses); 3863 return; 3864 } 3865 ok(ret, "InternetSetOption(INTERNET_OPTION_HTTP_DECODING) failed: %d\n", GetLastError()); 3866 3867 ret = HttpSendRequestA(req, "Accept-Encoding: gzip", -1, NULL, 0); 3868 ok(ret, "HttpSendRequest failed with error %u\n", GetLastError()); 3869 size = 0; 3870 while(InternetReadFile(req, buf+size, sizeof(buf)-size, &read) && read) 3871 size += read; 3872 ok(size == 10, "read %d bytes of data\n", size); 3873 buf[size] = 0; 3874 ok(!strncmp(buf, content, size), "incorrect page content: %s\n", buf); 3875 3876 size = sizeof(buf)-1; 3877 ret = HttpQueryInfoA(req, HTTP_QUERY_CONTENT_TYPE, buf, &size, 0); 3878 ok(ret, "HttpQueryInfo(HTTP_QUERY_CONTENT_TYPE) failed: %d\n", GetLastError()); 3879 buf[size] = 0; 3880 ok(!strncmp(text_html, buf, size), "buf = %s\n", buf); 3881 3882 size = sizeof(buf)-1; 3883 ret = HttpQueryInfoA(req, HTTP_QUERY_RAW_HEADERS_CRLF, buf, &size, 0); 3884 ok(ret, "HttpQueryInfo(HTTP_QUERY_CONTENT_TYPE) failed: %d\n", GetLastError()); 3885 buf[size] = 0; 3886 ok(!strncmp(raw_header, buf, size), "buf = %s\n", buf); 3887 InternetCloseHandle(req); 3888 3889 req = HttpOpenRequestA(con, NULL, get_gzip, NULL, NULL, NULL, INTERNET_FLAG_FROM_CACHE, 0); 3890 ok(req != NULL, "HttpOpenRequest failed\n"); 3891 3892 ret = TRUE; 3893 ret = InternetSetOptionA(req, INTERNET_OPTION_HTTP_DECODING, &ret, sizeof(ret)); 3894 ok(ret, "InternetSetOption(INTERNET_OPTION_HTTP_DECODING) failed: %d\n", GetLastError()); 3895 3896 ret = HttpSendRequestA(req, "Accept-Encoding: gzip", -1, NULL, 0); 3897 ok(ret, "HttpSendRequest failed with error %u\n", GetLastError()); 3898 size = 0; 3899 while(InternetReadFile(req, buf+size, sizeof(buf)-1-size, &read) && read) 3900 size += read; 3901 todo_wine ok(size == 10, "read %d bytes of data\n", size); 3902 buf[size] = 0; 3903 ok(!strncmp(buf, content, size), "incorrect page content: %s\n", buf); 3904 3905 size = sizeof(buf); 3906 ret = HttpQueryInfoA(req, HTTP_QUERY_CONTENT_ENCODING, buf, &size, 0); 3907 ok(!ret && GetLastError()==ERROR_HTTP_HEADER_NOT_FOUND, 3908 "HttpQueryInfo(HTTP_QUERY_CONTENT_ENCODING) returned %d, %d\n", 3909 ret, GetLastError()); 3910 3911 size = sizeof(buf)-1; 3912 ret = HttpQueryInfoA(req, HTTP_QUERY_CONTENT_TYPE, buf, &size, 0); 3913 todo_wine ok(ret, "HttpQueryInfo(HTTP_QUERY_CONTENT_TYPE) failed: %d\n", GetLastError()); 3914 buf[size] = 0; 3915 todo_wine ok(!strncmp(text_html, buf, size), "buf = %s\n", buf); 3916 InternetCloseHandle(req); 3917 3918 /* Decompression doesn't work while reading from cache */ 3919 test_cache_gzip = 0; 3920 sprintf(cache_url, cache_url_fmt, port, get_gzip); 3921 DeleteUrlCacheEntryA(cache_url); 3922 3923 req = HttpOpenRequestA(con, NULL, get_gzip, NULL, NULL, NULL, 0, 0); 3924 ok(req != NULL, "HttpOpenRequest failed\n"); 3925 3926 ret = HttpSendRequestA(req, "Accept-Encoding: gzip", -1, NULL, 0); 3927 ok(ret, "HttpSendRequest failed with error %u\n", GetLastError()); 3928 size = 0; 3929 while(InternetReadFile(req, buf+size, sizeof(buf)-1-size, &read) && read) 3930 size += read; 3931 ok(size == 31, "read %d bytes of data\n", size); 3932 InternetCloseHandle(req); 3933 3934 req = HttpOpenRequestA(con, NULL, get_gzip, NULL, NULL, NULL, INTERNET_FLAG_FROM_CACHE, 0); 3935 ok(req != NULL, "HttpOpenRequest failed\n"); 3936 3937 ret = TRUE; 3938 ret = InternetSetOptionA(req, INTERNET_OPTION_HTTP_DECODING, &ret, sizeof(ret)); 3939 ok(ret, "InternetSetOption(INTERNET_OPTION_HTTP_DECODING) failed: %d\n", GetLastError()); 3940 3941 ret = HttpSendRequestA(req, "Accept-Encoding: gzip", -1, NULL, 0); 3942 ok(ret, "HttpSendRequest failed with error %u\n", GetLastError()); 3943 size = 0; 3944 while(InternetReadFile(req, buf+size, sizeof(buf)-1-size, &read) && read) 3945 size += read; 3946 todo_wine ok(size == 31, "read %d bytes of data\n", size); 3947 3948 size = sizeof(buf); 3949 ret = HttpQueryInfoA(req, HTTP_QUERY_CONTENT_ENCODING, buf, &size, 0); 3950 todo_wine ok(ret, "HttpQueryInfo(HTTP_QUERY_CONTENT_ENCODING) failed: %d\n", GetLastError()); 3951 InternetCloseHandle(req); 3952 3953 InternetCloseHandle(con); 3954 InternetCloseHandle(ses); 3955 3956 /* Decompression doesn't work while reading from cache */ 3957 test_cache_gzip = 0; 3958 sprintf(cache_url, cache_url_fmt, port, get_gzip); 3959 DeleteUrlCacheEntryA(cache_url); 3960 3961 ses = InternetOpenA("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0); 3962 ok(ses != NULL,"InternetOpen failed with error %u\n", GetLastError()); 3963 3964 ret = TRUE; 3965 ret = InternetSetOptionA(ses, INTERNET_OPTION_HTTP_DECODING, &ret, sizeof(ret)); 3966 ok(ret, "InternetSetOption(INTERNET_OPTION_HTTP_DECODING) failed: %d\n", GetLastError()); 3967 3968 con = InternetConnectA(ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); 3969 ok(con != NULL, "InternetConnect failed with error %u\n", GetLastError()); 3970 3971 req = HttpOpenRequestA(con, NULL, get_gzip, NULL, NULL, NULL, 0, 0); 3972 ok(req != NULL, "HttpOpenRequest failed\n"); 3973 3974 ret = HttpSendRequestA(req, "Accept-Encoding: gzip", -1, NULL, 0); 3975 ok(ret, "HttpSendRequest failed with error %u\n", GetLastError()); 3976 size = 0; 3977 while(InternetReadFile(req, buf+size, sizeof(buf)-1-size, &read) && read) 3978 size += read; 3979 ok(size == 10, "read %d bytes of data\n", size); 3980 buf[size] = 0; 3981 ok(!strncmp(buf, content, size), "incorrect page content: %s\n", buf); 3982 InternetCloseHandle(req); 3983 3984 InternetCloseHandle(con); 3985 InternetCloseHandle(ses); 3986 3987 /* Decompression doesn't work while reading from cache */ 3988 test_cache_gzip = 0; 3989 sprintf(cache_url, cache_url_fmt, port, get_gzip); 3990 DeleteUrlCacheEntryA(cache_url); 3991 3992 ses = InternetOpenA("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0); 3993 ok(ses != NULL,"InternetOpen failed with error %u\n", GetLastError()); 3994 3995 con = InternetConnectA(ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); 3996 ok(con != NULL, "InternetConnect failed with error %u\n", GetLastError()); 3997 3998 ret = TRUE; 3999 ret = InternetSetOptionA(con, INTERNET_OPTION_HTTP_DECODING, &ret, sizeof(ret)); 4000 ok(ret, "InternetSetOption(INTERNET_OPTION_HTTP_DECODING) failed: %d\n", GetLastError()); 4001 4002 req = HttpOpenRequestA(con, NULL, get_gzip, NULL, NULL, NULL, 0, 0); 4003 ok(req != NULL, "HttpOpenRequest failed\n"); 4004 4005 ret = HttpSendRequestA(req, "Accept-Encoding: gzip", -1, NULL, 0); 4006 ok(ret, "HttpSendRequest failed with error %u\n", GetLastError()); 4007 size = 0; 4008 while(InternetReadFile(req, buf+size, sizeof(buf)-1-size, &read) && read) 4009 size += read; 4010 ok(size == 10, "read %d bytes of data\n", size); 4011 buf[size] = 0; 4012 ok(!strncmp(buf, content, size), "incorrect page content: %s\n", buf); 4013 InternetCloseHandle(req); 4014 4015 InternetCloseHandle(con); 4016 InternetCloseHandle(ses); 4017 4018 DeleteUrlCacheEntryA(cache_url); 4019 } 4020 4021 static void test_HttpSendRequestW(int port) 4022 { 4023 static const WCHAR header[] = {'U','A','-','C','P','U',':',' ','x','8','6',0}; 4024 HINTERNET ses, con, req; 4025 DWORD error; 4026 BOOL ret; 4027 4028 ses = InternetOpenA("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, INTERNET_FLAG_ASYNC); 4029 ok(ses != NULL, "InternetOpen failed\n"); 4030 4031 con = InternetConnectA(ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); 4032 ok(con != NULL, "InternetConnect failed\n"); 4033 4034 req = HttpOpenRequestA(con, NULL, "/test1", NULL, NULL, NULL, 0, 0); 4035 ok(req != NULL, "HttpOpenRequest failed\n"); 4036 4037 SetLastError(0xdeadbeef); 4038 ret = HttpSendRequestW(req, header, ~0u, NULL, 0); 4039 error = GetLastError(); 4040 ok(!ret, "HttpSendRequestW succeeded\n"); 4041 ok(error == ERROR_IO_PENDING || 4042 broken(error == ERROR_HTTP_HEADER_NOT_FOUND) || /* IE6 */ 4043 broken(error == ERROR_INVALID_PARAMETER), /* IE5 */ 4044 "got %u expected ERROR_IO_PENDING\n", error); 4045 4046 InternetCloseHandle(req); 4047 InternetCloseHandle(con); 4048 InternetCloseHandle(ses); 4049 } 4050 4051 static void test_cookie_header(int port) 4052 { 4053 HINTERNET ses, con, req; 4054 DWORD size, error; 4055 BOOL ret; 4056 char buffer[256]; 4057 4058 ses = InternetOpenA("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0); 4059 ok(ses != NULL, "InternetOpen failed\n"); 4060 4061 con = InternetConnectA(ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); 4062 ok(con != NULL, "InternetConnect failed\n"); 4063 4064 InternetSetCookieA("http://localhost", "cookie", "biscuit"); 4065 4066 req = HttpOpenRequestA(con, NULL, "/testC", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0); 4067 ok(req != NULL, "HttpOpenRequest failed\n"); 4068 4069 buffer[0] = 0; 4070 size = sizeof(buffer); 4071 SetLastError(0xdeadbeef); 4072 ret = HttpQueryInfoA(req, HTTP_QUERY_COOKIE | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, NULL); 4073 error = GetLastError(); 4074 ok(!ret, "HttpQueryInfo succeeded\n"); 4075 ok(error == ERROR_HTTP_HEADER_NOT_FOUND, "got %u expected ERROR_HTTP_HEADER_NOT_FOUND\n", error); 4076 4077 ret = HttpAddRequestHeadersA(req, "Cookie: cookie=not biscuit\r\n", ~0u, HTTP_ADDREQ_FLAG_ADD); 4078 ok(ret, "HttpAddRequestHeaders failed: %u\n", GetLastError()); 4079 4080 buffer[0] = 0; 4081 size = sizeof(buffer); 4082 ret = HttpQueryInfoA(req, HTTP_QUERY_COOKIE | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, NULL); 4083 ok(ret, "HttpQueryInfo failed: %u\n", GetLastError()); 4084 ok(!!strstr(buffer, "cookie=not biscuit"), "got '%s' expected \'cookie=not biscuit\'\n", buffer); 4085 4086 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 4087 ok(ret, "HttpSendRequest failed: %u\n", GetLastError()); 4088 4089 test_status_code(req, 200); 4090 4091 buffer[0] = 0; 4092 size = sizeof(buffer); 4093 ret = HttpQueryInfoA(req, HTTP_QUERY_COOKIE | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, NULL); 4094 ok(ret, "HttpQueryInfo failed: %u\n", GetLastError()); 4095 ok(!strstr(buffer, "cookie=not biscuit"), "'%s' should not contain \'cookie=not biscuit\'\n", buffer); 4096 ok(!!strstr(buffer, "cookie=biscuit"), "'%s' should contain \'cookie=biscuit\'\n", buffer); 4097 4098 InternetCloseHandle(req); 4099 4100 InternetSetCookieA("http://localhost/testCCCC", "subcookie", "data"); 4101 4102 req = HttpOpenRequestA(con, NULL, "/test_cookie_path1", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0); 4103 ok(req != NULL, "HttpOpenRequest failed\n"); 4104 4105 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 4106 ok(ret, "HttpSendRequest failed\n"); 4107 4108 test_status_code(req, 200); 4109 InternetCloseHandle(req); 4110 4111 req = HttpOpenRequestA(con, NULL, "/test_cookie_path1/abc", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0); 4112 ok(req != NULL, "HttpOpenRequest failed\n"); 4113 4114 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 4115 ok(ret, "HttpSendRequest failed\n"); 4116 4117 test_status_code(req, 200); 4118 InternetCloseHandle(req); 4119 4120 req = HttpOpenRequestA(con, NULL, "/test_cookie_set_path", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0); 4121 ok(req != NULL, "HttpOpenRequest failed\n"); 4122 4123 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 4124 ok(ret, "HttpSendRequest failed\n"); 4125 4126 test_status_code(req, 200); 4127 InternetCloseHandle(req); 4128 4129 req = HttpOpenRequestA(con, NULL, "/test_cookie_path2", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0); 4130 ok(req != NULL, "HttpOpenRequest failed\n"); 4131 4132 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 4133 ok(ret, "HttpSendRequest failed\n"); 4134 4135 test_status_code(req, 400); 4136 InternetCloseHandle(req); 4137 4138 req = HttpOpenRequestA(con, NULL, "/test_cookie_merge", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0); 4139 ok(req != NULL, "HttpOpenRequest failed\n"); 4140 4141 ret = HttpAddRequestHeadersA(req, "Cookie: manual_cookie=test\r\n", ~0u, HTTP_ADDREQ_FLAG_ADD); 4142 ok(ret, "HttpAddRequestHeaders failed: %u\n", GetLastError()); 4143 4144 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 4145 ok(ret, "HttpSendRequest failed\n"); 4146 4147 test_status_code(req, 200); 4148 InternetCloseHandle(req); 4149 4150 InternetCloseHandle(con); 4151 InternetCloseHandle(ses); 4152 } 4153 4154 static void test_basic_authentication(int port) 4155 { 4156 HINTERNET session, connect, request; 4157 BOOL ret; 4158 4159 session = InternetOpenA("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0); 4160 ok(session != NULL, "InternetOpen failed\n"); 4161 4162 connect = InternetConnectA(session, "localhost", port, "user", "pwd", INTERNET_SERVICE_HTTP, 0, 0); 4163 ok(connect != NULL, "InternetConnect failed\n"); 4164 4165 request = HttpOpenRequestA(connect, NULL, "/test3", NULL, NULL, NULL, 0, 0); 4166 ok(request != NULL, "HttpOpenRequest failed\n"); 4167 4168 ret = HttpSendRequestA(request, NULL, 0, NULL, 0); 4169 ok(ret, "HttpSendRequest failed %u\n", GetLastError()); 4170 4171 test_status_code(request, 200); 4172 test_request_flags(request, 0); 4173 4174 InternetCloseHandle(request); 4175 InternetCloseHandle(connect); 4176 InternetCloseHandle(session); 4177 } 4178 4179 static void test_premature_disconnect(int port) 4180 { 4181 test_request_t req; 4182 DWORD err; 4183 BOOL ret; 4184 4185 open_simple_request(&req, "localhost", port, NULL, "/premature_disconnect"); 4186 4187 SetLastError(0xdeadbeef); 4188 ret = HttpSendRequestA(req.request, NULL, 0, NULL, 0); 4189 err = GetLastError(); 4190 todo_wine ok(!ret, "HttpSendRequest succeeded\n"); 4191 todo_wine ok(err == ERROR_HTTP_INVALID_SERVER_RESPONSE, "got %u\n", err); 4192 4193 close_request(&req); 4194 } 4195 4196 static void test_invalid_response_headers(int port) 4197 { 4198 test_request_t req; 4199 DWORD size; 4200 BOOL ret; 4201 char buffer[256]; 4202 4203 open_simple_request(&req, "localhost", port, NULL, "/testE"); 4204 4205 ret = HttpSendRequestA(req.request, NULL, 0, NULL, 0); 4206 ok(ret, "HttpSendRequest failed %u\n", GetLastError()); 4207 4208 test_status_code(req.request, 401); 4209 test_request_flags(req.request, 0); 4210 4211 buffer[0] = 0; 4212 size = sizeof(buffer); 4213 ret = HttpQueryInfoA(req.request, HTTP_QUERY_RAW_HEADERS, buffer, &size, NULL); 4214 ok(ret, "HttpQueryInfo failed\n"); 4215 ok(!strcmp(buffer, "HTTP/1.0 401 Anonymous requests or requests on unsecure channel are not allowed"), 4216 "headers wrong \"%s\"\n", buffer); 4217 4218 buffer[0] = 0; 4219 size = sizeof(buffer); 4220 ret = HttpQueryInfoA(req.request, HTTP_QUERY_SERVER, buffer, &size, NULL); 4221 ok(ret, "HttpQueryInfo failed\n"); 4222 ok(!strcmp(buffer, "winetest"), "server wrong \"%s\"\n", buffer); 4223 4224 close_request(&req); 4225 } 4226 4227 static void test_response_without_headers(int port) 4228 { 4229 test_request_t req; 4230 DWORD r, count, size; 4231 char buffer[1024]; 4232 4233 open_simple_request(&req, "localhost", port, NULL, "/testG"); 4234 4235 test_request_flags(req.request, INTERNET_REQFLAG_NO_HEADERS); 4236 4237 r = HttpSendRequestA(req.request, NULL, 0, NULL, 0); 4238 ok(r, "HttpSendRequest failed %u\n", GetLastError()); 4239 4240 test_request_flags_todo(req.request, INTERNET_REQFLAG_NO_HEADERS); 4241 4242 count = 0; 4243 memset(buffer, 0, sizeof buffer); 4244 r = InternetReadFile(req.request, buffer, sizeof buffer, &count); 4245 ok(r, "InternetReadFile failed %u\n", GetLastError()); 4246 todo_wine ok(count == sizeof page1 - 1, "count was wrong\n"); 4247 todo_wine ok(!memcmp(buffer, page1, sizeof page1), "http data wrong\n"); 4248 4249 test_status_code(req.request, 200); 4250 test_request_flags_todo(req.request, INTERNET_REQFLAG_NO_HEADERS); 4251 4252 buffer[0] = 0; 4253 size = sizeof(buffer); 4254 r = HttpQueryInfoA(req.request, HTTP_QUERY_STATUS_TEXT, buffer, &size, NULL ); 4255 ok(r, "HttpQueryInfo failed %u\n", GetLastError()); 4256 ok(!strcmp(buffer, "OK"), "expected OK got: \"%s\"\n", buffer); 4257 4258 buffer[0] = 0; 4259 size = sizeof(buffer); 4260 r = HttpQueryInfoA(req.request, HTTP_QUERY_VERSION, buffer, &size, NULL); 4261 ok(r, "HttpQueryInfo failed %u\n", GetLastError()); 4262 ok(!strcmp(buffer, "HTTP/1.0"), "expected HTTP/1.0 got: \"%s\"\n", buffer); 4263 4264 buffer[0] = 0; 4265 size = sizeof(buffer); 4266 r = HttpQueryInfoA(req.request, HTTP_QUERY_RAW_HEADERS, buffer, &size, NULL); 4267 ok(r, "HttpQueryInfo failed %u\n", GetLastError()); 4268 ok(!strcmp(buffer, "HTTP/1.0 200 OK"), "raw headers wrong: \"%s\"\n", buffer); 4269 4270 close_request(&req); 4271 } 4272 4273 static void test_head_request(int port) 4274 { 4275 DWORD len, content_length; 4276 test_request_t req; 4277 BYTE buf[100]; 4278 BOOL ret; 4279 4280 open_simple_request(&req, "localhost", port, "HEAD", "/test_head"); 4281 4282 ret = HttpSendRequestA(req.request, NULL, 0, NULL, 0); 4283 ok(ret, "HttpSendRequest failed: %u\n", GetLastError()); 4284 4285 len = sizeof(content_length); 4286 content_length = -1; 4287 ret = HttpQueryInfoA(req.request, HTTP_QUERY_FLAG_NUMBER|HTTP_QUERY_CONTENT_LENGTH, &content_length, &len, 0); 4288 ok(ret, "HttpQueryInfo failed: %u\n", GetLastError()); 4289 ok(len == sizeof(DWORD), "len = %u\n", len); 4290 ok(content_length == 100, "content_length = %u\n", content_length); 4291 4292 len = -1; 4293 ret = InternetReadFile(req.request, buf, sizeof(buf), &len); 4294 ok(ret, "InternetReadFile failed: %u\n", GetLastError()); 4295 4296 len = -1; 4297 ret = InternetReadFile(req.request, buf, sizeof(buf), &len); 4298 ok(ret, "InternetReadFile failed: %u\n", GetLastError()); 4299 4300 close_request(&req); 4301 } 4302 4303 static void test_HttpQueryInfo(int port) 4304 { 4305 test_request_t req; 4306 DWORD size, index, error; 4307 char buffer[1024]; 4308 BOOL ret; 4309 4310 open_simple_request(&req, "localhost", port, NULL, "/testD"); 4311 4312 size = sizeof(buffer); 4313 ret = HttpQueryInfoA(req.request, HTTP_QUERY_STATUS_TEXT, buffer, &size, &index); 4314 error = GetLastError(); 4315 ok(!ret || broken(ret), "HttpQueryInfo succeeded\n"); 4316 if (!ret) ok(error == ERROR_HTTP_HEADER_NOT_FOUND, "got %u expected ERROR_HTTP_HEADER_NOT_FOUND\n", error); 4317 4318 ret = HttpSendRequestA(req.request, NULL, 0, NULL, 0); 4319 ok(ret, "HttpSendRequest failed\n"); 4320 4321 index = 0; 4322 size = sizeof(buffer); 4323 ret = HttpQueryInfoA(req.request, HTTP_QUERY_HOST | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, &index); 4324 ok(ret, "HttpQueryInfo failed %u\n", GetLastError()); 4325 ok(index == 1, "expected 1 got %u\n", index); 4326 4327 index = 0; 4328 size = sizeof(buffer); 4329 ret = HttpQueryInfoA(req.request, HTTP_QUERY_DATE | HTTP_QUERY_FLAG_SYSTEMTIME, buffer, &size, &index); 4330 ok(ret, "HttpQueryInfo failed %u\n", GetLastError()); 4331 ok(index == 1, "expected 1 got %u\n", index); 4332 4333 index = 0; 4334 size = sizeof(buffer); 4335 ret = HttpQueryInfoA(req.request, HTTP_QUERY_RAW_HEADERS, buffer, &size, &index); 4336 ok(ret, "HttpQueryInfo failed %u\n", GetLastError()); 4337 ok(index == 0, "expected 0 got %u\n", index); 4338 4339 size = sizeof(buffer); 4340 ret = HttpQueryInfoA(req.request, HTTP_QUERY_RAW_HEADERS, buffer, &size, &index); 4341 ok(ret, "HttpQueryInfo failed %u\n", GetLastError()); 4342 ok(index == 0, "expected 0 got %u\n", index); 4343 4344 index = 0xdeadbeef; /* invalid start index */ 4345 size = sizeof(buffer); 4346 ret = HttpQueryInfoA(req.request, HTTP_QUERY_RAW_HEADERS, buffer, &size, &index); 4347 todo_wine ok(!ret, "HttpQueryInfo should have failed\n"); 4348 todo_wine ok(GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND, 4349 "Expected ERROR_HTTP_HEADER_NOT_FOUND, got %u\n", GetLastError()); 4350 4351 index = 0; 4352 size = sizeof(buffer); 4353 ret = HttpQueryInfoA(req.request, HTTP_QUERY_RAW_HEADERS_CRLF, buffer, &size, &index); 4354 ok(ret, "HttpQueryInfo failed %u\n", GetLastError()); 4355 ok(index == 0, "expected 0 got %u\n", index); 4356 4357 size = sizeof(buffer); 4358 ret = HttpQueryInfoA(req.request, HTTP_QUERY_STATUS_TEXT, buffer, &size, &index); 4359 ok(ret, "HttpQueryInfo failed %u\n", GetLastError()); 4360 ok(index == 0, "expected 0 got %u\n", index); 4361 4362 size = sizeof(buffer); 4363 ret = HttpQueryInfoA(req.request, HTTP_QUERY_VERSION, buffer, &size, &index); 4364 ok(ret, "HttpQueryInfo failed %u\n", GetLastError()); 4365 ok(index == 0, "expected 0 got %u\n", index); 4366 4367 test_status_code(req.request, 200); 4368 4369 index = 0xdeadbeef; 4370 size = sizeof(buffer); 4371 ret = HttpQueryInfoA(req.request, HTTP_QUERY_FORWARDED, buffer, &size, &index); 4372 ok(!ret, "HttpQueryInfo succeeded\n"); 4373 ok(index == 0xdeadbeef, "expected 0xdeadbeef got %u\n", index); 4374 4375 index = 0; 4376 size = sizeof(buffer); 4377 ret = HttpQueryInfoA(req.request, HTTP_QUERY_SERVER, buffer, &size, &index); 4378 ok(ret, "HttpQueryInfo failed %u\n", GetLastError()); 4379 ok(index == 1, "expected 1 got %u\n", index); 4380 4381 index = 0; 4382 size = sizeof(buffer); 4383 strcpy(buffer, "Server"); 4384 ret = HttpQueryInfoA(req.request, HTTP_QUERY_CUSTOM, buffer, &size, &index); 4385 ok(ret, "HttpQueryInfo failed %u\n", GetLastError()); 4386 ok(index == 1, "expected 1 got %u\n", index); 4387 4388 index = 0; 4389 size = sizeof(buffer); 4390 ret = HttpQueryInfoA(req.request, HTTP_QUERY_SET_COOKIE, buffer, &size, &index); 4391 ok(ret, "HttpQueryInfo failed %u\n", GetLastError()); 4392 ok(index == 1, "expected 1 got %u\n", index); 4393 4394 size = sizeof(buffer); 4395 ret = HttpQueryInfoA(req.request, HTTP_QUERY_SET_COOKIE, buffer, &size, &index); 4396 ok(ret, "HttpQueryInfo failed %u\n", GetLastError()); 4397 ok(index == 2, "expected 2 got %u\n", index); 4398 4399 close_request(&req); 4400 } 4401 4402 static void test_options(int port) 4403 { 4404 INTERNET_DIAGNOSTIC_SOCKET_INFO idsi; 4405 HINTERNET ses, con, req; 4406 DWORD size, error; 4407 DWORD_PTR ctx; 4408 BOOL ret; 4409 4410 ses = InternetOpenA("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0); 4411 ok(ses != NULL, "InternetOpen failed\n"); 4412 4413 SetLastError(0xdeadbeef); 4414 ret = InternetSetOptionA(ses, INTERNET_OPTION_CONTEXT_VALUE, NULL, 0); 4415 error = GetLastError(); 4416 ok(!ret, "InternetSetOption succeeded\n"); 4417 ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %u\n", error); 4418 4419 SetLastError(0xdeadbeef); 4420 ret = InternetSetOptionA(ses, INTERNET_OPTION_CONTEXT_VALUE, NULL, sizeof(ctx)); 4421 ok(!ret, "InternetSetOption succeeded\n"); 4422 error = GetLastError(); 4423 ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %u\n", error); 4424 4425 SetLastError(0xdeadbeef); 4426 ret = InternetSetOptionA(ses, INTERNET_OPTION_CONTEXT_VALUE, &ctx, 0); 4427 ok(!ret, "InternetSetOption succeeded\n"); 4428 error = GetLastError(); 4429 ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %u\n", error); 4430 4431 ctx = 1; 4432 ret = InternetSetOptionA(ses, INTERNET_OPTION_CONTEXT_VALUE, &ctx, sizeof(ctx)); 4433 ok(ret, "InternetSetOption failed %u\n", GetLastError()); 4434 4435 SetLastError(0xdeadbeef); 4436 ret = InternetQueryOptionA(ses, INTERNET_OPTION_CONTEXT_VALUE, NULL, NULL); 4437 error = GetLastError(); 4438 ok(!ret, "InternetQueryOption succeeded\n"); 4439 ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %u\n", error); 4440 4441 SetLastError(0xdeadbeef); 4442 ret = InternetQueryOptionA(ses, INTERNET_OPTION_CONTEXT_VALUE, &ctx, NULL); 4443 error = GetLastError(); 4444 ok(!ret, "InternetQueryOption succeeded\n"); 4445 ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %u\n", error); 4446 4447 size = 0; 4448 SetLastError(0xdeadbeef); 4449 ret = InternetQueryOptionA(ses, INTERNET_OPTION_CONTEXT_VALUE, NULL, &size); 4450 error = GetLastError(); 4451 ok(!ret, "InternetQueryOption succeeded\n"); 4452 ok(error == ERROR_INSUFFICIENT_BUFFER, "expected ERROR_INSUFFICIENT_BUFFER, got %u\n", error); 4453 4454 size = sizeof(ctx); 4455 SetLastError(0xdeadbeef); 4456 ret = InternetQueryOptionA(NULL, INTERNET_OPTION_CONTEXT_VALUE, &ctx, &size); 4457 error = GetLastError(); 4458 ok(!ret, "InternetQueryOption succeeded\n"); 4459 ok(error == ERROR_INTERNET_INCORRECT_HANDLE_TYPE, "expected ERROR_INTERNET_INCORRECT_HANDLE_TYPE, got %u\n", error); 4460 4461 ctx = 0xdeadbeef; 4462 size = sizeof(ctx); 4463 ret = InternetQueryOptionA(ses, INTERNET_OPTION_CONTEXT_VALUE, &ctx, &size); 4464 ok(ret, "InternetQueryOption failed %u\n", GetLastError()); 4465 ok(ctx == 1, "expected 1 got %lu\n", ctx); 4466 4467 con = InternetConnectA(ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); 4468 ok(con != NULL, "InternetConnect failed\n"); 4469 4470 ctx = 0xdeadbeef; 4471 size = sizeof(ctx); 4472 ret = InternetQueryOptionA(con, INTERNET_OPTION_CONTEXT_VALUE, &ctx, &size); 4473 ok(ret, "InternetQueryOption failed %u\n", GetLastError()); 4474 ok(ctx == 0, "expected 0 got %lu\n", ctx); 4475 4476 ctx = 2; 4477 ret = InternetSetOptionA(con, INTERNET_OPTION_CONTEXT_VALUE, &ctx, sizeof(ctx)); 4478 ok(ret, "InternetSetOption failed %u\n", GetLastError()); 4479 4480 ctx = 0xdeadbeef; 4481 size = sizeof(ctx); 4482 ret = InternetQueryOptionA(con, INTERNET_OPTION_CONTEXT_VALUE, &ctx, &size); 4483 ok(ret, "InternetQueryOption failed %u\n", GetLastError()); 4484 ok(ctx == 2, "expected 2 got %lu\n", ctx); 4485 4486 req = HttpOpenRequestA(con, NULL, "/test1", NULL, NULL, NULL, 0, 0); 4487 ok(req != NULL, "HttpOpenRequest failed\n"); 4488 4489 ctx = 0xdeadbeef; 4490 size = sizeof(ctx); 4491 ret = InternetQueryOptionA(req, INTERNET_OPTION_CONTEXT_VALUE, &ctx, &size); 4492 ok(ret, "InternetQueryOption failed %u\n", GetLastError()); 4493 ok(ctx == 0, "expected 0 got %lu\n", ctx); 4494 4495 ctx = 3; 4496 ret = InternetSetOptionA(req, INTERNET_OPTION_CONTEXT_VALUE, &ctx, sizeof(ctx)); 4497 ok(ret, "InternetSetOption failed %u\n", GetLastError()); 4498 4499 ctx = 0xdeadbeef; 4500 size = sizeof(ctx); 4501 ret = InternetQueryOptionA(req, INTERNET_OPTION_CONTEXT_VALUE, &ctx, &size); 4502 ok(ret, "InternetQueryOption failed %u\n", GetLastError()); 4503 ok(ctx == 3, "expected 3 got %lu\n", ctx); 4504 4505 size = sizeof(idsi); 4506 ret = InternetQueryOptionA(req, INTERNET_OPTION_DIAGNOSTIC_SOCKET_INFO, &idsi, &size); 4507 ok(ret, "InternetQueryOption failed %u\n", GetLastError()); 4508 4509 size = 0; 4510 SetLastError(0xdeadbeef); 4511 ret = InternetQueryOptionA(req, INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT, NULL, &size); 4512 error = GetLastError(); 4513 ok(!ret, "InternetQueryOption succeeded\n"); 4514 ok(error == ERROR_INTERNET_INVALID_OPERATION, "expected ERROR_INTERNET_INVALID_OPERATION, got %u\n", error); 4515 4516 /* INTERNET_OPTION_PROXY */ 4517 SetLastError(0xdeadbeef); 4518 ret = InternetQueryOptionA(ses, INTERNET_OPTION_PROXY, NULL, NULL); 4519 error = GetLastError(); 4520 ok(!ret, "InternetQueryOption succeeded\n"); 4521 ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %u\n", error); 4522 4523 SetLastError(0xdeadbeef); 4524 ret = InternetQueryOptionA(ses, INTERNET_OPTION_PROXY, &ctx, NULL); 4525 error = GetLastError(); 4526 ok(!ret, "InternetQueryOption succeeded\n"); 4527 ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %u\n", error); 4528 4529 size = 0; 4530 SetLastError(0xdeadbeef); 4531 ret = InternetQueryOptionA(ses, INTERNET_OPTION_PROXY, NULL, &size); 4532 error = GetLastError(); 4533 ok(!ret, "InternetQueryOption succeeded\n"); 4534 ok(error == ERROR_INSUFFICIENT_BUFFER, "expected ERROR_INSUFFICIENT_BUFFER, got %u\n", error); 4535 ok(size >= sizeof(INTERNET_PROXY_INFOA), "expected size to be greater or equal to the struct size\n"); 4536 4537 InternetCloseHandle(req); 4538 InternetCloseHandle(con); 4539 InternetCloseHandle(ses); 4540 } 4541 4542 typedef struct { 4543 const char *response_text; 4544 int status_code; 4545 const char *status_text; 4546 const char *raw_headers; 4547 } http_status_test_t; 4548 4549 static const http_status_test_t http_status_tests[] = { 4550 { 4551 "HTTP/1.1 200 OK\r\n" 4552 "Content-Length: 1\r\n" 4553 "\r\nx", 4554 200, 4555 "OK" 4556 }, 4557 { 4558 "HTTP/1.1 404 Fail\r\n" 4559 "Content-Length: 1\r\n" 4560 "\r\nx", 4561 404, 4562 "Fail" 4563 }, 4564 { 4565 "HTTP/1.1 200\r\n" 4566 "Content-Length: 1\r\n" 4567 "\r\nx", 4568 200, 4569 "" 4570 }, 4571 { 4572 "HTTP/1.1 410 \r\n" 4573 "Content-Length: 1\r\n" 4574 "\r\nx", 4575 410, 4576 "" 4577 } 4578 }; 4579 4580 static void test_http_status(int port) 4581 { 4582 test_request_t req; 4583 char buf[1000]; 4584 DWORD i, size; 4585 BOOL res; 4586 4587 for(i = 0; i < ARRAY_SIZE(http_status_tests); i++) { 4588 send_buffer = http_status_tests[i].response_text; 4589 4590 open_simple_request(&req, "localhost", port, NULL, "/send_from_buffer"); 4591 4592 res = HttpSendRequestA(req.request, NULL, 0, NULL, 0); 4593 ok(res, "HttpSendRequest failed\n"); 4594 4595 test_status_code(req.request, http_status_tests[i].status_code); 4596 4597 size = sizeof(buf); 4598 res = HttpQueryInfoA(req.request, HTTP_QUERY_STATUS_TEXT, buf, &size, NULL); 4599 ok(res, "HttpQueryInfo failed: %u\n", GetLastError()); 4600 ok(!strcmp(buf, http_status_tests[i].status_text), "[%u] Unexpected status text \"%s\", expected \"%s\"\n", 4601 i, buf, http_status_tests[i].status_text); 4602 4603 close_request(&req); 4604 } 4605 } 4606 4607 static void test_cache_control_verb(int port) 4608 { 4609 HINTERNET session, connect, request; 4610 BOOL ret; 4611 4612 session = InternetOpenA("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0); 4613 ok(session != NULL, "InternetOpen failed\n"); 4614 4615 connect = InternetConnectA(session, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); 4616 ok(connect != NULL, "InternetConnect failed\n"); 4617 4618 request = HttpOpenRequestA(connect, "RPC_OUT_DATA", "/test_cache_control_verb", NULL, NULL, NULL, 4619 INTERNET_FLAG_NO_CACHE_WRITE, 0); 4620 ok(request != NULL, "HttpOpenRequest failed\n"); 4621 ret = HttpSendRequestA(request, NULL, 0, NULL, 0); 4622 ok(ret, "HttpSendRequest failed %u\n", GetLastError()); 4623 test_status_code(request, 200); 4624 InternetCloseHandle(request); 4625 4626 request = HttpOpenRequestA(connect, "POST", "/test_cache_control_verb", NULL, NULL, NULL, 4627 INTERNET_FLAG_NO_CACHE_WRITE, 0); 4628 ok(request != NULL, "HttpOpenRequest failed\n"); 4629 ret = HttpSendRequestA(request, NULL, 0, NULL, 0); 4630 ok(ret, "HttpSendRequest failed %u\n", GetLastError()); 4631 test_status_code(request, 200); 4632 InternetCloseHandle(request); 4633 4634 request = HttpOpenRequestA(connect, "HEAD", "/test_cache_control_verb", NULL, NULL, NULL, 4635 INTERNET_FLAG_NO_CACHE_WRITE, 0); 4636 ok(request != NULL, "HttpOpenRequest failed\n"); 4637 ret = HttpSendRequestA(request, NULL, 0, NULL, 0); 4638 ok(ret, "HttpSendRequest failed %u\n", GetLastError()); 4639 test_status_code(request, 200); 4640 InternetCloseHandle(request); 4641 4642 request = HttpOpenRequestA(connect, "GET", "/test_cache_control_verb", NULL, NULL, NULL, 4643 INTERNET_FLAG_NO_CACHE_WRITE, 0); 4644 ok(request != NULL, "HttpOpenRequest failed\n"); 4645 ret = HttpSendRequestA(request, NULL, 0, NULL, 0); 4646 ok(ret, "HttpSendRequest failed %u\n", GetLastError()); 4647 test_status_code(request, 200); 4648 InternetCloseHandle(request); 4649 4650 InternetCloseHandle(connect); 4651 InternetCloseHandle(session); 4652 } 4653 4654 static void test_request_content_length(int port) 4655 { 4656 char data[] = {'t','e','s','t'}; 4657 test_request_t req; 4658 BOOL ret; 4659 4660 reset_events(); 4661 open_simple_request(&req, "localhost", port, "POST", "/test_request_content_length"); 4662 4663 ret = HttpSendRequestA(req.request, NULL, 0, NULL, 0); 4664 ok(ret, "HttpSendRequest failed %u\n", GetLastError()); 4665 test_status_code(req.request, 200); 4666 4667 SetEvent(complete_event); 4668 4669 ret = HttpSendRequestA(req.request, NULL, 0, data, sizeof(data)); 4670 ok(ret, "HttpSendRequest failed %u\n", GetLastError()); 4671 test_status_code(req.request, 200); 4672 4673 SetEvent(complete_event); 4674 close_request(&req); 4675 } 4676 4677 static void test_accept_encoding(int port) 4678 { 4679 HINTERNET ses, con, req; 4680 char buf[1000]; 4681 BOOL ret; 4682 4683 ses = InternetOpenA("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0); 4684 ok(ses != NULL, "InternetOpen failed\n"); 4685 4686 con = InternetConnectA(ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); 4687 ok(con != NULL, "InternetConnect failed\n"); 4688 4689 req = HttpOpenRequestA(con, "GET", "/echo_request", "HTTP/1.0", NULL, NULL, 0, 0); 4690 ok(req != NULL, "HttpOpenRequest failed\n"); 4691 4692 ret = HttpAddRequestHeadersA(req, "Accept-Encoding: gzip\r\n", ~0u, HTTP_ADDREQ_FLAG_REPLACE | HTTP_ADDREQ_FLAG_ADD); 4693 ok(ret, "HttpAddRequestHeaders failed\n"); 4694 4695 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 4696 ok(ret, "HttpSendRequestA failed\n"); 4697 4698 test_status_code(req, 200); 4699 receive_simple_request(req, buf, sizeof(buf)); 4700 ok(strstr(buf, "Accept-Encoding: gzip") != NULL, "Accept-Encoding header not found in %s\n", buf); 4701 4702 InternetCloseHandle(req); 4703 4704 req = HttpOpenRequestA(con, "GET", "/echo_request", "HTTP/1.0", NULL, NULL, 0, 0); 4705 ok(req != NULL, "HttpOpenRequest failed\n"); 4706 4707 ret = HttpSendRequestA(req, "Accept-Encoding: gzip", ~0u, NULL, 0); 4708 ok(ret, "HttpSendRequestA failed\n"); 4709 4710 test_status_code(req, 200); 4711 receive_simple_request(req, buf, sizeof(buf)); 4712 ok(strstr(buf, "Accept-Encoding: gzip") != NULL, "Accept-Encoding header not found in %s\n", buf); 4713 4714 InternetCloseHandle(req); 4715 InternetCloseHandle(con); 4716 InternetCloseHandle(ses); 4717 } 4718 4719 static void test_basic_auth_credentials_reuse(int port) 4720 { 4721 HINTERNET ses, con, req; 4722 DWORD status, size; 4723 BOOL ret; 4724 char buffer[0x40]; 4725 4726 ses = InternetOpenA( "winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0 ); 4727 ok( ses != NULL, "InternetOpenA failed\n" ); 4728 4729 con = InternetConnectA( ses, "localhost", port, "user", "pwd", 4730 INTERNET_SERVICE_HTTP, 0, 0 ); 4731 ok( con != NULL, "InternetConnectA failed %u\n", GetLastError() ); 4732 4733 req = HttpOpenRequestA( con, "HEAD", "/upload.txt", NULL, NULL, NULL, 0, 0 ); 4734 ok( req != NULL, "HttpOpenRequestA failed %u\n", GetLastError() ); 4735 4736 ret = HttpSendRequestA( req, NULL, 0, NULL, 0 ); 4737 ok( ret, "HttpSendRequestA failed %u\n", GetLastError() ); 4738 4739 size = sizeof(buffer); 4740 SetLastError(0xdeadbeef); 4741 ret = InternetQueryOptionA(req, INTERNET_OPTION_USERNAME, buffer, &size); 4742 ok(ret, "unexpected failure %u\n", GetLastError()); 4743 ok(!strcmp(buffer, "user"), "got %s\n", buffer); 4744 ok(size == 4, "got %u\n", size); 4745 4746 size = sizeof(buffer); 4747 SetLastError(0xdeadbeef); 4748 ret = InternetQueryOptionA(req, INTERNET_OPTION_PASSWORD, buffer, &size); 4749 ok(ret, "unexpected failure %u\n", GetLastError()); 4750 ok(!strcmp(buffer, "pwd"), "got %s\n", buffer); 4751 ok(size == 3, "got %u\n", size); 4752 4753 status = 0xdeadbeef; 4754 size = sizeof(status); 4755 ret = HttpQueryInfoA( req, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL ); 4756 ok( ret, "HttpQueryInfoA failed %u\n", GetLastError() ); 4757 ok( status == 200, "got %u\n", status ); 4758 4759 InternetCloseHandle( req ); 4760 InternetCloseHandle( con ); 4761 InternetCloseHandle( ses ); 4762 4763 ses = InternetOpenA( "winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0 ); 4764 ok( ses != NULL, "InternetOpenA failed\n" ); 4765 4766 con = InternetConnectA( ses, "localhost", port, NULL, NULL, 4767 INTERNET_SERVICE_HTTP, 0, 0 ); 4768 ok( con != NULL, "InternetConnectA failed %u\n", GetLastError() ); 4769 4770 req = HttpOpenRequestA( con, "PUT", "/upload2.txt", NULL, NULL, NULL, 0, 0 ); 4771 ok( req != NULL, "HttpOpenRequestA failed %u\n", GetLastError() ); 4772 4773 ret = HttpSendRequestA( req, NULL, 0, NULL, 0 ); 4774 ok( ret, "HttpSendRequestA failed %u\n", GetLastError() ); 4775 4776 size = sizeof(buffer); 4777 SetLastError(0xdeadbeef); 4778 ret = InternetQueryOptionA(req, INTERNET_OPTION_USERNAME, buffer, &size); 4779 ok(ret, "unexpected failure %u\n", GetLastError()); 4780 ok(!strcmp(buffer, "user"), "got %s\n", buffer); 4781 ok(size == 4, "got %u\n", size); 4782 4783 size = sizeof(buffer); 4784 SetLastError(0xdeadbeef); 4785 ret = InternetQueryOptionA(req, INTERNET_OPTION_PASSWORD, buffer, &size); 4786 ok(ret, "unexpected failure %u\n", GetLastError()); 4787 ok(!strcmp(buffer, "pwd"), "got %s\n", buffer); 4788 ok(size == 3, "got %u\n", size); 4789 4790 status = 0xdeadbeef; 4791 size = sizeof(status); 4792 ret = HttpQueryInfoA( req, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL ); 4793 ok( ret, "HttpQueryInfoA failed %u\n", GetLastError() ); 4794 ok( status == 200, "got %u\n", status ); 4795 4796 InternetCloseHandle( req ); 4797 InternetCloseHandle( con ); 4798 InternetCloseHandle( ses ); 4799 } 4800 4801 static void test_basic_auth_credentials_end_session(int port) 4802 { 4803 HINTERNET ses, con, req; 4804 DWORD status, size; 4805 BOOL ret; 4806 char buffer[0x40]; 4807 4808 ses = InternetOpenA( "winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0 ); 4809 ok( ses != NULL, "InternetOpenA failed\n" ); 4810 4811 con = InternetConnectA( ses, "localhost", port, "user", "pwd", 4812 INTERNET_SERVICE_HTTP, 0, 0 ); 4813 ok( con != NULL, "InternetConnectA failed %u\n", GetLastError() ); 4814 4815 req = HttpOpenRequestA( con, "HEAD", "/upload.txt", NULL, NULL, NULL, 0, 0 ); 4816 ok( req != NULL, "HttpOpenRequestA failed %u\n", GetLastError() ); 4817 4818 ret = HttpSendRequestA( req, NULL, 0, NULL, 0 ); 4819 ok( ret, "HttpSendRequestA failed %u\n", GetLastError() ); 4820 4821 size = sizeof(buffer); 4822 SetLastError(0xdeadbeef); 4823 ret = InternetQueryOptionA(req, INTERNET_OPTION_USERNAME, buffer, &size); 4824 ok(ret, "unexpected failure %u\n", GetLastError()); 4825 ok(!strcmp(buffer, "user"), "got %s\n", buffer); 4826 ok(size == 4, "got %u\n", size); 4827 4828 size = sizeof(buffer); 4829 SetLastError(0xdeadbeef); 4830 ret = InternetQueryOptionA(req, INTERNET_OPTION_PASSWORD, buffer, &size); 4831 ok(ret, "unexpected failure %u\n", GetLastError()); 4832 ok(!strcmp(buffer, "pwd"), "got %s\n", buffer); 4833 ok(size == 3, "got %u\n", size); 4834 4835 status = 0xdeadbeef; 4836 size = sizeof(status); 4837 ret = HttpQueryInfoA( req, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL ); 4838 ok( ret, "HttpQueryInfoA failed %u\n", GetLastError() ); 4839 ok( status == HTTP_STATUS_OK, "got %u\n", status ); 4840 4841 InternetCloseHandle( req ); 4842 InternetCloseHandle( con ); 4843 InternetCloseHandle( ses ); 4844 4845 ses = InternetOpenA( "winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0 ); 4846 ok( ses != NULL, "InternetOpenA failed\n" ); 4847 4848 /* Clear the cached credentials */ 4849 ret = InternetSetOptionA(ses, INTERNET_OPTION_END_BROWSER_SESSION, NULL, 0); 4850 ok(ret, "unexpected failure %u\n", GetLastError()); 4851 4852 con = InternetConnectA( ses, "localhost", port, NULL, NULL, 4853 INTERNET_SERVICE_HTTP, 0, 0 ); 4854 ok( con != NULL, "InternetConnectA failed %u\n", GetLastError() ); 4855 4856 req = HttpOpenRequestA( con, "PUT", "/upload2.txt", NULL, NULL, NULL, 0, 0 ); 4857 ok( req != NULL, "HttpOpenRequestA failed %u\n", GetLastError() ); 4858 4859 ret = HttpSendRequestA( req, NULL, 0, NULL, 0 ); 4860 ok( ret, "HttpSendRequestA failed %u\n", GetLastError() ); 4861 4862 size = sizeof(buffer); 4863 SetLastError(0xdeadbeef); 4864 ret = InternetQueryOptionA(req, INTERNET_OPTION_USERNAME, buffer, &size); 4865 ok(ret, "unexpected failure %u\n", GetLastError()); 4866 ok(!strcmp(buffer, ""), "got %s\n", buffer); 4867 ok(size == 0, "got %u\n", size); 4868 4869 size = sizeof(buffer); 4870 SetLastError(0xdeadbeef); 4871 ret = InternetQueryOptionA(req, INTERNET_OPTION_PASSWORD, buffer, &size); 4872 ok(ret, "unexpected failure %u\n", GetLastError()); 4873 ok(!strcmp(buffer, ""), "got %s\n", buffer); 4874 ok(size == 0, "got %u\n", size); 4875 4876 status = 0xdeadbeef; 4877 size = sizeof(status); 4878 ret = HttpQueryInfoA( req, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL ); 4879 ok( ret, "HttpQueryInfoA failed %u\n", GetLastError() ); 4880 ok( status == HTTP_STATUS_BAD_REQUEST, "got %u\n", status ); 4881 4882 InternetCloseHandle( req ); 4883 InternetCloseHandle( con ); 4884 InternetCloseHandle( ses ); 4885 } 4886 4887 static void test_basic_auth_credentials_different(int port) 4888 { 4889 HINTERNET ses, con, req; 4890 DWORD status, size; 4891 BOOL ret; 4892 char buffer[0x40]; 4893 4894 ses = InternetOpenA( "winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0 ); 4895 ok( ses != NULL, "InternetOpenA failed\n" ); 4896 4897 con = InternetConnectA( ses, "localhost", port, "user", "pwd", 4898 INTERNET_SERVICE_HTTP, 0, 0 ); 4899 ok( con != NULL, "InternetConnectA failed %u\n", GetLastError() ); 4900 4901 req = HttpOpenRequestA( con, "HEAD", "/upload.txt", NULL, NULL, NULL, 0, 0 ); 4902 ok( req != NULL, "HttpOpenRequestA failed %u\n", GetLastError() ); 4903 4904 ret = HttpSendRequestA( req, NULL, 0, NULL, 0 ); 4905 ok( ret, "HttpSendRequestA failed %u\n", GetLastError() ); 4906 4907 size = sizeof(buffer); 4908 SetLastError(0xdeadbeef); 4909 ret = InternetQueryOptionA(req, INTERNET_OPTION_USERNAME, buffer, &size); 4910 ok(ret, "unexpected failure %u\n", GetLastError()); 4911 ok(!strcmp(buffer, "user"), "got %s\n", buffer); 4912 ok(size == 4, "got %u\n", size); 4913 4914 size = sizeof(buffer); 4915 SetLastError(0xdeadbeef); 4916 ret = InternetQueryOptionA(req, INTERNET_OPTION_PASSWORD, buffer, &size); 4917 ok(ret, "unexpected failure %u\n", GetLastError()); 4918 ok(!strcmp(buffer, "pwd"), "got %s\n", buffer); 4919 ok(size == 3, "got %u\n", size); 4920 4921 status = 0xdeadbeef; 4922 size = sizeof(status); 4923 ret = HttpQueryInfoA( req, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL ); 4924 ok( ret, "HttpQueryInfoA failed %u\n", GetLastError() ); 4925 ok( status == 200, "got %u\n", status ); 4926 4927 InternetCloseHandle( req ); 4928 InternetCloseHandle( con ); 4929 InternetCloseHandle( ses ); 4930 4931 ses = InternetOpenA( "winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0 ); 4932 ok( ses != NULL, "InternetOpenA failed\n" ); 4933 4934 con = InternetConnectA( ses, "localhost", port, "user1", "pwd1", 4935 INTERNET_SERVICE_HTTP, 0, 0 ); 4936 ok( con != NULL, "InternetConnectA failed %u\n", GetLastError() ); 4937 4938 req = HttpOpenRequestA( con, "HEAD", "/upload3.txt", NULL, NULL, NULL, 0, 0 ); 4939 ok( req != NULL, "HttpOpenRequestA failed %u\n", GetLastError() ); 4940 4941 ret = HttpSendRequestA( req, NULL, 0, NULL, 0 ); 4942 ok( ret, "HttpSendRequestA failed %u\n", GetLastError() ); 4943 4944 size = sizeof(buffer); 4945 SetLastError(0xdeadbeef); 4946 ret = InternetQueryOptionA(req, INTERNET_OPTION_USERNAME, buffer, &size); 4947 ok(ret, "unexpected failure %u\n", GetLastError()); 4948 ok(!strcmp(buffer, "user1"), "got %s\n", buffer); 4949 ok(size == 5, "got %u\n", size); 4950 4951 size = sizeof(buffer); 4952 SetLastError(0xdeadbeef); 4953 ret = InternetQueryOptionA(req, INTERNET_OPTION_PASSWORD, buffer, &size); 4954 ok(ret, "unexpected failure %u\n", GetLastError()); 4955 ok(!strcmp(buffer, "pwd1"), "got %s\n", buffer); 4956 ok(size == 4, "got %u\n", size); 4957 4958 status = 0xdeadbeef; 4959 size = sizeof(status); 4960 ret = HttpQueryInfoA( req, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL ); 4961 ok( ret, "HttpQueryInfoA failed %u\n", GetLastError() ); 4962 ok( status == 200, "got %u\n", status ); 4963 4964 InternetCloseHandle( req ); 4965 InternetCloseHandle( con ); 4966 InternetCloseHandle( ses ); 4967 } 4968 4969 /* 4970 * Manually set the Authorization for both calls. 4971 */ 4972 static void test_basic_auth_credentials_manual(int port) 4973 { 4974 HINTERNET ses, con, req; 4975 DWORD status, size; 4976 BOOL ret; 4977 4978 ses = InternetOpenA( "winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0 ); 4979 ok( ses != NULL, "InternetOpenA failed\n" ); 4980 4981 /* Clear the cached credentials */ 4982 ret = InternetSetOptionA(ses, INTERNET_OPTION_END_BROWSER_SESSION, NULL, 0); 4983 ok(ret, "unexpected failure %u\n", GetLastError()); 4984 4985 con = InternetConnectA( ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0 ); 4986 ok( con != NULL, "InternetConnectA failed %u\n", GetLastError() ); 4987 4988 req = HttpOpenRequestA( con, "HEAD", "/upload.txt", NULL, NULL, NULL, 0, 0 ); 4989 ok( req != NULL, "HttpOpenRequestA failed %u\n", GetLastError() ); 4990 4991 /* Set Authorization Header */ 4992 ret = HttpAddRequestHeadersA(req, "Authorization: Basic dXNlcjpwd2Q=\r\n", ~0u, 4993 HTTP_ADDREQ_FLAG_REPLACE | HTTP_ADDREQ_FLAG_ADD); 4994 ok(ret, "HttpAddRequestHeaders Failed\n"); 4995 4996 ret = HttpSendRequestA( req, NULL, 0, NULL, 0 ); 4997 ok( ret, "HttpSendRequestA failed %u\n", GetLastError() ); 4998 4999 status = 0xdeadbeef; 5000 size = sizeof(status); 5001 ret = HttpQueryInfoA( req, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL ); 5002 ok( ret, "HttpQueryInfoA failed %u\n", GetLastError() ); 5003 ok( status == 200, "got %u\n", status ); 5004 5005 InternetCloseHandle( req ); 5006 InternetCloseHandle( con ); 5007 InternetCloseHandle( ses ); 5008 5009 /* Show manual headers are cached. */ 5010 ses = InternetOpenA( "winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0 ); 5011 ok( ses != NULL, "InternetOpenA failed\n" ); 5012 5013 con = InternetConnectA( ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0 ); 5014 ok( con != NULL, "InternetConnectA failed %u\n", GetLastError() ); 5015 5016 req = HttpOpenRequestA( con, "HEAD", "/upload.txt", NULL, NULL, NULL, 0, 0 ); 5017 ok( req != NULL, "HttpOpenRequestA failed %u\n", GetLastError() ); 5018 5019 ret = HttpSendRequestA( req, NULL, 0, NULL, 0 ); 5020 ok( ret, "HttpSendRequestA failed %u\n", GetLastError() ); 5021 5022 status = 0xdeadbeef; 5023 size = sizeof(status); 5024 ret = HttpQueryInfoA( req, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL ); 5025 ok( ret, "HttpQueryInfoA failed %u\n", GetLastError() ); 5026 ok( status == 401, "got %u\n", status ); 5027 5028 InternetCloseHandle( req ); 5029 InternetCloseHandle( con ); 5030 InternetCloseHandle( ses ); 5031 5032 ses = InternetOpenA( "winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0 ); 5033 ok( ses != NULL, "InternetOpenA failed\n" ); 5034 5035 con = InternetConnectA( ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0 ); 5036 ok( con != NULL, "InternetConnectA failed %u\n", GetLastError() ); 5037 5038 req = HttpOpenRequestA( con, "HEAD", "/upload4.txt", NULL, NULL, NULL, 0, 0 ); 5039 ok( req != NULL, "HttpOpenRequestA failed %u\n", GetLastError() ); 5040 5041 /* Set Authorization Header */ 5042 ret = HttpAddRequestHeadersA(req, "Authorization: Bearer dXNlcjE6cHdkMQ==\r\n", ~0u, 5043 HTTP_ADDREQ_FLAG_REPLACE | HTTP_ADDREQ_FLAG_ADD); 5044 ok(ret, "HttpAddRequestHeaders Failed\n"); 5045 5046 ret = HttpSendRequestA( req, NULL, 0, NULL, 0 ); 5047 ok( ret, "HttpSendRequestA failed %u\n", GetLastError() ); 5048 5049 status = 0xdeadbeef; 5050 size = sizeof(status); 5051 ret = HttpQueryInfoA( req, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL ); 5052 ok( ret, "HttpQueryInfoA failed %u\n", GetLastError() ); 5053 ok( status == 200, "got %u\n", status ); 5054 5055 InternetCloseHandle( req ); 5056 InternetCloseHandle( con ); 5057 InternetCloseHandle( ses ); 5058 } 5059 5060 /* 5061 * Manually set the Authorization for the bearer call, which shows the cached is used. 5062 */ 5063 static void test_basic_auth_credentials_cached_manual(int port) 5064 { 5065 HINTERNET ses, con, req; 5066 DWORD status, size; 5067 BOOL ret; 5068 5069 ses = InternetOpenA( "winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0 ); 5070 ok( ses != NULL, "InternetOpenA failed\n" ); 5071 5072 /* Clear the cached credentials */ 5073 ret = InternetSetOptionA(ses, INTERNET_OPTION_END_BROWSER_SESSION, NULL, 0); 5074 ok(ret, "unexpected failure %u\n", GetLastError()); 5075 5076 con = InternetConnectA( ses, "localhost", port, "user", "pwd", 5077 INTERNET_SERVICE_HTTP, 0, 0 ); 5078 ok( con != NULL, "InternetConnectA failed %u\n", GetLastError() ); 5079 5080 req = HttpOpenRequestA( con, "HEAD", "/upload.txt", NULL, NULL, NULL, 0, 0 ); 5081 ok( req != NULL, "HttpOpenRequestA failed %u\n", GetLastError() ); 5082 5083 ret = HttpSendRequestA( req, NULL, 0, NULL, 0 ); 5084 ok( ret, "HttpSendRequestA failed %u\n", GetLastError() ); 5085 5086 status = 0xdeadbeef; 5087 size = sizeof(status); 5088 ret = HttpQueryInfoA( req, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL ); 5089 ok( ret, "HttpQueryInfoA failed %u\n", GetLastError() ); 5090 ok( status == 200, "got %u\n", status ); 5091 5092 InternetCloseHandle( req ); 5093 InternetCloseHandle( con ); 5094 InternetCloseHandle( ses ); 5095 5096 ses = InternetOpenA( "winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0 ); 5097 ok( ses != NULL, "InternetOpenA failed\n" ); 5098 5099 con = InternetConnectA( ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0 ); 5100 ok( con != NULL, "InternetConnectA failed %u\n", GetLastError() ); 5101 5102 req = HttpOpenRequestA( con, "HEAD", "/upload4.txt", NULL, NULL, NULL, 0, 0 ); 5103 ok( req != NULL, "HttpOpenRequestA failed %u\n", GetLastError() ); 5104 5105 /* Setting an Authorization Header doesn't override the cached one. */ 5106 ret = HttpAddRequestHeadersA(req, "Authorization: Bearer dXNlcjE6cHdkMQ==\r\n", ~0u, 5107 HTTP_ADDREQ_FLAG_REPLACE | HTTP_ADDREQ_FLAG_ADD); 5108 ok(ret, "HttpAddRequestHeaders Failed\n"); 5109 5110 ret = HttpSendRequestA( req, NULL, 0, NULL, 0 ); 5111 ok( ret, "HttpSendRequestA failed %u\n", GetLastError() ); 5112 5113 status = 0xdeadbeef; 5114 size = sizeof(status); 5115 ret = HttpQueryInfoA( req, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL ); 5116 ok( ret, "HttpQueryInfoA failed %u\n", GetLastError() ); 5117 ok( status == 201, "got %u\n", status ); 5118 5119 InternetCloseHandle( req ); 5120 InternetCloseHandle( con ); 5121 InternetCloseHandle( ses ); 5122 } 5123 5124 static void test_async_read(int port) 5125 { 5126 HINTERNET ses, con, req; 5127 INTERNET_BUFFERSA ib; 5128 char buffer[0x100]; 5129 DWORD pending_reads; 5130 DWORD res, count, bytes; 5131 BOOL ret; 5132 5133 reset_events(); 5134 5135 /* test asynchronous InternetReadFileEx */ 5136 ses = InternetOpenA( "winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, INTERNET_FLAG_ASYNC ); 5137 ok( ses != NULL, "InternetOpenA failed\n" ); 5138 pInternetSetStatusCallbackA( ses, &callback ); 5139 5140 SET_EXPECT( INTERNET_STATUS_HANDLE_CREATED ); 5141 con = InternetConnectA( ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0xdeadbeef ); 5142 ok( con != NULL, "InternetConnectA failed %u\n", GetLastError() ); 5143 CHECK_NOTIFIED( INTERNET_STATUS_HANDLE_CREATED ); 5144 5145 SET_EXPECT( INTERNET_STATUS_HANDLE_CREATED ); 5146 req = HttpOpenRequestA( con, "GET", "/async_read", NULL, NULL, NULL, INTERNET_FLAG_RELOAD, 0xdeadbeef ); 5147 ok( req != NULL, "HttpOpenRequestA failed %u\n", GetLastError() ); 5148 CHECK_NOTIFIED( INTERNET_STATUS_HANDLE_CREATED ); 5149 5150 SET_OPTIONAL( INTERNET_STATUS_COOKIE_SENT ); 5151 SET_OPTIONAL( INTERNET_STATUS_DETECTING_PROXY ); 5152 SET_EXPECT( INTERNET_STATUS_CONNECTING_TO_SERVER ); 5153 SET_EXPECT( INTERNET_STATUS_CONNECTED_TO_SERVER ); 5154 SET_EXPECT( INTERNET_STATUS_SENDING_REQUEST ); 5155 SET_EXPECT( INTERNET_STATUS_REQUEST_SENT ); 5156 SET_EXPECT( INTERNET_STATUS_RECEIVING_RESPONSE ); 5157 SET_EXPECT( INTERNET_STATUS_RESPONSE_RECEIVED ); 5158 SET_OPTIONAL( INTERNET_STATUS_CLOSING_CONNECTION ); 5159 SET_OPTIONAL( INTERNET_STATUS_CONNECTION_CLOSED ); 5160 SET_EXPECT( INTERNET_STATUS_REQUEST_COMPLETE ); 5161 5162 SetLastError( 0xdeadbeef ); 5163 ret = HttpSendRequestA( req, NULL, 0, NULL, 0 ); 5164 ok( !ret, "HttpSendRequestA unexpectedly succeeded\n" ); 5165 ok( GetLastError() == ERROR_IO_PENDING, "expected ERROR_IO_PENDING, got %u\n", GetLastError() ); 5166 WaitForSingleObject( complete_event, INFINITE ); 5167 ok( req_error == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", req_error ); 5168 5169 CLEAR_NOTIFIED( INTERNET_STATUS_COOKIE_SENT ); 5170 CLEAR_NOTIFIED( INTERNET_STATUS_DETECTING_PROXY ); 5171 CHECK_NOTIFIED( INTERNET_STATUS_CONNECTING_TO_SERVER ); 5172 CHECK_NOTIFIED( INTERNET_STATUS_CONNECTED_TO_SERVER ); 5173 CHECK_NOTIFIED( INTERNET_STATUS_SENDING_REQUEST ); 5174 CHECK_NOTIFIED( INTERNET_STATUS_REQUEST_SENT ); 5175 CHECK_NOTIFIED( INTERNET_STATUS_RECEIVING_RESPONSE ); 5176 CHECK_NOTIFIED( INTERNET_STATUS_RESPONSE_RECEIVED ); 5177 CLEAR_NOTIFIED( INTERNET_STATUS_CLOSING_CONNECTION ); 5178 CLEAR_NOTIFIED( INTERNET_STATUS_CONNECTION_CLOSED ); 5179 CHECK_NOTIFIED( INTERNET_STATUS_REQUEST_COMPLETE ); 5180 5181 pending_reads = 0; 5182 memset( &ib, 0, sizeof(ib) ); 5183 memset( buffer, 0, sizeof(buffer) ); 5184 ib.dwStructSize = sizeof(ib); 5185 for (count = 0; count < sizeof(buffer); count += ib.dwBufferLength) 5186 { 5187 ib.lpvBuffer = buffer + count; 5188 ib.dwBufferLength = min(16, sizeof(buffer) - count); 5189 5190 SET_EXPECT( INTERNET_STATUS_RECEIVING_RESPONSE ); 5191 SET_EXPECT( INTERNET_STATUS_RESPONSE_RECEIVED ); 5192 5193 ret = InternetReadFileExA( req, &ib, 0, 0xdeadbeef ); 5194 if (!count) /* the first part should arrive immediately */ 5195 ok( ret, "InternetReadFileExA failed %u\n", GetLastError() ); 5196 ros_skip_flaky 5197 if (!ret) 5198 { 5199 ok( GetLastError() == ERROR_IO_PENDING, "expected ERROR_IO_PENDING, got %u\n", GetLastError() ); 5200 ros_skip_flaky 5201 CHECK_NOTIFIED( INTERNET_STATUS_RECEIVING_RESPONSE ); 5202 SET_EXPECT( INTERNET_STATUS_REQUEST_COMPLETE ); 5203 if (!pending_reads++) 5204 { 5205 res = WaitForSingleObject( complete_event, 0 ); 5206 ok( res == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %u\n", res ); 5207 SetEvent( conn_wait_event ); 5208 } 5209 res = WaitForSingleObject( complete_event, INFINITE ); 5210 ok( res == WAIT_OBJECT_0, "expected WAIT_OBJECT_0, got %u\n", res ); 5211 ok( req_error == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", req_error ); 5212 todo_wine_if( pending_reads > 1 ) 5213 ok( ib.dwBufferLength != 0, "expected ib.dwBufferLength != 0\n" ); 5214 CHECK_NOTIFIED( INTERNET_STATUS_RESPONSE_RECEIVED ); 5215 CHECK_NOTIFIED( INTERNET_STATUS_REQUEST_COMPLETE ); 5216 } 5217 5218 CLEAR_NOTIFIED( INTERNET_STATUS_RECEIVING_RESPONSE ); 5219 CLEAR_NOTIFIED( INTERNET_STATUS_RESPONSE_RECEIVED ); 5220 if (!ib.dwBufferLength) break; 5221 } 5222 5223 ok( pending_reads == 1, "expected 1 pending read, got %u\n", pending_reads ); 5224 ok( !strcmp(buffer, page1), "unexpected buffer content\n" ); 5225 close_async_handle( ses, 2 ); 5226 ResetEvent( conn_wait_event ); 5227 5228 /* test asynchronous InternetReadFile */ 5229 ses = InternetOpenA( "winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, INTERNET_FLAG_ASYNC ); 5230 ok( ses != NULL, "InternetOpenA failed\n" ); 5231 pInternetSetStatusCallbackA( ses, &callback ); 5232 5233 SET_EXPECT( INTERNET_STATUS_HANDLE_CREATED ); 5234 con = InternetConnectA( ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0xdeadbeef ); 5235 ok( con != NULL, "InternetConnectA failed %u\n", GetLastError() ); 5236 CHECK_NOTIFIED( INTERNET_STATUS_HANDLE_CREATED ); 5237 5238 SET_EXPECT( INTERNET_STATUS_HANDLE_CREATED ); 5239 req = HttpOpenRequestA( con, "GET", "/async_read", NULL, NULL, NULL, INTERNET_FLAG_RELOAD, 0xdeadbeef ); 5240 ok( req != NULL, "HttpOpenRequestA failed %u\n", GetLastError() ); 5241 CHECK_NOTIFIED( INTERNET_STATUS_HANDLE_CREATED ); 5242 5243 SET_OPTIONAL( INTERNET_STATUS_COOKIE_SENT ); 5244 SET_OPTIONAL( INTERNET_STATUS_DETECTING_PROXY ); 5245 SET_EXPECT( INTERNET_STATUS_CONNECTING_TO_SERVER ); 5246 SET_EXPECT( INTERNET_STATUS_CONNECTED_TO_SERVER ); 5247 SET_EXPECT( INTERNET_STATUS_SENDING_REQUEST ); 5248 SET_EXPECT( INTERNET_STATUS_REQUEST_SENT ); 5249 SET_EXPECT( INTERNET_STATUS_RECEIVING_RESPONSE ); 5250 SET_EXPECT( INTERNET_STATUS_RESPONSE_RECEIVED ); 5251 SET_OPTIONAL( INTERNET_STATUS_CLOSING_CONNECTION ); 5252 SET_OPTIONAL( INTERNET_STATUS_CONNECTION_CLOSED ); 5253 SET_EXPECT( INTERNET_STATUS_REQUEST_COMPLETE ); 5254 5255 SetLastError( 0xdeadbeef ); 5256 ret = HttpSendRequestA( req, NULL, 0, NULL, 0 ); 5257 ok( !ret, "HttpSendRequestA unexpectedly succeeded\n" ); 5258 ok( GetLastError() == ERROR_IO_PENDING, "expected ERROR_IO_PENDING, got %u\n", GetLastError() ); 5259 WaitForSingleObject( complete_event, INFINITE ); 5260 ok( req_error == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", req_error ); 5261 5262 CLEAR_NOTIFIED( INTERNET_STATUS_COOKIE_SENT ); 5263 CLEAR_NOTIFIED( INTERNET_STATUS_DETECTING_PROXY ); 5264 CHECK_NOTIFIED( INTERNET_STATUS_CONNECTING_TO_SERVER ); 5265 CHECK_NOTIFIED( INTERNET_STATUS_CONNECTED_TO_SERVER ); 5266 CHECK_NOTIFIED( INTERNET_STATUS_SENDING_REQUEST ); 5267 CHECK_NOTIFIED( INTERNET_STATUS_REQUEST_SENT ); 5268 CHECK_NOTIFIED( INTERNET_STATUS_RECEIVING_RESPONSE ); 5269 CHECK_NOTIFIED( INTERNET_STATUS_RESPONSE_RECEIVED ); 5270 CLEAR_NOTIFIED( INTERNET_STATUS_CLOSING_CONNECTION ); 5271 CLEAR_NOTIFIED( INTERNET_STATUS_CONNECTION_CLOSED ); 5272 CHECK_NOTIFIED( INTERNET_STATUS_REQUEST_COMPLETE ); 5273 5274 pending_reads = 0; 5275 memset( buffer, 0, sizeof(buffer) ); 5276 for (count = 0; count < sizeof(buffer); count += bytes) 5277 { 5278 SET_EXPECT( INTERNET_STATUS_RECEIVING_RESPONSE ); 5279 SET_EXPECT( INTERNET_STATUS_RESPONSE_RECEIVED ); 5280 5281 bytes = 0xdeadbeef; 5282 ret = InternetReadFile( req, buffer + count, min(16, sizeof(buffer) - count), &bytes ); 5283 if (!count) /* the first part should arrive immediately */ 5284 ok( ret, "InternetReadFile failed %u\n", GetLastError() ); 5285 if (!ret) 5286 { 5287 ok( GetLastError() == ERROR_IO_PENDING, "expected ERROR_IO_PENDING, got %u\n", GetLastError() ); 5288 ok( bytes == 0, "expected 0, got %u\n", bytes ); 5289 ros_skip_flaky 5290 CHECK_NOTIFIED( INTERNET_STATUS_RECEIVING_RESPONSE ); 5291 SET_EXPECT( INTERNET_STATUS_REQUEST_COMPLETE ); 5292 if (!pending_reads++) 5293 { 5294 res = WaitForSingleObject( complete_event, 0 ); 5295 ok( res == WAIT_TIMEOUT, "expected WAIT_TIMEOUT, got %u\n", res ); 5296 SetEvent( conn_wait_event ); 5297 } 5298 res = WaitForSingleObject( complete_event, INFINITE ); 5299 ok( res == WAIT_OBJECT_0, "expected WAIT_OBJECT_0, got %u\n", res ); 5300 ok( req_error == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", req_error ); 5301 ros_skip_flaky { 5302 todo_wine_if( pending_reads > 1 ) 5303 ok( bytes != 0, "expected bytes != 0\n" ); 5304 } 5305 ros_skip_flaky 5306 CHECK_NOTIFIED( INTERNET_STATUS_RESPONSE_RECEIVED ); 5307 ros_skip_flaky 5308 CHECK_NOTIFIED( INTERNET_STATUS_REQUEST_COMPLETE ); 5309 } 5310 5311 CLEAR_NOTIFIED( INTERNET_STATUS_RECEIVING_RESPONSE ); 5312 CLEAR_NOTIFIED( INTERNET_STATUS_RESPONSE_RECEIVED ); 5313 if (!bytes) break; 5314 } 5315 5316 ros_skip_flaky 5317 ok( pending_reads == 1, "expected 1 pending read, got %u\n", pending_reads ); 5318 ok( !strcmp(buffer, page1), "unexpected buffer content\n" ); 5319 close_async_handle( ses, 2 ); 5320 } 5321 5322 static void server_send_string(const char *msg) 5323 { 5324 send(server_socket, msg, strlen(msg), 0); 5325 } 5326 5327 static size_t server_read_data(char *buf, size_t buf_size) 5328 { 5329 return recv(server_socket, buf, buf_size, 0); 5330 } 5331 5332 #define server_read_request(a) _server_read_request(__LINE__,a) 5333 static void _server_read_request(unsigned line, const char *expected_request) 5334 { 5335 char buf[4000], *p; 5336 size_t size; 5337 5338 size = server_read_data(buf, sizeof(buf) - 1); 5339 buf[size] = 0; 5340 p = strstr(buf, "\r\n"); 5341 if(p) *p = 0; 5342 ok_(__FILE__,line)(p && !strcmp(buf, expected_request), "unexpected request %s\n", buf); 5343 } 5344 5345 static BOOL skip_receive_notification_tests; 5346 static DWORD received_response_size; 5347 5348 static void WINAPI readex_callback(HINTERNET handle, DWORD_PTR context, DWORD status, void *info, DWORD info_size) 5349 { 5350 switch(status) { 5351 case INTERNET_STATUS_RECEIVING_RESPONSE: 5352 if(!skip_receive_notification_tests) 5353 callback(handle, context, status, info, info_size); 5354 break; 5355 case INTERNET_STATUS_RESPONSE_RECEIVED: 5356 if(!skip_receive_notification_tests) 5357 callback(handle, context, status, info, info_size); 5358 received_response_size = *(DWORD*)info; 5359 break; 5360 case INTERNET_STATUS_REQUEST_SENT: 5361 callback(handle, context, status, info, info_size); 5362 SetEvent(request_sent_event); 5363 break; 5364 default: 5365 callback(handle, context, status, info, info_size); 5366 } 5367 } 5368 5369 static void send_socket_request(test_request_t *req, BOOL new_connection) 5370 { 5371 BOOL ret; 5372 5373 SET_OPTIONAL(INTERNET_STATUS_COOKIE_SENT); 5374 SET_OPTIONAL(INTERNET_STATUS_DETECTING_PROXY); 5375 if(new_connection) { 5376 SET_EXPECT(INTERNET_STATUS_CONNECTING_TO_SERVER); 5377 SET_EXPECT(INTERNET_STATUS_CONNECTED_TO_SERVER); 5378 } 5379 SET_EXPECT(INTERNET_STATUS_SENDING_REQUEST); 5380 SET_EXPECT(INTERNET_STATUS_REQUEST_SENT); 5381 if(!skip_receive_notification_tests) 5382 SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE); 5383 5384 SetLastError(0xdeadbeef); 5385 ret = HttpSendRequestA(req->request, NULL, 0, NULL, 0); 5386 ok(!ret, "HttpSendRequestA unexpectedly succeeded\n"); 5387 ok(GetLastError() == ERROR_IO_PENDING, "expected ERROR_IO_PENDING, got %u\n", GetLastError()); 5388 5389 if(new_connection) 5390 WaitForSingleObject(server_req_rec_event, INFINITE); 5391 WaitForSingleObject(request_sent_event, INFINITE); 5392 5393 CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_SENT); 5394 CLEAR_NOTIFIED(INTERNET_STATUS_DETECTING_PROXY); 5395 if(new_connection) { 5396 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTING_TO_SERVER); 5397 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTED_TO_SERVER); 5398 } 5399 CHECK_NOTIFIED(INTERNET_STATUS_SENDING_REQUEST); 5400 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_SENT); 5401 } 5402 5403 static void open_socket_request(int port, test_request_t *req, const char *verb) 5404 { 5405 /* We're connecting to new socket */ 5406 if(!verb) 5407 reset_events(); 5408 5409 req->session = InternetOpenA("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, INTERNET_FLAG_ASYNC); 5410 ok(req->session != NULL, "InternetOpenA failed\n"); 5411 pInternetSetStatusCallbackA(req->session, readex_callback); 5412 5413 SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED); 5414 req->connection = InternetConnectA(req->session, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0xdeadbeef); 5415 ok(req->connection != NULL, "InternetConnectA failed %u\n", GetLastError()); 5416 CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED ); 5417 5418 SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED); 5419 req->request = HttpOpenRequestA(req->connection, "GET", verb ? verb : "/socket", 5420 NULL, NULL, NULL, INTERNET_FLAG_RELOAD, 0xdeadbeef); 5421 ok(req->request != NULL, "HttpOpenRequestA failed %u\n", GetLastError()); 5422 CHECK_NOTIFIED( INTERNET_STATUS_HANDLE_CREATED ); 5423 5424 send_socket_request(req, !verb); 5425 } 5426 5427 static void open_read_test_request(int port, test_request_t *req, const char *response) 5428 { 5429 if(!skip_receive_notification_tests) 5430 SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE); 5431 5432 open_socket_request(port, req, NULL); 5433 5434 if(!skip_receive_notification_tests) { 5435 SET_EXPECT(INTERNET_STATUS_RESPONSE_RECEIVED); 5436 received_response_size = 0xdeadbeef; 5437 } 5438 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 5439 5440 server_send_string(response); 5441 WaitForSingleObject(complete_event, INFINITE); 5442 5443 if(!skip_receive_notification_tests) { 5444 CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 5445 CHECK_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED); 5446 todo_wine 5447 ok(received_response_size == strlen(response), "received_response_size = %u\n", received_response_size); 5448 } 5449 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 5450 ok(req_error == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", req_error); 5451 } 5452 5453 #define readex_expect_sync_data_len(a,b,c,d,e,f,g) _readex_expect_sync_data_len(__LINE__,a,b,c,d,e,f,g) 5454 static void _readex_expect_sync_data_len(unsigned line, HINTERNET req, DWORD flags, INTERNET_BUFFERSW *buf, 5455 DWORD buf_size, const char *exdata, DWORD len, DWORD expect_receive) 5456 { 5457 BOOL ret; 5458 5459 if(!skip_receive_notification_tests && expect_receive) { 5460 SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE); 5461 SET_EXPECT(INTERNET_STATUS_RESPONSE_RECEIVED); 5462 received_response_size = 0xdeadbeef; 5463 } 5464 5465 memset(buf->lpvBuffer, 0xff, buf_size); 5466 buf->dwBufferLength = buf_size; 5467 ret = InternetReadFileExW(req, buf, flags, 0xdeadbeef); 5468 ok_(__FILE__,line)(ret, "InternetReadFileExW failed: %u\n", GetLastError()); 5469 ok_(__FILE__,line)(buf->dwBufferLength == len, "dwBufferLength = %u, expected %u\n", buf->dwBufferLength, len); 5470 if(len && exdata) 5471 ok_(__FILE__,line)(!memcmp(buf->lpvBuffer, exdata, len), "Unexpected data\n"); 5472 5473 if(!skip_receive_notification_tests && expect_receive) { 5474 CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 5475 CHECK_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED); 5476 ok_(__FILE__,line)(received_response_size == len, "received_response_size = %u\n", received_response_size); 5477 } 5478 } 5479 5480 #define readex_expect_sync_data(a,b,c,d,e,f) _readex_expect_sync_data(__LINE__,a,b,c,d,e,f) 5481 static void _readex_expect_sync_data(unsigned line, HINTERNET req, DWORD flags, INTERNET_BUFFERSW *buf, 5482 DWORD buf_size, const char *exdata, DWORD expect_receive) 5483 { 5484 _readex_expect_sync_data_len(line, req, flags, buf, buf_size, exdata, strlen(exdata), expect_receive); 5485 } 5486 5487 #define read_expect_sync_data_len(a,b,c,d,e) _read_expect_sync_data_len(__LINE__,a,b,c,d,e) 5488 static void _read_expect_sync_data_len(unsigned line, HINTERNET req, void *buf, DWORD buf_size, 5489 const char *exdata, DWORD len) 5490 { 5491 DWORD ret_size = 0xdeadbeef; 5492 BOOL ret; 5493 5494 SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE); 5495 SET_EXPECT(INTERNET_STATUS_RESPONSE_RECEIVED); 5496 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 5497 received_response_size = 0xdeadbeef; 5498 5499 memset(buf, 0xff, buf_size); 5500 ret = InternetReadFile(req, buf, buf_size, &ret_size); 5501 ok_(__FILE__,line)(ret, "InternetReadFileExW failed: %u\n", GetLastError()); 5502 ok_(__FILE__,line)(ret_size == len, "dwBufferLength = %u, expected %u\n", ret_size, len); 5503 if(len && exdata) 5504 ok_(__FILE__,line)(!memcmp(buf, exdata, len), "Unexpected data\n"); 5505 5506 CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 5507 CHECK_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED); 5508 CLEAR_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 5509 ok_(__FILE__,line)(received_response_size == len, "received_response_size = %u\n", received_response_size); 5510 ok_(__FILE__,line)(!req_error, "req_error = %u\n", req_error); 5511 } 5512 5513 #define read_expect_sync_data(a,b,c,d) _read_expect_sync_data(__LINE__,a,b,c,d) 5514 static void _read_expect_sync_data(unsigned line, HINTERNET req, void *buf, 5515 DWORD buf_size, const char *exdata) 5516 { 5517 _read_expect_sync_data_len(line, req, buf, buf_size, exdata, strlen(exdata)); 5518 } 5519 5520 static void close_connection(void) 5521 { 5522 char c; 5523 SetEvent(conn_wait_event); 5524 recv(server_socket, &c, 1, 0); 5525 } 5526 5527 #define send_response_and_wait(a,b,c,d,e,f,g,h) _send_response_and_wait(__LINE__,a,b,c,d,e,f,g,h) 5528 static void _send_response_and_wait(unsigned line, const char *response, BOOL do_close_connection, 5529 void *buf, DWORD *ret_size, const char *exdata, 5530 DWORD expected_size, DWORD expected_req_error, DWORD expected_receive_size) 5531 { 5532 if(!skip_receive_notification_tests) 5533 SET_EXPECT(INTERNET_STATUS_RESPONSE_RECEIVED); 5534 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 5535 5536 if(response) 5537 server_send_string(response); 5538 5539 if(do_close_connection) 5540 close_connection(); 5541 5542 WaitForSingleObject(complete_event, INFINITE); 5543 5544 if(!skip_receive_notification_tests) 5545 CHECK_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED); 5546 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 5547 if(!skip_receive_notification_tests && expected_receive_size != -1) 5548 todo_wine_if(received_response_size != expected_receive_size) /* FIXME! remove when wine is fixed */ 5549 ok_(__FILE__,line)(received_response_size == expected_receive_size, 5550 "received_response_size = %u\n", received_response_size); 5551 ok_(__FILE__,line)(req_error == expected_req_error, "req_error = %u, expected %u\n", req_error, expected_req_error); 5552 5553 /* If IRF_NO_WAIT is used, buffer is not changed. */ 5554 ok_(__FILE__,line)(*ret_size == expected_size, "dwBufferLength = %u\n", *ret_size); 5555 if(exdata) 5556 ok_(__FILE__,line)(!memcmp(buf, exdata, strlen(exdata)), "unexpected buffer data\n"); 5557 else if(buf) 5558 ok_(__FILE__,line)(!*(DWORD*)buf, "buffer data changed\n"); 5559 } 5560 5561 #define send_response_ex_and_wait(a,b,c,d,e,f) _send_response_ex_and_wait(__LINE__,a,b,c,d,e,f) 5562 static void _send_response_ex_and_wait(unsigned line, const char *response, BOOL close_connection, 5563 INTERNET_BUFFERSW *buf, const char *exdata, DWORD expected_req_error, 5564 DWORD expected_receive_size) 5565 { 5566 _send_response_and_wait(line, response, close_connection, buf->lpvBuffer, &buf->dwBufferLength, 5567 exdata, exdata ? strlen(exdata) : buf->dwBufferLength, expected_req_error, 5568 expected_receive_size); 5569 } 5570 5571 static void send_response_len_and_wait(unsigned len, BOOL close_connection, INTERNET_BUFFERSW *buf) 5572 { 5573 char *response; 5574 5575 response = HeapAlloc(GetProcessHeap(), 0, len+1); 5576 memset(response, 'x', len); 5577 response[len] = 0; 5578 send_response_ex_and_wait(response, close_connection, buf, NULL, 0, -1); 5579 HeapFree(GetProcessHeap(), 0, response); 5580 } 5581 5582 #define readex_expect_async(a,b,c,d,e) _readex_expect_async(__LINE__,a,b,c,d,e) 5583 static void _readex_expect_async(unsigned line, HINTERNET req, DWORD flags, INTERNET_BUFFERSW *buf, 5584 DWORD buf_size, const char *exdata) 5585 { 5586 unsigned len = 0; 5587 BOOL ret; 5588 5589 if(!skip_receive_notification_tests) 5590 SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE); 5591 5592 memset(buf->lpvBuffer, 0, max(buf_size, sizeof(DWORD))); 5593 buf->dwBufferLength = buf_size; 5594 ret = InternetReadFileExW(req, buf, flags, 0xdeadbeef); 5595 ok_(__FILE__,line)(!ret && GetLastError() == ERROR_IO_PENDING, "InternetReadFileExW returned %x (%u)\n", ret, GetLastError()); 5596 ok_(__FILE__,line)(buf->dwBufferLength == buf_size, "dwBufferLength = %u, expected %u\n", buf->dwBufferLength, buf_size); 5597 if(exdata) { 5598 len = strlen(exdata); 5599 ok_(__FILE__,line)(!memcmp(buf->lpvBuffer, exdata, len), "unexpected buffer data\n"); 5600 }else { 5601 ok_(__FILE__,line)(!*(DWORD*)buf->lpvBuffer, "buffer data changed\n"); 5602 } 5603 5604 if(!skip_receive_notification_tests) 5605 CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 5606 } 5607 5608 static void read_expect_async(HINTERNET req, void *buf, DWORD buf_size, DWORD *ret_size, const char *exdata) 5609 { 5610 unsigned len = 0; 5611 const char *p; 5612 BOOL ret; 5613 5614 SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE); 5615 5616 *ret_size = 0xdeadbeef; 5617 memset(buf, 0, buf_size); 5618 ret = InternetReadFile(req, buf, buf_size, ret_size); 5619 ok(!ret && GetLastError() == ERROR_IO_PENDING, "InternetReadFileExW returned %x (%u)\n", ret, GetLastError()); 5620 ok(*ret_size == 0, "dwBufferLength = %u\n", *ret_size); 5621 if(exdata) { 5622 len = strlen(exdata); 5623 ok(!memcmp(buf, exdata, len), "unexpected buffer data\n"); 5624 } 5625 for(p = (const char*)buf + len; p < (const char*)buf + buf_size; p++) { 5626 if(*p) 5627 ok(0, "buffer data changed\n"); 5628 } 5629 5630 CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 5631 } 5632 5633 #define expect_data_available(a,b) _expect_data_available(__LINE__,a,b) 5634 static DWORD _expect_data_available(unsigned line, HINTERNET req, int exsize) 5635 { 5636 DWORD size = 0; 5637 BOOL res; 5638 5639 res = InternetQueryDataAvailable(req, &size, 0, 0); 5640 ok_(__FILE__,line)(res, "InternetQueryDataAvailable failed: %u\n", GetLastError()); 5641 if(exsize != -1) 5642 ok_(__FILE__,line)(size == exsize, "size = %u, expected %u\n", size, exsize); 5643 5644 return size; 5645 } 5646 5647 #define async_query_data_available(a,b) _async_query_data_available(__LINE__,a,b) 5648 static void _async_query_data_available(unsigned line, HINTERNET req, DWORD *size) 5649 { 5650 BOOL res; 5651 5652 if(!skip_receive_notification_tests) 5653 SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE); 5654 5655 *size = 0xdeadbeef; 5656 res = InternetQueryDataAvailable(req, size, 0, 0); 5657 ok_(__FILE__,line)(!res && GetLastError() == ERROR_IO_PENDING, 5658 "InternetQueryDataAvailable returned: %x(%u)\n", res, GetLastError()); 5659 ok_(__FILE__,line)(!*size, "size = %u\n", *size); 5660 5661 if(!skip_receive_notification_tests) 5662 CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 5663 } 5664 5665 static void test_http_read(int port) 5666 { 5667 INTERNET_BUFFERSW ib; 5668 test_request_t req; 5669 DWORD read_size; 5670 char buf[24000]; 5671 DWORD avail, i; 5672 5673 if(!is_ie7plus) 5674 return; 5675 5676 memset(&ib, 0, sizeof(ib)); 5677 ib.dwStructSize = sizeof(ib); 5678 ib.lpvBuffer = buf; 5679 5680 trace("Testing InternetReadFileExW with IRF_ASYNC flag...\n"); 5681 5682 open_read_test_request(port, &req, 5683 "HTTP/1.1 200 OK\r\n" 5684 "Server: winetest\r\n" 5685 "\r\n" 5686 "xx"); 5687 5688 readex_expect_async(req.request, IRF_ASYNC, &ib, 4, "xx"); 5689 5690 send_response_ex_and_wait("yy1234567890", FALSE, &ib, "xxyy", 0, 2); 5691 readex_expect_sync_data(req.request, IRF_ASYNC, &ib, 4, "1234", 4); 5692 readex_expect_sync_data(req.request, IRF_ASYNC, &ib, 5, "56789", 5); 5693 5694 readex_expect_async(req.request, IRF_ASYNC, &ib, sizeof(buf), "0"); 5695 send_response_ex_and_wait("123", TRUE, &ib, "0123", 0, 4); 5696 5697 close_async_handle(req.session, 2); 5698 5699 trace("Testing InternetReadFileExW with no flags...\n"); 5700 5701 open_read_test_request(port, &req, 5702 "HTTP/1.1 200 OK\r\n" 5703 "Server: winetest\r\n" 5704 "\r\n" 5705 "xx"); 5706 5707 readex_expect_async(req.request, 0, &ib, 4, "xx"); 5708 5709 send_response_ex_and_wait("yy1234567890", FALSE, &ib, "xxyy", 0, 2); 5710 readex_expect_sync_data(req.request, 0, &ib, 4, "1234", 4); 5711 readex_expect_sync_data(req.request, 0, &ib, 5, "56789", 5); 5712 5713 readex_expect_async(req.request, 0, &ib, sizeof(buf), "0"); 5714 send_response_ex_and_wait("123", TRUE, &ib, "0123", 0, 4); 5715 5716 close_async_handle(req.session, 2); 5717 5718 trace("Testing InternetReadFile...\n"); 5719 5720 open_read_test_request(port, &req, 5721 "HTTP/1.1 200 OK\r\n" 5722 "Server: winetest\r\n" 5723 "\r\n" 5724 "xx"); 5725 5726 read_expect_async(req.request, buf, 4, &read_size, "xx"); 5727 5728 send_response_and_wait("yy1234567890", FALSE, buf, &read_size, "xxyy", 4, 0, 2); 5729 read_expect_sync_data(req.request, buf, 4, "1234"); 5730 read_expect_sync_data(req.request, buf, 5, "56789"); 5731 5732 read_expect_async(req.request, buf, sizeof(buf), &read_size, "0"); 5733 send_response_and_wait("123", TRUE, buf, &read_size, "0123", 4, 0, 4); 5734 5735 close_async_handle(req.session, 2); 5736 5737 trace("Testing InternetReadFileExW with IRF_NO_WAIT flag...\n"); 5738 5739 open_read_test_request(port, &req, 5740 "HTTP/1.1 200 OK\r\n" 5741 "Server: winetest\r\n" 5742 "\r\n" 5743 "xx"); 5744 5745 SET_OPTIONAL(INTERNET_STATUS_RECEIVING_RESPONSE); 5746 5747 readex_expect_sync_data(req.request, IRF_NO_WAIT, &ib, sizeof(buf), "xx", 0); 5748 5749 if(notified[INTERNET_STATUS_RECEIVING_RESPONSE]) { 5750 win_skip("Skipping receive notification tests on too old Windows.\n"); 5751 skip_receive_notification_tests = TRUE; 5752 } 5753 CLEAR_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 5754 5755 readex_expect_async(req.request, IRF_NO_WAIT, &ib, sizeof(buf), NULL); 5756 send_response_ex_and_wait("1234567890", FALSE, &ib, NULL, 0, 10); 5757 readex_expect_sync_data(req.request, IRF_NO_WAIT, &ib, 5, "12345", 0); 5758 readex_expect_sync_data(req.request, IRF_NO_WAIT, &ib, sizeof(buf), "67890", 0); 5759 5760 readex_expect_async(req.request, IRF_NO_WAIT, &ib, sizeof(buf), NULL); 5761 send_response_ex_and_wait("12345", TRUE, &ib, NULL, 0, 5); 5762 5763 readex_expect_sync_data(req.request, IRF_NO_WAIT, &ib, sizeof(buf), "12345", 0); 5764 readex_expect_sync_data(req.request, IRF_NO_WAIT, &ib, sizeof(buf), "", TRUE); 5765 5766 close_async_handle(req.session, 2); 5767 5768 open_read_test_request(port, &req, 5769 "HTTP/1.1 200 OK\r\n" 5770 "Server: winetest\r\n" 5771 "Transfer-Encoding: chunked\r\n" 5772 "\r\n" 5773 "9\r\n123456789"); 5774 readex_expect_sync_data(req.request, IRF_NO_WAIT, &ib, sizeof(buf), "123456789", 0); 5775 readex_expect_async(req.request, IRF_NO_WAIT, &ib, sizeof(buf), NULL); 5776 5777 send_response_ex_and_wait("\r\n1\r\na\r\n1\r\nb\r", FALSE, &ib, NULL, 0, 13); 5778 readex_expect_sync_data(req.request, IRF_NO_WAIT, &ib, sizeof(buf), "ab", 0); 5779 readex_expect_async(req.request, IRF_NO_WAIT, &ib, sizeof(buf), NULL); 5780 5781 send_response_ex_and_wait("\n3\r\nab", FALSE, &ib, NULL, 0, 6); 5782 readex_expect_sync_data(req.request, IRF_NO_WAIT, &ib, sizeof(buf), "ab", 0); 5783 readex_expect_async(req.request, IRF_NO_WAIT, &ib, sizeof(buf), NULL); 5784 5785 send_response_ex_and_wait("c", FALSE, &ib, NULL, 0, 1); 5786 readex_expect_sync_data(req.request, IRF_NO_WAIT, &ib, sizeof(buf), "c", 0); 5787 readex_expect_async(req.request, IRF_NO_WAIT, &ib, sizeof(buf), NULL); 5788 5789 send_response_ex_and_wait("\r\n1\r\nx\r\n0\r\n\r\n", TRUE, &ib, NULL, 0, 13); 5790 readex_expect_sync_data(req.request, IRF_NO_WAIT, &ib, sizeof(buf), "x", 0); 5791 readex_expect_sync_data(req.request, IRF_NO_WAIT, &ib, sizeof(buf), "", 0); 5792 5793 close_async_handle(req.session, 2); 5794 5795 open_read_test_request(port, &req, 5796 "HTTP/1.1 200 OK\r\n" 5797 "Server: winetest\r\n" 5798 "Transfer-Encoding: chunked\r\n" 5799 "\r\n" 5800 "3\r\n123\r\n"); 5801 readex_expect_sync_data(req.request, IRF_NO_WAIT, &ib, sizeof(buf), "123", 0); 5802 readex_expect_async(req.request, IRF_NO_WAIT, &ib, sizeof(buf), NULL); 5803 5804 send_response_ex_and_wait("0\r\n\r\n", TRUE, &ib, NULL, 0, 5); 5805 readex_expect_sync_data(req.request, IRF_NO_WAIT, &ib, sizeof(buf), "", 0); 5806 5807 close_async_handle(req.session, 2); 5808 5809 open_read_test_request(port, &req, 5810 "HTTP/1.1 200 OK\r\n" 5811 "Server: winetest\r\n" 5812 "Connection: close\r\n" 5813 "\r\n"); 5814 readex_expect_async(req.request, IRF_NO_WAIT, &ib, sizeof(buf), NULL); 5815 send_response_ex_and_wait("123", TRUE, &ib, NULL, 0, 3); 5816 readex_expect_sync_data(req.request, IRF_NO_WAIT, &ib, sizeof(buf), "123", 0); 5817 5818 SET_EXPECT(INTERNET_STATUS_CLOSING_CONNECTION); 5819 SET_EXPECT(INTERNET_STATUS_CONNECTION_CLOSED); 5820 close_async_handle(req.session, 2); 5821 CHECK_NOTIFIED(INTERNET_STATUS_CLOSING_CONNECTION); 5822 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTION_CLOSED); 5823 5824 trace("Testing InternetQueryDataAvailable...\n"); 5825 5826 open_read_test_request(port, &req, 5827 "HTTP/1.1 200 OK\r\n" 5828 "Server: winetest\r\n" 5829 "\r\n" 5830 "123"); 5831 expect_data_available(req.request, 3); 5832 readex_expect_sync_data(req.request, IRF_NO_WAIT, &ib, sizeof(buf), "123", 0); 5833 readex_expect_async(req.request, IRF_NO_WAIT, &ib, sizeof(buf), NULL); 5834 5835 send_response_len_and_wait(20000, TRUE, &ib); 5836 avail = expect_data_available(req.request, -1); 5837 ok(avail < 17000, "avail = %u\n", avail); 5838 5839 SET_WINE_ALLOW(INTERNET_STATUS_CLOSING_CONNECTION); 5840 SET_WINE_ALLOW(INTERNET_STATUS_CONNECTION_CLOSED); 5841 close_async_handle(req.session, 2); 5842 todo_wine CHECK_NOT_NOTIFIED(INTERNET_STATUS_CLOSING_CONNECTION); 5843 todo_wine CHECK_NOT_NOTIFIED(INTERNET_STATUS_CONNECTION_CLOSED); 5844 5845 open_read_test_request(port, &req, 5846 "HTTP/1.1 200 OK\r\n" 5847 "Server: winetest\r\n" 5848 "Connection: close\r\n" 5849 "\r\n" 5850 "123"); 5851 5852 expect_data_available(req.request, 3); 5853 readex_expect_sync_data(req.request, 0, &ib, 3, "123", 0); 5854 5855 async_query_data_available(req.request, &read_size); 5856 send_response_and_wait("1234567890", FALSE, NULL, &read_size, NULL, 10, 10, 10); 5857 5858 readex_expect_sync_data(req.request, 0, &ib, 9, "123456789", 0); 5859 expect_data_available(req.request, 1); 5860 readex_expect_sync_data(req.request, 0, &ib, 1, "0", 0); 5861 5862 async_query_data_available(req.request, &read_size); 5863 send_response_and_wait("1234567890", FALSE, NULL, &read_size, NULL, 10, 10, 10); 5864 expect_data_available(req.request, 10); 5865 for(i = 0; i < 10; i++) 5866 server_send_string("x"); 5867 expect_data_available(req.request, 10); 5868 5869 readex_expect_async(req.request, IRF_ASYNC, &ib, 21, "1234567890"); 5870 send_response_ex_and_wait("X", FALSE, &ib, "1234567890xxxxxxxxxxX", 0, 11); 5871 async_query_data_available(req.request, &read_size); 5872 5873 SET_EXPECT(INTERNET_STATUS_CLOSING_CONNECTION); 5874 SET_EXPECT(INTERNET_STATUS_CONNECTION_CLOSED); 5875 send_response_and_wait(NULL, TRUE, NULL, &read_size, NULL, 0, 0, 0); 5876 CHECK_NOTIFIED(INTERNET_STATUS_CLOSING_CONNECTION); 5877 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTION_CLOSED); 5878 5879 close_async_handle(req.session, 2); 5880 5881 skip_receive_notification_tests = FALSE; 5882 } 5883 5884 static void test_connection_break(int port) 5885 { 5886 INTERNET_BUFFERSW ib; 5887 test_request_t req; 5888 char buf[24000]; 5889 5890 if(!is_ie7plus) 5891 return; 5892 5893 memset(&ib, 0, sizeof(ib)); 5894 ib.dwStructSize = sizeof(ib); 5895 ib.lpvBuffer = buf; 5896 5897 trace("Testing InternetReadFileExW on broken connection...\n"); 5898 5899 open_read_test_request(port, &req, 5900 "HTTP/1.1 200 OK\r\n" 5901 "Server: winetest\r\n" 5902 "Content-Length: 10000\r\n" 5903 "\r\n" 5904 "xx"); 5905 5906 /* close connection and make sure that it's closed on handle release. */ 5907 close_connection(); 5908 SET_EXPECT(INTERNET_STATUS_CLOSING_CONNECTION); 5909 SET_EXPECT(INTERNET_STATUS_CONNECTION_CLOSED); 5910 close_async_handle(req.session, 2); 5911 CHECK_NOTIFIED(INTERNET_STATUS_CLOSING_CONNECTION); 5912 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTION_CLOSED); 5913 } 5914 5915 static void test_long_url(int port) 5916 { 5917 char long_path[INTERNET_MAX_PATH_LENGTH*2] = "/echo_request?"; 5918 char buf[sizeof(long_path)*2], url[sizeof(buf)]; 5919 test_request_t req; 5920 DWORD size, len; 5921 BOOL ret; 5922 5923 if(!is_ie7plus) 5924 return; 5925 5926 memset(long_path+strlen(long_path), 'x', sizeof(long_path)-strlen(long_path)); 5927 long_path[sizeof(long_path)-1] = 0; 5928 open_simple_request(&req, "localhost", port, NULL, long_path); 5929 5930 ret = HttpSendRequestA(req.request, NULL, 0, NULL, 0); 5931 ok(ret, "HttpSendRequest failed: %u\n", GetLastError()); 5932 test_status_code(req.request, 200); 5933 5934 receive_simple_request(req.request, buf, sizeof(buf)); 5935 ok(strstr(buf, long_path) != NULL, "long pathnot found in %s\n", buf); 5936 5937 sprintf(url, "http://localhost:%u%s", port, long_path); 5938 5939 size = sizeof(buf); 5940 ret = InternetQueryOptionA(req.request, INTERNET_OPTION_URL, buf, &size); 5941 ok(ret, "InternetQueryOptionA(INTERNET_OPTION_URL) failed: %u\n", GetLastError()); 5942 len = strlen(url); 5943 ok(size == len, "size = %u, expected %u\n", size, len); 5944 ok(!strcmp(buf, url), "Wrong URL %s, expected %s\n", buf, url); 5945 5946 close_request(&req); 5947 } 5948 5949 static void test_persistent_connection(int port) 5950 { 5951 INTERNET_BUFFERSW ib; 5952 test_request_t req; 5953 char buf[24000]; 5954 5955 if(!is_ie7plus) 5956 return; 5957 5958 memset(&ib, 0, sizeof(ib)); 5959 ib.dwStructSize = sizeof(ib); 5960 ib.lpvBuffer = buf; 5961 5962 skip_receive_notification_tests = TRUE; 5963 5964 trace("Testing persistent connection...\n"); 5965 5966 open_read_test_request(port, &req, 5967 "HTTP/1.1 200 OK\r\n" 5968 "Server: winetest\r\n" 5969 "Content-Length: 2\r\n" 5970 "\r\n" 5971 "xx"); 5972 readex_expect_sync_data(req.request, IRF_ASYNC, &ib, 4, "xx", 0); 5973 close_async_handle(req.session, 2); 5974 5975 open_socket_request(port, &req, "/test_simple_chunked"); 5976 server_read_request("GET /test_simple_chunked HTTP/1.1"); 5977 5978 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 5979 server_send_string("HTTP/1.1 200 OK\r\n" 5980 "Server: winetest\r\n" 5981 "Transfer-Encoding: chunked\r\n" 5982 "\r\n" 5983 "2\r\nab\r\n"); 5984 WaitForSingleObject(complete_event, INFINITE); 5985 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 5986 ok(req_error == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", req_error); 5987 5988 readex_expect_sync_data(req.request, IRF_NO_WAIT, &ib, sizeof(buf), "ab", 0); 5989 readex_expect_async(req.request, IRF_ASYNC, &ib, sizeof(buf), NULL); 5990 send_response_ex_and_wait("3\r\nabc\r\n0\r\n\r\n", FALSE, &ib, "abc", 0, 13); 5991 close_async_handle(req.session, 2); 5992 5993 open_socket_request(port, &req, "/chunked"); 5994 server_read_request("GET /chunked HTTP/1.1"); 5995 5996 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 5997 server_send_string("HTTP/1.1 200 OK\r\n" 5998 "Server: winetest\r\n" 5999 "Transfer-Encoding: chunked\r\n" 6000 "\r\n" 6001 "2\r\nab\r\n"); 6002 WaitForSingleObject(complete_event, INFINITE); 6003 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 6004 ok(req_error == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", req_error); 6005 6006 readex_expect_sync_data(req.request, IRF_NO_WAIT, &ib, 3, "ab", 0); 6007 readex_expect_async(req.request, IRF_ASYNC, &ib, 3, NULL); 6008 send_response_ex_and_wait("3\r\nabc\r\n", FALSE, &ib, "abc", 0, 13); 6009 6010 /* send another request on the same request handle, it must drain remaining last chunk marker */ 6011 server_send_string("0\r\n\r\n"); 6012 6013 send_socket_request(&req, FALSE); 6014 server_read_request("GET /chunked HTTP/1.1"); 6015 6016 ResetEvent(complete_event); 6017 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 6018 server_send_string("HTTP/1.1 201 OK\r\n" 6019 "Server: winetest\r\n" 6020 "Content-Length: 0\r\n" 6021 "Connection: keep-alive\r\n" 6022 "\r\n"); 6023 WaitForSingleObject(complete_event, INFINITE); 6024 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 6025 ok(req_error == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", req_error); 6026 6027 test_status_code(req.request, 201); 6028 close_async_handle(req.session, 2); 6029 6030 /* the connection is still valid */ 6031 open_socket_request(port, &req, "/another_chunked"); 6032 server_read_request("GET /another_chunked HTTP/1.1"); 6033 6034 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 6035 server_send_string("HTTP/1.1 200 OK\r\n" 6036 "Server: winetest\r\n" 6037 "Transfer-Encoding: chunked\r\n" 6038 "\r\n" 6039 "2\r\nab\r\n"); 6040 WaitForSingleObject(complete_event, INFINITE); 6041 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 6042 ok(req_error == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", req_error); 6043 6044 readex_expect_sync_data(req.request, IRF_NO_WAIT, &ib, sizeof(buf), "ab", 0); 6045 readex_expect_async(req.request, IRF_ASYNC, &ib, sizeof(buf), NULL); 6046 6047 /* we're missing trailing '\n'; the connection can't be drained without blocking, 6048 * so it will be closed */ 6049 send_response_ex_and_wait("3\r\nabc\r\n0\r\n\r", FALSE, &ib, "abc", 0, 13); 6050 6051 SET_EXPECT(INTERNET_STATUS_CLOSING_CONNECTION); 6052 SET_EXPECT(INTERNET_STATUS_CONNECTION_CLOSED); 6053 close_async_handle(req.session, 2); 6054 CHECK_NOTIFIED(INTERNET_STATUS_CLOSING_CONNECTION); 6055 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTION_CLOSED); 6056 6057 close_connection(); 6058 skip_receive_notification_tests = FALSE; 6059 } 6060 6061 static void test_redirect(int port) 6062 { 6063 char buf[4000], expect_url[INTERNET_MAX_URL_LENGTH]; 6064 INTERNET_BUFFERSW ib; 6065 test_request_t req; 6066 6067 if(!is_ie7plus) 6068 return; 6069 6070 skip_receive_notification_tests = TRUE; 6071 6072 memset(&ib, 0, sizeof(ib)); 6073 ib.dwStructSize = sizeof(ib); 6074 ib.lpvBuffer = buf; 6075 6076 trace("Testing redirection...\n"); 6077 6078 open_socket_request(port, &req, NULL); 6079 6080 SET_OPTIONAL(INTERNET_STATUS_COOKIE_SENT); 6081 SET_EXPECT(INTERNET_STATUS_REDIRECT); 6082 SET_EXPECT(INTERNET_STATUS_SENDING_REQUEST); 6083 SET_EXPECT(INTERNET_STATUS_REQUEST_SENT); 6084 6085 server_send_string("HTTP/1.1 302 Found\r\n" 6086 "Server: winetest\r\n" 6087 "Location: test_redirection\r\n" 6088 "Connection: keep-alive\r\n" 6089 "Content-Length: 0\r\n" 6090 "\r\n"); 6091 6092 server_read_request("GET /test_redirection HTTP/1.1"); 6093 6094 CHECK_NOTIFIED(INTERNET_STATUS_SENDING_REQUEST); 6095 6096 sprintf(expect_url, "http://localhost:%u/test_redirection", port); 6097 test_request_url(req.request, expect_url); 6098 6099 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 6100 6101 server_send_string("HTTP/1.1 200 OK\r\n" 6102 "Server: winetest\r\n" 6103 "Content-Length: 3\r\n" 6104 "\r\n" 6105 "xxx"); 6106 6107 WaitForSingleObject(complete_event, INFINITE); 6108 6109 CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_SENT); 6110 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_SENT); 6111 CHECK_NOTIFIED(INTERNET_STATUS_REDIRECT); 6112 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 6113 ok(req_error == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", req_error); 6114 6115 test_status_code(req.request, 200); 6116 6117 close_connection(); 6118 close_async_handle(req.session, 2); 6119 6120 trace("Test redirect to non-http URL...\n"); 6121 6122 open_socket_request(port, &req, NULL); 6123 6124 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 6125 6126 server_send_string("HTTP/1.1 302 Found\r\n" 6127 "Server: winetest\r\n" 6128 "Location: test:non:http/url\r\n" 6129 "Connection: keep-alive\r\n" 6130 "Content-Length: 0\r\n" 6131 "\r\n"); 6132 6133 WaitForSingleObject(complete_event, INFINITE); 6134 6135 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 6136 ok(req_error == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", req_error); 6137 6138 sprintf(expect_url, "http://localhost:%u/socket", port); 6139 test_request_url(req.request, expect_url); 6140 test_status_code(req.request, 302); 6141 6142 close_connection(); 6143 close_async_handle(req.session, 2); 6144 6145 trace("Test redirect to http URL with no host name...\n"); 6146 6147 open_socket_request(port, &req, NULL); 6148 6149 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 6150 6151 server_send_string("HTTP/1.1 302 Found\r\n" 6152 "Server: winetest\r\n" 6153 "Location: http:///nohost\r\n" 6154 "Connection: keep-alive\r\n" 6155 "Content-Length: 0\r\n" 6156 "\r\n"); 6157 6158 WaitForSingleObject(complete_event, INFINITE); 6159 6160 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 6161 ok(req_error == ERROR_INTERNET_INVALID_URL, "expected ERROR_INTERNET_INVALID_URL, got %u\n", req_error); 6162 6163 sprintf(expect_url, "http://localhost:%u/socket", port); 6164 test_request_url(req.request, expect_url); 6165 test_status_code(req.request, 302); 6166 6167 close_connection(); 6168 close_async_handle(req.session, 2); 6169 6170 skip_receive_notification_tests = FALSE; 6171 } 6172 6173 static void test_remove_dot_segments(int port) 6174 { 6175 test_request_t req; 6176 BOOL ret; 6177 6178 open_simple_request(&req, "localhost", port, NULL, "/A/../B/./C/../../test_remove_dot_segments"); 6179 6180 ret = HttpSendRequestA(req.request, NULL, 0, NULL, 0); 6181 ok(ret, "HttpSendRequest failed: %u\n", GetLastError()); 6182 test_status_code(req.request, 200); 6183 6184 close_request(&req); 6185 } 6186 6187 struct large_test 6188 { 6189 DWORD64 content_length; 6190 BOOL ret; 6191 }; 6192 6193 static void test_large_content(int port) 6194 { 6195 struct large_test tests[] = { 6196 { 0, TRUE }, 6197 { UINT_MAX-1, TRUE }, 6198 { UINT_MAX, TRUE }, 6199 { (DWORD64)UINT_MAX+1, FALSE }, 6200 { ~0, FALSE }, 6201 }; 6202 test_request_t req; 6203 DWORD sizelen, len; 6204 DWORD read_size; 6205 DWORD64 len64; 6206 char buf[16]; 6207 BOOL ret; 6208 size_t i; 6209 6210 open_simple_request(&req, "localhost", port, "HEAD", "/test_large_content"); 6211 6212 for (i = 0; i < ARRAY_SIZE(tests); i++) 6213 { 6214 content_length = tests[i].content_length; 6215 ret = HttpSendRequestA(req.request, NULL, 0, NULL, 0); 6216 ok(ret, "HttpSendRequest failed: %u\n", GetLastError()); 6217 6218 len = ~0; 6219 sizelen = sizeof(len); 6220 SetLastError(0xdeadbeef); 6221 ret = HttpQueryInfoA(req.request, HTTP_QUERY_FLAG_NUMBER|HTTP_QUERY_CONTENT_LENGTH, 6222 &len, &sizelen, 0); 6223 if (tests[i].ret) 6224 { 6225 ok(ret, "HttpQueryInfo should have succeeded\n"); 6226 ok(GetLastError() == ERROR_SUCCESS || 6227 broken(GetLastError() == 0xdeadbeef), /* xp, 2k8, vista */ 6228 "expected ERROR_SUCCESS, got %x\n", GetLastError()); 6229 ok(len == (DWORD)tests[i].content_length, "expected %u, got %u\n", 6230 (DWORD)tests[i].content_length, len); 6231 } 6232 else 6233 { 6234 ok(!ret, "HttpQueryInfo should have failed\n"); 6235 ok(GetLastError() == ERROR_HTTP_INVALID_HEADER, 6236 "expected ERROR_HTTP_INVALID_HEADER, got %x\n", GetLastError()); 6237 ok(len == ~0, "expected ~0, got %u\n", len); 6238 } 6239 ok(sizelen == sizeof(DWORD), "sizelen %u\n", sizelen); 6240 } 6241 6242 /* test argument size */ 6243 len64 = ~0; 6244 sizelen = sizeof(len64); 6245 SetLastError(0xdeadbeef); 6246 ret = HttpQueryInfoA(req.request, HTTP_QUERY_FLAG_NUMBER|HTTP_QUERY_CONTENT_LENGTH, 6247 &len64, &len, 0); 6248 ok(!ret, "HttpQueryInfo should have failed\n"); 6249 ok(GetLastError() == ERROR_HTTP_INVALID_HEADER, 6250 "expected ERROR_HTTP_INVALID_HEADER, got %x\n", GetLastError()); 6251 ok(sizelen == sizeof(DWORD64), "sizelen %u\n", sizelen); 6252 ok(len64 == ~0, "len64 %x%08x\n", (DWORD)(len64 >> 32), (DWORD)len64); 6253 6254 close_request(&req); 6255 6256 /* test internal use of HttpQueryInfo on large size */ 6257 open_read_test_request(port, &req, 6258 "HTTP/1.1 200 OK\r\n" 6259 "Server: winetest\r\n" 6260 "Content-Length: 4294967296\r\n" 6261 "\r\n" 6262 "xx"); 6263 read_expect_async(req.request, buf, 4, &read_size, "xx"); 6264 send_response_and_wait("yy1234567890", FALSE, buf, &read_size, "xxyy", 4, 0, 2); 6265 read_expect_sync_data(req.request, buf, 10, "1234567890"); 6266 6267 SET_EXPECT(INTERNET_STATUS_CLOSING_CONNECTION); 6268 SET_EXPECT(INTERNET_STATUS_CONNECTION_CLOSED); 6269 close_async_handle(req.session, 2); 6270 CHECK_NOTIFIED(INTERNET_STATUS_CLOSING_CONNECTION); 6271 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTION_CLOSED); 6272 close_connection(); 6273 } 6274 6275 static void test_http_connection(void) 6276 { 6277 struct server_info si; 6278 HANDLE hThread; 6279 DWORD id = 0, r; 6280 6281 si.hEvent = CreateEventW(NULL, 0, 0, NULL); 6282 si.port = 7531; 6283 6284 hThread = CreateThread(NULL, 0, server_thread, &si, 0, &id); 6285 ok( hThread != NULL, "create thread failed\n"); 6286 6287 r = WaitForSingleObject(si.hEvent, 10000); 6288 ok (r == WAIT_OBJECT_0, "failed to start wininet test server\n"); 6289 if (r != WAIT_OBJECT_0) 6290 { 6291 CloseHandle(hThread); 6292 return; 6293 } 6294 6295 test_basic_request(si.port, "GET", "/test1"); 6296 test_proxy_indirect(si.port); 6297 test_proxy_direct(si.port); 6298 test_header_handling_order(si.port); 6299 test_basic_request(si.port, "POST", "/test5"); 6300 test_basic_request(si.port, "RPC_IN_DATA", "/test5"); 6301 test_basic_request(si.port, "RPC_OUT_DATA", "/test5"); 6302 test_basic_request(si.port, "GET", "/test6"); 6303 test_basic_request(si.port, "GET", "/testF"); 6304 test_connection_header(si.port); 6305 test_header_override(si.port); 6306 test_cookie_header(si.port); 6307 test_basic_authentication(si.port); 6308 test_invalid_response_headers(si.port); 6309 test_response_without_headers(si.port); 6310 test_HttpQueryInfo(si.port); 6311 test_HttpSendRequestW(si.port); 6312 test_options(si.port); 6313 test_no_content(si.port); 6314 test_conn_close(si.port); 6315 test_no_cache(si.port); 6316 test_cache_read_gzipped(si.port); 6317 test_http_status(si.port); 6318 test_premature_disconnect(si.port); 6319 test_connection_closing(si.port); 6320 test_cache_control_verb(si.port); 6321 test_successive_HttpSendRequest(si.port); 6322 test_head_request(si.port); 6323 test_request_content_length(si.port); 6324 test_accept_encoding(si.port); 6325 test_basic_auth_credentials_reuse(si.port); 6326 test_basic_auth_credentials_end_session(si.port); 6327 test_basic_auth_credentials_different(si.port); 6328 test_basic_auth_credentials_manual(si.port); 6329 test_basic_auth_credentials_cached_manual(si.port); 6330 test_async_read(si.port); 6331 test_http_read(si.port); 6332 test_connection_break(si.port); 6333 test_long_url(si.port); 6334 #ifdef __REACTOS__ 6335 if (!winetest_interactive) 6336 { 6337 skip("Skipping test_redirect and test_persistent_connection due to hang. See ROSTESTS-294.\n"); 6338 } 6339 else 6340 { 6341 #endif 6342 test_redirect(si.port); 6343 test_persistent_connection(si.port); 6344 #ifdef __REACTOS__ 6345 } 6346 #endif 6347 test_remove_dot_segments(si.port); 6348 test_large_content(si.port); 6349 6350 /* send the basic request again to shutdown the server thread */ 6351 test_basic_request(si.port, "GET", "/quit"); 6352 6353 r = WaitForSingleObject(hThread, 3000); 6354 ok( r == WAIT_OBJECT_0, "thread wait failed\n"); 6355 CloseHandle(hThread); 6356 } 6357 6358 static void release_cert_info(INTERNET_CERTIFICATE_INFOA *info) 6359 { 6360 LocalFree(info->lpszSubjectInfo); 6361 LocalFree(info->lpszIssuerInfo); 6362 LocalFree(info->lpszProtocolName); 6363 LocalFree(info->lpszSignatureAlgName); 6364 LocalFree(info->lpszEncryptionAlgName); 6365 } 6366 6367 typedef struct { 6368 const char *ex_subject; 6369 const char *ex_issuer; 6370 } cert_struct_test_t; 6371 6372 static const cert_struct_test_t test_winehq_org_cert = { 6373 "US\r\n" 6374 "55114\r\n" 6375 "MN\r\n" 6376 "Saint Paul\r\n" 6377 "Ste 120\r\n" 6378 "700 Raymond Ave\r\n" 6379 "CodeWeavers\r\n" 6380 "IT\r\n" 6381 "Secure Link SSL Wildcard\r\n" 6382 "*.winehq.org", 6383 6384 "US\r\n" 6385 "VA\r\n" 6386 "Herndon\r\n" 6387 "Network Solutions L.L.C.\r\n" 6388 "Network Solutions OV Server CA 2" 6389 }; 6390 6391 static const cert_struct_test_t test_winehq_com_cert = { 6392 "US\r\n" 6393 "Minnesota\r\n" 6394 "Saint Paul\r\n" 6395 "WineHQ\r\n" 6396 "IT\r\n" 6397 "test.winehq.com\r\n" 6398 "webmaster@winehq.org", 6399 6400 "US\r\n" 6401 "Minnesota\r\n" 6402 "Saint Paul\r\n" 6403 "WineHQ\r\n" 6404 "IT\r\n" 6405 "test.winehq.com\r\n" 6406 "webmaster@winehq.org" 6407 }; 6408 6409 static void test_cert_struct(HINTERNET req, const cert_struct_test_t *test) 6410 { 6411 INTERNET_CERTIFICATE_INFOA info; 6412 DWORD size; 6413 BOOL res; 6414 6415 memset(&info, 0x5, sizeof(info)); 6416 6417 size = sizeof(info); 6418 res = InternetQueryOptionA(req, INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT, &info, &size); 6419 if (!res) 6420 { 6421 win_skip("Querying INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT failed, skipping tests\n"); 6422 return; 6423 } 6424 6425 ok(res, "InternetQueryOption failed: %u\n", GetLastError()); 6426 ok(size == sizeof(info), "size = %u\n", size); 6427 6428 ok(!strcmp(info.lpszSubjectInfo, test->ex_subject), "lpszSubjectInfo = %s\n", info.lpszSubjectInfo); 6429 ok(!strcmp(info.lpszIssuerInfo, test->ex_issuer), "lpszIssuerInfo = %s\n", info.lpszIssuerInfo); 6430 ok(!info.lpszSignatureAlgName, "lpszSignatureAlgName = %s\n", info.lpszSignatureAlgName); 6431 ok(!info.lpszEncryptionAlgName, "lpszEncryptionAlgName = %s\n", info.lpszEncryptionAlgName); 6432 ok(!info.lpszProtocolName, "lpszProtocolName = %s\n", info.lpszProtocolName); 6433 ok(info.dwKeySize >= 128 && info.dwKeySize <= 256, "dwKeySize = %u\n", info.dwKeySize); 6434 6435 release_cert_info(&info); 6436 } 6437 6438 #define test_security_info(a,b,c) _test_security_info(__LINE__,a,b,c) 6439 static void _test_security_info(unsigned line, const char *urlc, DWORD error, DWORD ex_flags) 6440 { 6441 char url[INTERNET_MAX_URL_LENGTH]; 6442 const CERT_CHAIN_CONTEXT *chain; 6443 DWORD flags; 6444 BOOL res; 6445 6446 if(!pInternetGetSecurityInfoByURLA) { 6447 win_skip("pInternetGetSecurityInfoByURLA not available\n"); 6448 return; 6449 } 6450 6451 strcpy(url, urlc); 6452 chain = (void*)0xdeadbeef; 6453 flags = 0xdeadbeef; 6454 res = pInternetGetSecurityInfoByURLA(url, &chain, &flags); 6455 if(error == ERROR_SUCCESS) { 6456 ok_(__FILE__,line)(res, "InternetGetSecurityInfoByURLA failed: %u\n", GetLastError()); 6457 ok_(__FILE__,line)(chain != NULL, "chain = NULL\n"); 6458 ok_(__FILE__,line)(flags == ex_flags, "flags = %x\n", flags); 6459 CertFreeCertificateChain(chain); 6460 6461 SetLastError(0xdeadbeef); 6462 res = pInternetGetSecurityInfoByURLA(url, NULL, NULL); 6463 ok_(__FILE__,line)(!res && GetLastError() == ERROR_INVALID_PARAMETER, 6464 "InternetGetSecurityInfoByURLA returned: %x(%u)\n", res, GetLastError()); 6465 6466 res = pInternetGetSecurityInfoByURLA(url, &chain, NULL); 6467 ok_(__FILE__,line)(res, "InternetGetSecurityInfoByURLA failed: %u\n", GetLastError()); 6468 CertFreeCertificateChain(chain); 6469 6470 res = pInternetGetSecurityInfoByURLA(url, NULL, &flags); 6471 ok_(__FILE__,line)(res, "InternetGetSecurityInfoByURLA failed: %u\n", GetLastError()); 6472 }else { 6473 ok_(__FILE__,line)(!res && GetLastError() == error, 6474 "InternetGetSecurityInfoByURLA returned: %x(%u), expected %u\n", res, GetLastError(), error); 6475 } 6476 } 6477 6478 #define test_secflags_option(a,b,c) _test_secflags_option(__LINE__,a,b,c) 6479 static void _test_secflags_option(unsigned line, HINTERNET req, DWORD ex_flags, DWORD opt_flags) 6480 { 6481 DWORD flags, size; 6482 BOOL res; 6483 6484 flags = 0xdeadbeef; 6485 size = sizeof(flags); 6486 res = InternetQueryOptionW(req, INTERNET_OPTION_SECURITY_FLAGS, &flags, &size); 6487 ok_(__FILE__,line)(res, "InternetQueryOptionW(INTERNET_OPTION_SECURITY_FLAGS) failed: %u\n", GetLastError()); 6488 ok_(__FILE__,line)((flags & ~opt_flags) == ex_flags, "INTERNET_OPTION_SECURITY_FLAGS flags = %x, expected %x\n", 6489 flags, ex_flags); 6490 6491 /* Option 98 is undocumented and seems to be the same as INTERNET_OPTION_SECURITY_FLAGS */ 6492 flags = 0xdeadbeef; 6493 size = sizeof(flags); 6494 res = InternetQueryOptionW(req, 98, &flags, &size); 6495 ok_(__FILE__,line)(res, "InternetQueryOptionW(98) failed: %u\n", GetLastError()); 6496 ok_(__FILE__,line)((flags & ~opt_flags) == ex_flags, "INTERNET_OPTION_SECURITY_FLAGS(98) flags = %x, expected %x\n", 6497 flags, ex_flags); 6498 } 6499 6500 #define set_secflags(a,b,c) _set_secflags(__LINE__,a,b,c) 6501 static void _set_secflags(unsigned line, HINTERNET req, BOOL use_undoc, DWORD flags) 6502 { 6503 BOOL res; 6504 6505 res = InternetSetOptionW(req, use_undoc ? 99 : INTERNET_OPTION_SECURITY_FLAGS, &flags, sizeof(flags)); 6506 ok_(__FILE__,line)(res, "InternetSetOption(INTERNET_OPTION_SECURITY_FLAGS) failed: %u\n", GetLastError()); 6507 } 6508 6509 static void test_security_flags(void) 6510 { 6511 INTERNET_CERTIFICATE_INFOA *cert; 6512 HINTERNET ses, conn, req; 6513 DWORD size, flags; 6514 char buf[100]; 6515 BOOL res; 6516 6517 trace("Testing security flags...\n"); 6518 reset_events(); 6519 6520 ses = InternetOpenA("WineTest", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, INTERNET_FLAG_ASYNC); 6521 ok(ses != NULL, "InternetOpen failed\n"); 6522 6523 pInternetSetStatusCallbackA(ses, &callback); 6524 6525 SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED); 6526 conn = InternetConnectA(ses, "test.winehq.com", INTERNET_DEFAULT_HTTPS_PORT, 6527 NULL, NULL, INTERNET_SERVICE_HTTP, INTERNET_FLAG_SECURE, 0xdeadbeef); 6528 ok(conn != NULL, "InternetConnect failed with error %u\n", GetLastError()); 6529 CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED); 6530 6531 SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED); 6532 req = HttpOpenRequestA(conn, "GET", "/tests/hello.html", NULL, NULL, NULL, 6533 INTERNET_FLAG_SECURE|INTERNET_FLAG_KEEP_CONNECTION|INTERNET_FLAG_RELOAD|INTERNET_FLAG_NO_CACHE_WRITE, 6534 0xdeadbeef); 6535 ok(req != NULL, "HttpOpenRequest failed\n"); 6536 CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED); 6537 6538 flags = 0xdeadbeef; 6539 size = sizeof(flags); 6540 res = InternetQueryOptionW(req, 98, &flags, &size); 6541 if(!res && GetLastError() == ERROR_INVALID_PARAMETER) { 6542 win_skip("Incomplete security flags support, skipping\n"); 6543 6544 close_async_handle(ses, 2); 6545 return; 6546 } 6547 6548 test_secflags_option(req, 0, 0); 6549 test_security_info("https://test.winehq.com/data/some_file.html?q", ERROR_INTERNET_ITEM_NOT_FOUND, 0); 6550 6551 set_secflags(req, TRUE, SECURITY_FLAG_IGNORE_REVOCATION); 6552 test_secflags_option(req, SECURITY_FLAG_IGNORE_REVOCATION, 0); 6553 6554 set_secflags(req, TRUE, SECURITY_FLAG_IGNORE_CERT_CN_INVALID); 6555 test_secflags_option(req, SECURITY_FLAG_IGNORE_REVOCATION|SECURITY_FLAG_IGNORE_CERT_CN_INVALID, 0); 6556 6557 set_secflags(req, FALSE, SECURITY_FLAG_IGNORE_UNKNOWN_CA); 6558 test_secflags_option(req, SECURITY_FLAG_IGNORE_UNKNOWN_CA|SECURITY_FLAG_IGNORE_REVOCATION|SECURITY_FLAG_IGNORE_CERT_CN_INVALID, 0); 6559 6560 flags = SECURITY_FLAG_IGNORE_CERT_CN_INVALID|SECURITY_FLAG_SECURE; 6561 res = InternetSetOptionW(req, 99, &flags, sizeof(flags)); 6562 ok(!res && GetLastError() == ERROR_INTERNET_OPTION_NOT_SETTABLE, "InternetSetOption(99) failed: %u\n", GetLastError()); 6563 6564 SET_EXPECT(INTERNET_STATUS_RESOLVING_NAME); 6565 SET_EXPECT(INTERNET_STATUS_NAME_RESOLVED); 6566 SET_EXPECT(INTERNET_STATUS_CONNECTING_TO_SERVER); 6567 SET_EXPECT(INTERNET_STATUS_CONNECTED_TO_SERVER); 6568 SET_OPTIONAL(INTERNET_STATUS_CLOSING_CONNECTION); /* IE11 calls it, it probably reconnects. */ 6569 SET_OPTIONAL(INTERNET_STATUS_CONNECTION_CLOSED); /* IE11 */ 6570 SET_OPTIONAL(INTERNET_STATUS_CONNECTING_TO_SERVER); /* IE11 */ 6571 SET_OPTIONAL(INTERNET_STATUS_CONNECTED_TO_SERVER); /* IE11 */ 6572 SET_EXPECT(INTERNET_STATUS_SENDING_REQUEST); 6573 SET_EXPECT(INTERNET_STATUS_REQUEST_SENT); 6574 SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE); 6575 SET_EXPECT(INTERNET_STATUS_RESPONSE_RECEIVED); 6576 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 6577 SET_OPTIONAL(INTERNET_STATUS_DETECTING_PROXY); 6578 SET_OPTIONAL(INTERNET_STATUS_COOKIE_SENT); 6579 6580 res = HttpSendRequestA(req, NULL, 0, NULL, 0); 6581 ok(!res && GetLastError() == ERROR_IO_PENDING, "HttpSendRequest failed: %u\n", GetLastError()); 6582 6583 WaitForSingleObject(complete_event, INFINITE); 6584 ok(req_error == ERROR_SUCCESS, "req_error = %d\n", req_error); 6585 6586 CHECK_NOTIFIED(INTERNET_STATUS_RESOLVING_NAME); 6587 CHECK_NOTIFIED(INTERNET_STATUS_NAME_RESOLVED); 6588 CHECK_NOTIFIED2(INTERNET_STATUS_CONNECTING_TO_SERVER, 2); 6589 CHECK_NOTIFIED2(INTERNET_STATUS_CONNECTED_TO_SERVER, 2); 6590 CHECK_NOTIFIED(INTERNET_STATUS_CLOSING_CONNECTION); 6591 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTION_CLOSED); 6592 CHECK_NOTIFIED(INTERNET_STATUS_SENDING_REQUEST); 6593 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_SENT); 6594 CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 6595 CHECK_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED); 6596 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 6597 CLEAR_NOTIFIED(INTERNET_STATUS_DETECTING_PROXY); 6598 CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_SENT); 6599 6600 test_request_flags(req, 0); 6601 test_secflags_option(req, SECURITY_FLAG_SECURE|SECURITY_FLAG_IGNORE_UNKNOWN_CA 6602 |SECURITY_FLAG_IGNORE_REVOCATION|SECURITY_FLAG_IGNORE_CERT_CN_INVALID|SECURITY_FLAG_STRENGTH_STRONG, 0); 6603 6604 res = InternetReadFile(req, buf, sizeof(buf), &size); 6605 ok(res, "InternetReadFile failed: %u\n", GetLastError()); 6606 ok(size, "size = 0\n"); 6607 6608 /* Collect all existing persistent connections */ 6609 res = InternetSetOptionA(NULL, INTERNET_OPTION_SETTINGS_CHANGED, NULL, 0); 6610 ok(res, "InternetSetOption(INTERNET_OPTION_END_BROWSER_SESSION) failed: %u\n", GetLastError()); 6611 6612 SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED); 6613 req = HttpOpenRequestA(conn, "GET", "/tests/hello.html", NULL, NULL, NULL, 6614 INTERNET_FLAG_SECURE|INTERNET_FLAG_KEEP_CONNECTION|INTERNET_FLAG_RELOAD|INTERNET_FLAG_NO_CACHE_WRITE, 6615 0xdeadbeef); 6616 ok(req != NULL, "HttpOpenRequest failed\n"); 6617 CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED); 6618 6619 flags = INTERNET_ERROR_MASK_COMBINED_SEC_CERT|INTERNET_ERROR_MASK_LOGIN_FAILURE_DISPLAY_ENTITY_BODY; 6620 res = InternetSetOptionA(req, INTERNET_OPTION_ERROR_MASK, (void*)&flags, sizeof(flags)); 6621 ok(res, "InternetQueryOption(INTERNET_OPTION_ERROR_MASK failed: %u\n", GetLastError()); 6622 6623 SET_EXPECT(INTERNET_STATUS_CONNECTING_TO_SERVER); 6624 SET_EXPECT(INTERNET_STATUS_CONNECTED_TO_SERVER); 6625 SET_OPTIONAL(INTERNET_STATUS_CLOSING_CONNECTION); /* IE11 calls it, it probably reconnects. */ 6626 SET_OPTIONAL(INTERNET_STATUS_CONNECTION_CLOSED); /* IE11 */ 6627 SET_OPTIONAL(INTERNET_STATUS_CONNECTING_TO_SERVER); /* IE11 */ 6628 SET_OPTIONAL(INTERNET_STATUS_CONNECTED_TO_SERVER); /* IE11 */ 6629 SET_EXPECT(INTERNET_STATUS_CLOSING_CONNECTION); 6630 SET_EXPECT(INTERNET_STATUS_CONNECTION_CLOSED); 6631 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 6632 SET_OPTIONAL(INTERNET_STATUS_COOKIE_SENT); 6633 SET_OPTIONAL(INTERNET_STATUS_DETECTING_PROXY); 6634 6635 res = HttpSendRequestA(req, NULL, 0, NULL, 0); 6636 ok(!res && GetLastError() == ERROR_IO_PENDING, "HttpSendRequest failed: %u\n", GetLastError()); 6637 6638 WaitForSingleObject(complete_event, INFINITE); 6639 ok(req_error == ERROR_INTERNET_SEC_CERT_ERRORS, 6640 "req_error = %d\n", req_error); 6641 6642 size = 0; 6643 res = InternetQueryOptionW(req, INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT, NULL, &size); 6644 ok(res || GetLastError() == ERROR_INSUFFICIENT_BUFFER, "InternetQueryOption failed: %d\n", GetLastError()); 6645 ok(size == sizeof(INTERNET_CERTIFICATE_INFOA), "size = %u\n", size); 6646 cert = HeapAlloc(GetProcessHeap(), 0, size); 6647 cert->lpszSubjectInfo = NULL; 6648 cert->lpszIssuerInfo = NULL; 6649 cert->lpszSignatureAlgName = (char *)0xdeadbeef; 6650 cert->lpszEncryptionAlgName = (char *)0xdeadbeef; 6651 cert->lpszProtocolName = (char *)0xdeadbeef; 6652 cert->dwKeySize = 0xdeadbeef; 6653 res = InternetQueryOptionW(req, INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT, cert, &size); 6654 ok(res, "InternetQueryOption failed: %u\n", GetLastError()); 6655 if (res) 6656 { 6657 ok(cert->lpszSubjectInfo && strlen(cert->lpszSubjectInfo) > 1, "expected a non-empty subject name\n"); 6658 ok(cert->lpszIssuerInfo && strlen(cert->lpszIssuerInfo) > 1, "expected a non-empty issuer name\n"); 6659 ok(!cert->lpszSignatureAlgName, "unexpected signature algorithm name\n"); 6660 ok(!cert->lpszEncryptionAlgName, "unexpected encryption algorithm name\n"); 6661 ok(!cert->lpszProtocolName, "unexpected protocol name\n"); 6662 ok(cert->dwKeySize != 0xdeadbeef, "unexpected key size\n"); 6663 6664 LocalFree(cert->lpszSubjectInfo); 6665 LocalFree(cert->lpszIssuerInfo); 6666 } 6667 HeapFree(GetProcessHeap(), 0, cert); 6668 6669 ros_skip_flaky 6670 CHECK_NOTIFIED2(INTERNET_STATUS_CONNECTING_TO_SERVER, 2); 6671 CHECK_NOTIFIED2(INTERNET_STATUS_CONNECTED_TO_SERVER, 2); 6672 CHECK_NOTIFIED2(INTERNET_STATUS_CLOSING_CONNECTION, 2); 6673 CHECK_NOTIFIED2(INTERNET_STATUS_CONNECTION_CLOSED, 2); 6674 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 6675 CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_SENT); 6676 CLEAR_NOTIFIED(INTERNET_STATUS_DETECTING_PROXY); 6677 6678 if(req_error != ERROR_INTERNET_SEC_CERT_ERRORS) { 6679 win_skip("Unexpected cert errors %u, skipping security flags tests\n", req_error); 6680 6681 close_async_handle(ses, 3); 6682 return; 6683 } 6684 6685 size = sizeof(buf); 6686 res = HttpQueryInfoA(req, HTTP_QUERY_CONTENT_ENCODING, buf, &size, 0); 6687 ok(!res && GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND, "HttpQueryInfoA(HTTP_QUERY_CONTENT_ENCODING) failed: %u\n", GetLastError()); 6688 6689 test_request_flags(req, 8); 6690 /* IE11 finds both rev failure and invalid CA. Previous versions required rev failure 6691 to be ignored before invalid CA was reported. */ 6692 test_secflags_option(req, _SECURITY_FLAG_CERT_INVALID_CA, _SECURITY_FLAG_CERT_REV_FAILED); 6693 6694 set_secflags(req, FALSE, SECURITY_FLAG_IGNORE_REVOCATION); 6695 test_secflags_option(req, _SECURITY_FLAG_CERT_INVALID_CA|SECURITY_FLAG_IGNORE_REVOCATION, _SECURITY_FLAG_CERT_REV_FAILED); 6696 6697 SET_EXPECT(INTERNET_STATUS_CONNECTING_TO_SERVER); 6698 SET_EXPECT(INTERNET_STATUS_CONNECTED_TO_SERVER); 6699 SET_EXPECT(INTERNET_STATUS_CLOSING_CONNECTION); 6700 SET_EXPECT(INTERNET_STATUS_CONNECTION_CLOSED); 6701 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 6702 SET_OPTIONAL(INTERNET_STATUS_COOKIE_SENT); 6703 SET_OPTIONAL(INTERNET_STATUS_DETECTING_PROXY); 6704 6705 res = HttpSendRequestA(req, NULL, 0, NULL, 0); 6706 ok(!res && GetLastError() == ERROR_IO_PENDING, "HttpSendRequest failed: %u\n", GetLastError()); 6707 6708 WaitForSingleObject(complete_event, INFINITE); 6709 ok(req_error == ERROR_INTERNET_INVALID_CA || req_error == ERROR_INTERNET_SEC_CERT_ERRORS, "req_error = %d\n", req_error); 6710 6711 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTING_TO_SERVER); 6712 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTED_TO_SERVER); 6713 CHECK_NOTIFIED(INTERNET_STATUS_CLOSING_CONNECTION); 6714 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTION_CLOSED); 6715 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 6716 CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_SENT); 6717 CLEAR_NOTIFIED(INTERNET_STATUS_DETECTING_PROXY); 6718 6719 test_request_flags(req, INTERNET_REQFLAG_NO_HEADERS); 6720 test_secflags_option(req, SECURITY_FLAG_IGNORE_REVOCATION|_SECURITY_FLAG_CERT_INVALID_CA, 0); 6721 test_security_info("https://test.winehq.com/data/some_file.html?q", ERROR_INTERNET_ITEM_NOT_FOUND, 0); 6722 6723 set_secflags(req, FALSE, SECURITY_FLAG_IGNORE_UNKNOWN_CA); 6724 test_secflags_option(req, _SECURITY_FLAG_CERT_INVALID_CA 6725 |SECURITY_FLAG_IGNORE_REVOCATION|SECURITY_FLAG_IGNORE_UNKNOWN_CA, 0); 6726 test_http_version(req); 6727 6728 SET_EXPECT(INTERNET_STATUS_CONNECTING_TO_SERVER); 6729 SET_EXPECT(INTERNET_STATUS_CONNECTED_TO_SERVER); 6730 SET_OPTIONAL(INTERNET_STATUS_CLOSING_CONNECTION); /* IE11 calls it, it probably reconnects. */ 6731 SET_OPTIONAL(INTERNET_STATUS_CONNECTION_CLOSED); /* IE11 */ 6732 SET_OPTIONAL(INTERNET_STATUS_CONNECTING_TO_SERVER); /* IE11 */ 6733 SET_OPTIONAL(INTERNET_STATUS_CONNECTED_TO_SERVER); /* IE11 */ 6734 SET_EXPECT(INTERNET_STATUS_SENDING_REQUEST); 6735 SET_EXPECT(INTERNET_STATUS_REQUEST_SENT); 6736 SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE); 6737 SET_EXPECT(INTERNET_STATUS_RESPONSE_RECEIVED); 6738 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 6739 SET_OPTIONAL(INTERNET_STATUS_COOKIE_SENT); 6740 SET_OPTIONAL(INTERNET_STATUS_DETECTING_PROXY); 6741 6742 res = HttpSendRequestA(req, NULL, 0, NULL, 0); 6743 ok(!res && GetLastError() == ERROR_IO_PENDING, "HttpSendRequest failed: %u\n", GetLastError()); 6744 6745 WaitForSingleObject(complete_event, INFINITE); 6746 ok(req_error == ERROR_SUCCESS, "req_error = %d\n", req_error); 6747 6748 CHECK_NOTIFIED2(INTERNET_STATUS_CONNECTING_TO_SERVER, 2); 6749 CHECK_NOTIFIED2(INTERNET_STATUS_CONNECTED_TO_SERVER, 2); 6750 CHECK_NOTIFIED(INTERNET_STATUS_CLOSING_CONNECTION); 6751 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTION_CLOSED); 6752 CHECK_NOTIFIED(INTERNET_STATUS_SENDING_REQUEST); 6753 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_SENT); 6754 CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 6755 CHECK_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED); 6756 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 6757 CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_SENT); 6758 CLEAR_NOTIFIED(INTERNET_STATUS_DETECTING_PROXY); 6759 6760 test_request_flags(req, 0); 6761 test_secflags_option(req, SECURITY_FLAG_SECURE|SECURITY_FLAG_IGNORE_UNKNOWN_CA|SECURITY_FLAG_IGNORE_REVOCATION 6762 |SECURITY_FLAG_STRENGTH_STRONG|_SECURITY_FLAG_CERT_INVALID_CA, 0); 6763 6764 test_cert_struct(req, &test_winehq_com_cert); 6765 test_security_info("https://test.winehq.com/data/some_file.html?q", 0, 6766 _SECURITY_FLAG_CERT_INVALID_CA); 6767 6768 res = InternetReadFile(req, buf, sizeof(buf), &size); 6769 ok(res, "InternetReadFile failed: %u\n", GetLastError()); 6770 ok(size, "size = 0\n"); 6771 6772 close_async_handle(ses, 3); 6773 6774 /* Collect all existing persistent connections */ 6775 res = InternetSetOptionA(NULL, INTERNET_OPTION_SETTINGS_CHANGED, NULL, 0); 6776 ok(res, "InternetSetOption(INTERNET_OPTION_END_BROWSER_SESSION) failed: %u\n", GetLastError()); 6777 6778 /* Make another request, without setting security flags */ 6779 6780 ses = InternetOpenA("WineTest", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, INTERNET_FLAG_ASYNC); 6781 ok(ses != NULL, "InternetOpen failed\n"); 6782 6783 pInternetSetStatusCallbackA(ses, &callback); 6784 6785 SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED); 6786 conn = InternetConnectA(ses, "test.winehq.com", INTERNET_DEFAULT_HTTPS_PORT, 6787 NULL, NULL, INTERNET_SERVICE_HTTP, INTERNET_FLAG_SECURE, 0xdeadbeef); 6788 ok(conn != NULL, "InternetConnect failed with error %u\n", GetLastError()); 6789 CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED); 6790 6791 SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED); 6792 req = HttpOpenRequestA(conn, "GET", "/tests/hello.html", NULL, NULL, NULL, 6793 INTERNET_FLAG_SECURE|INTERNET_FLAG_KEEP_CONNECTION|INTERNET_FLAG_RELOAD|INTERNET_FLAG_NO_CACHE_WRITE, 6794 0xdeadbeef); 6795 ok(req != NULL, "HttpOpenRequest failed\n"); 6796 CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED); 6797 6798 test_secflags_option(req, SECURITY_FLAG_SECURE|SECURITY_FLAG_IGNORE_UNKNOWN_CA|SECURITY_FLAG_STRENGTH_STRONG 6799 |SECURITY_FLAG_IGNORE_REVOCATION|_SECURITY_FLAG_CERT_INVALID_CA, 0); 6800 test_http_version(req); 6801 6802 SET_EXPECT(INTERNET_STATUS_CONNECTING_TO_SERVER); 6803 SET_EXPECT(INTERNET_STATUS_CONNECTED_TO_SERVER); 6804 SET_OPTIONAL(INTERNET_STATUS_CLOSING_CONNECTION); /* IE11 calls it, it probably reconnects. */ 6805 SET_OPTIONAL(INTERNET_STATUS_CONNECTION_CLOSED); /* IE11 */ 6806 SET_OPTIONAL(INTERNET_STATUS_CONNECTING_TO_SERVER); /* IE11 */ 6807 SET_OPTIONAL(INTERNET_STATUS_CONNECTED_TO_SERVER); /* IE11 */ 6808 SET_EXPECT(INTERNET_STATUS_SENDING_REQUEST); 6809 SET_EXPECT(INTERNET_STATUS_REQUEST_SENT); 6810 SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE); 6811 SET_EXPECT(INTERNET_STATUS_RESPONSE_RECEIVED); 6812 SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE); 6813 SET_OPTIONAL(INTERNET_STATUS_COOKIE_SENT); 6814 6815 res = HttpSendRequestA(req, NULL, 0, NULL, 0); 6816 ok(!res && GetLastError() == ERROR_IO_PENDING, "HttpSendRequest failed: %u\n", GetLastError()); 6817 6818 WaitForSingleObject(complete_event, INFINITE); 6819 ok(req_error == ERROR_SUCCESS, "req_error = %d\n", req_error); 6820 6821 CHECK_NOTIFIED2(INTERNET_STATUS_CONNECTING_TO_SERVER, 2); 6822 CHECK_NOTIFIED2(INTERNET_STATUS_CONNECTED_TO_SERVER, 2); 6823 CHECK_NOTIFIED(INTERNET_STATUS_CLOSING_CONNECTION); 6824 CHECK_NOTIFIED(INTERNET_STATUS_CONNECTION_CLOSED); 6825 CHECK_NOTIFIED(INTERNET_STATUS_SENDING_REQUEST); 6826 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_SENT); 6827 CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE); 6828 CHECK_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED); 6829 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE); 6830 CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_SENT); 6831 6832 test_request_flags(req, 0); 6833 test_secflags_option(req, SECURITY_FLAG_SECURE|SECURITY_FLAG_IGNORE_UNKNOWN_CA|SECURITY_FLAG_STRENGTH_STRONG 6834 |SECURITY_FLAG_IGNORE_REVOCATION|_SECURITY_FLAG_CERT_INVALID_CA, 0); 6835 6836 res = InternetReadFile(req, buf, sizeof(buf), &size); 6837 ok(res, "InternetReadFile failed: %u\n", GetLastError()); 6838 ok(size, "size = 0\n"); 6839 6840 close_async_handle(ses, 2); 6841 6842 test_security_info("http://test.winehq.com/data/some_file.html?q", ERROR_INTERNET_ITEM_NOT_FOUND, 0); 6843 test_security_info("file:///c:/dir/file.txt", ERROR_INTERNET_ITEM_NOT_FOUND, 0); 6844 test_security_info("xxx:///c:/dir/file.txt", ERROR_INTERNET_ITEM_NOT_FOUND, 0); 6845 } 6846 6847 static void test_secure_connection(void) 6848 { 6849 static const WCHAR gizmo5[] = {'G','i','z','m','o','5',0}; 6850 static const WCHAR testsite[] = {'t','e','s','t','.','w','i','n','e','h','q','.','o','r','g',0}; 6851 static const WCHAR get[] = {'G','E','T',0}; 6852 static const WCHAR testpage[] = {'/','t','e','s','t','s','/','h','e','l','l','o','.','h','t','m','l',0}; 6853 HINTERNET ses, con, req; 6854 DWORD size, flags; 6855 INTERNET_CERTIFICATE_INFOA *certificate_structA = NULL; 6856 INTERNET_CERTIFICATE_INFOW *certificate_structW = NULL; 6857 BOOL ret; 6858 6859 ses = InternetOpenA("Gizmo5", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0); 6860 ok(ses != NULL, "InternetOpen failed\n"); 6861 6862 con = InternetConnectA(ses, "test.winehq.org", 6863 INTERNET_DEFAULT_HTTPS_PORT, NULL, NULL, 6864 INTERNET_SERVICE_HTTP, 0, 0); 6865 ok(con != NULL, "InternetConnect failed\n"); 6866 6867 req = HttpOpenRequestA(con, "GET", "/tests/hello.html", NULL, NULL, NULL, 6868 INTERNET_FLAG_SECURE, 0); 6869 ok(req != NULL, "HttpOpenRequest failed\n"); 6870 6871 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 6872 ok(ret || broken(GetLastError() == ERROR_INTERNET_CANNOT_CONNECT), 6873 "HttpSendRequest failed: %d\n", GetLastError()); 6874 if (!ret) 6875 { 6876 win_skip("Cannot connect to https.\n"); 6877 goto done; 6878 } 6879 6880 size = sizeof(flags); 6881 ret = InternetQueryOptionA(req, INTERNET_OPTION_SECURITY_FLAGS, &flags, &size); 6882 ok(ret, "InternetQueryOption failed: %d\n", GetLastError()); 6883 ok(flags & SECURITY_FLAG_SECURE, "expected secure flag to be set\n"); 6884 6885 test_cert_struct(req, &test_winehq_org_cert); 6886 6887 /* Querying the same option through InternetQueryOptionW still results in 6888 * ASCII strings being returned. 6889 */ 6890 size = 0; 6891 ret = InternetQueryOptionW(req, INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT, 6892 NULL, &size); 6893 ok(ret || GetLastError() == ERROR_INSUFFICIENT_BUFFER, "InternetQueryOption failed: %d\n", GetLastError()); 6894 ok(size == sizeof(INTERNET_CERTIFICATE_INFOW), "size = %d\n", size); 6895 certificate_structW = HeapAlloc(GetProcessHeap(), 0, size); 6896 ret = InternetQueryOptionA(req, INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT, 6897 certificate_structW, &size); 6898 certificate_structA = (INTERNET_CERTIFICATE_INFOA *)certificate_structW; 6899 ok(ret, "InternetQueryOption failed: %d\n", GetLastError()); 6900 if (ret) 6901 { 6902 ok(certificate_structA->lpszSubjectInfo && 6903 strlen(certificate_structA->lpszSubjectInfo) > 1, 6904 "expected a non-empty subject name\n"); 6905 ok(certificate_structA->lpszIssuerInfo && 6906 strlen(certificate_structA->lpszIssuerInfo) > 1, 6907 "expected a non-empty issuer name\n"); 6908 ok(!certificate_structA->lpszSignatureAlgName, 6909 "unexpected signature algorithm name\n"); 6910 ok(!certificate_structA->lpszEncryptionAlgName, 6911 "unexpected encryption algorithm name\n"); 6912 ok(!certificate_structA->lpszProtocolName, 6913 "unexpected protocol name\n"); 6914 ok(certificate_structA->dwKeySize, "expected a non-zero key size\n"); 6915 release_cert_info(certificate_structA); 6916 } 6917 HeapFree(GetProcessHeap(), 0, certificate_structW); 6918 6919 InternetCloseHandle(req); 6920 InternetCloseHandle(con); 6921 InternetCloseHandle(ses); 6922 6923 /* Repeating the tests with the W functions has the same result: */ 6924 ses = InternetOpenW(gizmo5, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0); 6925 ok(ses != NULL, "InternetOpen failed\n"); 6926 6927 con = InternetConnectW(ses, testsite, 6928 INTERNET_DEFAULT_HTTPS_PORT, NULL, NULL, 6929 INTERNET_SERVICE_HTTP, 0, 0); 6930 ok(con != NULL, "InternetConnect failed\n"); 6931 6932 req = HttpOpenRequestW(con, get, testpage, NULL, NULL, NULL, 6933 INTERNET_FLAG_SECURE|INTERNET_FLAG_RELOAD, 0); 6934 ok(req != NULL, "HttpOpenRequest failed\n"); 6935 6936 ret = HttpSendRequestA(req, NULL, 0, NULL, 0); 6937 ok(ret, "HttpSendRequest failed: %d\n", GetLastError()); 6938 6939 size = sizeof(flags); 6940 ret = InternetQueryOptionA(req, INTERNET_OPTION_SECURITY_FLAGS, &flags, &size); 6941 ok(ret, "InternetQueryOption failed: %d\n", GetLastError()); 6942 ok(flags & SECURITY_FLAG_SECURE, "expected secure flag to be set, got %x\n", flags); 6943 6944 ret = InternetQueryOptionA(req, INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT, 6945 NULL, &size); 6946 ok(ret || GetLastError() == ERROR_INSUFFICIENT_BUFFER, "InternetQueryOption failed: %d\n", GetLastError()); 6947 ok(size == sizeof(INTERNET_CERTIFICATE_INFOA), "size = %d\n", size); 6948 certificate_structA = HeapAlloc(GetProcessHeap(), 0, size); 6949 ret = InternetQueryOptionW(req, INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT, 6950 certificate_structA, &size); 6951 ok(ret, "InternetQueryOption failed: %d\n", GetLastError()); 6952 if (ret) 6953 { 6954 ok(certificate_structA->lpszSubjectInfo && 6955 strlen(certificate_structA->lpszSubjectInfo) > 1, 6956 "expected a non-empty subject name\n"); 6957 ok(certificate_structA->lpszIssuerInfo && 6958 strlen(certificate_structA->lpszIssuerInfo) > 1, 6959 "expected a non-empty issuer name\n"); 6960 ok(!certificate_structA->lpszSignatureAlgName, 6961 "unexpected signature algorithm name\n"); 6962 ok(!certificate_structA->lpszEncryptionAlgName, 6963 "unexpected encryption algorithm name\n"); 6964 ok(!certificate_structA->lpszProtocolName, 6965 "unexpected protocol name\n"); 6966 ok(certificate_structA->dwKeySize, "expected a non-zero key size\n"); 6967 release_cert_info(certificate_structA); 6968 } 6969 HeapFree(GetProcessHeap(), 0, certificate_structA); 6970 6971 /* Again, querying the same option through InternetQueryOptionW still 6972 * results in ASCII strings being returned. 6973 */ 6974 size = 0; 6975 ret = InternetQueryOptionW(req, INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT, 6976 NULL, &size); 6977 ok(ret || GetLastError() == ERROR_INSUFFICIENT_BUFFER, "InternetQueryOption failed: %d\n", GetLastError()); 6978 ok(size == sizeof(INTERNET_CERTIFICATE_INFOW), "size = %d\n", size); 6979 certificate_structW = HeapAlloc(GetProcessHeap(), 0, size); 6980 ret = InternetQueryOptionW(req, INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT, 6981 certificate_structW, &size); 6982 certificate_structA = (INTERNET_CERTIFICATE_INFOA *)certificate_structW; 6983 ok(ret, "InternetQueryOption failed: %d\n", GetLastError()); 6984 if (ret) 6985 { 6986 ok(certificate_structA->lpszSubjectInfo && 6987 strlen(certificate_structA->lpszSubjectInfo) > 1, 6988 "expected a non-empty subject name\n"); 6989 ok(certificate_structA->lpszIssuerInfo && 6990 strlen(certificate_structA->lpszIssuerInfo) > 1, 6991 "expected a non-empty issuer name\n"); 6992 ok(!certificate_structA->lpszSignatureAlgName, 6993 "unexpected signature algorithm name\n"); 6994 ok(!certificate_structA->lpszEncryptionAlgName, 6995 "unexpected encryption algorithm name\n"); 6996 ok(!certificate_structA->lpszProtocolName, 6997 "unexpected protocol name\n"); 6998 ok(certificate_structA->dwKeySize, "expected a non-zero key size\n"); 6999 release_cert_info(certificate_structA); 7000 } 7001 HeapFree(GetProcessHeap(), 0, certificate_structW); 7002 7003 done: 7004 InternetCloseHandle(req); 7005 InternetCloseHandle(con); 7006 InternetCloseHandle(ses); 7007 } 7008 7009 static void test_user_agent_header(void) 7010 { 7011 HINTERNET ses, con, req; 7012 DWORD size, err; 7013 char buffer[64]; 7014 BOOL ret; 7015 7016 ses = InternetOpenA("Gizmo5", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0); 7017 ok(ses != NULL, "InternetOpen failed\n"); 7018 7019 con = InternetConnectA(ses, "test.winehq.org", 80, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); 7020 ok(con != NULL, "InternetConnect failed\n"); 7021 7022 req = HttpOpenRequestA(con, "GET", "/tests/hello.html", "HTTP/1.0", NULL, NULL, 0, 0); 7023 ok(req != NULL, "HttpOpenRequest failed\n"); 7024 7025 size = sizeof(buffer); 7026 ret = HttpQueryInfoA(req, HTTP_QUERY_USER_AGENT | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, NULL); 7027 err = GetLastError(); 7028 ok(!ret, "HttpQueryInfo succeeded\n"); 7029 ok(err == ERROR_HTTP_HEADER_NOT_FOUND, "expected ERROR_HTTP_HEADER_NOT_FOUND, got %u\n", err); 7030 7031 ret = HttpAddRequestHeadersA(req, "User-Agent: Gizmo Project\r\n", ~0u, HTTP_ADDREQ_FLAG_ADD_IF_NEW); 7032 ok(ret, "HttpAddRequestHeaders succeeded\n"); 7033 7034 size = sizeof(buffer); 7035 ret = HttpQueryInfoA(req, HTTP_QUERY_USER_AGENT | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, NULL); 7036 err = GetLastError(); 7037 ok(ret, "HttpQueryInfo failed\n"); 7038 7039 InternetCloseHandle(req); 7040 7041 req = HttpOpenRequestA(con, "GET", "/", "HTTP/1.0", NULL, NULL, 0, 0); 7042 ok(req != NULL, "HttpOpenRequest failed\n"); 7043 7044 size = sizeof(buffer); 7045 ret = HttpQueryInfoA(req, HTTP_QUERY_ACCEPT | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, NULL); 7046 err = GetLastError(); 7047 ok(!ret, "HttpQueryInfo succeeded\n"); 7048 ok(err == ERROR_HTTP_HEADER_NOT_FOUND, "expected ERROR_HTTP_HEADER_NOT_FOUND, got %u\n", err); 7049 7050 ret = HttpAddRequestHeadersA(req, "Accept: audio/*, image/*, text/*\r\nUser-Agent: Gizmo Project\r\n", ~0u, HTTP_ADDREQ_FLAG_ADD_IF_NEW); 7051 ok(ret, "HttpAddRequestHeaders failed\n"); 7052 7053 buffer[0] = 0; 7054 size = sizeof(buffer); 7055 ret = HttpQueryInfoA(req, HTTP_QUERY_ACCEPT | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, NULL); 7056 ok(ret, "HttpQueryInfo failed: %u\n", GetLastError()); 7057 ok(!strcmp(buffer, "audio/*, image/*, text/*"), "got '%s' expected 'audio/*, image/*, text/*'\n", buffer); 7058 7059 InternetCloseHandle(req); 7060 InternetCloseHandle(con); 7061 InternetCloseHandle(ses); 7062 } 7063 7064 static void test_bogus_accept_types_array(void) 7065 { 7066 HINTERNET ses, con, req; 7067 static const char *types[] = { (const char *)6240, "*/*", "%p", "", (const char *)0xffffffff, "*/*", NULL }; 7068 DWORD size, error; 7069 char buffer[32]; 7070 BOOL ret; 7071 7072 ses = InternetOpenA("MERONG(0.9/;p)", INTERNET_OPEN_TYPE_DIRECT, "", "", 0); 7073 con = InternetConnectA(ses, "www.winehq.org", 80, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0); 7074 req = HttpOpenRequestA(con, "POST", "/post/post_action.php", "HTTP/1.0", "", types, INTERNET_FLAG_FORMS_SUBMIT, 0); 7075 7076 ok(req != NULL, "HttpOpenRequest failed: %u\n", GetLastError()); 7077 7078 buffer[0] = 0; 7079 size = sizeof(buffer); 7080 SetLastError(0xdeadbeef); 7081 ret = HttpQueryInfoA(req, HTTP_QUERY_ACCEPT | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, NULL); 7082 error = GetLastError(); 7083 ok(!ret || broken(ret), "HttpQueryInfo succeeded\n"); 7084 if (!ret) ok(error == ERROR_HTTP_HEADER_NOT_FOUND, "expected ERROR_HTTP_HEADER_NOT_FOUND, got %u\n", error); 7085 ok(broken(!strcmp(buffer, ", */*, %p, , , */*")) /* IE6 */ || 7086 broken(!strcmp(buffer, "*/*, %p, */*")) /* IE7/8 */ || 7087 !strcmp(buffer, ""), "got '%s' expected ''\n", buffer); 7088 7089 InternetCloseHandle(req); 7090 InternetCloseHandle(con); 7091 InternetCloseHandle(ses); 7092 } 7093 7094 struct context 7095 { 7096 HANDLE event; 7097 HINTERNET req; 7098 }; 7099 7100 static void WINAPI cb(HINTERNET handle, DWORD_PTR context, DWORD status, LPVOID info, DWORD size) 7101 { 7102 INTERNET_ASYNC_RESULT *result = info; 7103 struct context *ctx = (struct context *)context; 7104 7105 if(winetest_debug > 1) 7106 trace("%p 0x%08lx %u %p 0x%08x\n", handle, context, status, info, size); 7107 7108 switch(status) { 7109 case INTERNET_STATUS_REQUEST_COMPLETE: 7110 trace("request handle: 0x%08lx\n", result->dwResult); 7111 ctx->req = (HINTERNET)result->dwResult; 7112 SetEvent(ctx->event); 7113 break; 7114 case INTERNET_STATUS_HANDLE_CLOSING: { 7115 DWORD type = INTERNET_HANDLE_TYPE_CONNECT_HTTP, size = sizeof(type); 7116 7117 if (InternetQueryOptionA(handle, INTERNET_OPTION_HANDLE_TYPE, &type, &size)) 7118 ok(type != INTERNET_HANDLE_TYPE_CONNECT_HTTP, "unexpected callback\n"); 7119 SetEvent(ctx->event); 7120 break; 7121 } 7122 case INTERNET_STATUS_NAME_RESOLVED: 7123 case INTERNET_STATUS_CONNECTING_TO_SERVER: 7124 case INTERNET_STATUS_CONNECTED_TO_SERVER: { 7125 char *str = info; 7126 ok(str[0] && str[1], "Got string: %s\n", str); 7127 ok(size == strlen(str)+1, "unexpected size %u\n", size); 7128 } 7129 } 7130 } 7131 7132 static void test_open_url_async(void) 7133 { 7134 BOOL ret; 7135 HINTERNET ses, req; 7136 DWORD size, error; 7137 struct context ctx; 7138 ULONG type; 7139 7140 /* Collect all existing persistent connections */ 7141 ret = InternetSetOptionA(NULL, INTERNET_OPTION_SETTINGS_CHANGED, NULL, 0); 7142 ok(ret, "InternetSetOption(INTERNET_OPTION_END_BROWSER_SESSION) failed: %u\n", GetLastError()); 7143 7144 /* 7145 * Some versions of IE6 fail those tests. They pass some notification data as UNICODE string, while 7146 * other versions never do. They also hang of following tests. We disable it for everything older 7147 * than IE7. 7148 */ 7149 if(!is_ie7plus) 7150 return; 7151 7152 ctx.req = NULL; 7153 ctx.event = CreateEventA(NULL, TRUE, FALSE, "Z:_home_hans_jaman-installer.exe_ev1"); 7154 7155 ses = InternetOpenA("AdvancedInstaller", 0, NULL, NULL, INTERNET_FLAG_ASYNC); 7156 ok(ses != NULL, "InternetOpen failed\n"); 7157 7158 SetLastError(0xdeadbeef); 7159 ret = InternetSetOptionA(NULL, INTERNET_OPTION_CALLBACK, &cb, sizeof(DWORD_PTR)); 7160 error = GetLastError(); 7161 ok(!ret, "InternetSetOptionA succeeded\n"); 7162 ok(error == ERROR_INTERNET_INCORRECT_HANDLE_TYPE, "got %u expected ERROR_INTERNET_INCORRECT_HANDLE_TYPE\n", error); 7163 7164 ret = InternetSetOptionA(ses, INTERNET_OPTION_CALLBACK, &cb, sizeof(DWORD_PTR)); 7165 error = GetLastError(); 7166 ok(!ret, "InternetSetOptionA failed\n"); 7167 ok(error == ERROR_INTERNET_OPTION_NOT_SETTABLE, "got %u expected ERROR_INTERNET_OPTION_NOT_SETTABLE\n", error); 7168 7169 pInternetSetStatusCallbackW(ses, cb); 7170 ResetEvent(ctx.event); 7171 7172 req = InternetOpenUrlA(ses, "http://test.winehq.org", NULL, 0, 0, (DWORD_PTR)&ctx); 7173 ok(!req && GetLastError() == ERROR_IO_PENDING, "InternetOpenUrl failed\n"); 7174 7175 WaitForSingleObject(ctx.event, INFINITE); 7176 7177 type = 0; 7178 size = sizeof(type); 7179 ret = InternetQueryOptionA(ctx.req, INTERNET_OPTION_HANDLE_TYPE, &type, &size); 7180 ok(ret, "InternetQueryOption failed: %u\n", GetLastError()); 7181 ok(type == INTERNET_HANDLE_TYPE_HTTP_REQUEST, 7182 "expected INTERNET_HANDLE_TYPE_HTTP_REQUEST, got %u\n", type); 7183 7184 size = 0; 7185 ret = HttpQueryInfoA(ctx.req, HTTP_QUERY_RAW_HEADERS_CRLF, NULL, &size, NULL); 7186 ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "HttpQueryInfo failed\n"); 7187 ok(size > 0, "expected size > 0\n"); 7188 7189 ResetEvent(ctx.event); 7190 InternetCloseHandle(ctx.req); 7191 WaitForSingleObject(ctx.event, INFINITE); 7192 7193 InternetCloseHandle(ses); 7194 CloseHandle(ctx.event); 7195 } 7196 7197 enum api 7198 { 7199 internet_connect = 1, 7200 http_open_request, 7201 http_send_request_ex, 7202 internet_writefile, 7203 http_end_request, 7204 internet_close_handle 7205 }; 7206 7207 struct notification 7208 { 7209 enum api function; /* api responsible for notification */ 7210 unsigned int status; /* status received */ 7211 BOOL async; /* delivered from another thread? */ 7212 BOOL todo; 7213 BOOL optional; 7214 }; 7215 7216 struct info 7217 { 7218 enum api function; 7219 const struct notification *test; 7220 unsigned int count; 7221 unsigned int index; 7222 HANDLE wait; 7223 DWORD thread; 7224 unsigned int line; 7225 DWORD expect_result; 7226 BOOL is_aborted; 7227 }; 7228 7229 static CRITICAL_SECTION notification_cs; 7230 7231 static void CALLBACK check_notification( HINTERNET handle, DWORD_PTR context, DWORD status, LPVOID buffer, DWORD buflen ) 7232 { 7233 BOOL status_ok, function_ok; 7234 struct info *info = (struct info *)context; 7235 unsigned int i; 7236 7237 EnterCriticalSection( ¬ification_cs ); 7238 7239 if(info->is_aborted) { 7240 LeaveCriticalSection(¬ification_cs); 7241 return; 7242 } 7243 7244 if (status == INTERNET_STATUS_HANDLE_CREATED) 7245 { 7246 DWORD size = sizeof(struct info *); 7247 HttpQueryInfoA( handle, INTERNET_OPTION_CONTEXT_VALUE, &info, &size, 0 ); 7248 }else if(status == INTERNET_STATUS_REQUEST_COMPLETE) { 7249 INTERNET_ASYNC_RESULT *ar = (INTERNET_ASYNC_RESULT*)buffer; 7250 7251 ok(buflen == sizeof(*ar), "unexpected buflen = %d\n", buflen); 7252 if(info->expect_result == ERROR_SUCCESS) { 7253 ok(ar->dwResult == 1, "ar->dwResult = %ld, expected 1\n", ar->dwResult); 7254 }else { 7255 ok(!ar->dwResult, "ar->dwResult = %ld, expected 1\n", ar->dwResult); 7256 ok(ar->dwError == info->expect_result, "ar->dwError = %d, expected %d\n", ar->dwError, info->expect_result); 7257 } 7258 } 7259 7260 i = info->index; 7261 if (i >= info->count) 7262 { 7263 LeaveCriticalSection( ¬ification_cs ); 7264 return; 7265 } 7266 7267 while (info->test[i].status != status && 7268 (info->test[i].optional || info->test[i].todo) && 7269 i < info->count - 1 && 7270 info->test[i].function == info->test[i + 1].function) 7271 { 7272 i++; 7273 } 7274 7275 status_ok = (info->test[i].status == status); 7276 function_ok = (info->test[i].function == info->function); 7277 7278 if (!info->test[i].todo) 7279 { 7280 ok( status_ok, "%u: expected status %u got %u\n", info->line, info->test[i].status, status ); 7281 ok( function_ok, "%u: expected function %u got %u\n", info->line, info->test[i].function, info->function ); 7282 7283 if (info->test[i].async) 7284 ok(info->thread != GetCurrentThreadId(), "%u: expected thread %u got %u\n", 7285 info->line, info->thread, GetCurrentThreadId()); 7286 } 7287 else 7288 { 7289 todo_wine ok( status_ok, "%u: expected status %u got %u\n", info->line, info->test[i].status, status ); 7290 if (status_ok) 7291 todo_wine ok( function_ok, "%u: expected function %u got %u\n", info->line, info->test[i].function, info->function ); 7292 } 7293 if (i == info->count - 1 || info->test[i].function != info->test[i + 1].function) SetEvent( info->wait ); 7294 info->index = i+1; 7295 7296 LeaveCriticalSection( ¬ification_cs ); 7297 } 7298 7299 static void setup_test( struct info *info, enum api function, unsigned int line, DWORD expect_result ) 7300 { 7301 info->function = function; 7302 info->line = line; 7303 info->expect_result = expect_result; 7304 } 7305 7306 struct notification_data 7307 { 7308 const struct notification *test; 7309 const unsigned int count; 7310 const char *method; 7311 const char *host; 7312 const char *path; 7313 const char *data; 7314 BOOL expect_conn_failure; 7315 }; 7316 7317 static const struct notification async_send_request_ex_test[] = 7318 { 7319 { internet_connect, INTERNET_STATUS_HANDLE_CREATED, FALSE }, 7320 { http_open_request, INTERNET_STATUS_HANDLE_CREATED, FALSE }, 7321 { http_send_request_ex, INTERNET_STATUS_DETECTING_PROXY, TRUE, FALSE, TRUE }, 7322 { http_send_request_ex, INTERNET_STATUS_COOKIE_SENT, TRUE, FALSE, TRUE }, 7323 { http_send_request_ex, INTERNET_STATUS_RESOLVING_NAME, TRUE, FALSE, TRUE }, 7324 { http_send_request_ex, INTERNET_STATUS_NAME_RESOLVED, TRUE, FALSE, TRUE }, 7325 { http_send_request_ex, INTERNET_STATUS_CONNECTING_TO_SERVER, TRUE }, 7326 { http_send_request_ex, INTERNET_STATUS_CONNECTED_TO_SERVER, TRUE }, 7327 { http_send_request_ex, INTERNET_STATUS_SENDING_REQUEST, TRUE }, 7328 { http_send_request_ex, INTERNET_STATUS_REQUEST_SENT, TRUE }, 7329 { http_send_request_ex, INTERNET_STATUS_REQUEST_COMPLETE, TRUE }, 7330 { internet_writefile, INTERNET_STATUS_SENDING_REQUEST, FALSE }, 7331 { internet_writefile, INTERNET_STATUS_REQUEST_SENT, FALSE }, 7332 { http_end_request, INTERNET_STATUS_RECEIVING_RESPONSE, TRUE }, 7333 { http_end_request, INTERNET_STATUS_RESPONSE_RECEIVED, TRUE }, 7334 { http_end_request, INTERNET_STATUS_REQUEST_COMPLETE, TRUE }, 7335 { internet_close_handle, INTERNET_STATUS_CLOSING_CONNECTION, FALSE, FALSE, TRUE }, 7336 { internet_close_handle, INTERNET_STATUS_CONNECTION_CLOSED, FALSE, FALSE, TRUE }, 7337 { internet_close_handle, INTERNET_STATUS_HANDLE_CLOSING, FALSE, }, 7338 { internet_close_handle, INTERNET_STATUS_HANDLE_CLOSING, FALSE, } 7339 }; 7340 7341 static const struct notification async_send_request_ex_test2[] = 7342 { 7343 { internet_connect, INTERNET_STATUS_HANDLE_CREATED, FALSE }, 7344 { http_open_request, INTERNET_STATUS_HANDLE_CREATED, FALSE }, 7345 { http_send_request_ex, INTERNET_STATUS_DETECTING_PROXY, TRUE, FALSE, TRUE }, 7346 { http_send_request_ex, INTERNET_STATUS_COOKIE_SENT, TRUE, FALSE, TRUE }, 7347 { http_send_request_ex, INTERNET_STATUS_RESOLVING_NAME, TRUE, FALSE, TRUE }, 7348 { http_send_request_ex, INTERNET_STATUS_NAME_RESOLVED, TRUE, FALSE, TRUE }, 7349 { http_send_request_ex, INTERNET_STATUS_CONNECTING_TO_SERVER, TRUE, TRUE }, 7350 { http_send_request_ex, INTERNET_STATUS_CONNECTED_TO_SERVER, TRUE, TRUE }, 7351 { http_send_request_ex, INTERNET_STATUS_SENDING_REQUEST, TRUE }, 7352 { http_send_request_ex, INTERNET_STATUS_REQUEST_SENT, TRUE }, 7353 { http_send_request_ex, INTERNET_STATUS_REQUEST_COMPLETE, TRUE }, 7354 { http_end_request, INTERNET_STATUS_RECEIVING_RESPONSE, TRUE }, 7355 { http_end_request, INTERNET_STATUS_RESPONSE_RECEIVED, TRUE }, 7356 { http_end_request, INTERNET_STATUS_REQUEST_COMPLETE, TRUE }, 7357 { internet_close_handle, INTERNET_STATUS_CLOSING_CONNECTION, FALSE, FALSE, TRUE }, 7358 { internet_close_handle, INTERNET_STATUS_CONNECTION_CLOSED, FALSE, FALSE, TRUE }, 7359 { internet_close_handle, INTERNET_STATUS_HANDLE_CLOSING, FALSE, }, 7360 { internet_close_handle, INTERNET_STATUS_HANDLE_CLOSING, FALSE, } 7361 }; 7362 7363 static const struct notification async_send_request_ex_resolve_failure_test[] = 7364 { 7365 { internet_connect, INTERNET_STATUS_HANDLE_CREATED, FALSE }, 7366 { http_open_request, INTERNET_STATUS_HANDLE_CREATED, FALSE }, 7367 { http_send_request_ex, INTERNET_STATUS_DETECTING_PROXY, TRUE, FALSE, TRUE }, 7368 { http_send_request_ex, INTERNET_STATUS_RESOLVING_NAME, TRUE }, 7369 { http_send_request_ex, INTERNET_STATUS_DETECTING_PROXY, TRUE, FALSE, TRUE }, 7370 { http_send_request_ex, INTERNET_STATUS_REQUEST_COMPLETE, TRUE }, 7371 { http_end_request, INTERNET_STATUS_REQUEST_COMPLETE, TRUE }, 7372 { internet_close_handle, INTERNET_STATUS_CLOSING_CONNECTION, FALSE, FALSE, TRUE }, 7373 { internet_close_handle, INTERNET_STATUS_CONNECTION_CLOSED, FALSE, FALSE, TRUE }, 7374 { internet_close_handle, INTERNET_STATUS_HANDLE_CLOSING, FALSE, }, 7375 { internet_close_handle, INTERNET_STATUS_HANDLE_CLOSING, FALSE, } 7376 }; 7377 7378 static const struct notification async_send_request_ex_chunked_test[] = 7379 { 7380 { internet_connect, INTERNET_STATUS_HANDLE_CREATED }, 7381 { http_open_request, INTERNET_STATUS_HANDLE_CREATED }, 7382 { http_send_request_ex, INTERNET_STATUS_DETECTING_PROXY, TRUE, FALSE, TRUE }, 7383 { http_send_request_ex, INTERNET_STATUS_COOKIE_SENT, TRUE, FALSE, TRUE }, 7384 { http_send_request_ex, INTERNET_STATUS_RESOLVING_NAME, TRUE, FALSE, TRUE }, 7385 { http_send_request_ex, INTERNET_STATUS_NAME_RESOLVED, TRUE, FALSE, TRUE }, 7386 { http_send_request_ex, INTERNET_STATUS_CONNECTING_TO_SERVER, TRUE }, 7387 { http_send_request_ex, INTERNET_STATUS_CONNECTED_TO_SERVER, TRUE }, 7388 { http_send_request_ex, INTERNET_STATUS_SENDING_REQUEST, TRUE }, 7389 { http_send_request_ex, INTERNET_STATUS_REQUEST_SENT, TRUE }, 7390 { http_send_request_ex, INTERNET_STATUS_REQUEST_COMPLETE, TRUE }, 7391 { http_end_request, INTERNET_STATUS_RECEIVING_RESPONSE, TRUE }, 7392 { http_end_request, INTERNET_STATUS_RESPONSE_RECEIVED, TRUE }, 7393 { http_end_request, INTERNET_STATUS_REQUEST_COMPLETE, TRUE }, 7394 { internet_close_handle, INTERNET_STATUS_CLOSING_CONNECTION }, 7395 { internet_close_handle, INTERNET_STATUS_CONNECTION_CLOSED }, 7396 { internet_close_handle, INTERNET_STATUS_HANDLE_CLOSING }, 7397 { internet_close_handle, INTERNET_STATUS_HANDLE_CLOSING } 7398 }; 7399 7400 static const struct notification_data notification_data[] = { 7401 { 7402 async_send_request_ex_chunked_test, 7403 ARRAY_SIZE(async_send_request_ex_chunked_test), 7404 "GET", 7405 "test.winehq.org", 7406 "tests/data.php" 7407 }, 7408 { 7409 async_send_request_ex_test, 7410 ARRAY_SIZE(async_send_request_ex_test), 7411 "POST", 7412 "test.winehq.org", 7413 "tests/post.php", 7414 "Public ID=codeweavers" 7415 }, 7416 { 7417 async_send_request_ex_test2, 7418 ARRAY_SIZE(async_send_request_ex_test2), 7419 "POST", 7420 "test.winehq.org", 7421 "tests/post.php" 7422 }, 7423 { 7424 async_send_request_ex_resolve_failure_test, 7425 ARRAY_SIZE(async_send_request_ex_resolve_failure_test), 7426 "GET", 7427 "brokenhost", 7428 "index.html", 7429 NULL, 7430 TRUE 7431 } 7432 }; 7433 7434 static void test_async_HttpSendRequestEx(const struct notification_data *nd) 7435 { 7436 BOOL ret; 7437 HINTERNET ses, req, con; 7438 struct info info; 7439 DWORD size, written, error; 7440 INTERNET_BUFFERSA b; 7441 static const char *accept[2] = {"*/*", NULL}; 7442 char buffer[32]; 7443 7444 trace("Async HttpSendRequestEx test (%s %s)\n", nd->method, nd->host); 7445 7446 InitializeCriticalSection( ¬ification_cs ); 7447 7448 info.test = nd->test; 7449 info.count = nd->count; 7450 info.index = 0; 7451 info.wait = CreateEventW( NULL, FALSE, FALSE, NULL ); 7452 info.thread = GetCurrentThreadId(); 7453 info.is_aborted = FALSE; 7454 7455 ses = InternetOpenA( "winetest", 0, NULL, NULL, INTERNET_FLAG_ASYNC ); 7456 ok( ses != NULL, "InternetOpen failed\n" ); 7457 7458 pInternetSetStatusCallbackA( ses, check_notification ); 7459 7460 setup_test( &info, internet_connect, __LINE__, ERROR_SUCCESS ); 7461 con = InternetConnectA( ses, nd->host, 80, NULL, NULL, INTERNET_SERVICE_HTTP, 0, (DWORD_PTR)&info ); 7462 ok( con != NULL, "InternetConnect failed %u\n", GetLastError() ); 7463 7464 WaitForSingleObject( info.wait, 10000 ); 7465 7466 setup_test( &info, http_open_request, __LINE__, ERROR_SUCCESS ); 7467 req = HttpOpenRequestA( con, nd->method, nd->path, NULL, NULL, accept, 0, (DWORD_PTR)&info ); 7468 ok( req != NULL, "HttpOpenRequest failed %u\n", GetLastError() ); 7469 7470 WaitForSingleObject( info.wait, 10000 ); 7471 7472 if(nd->data) { 7473 memset( &b, 0, sizeof(INTERNET_BUFFERSA) ); 7474 b.dwStructSize = sizeof(INTERNET_BUFFERSA); 7475 b.lpcszHeader = "Content-Type: application/x-www-form-urlencoded"; 7476 b.dwHeadersLength = strlen( b.lpcszHeader ); 7477 b.dwBufferTotal = nd->data ? strlen( nd->data ) : 0; 7478 } 7479 7480 setup_test( &info, http_send_request_ex, __LINE__, 7481 nd->expect_conn_failure ? ERROR_INTERNET_NAME_NOT_RESOLVED : ERROR_SUCCESS ); 7482 ret = HttpSendRequestExA( req, nd->data ? &b : NULL, NULL, 0x28, 0 ); 7483 ok( !ret && GetLastError() == ERROR_IO_PENDING, "HttpSendRequestExA failed %d %u\n", ret, GetLastError() ); 7484 7485 error = WaitForSingleObject( info.wait, 10000 ); 7486 if(error != WAIT_OBJECT_0) { 7487 skip("WaitForSingleObject returned %d, assuming DNS problem\n", error); 7488 info.is_aborted = TRUE; 7489 goto abort; 7490 } 7491 7492 size = sizeof(buffer); 7493 SetLastError( 0xdeadbeef ); 7494 ret = HttpQueryInfoA( req, HTTP_QUERY_CONTENT_ENCODING, buffer, &size, 0 ); 7495 error = GetLastError(); 7496 ok( !ret, "HttpQueryInfoA failed %u\n", GetLastError() ); 7497 if(nd->expect_conn_failure) { 7498 ok(error == ERROR_HTTP_HEADER_NOT_FOUND, "expected ERROR_HTTP_HEADER_NOT_FOUND got %u\n", error ); 7499 }else { 7500 todo_wine 7501 ok(error == ERROR_INTERNET_INCORRECT_HANDLE_STATE, 7502 "expected ERROR_INTERNET_INCORRECT_HANDLE_STATE got %u\n", error ); 7503 } 7504 7505 if (nd->data) 7506 { 7507 written = 0; 7508 size = strlen( nd->data ); 7509 setup_test( &info, internet_writefile, __LINE__, ERROR_SUCCESS ); 7510 ret = InternetWriteFile( req, nd->data, size, &written ); 7511 ok( ret, "InternetWriteFile failed %u\n", GetLastError() ); 7512 ok( written == size, "expected %u got %u\n", written, size ); 7513 7514 WaitForSingleObject( info.wait, 10000 ); 7515 7516 SetLastError( 0xdeadbeef ); 7517 ret = HttpEndRequestA( req, (void *)nd->data, 0x28, 0 ); 7518 error = GetLastError(); 7519 ok( !ret, "HttpEndRequestA succeeded\n" ); 7520 ok( error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER got %u\n", error ); 7521 } 7522 7523 SetLastError( 0xdeadbeef ); 7524 setup_test( &info, http_end_request, __LINE__, 7525 nd->expect_conn_failure ? ERROR_INTERNET_OPERATION_CANCELLED : ERROR_SUCCESS); 7526 ret = HttpEndRequestA( req, NULL, 0x28, 0 ); 7527 error = GetLastError(); 7528 ok( !ret, "HttpEndRequestA succeeded\n" ); 7529 ok( error == ERROR_IO_PENDING, "expected ERROR_IO_PENDING got %u\n", error ); 7530 7531 WaitForSingleObject( info.wait, 10000 ); 7532 7533 setup_test( &info, internet_close_handle, __LINE__, ERROR_SUCCESS ); 7534 abort: 7535 InternetCloseHandle( req ); 7536 InternetCloseHandle( con ); 7537 InternetCloseHandle( ses ); 7538 7539 WaitForSingleObject( info.wait, 10000 ); 7540 Sleep(100); 7541 CloseHandle( info.wait ); 7542 DeleteCriticalSection( ¬ification_cs ); 7543 } 7544 7545 static HINTERNET closetest_session, closetest_req, closetest_conn; 7546 static BOOL closetest_closed; 7547 7548 static void WINAPI closetest_callback(HINTERNET hInternet, DWORD_PTR dwContext, DWORD dwInternetStatus, 7549 LPVOID lpvStatusInformation, DWORD dwStatusInformationLength) 7550 { 7551 DWORD len, type; 7552 BOOL res; 7553 7554 if(winetest_debug > 1) 7555 trace("closetest_callback %p: %d\n", hInternet, dwInternetStatus); 7556 7557 ok(hInternet == closetest_session || hInternet == closetest_conn || hInternet == closetest_req, 7558 "Unexpected hInternet %p\n", hInternet); 7559 if(!closetest_closed) 7560 return; 7561 7562 len = sizeof(type); 7563 res = InternetQueryOptionA(closetest_req, INTERNET_OPTION_HANDLE_TYPE, &type, &len); 7564 ok(!res && GetLastError() == ERROR_INVALID_HANDLE, 7565 "InternetQueryOptionA(%p INTERNET_OPTION_HANDLE_TYPE) failed: %x %u, expected TRUE ERROR_INVALID_HANDLE\n", 7566 closetest_req, res, GetLastError()); 7567 } 7568 7569 static void test_InternetCloseHandle(void) 7570 { 7571 DWORD len, flags; 7572 BOOL res; 7573 7574 closetest_session = InternetOpenA("", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, INTERNET_FLAG_ASYNC); 7575 ok(closetest_session != NULL,"InternetOpen failed with error %u\n", GetLastError()); 7576 7577 pInternetSetStatusCallbackA(closetest_session, closetest_callback); 7578 7579 closetest_conn = InternetConnectA(closetest_session, "source.winehq.org", INTERNET_INVALID_PORT_NUMBER, 7580 NULL, NULL, INTERNET_SERVICE_HTTP, 0x0, 0xdeadbeef); 7581 ok(closetest_conn != NULL,"InternetConnect failed with error %u\n", GetLastError()); 7582 7583 closetest_req = HttpOpenRequestA(closetest_conn, "GET", "winegecko.php", NULL, NULL, NULL, 7584 INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_RESYNCHRONIZE, 0xdeadbead); 7585 7586 res = HttpSendRequestA(closetest_req, NULL, -1, NULL, 0); 7587 ok(!res && (GetLastError() == ERROR_IO_PENDING), 7588 "Asynchronous HttpSendRequest NOT returning 0 with error ERROR_IO_PENDING\n"); 7589 7590 test_request_flags(closetest_req, INTERNET_REQFLAG_NO_HEADERS); 7591 7592 res = InternetCloseHandle(closetest_session); 7593 ok(res, "InternetCloseHandle failed: %u\n", GetLastError()); 7594 closetest_closed = TRUE; 7595 trace("Closed session handle\n"); 7596 7597 res = InternetCloseHandle(closetest_conn); 7598 ok(!res && GetLastError() == ERROR_INVALID_HANDLE, "InternetCloseConnection(conn) failed: %x %u\n", 7599 res, GetLastError()); 7600 7601 res = InternetCloseHandle(closetest_req); 7602 ok(!res && GetLastError() == ERROR_INVALID_HANDLE, "InternetCloseConnection(req) failed: %x %u\n", 7603 res, GetLastError()); 7604 7605 len = sizeof(flags); 7606 res = InternetQueryOptionA(closetest_req, INTERNET_OPTION_REQUEST_FLAGS, &flags, &len); 7607 ok(!res && GetLastError() == ERROR_INVALID_HANDLE, 7608 "InternetQueryOptionA(%p INTERNET_OPTION_REQUEST_FLAGS) failed: %x %u, expected TRUE ERROR_INVALID_HANDLE\n", 7609 closetest_req, res, GetLastError()); 7610 } 7611 7612 static void test_connection_failure(void) 7613 { 7614 test_request_t req; 7615 DWORD error; 7616 BOOL ret; 7617 7618 open_simple_request(&req, "localhost", 1, NULL, "/"); 7619 7620 SetLastError(0xdeadbeef); 7621 ret = HttpSendRequestA(req.request, NULL, 0, NULL, 0); 7622 error = GetLastError(); 7623 ok(!ret, "unexpected success\n"); 7624 ok(error == ERROR_INTERNET_CANNOT_CONNECT, "wrong error %u\n", error); 7625 7626 close_request(&req); 7627 } 7628 7629 static void test_default_service_port(void) 7630 { 7631 HINTERNET session, connect, request; 7632 DWORD size, error; 7633 char buffer[128]; 7634 BOOL ret; 7635 7636 if(!is_ie7plus) 7637 return; 7638 7639 session = InternetOpenA("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0); 7640 ok(session != NULL, "InternetOpen failed\n"); 7641 7642 connect = InternetConnectA(session, "test.winehq.org", INTERNET_INVALID_PORT_NUMBER, NULL, NULL, 7643 INTERNET_SERVICE_HTTP, 0, 0); 7644 ok(connect != NULL, "InternetConnect failed\n"); 7645 7646 request = HttpOpenRequestA(connect, NULL, "/", NULL, NULL, NULL, INTERNET_FLAG_SECURE, 0); 7647 ok(request != NULL, "HttpOpenRequest failed\n"); 7648 7649 SetLastError(0xdeadbeef); 7650 ret = HttpSendRequestA(request, NULL, 0, NULL, 0); 7651 error = GetLastError(); 7652 ok(!ret, "HttpSendRequest succeeded\n"); 7653 ok(error == ERROR_INTERNET_SECURITY_CHANNEL_ERROR || error == ERROR_INTERNET_CANNOT_CONNECT, 7654 "got %u\n", error); 7655 7656 size = sizeof(buffer); 7657 memset(buffer, 0, sizeof(buffer)); 7658 ret = HttpQueryInfoA(request, HTTP_QUERY_HOST | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, NULL); 7659 ok(ret, "HttpQueryInfo failed with error %u\n", GetLastError()); 7660 ok(!strcmp(buffer, "test.winehq.org:80"), "Expected test.winehg.org:80, got '%s'\n", buffer); 7661 7662 InternetCloseHandle(request); 7663 InternetCloseHandle(connect); 7664 7665 connect = InternetConnectA(session, "test.winehq.org", INTERNET_INVALID_PORT_NUMBER, NULL, NULL, 7666 INTERNET_SERVICE_HTTP, INTERNET_FLAG_SECURE, 0); 7667 ok(connect != NULL, "InternetConnect failed\n"); 7668 7669 request = HttpOpenRequestA(connect, NULL, "/", NULL, NULL, NULL, INTERNET_FLAG_SECURE, 0); 7670 ok(request != NULL, "HttpOpenRequest failed\n"); 7671 7672 ret = HttpSendRequestA(request, NULL, 0, NULL, 0); 7673 ok(ret, "HttpSendRequest failed with error %u\n", GetLastError()); 7674 7675 size = sizeof(buffer); 7676 memset(buffer, 0, sizeof(buffer)); 7677 ret = HttpQueryInfoA(request, HTTP_QUERY_HOST | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, NULL); 7678 ok(ret, "HttpQueryInfo failed with error %u\n", GetLastError()); 7679 ok(!strcmp(buffer, "test.winehq.org"), "Expected test.winehg.org, got '%s'\n", buffer); 7680 7681 InternetCloseHandle(request); 7682 InternetCloseHandle(connect); 7683 7684 connect = InternetConnectA(session, "test.winehq.org", INTERNET_INVALID_PORT_NUMBER, NULL, NULL, 7685 INTERNET_SERVICE_HTTP, INTERNET_FLAG_SECURE, 0); 7686 ok(connect != NULL, "InternetConnect failed\n"); 7687 7688 request = HttpOpenRequestA(connect, NULL, "/", NULL, NULL, NULL, 0, 0); 7689 ok(request != NULL, "HttpOpenRequest failed\n"); 7690 7691 ret = HttpSendRequestA(request, NULL, 0, NULL, 0); 7692 ok(ret, "HttpSendRequest failed with error %u\n", GetLastError()); 7693 7694 size = sizeof(buffer); 7695 memset(buffer, 0, sizeof(buffer)); 7696 ret = HttpQueryInfoA(request, HTTP_QUERY_HOST | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, NULL); 7697 ok(ret, "HttpQueryInfo failed with error %u\n", GetLastError()); 7698 ok(!strcmp(buffer, "test.winehq.org:443"), "Expected test.winehg.org:443, got '%s'\n", buffer); 7699 7700 InternetCloseHandle(request); 7701 InternetCloseHandle(connect); 7702 InternetCloseHandle(session); 7703 } 7704 7705 static void init_status_tests(void) 7706 { 7707 memset(expect, 0, sizeof(expect)); 7708 memset(optional, 0, sizeof(optional)); 7709 memset(wine_allow, 0, sizeof(wine_allow)); 7710 memset(notified, 0, sizeof(notified)); 7711 memset(status_string, 0, sizeof(status_string)); 7712 7713 #define STATUS_STRING(status) status_string[status] = #status 7714 STATUS_STRING(INTERNET_STATUS_RESOLVING_NAME); 7715 STATUS_STRING(INTERNET_STATUS_NAME_RESOLVED); 7716 STATUS_STRING(INTERNET_STATUS_CONNECTING_TO_SERVER); 7717 STATUS_STRING(INTERNET_STATUS_CONNECTED_TO_SERVER); 7718 STATUS_STRING(INTERNET_STATUS_SENDING_REQUEST); 7719 STATUS_STRING(INTERNET_STATUS_REQUEST_SENT); 7720 STATUS_STRING(INTERNET_STATUS_RECEIVING_RESPONSE); 7721 STATUS_STRING(INTERNET_STATUS_RESPONSE_RECEIVED); 7722 STATUS_STRING(INTERNET_STATUS_CTL_RESPONSE_RECEIVED); 7723 STATUS_STRING(INTERNET_STATUS_PREFETCH); 7724 STATUS_STRING(INTERNET_STATUS_CLOSING_CONNECTION); 7725 STATUS_STRING(INTERNET_STATUS_CONNECTION_CLOSED); 7726 STATUS_STRING(INTERNET_STATUS_HANDLE_CREATED); 7727 STATUS_STRING(INTERNET_STATUS_HANDLE_CLOSING); 7728 STATUS_STRING(INTERNET_STATUS_DETECTING_PROXY); 7729 STATUS_STRING(INTERNET_STATUS_REQUEST_COMPLETE); 7730 STATUS_STRING(INTERNET_STATUS_REDIRECT); 7731 STATUS_STRING(INTERNET_STATUS_INTERMEDIATE_RESPONSE); 7732 STATUS_STRING(INTERNET_STATUS_USER_INPUT_REQUIRED); 7733 STATUS_STRING(INTERNET_STATUS_STATE_CHANGE); 7734 STATUS_STRING(INTERNET_STATUS_COOKIE_SENT); 7735 STATUS_STRING(INTERNET_STATUS_COOKIE_RECEIVED); 7736 STATUS_STRING(INTERNET_STATUS_PRIVACY_IMPACTED); 7737 STATUS_STRING(INTERNET_STATUS_P3P_HEADER); 7738 STATUS_STRING(INTERNET_STATUS_P3P_POLICYREF); 7739 STATUS_STRING(INTERNET_STATUS_COOKIE_HISTORY); 7740 #undef STATUS_STRING 7741 } 7742 7743 static void WINAPI header_cb( HINTERNET handle, DWORD_PTR ctx, DWORD status, LPVOID info, DWORD len ) 7744 { 7745 BOOL ret; 7746 DWORD index, size; 7747 char buf[256]; 7748 7749 if (status == INTERNET_STATUS_SENDING_REQUEST) 7750 { 7751 ret = HttpAddRequestHeadersA( handle, "winetest: winetest", ~0u, HTTP_ADDREQ_FLAG_ADD ); 7752 ok( ret, "HttpAddRequestHeadersA failed %u\n", GetLastError() ); 7753 SetEvent( (HANDLE)ctx ); 7754 } 7755 else if (status == INTERNET_STATUS_REQUEST_SENT) 7756 { 7757 index = 0; 7758 size = sizeof(buf); 7759 ret = HttpQueryInfoA( handle, HTTP_QUERY_RAW_HEADERS_CRLF|HTTP_QUERY_FLAG_REQUEST_HEADERS, 7760 buf, &size, &index ); 7761 ok( ret, "HttpQueryInfoA failed %u\n", GetLastError() ); 7762 ok( strstr( buf, "winetest: winetest" ) != NULL, "header missing\n" ); 7763 SetEvent( (HANDLE)ctx ); 7764 } 7765 } 7766 7767 static void test_concurrent_header_access(void) 7768 { 7769 HINTERNET ses, con, req; 7770 DWORD err; 7771 BOOL ret; 7772 HANDLE wait = CreateEventW( NULL, FALSE, FALSE, NULL ); 7773 7774 ses = InternetOpenA( "winetest", 0, NULL, NULL, INTERNET_FLAG_ASYNC ); 7775 ok( ses != NULL, "InternetOpenA failed\n" ); 7776 7777 con = InternetConnectA( ses, "test.winehq.org", INTERNET_DEFAULT_HTTP_PORT, NULL, NULL, 7778 INTERNET_SERVICE_HTTP, 0, 0 ); 7779 ok( con != NULL, "InternetConnectA failed %u\n", GetLastError() ); 7780 7781 req = HttpOpenRequestA( con, NULL, "/", NULL, NULL, NULL, 0, (DWORD_PTR)wait ); 7782 ok( req != NULL, "HttpOpenRequestA failed %u\n", GetLastError() ); 7783 7784 pInternetSetStatusCallbackA( req, header_cb ); 7785 7786 SetLastError( 0xdeadbeef ); 7787 ret = HttpSendRequestA( req, NULL, 0, NULL, 0 ); 7788 err = GetLastError(); 7789 ok( !ret, "HttpSendRequestA succeeded\n" ); 7790 ok( err == ERROR_IO_PENDING, "got %u\n", ERROR_IO_PENDING ); 7791 7792 WaitForSingleObject( wait, 5000 ); 7793 WaitForSingleObject( wait, 5000 ); 7794 7795 InternetCloseHandle( req ); 7796 InternetCloseHandle( con ); 7797 InternetCloseHandle( ses ); 7798 CloseHandle( wait ); 7799 } 7800 7801 START_TEST(http) 7802 { 7803 HMODULE hdll; 7804 hdll = GetModuleHandleA("wininet.dll"); 7805 7806 if(!GetProcAddress(hdll, "InternetGetCookieExW")) { 7807 win_skip("Too old IE (older than 6.0)\n"); 7808 return; 7809 } 7810 7811 pInternetSetStatusCallbackA = (void*)GetProcAddress(hdll, "InternetSetStatusCallbackA"); 7812 pInternetSetStatusCallbackW = (void*)GetProcAddress(hdll, "InternetSetStatusCallbackW"); 7813 pInternetGetSecurityInfoByURLA = (void*)GetProcAddress(hdll, "InternetGetSecurityInfoByURLA"); 7814 7815 if(!pInternetGetSecurityInfoByURLA) { 7816 is_ie7plus = FALSE; 7817 win_skip("IE6 found. It's too old for some tests.\n"); 7818 } 7819 7820 init_events(); 7821 init_status_tests(); 7822 test_InternetCloseHandle(); 7823 InternetReadFile_test(INTERNET_FLAG_ASYNC, &test_data[0]); 7824 InternetReadFile_test(INTERNET_FLAG_ASYNC, &test_data[1]); 7825 InternetReadFile_test(0, &test_data[1]); 7826 InternetReadFile_test(INTERNET_FLAG_ASYNC, &test_data[2]); 7827 test_security_flags(); 7828 InternetReadFile_test(0, &test_data[2]); 7829 InternetReadFileExA_test(INTERNET_FLAG_ASYNC); 7830 test_open_url_async(); 7831 test_async_HttpSendRequestEx(¬ification_data[0]); 7832 test_async_HttpSendRequestEx(¬ification_data[1]); 7833 test_async_HttpSendRequestEx(¬ification_data[2]); 7834 test_async_HttpSendRequestEx(¬ification_data[3]); 7835 InternetOpenRequest_test(); 7836 test_http_cache(); 7837 InternetLockRequestFile_test(); 7838 InternetOpenUrlA_test(); 7839 HttpHeaders_test(); 7840 test_http_connection(); 7841 test_secure_connection(); 7842 test_user_agent_header(); 7843 test_bogus_accept_types_array(); 7844 InternetReadFile_chunked_test(); 7845 HttpSendRequestEx_test(); 7846 InternetReadFile_test(INTERNET_FLAG_ASYNC, &test_data[3]); 7847 test_connection_failure(); 7848 test_default_service_port(); 7849 test_concurrent_header_access(); 7850 free_events(); 7851 } 7852