git.oblomov.eu Git - wine/blob - dlls/wininet/tests/http.c

   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
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "wininet.h"
  30 #include "winsock.h"
  31
  32 #include "wine/test.h"
  33
  34 #define TEST_URL "http://test.winehq.org/tests/hello.html"
  35
  36 static BOOL first_connection_to_test_url = TRUE;
  37
  38 /* Adapted from dlls/urlmon/tests/protocol.c */
  39
  40 #define SET_EXPECT2(status, num) \
  41     expect[status] = num
  42
  43 #define SET_EXPECT(status) \
  44     SET_EXPECT2(status, 1)
  45
  46 #define SET_OPTIONAL2(status, num) \
  47     optional[status] = num
  48
  49 #define SET_OPTIONAL(status) \
  50     SET_OPTIONAL2(status, 1)
  51
  52 /* SET_WINE_ALLOW's should be used with an appropriate
  53  * todo_wine CHECK_NOTIFIED at a later point in the code */
  54 #define SET_WINE_ALLOW2(status, num) \
  55     wine_allow[status] = num
  56
  57 #define SET_WINE_ALLOW(status) \
  58     SET_WINE_ALLOW2(status, 1)
  59
  60 #define CHECK_EXPECT(status) \
  61     do { \
  62         if (!expect[status] && !optional[status] && wine_allow[status]) \
  63         { \
  64             todo_wine ok(expect[status], "unexpected status %d (%s)\n", status, \
  65                          status < MAX_INTERNET_STATUS && status_string[status] ? \
  66                          status_string[status] : "unknown");            \
  67             wine_allow[status]--; \
  68         } \
  69         else \
  70         { \
  71             ok(expect[status] || optional[status], "unexpected status %d (%s)\n", status,   \
  72                status < MAX_INTERNET_STATUS && status_string[status] ? \
  73                status_string[status] : "unknown");                      \
  74             if (expect[status]) expect[status]--; \
  75             else optional[status]--; \
  76         } \
  77         notified[status]++; \
  78     }while(0)
  79
  80 /* CLEAR_NOTIFIED used in cases when notification behavior
  81  * differs between Windows versions */
  82 #define CLEAR_NOTIFIED(status) \
  83     expect[status] = optional[status] = wine_allow[status] = notified[status] = 0;
  84
  85 #define CHECK_NOTIFIED2(status, num) \
  86     do { \
  87         ok(notified[status] + optional[status] == (num), \
  88            "expected status %d (%s) %d times, received %d times\n", \
  89            status, status < MAX_INTERNET_STATUS && status_string[status] ? \
  90            status_string[status] : "unknown", (num), notified[status]); \
  91         CLEAR_NOTIFIED(status);                                         \
  92     }while(0)
  93
  94 #define CHECK_NOTIFIED(status) \
  95     CHECK_NOTIFIED2(status, 1)
  96
  97 #define CHECK_NOT_NOTIFIED(status) \
  98     CHECK_NOTIFIED2(status, 0)
  99
 100 #define MAX_INTERNET_STATUS (INTERNET_STATUS_COOKIE_HISTORY+1)
 101 static int expect[MAX_INTERNET_STATUS], optional[MAX_INTERNET_STATUS],
 102     wine_allow[MAX_INTERNET_STATUS], notified[MAX_INTERNET_STATUS];
 103 static const char *status_string[MAX_INTERNET_STATUS];
 104
 105 static HANDLE hCompleteEvent, conn_close_event;
 106 static DWORD req_error;
 107
 108 #define TESTF_REDIRECT      0x01
 109 #define TESTF_COMPRESSED    0x02
 110 #define TESTF_ALLOW_COOKIE  0x04
 111 #define TESTF_CHUNKED       0x08
 112
 113 typedef struct {
 114     const char *url;
 115     const char *redirected_url;
 116     const char *host;
 117     const char *path;
 118     const char *headers;
 119     DWORD flags;
 120     const char *post_data;
 121     const char *content;
 122 } test_data_t;
 123
 124 static const test_data_t test_data[] = {
 125     {
 126         "http://test.winehq.org/tests/data.php",
 127         "http://test.winehq.org/tests/data.php",
 128         "test.winehq.org",
 129         "/tests/data.php",
 130         "",
 131         TESTF_CHUNKED
 132     },
 133     {
 134         "http://test.winehq.org/tests/redirect",
 135         "http://test.winehq.org/tests/hello.html",
 136         "test.winehq.org",
 137         "/tests/redirect",
 138         "",
 139         TESTF_REDIRECT
 140     },
 141     {
 142         "http://www.codeweavers.com/",
 143         "http://www.codeweavers.com/",
 144         "www.codeweavers.com",
 145         "",
 146         "Accept-Encoding: gzip, deflate",
 147         TESTF_COMPRESSED|TESTF_ALLOW_COOKIE
 148     },
 149     {
 150         "http://test.winehq.org/tests/post.php",
 151         "http://test.winehq.org/tests/post.php",
 152         "test.winehq.org",
 153         "/tests/post.php",
 154         "Content-Type: application/x-www-form-urlencoded",
 155         0,
 156         "mode=Test",
 157         "mode => Test\n"
 158     }
 159 };
 160
 161 static INTERNET_STATUS_CALLBACK (WINAPI *pInternetSetStatusCallbackA)(HINTERNET ,INTERNET_STATUS_CALLBACK);
 162
 163 static BOOL proxy_active(void)
 164 {
 165     HKEY internet_settings;
 166     DWORD proxy_enable;
 167     DWORD size;
 168
 169     if (RegOpenKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",
 170                       0, KEY_QUERY_VALUE, &internet_settings) != ERROR_SUCCESS)
 171         return FALSE;
 172
 173     size = sizeof(DWORD);
 174     if (RegQueryValueExA(internet_settings, "ProxyEnable", NULL, NULL, (LPBYTE) &proxy_enable, &size) != ERROR_SUCCESS)
 175         proxy_enable = 0;
 176
 177     RegCloseKey(internet_settings);
 178
 179     return proxy_enable != 0;
 180 }
 181
 182 static int close_handle_cnt;
 183
 184 static VOID WINAPI callback(
 185      HINTERNET hInternet,
 186      DWORD_PTR dwContext,
 187      DWORD dwInternetStatus,
 188      LPVOID lpvStatusInformation,
 189      DWORD dwStatusInformationLength
 190 )
 191 {
 192     CHECK_EXPECT(dwInternetStatus);
 193     switch (dwInternetStatus)
 194     {
 195         case INTERNET_STATUS_RESOLVING_NAME:
 196             trace("%04x:Callback %p 0x%lx INTERNET_STATUS_RESOLVING_NAME \"%s\" %d\n",
 197                 GetCurrentThreadId(), hInternet, dwContext,
 198                 (LPCSTR)lpvStatusInformation,dwStatusInformationLength);
 199             *(LPSTR)lpvStatusInformation = '\0';
 200             break;
 201         case INTERNET_STATUS_NAME_RESOLVED:
 202             trace("%04x:Callback %p 0x%lx INTERNET_STATUS_NAME_RESOLVED \"%s\" %d\n",
 203                 GetCurrentThreadId(), hInternet, dwContext,
 204                 (LPCSTR)lpvStatusInformation,dwStatusInformationLength);
 205             *(LPSTR)lpvStatusInformation = '\0';
 206             break;
 207         case INTERNET_STATUS_CONNECTING_TO_SERVER:
 208             trace("%04x:Callback %p 0x%lx INTERNET_STATUS_CONNECTING_TO_SERVER \"%s\" %d\n",
 209                 GetCurrentThreadId(), hInternet, dwContext,
 210                 (LPCSTR)lpvStatusInformation,dwStatusInformationLength);
 211             *(LPSTR)lpvStatusInformation = '\0';
 212             break;
 213         case INTERNET_STATUS_CONNECTED_TO_SERVER:
 214             trace("%04x:Callback %p 0x%lx INTERNET_STATUS_CONNECTED_TO_SERVER \"%s\" %d\n",
 215                 GetCurrentThreadId(), hInternet, dwContext,
 216                 (LPCSTR)lpvStatusInformation,dwStatusInformationLength);
 217             *(LPSTR)lpvStatusInformation = '\0';
 218             break;
 219         case INTERNET_STATUS_SENDING_REQUEST:
 220             trace("%04x:Callback %p 0x%lx INTERNET_STATUS_SENDING_REQUEST %p %d\n",
 221                 GetCurrentThreadId(), hInternet, dwContext,
 222                 lpvStatusInformation,dwStatusInformationLength);
 223             break;
 224         case INTERNET_STATUS_REQUEST_SENT:
 225             ok(dwStatusInformationLength == sizeof(DWORD),
 226                 "info length should be sizeof(DWORD) instead of %d\n",
 227                 dwStatusInformationLength);
 228             trace("%04x:Callback %p 0x%lx INTERNET_STATUS_REQUEST_SENT 0x%x %d\n",
 229                 GetCurrentThreadId(), hInternet, dwContext,
 230                 *(DWORD *)lpvStatusInformation,dwStatusInformationLength);
 231             break;
 232         case INTERNET_STATUS_RECEIVING_RESPONSE:
 233             trace("%04x:Callback %p 0x%lx INTERNET_STATUS_RECEIVING_RESPONSE %p %d\n",
 234                 GetCurrentThreadId(), hInternet, dwContext,
 235                 lpvStatusInformation,dwStatusInformationLength);
 236             break;
 237         case INTERNET_STATUS_RESPONSE_RECEIVED:
 238             ok(dwStatusInformationLength == sizeof(DWORD),
 239                 "info length should be sizeof(DWORD) instead of %d\n",
 240                 dwStatusInformationLength);
 241             trace("%04x:Callback %p 0x%lx INTERNET_STATUS_RESPONSE_RECEIVED 0x%x %d\n",
 242                 GetCurrentThreadId(), hInternet, dwContext,
 243                 *(DWORD *)lpvStatusInformation,dwStatusInformationLength);
 244             break;
 245         case INTERNET_STATUS_CTL_RESPONSE_RECEIVED:
 246             trace("%04x:Callback %p 0x%lx INTERNET_STATUS_CTL_RESPONSE_RECEIVED %p %d\n",
 247                 GetCurrentThreadId(), hInternet,dwContext,
 248                 lpvStatusInformation,dwStatusInformationLength);
 249             break;
 250         case INTERNET_STATUS_PREFETCH:
 251             trace("%04x:Callback %p 0x%lx INTERNET_STATUS_PREFETCH %p %d\n",
 252                 GetCurrentThreadId(), hInternet, dwContext,
 253                 lpvStatusInformation,dwStatusInformationLength);
 254             break;
 255         case INTERNET_STATUS_CLOSING_CONNECTION:
 256             trace("%04x:Callback %p 0x%lx INTERNET_STATUS_CLOSING_CONNECTION %p %d\n",
 257                 GetCurrentThreadId(), hInternet, dwContext,
 258                 lpvStatusInformation,dwStatusInformationLength);
 259             break;
 260         case INTERNET_STATUS_CONNECTION_CLOSED:
 261             trace("%04x:Callback %p 0x%lx INTERNET_STATUS_CONNECTION_CLOSED %p %d\n",
 262                 GetCurrentThreadId(), hInternet, dwContext,
 263                 lpvStatusInformation,dwStatusInformationLength);
 264             break;
 265         case INTERNET_STATUS_HANDLE_CREATED:
 266             ok(dwStatusInformationLength == sizeof(HINTERNET),
 267                 "info length should be sizeof(HINTERNET) instead of %d\n",
 268                 dwStatusInformationLength);
 269             trace("%04x:Callback %p 0x%lx INTERNET_STATUS_HANDLE_CREATED %p %d\n",
 270                 GetCurrentThreadId(), hInternet, dwContext,
 271                 *(HINTERNET *)lpvStatusInformation,dwStatusInformationLength);
 272             CLEAR_NOTIFIED(INTERNET_STATUS_DETECTING_PROXY);
 273             SET_EXPECT(INTERNET_STATUS_DETECTING_PROXY);
 274             break;
 275         case INTERNET_STATUS_HANDLE_CLOSING:
 276             ok(dwStatusInformationLength == sizeof(HINTERNET),
 277                 "info length should be sizeof(HINTERNET) instead of %d\n",
 278                 dwStatusInformationLength);
 279             trace("%04x:Callback %p 0x%lx INTERNET_STATUS_HANDLE_CLOSING %p %d\n",
 280                 GetCurrentThreadId(), hInternet, dwContext,
 281                 *(HINTERNET *)lpvStatusInformation, dwStatusInformationLength);
 282             if(!--close_handle_cnt)
 283                 SetEvent(hCompleteEvent);
 284             break;
 285         case INTERNET_STATUS_REQUEST_COMPLETE:
 286         {
 287             INTERNET_ASYNC_RESULT *iar = (INTERNET_ASYNC_RESULT *)lpvStatusInformation;
 288             ok(dwStatusInformationLength == sizeof(INTERNET_ASYNC_RESULT),
 289                 "info length should be sizeof(INTERNET_ASYNC_RESULT) instead of %d\n",
 290                 dwStatusInformationLength);
 291             ok(iar->dwResult == 1 || iar->dwResult == 0, "iar->dwResult = %ld\n", iar->dwResult);
 292             trace("%04x:Callback %p 0x%lx INTERNET_STATUS_REQUEST_COMPLETE {%ld,%d} %d\n",
 293                 GetCurrentThreadId(), hInternet, dwContext,
 294                 iar->dwResult,iar->dwError,dwStatusInformationLength);
 295             req_error = iar->dwError;
 296             SetEvent(hCompleteEvent);
 297             break;
 298         }
 299         case INTERNET_STATUS_REDIRECT:
 300             trace("%04x:Callback %p 0x%lx INTERNET_STATUS_REDIRECT \"%s\" %d\n",
 301                 GetCurrentThreadId(), hInternet, dwContext,
 302                 (LPCSTR)lpvStatusInformation, dwStatusInformationLength);
 303             *(LPSTR)lpvStatusInformation = '\0';
 304             CLEAR_NOTIFIED(INTERNET_STATUS_DETECTING_PROXY);
 305             SET_EXPECT(INTERNET_STATUS_DETECTING_PROXY);
 306             break;
 307         case INTERNET_STATUS_INTERMEDIATE_RESPONSE:
 308             trace("%04x:Callback %p 0x%lx INTERNET_STATUS_INTERMEDIATE_RESPONSE %p %d\n",
 309                 GetCurrentThreadId(), hInternet, dwContext,
 310                 lpvStatusInformation, dwStatusInformationLength);
 311             break;
 312         default:
 313             trace("%04x:Callback %p 0x%lx %d %p %d\n",
 314                 GetCurrentThreadId(), hInternet, dwContext, dwInternetStatus,
 315                 lpvStatusInformation, dwStatusInformationLength);
 316     }
 317 }
 318
 319 static void close_async_handle(HINTERNET handle, HANDLE complete_event, int handle_cnt)
 320 {
 321     BOOL res;
 322
 323     close_handle_cnt = handle_cnt;
 324
 325     SET_EXPECT2(INTERNET_STATUS_HANDLE_CLOSING, handle_cnt);
 326     res = InternetCloseHandle(handle);
 327     ok(res, "InternetCloseHandle failed: %u\n", GetLastError());
 328     WaitForSingleObject(hCompleteEvent, INFINITE);
 329     CHECK_NOTIFIED2(INTERNET_STATUS_HANDLE_CLOSING, handle_cnt);
 330     SET_EXPECT2(INTERNET_STATUS_HANDLE_CLOSING, handle_cnt);
 331 }
 332
 333 static void InternetReadFile_test(int flags, const test_data_t *test)
 334 {
 335     char *post_data = NULL;
 336     BOOL res, on_async = TRUE;
 337     CHAR buffer[4000];
 338     DWORD length, post_len = 0;
 339     DWORD out;
 340     const char *types[2] = { "*", NULL };
 341     HINTERNET hi, hic = 0, hor = 0;
 342
 343     hCompleteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 344
 345     trace("Starting InternetReadFile test with flags 0x%x on url %s\n",flags,test->url);
 346
 347     trace("InternetOpenA <--\n");
 348     hi = InternetOpenA((test->flags & TESTF_COMPRESSED) ? "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0)" : "",
 349             INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, flags);
 350     ok((hi != 0x0),"InternetOpen failed with error %u\n", GetLastError());
 351     trace("InternetOpenA -->\n");
 352
 353     if (hi == 0x0) goto abort;
 354
 355     pInternetSetStatusCallbackA(hi,&callback);
 356
 357     SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED);
 358
 359     trace("InternetConnectA <--\n");
 360     hic=InternetConnectA(hi, test->host, INTERNET_INVALID_PORT_NUMBER,
 361                          NULL, NULL, INTERNET_SERVICE_HTTP, 0x0, 0xdeadbeef);
 362     ok((hic != 0x0),"InternetConnect failed with error %u\n", GetLastError());
 363     trace("InternetConnectA -->\n");
 364
 365     if (hic == 0x0) goto abort;
 366
 367     CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED);
 368     SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED);
 369
 370     trace("HttpOpenRequestA <--\n");
 371     hor = HttpOpenRequestA(hic, test->post_data ? "POST" : "GET", test->path, NULL, NULL, types,
 372                            INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_RESYNCHRONIZE,
 373                            0xdeadbead);
 374     if (hor == 0x0 && GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED) {
 375         /*
 376          * If the internet name can't be resolved we are probably behind
 377          * a firewall or in some other way not directly connected to the
 378          * Internet. Not enough reason to fail the test. Just ignore and
 379          * abort.
 380          */
 381     } else  {
 382         ok((hor != 0x0),"HttpOpenRequest failed with error %u\n", GetLastError());
 383     }
 384     trace("HttpOpenRequestA -->\n");
 385
 386     if (hor == 0x0) goto abort;
 387
 388     length = sizeof(buffer);
 389     res = InternetQueryOptionA(hor, INTERNET_OPTION_URL, buffer, &length);
 390     ok(res, "InternetQueryOptionA(INTERNET_OPTION_URL) failed: %u\n", GetLastError());
 391     ok(!strcmp(buffer, test->url), "Wrong URL %s, expected %s\n", buffer, test->url);
 392
 393     length = sizeof(buffer);
 394     res = HttpQueryInfoA(hor, HTTP_QUERY_RAW_HEADERS, buffer, &length, 0x0);
 395     ok(res, "HttpQueryInfoA(HTTP_QUERY_RAW_HEADERS) failed with error %d\n", GetLastError());
 396     ok(length == 0, "HTTP_QUERY_RAW_HEADERS: expected length 0, but got %d\n", length);
 397     ok(!strcmp(buffer, ""), "HTTP_QUERY_RAW_HEADERS: expected string \"\", but got \"%s\"\n", buffer);
 398
 399     CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED);
 400     CHECK_NOT_NOTIFIED(INTERNET_STATUS_RESOLVING_NAME);
 401     CHECK_NOT_NOTIFIED(INTERNET_STATUS_NAME_RESOLVED);
 402     if(test->flags & TESTF_ALLOW_COOKIE) {
 403         SET_OPTIONAL(INTERNET_STATUS_COOKIE_SENT);
 404         SET_OPTIONAL(INTERNET_STATUS_COOKIE_RECEIVED);
 405     }
 406     if (first_connection_to_test_url)
 407     {
 408         SET_EXPECT(INTERNET_STATUS_RESOLVING_NAME);
 409         SET_EXPECT(INTERNET_STATUS_NAME_RESOLVED);
 410     }
 411     SET_EXPECT(INTERNET_STATUS_CONNECTING_TO_SERVER);
 412     SET_EXPECT(INTERNET_STATUS_CONNECTED_TO_SERVER);
 413     SET_EXPECT2(INTERNET_STATUS_SENDING_REQUEST, (test->flags & TESTF_REDIRECT) ? 2 : 1);
 414     SET_EXPECT2(INTERNET_STATUS_REQUEST_SENT, (test->flags & TESTF_REDIRECT) ? 2 : 1);
 415     SET_EXPECT2(INTERNET_STATUS_RECEIVING_RESPONSE, (test->flags & TESTF_REDIRECT) ? 2 : 1);
 416     SET_EXPECT2(INTERNET_STATUS_RESPONSE_RECEIVED, (test->flags & TESTF_REDIRECT) ? 2 : 1);
 417     if(test->flags & TESTF_REDIRECT) {
 418         SET_OPTIONAL2(INTERNET_STATUS_CLOSING_CONNECTION, 2);
 419         SET_OPTIONAL2(INTERNET_STATUS_CONNECTION_CLOSED, 2);
 420     }
 421     SET_EXPECT(INTERNET_STATUS_REDIRECT);
 422     SET_OPTIONAL(INTERNET_STATUS_CONNECTING_TO_SERVER);
 423     SET_OPTIONAL(INTERNET_STATUS_CONNECTED_TO_SERVER);
 424     if (flags & INTERNET_FLAG_ASYNC)
 425         SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE);
 426
 427     if(test->flags & TESTF_COMPRESSED) {
 428         BOOL b = TRUE;
 429
 430         res = InternetSetOption(hor, INTERNET_OPTION_HTTP_DECODING, &b, sizeof(b));
 431         ok(res || broken(!res && GetLastError() == ERROR_INTERNET_INVALID_OPTION),
 432            "InternetSetOption failed: %u\n", GetLastError());
 433         if(!res)
 434             goto abort;
 435     }
 436
 437     trace("HttpSendRequestA -->\n");
 438     if(test->post_data) {
 439         post_len = strlen(test->post_data);
 440         post_data = HeapAlloc(GetProcessHeap(), 0, post_len);
 441         memcpy(post_data, test->post_data, post_len);
 442     }
 443     SetLastError(0xdeadbeef);
 444     res = HttpSendRequestA(hor, test->headers, -1, post_data, post_len);
 445     if (flags & INTERNET_FLAG_ASYNC)
 446         ok(!res && (GetLastError() == ERROR_IO_PENDING),
 447             "Asynchronous HttpSendRequest NOT returning 0 with error ERROR_IO_PENDING\n");
 448     else
 449         ok(res || (GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED),
 450            "Synchronous HttpSendRequest returning 0, error %u\n", GetLastError());
 451     trace("HttpSendRequestA <--\n");
 452
 453     if (flags & INTERNET_FLAG_ASYNC) {
 454         WaitForSingleObject(hCompleteEvent, INFINITE);
 455         ok(req_error == ERROR_SUCCESS, "req_error = %u\n", req_error);
 456     }
 457     HeapFree(GetProcessHeap(), 0, post_data);
 458
 459     if(test->flags & TESTF_ALLOW_COOKIE) {
 460         CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_SENT);
 461         CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_RECEIVED);
 462     }
 463     if (first_connection_to_test_url)
 464     {
 465         if (! proxy_active())
 466         {
 467             CHECK_NOTIFIED(INTERNET_STATUS_RESOLVING_NAME);
 468             CHECK_NOTIFIED(INTERNET_STATUS_NAME_RESOLVED);
 469         }
 470         else
 471         {
 472             CLEAR_NOTIFIED(INTERNET_STATUS_RESOLVING_NAME);
 473             CLEAR_NOTIFIED(INTERNET_STATUS_NAME_RESOLVED);
 474         }
 475     }
 476     else
 477     {
 478         CHECK_NOT_NOTIFIED(INTERNET_STATUS_RESOLVING_NAME);
 479         CHECK_NOT_NOTIFIED(INTERNET_STATUS_NAME_RESOLVED);
 480     }
 481     CHECK_NOTIFIED2(INTERNET_STATUS_SENDING_REQUEST, (test->flags & TESTF_REDIRECT) ? 2 : 1);
 482     CHECK_NOTIFIED2(INTERNET_STATUS_REQUEST_SENT, (test->flags & TESTF_REDIRECT) ? 2 : 1);
 483     CHECK_NOTIFIED2(INTERNET_STATUS_RECEIVING_RESPONSE, (test->flags & TESTF_REDIRECT) ? 2 : 1);
 484     CHECK_NOTIFIED2(INTERNET_STATUS_RESPONSE_RECEIVED, (test->flags & TESTF_REDIRECT) ? 2 : 1);
 485     if(test->flags & TESTF_REDIRECT)
 486         CHECK_NOTIFIED(INTERNET_STATUS_REDIRECT);
 487     if (flags & INTERNET_FLAG_ASYNC)
 488         CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE);
 489     /* Sent on WinXP only if first_connection_to_test_url is TRUE, on Win98 always sent */
 490     CLEAR_NOTIFIED(INTERNET_STATUS_CONNECTING_TO_SERVER);
 491     CLEAR_NOTIFIED(INTERNET_STATUS_CONNECTED_TO_SERVER);
 492
 493     length = 4;
 494     res = InternetQueryOptionA(hor,INTERNET_OPTION_REQUEST_FLAGS,&out,&length);
 495     ok(res, "InternetQueryOptionA(INTERNET_OPTION_REQUEST) failed with error %d\n", GetLastError());
 496
 497     length = 100;
 498     res = InternetQueryOptionA(hor,INTERNET_OPTION_URL,buffer,&length);
 499     ok(res, "InternetQueryOptionA(INTERNET_OPTION_URL) failed with error %d\n", GetLastError());
 500
 501     length = sizeof(buffer);
 502     res = HttpQueryInfoA(hor,HTTP_QUERY_RAW_HEADERS,buffer,&length,0x0);
 503     ok(res, "HttpQueryInfoA(HTTP_QUERY_RAW_HEADERS) failed with error %d\n", GetLastError());
 504     buffer[length]=0;
 505
 506     length = sizeof(buffer);
 507     res = InternetQueryOptionA(hor, INTERNET_OPTION_URL, buffer, &length);
 508     ok(res, "InternetQueryOptionA(INTERNET_OPTION_URL) failed: %u\n", GetLastError());
 509     ok(!strcmp(buffer, test->redirected_url), "Wrong URL %s\n", buffer);
 510
 511     length = 16;
 512     res = HttpQueryInfoA(hor,HTTP_QUERY_CONTENT_LENGTH,&buffer,&length,0x0);
 513     trace("Option HTTP_QUERY_CONTENT_LENGTH -> %i  %s  (%u)\n",res,buffer,GetLastError());
 514     if(test->flags & TESTF_COMPRESSED)
 515         ok(!res && GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND,
 516            "expected ERROR_HTTP_HEADER_NOT_FOUND, got %x (%u)\n", res, GetLastError());
 517
 518     length = 100;
 519     res = HttpQueryInfoA(hor,HTTP_QUERY_CONTENT_TYPE,buffer,&length,0x0);
 520     buffer[length]=0;
 521     trace("Option HTTP_QUERY_CONTENT_TYPE -> %i  %s\n",res,buffer);
 522
 523     length = 100;
 524     res = HttpQueryInfoA(hor,HTTP_QUERY_CONTENT_ENCODING,buffer,&length,0x0);
 525     buffer[length]=0;
 526     trace("Option HTTP_QUERY_CONTENT_ENCODING -> %i  %s\n",res,buffer);
 527
 528     SetLastError(0xdeadbeef);
 529     res = InternetReadFile(NULL, buffer, 100, &length);
 530     ok(!res, "InternetReadFile should have failed\n");
 531     ok(GetLastError() == ERROR_INVALID_HANDLE,
 532         "InternetReadFile should have set last error to ERROR_INVALID_HANDLE instead of %u\n",
 533         GetLastError());
 534
 535     length = 100;
 536     trace("Entering Query loop\n");
 537
 538     while (TRUE)
 539     {
 540         if (flags & INTERNET_FLAG_ASYNC)
 541             SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE);
 542         res = InternetQueryDataAvailable(hor,&length,0x0,0x0);
 543         if (flags & INTERNET_FLAG_ASYNC)
 544         {
 545             if (res)
 546             {
 547                 CHECK_NOT_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE);
 548             }
 549             else if (GetLastError() == ERROR_IO_PENDING)
 550             {
 551                 trace("PENDING\n");
 552                 /* on some tests, InternetQueryDataAvailable returns non-zero length and ERROR_IO_PENDING */
 553                 if(!(test->flags & TESTF_CHUNKED))
 554                     ok(!length, "InternetQueryDataAvailable returned ERROR_IO_PENDING and %u length\n", length);
 555                 WaitForSingleObject(hCompleteEvent, INFINITE);
 556                 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE);
 557                 ok(req_error, "req_error = 0\n");
 558                 continue;
 559             }else {
 560                 ok(0, "InternetQueryDataAvailable failed: %u\n", GetLastError());
 561             }
 562         }else {
 563             ok(res, "InternetQueryDataAvailable failed: %u\n", GetLastError());
 564         }
 565         trace("LENGTH %d\n", length);
 566         if(test->flags & TESTF_CHUNKED)
 567             ok(length <= 8192, "length = %d, expected <= 8192\n", length);
 568         if (length)
 569         {
 570             char *buffer;
 571             buffer = HeapAlloc(GetProcessHeap(),0,length+1);
 572
 573             res = InternetReadFile(hor,buffer,length,&length);
 574
 575             buffer[length]=0;
 576
 577             trace("ReadFile -> %s %i\n",res?"TRUE":"FALSE",length);
 578
 579             if(test->content)
 580                 ok(!strcmp(buffer, test->content), "buffer = '%s', expected '%s'\n", buffer, test->content);
 581             HeapFree(GetProcessHeap(),0,buffer);
 582         }else {
 583             ok(!on_async, "Returned zero size in response to request complete\n");
 584             break;
 585         }
 586         on_async = FALSE;
 587     }
 588     if(test->flags & TESTF_REDIRECT) {
 589         CHECK_NOTIFIED2(INTERNET_STATUS_CLOSING_CONNECTION, 2);
 590         CHECK_NOTIFIED2(INTERNET_STATUS_CONNECTION_CLOSED, 2);
 591     }
 592 abort:
 593     trace("aborting\n");
 594     close_async_handle(hi, hCompleteEvent, 2);
 595     CloseHandle(hCompleteEvent);
 596     first_connection_to_test_url = FALSE;
 597 }
 598
 599 static void InternetReadFile_chunked_test(void)
 600 {
 601     BOOL res;
 602     CHAR buffer[4000];
 603     DWORD length;
 604     const char *types[2] = { "*", NULL };
 605     HINTERNET hi, hic = 0, hor = 0;
 606
 607     trace("Starting InternetReadFile chunked test\n");
 608
 609     trace("InternetOpenA <--\n");
 610     hi = InternetOpenA("", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
 611     ok((hi != 0x0),"InternetOpen failed with error %u\n", GetLastError());
 612     trace("InternetOpenA -->\n");
 613
 614     if (hi == 0x0) goto abort;
 615
 616     trace("InternetConnectA <--\n");
 617     hic=InternetConnectA(hi, "test.winehq.org", INTERNET_INVALID_PORT_NUMBER,
 618                          NULL, NULL, INTERNET_SERVICE_HTTP, 0x0, 0xdeadbeef);
 619     ok((hic != 0x0),"InternetConnect failed with error %u\n", GetLastError());
 620     trace("InternetConnectA -->\n");
 621
 622     if (hic == 0x0) goto abort;
 623
 624     trace("HttpOpenRequestA <--\n");
 625     hor = HttpOpenRequestA(hic, "GET", "/tests/chunked", NULL, NULL, types,
 626                            INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_RESYNCHRONIZE,
 627                            0xdeadbead);
 628     if (hor == 0x0 && GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED) {
 629         /*
 630          * If the internet name can't be resolved we are probably behind
 631          * a firewall or in some other way not directly connected to the
 632          * Internet. Not enough reason to fail the test. Just ignore and
 633          * abort.
 634          */
 635     } else  {
 636         ok((hor != 0x0),"HttpOpenRequest failed with error %u\n", GetLastError());
 637     }
 638     trace("HttpOpenRequestA -->\n");
 639
 640     if (hor == 0x0) goto abort;
 641
 642     trace("HttpSendRequestA -->\n");
 643     SetLastError(0xdeadbeef);
 644     res = HttpSendRequestA(hor, "", -1, NULL, 0);
 645     ok(res || (GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED),
 646        "Synchronous HttpSendRequest returning 0, error %u\n", GetLastError());
 647     trace("HttpSendRequestA <--\n");
 648
 649     length = 100;
 650     res = HttpQueryInfoA(hor,HTTP_QUERY_CONTENT_TYPE,buffer,&length,0x0);
 651     buffer[length]=0;
 652     trace("Option CONTENT_TYPE -> %i  %s\n",res,buffer);
 653
 654     SetLastError( 0xdeadbeef );
 655     length = 100;
 656     res = HttpQueryInfoA(hor,HTTP_QUERY_TRANSFER_ENCODING,buffer,&length,0x0);
 657     buffer[length]=0;
 658     trace("Option TRANSFER_ENCODING -> %i  %s\n",res,buffer);
 659     ok( res || ( proxy_active() && GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND ),
 660         "Failed to get TRANSFER_ENCODING option, error %u\n", GetLastError() );
 661     ok( !strcmp( buffer, "chunked" ) || ( ! res && proxy_active() && GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND ),
 662         "Wrong transfer encoding '%s'\n", buffer );
 663
 664     SetLastError( 0xdeadbeef );
 665     length = 16;
 666     res = HttpQueryInfoA(hor,HTTP_QUERY_CONTENT_LENGTH,&buffer,&length,0x0);
 667     ok( !res, "Found CONTENT_LENGTH option '%s'\n", buffer );
 668     ok( GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND, "Wrong error %u\n", GetLastError() );
 669
 670     length = 100;
 671     trace("Entering Query loop\n");
 672
 673     while (TRUE)
 674     {
 675         res = InternetQueryDataAvailable(hor,&length,0x0,0x0);
 676         ok(!(!res && length != 0),"InternetQueryDataAvailable failed with non-zero length\n");
 677         ok(res, "InternetQueryDataAvailable failed, error %d\n", GetLastError());
 678         trace("got %u available\n",length);
 679         if (length)
 680         {
 681             DWORD got;
 682             char *buffer = HeapAlloc(GetProcessHeap(),0,length+1);
 683
 684             res = InternetReadFile(hor,buffer,length,&got);
 685
 686             buffer[got]=0;
 687             trace("ReadFile -> %i %i\n",res,got);
 688             ok( length == got, "only got %u of %u available\n", got, length );
 689             ok( buffer[got-1] == '\n', "received partial line '%s'\n", buffer );
 690
 691             HeapFree(GetProcessHeap(),0,buffer);
 692             if (!got) break;
 693         }
 694         if (length == 0)
 695             break;
 696     }
 697 abort:
 698     trace("aborting\n");
 699     if (hor != 0x0) {
 700         res = InternetCloseHandle(hor);
 701         ok (res, "InternetCloseHandle of handle opened by HttpOpenRequestA failed\n");
 702     }
 703     if (hi != 0x0) {
 704         res = InternetCloseHandle(hi);
 705         ok (res, "InternetCloseHandle of handle opened by InternetOpenA failed\n");
 706     }
 707 }
 708
 709 static void InternetReadFileExA_test(int flags)
 710 {
 711     DWORD rc;
 712     DWORD length;
 713     const char *types[2] = { "*", NULL };
 714     HINTERNET hi, hic = 0, hor = 0;
 715     INTERNET_BUFFERS inetbuffers;
 716
 717     hCompleteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
 718
 719     trace("Starting InternetReadFileExA test with flags 0x%x\n",flags);
 720
 721     trace("InternetOpenA <--\n");
 722     hi = InternetOpenA("", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, flags);
 723     ok((hi != 0x0),"InternetOpen failed with error %u\n", GetLastError());
 724     trace("InternetOpenA -->\n");
 725
 726     if (hi == 0x0) goto abort;
 727
 728     pInternetSetStatusCallbackA(hi,&callback);
 729
 730     SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED);
 731
 732     trace("InternetConnectA <--\n");
 733     hic=InternetConnectA(hi, "test.winehq.org", INTERNET_INVALID_PORT_NUMBER,
 734                          NULL, NULL, INTERNET_SERVICE_HTTP, 0x0, 0xdeadbeef);
 735     ok((hic != 0x0),"InternetConnect failed with error %u\n", GetLastError());
 736     trace("InternetConnectA -->\n");
 737
 738     if (hic == 0x0) goto abort;
 739
 740     CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED);
 741     SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED);
 742
 743     trace("HttpOpenRequestA <--\n");
 744     hor = HttpOpenRequestA(hic, "GET", "/tests/redirect", NULL, NULL, types,
 745                            INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_RESYNCHRONIZE,
 746                            0xdeadbead);
 747     if (hor == 0x0 && GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED) {
 748         /*
 749          * If the internet name can't be resolved we are probably behind
 750          * a firewall or in some other way not directly connected to the
 751          * Internet. Not enough reason to fail the test. Just ignore and
 752          * abort.
 753          */
 754     } else  {
 755         ok((hor != 0x0),"HttpOpenRequest failed with error %u\n", GetLastError());
 756     }
 757     trace("HttpOpenRequestA -->\n");
 758
 759     if (hor == 0x0) goto abort;
 760
 761     CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED);
 762     CHECK_NOT_NOTIFIED(INTERNET_STATUS_RESOLVING_NAME);
 763     CHECK_NOT_NOTIFIED(INTERNET_STATUS_NAME_RESOLVED);
 764     if (first_connection_to_test_url)
 765     {
 766         SET_EXPECT(INTERNET_STATUS_RESOLVING_NAME);
 767         SET_EXPECT(INTERNET_STATUS_NAME_RESOLVED);
 768     }
 769     SET_EXPECT(INTERNET_STATUS_CONNECTING_TO_SERVER);
 770     SET_EXPECT(INTERNET_STATUS_CONNECTED_TO_SERVER);
 771     SET_EXPECT2(INTERNET_STATUS_SENDING_REQUEST, 2);
 772     SET_EXPECT2(INTERNET_STATUS_REQUEST_SENT, 2);
 773     SET_EXPECT2(INTERNET_STATUS_RECEIVING_RESPONSE, 2);
 774     SET_EXPECT2(INTERNET_STATUS_RESPONSE_RECEIVED, 2);
 775     SET_OPTIONAL2(INTERNET_STATUS_CLOSING_CONNECTION, 2);
 776     SET_OPTIONAL2(INTERNET_STATUS_CONNECTION_CLOSED, 2);
 777     SET_EXPECT(INTERNET_STATUS_REDIRECT);
 778     SET_OPTIONAL(INTERNET_STATUS_CONNECTING_TO_SERVER);
 779     SET_OPTIONAL(INTERNET_STATUS_CONNECTED_TO_SERVER);
 780     if (flags & INTERNET_FLAG_ASYNC)
 781         SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE);
 782     else
 783         SET_WINE_ALLOW(INTERNET_STATUS_REQUEST_COMPLETE);
 784
 785     trace("HttpSendRequestA -->\n");
 786     SetLastError(0xdeadbeef);
 787     rc = HttpSendRequestA(hor, "", -1, NULL, 0);
 788     if (flags & INTERNET_FLAG_ASYNC)
 789         ok(((rc == 0)&&(GetLastError() == ERROR_IO_PENDING)),
 790             "Asynchronous HttpSendRequest NOT returning 0 with error ERROR_IO_PENDING\n");
 791     else
 792         ok((rc != 0) || GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED,
 793            "Synchronous HttpSendRequest returning 0, error %u\n", GetLastError());
 794     trace("HttpSendRequestA <--\n");
 795
 796     if (!rc && (GetLastError() == ERROR_IO_PENDING)) {
 797         WaitForSingleObject(hCompleteEvent, INFINITE);
 798         ok(req_error == ERROR_SUCCESS, "req_error = %u\n", req_error);
 799     }
 800
 801     if (first_connection_to_test_url)
 802     {
 803         CHECK_NOTIFIED(INTERNET_STATUS_RESOLVING_NAME);
 804         CHECK_NOTIFIED(INTERNET_STATUS_NAME_RESOLVED);
 805     }
 806     else
 807     {
 808         CHECK_NOT_NOTIFIED(INTERNET_STATUS_RESOLVING_NAME);
 809         CHECK_NOT_NOTIFIED(INTERNET_STATUS_NAME_RESOLVED);
 810     }
 811     CHECK_NOTIFIED2(INTERNET_STATUS_SENDING_REQUEST, 2);
 812     CHECK_NOTIFIED2(INTERNET_STATUS_REQUEST_SENT, 2);
 813     CHECK_NOTIFIED2(INTERNET_STATUS_RECEIVING_RESPONSE, 2);
 814     CHECK_NOTIFIED2(INTERNET_STATUS_RESPONSE_RECEIVED, 2);
 815     CHECK_NOTIFIED2(INTERNET_STATUS_CLOSING_CONNECTION, 2);
 816     CHECK_NOTIFIED2(INTERNET_STATUS_CONNECTION_CLOSED, 2);
 817     CHECK_NOTIFIED(INTERNET_STATUS_REDIRECT);
 818     if (flags & INTERNET_FLAG_ASYNC)
 819         CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE);
 820     else
 821         todo_wine CHECK_NOT_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE);
 822     /* Sent on WinXP only if first_connection_to_test_url is TRUE, on Win98 always sent */
 823     CLEAR_NOTIFIED(INTERNET_STATUS_CONNECTING_TO_SERVER);
 824     CLEAR_NOTIFIED(INTERNET_STATUS_CONNECTED_TO_SERVER);
 825
 826     /* tests invalid dwStructSize */
 827     inetbuffers.dwStructSize = sizeof(INTERNET_BUFFERS)+1;
 828     inetbuffers.lpcszHeader = NULL;
 829     inetbuffers.dwHeadersLength = 0;
 830     inetbuffers.dwBufferLength = 10;
 831     inetbuffers.lpvBuffer = HeapAlloc(GetProcessHeap(), 0, 10);
 832     inetbuffers.dwOffsetHigh = 1234;
 833     inetbuffers.dwOffsetLow = 5678;
 834     rc = InternetReadFileEx(hor, &inetbuffers, 0, 0xdeadcafe);
 835     ok(!rc && (GetLastError() == ERROR_INVALID_PARAMETER),
 836         "InternetReadFileEx should have failed with ERROR_INVALID_PARAMETER instead of %s, %u\n",
 837         rc ? "TRUE" : "FALSE", GetLastError());
 838     HeapFree(GetProcessHeap(), 0, inetbuffers.lpvBuffer);
 839
 840     /* tests to see whether lpcszHeader is used - it isn't */
 841     inetbuffers.dwStructSize = sizeof(INTERNET_BUFFERS);
 842     inetbuffers.lpcszHeader = (LPCTSTR)0xdeadbeef;
 843     inetbuffers.dwHeadersLength = 255;
 844     inetbuffers.dwBufferLength = 0;
 845     inetbuffers.lpvBuffer = NULL;
 846     inetbuffers.dwOffsetHigh = 1234;
 847     inetbuffers.dwOffsetLow = 5678;
 848     SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE);
 849     SET_EXPECT(INTERNET_STATUS_RESPONSE_RECEIVED);
 850     rc = InternetReadFileEx(hor, &inetbuffers, 0, 0xdeadcafe);
 851     ok(rc, "InternetReadFileEx failed with error %u\n", GetLastError());
 852         trace("read %i bytes\n", inetbuffers.dwBufferLength);
 853     todo_wine
 854     {
 855         CHECK_NOT_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE);
 856         CHECK_NOT_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED);
 857     }
 858
 859     rc = InternetReadFileEx(NULL, &inetbuffers, 0, 0xdeadcafe);
 860     ok(!rc && (GetLastError() == ERROR_INVALID_HANDLE),
 861         "InternetReadFileEx should have failed with ERROR_INVALID_HANDLE instead of %s, %u\n",
 862         rc ? "TRUE" : "FALSE", GetLastError());
 863
 864     length = 0;
 865     trace("Entering Query loop\n");
 866
 867     while (TRUE)
 868     {
 869         inetbuffers.dwStructSize = sizeof(INTERNET_BUFFERS);
 870         inetbuffers.dwBufferLength = 1024;
 871         inetbuffers.lpvBuffer = HeapAlloc(GetProcessHeap(), 0, inetbuffers.dwBufferLength+1);
 872         inetbuffers.dwOffsetHigh = 1234;
 873         inetbuffers.dwOffsetLow = 5678;
 874
 875         SET_WINE_ALLOW(INTERNET_STATUS_RECEIVING_RESPONSE);
 876         SET_WINE_ALLOW(INTERNET_STATUS_RESPONSE_RECEIVED);
 877         SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE);
 878         rc = InternetReadFileExA(hor, &inetbuffers, IRF_ASYNC | IRF_USE_CONTEXT, 0xcafebabe);
 879         if (!rc)
 880         {
 881             if (GetLastError() == ERROR_IO_PENDING)
 882             {
 883                 trace("InternetReadFileEx -> PENDING\n");
 884                 ok(flags & INTERNET_FLAG_ASYNC,
 885                    "Should not get ERROR_IO_PENDING without INTERNET_FLAG_ASYNC\n");
 886                 CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE);
 887                 WaitForSingleObject(hCompleteEvent, INFINITE);
 888                 CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE);
 889                 CHECK_NOT_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED);
 890                 ok(req_error == ERROR_SUCCESS, "req_error = %u\n", req_error);
 891             }
 892             else
 893             {
 894                 trace("InternetReadFileEx -> FAILED %u\n", GetLastError());
 895                 break;
 896             }
 897         }
 898         else
 899         {
 900             trace("InternetReadFileEx -> SUCCEEDED\n");
 901             CHECK_NOT_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE);
 902             if (inetbuffers.dwBufferLength)
 903             {
 904                 todo_wine {
 905                 CHECK_NOT_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE);
 906                 CHECK_NOT_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED);
 907                 }
 908             }
 909             else
 910             {
 911                 /* Win98 still sends these when 0 bytes are read, WinXP does not */
 912                 CLEAR_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE);
 913                 CLEAR_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED);
 914             }
 915         }
 916
 917         trace("read %i bytes\n", inetbuffers.dwBufferLength);
 918         ((char *)inetbuffers.lpvBuffer)[inetbuffers.dwBufferLength] = '\0';
 919
 920         ok(inetbuffers.dwOffsetHigh == 1234 && inetbuffers.dwOffsetLow == 5678,
 921             "InternetReadFileEx sets offsets to 0x%x%08x\n",
 922             inetbuffers.dwOffsetHigh, inetbuffers.dwOffsetLow);
 923
 924         HeapFree(GetProcessHeap(), 0, inetbuffers.lpvBuffer);
 925
 926         if (!inetbuffers.dwBufferLength)
 927             break;
 928
 929         length += inetbuffers.dwBufferLength;
 930     }
 931     ok(length > 0, "failed to read any of the document\n");
 932     trace("Finished. Read %d bytes\n", length);
 933
 934 abort:
 935     close_async_handle(hi, hCompleteEvent, 2);
 936     CloseHandle(hCompleteEvent);
 937     first_connection_to_test_url = FALSE;
 938 }
 939
 940 static void InternetOpenUrlA_test(void)
 941 {
 942   HINTERNET myhinternet, myhttp;
 943   char buffer[0x400];
 944   DWORD size, readbytes, totalbytes=0;
 945   BOOL ret;
 946
 947   myhinternet = InternetOpen("Winetest",0,NULL,NULL,INTERNET_FLAG_NO_CACHE_WRITE);
 948   ok((myhinternet != 0), "InternetOpen failed, error %u\n",GetLastError());
 949   size = 0x400;
 950   ret = InternetCanonicalizeUrl(TEST_URL, buffer, &size,ICU_BROWSER_MODE);
 951   ok( ret, "InternetCanonicalizeUrl failed, error %u\n",GetLastError());
 952
 953   SetLastError(0);
 954   myhttp = InternetOpenUrl(myhinternet, TEST_URL, 0, 0,
 955                            INTERNET_FLAG_RELOAD|INTERNET_FLAG_NO_CACHE_WRITE|INTERNET_FLAG_TRANSFER_BINARY,0);
 956   if (GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED)
 957     return; /* WinXP returns this when not connected to the net */
 958   ok((myhttp != 0),"InternetOpenUrl failed, error %u\n",GetLastError());
 959   ret = InternetReadFile(myhttp, buffer,0x400,&readbytes);
 960   ok( ret, "InternetReadFile failed, error %u\n",GetLastError());
 961   totalbytes += readbytes;
 962   while (readbytes && InternetReadFile(myhttp, buffer,0x400,&readbytes))
 963     totalbytes += readbytes;
 964   trace("read 0x%08x bytes\n",totalbytes);
 965
 966   InternetCloseHandle(myhttp);
 967   InternetCloseHandle(myhinternet);
 968 }
 969
 970 static void HttpSendRequestEx_test(void)
 971 {
 972     HINTERNET hSession;
 973     HINTERNET hConnect;
 974     HINTERNET hRequest;
 975
 976     INTERNET_BUFFERS BufferIn;
 977     DWORD dwBytesWritten, dwBytesRead, error;
 978     CHAR szBuffer[256];
 979     int i;
 980     BOOL ret;
 981
 982     static char szPostData[] = "mode=Test";
 983     static const char szContentType[] = "Content-Type: application/x-www-form-urlencoded";
 984
 985     hSession = InternetOpen("Wine Regression Test",
 986             INTERNET_OPEN_TYPE_PRECONFIG,NULL,NULL,0);
 987     ok( hSession != NULL ,"Unable to open Internet session\n");
 988     hConnect = InternetConnect(hSession, "crossover.codeweavers.com",
 989             INTERNET_DEFAULT_HTTP_PORT, NULL, NULL, INTERNET_SERVICE_HTTP, 0,
 990             0);
 991     ok( hConnect != NULL, "Unable to connect to http://crossover.codeweavers.com\n");
 992     hRequest = HttpOpenRequest(hConnect, "POST", "/posttest.php",
 993             NULL, NULL, NULL, INTERNET_FLAG_NO_CACHE_WRITE, 0);
 994     if (!hRequest && GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED)
 995     {
 996         skip( "Network unreachable, skipping test\n" );
 997         goto done;
 998     }
 999     ok( hRequest != NULL, "Failed to open request handle err %u\n", GetLastError());
1000
1001
1002     BufferIn.dwStructSize = sizeof( INTERNET_BUFFERS);
1003     BufferIn.Next = (LPINTERNET_BUFFERS)0xdeadcab;
1004     BufferIn.lpcszHeader = szContentType;
1005     BufferIn.dwHeadersLength = sizeof(szContentType)-1;
1006     BufferIn.dwHeadersTotal = sizeof(szContentType)-1;
1007     BufferIn.lpvBuffer = szPostData;
1008     BufferIn.dwBufferLength = 3;
1009     BufferIn.dwBufferTotal = sizeof(szPostData)-1;
1010     BufferIn.dwOffsetLow = 0;
1011     BufferIn.dwOffsetHigh = 0;
1012
1013     SetLastError(0xdeadbeef);
1014     ret = HttpSendRequestEx(hRequest, &BufferIn, NULL, 0 ,0);
1015     error = GetLastError();
1016     ok(ret, "HttpSendRequestEx Failed with error %u\n", error);
1017     ok(error == ERROR_SUCCESS, "expected ERROR_SUCCESS, got %u\n", error);
1018
1019     for (i = 3; szPostData[i]; i++)
1020         ok(InternetWriteFile(hRequest, &szPostData[i], 1, &dwBytesWritten),
1021                 "InternetWriteFile failed\n");
1022
1023     ok(HttpEndRequest(hRequest, NULL, 0, 0), "HttpEndRequest Failed\n");
1024
1025     ok(InternetReadFile(hRequest, szBuffer, 255, &dwBytesRead),
1026             "Unable to read response\n");
1027     szBuffer[dwBytesRead] = 0;
1028
1029     ok(dwBytesRead == 13,"Read %u bytes instead of 13\n",dwBytesRead);
1030     ok(strncmp(szBuffer,"mode => Test\n",dwBytesRead)==0 || broken(proxy_active()),"Got string %s\n",szBuffer);
1031
1032     ok(InternetCloseHandle(hRequest), "Close request handle failed\n");
1033 done:
1034     ok(InternetCloseHandle(hConnect), "Close connect handle failed\n");
1035     ok(InternetCloseHandle(hSession), "Close session handle failed\n");
1036 }
1037
1038 static void InternetOpenRequest_test(void)
1039 {
1040     HINTERNET session, connect, request;
1041     static const char *types[] = { "*", "", NULL };
1042     static const WCHAR slash[] = {'/', 0}, any[] = {'*', 0}, empty[] = {0};
1043     static const WCHAR *typesW[] = { any, empty, NULL };
1044     BOOL ret;
1045
1046     session = InternetOpenA("Wine Regression Test", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
1047     ok(session != NULL ,"Unable to open Internet session\n");
1048
1049     connect = InternetConnectA(session, NULL, INTERNET_DEFAULT_HTTP_PORT, NULL, NULL,
1050                               INTERNET_SERVICE_HTTP, 0, 0);
1051     ok(connect == NULL, "InternetConnectA should have failed\n");
1052     ok(GetLastError() == ERROR_INVALID_PARAMETER, "InternetConnectA with NULL server named should have failed with ERROR_INVALID_PARAMETER instead of %d\n", GetLastError());
1053
1054     connect = InternetConnectA(session, "", INTERNET_DEFAULT_HTTP_PORT, NULL, NULL,
1055                               INTERNET_SERVICE_HTTP, 0, 0);
1056     ok(connect == NULL, "InternetConnectA should have failed\n");
1057     ok(GetLastError() == ERROR_INVALID_PARAMETER, "InternetConnectA with blank server named should have failed with ERROR_INVALID_PARAMETER instead of %d\n", GetLastError());
1058
1059     connect = InternetConnectA(session, "test.winehq.org", INTERNET_DEFAULT_HTTP_PORT, NULL, NULL,
1060                               INTERNET_SERVICE_HTTP, 0, 0);
1061     ok(connect != NULL, "Unable to connect to http://test.winehq.org with error %d\n", GetLastError());
1062
1063     request = HttpOpenRequestA(connect, NULL, "/", NULL, NULL, types, INTERNET_FLAG_NO_CACHE_WRITE, 0);
1064     if (!request && GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED)
1065     {
1066         skip( "Network unreachable, skipping test\n" );
1067         goto done;
1068     }
1069     ok(request != NULL, "Failed to open request handle err %u\n", GetLastError());
1070
1071     ret = HttpSendRequest(request, NULL, 0, NULL, 0);
1072     ok(ret, "HttpSendRequest failed: %u\n", GetLastError());
1073     ok(InternetCloseHandle(request), "Close request handle failed\n");
1074
1075     request = HttpOpenRequestW(connect, NULL, slash, NULL, NULL, typesW, INTERNET_FLAG_NO_CACHE_WRITE, 0);
1076     ok(request != NULL, "Failed to open request handle err %u\n", GetLastError());
1077
1078     ret = HttpSendRequest(request, NULL, 0, NULL, 0);
1079     ok(ret, "HttpSendRequest failed: %u\n", GetLastError());
1080     ok(InternetCloseHandle(request), "Close request handle failed\n");
1081
1082 done:
1083     ok(InternetCloseHandle(connect), "Close connect handle failed\n");
1084     ok(InternetCloseHandle(session), "Close session handle failed\n");
1085 }
1086
1087 static void test_http_cache(void)
1088 {
1089     HINTERNET session, connect, request;
1090     char file_name[MAX_PATH], url[INTERNET_MAX_URL_LENGTH];
1091     DWORD size, file_size;
1092     BYTE buf[100];
1093     HANDLE file;
1094     BOOL ret;
1095
1096     static const char *types[] = { "*", "", NULL };
1097
1098     session = InternetOpenA("Wine Regression Test", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
1099     ok(session != NULL ,"Unable to open Internet session\n");
1100
1101     connect = InternetConnectA(session, "test.winehq.org", INTERNET_DEFAULT_HTTP_PORT, NULL, NULL,
1102                               INTERNET_SERVICE_HTTP, 0, 0);
1103     ok(connect != NULL, "Unable to connect to http://test.winehq.org with error %d\n", GetLastError());
1104
1105     request = HttpOpenRequestA(connect, NULL, "/tests/hello.html", NULL, NULL, types, INTERNET_FLAG_NEED_FILE, 0);
1106     if (!request && GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED)
1107     {
1108         skip( "Network unreachable, skipping test\n" );
1109
1110         ok(InternetCloseHandle(connect), "Close connect handle failed\n");
1111         ok(InternetCloseHandle(session), "Close session handle failed\n");
1112
1113         return;
1114     }
1115     ok(request != NULL, "Failed to open request handle err %u\n", GetLastError());
1116
1117     size = sizeof(url);
1118     ret = InternetQueryOptionA(request, INTERNET_OPTION_URL, url, &size);
1119     ok(ret, "InternetQueryOptionA(INTERNET_OPTION_URL) failed: %u\n", GetLastError());
1120     ok(!strcmp(url, "http://test.winehq.org/tests/hello.html"), "Wrong URL %s\n", url);
1121
1122     size = sizeof(file_name);
1123     ret = InternetQueryOptionA(request, INTERNET_OPTION_DATAFILE_NAME, file_name, &size);
1124     ok(!ret, "InternetQueryOptionA(INTERNET_OPTION_DATAFILE_NAME) succeeded\n");
1125     ok(GetLastError() == ERROR_INTERNET_ITEM_NOT_FOUND, "GetLastError()=%u\n", GetLastError());
1126     ok(!size, "size = %d\n", size);
1127
1128     ret = HttpSendRequest(request, NULL, 0, NULL, 0);
1129     ok(ret, "HttpSendRequest failed: %u\n", GetLastError());
1130
1131     size = sizeof(file_name);
1132     ret = InternetQueryOptionA(request, INTERNET_OPTION_DATAFILE_NAME, file_name, &size);
1133     ok(ret, "InternetQueryOptionA(INTERNET_OPTION_DATAFILE_NAME) failed: %u\n", GetLastError());
1134
1135     file = CreateFile(file_name, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
1136                       FILE_ATTRIBUTE_NORMAL, NULL);
1137     ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError());
1138     file_size = GetFileSize(file, NULL);
1139     todo_wine ok(file_size == 106, "file size = %u\n", file_size);
1140
1141     size = sizeof(buf);
1142     ret = InternetReadFile(request, buf, sizeof(buf), &size);
1143     ok(ret, "InternetReadFile failed: %u\n", GetLastError());
1144     ok(size == 100, "size = %u\n", size);
1145
1146     file_size = GetFileSize(file, NULL);
1147     todo_wine ok(file_size == 106, "file size = %u\n", file_size);
1148     CloseHandle(file);
1149
1150     ok(InternetCloseHandle(request), "Close request handle failed\n");
1151
1152     file = CreateFile(file_name, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
1153                       FILE_ATTRIBUTE_NORMAL, NULL);
1154     ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError());
1155     CloseHandle(file);
1156
1157     /* Send the same request, requiring it to be retrieved from the cache */
1158     request = HttpOpenRequest(connect, "GET", "/tests/hello.html", NULL, NULL, NULL, INTERNET_FLAG_FROM_CACHE, 0);
1159
1160     ret = HttpSendRequest(request, NULL, 0, NULL, 0);
1161     ok(ret, "HttpSendRequest failed\n");
1162
1163     size = sizeof(buf);
1164     ret = InternetReadFile(request, buf, sizeof(buf), &size);
1165     ok(ret, "InternetReadFile failed: %u\n", GetLastError());
1166     ok(size == 100, "size = %u\n", size);
1167
1168     ok(InternetCloseHandle(request), "Close request handle failed\n");
1169
1170     request = HttpOpenRequestA(connect, NULL, "/", NULL, NULL, types, INTERNET_FLAG_NO_CACHE_WRITE, 0);
1171     ok(request != NULL, "Failed to open request handle err %u\n", GetLastError());
1172
1173     size = sizeof(file_name);
1174     ret = InternetQueryOptionA(request, INTERNET_OPTION_DATAFILE_NAME, file_name, &size);
1175     ok(!ret, "InternetQueryOptionA(INTERNET_OPTION_DATAFILE_NAME) succeeded\n");
1176     ok(GetLastError() == ERROR_INTERNET_ITEM_NOT_FOUND, "GetLastError()=%u\n", GetLastError());
1177     ok(!size, "size = %d\n", size);
1178
1179     ret = HttpSendRequest(request, NULL, 0, NULL, 0);
1180     ok(ret, "HttpSendRequest failed: %u\n", GetLastError());
1181
1182     size = sizeof(file_name);
1183     file_name[0] = 0;
1184     ret = InternetQueryOptionA(request, INTERNET_OPTION_DATAFILE_NAME, file_name, &size);
1185     if (ret)
1186     {
1187         file = CreateFile(file_name, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
1188                       FILE_ATTRIBUTE_NORMAL, NULL);
1189         ok(file != INVALID_HANDLE_VALUE, "Could not create file: %u\n", GetLastError());
1190         CloseHandle(file);
1191     }
1192     else
1193     {
1194         /* < IE8 */
1195         ok(file_name[0] == 0, "Didn't expect a file name\n");
1196     }
1197
1198     ok(InternetCloseHandle(request), "Close request handle failed\n");
1199     ok(InternetCloseHandle(connect), "Close connect handle failed\n");
1200     ok(InternetCloseHandle(session), "Close session handle failed\n");
1201 }
1202
1203 static void HttpHeaders_test(void)
1204 {
1205     HINTERNET hSession;
1206     HINTERNET hConnect;
1207     HINTERNET hRequest;
1208     CHAR      buffer[256];
1209     WCHAR     wbuffer[256];
1210     DWORD     len = 256;
1211     DWORD     oldlen;
1212     DWORD     index = 0;
1213
1214     hSession = InternetOpen("Wine Regression Test",
1215             INTERNET_OPEN_TYPE_PRECONFIG,NULL,NULL,0);
1216     ok( hSession != NULL ,"Unable to open Internet session\n");
1217     hConnect = InternetConnect(hSession, "crossover.codeweavers.com",
1218             INTERNET_DEFAULT_HTTP_PORT, NULL, NULL, INTERNET_SERVICE_HTTP, 0,
1219             0);
1220     ok( hConnect != NULL, "Unable to connect to http://crossover.codeweavers.com\n");
1221     hRequest = HttpOpenRequest(hConnect, "POST", "/posttest.php",
1222             NULL, NULL, NULL, INTERNET_FLAG_NO_CACHE_WRITE, 0);
1223     if (!hRequest && GetLastError() == ERROR_INTERNET_NAME_NOT_RESOLVED)
1224     {
1225         skip( "Network unreachable, skipping test\n" );
1226         goto done;
1227     }
1228     ok( hRequest != NULL, "Failed to open request handle\n");
1229
1230     index = 0;
1231     len = sizeof(buffer);
1232     strcpy(buffer,"Warning");
1233     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
1234                buffer,&len,&index)==0,"Warning hearder reported as Existing\n");
1235
1236     ok(HttpAddRequestHeaders(hRequest,"Warning:test1",-1,HTTP_ADDREQ_FLAG_ADD),
1237             "Failed to add new header\n");
1238
1239     index = 0;
1240     len = sizeof(buffer);
1241     strcpy(buffer,"Warning");
1242     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
1243                 buffer,&len,&index),"Unable to query header\n");
1244     ok(index == 1, "Index was not incremented\n");
1245     ok(strcmp(buffer,"test1")==0, "incorrect string was returned(%s)\n",buffer);
1246     ok(len == 5, "Invalid length (exp. 5, got %d)\n", len);
1247     ok((len < sizeof(buffer)) && (buffer[len] == 0), "Buffer not NULL-terminated\n"); /* len show only 5 characters but the buffer is NULL-terminated*/
1248     len = sizeof(buffer);
1249     strcpy(buffer,"Warning");
1250     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
1251                 buffer,&len,&index)==0,"Second Index Should Not Exist\n");
1252
1253     index = 0;
1254     len = 5; /* could store the string but not the NULL terminator */
1255     strcpy(buffer,"Warning");
1256     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
1257                 buffer,&len,&index) == FALSE,"Query succeeded on a too small buffer\n");
1258     ok(strcmp(buffer,"Warning")==0, "incorrect string was returned(%s)\n",buffer); /* string not touched */
1259     ok(len == 6, "Invalid length (exp. 6, got %d)\n", len); /* unlike success, the length includes the NULL-terminator */
1260
1261     /* a call with NULL will fail but will return the length */
1262     index = 0;
1263     len = sizeof(buffer);
1264     SetLastError(0xdeadbeef);
1265     ok(HttpQueryInfo(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF|HTTP_QUERY_FLAG_REQUEST_HEADERS,
1266                 NULL,&len,&index) == FALSE,"Query worked\n");
1267     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Unexpected last error: %d\n", GetLastError());
1268     ok(len > 40, "Invalid length (exp. more than 40, got %d)\n", len);
1269     ok(index == 0, "Index was incremented\n");
1270
1271     /* even for a len that is too small */
1272     index = 0;
1273     len = 15;
1274     SetLastError(0xdeadbeef);
1275     ok(HttpQueryInfo(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF|HTTP_QUERY_FLAG_REQUEST_HEADERS,
1276                 NULL,&len,&index) == FALSE,"Query worked\n");
1277     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Unexpected last error: %d\n", GetLastError());
1278     ok(len > 40, "Invalid length (exp. more than 40, got %d)\n", len);
1279     ok(index == 0, "Index was incremented\n");
1280
1281     index = 0;
1282     len = 0;
1283     SetLastError(0xdeadbeef);
1284     ok(HttpQueryInfo(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF|HTTP_QUERY_FLAG_REQUEST_HEADERS,
1285                 NULL,&len,&index) == FALSE,"Query worked\n");
1286     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Unexpected last error: %d\n", GetLastError());
1287     ok(len > 40, "Invalid length (exp. more than 40, got %d)\n", len);
1288     ok(index == 0, "Index was incremented\n");
1289     oldlen = len;   /* bytes; at least long enough to hold buffer & nul */
1290
1291
1292     /* a working query */
1293     index = 0;
1294     len = sizeof(buffer);
1295     memset(buffer, 'x', sizeof(buffer));
1296     ok(HttpQueryInfo(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF|HTTP_QUERY_FLAG_REQUEST_HEADERS,
1297                 buffer,&len,&index),"Unable to query header\n");
1298     ok(len + sizeof(CHAR) <= oldlen, "Result longer than advertised\n");
1299     ok((len < sizeof(buffer)-sizeof(CHAR)) && (buffer[len/sizeof(CHAR)] == 0),"No NUL at end\n");
1300     ok(len == strlen(buffer) * sizeof(CHAR), "Length wrong\n");
1301     /* what's in the middle differs between Wine and Windows so currently we check only the beginning and the end */
1302     ok(strncmp(buffer, "POST /posttest.php HTTP/1", 25)==0, "Invalid beginning of headers string\n");
1303     ok(strcmp(buffer + strlen(buffer) - 4, "\r\n\r\n")==0, "Invalid end of headers string\n");
1304     ok(index == 0, "Index was incremented\n");
1305
1306     /* Like above two tests, but for W version */
1307
1308     index = 0;
1309     len = 0;
1310     SetLastError(0xdeadbeef);
1311     ok(HttpQueryInfoW(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF|HTTP_QUERY_FLAG_REQUEST_HEADERS,
1312                 NULL,&len,&index) == FALSE,"Query worked\n");
1313     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "Unexpected last error: %d\n", GetLastError());
1314     ok(len > 80, "Invalid length (exp. more than 80, got %d)\n", len);
1315     ok(index == 0, "Index was incremented\n");
1316     oldlen = len;   /* bytes; at least long enough to hold buffer & nul */
1317
1318     /* a working query */
1319     index = 0;
1320     len = sizeof(wbuffer);
1321     memset(wbuffer, 'x', sizeof(wbuffer));
1322     ok(HttpQueryInfoW(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF|HTTP_QUERY_FLAG_REQUEST_HEADERS,
1323                 wbuffer,&len,&index),"Unable to query header\n");
1324     ok(len + sizeof(WCHAR) <= oldlen, "Result longer than advertised\n");
1325     ok(len == lstrlenW(wbuffer) * sizeof(WCHAR), "Length wrong\n");
1326     ok((len < sizeof(wbuffer)-sizeof(WCHAR)) && (wbuffer[len/sizeof(WCHAR)] == 0),"No NUL at end\n");
1327     ok(index == 0, "Index was incremented\n");
1328
1329     /* end of W version tests */
1330
1331     /* Without HTTP_QUERY_FLAG_REQUEST_HEADERS */
1332     index = 0;
1333     len = sizeof(buffer);
1334     memset(buffer, 'x', sizeof(buffer));
1335     ok(HttpQueryInfo(hRequest,HTTP_QUERY_RAW_HEADERS_CRLF,
1336                 buffer,&len,&index) == TRUE,"Query failed\n");
1337     ok(len == 2, "Expected 2, got %d\n", len);
1338     ok(strcmp(buffer, "\r\n") == 0, "Expected CRLF, got '%s'\n", buffer);
1339     ok(index == 0, "Index was incremented\n");
1340
1341     ok(HttpAddRequestHeaders(hRequest,"Warning:test2",-1,HTTP_ADDREQ_FLAG_ADD),
1342             "Failed to add duplicate header using HTTP_ADDREQ_FLAG_ADD\n");
1343
1344     index = 0;
1345     len = sizeof(buffer);
1346     strcpy(buffer,"Warning");
1347     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
1348                 buffer,&len,&index),"Unable to query header\n");
1349     ok(index == 1, "Index was not incremented\n");
1350     ok(strcmp(buffer,"test1")==0, "incorrect string was returned(%s)\n",buffer);
1351     len = sizeof(buffer);
1352     strcpy(buffer,"Warning");
1353     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
1354                 buffer,&len,&index),"Failed to get second header\n");
1355     ok(index == 2, "Index was not incremented\n");
1356     ok(strcmp(buffer,"test2")==0, "incorrect string was returned(%s)\n",buffer);
1357     len = sizeof(buffer);
1358     strcpy(buffer,"Warning");
1359     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
1360                 buffer,&len,&index)==0,"Third Header Should Not Exist\n");
1361
1362     ok(HttpAddRequestHeaders(hRequest,"Warning:test3",-1,HTTP_ADDREQ_FLAG_REPLACE), "Failed to replace header using HTTP_ADDREQ_FLAG_REPLACE\n");
1363
1364     index = 0;
1365     len = sizeof(buffer);
1366     strcpy(buffer,"Warning");
1367     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
1368                 buffer,&len,&index),"Unable to query header\n");
1369     ok(index == 1, "Index was not incremented\n");
1370     ok(strcmp(buffer,"test2")==0, "incorrect string was returned(%s)\n",buffer);
1371     len = sizeof(buffer);
1372     strcpy(buffer,"Warning");
1373     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
1374                 buffer,&len,&index),"Failed to get second header\n");
1375     ok(index == 2, "Index was not incremented\n");
1376     ok(strcmp(buffer,"test3")==0, "incorrect string was returned(%s)\n",buffer);
1377     len = sizeof(buffer);
1378     strcpy(buffer,"Warning");
1379     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
1380                 buffer,&len,&index)==0,"Third Header Should Not Exist\n");
1381
1382     ok(HttpAddRequestHeaders(hRequest,"Warning:test4",-1,HTTP_ADDREQ_FLAG_ADD_IF_NEW)==0, "HTTP_ADDREQ_FLAG_ADD_IF_NEW replaced existing header\n");
1383
1384     index = 0;
1385     len = sizeof(buffer);
1386     strcpy(buffer,"Warning");
1387     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
1388                 buffer,&len,&index),"Unable to query header\n");
1389     ok(index == 1, "Index was not incremented\n");
1390     ok(strcmp(buffer,"test2")==0, "incorrect string was returned(%s)\n",buffer);
1391     len = sizeof(buffer);
1392     strcpy(buffer,"Warning");
1393     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
1394                 buffer,&len,&index),"Failed to get second header\n");
1395     ok(index == 2, "Index was not incremented\n");
1396     ok(strcmp(buffer,"test3")==0, "incorrect string was returned(%s)\n",buffer);
1397     len = sizeof(buffer);
1398     strcpy(buffer,"Warning");
1399     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
1400                 buffer,&len,&index)==0,"Third Header Should Not Exist\n");
1401
1402     ok(HttpAddRequestHeaders(hRequest,"Warning:test4",-1, HTTP_ADDREQ_FLAG_COALESCE), "HTTP_ADDREQ_FLAG_COALESCE Did not work\n");
1403
1404     index = 0;
1405     len = sizeof(buffer);
1406     strcpy(buffer,"Warning");
1407     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS,
1408                 buffer,&len,&index),"Unable to query header\n");
1409     ok(index == 1, "Index was not incremented\n");
1410     ok(strcmp(buffer,"test2, test4")==0, "incorrect string was returned(%s)\n", buffer);
1411     len = sizeof(buffer);
1412     strcpy(buffer,"Warning");
1413     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Failed to get second header\n");
1414     ok(index == 2, "Index was not incremented\n");
1415     ok(strcmp(buffer,"test3")==0, "incorrect string was returned(%s)\n",buffer);
1416     len = sizeof(buffer);
1417     strcpy(buffer,"Warning");
1418     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index)==0,"Third Header Should Not Exist\n");
1419
1420     ok(HttpAddRequestHeaders(hRequest,"Warning:test5",-1, HTTP_ADDREQ_FLAG_COALESCE_WITH_COMMA), "HTTP_ADDREQ_FLAG_COALESCE Did not work\n");
1421
1422     index = 0;
1423     len = sizeof(buffer);
1424     strcpy(buffer,"Warning");
1425     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Unable to query header\n");
1426     ok(index == 1, "Index was not incremented\n");
1427     ok(strcmp(buffer,"test2, test4, test5")==0, "incorrect string was returned(%s)\n",buffer);
1428     len = sizeof(buffer);
1429     strcpy(buffer,"Warning");
1430     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Failed to get second header\n");
1431     ok(index == 2, "Index was not incremented\n");
1432     ok(strcmp(buffer,"test3")==0, "incorrect string was returned(%s)\n",buffer);
1433     len = sizeof(buffer);
1434     strcpy(buffer,"Warning");
1435     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index)==0,"Third Header Should Not Exist\n");
1436
1437     ok(HttpAddRequestHeaders(hRequest,"Warning:test6",-1, HTTP_ADDREQ_FLAG_COALESCE_WITH_SEMICOLON), "HTTP_ADDREQ_FLAG_COALESCE Did not work\n");
1438
1439     index = 0;
1440     len = sizeof(buffer);
1441     strcpy(buffer,"Warning");
1442     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Unable to query header\n");
1443     ok(index == 1, "Index was not incremented\n");
1444     ok(strcmp(buffer,"test2, test4, test5; test6")==0, "incorrect string was returned(%s)\n",buffer);
1445     len = sizeof(buffer);
1446     strcpy(buffer,"Warning");
1447     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Failed to get second header\n");
1448     ok(index == 2, "Index was not incremented\n");
1449     ok(strcmp(buffer,"test3")==0, "incorrect string was returned(%s)\n",buffer);
1450     len = sizeof(buffer);
1451     strcpy(buffer,"Warning");
1452     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index)==0,"Third Header Should Not Exist\n");
1453
1454     ok(HttpAddRequestHeaders(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");
1455
1456     index = 0;
1457     len = sizeof(buffer);
1458     strcpy(buffer,"Warning");
1459     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Unable to query header\n");
1460     ok(index == 1, "Index was not incremented\n");
1461     ok(strcmp(buffer,"test3")==0, "incorrect string was returned(%s)\n",buffer);
1462     len = sizeof(buffer);
1463     strcpy(buffer,"Warning");
1464     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Failed to get second header\n");
1465     ok(index == 2, "Index was not incremented\n");
1466     ok(strcmp(buffer,"test7")==0, "incorrect string was returned(%s)\n",buffer);
1467     len = sizeof(buffer);
1468     strcpy(buffer,"Warning");
1469     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index)==0,"Third Header Should Not Exist\n");
1470
1471     /* Ensure that blank headers are ignored and don't cause a failure */
1472     ok(HttpAddRequestHeaders(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");
1473
1474     index = 0;
1475     len = sizeof(buffer);
1476     strcpy(buffer,"BlankTest");
1477     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Unable to query header\n");
1478     ok(index == 1, "Index was not incremented\n");
1479     ok(strcmp(buffer,"value")==0, "incorrect string was returned(%s)\n",buffer);
1480
1481     /* Ensure that malformed header separators are ignored and don't cause a failure */
1482     ok(HttpAddRequestHeaders(hRequest,"\r\rMalformedTest:value\n\nMalformedTestTwo: value2\rMalformedTestThree: value3\n\n\r\r\n",-1, HTTP_ADDREQ_FLAG_ADD|HTTP_ADDREQ_FLAG_REPLACE),
1483         "Failed to add header with malformed entries in list\n");
1484
1485     index = 0;
1486     len = sizeof(buffer);
1487     strcpy(buffer,"MalformedTest");
1488     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Unable to query header\n");
1489     ok(index == 1, "Index was not incremented\n");
1490     ok(strcmp(buffer,"value")==0, "incorrect string was returned(%s)\n",buffer);
1491     index = 0;
1492     len = sizeof(buffer);
1493     strcpy(buffer,"MalformedTestTwo");
1494     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Unable to query header\n");
1495     ok(index == 1, "Index was not incremented\n");
1496     ok(strcmp(buffer,"value2")==0, "incorrect string was returned(%s)\n",buffer);
1497     index = 0;
1498     len = sizeof(buffer);
1499     strcpy(buffer,"MalformedTestThree");
1500     ok(HttpQueryInfo(hRequest,HTTP_QUERY_CUSTOM|HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer,&len,&index),"Unable to query header\n");
1501     ok(index == 1, "Index was not incremented\n");
1502     ok(strcmp(buffer,"value3")==0, "incorrect string was returned(%s)\n",buffer);
1503
1504     ok(InternetCloseHandle(hRequest), "Close request handle failed\n");
1505 done:
1506     ok(InternetCloseHandle(hConnect), "Close connect handle failed\n");
1507     ok(InternetCloseHandle(hSession), "Close session handle failed\n");
1508 }
1509
1510 static const char garbagemsg[] =
1511 "Garbage: Header\r\n";
1512
1513 static const char contmsg[] =
1514 "HTTP/1.1 100 Continue\r\n";
1515
1516 static const char expandcontmsg[] =
1517 "HTTP/1.1 100 Continue\r\n"
1518 "Server: winecontinue\r\n"
1519 "Tag: something witty\r\n"
1520 "\r\n";
1521
1522 static const char okmsg[] =
1523 "HTTP/1.1 200 OK\r\n"
1524 "Server: winetest\r\n"
1525 "\r\n";
1526
1527 static const char okmsg2[] =
1528 "HTTP/1.1 200 OK\r\n"
1529 "Date: Mon, 01 Dec 2008 13:44:34 GMT\r\n"
1530 "Server: winetest\r\n"
1531 "Content-Length: 0\r\n"
1532 "Set-Cookie: one\r\n"
1533 "Set-Cookie: two\r\n"
1534 "\r\n";
1535
1536 static const char notokmsg[] =
1537 "HTTP/1.1 400 Bad Request\r\n"
1538 "Server: winetest\r\n"
1539 "\r\n";
1540
1541 static const char noauthmsg[] =
1542 "HTTP/1.1 401 Unauthorized\r\n"
1543 "Server: winetest\r\n"
1544 "Connection: close\r\n"
1545 "WWW-Authenticate: Basic realm=\"placebo\"\r\n"
1546 "\r\n";
1547
1548 static const char noauthmsg2[] =
1549 "HTTP/1.0 401 Anonymous requests or requests on unsecure channel are not allowed\r\n"
1550 "HTTP/1.0 401 Anonymous requests or requests on unsecure channel are not allowed"
1551 "\0d`0|6\n"
1552 "Server: winetest\r\n";
1553
1554 static const char proxymsg[] =
1555 "HTTP/1.1 407 Proxy Authentication Required\r\n"
1556 "Server: winetest\r\n"
1557 "Proxy-Connection: close\r\n"
1558 "Proxy-Authenticate: Basic realm=\"placebo\"\r\n"
1559 "\r\n";
1560
1561 static const char page1[] =
1562 "<HTML>\r\n"
1563 "<HEAD><TITLE>wininet test page</TITLE></HEAD>\r\n"
1564 "<BODY>The quick brown fox jumped over the lazy dog<P></BODY>\r\n"
1565 "</HTML>\r\n\r\n";
1566
1567 struct server_info {
1568     HANDLE hEvent;
1569     int port;
1570     int num_testH_retrievals;
1571 };
1572
1573 static DWORD CALLBACK server_thread(LPVOID param)
1574 {
1575     struct server_info *si = param;
1576     int r, c, i, on;
1577     SOCKET s;
1578     struct sockaddr_in sa;
1579     char buffer[0x100];
1580     WSADATA wsaData;
1581     int last_request = 0;
1582     char host_header[22];
1583     static int test_b = 0;
1584
1585     WSAStartup(MAKEWORD(1,1), &wsaData);
1586
1587     s = socket(AF_INET, SOCK_STREAM, 0);
1588     if (s == INVALID_SOCKET)
1589         return 1;
1590
1591     on = 1;
1592     setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char*)&on, sizeof on);
1593
1594     memset(&sa, 0, sizeof sa);
1595     sa.sin_family = AF_INET;
1596     sa.sin_port = htons(si->port);
1597     sa.sin_addr.S_un.S_addr = inet_addr("127.0.0.1");
1598
1599     r = bind(s, (struct sockaddr*) &sa, sizeof sa);
1600     if (r<0)
1601         return 1;
1602
1603     listen(s, 0);
1604
1605     SetEvent(si->hEvent);
1606
1607     sprintf(host_header, "Host: localhost:%d", si->port);
1608
1609     do
1610     {
1611         c = accept(s, NULL, NULL);
1612
1613         memset(buffer, 0, sizeof buffer);
1614         for(i=0; i<(sizeof buffer-1); i++)
1615         {
1616             r = recv(c, &buffer[i], 1, 0);
1617             if (r != 1)
1618                 break;
1619             if (i<4) continue;
1620             if (buffer[i-2] == '\n' && buffer[i] == '\n' &&
1621                 buffer[i-3] == '\r' && buffer[i-1] == '\r')
1622                 break;
1623         }
1624         if (strstr(buffer, "GET /test1"))
1625         {
1626             if (!strstr(buffer, "Content-Length: 0"))
1627             {
1628                 send(c, okmsg, sizeof okmsg-1, 0);
1629                 send(c, page1, sizeof page1-1, 0);
1630             }
1631             else
1632                 send(c, notokmsg, sizeof notokmsg-1, 0);
1633         }
1634         if (strstr(buffer, "/test2"))
1635         {
1636             if (strstr(buffer, "Proxy-Authorization: Basic bWlrZToxMTAx"))
1637             {
1638                 send(c, okmsg, sizeof okmsg-1, 0);
1639                 send(c, page1, sizeof page1-1, 0);
1640             }
1641             else
1642                 send(c, proxymsg, sizeof proxymsg-1, 0);
1643         }
1644         if (strstr(buffer, "/test3"))
1645         {
1646             if (strstr(buffer, "Authorization: Basic dXNlcjpwd2Q="))
1647                 send(c, okmsg, sizeof okmsg-1, 0);
1648             else
1649                 send(c, noauthmsg, sizeof noauthmsg-1, 0);
1650         }
1651         if (strstr(buffer, "/test4"))
1652         {
1653             if (strstr(buffer, "Connection: Close"))
1654                 send(c, okmsg, sizeof okmsg-1, 0);
1655             else
1656                 send(c, notokmsg, sizeof notokmsg-1, 0);
1657         }
1658         if (strstr(buffer, "POST /test5") ||
1659             strstr(buffer, "RPC_IN_DATA /test5") ||
1660             strstr(buffer, "RPC_OUT_DATA /test5"))
1661         {
1662             if (strstr(buffer, "Content-Length: 0"))
1663             {
1664                 send(c, okmsg, sizeof okmsg-1, 0);
1665                 send(c, page1, sizeof page1-1, 0);
1666             }
1667             else
1668                 send(c, notokmsg, sizeof notokmsg-1, 0);
1669         }
1670         if (strstr(buffer, "GET /test6"))
1671         {
1672             send(c, contmsg, sizeof contmsg-1, 0);
1673             send(c, contmsg, sizeof contmsg-1, 0);
1674             send(c, okmsg, sizeof okmsg-1, 0);
1675             send(c, page1, sizeof page1-1, 0);
1676         }
1677         if (strstr(buffer, "POST /test7"))
1678         {
1679             if (strstr(buffer, "Content-Length: 100"))
1680             {
1681                 send(c, okmsg, sizeof okmsg-1, 0);
1682                 send(c, page1, sizeof page1-1, 0);
1683             }
1684             else
1685                 send(c, notokmsg, sizeof notokmsg-1, 0);
1686         }
1687         if (strstr(buffer, "/test8"))
1688         {
1689             if (!strstr(buffer, "Connection: Close") &&
1690                  strstr(buffer, "Connection: Keep-Alive") &&
1691                 !strstr(buffer, "Cache-Control: no-cache") &&
1692                 !strstr(buffer, "Pragma: no-cache") &&
1693                  strstr(buffer, host_header))
1694                 send(c, okmsg, sizeof okmsg-1, 0);
1695             else
1696                 send(c, notokmsg, sizeof notokmsg-1, 0);
1697         }
1698         if (strstr(buffer, "/test9"))
1699         {
1700             if (!strstr(buffer, "Connection: Close") &&
1701                 !strstr(buffer, "Connection: Keep-Alive") &&
1702                 !strstr(buffer, "Cache-Control: no-cache") &&
1703                 !strstr(buffer, "Pragma: no-cache") &&
1704                  strstr(buffer, host_header))
1705                 send(c, okmsg, sizeof okmsg-1, 0);
1706             else
1707                 send(c, notokmsg, sizeof notokmsg-1, 0);
1708         }
1709         if (strstr(buffer, "/testA"))
1710         {
1711             if (!strstr(buffer, "Connection: Close") &&
1712                 !strstr(buffer, "Connection: Keep-Alive") &&
1713                 (strstr(buffer, "Cache-Control: no-cache") ||
1714                  strstr(buffer, "Pragma: no-cache")) &&
1715                  strstr(buffer, host_header))
1716                 send(c, okmsg, sizeof okmsg-1, 0);
1717             else
1718                 send(c, notokmsg, sizeof notokmsg-1, 0);
1719         }
1720         if (!test_b && strstr(buffer, "/testB HTTP/1.1"))
1721         {
1722             test_b = 1;
1723             send(c, okmsg, sizeof okmsg-1, 0);
1724             recvfrom(c, buffer, sizeof buffer, 0, NULL, NULL);
1725             send(c, okmsg, sizeof okmsg-1, 0);
1726         }
1727         if (strstr(buffer, "/testC"))
1728         {
1729             if (strstr(buffer, "Cookie: cookie=biscuit"))
1730                 send(c, okmsg, sizeof okmsg-1, 0);
1731             else
1732                 send(c, notokmsg, sizeof notokmsg-1, 0);
1733         }
1734         if (strstr(buffer, "/testD"))
1735         {
1736             send(c, okmsg2, sizeof okmsg2-1, 0);
1737         }
1738         if (strstr(buffer, "/testE"))
1739         {
1740             send(c, noauthmsg2, sizeof noauthmsg2-1, 0);
1741         }
1742         if (strstr(buffer, "GET /quit"))
1743         {
1744             send(c, okmsg, sizeof okmsg-1, 0);
1745             send(c, page1, sizeof page1-1, 0);
1746             last_request = 1;
1747         }
1748         if (strstr(buffer, "GET /testF"))
1749         {
1750             send(c, expandcontmsg, sizeof expandcontmsg-1, 0);
1751             send(c, garbagemsg, sizeof garbagemsg-1, 0);
1752             send(c, contmsg, sizeof contmsg-1, 0);
1753             send(c, garbagemsg, sizeof garbagemsg-1, 0);
1754             send(c, okmsg, sizeof okmsg-1, 0);
1755             send(c, page1, sizeof page1-1, 0);
1756         }
1757         if (strstr(buffer, "GET /testG"))
1758         {
1759             send(c, page1, sizeof page1-1, 0);
1760         }
1761         if (strstr(buffer, "GET /testH"))
1762         {
1763             si->num_testH_retrievals++;
1764             if (!strstr(buffer, "Content-Length: 0"))
1765             {
1766                 send(c, okmsg, sizeof okmsg-1, 0);
1767                 send(c, page1, sizeof page1-1, 0);
1768             }
1769             else
1770                 send(c, notokmsg, sizeof notokmsg-1, 0);
1771         }
1772         if (strstr(buffer, "GET /test_no_content"))
1773         {
1774             static const char nocontentmsg[] = "HTTP/1.1 204 No Content\r\nConnection: close\r\n\r\n";
1775             send(c, nocontentmsg, sizeof(nocontentmsg)-1, 0);
1776         }
1777         if (strstr(buffer, "GET /test_conn_close"))
1778         {
1779             static const char conn_close_response[] = "HTTP/1.1 200 OK\r\nConnection: close\r\n\r\nsome content";
1780             send(c, conn_close_response, sizeof(conn_close_response)-1, 0);
1781             WaitForSingleObject(conn_close_event, INFINITE);
1782             trace("closing connection\n");
1783         }
1784
1785         shutdown(c, 2);
1786         closesocket(c);
1787     } while (!last_request);
1788
1789     closesocket(s);
1790
1791     return 0;
1792 }
1793
1794 static void test_basic_request(int port, const char *verb, const char *url)
1795 {
1796     HINTERNET hi, hc, hr;
1797     DWORD r, count;
1798     char buffer[0x100];
1799
1800     hi = InternetOpen(NULL, INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
1801     ok(hi != NULL, "open failed\n");
1802
1803     hc = InternetConnect(hi, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
1804     ok(hc != NULL, "connect failed\n");
1805
1806     hr = HttpOpenRequest(hc, verb, url, NULL, NULL, NULL, 0, 0);
1807     ok(hr != NULL, "HttpOpenRequest failed\n");
1808
1809     r = HttpSendRequest(hr, NULL, 0, NULL, 0);
1810     ok(r, "HttpSendRequest failed\n");
1811
1812     count = 0;
1813     memset(buffer, 0, sizeof buffer);
1814     SetLastError(0xdeadbeef);
1815     r = InternetReadFile(hr, buffer, sizeof buffer, &count);
1816     ok(r, "InternetReadFile failed %u\n", GetLastError());
1817     ok(count == sizeof page1 - 1, "count was wrong\n");
1818     ok(!memcmp(buffer, page1, sizeof page1), "http data wrong, got: %s\n", buffer);
1819
1820     InternetCloseHandle(hr);
1821     InternetCloseHandle(hc);
1822     InternetCloseHandle(hi);
1823 }
1824
1825 static void test_last_error(int port)
1826 {
1827     HINTERNET hi, hc, hr;
1828     DWORD error;
1829     BOOL r;
1830
1831     hi = InternetOpen(NULL, INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
1832     ok(hi != NULL, "open failed\n");
1833
1834     hc = InternetConnect(hi, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
1835     ok(hc != NULL, "connect failed\n");
1836
1837     hr = HttpOpenRequest(hc, NULL, "/test1", NULL, NULL, NULL, 0, 0);
1838     ok(hr != NULL, "HttpOpenRequest failed\n");
1839
1840     SetLastError(0xdeadbeef);
1841     r = HttpSendRequest(hr, NULL, 0, NULL, 0);
1842     error = GetLastError();
1843     ok(r, "HttpSendRequest failed\n");
1844     ok(error == ERROR_SUCCESS || broken(error != ERROR_SUCCESS), "expected ERROR_SUCCESS, got %u\n", error);
1845
1846     InternetCloseHandle(hr);
1847     InternetCloseHandle(hc);
1848     InternetCloseHandle(hi);
1849 }
1850
1851 static void test_proxy_indirect(int port)
1852 {
1853     HINTERNET hi, hc, hr;
1854     DWORD r, sz, val;
1855     char buffer[0x40];
1856
1857     hi = InternetOpen(NULL, 0, NULL, NULL, 0);
1858     ok(hi != NULL, "open failed\n");
1859
1860     hc = InternetConnect(hi, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
1861     ok(hc != NULL, "connect failed\n");
1862
1863     hr = HttpOpenRequest(hc, NULL, "/test2", NULL, NULL, NULL, 0, 0);
1864     ok(hr != NULL, "HttpOpenRequest failed\n");
1865
1866     r = HttpSendRequest(hr, NULL, 0, NULL, 0);
1867     ok(r, "HttpSendRequest failed\n");
1868
1869     sz = sizeof buffer;
1870     r = HttpQueryInfo(hr, HTTP_QUERY_PROXY_AUTHENTICATE, buffer, &sz, NULL);
1871     ok(r || GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND, "HttpQueryInfo failed: %d\n", GetLastError());
1872     if (!r)
1873     {
1874         skip("missing proxy header, not testing remaining proxy headers\n");
1875         goto out;
1876     }
1877     ok(!strcmp(buffer, "Basic realm=\"placebo\""), "proxy auth info wrong\n");
1878
1879     sz = sizeof buffer;
1880     r = HttpQueryInfo(hr, HTTP_QUERY_STATUS_CODE, buffer, &sz, NULL);
1881     ok(r, "HttpQueryInfo failed\n");
1882     ok(!strcmp(buffer, "407"), "proxy code wrong\n");
1883
1884     sz = sizeof val;
1885     r = HttpQueryInfo(hr, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER, &val, &sz, NULL);
1886     ok(r, "HttpQueryInfo failed\n");
1887     ok(val == 407, "proxy code wrong\n");
1888
1889     sz = sizeof buffer;
1890     r = HttpQueryInfo(hr, HTTP_QUERY_STATUS_TEXT, buffer, &sz, NULL);
1891     ok(r, "HttpQueryInfo failed\n");
1892     ok(!strcmp(buffer, "Proxy Authentication Required"), "proxy text wrong\n");
1893
1894     sz = sizeof buffer;
1895     r = HttpQueryInfo(hr, HTTP_QUERY_VERSION, buffer, &sz, NULL);
1896     ok(r, "HttpQueryInfo failed\n");
1897     ok(!strcmp(buffer, "HTTP/1.1"), "http version wrong\n");
1898
1899     sz = sizeof buffer;
1900     r = HttpQueryInfo(hr, HTTP_QUERY_SERVER, buffer, &sz, NULL);
1901     ok(r, "HttpQueryInfo failed\n");
1902     ok(!strcmp(buffer, "winetest"), "http server wrong\n");
1903
1904     sz = sizeof buffer;
1905     r = HttpQueryInfo(hr, HTTP_QUERY_CONTENT_ENCODING, buffer, &sz, NULL);
1906     ok(GetLastError() == ERROR_HTTP_HEADER_NOT_FOUND, "HttpQueryInfo should fail\n");
1907     ok(r == FALSE, "HttpQueryInfo failed\n");
1908
1909 out:
1910     InternetCloseHandle(hr);
1911     InternetCloseHandle(hc);
1912     InternetCloseHandle(hi);
1913 }
1914
1915 static void test_proxy_direct(int port)
1916 {
1917     HINTERNET hi, hc, hr;
1918     DWORD r, sz;
1919     char buffer[0x40];
1920     static CHAR username[] = "mike",
1921                 password[] = "1101";
1922
1923     sprintf(buffer, "localhost:%d\n", port);
1924     hi = InternetOpen(NULL, INTERNET_OPEN_TYPE_PROXY, buffer, NULL, 0);
1925     ok(hi != NULL, "open failed\n");
1926
1927     /* try connect without authorization */
1928     hc = InternetConnect(hi, "test.winehq.org/", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
1929     ok(hc != NULL, "connect failed\n");
1930
1931     hr = HttpOpenRequest(hc, NULL, "/test2", NULL, NULL, NULL, 0, 0);
1932     ok(hr != NULL, "HttpOpenRequest failed\n");
1933
1934     r = HttpSendRequest(hr, NULL, 0, NULL, 0);
1935     ok(r, "HttpSendRequest failed\n");
1936
1937     sz = sizeof buffer;
1938     r = HttpQueryInfo(hr, HTTP_QUERY_STATUS_CODE, buffer, &sz, NULL);
1939     ok(r, "HttpQueryInfo failed\n");
1940     ok(!strcmp(buffer, "407"), "proxy code wrong\n");
1941
1942
1943     /* set the user + password then try again */
1944     todo_wine {
1945     r = InternetSetOption(hr, INTERNET_OPTION_PROXY_USERNAME, username, 4);
1946     ok(r, "failed to set user\n");
1947
1948     r = InternetSetOption(hr, INTERNET_OPTION_PROXY_PASSWORD, password, 4);
1949     ok(r, "failed to set password\n");
1950     }
1951
1952     r = HttpSendRequest(hr, NULL, 0, NULL, 0);
1953     ok(r, "HttpSendRequest failed\n");
1954     sz = sizeof buffer;
1955     r = HttpQueryInfo(hr, HTTP_QUERY_STATUS_CODE, buffer, &sz, NULL);
1956     ok(r, "HttpQueryInfo failed\n");
1957     todo_wine {
1958     ok(!strcmp(buffer, "200"), "proxy code wrong\n");
1959     }
1960
1961
1962     InternetCloseHandle(hr);
1963     InternetCloseHandle(hc);
1964     InternetCloseHandle(hi);
1965 }
1966
1967 static void test_header_handling_order(int port)
1968 {
1969     static char authorization[] = "Authorization: Basic dXNlcjpwd2Q=";
1970     static char connection[]    = "Connection: Close";
1971
1972     static const char *types[2] = { "*", NULL };
1973     HINTERNET session, connect, request;
1974     DWORD size, status;
1975     BOOL ret;
1976
1977     session = InternetOpen("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
1978     ok(session != NULL, "InternetOpen failed\n");
1979
1980     connect = InternetConnect(session, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
1981     ok(connect != NULL, "InternetConnect failed\n");
1982
1983     request = HttpOpenRequest(connect, NULL, "/test3", NULL, NULL, types, INTERNET_FLAG_KEEP_CONNECTION, 0);
1984     ok(request != NULL, "HttpOpenRequest failed\n");
1985
1986     ret = HttpAddRequestHeaders(request, authorization, ~0u, HTTP_ADDREQ_FLAG_ADD);
1987     ok(ret, "HttpAddRequestHeaders failed\n");
1988
1989     ret = HttpSendRequest(request, NULL, 0, NULL, 0);
1990     ok(ret, "HttpSendRequest failed\n");
1991
1992     status = 0;
1993     size = sizeof(status);
1994     ret = HttpQueryInfo( request, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL );
1995     ok(ret, "HttpQueryInfo failed\n");
1996     ok(status == 200, "request failed with status %u\n", status);
1997
1998     InternetCloseHandle(request);
1999
2000     request = HttpOpenRequest(connect, NULL, "/test4", NULL, NULL, types, INTERNET_FLAG_KEEP_CONNECTION, 0);
2001     ok(request != NULL, "HttpOpenRequest failed\n");
2002
2003     ret = HttpSendRequest(request, connection, ~0u, NULL, 0);
2004     ok(ret, "HttpSendRequest failed\n");
2005
2006     status = 0;
2007     size = sizeof(status);
2008     ret = HttpQueryInfo( request, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL );
2009     ok(ret, "HttpQueryInfo failed\n");
2010     ok(status == 200 || status == 400 /* IE6 */, "got status %u, expected 200 or 400\n", status);
2011
2012     InternetCloseHandle(request);
2013
2014     request = HttpOpenRequest(connect, "POST", "/test7", NULL, NULL, types, INTERNET_FLAG_KEEP_CONNECTION, 0);
2015     ok(request != NULL, "HttpOpenRequest failed\n");
2016
2017     ret = HttpAddRequestHeaders(request, "Content-Length: 100\r\n", ~0u, HTTP_ADDREQ_FLAG_ADD_IF_NEW);
2018     ok(ret, "HttpAddRequestHeaders failed\n");
2019
2020     ret = HttpSendRequest(request, connection, ~0u, NULL, 0);
2021     ok(ret, "HttpSendRequest failed\n");
2022
2023     status = 0;
2024     size = sizeof(status);
2025     ret = HttpQueryInfo( request, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL );
2026     ok(ret, "HttpQueryInfo failed\n");
2027     ok(status == 200 || status == 400 /* IE6 */, "got status %u, expected 200 or 400\n", status);
2028
2029     InternetCloseHandle(request);
2030     InternetCloseHandle(connect);
2031     InternetCloseHandle(session);
2032 }
2033
2034 static void test_connection_header(int port)
2035 {
2036     HINTERNET ses, con, req;
2037     DWORD size, status;
2038     BOOL ret;
2039
2040     ses = InternetOpen("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
2041     ok(ses != NULL, "InternetOpen failed\n");
2042
2043     con = InternetConnect(ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
2044     ok(con != NULL, "InternetConnect failed\n");
2045
2046     req = HttpOpenRequest(con, NULL, "/test8", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0);
2047     ok(req != NULL, "HttpOpenRequest failed\n");
2048
2049     ret = HttpSendRequest(req, NULL, 0, NULL, 0);
2050     ok(ret, "HttpSendRequest failed\n");
2051
2052     status = 0;
2053     size = sizeof(status);
2054     ret = HttpQueryInfo(req, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL);
2055     ok(ret, "HttpQueryInfo failed\n");
2056     ok(status == 200, "request failed with status %u\n", status);
2057
2058     InternetCloseHandle(req);
2059
2060     req = HttpOpenRequest(con, NULL, "/test9", NULL, NULL, NULL, 0, 0);
2061     ok(req != NULL, "HttpOpenRequest failed\n");
2062
2063     ret = HttpSendRequest(req, NULL, 0, NULL, 0);
2064     ok(ret, "HttpSendRequest failed\n");
2065
2066     status = 0;
2067     size = sizeof(status);
2068     ret = HttpQueryInfo(req, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL);
2069     ok(ret, "HttpQueryInfo failed\n");
2070     ok(status == 200, "request failed with status %u\n", status);
2071
2072     InternetCloseHandle(req);
2073
2074     req = HttpOpenRequest(con, NULL, "/test9", NULL, NULL, NULL, INTERNET_FLAG_NO_CACHE_WRITE, 0);
2075     ok(req != NULL, "HttpOpenRequest failed\n");
2076
2077     ret = HttpSendRequest(req, NULL, 0, NULL, 0);
2078     ok(ret, "HttpSendRequest failed\n");
2079
2080     status = 0;
2081     size = sizeof(status);
2082     ret = HttpQueryInfo(req, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL);
2083     ok(ret, "HttpQueryInfo failed\n");
2084     ok(status == 200, "request failed with status %u\n", status);
2085
2086     InternetCloseHandle(req);
2087
2088     req = HttpOpenRequest(con, "POST", "/testA", NULL, NULL, NULL, INTERNET_FLAG_NO_CACHE_WRITE, 0);
2089     ok(req != NULL, "HttpOpenRequest failed\n");
2090
2091     ret = HttpSendRequest(req, NULL, 0, NULL, 0);
2092     ok(ret, "HttpSendRequest failed\n");
2093
2094     status = 0;
2095     size = sizeof(status);
2096     ret = HttpQueryInfo(req, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL);
2097     ok(ret, "HttpQueryInfo failed\n");
2098     ok(status == 200, "request failed with status %u\n", status);
2099
2100     InternetCloseHandle(req);
2101     InternetCloseHandle(con);
2102     InternetCloseHandle(ses);
2103 }
2104
2105 static void test_http1_1(int port)
2106 {
2107     HINTERNET ses, con, req;
2108     BOOL ret;
2109
2110     ses = InternetOpen("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
2111     ok(ses != NULL, "InternetOpen failed\n");
2112
2113     con = InternetConnect(ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
2114     ok(con != NULL, "InternetConnect failed\n");
2115
2116     req = HttpOpenRequest(con, NULL, "/testB", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0);
2117     ok(req != NULL, "HttpOpenRequest failed\n");
2118
2119     ret = HttpSendRequest(req, NULL, 0, NULL, 0);
2120     if (ret)
2121     {
2122         InternetCloseHandle(req);
2123
2124         req = HttpOpenRequest(con, NULL, "/testB", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0);
2125         ok(req != NULL, "HttpOpenRequest failed\n");
2126
2127         ret = HttpSendRequest(req, NULL, 0, NULL, 0);
2128         ok(ret, "HttpSendRequest failed\n");
2129     }
2130
2131     InternetCloseHandle(req);
2132     InternetCloseHandle(con);
2133     InternetCloseHandle(ses);
2134 }
2135
2136 static void test_no_content(int port)
2137 {
2138     HINTERNET session, connection, req;
2139     DWORD res;
2140
2141     trace("Testing 204 no content response...\n");
2142
2143     hCompleteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
2144
2145     session = InternetOpenA("", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, INTERNET_FLAG_ASYNC);
2146     ok(session != NULL,"InternetOpen failed with error %u\n", GetLastError());
2147
2148     pInternetSetStatusCallbackA(session, callback);
2149
2150     SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED);
2151     connection = InternetConnectA(session, "localhost", port,
2152             NULL, NULL, INTERNET_SERVICE_HTTP, 0x0, 0xdeadbeef);
2153     ok(connection != NULL,"InternetConnect failed with error %u\n", GetLastError());
2154     CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED);
2155
2156     SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED);
2157     req = HttpOpenRequestA(connection, "GET", "/test_no_content", NULL, NULL, NULL,
2158             INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_RESYNCHRONIZE, 0xdeadbead);
2159     ok(req != NULL, "HttpOpenRequest failed: %u\n", GetLastError());
2160     CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED);
2161
2162     SET_OPTIONAL(INTERNET_STATUS_COOKIE_SENT);
2163     SET_EXPECT(INTERNET_STATUS_CONNECTING_TO_SERVER);
2164     SET_EXPECT(INTERNET_STATUS_CONNECTED_TO_SERVER);
2165     SET_EXPECT(INTERNET_STATUS_SENDING_REQUEST);
2166     SET_EXPECT(INTERNET_STATUS_REQUEST_SENT);
2167     SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE);
2168     SET_EXPECT(INTERNET_STATUS_RESPONSE_RECEIVED);
2169     SET_EXPECT(INTERNET_STATUS_CLOSING_CONNECTION);
2170     SET_EXPECT(INTERNET_STATUS_CONNECTION_CLOSED);
2171     SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE);
2172
2173     res = HttpSendRequestA(req, NULL, -1, NULL, 0);
2174     ok(!res && (GetLastError() == ERROR_IO_PENDING),
2175        "Asynchronous HttpSendRequest NOT returning 0 with error ERROR_IO_PENDING\n");
2176     WaitForSingleObject(hCompleteEvent, INFINITE);
2177     ok(req_error == ERROR_SUCCESS, "req_error = %u\n", req_error);
2178
2179     CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_SENT);
2180     CHECK_NOTIFIED(INTERNET_STATUS_CONNECTING_TO_SERVER);
2181     CHECK_NOTIFIED(INTERNET_STATUS_CONNECTED_TO_SERVER);
2182     CHECK_NOTIFIED(INTERNET_STATUS_SENDING_REQUEST);
2183     CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_SENT);
2184     CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE);
2185     CHECK_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED);
2186     CHECK_NOTIFIED(INTERNET_STATUS_CLOSING_CONNECTION);
2187     CHECK_NOTIFIED(INTERNET_STATUS_CONNECTION_CLOSED);
2188     CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE);
2189
2190     close_async_handle(session, hCompleteEvent, 2);
2191     CloseHandle(hCompleteEvent);
2192 }
2193
2194 static void test_conn_close(int port)
2195 {
2196     HINTERNET session, connection, req;
2197     DWORD res, avail, size;
2198     BYTE buf[1024];
2199
2200     trace("Testing connection close connection...\n");
2201
2202     hCompleteEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
2203     conn_close_event = CreateEvent(NULL, FALSE, FALSE, NULL);
2204
2205     session = InternetOpenA("", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, INTERNET_FLAG_ASYNC);
2206     ok(session != NULL,"InternetOpen failed with error %u\n", GetLastError());
2207
2208     pInternetSetStatusCallbackA(session, callback);
2209
2210     SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED);
2211     connection = InternetConnectA(session, "localhost", port,
2212             NULL, NULL, INTERNET_SERVICE_HTTP, 0x0, 0xdeadbeef);
2213     ok(connection != NULL,"InternetConnect failed with error %u\n", GetLastError());
2214     CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED);
2215
2216     SET_EXPECT(INTERNET_STATUS_HANDLE_CREATED);
2217     req = HttpOpenRequestA(connection, "GET", "/test_conn_close", NULL, NULL, NULL,
2218             INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_RESYNCHRONIZE, 0xdeadbead);
2219     ok(req != NULL, "HttpOpenRequest failed: %u\n", GetLastError());
2220     CHECK_NOTIFIED(INTERNET_STATUS_HANDLE_CREATED);
2221
2222     SET_OPTIONAL(INTERNET_STATUS_COOKIE_SENT);
2223     SET_EXPECT(INTERNET_STATUS_CONNECTING_TO_SERVER);
2224     SET_EXPECT(INTERNET_STATUS_CONNECTED_TO_SERVER);
2225     SET_EXPECT(INTERNET_STATUS_SENDING_REQUEST);
2226     SET_EXPECT(INTERNET_STATUS_REQUEST_SENT);
2227     SET_EXPECT(INTERNET_STATUS_RECEIVING_RESPONSE);
2228     SET_EXPECT(INTERNET_STATUS_RESPONSE_RECEIVED);
2229     SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE);
2230
2231     res = HttpSendRequestA(req, NULL, -1, NULL, 0);
2232     ok(!res && (GetLastError() == ERROR_IO_PENDING),
2233        "Asynchronous HttpSendRequest NOT returning 0 with error ERROR_IO_PENDING\n");
2234     WaitForSingleObject(hCompleteEvent, INFINITE);
2235     ok(req_error == ERROR_SUCCESS, "req_error = %u\n", req_error);
2236
2237     CLEAR_NOTIFIED(INTERNET_STATUS_COOKIE_SENT);
2238     CHECK_NOTIFIED(INTERNET_STATUS_CONNECTING_TO_SERVER);
2239     CHECK_NOTIFIED(INTERNET_STATUS_CONNECTED_TO_SERVER);
2240     CHECK_NOTIFIED(INTERNET_STATUS_SENDING_REQUEST);
2241     CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_SENT);
2242     CHECK_NOTIFIED(INTERNET_STATUS_RECEIVING_RESPONSE);
2243     CHECK_NOTIFIED(INTERNET_STATUS_RESPONSE_RECEIVED);
2244     CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE);
2245
2246     avail = 0;
2247     res = InternetQueryDataAvailable(req, &avail, 0, 0);
2248     ok(res, "InternetQueryDataAvailable failed: %u\n", GetLastError());
2249     ok(avail != 0, "avail = 0\n");
2250
2251     size = 0;
2252     res = InternetReadFile(req, buf, avail, &size);
2253     ok(res, "InternetReadFile failed: %u\n", GetLastError());
2254
2255     res = InternetQueryDataAvailable(req, &avail, 0, 0);
2256     ok(!res && (GetLastError() == ERROR_IO_PENDING),
2257        "Asynchronous HttpSendRequest NOT returning 0 with error ERROR_IO_PENDING\n");
2258     ok(!avail, "avail = %u, expected 0\n", avail);
2259
2260     SET_EXPECT(INTERNET_STATUS_CLOSING_CONNECTION);
2261     SET_EXPECT(INTERNET_STATUS_CONNECTION_CLOSED);
2262     SET_EXPECT(INTERNET_STATUS_REQUEST_COMPLETE);
2263     SetEvent(conn_close_event);
2264     WaitForSingleObject(hCompleteEvent, INFINITE);
2265     ok(req_error == ERROR_SUCCESS, "req_error = %u\n", req_error);
2266     CHECK_NOTIFIED(INTERNET_STATUS_CLOSING_CONNECTION);
2267     CHECK_NOTIFIED(INTERNET_STATUS_CONNECTION_CLOSED);
2268     CHECK_NOTIFIED(INTERNET_STATUS_REQUEST_COMPLETE);
2269
2270     close_async_handle(session, hCompleteEvent, 2);
2271     CloseHandle(hCompleteEvent);
2272 }
2273
2274 static void test_HttpSendRequestW(int port)
2275 {
2276     static const WCHAR header[] = {'U','A','-','C','P','U',':',' ','x','8','6',0};
2277     HINTERNET ses, con, req;
2278     DWORD error;
2279     BOOL ret;
2280
2281     ses = InternetOpen("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, INTERNET_FLAG_ASYNC);
2282     ok(ses != NULL, "InternetOpen failed\n");
2283
2284     con = InternetConnect(ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
2285     ok(con != NULL, "InternetConnect failed\n");
2286
2287     req = HttpOpenRequest(con, NULL, "/test1", NULL, NULL, NULL, 0, 0);
2288     ok(req != NULL, "HttpOpenRequest failed\n");
2289
2290     SetLastError(0xdeadbeef);
2291     ret = HttpSendRequestW(req, header, ~0u, NULL, 0);
2292     error = GetLastError();
2293     ok(!ret, "HttpSendRequestW succeeded\n");
2294     ok(error == ERROR_IO_PENDING ||
2295        broken(error == ERROR_HTTP_HEADER_NOT_FOUND) ||  /* IE6 */
2296        broken(error == ERROR_INVALID_PARAMETER),        /* IE5 */
2297        "got %u expected ERROR_IO_PENDING\n", error);
2298
2299     InternetCloseHandle(req);
2300     InternetCloseHandle(con);
2301     InternetCloseHandle(ses);
2302 }
2303
2304 static void test_cookie_header(int port)
2305 {
2306     HINTERNET ses, con, req;
2307     DWORD size, status, error;
2308     BOOL ret;
2309     char buffer[64];
2310
2311     ses = InternetOpen("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
2312     ok(ses != NULL, "InternetOpen failed\n");
2313
2314     con = InternetConnect(ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
2315     ok(con != NULL, "InternetConnect failed\n");
2316
2317     InternetSetCookie("http://localhost", "cookie", "biscuit");
2318
2319     req = HttpOpenRequest(con, NULL, "/testC", NULL, NULL, NULL, INTERNET_FLAG_KEEP_CONNECTION, 0);
2320     ok(req != NULL, "HttpOpenRequest failed\n");
2321
2322     buffer[0] = 0;
2323     size = sizeof(buffer);
2324     SetLastError(0xdeadbeef);
2325     ret = HttpQueryInfo(req, HTTP_QUERY_COOKIE | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, NULL);
2326     error = GetLastError();
2327     ok(!ret, "HttpQueryInfo succeeded\n");
2328     ok(error == ERROR_HTTP_HEADER_NOT_FOUND, "got %u expected ERROR_HTTP_HEADER_NOT_FOUND\n", error);
2329
2330     ret = HttpAddRequestHeaders(req, "Cookie: cookie=not biscuit\r\n", ~0u, HTTP_ADDREQ_FLAG_ADD);
2331     ok(ret, "HttpAddRequestHeaders failed: %u\n", GetLastError());
2332
2333     buffer[0] = 0;
2334     size = sizeof(buffer);
2335     ret = HttpQueryInfo(req, HTTP_QUERY_COOKIE | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, NULL);
2336     ok(ret, "HttpQueryInfo failed: %u\n", GetLastError());
2337     ok(!strcmp(buffer, "cookie=not biscuit"), "got '%s' expected \'cookie=not biscuit\'\n", buffer);
2338
2339     ret = HttpSendRequest(req, NULL, 0, NULL, 0);
2340     ok(ret, "HttpSendRequest failed: %u\n", GetLastError());
2341
2342     status = 0;
2343     size = sizeof(status);
2344     ret = HttpQueryInfo(req, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL);
2345     ok(ret, "HttpQueryInfo failed\n");
2346     ok(status == 200, "request failed with status %u\n", status);
2347
2348     buffer[0] = 0;
2349     size = sizeof(buffer);
2350     ret = HttpQueryInfo(req, HTTP_QUERY_COOKIE | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, NULL);
2351     ok(ret, "HttpQueryInfo failed: %u\n", GetLastError());
2352     ok(!strcmp(buffer, "cookie=biscuit"), "got '%s' expected \'cookie=biscuit\'\n", buffer);
2353
2354     InternetCloseHandle(req);
2355     InternetCloseHandle(con);
2356     InternetCloseHandle(ses);
2357 }
2358
2359 static void test_basic_authentication(int port)
2360 {
2361     HINTERNET session, connect, request;
2362     DWORD size, status;
2363     BOOL ret;
2364
2365     session = InternetOpen("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
2366     ok(session != NULL, "InternetOpen failed\n");
2367
2368     connect = InternetConnect(session, "localhost", port, "user", "pwd", INTERNET_SERVICE_HTTP, 0, 0);
2369     ok(connect != NULL, "InternetConnect failed\n");
2370
2371     request = HttpOpenRequest(connect, NULL, "/test3", NULL, NULL, NULL, 0, 0);
2372     ok(request != NULL, "HttpOpenRequest failed\n");
2373
2374     ret = HttpSendRequest(request, NULL, 0, NULL, 0);
2375     ok(ret, "HttpSendRequest failed %u\n", GetLastError());
2376
2377     status = 0;
2378     size = sizeof(status);
2379     ret = HttpQueryInfo( request, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL );
2380     ok(ret, "HttpQueryInfo failed\n");
2381     ok(status == 200, "request failed with status %u\n", status);
2382
2383     InternetCloseHandle(request);
2384     InternetCloseHandle(connect);
2385     InternetCloseHandle(session);
2386 }
2387
2388 static void test_invalid_response_headers(int port)
2389 {
2390     HINTERNET session, connect, request;
2391     DWORD size, status;
2392     BOOL ret;
2393     char buffer[256];
2394
2395     session = InternetOpen("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
2396     ok(session != NULL, "InternetOpen failed\n");
2397
2398     connect = InternetConnect(session, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
2399     ok(connect != NULL, "InternetConnect failed\n");
2400
2401     request = HttpOpenRequest(connect, NULL, "/testE", NULL, NULL, NULL, 0, 0);
2402     ok(request != NULL, "HttpOpenRequest failed\n");
2403
2404     ret = HttpSendRequest(request, NULL, 0, NULL, 0);
2405     ok(ret, "HttpSendRequest failed %u\n", GetLastError());
2406
2407     status = 0;
2408     size = sizeof(status);
2409     ret = HttpQueryInfo( request, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL );
2410     ok(ret, "HttpQueryInfo failed\n");
2411     ok(status == 401, "unexpected status %u\n", status);
2412
2413     buffer[0] = 0;
2414     size = sizeof(buffer);
2415     ret = HttpQueryInfo( request, HTTP_QUERY_RAW_HEADERS, buffer, &size, NULL);
2416     ok(ret, "HttpQueryInfo failed\n");
2417     ok(!strcmp(buffer, "HTTP/1.0 401 Anonymous requests or requests on unsecure channel are not allowed"),
2418        "headers wrong \"%s\"\n", buffer);
2419
2420     buffer[0] = 0;
2421     size = sizeof(buffer);
2422     ret = HttpQueryInfo( request, HTTP_QUERY_SERVER, buffer, &size, NULL);
2423     ok(ret, "HttpQueryInfo failed\n");
2424     ok(!strcmp(buffer, "winetest"), "server wrong \"%s\"\n", buffer);
2425
2426     InternetCloseHandle(request);
2427     InternetCloseHandle(connect);
2428     InternetCloseHandle(session);
2429 }
2430
2431 static void test_response_without_headers(int port)
2432 {
2433     HINTERNET hi, hc, hr;
2434     DWORD r, count, size, status;
2435     char buffer[1024];
2436
2437     SetLastError(0xdeadbeef);
2438     hi = InternetOpen(NULL, INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
2439     ok(hi != NULL, "open failed %u\n", GetLastError());
2440
2441     SetLastError(0xdeadbeef);
2442     hc = InternetConnect(hi, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
2443     ok(hc != NULL, "connect failed %u\n", GetLastError());
2444
2445     SetLastError(0xdeadbeef);
2446     hr = HttpOpenRequest(hc, NULL, "/testG", NULL, NULL, NULL, 0, 0);
2447     ok(hr != NULL, "HttpOpenRequest failed %u\n", GetLastError());
2448
2449     SetLastError(0xdeadbeef);
2450     r = HttpSendRequest(hr, NULL, 0, NULL, 0);
2451     ok(r, "HttpSendRequest failed %u\n", GetLastError());
2452
2453     count = 0;
2454     memset(buffer, 0, sizeof buffer);
2455     SetLastError(0xdeadbeef);
2456     r = InternetReadFile(hr, buffer, sizeof buffer, &count);
2457     ok(r, "InternetReadFile failed %u\n", GetLastError());
2458     todo_wine ok(count == sizeof page1 - 1, "count was wrong\n");
2459     todo_wine ok(!memcmp(buffer, page1, sizeof page1), "http data wrong\n");
2460
2461     status = 0;
2462     size = sizeof(status);
2463     SetLastError(0xdeadbeef);
2464     r = HttpQueryInfo(hr, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, &status, &size, NULL );
2465     todo_wine ok(r, "HttpQueryInfo failed %u\n", GetLastError());
2466     todo_wine ok(status == 200, "expected status 200 got %u\n", status);
2467
2468     buffer[0] = 0;
2469     size = sizeof(buffer);
2470     SetLastError(0xdeadbeef);
2471     r = HttpQueryInfo(hr, HTTP_QUERY_STATUS_TEXT, buffer, &size, NULL );
2472     ok(r, "HttpQueryInfo failed %u\n", GetLastError());
2473     ok(!strcmp(buffer, "OK"), "expected OK got: \"%s\"\n", buffer);
2474
2475     buffer[0] = 0;
2476     size = sizeof(buffer);
2477     SetLastError(0xdeadbeef);
2478     r = HttpQueryInfo(hr, HTTP_QUERY_VERSION, buffer, &size, NULL);
2479     ok(r, "HttpQueryInfo failed %u\n", GetLastError());
2480     ok(!strcmp(buffer, "HTTP/1.0"), "expected HTTP/1.0 got: \"%s\"\n", buffer);
2481
2482     buffer[0] = 0;
2483     size = sizeof(buffer);
2484     SetLastError(0xdeadbeef);
2485     r = HttpQueryInfo(hr, HTTP_QUERY_RAW_HEADERS, buffer, &size, NULL);
2486     ok(r, "HttpQueryInfo failed %u\n", GetLastError());
2487     ok(!strcmp(buffer, "HTTP/1.0 200 OK"), "raw headers wrong: \"%s\"\n", buffer);
2488
2489     InternetCloseHandle(hr);
2490     InternetCloseHandle(hc);
2491     InternetCloseHandle(hi);
2492 }
2493
2494 static void test_HttpQueryInfo(int port)
2495 {
2496     HINTERNET hi, hc, hr;
2497     DWORD size, index;
2498     char buffer[1024];
2499     BOOL ret;
2500
2501     hi = InternetOpen(NULL, INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
2502     ok(hi != NULL, "InternetOpen failed\n");
2503
2504     hc = InternetConnect(hi, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
2505     ok(hc != NULL, "InternetConnect failed\n");
2506
2507     hr = HttpOpenRequest(hc, NULL, "/testD", NULL, NULL, NULL, 0, 0);
2508     ok(hr != NULL, "HttpOpenRequest failed\n");
2509
2510     ret = HttpSendRequest(hr, NULL, 0, NULL, 0);
2511     ok(ret, "HttpSendRequest failed\n");
2512
2513     index = 0;
2514     size = sizeof(buffer);
2515     ret = HttpQueryInfo(hr, HTTP_QUERY_HOST | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, &index);
2516     ok(ret, "HttpQueryInfo failed %u\n", GetLastError());
2517     ok(index == 1, "expected 1 got %u\n", index);
2518
2519     index = 0;
2520     size = sizeof(buffer);
2521     ret = HttpQueryInfo(hr, HTTP_QUERY_DATE | HTTP_QUERY_FLAG_SYSTEMTIME, buffer, &size, &index);
2522     ok(ret, "HttpQueryInfo failed %u\n", GetLastError());
2523     ok(index == 1, "expected 1 got %u\n", index);
2524
2525     index = 0;
2526     size = sizeof(buffer);
2527     ret = HttpQueryInfo(hr, HTTP_QUERY_RAW_HEADERS, buffer, &size, &index);
2528     ok(ret, "HttpQueryInfo failed %u\n", GetLastError());
2529     ok(index == 0, "expected 0 got %u\n", index);
2530
2531     size = sizeof(buffer);
2532     ret = HttpQueryInfo(hr, HTTP_QUERY_RAW_HEADERS, buffer, &size, &index);
2533     ok(ret, "HttpQueryInfo failed %u\n", GetLastError());
2534     ok(index == 0, "expected 0 got %u\n", index);
2535
2536     size = sizeof(buffer);
2537     ret = HttpQueryInfo(hr, HTTP_QUERY_RAW_HEADERS_CRLF, buffer, &size, &index);
2538     ok(ret, "HttpQueryInfo failed %u\n", GetLastError());
2539     ok(index == 0, "expected 0 got %u\n", index);
2540
2541     size = sizeof(buffer);
2542     ret = HttpQueryInfo(hr, HTTP_QUERY_STATUS_TEXT, buffer, &size, &index);
2543     ok(ret, "HttpQueryInfo failed %u\n", GetLastError());
2544     ok(index == 0, "expected 0 got %u\n", index);
2545
2546     size = sizeof(buffer);
2547     ret = HttpQueryInfo(hr, HTTP_QUERY_VERSION, buffer, &size, &index);
2548     ok(ret, "HttpQueryInfo failed %u\n", GetLastError());
2549     ok(index == 0, "expected 0 got %u\n", index);
2550
2551     index = 0;
2552     size = sizeof(buffer);
2553     ret = HttpQueryInfo(hr, HTTP_QUERY_STATUS_CODE, buffer, &size, &index);
2554     ok(ret, "HttpQueryInfo failed %u\n", GetLastError());
2555     ok(index == 0, "expected 0 got %u\n", index);
2556
2557     index = 0;
2558     size = sizeof(buffer);
2559     ret = HttpQueryInfo(hr, HTTP_QUERY_STATUS_CODE | HTTP_QUERY_FLAG_NUMBER, buffer, &size, &index);
2560     ok(ret, "HttpQueryInfo failed %u\n", GetLastError());
2561     ok(index == 0, "expected 0 got %u\n", index);
2562
2563     index = 0xdeadbeef;
2564     size = sizeof(buffer);
2565     ret = HttpQueryInfo(hr, HTTP_QUERY_FORWARDED, buffer, &size, &index);
2566     ok(!ret, "HttpQueryInfo succeeded\n");
2567     ok(index == 0xdeadbeef, "expected 0xdeadbeef got %u\n", index);
2568
2569     index = 0;
2570     size = sizeof(buffer);
2571     ret = HttpQueryInfo(hr, HTTP_QUERY_SERVER, buffer, &size, &index);
2572     ok(ret, "HttpQueryInfo failed %u\n", GetLastError());
2573     ok(index == 1, "expected 1 got %u\n", index);
2574
2575     index = 0;
2576     size = sizeof(buffer);
2577     strcpy(buffer, "Server");
2578     ret = HttpQueryInfo(hr, HTTP_QUERY_CUSTOM, buffer, &size, &index);
2579     ok(ret, "HttpQueryInfo failed %u\n", GetLastError());
2580     ok(index == 1, "expected 1 got %u\n", index);
2581
2582     index = 0;
2583     size = sizeof(buffer);
2584     ret = HttpQueryInfo(hr, HTTP_QUERY_SET_COOKIE, buffer, &size, &index);
2585     ok(ret, "HttpQueryInfo failed %u\n", GetLastError());
2586     ok(index == 1, "expected 1 got %u\n", index);
2587
2588     size = sizeof(buffer);
2589     ret = HttpQueryInfo(hr, HTTP_QUERY_SET_COOKIE, buffer, &size, &index);
2590     ok(ret, "HttpQueryInfo failed %u\n", GetLastError());
2591     ok(index == 2, "expected 2 got %u\n", index);
2592
2593     InternetCloseHandle(hr);
2594     InternetCloseHandle(hc);
2595     InternetCloseHandle(hi);
2596 }
2597
2598 static void test_options(int port)
2599 {
2600     HINTERNET ses, con, req;
2601     DWORD size, error;
2602     DWORD_PTR ctx;
2603     BOOL ret;
2604
2605     ses = InternetOpen("winetest", INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
2606     ok(ses != NULL, "InternetOpen failed\n");
2607
2608     SetLastError(0xdeadbeef);
2609     ret = InternetSetOption(ses, INTERNET_OPTION_CONTEXT_VALUE, NULL, 0);
2610     error = GetLastError();
2611     ok(!ret, "InternetSetOption succeeded\n");
2612     ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %u\n", error);
2613
2614     SetLastError(0xdeadbeef);
2615     ret = InternetSetOption(ses, INTERNET_OPTION_CONTEXT_VALUE, NULL, sizeof(ctx));
2616     ok(!ret, "InternetSetOption succeeded\n");
2617     error = GetLastError();
2618     ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %u\n", error);
2619
2620     SetLastError(0xdeadbeef);
2621     ret = InternetSetOption(ses, INTERNET_OPTION_CONTEXT_VALUE, &ctx, 0);
2622     ok(!ret, "InternetSetOption succeeded\n");
2623     error = GetLastError();
2624     ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %u\n", error);
2625
2626     ctx = 1;
2627     ret = InternetSetOption(ses, INTERNET_OPTION_CONTEXT_VALUE, &ctx, sizeof(ctx));
2628     ok(ret, "InternetSetOption failed %u\n", GetLastError());
2629
2630     SetLastError(0xdeadbeef);
2631     ret = InternetQueryOption(ses, INTERNET_OPTION_CONTEXT_VALUE, NULL, NULL);
2632     error = GetLastError();
2633     ok(!ret, "InternetQueryOption succeeded\n");
2634     ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %u\n", error);
2635
2636     SetLastError(0xdeadbeef);
2637     ret = InternetQueryOption(ses, INTERNET_OPTION_CONTEXT_VALUE, &ctx, NULL);
2638     error = GetLastError();
2639     ok(!ret, "InternetQueryOption succeeded\n");
2640     ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %u\n", error);
2641
2642     size = 0;
2643     SetLastError(0xdeadbeef);
2644     ret = InternetQueryOption(ses, INTERNET_OPTION_CONTEXT_VALUE, NULL, &size);
2645     error = GetLastError();
2646     ok(!ret, "InternetQueryOption succeeded\n");
2647     ok(error == ERROR_INSUFFICIENT_BUFFER, "expected ERROR_INSUFFICIENT_BUFFER, got %u\n", error);
2648
2649     size = sizeof(ctx);
2650     SetLastError(0xdeadbeef);
2651     ret = InternetQueryOption(NULL, INTERNET_OPTION_CONTEXT_VALUE, &ctx, &size);
2652     error = GetLastError();
2653     ok(!ret, "InternetQueryOption succeeded\n");
2654     ok(error == ERROR_INTERNET_INCORRECT_HANDLE_TYPE, "expected ERROR_INTERNET_INCORRECT_HANDLE_TYPE, got %u\n", error);
2655
2656     ctx = 0xdeadbeef;
2657     size = sizeof(ctx);
2658     ret = InternetQueryOption(ses, INTERNET_OPTION_CONTEXT_VALUE, &ctx, &size);
2659     ok(ret, "InternetQueryOption failed %u\n", GetLastError());
2660     ok(ctx == 1, "expected 1 got %lu\n", ctx);
2661
2662     con = InternetConnect(ses, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
2663     ok(con != NULL, "InternetConnect failed\n");
2664
2665     ctx = 0xdeadbeef;
2666     size = sizeof(ctx);
2667     ret = InternetQueryOption(con, INTERNET_OPTION_CONTEXT_VALUE, &ctx, &size);
2668     ok(ret, "InternetQueryOption failed %u\n", GetLastError());
2669     ok(ctx == 0, "expected 0 got %lu\n", ctx);
2670
2671     ctx = 2;
2672     ret = InternetSetOption(con, INTERNET_OPTION_CONTEXT_VALUE, &ctx, sizeof(ctx));
2673     ok(ret, "InternetSetOption failed %u\n", GetLastError());
2674
2675     ctx = 0xdeadbeef;
2676     size = sizeof(ctx);
2677     ret = InternetQueryOption(con, INTERNET_OPTION_CONTEXT_VALUE, &ctx, &size);
2678     ok(ret, "InternetQueryOption failed %u\n", GetLastError());
2679     ok(ctx == 2, "expected 2 got %lu\n", ctx);
2680
2681     req = HttpOpenRequest(con, NULL, "/test1", NULL, NULL, NULL, 0, 0);
2682     ok(req != NULL, "HttpOpenRequest failed\n");
2683
2684     ctx = 0xdeadbeef;
2685     size = sizeof(ctx);
2686     ret = InternetQueryOption(req, INTERNET_OPTION_CONTEXT_VALUE, &ctx, &size);
2687     ok(ret, "InternetQueryOption failed %u\n", GetLastError());
2688     ok(ctx == 0, "expected 0 got %lu\n", ctx);
2689
2690     ctx = 3;
2691     ret = InternetSetOption(req, INTERNET_OPTION_CONTEXT_VALUE, &ctx, sizeof(ctx));
2692     ok(ret, "InternetSetOption failed %u\n", GetLastError());
2693
2694     ctx = 0xdeadbeef;
2695     size = sizeof(ctx);
2696     ret = InternetQueryOption(req, INTERNET_OPTION_CONTEXT_VALUE, &ctx, &size);
2697     ok(ret, "InternetQueryOption failed %u\n", GetLastError());
2698     ok(ctx == 3, "expected 3 got %lu\n", ctx);
2699
2700     /* INTERNET_OPTION_PROXY */
2701     SetLastError(0xdeadbeef);
2702     ret = InternetQueryOptionA(ses, INTERNET_OPTION_PROXY, NULL, NULL);
2703     error = GetLastError();
2704     ok(!ret, "InternetQueryOption succeeded\n");
2705     ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %u\n", error);
2706
2707     SetLastError(0xdeadbeef);
2708     ret = InternetQueryOptionA(ses, INTERNET_OPTION_PROXY, &ctx, NULL);
2709     error = GetLastError();
2710     ok(!ret, "InternetQueryOption succeeded\n");
2711     ok(error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER, got %u\n", error);
2712
2713     size = 0;
2714     SetLastError(0xdeadbeef);
2715     ret = InternetQueryOptionA(ses, INTERNET_OPTION_PROXY, NULL, &size);
2716     error = GetLastError();
2717     ok(!ret, "InternetQueryOption succeeded\n");
2718     ok(error == ERROR_INSUFFICIENT_BUFFER, "expected ERROR_INSUFFICIENT_BUFFER, got %u\n", error);
2719     ok(size >= sizeof(INTERNET_PROXY_INFOA), "expected size to be greater or equal to the struct size\n");
2720
2721     InternetCloseHandle(req);
2722     InternetCloseHandle(con);
2723     InternetCloseHandle(ses);
2724 }
2725
2726 static void test_url_caching(int port, int *num_retrievals)
2727 {
2728     HINTERNET hi, hc, hr;
2729     DWORD r, count;
2730     char buffer[0x100];
2731
2732     ok(*num_retrievals == 0, "expected 0 retrievals prior to test\n");
2733
2734     hi = InternetOpen(NULL, INTERNET_OPEN_TYPE_DIRECT, NULL, NULL, 0);
2735     ok(hi != NULL, "open failed\n");
2736
2737     hc = InternetConnect(hi, "localhost", port, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
2738     ok(hc != NULL, "connect failed\n");
2739
2740     /* Pre-load the cache: */
2741     hr = HttpOpenRequest(hc, "GET", "/testH", NULL, NULL, NULL, 0, 0);
2742     ok(hr != NULL, "HttpOpenRequest failed\n");
2743
2744     r = HttpSendRequest(hr, NULL, 0, NULL, 0);
2745     ok(r, "HttpSendRequest failed\n");
2746
2747     ok(*num_retrievals == 1, "expected 1 retrievals, got %d\n", *num_retrievals);
2748
2749     count = 0;
2750     memset(buffer, 0, sizeof buffer);
2751     SetLastError(0xdeadbeef);
2752     r = InternetReadFile(hr, buffer, sizeof buffer, &count);
2753     ok(r, "InternetReadFile failed %u\n", GetLastError());
2754     ok(count == sizeof page1 - 1, "count was wrong\n");
2755     ok(!memcmp(buffer, page1, sizeof page1), "http data wrong\n");
2756
2757     InternetCloseHandle(hr);
2758
2759     /* Send the same request, requiring it to be retrieved from the cache */
2760     hr = HttpOpenRequest(hc, "GET", "/testH", NULL, NULL, NULL, INTERNET_FLAG_FROM_CACHE, 0);
2761     ok(hr != NULL, "HttpOpenRequest failed\n");
2762
2763     r = HttpSendRequest(hr, NULL, 0, NULL, 0);
2764     /* Older Windows versions succeed with this request, newer ones fail with
2765      * ERROR_FILE_NOT_FOUND.  Accept either, as the older version allows us
2766      * to verify that the server isn't contacted.
2767      */
2768     if (!r)
2769         ok(GetLastError() == ERROR_FILE_NOT_FOUND,
2770            "expected ERROR_FILE_NOT_FOUND, got %d\n", GetLastError());
2771     else
2772     {
2773         /* The server shouldn't be contacted for this request. */
2774         todo_wine
2775         ok(*num_retrievals == 1, "expected 1 retrievals\n");
2776
2777         count = 0;
2778         memset(buffer, 0, sizeof buffer);
2779         SetLastError(0xdeadbeef);
2780         r = InternetReadFile(hr, buffer, sizeof buffer, &count);
2781         ok(r, "InternetReadFile failed %u\n", GetLastError());
2782         ok(count == sizeof page1 - 1, "count was wrong\n");
2783         ok(!memcmp(buffer, page1, sizeof page1), "http data wrong\n");
2784     }
2785
2786     InternetCloseHandle(hc);
2787     InternetCloseHandle(hi);
2788 }
2789
2790 static void test_http_connection(void)
2791 {
2792     struct server_info si;
2793     HANDLE hThread;
2794     DWORD id = 0, r;
2795
2796     si.hEvent = CreateEvent(NULL, 0, 0, NULL);
2797     si.port = 7531;
2798     si.num_testH_retrievals = 0;
2799
2800     hThread = CreateThread(NULL, 0, server_thread, (LPVOID) &si, 0, &id);
2801     ok( hThread != NULL, "create thread failed\n");
2802
2803     r = WaitForSingleObject(si.hEvent, 10000);
2804     ok (r == WAIT_OBJECT_0, "failed to start wininet test server\n");
2805     if (r != WAIT_OBJECT_0)
2806         return;
2807
2808     test_basic_request(si.port, "GET", "/test1");
2809     test_proxy_indirect(si.port);
2810     test_proxy_direct(si.port);
2811     test_header_handling_order(si.port);
2812     test_basic_request(si.port, "POST", "/test5");
2813     test_basic_request(si.port, "RPC_IN_DATA", "/test5");
2814     test_basic_request(si.port, "RPC_OUT_DATA", "/test5");
2815     test_basic_request(si.port, "GET", "/test6");
2816     test_basic_request(si.port, "GET", "/testF");
2817     test_connection_header(si.port);
2818     test_http1_1(si.port);
2819     test_cookie_header(si.port);
2820     test_basic_authentication(si.port);
2821     test_invalid_response_headers(si.port);
2822     test_response_without_headers(si.port);
2823     test_HttpQueryInfo(si.port);
2824     test_HttpSendRequestW(si.port);
2825     test_last_error(si.port);
2826     test_options(si.port);
2827     test_url_caching(si.port, &si.num_testH_retrievals);
2828     test_no_content(si.port);
2829     test_conn_close(si.port);
2830
2831     /* send the basic request again to shutdown the server thread */
2832     test_basic_request(si.port, "GET", "/quit");
2833
2834     r = WaitForSingleObject(hThread, 3000);
2835     ok( r == WAIT_OBJECT_0, "thread wait failed\n");
2836     CloseHandle(hThread);
2837 }
2838
2839 static void release_cert_info(INTERNET_CERTIFICATE_INFOA *info)
2840 {
2841     LocalFree(info->lpszSubjectInfo);
2842     LocalFree(info->lpszIssuerInfo);
2843     LocalFree(info->lpszProtocolName);
2844     LocalFree(info->lpszSignatureAlgName);
2845     LocalFree(info->lpszEncryptionAlgName);
2846 }
2847
2848 static void test_secure_connection(void)
2849 {
2850     static const WCHAR gizmo5[] = {'G','i','z','m','o','5',0};
2851     static const WCHAR testbot[] = {'t','e','s','t','b','o','t','.','w','i','n','e','h','q','.','o','r','g',0};
2852     static const WCHAR get[] = {'G','E','T',0};
2853     static const WCHAR slash[] = {'/',0};
2854     HINTERNET ses, con, req;
2855     DWORD size, flags;
2856     INTERNET_CERTIFICATE_INFOA *certificate_structA = NULL;
2857     INTERNET_CERTIFICATE_INFOW *certificate_structW = NULL;
2858     BOOL ret;
2859
2860     ses = InternetOpen("Gizmo5", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
2861     ok(ses != NULL, "InternetOpen failed\n");
2862
2863     con = InternetConnect(ses, "testbot.winehq.org",
2864                           INTERNET_DEFAULT_HTTPS_PORT, NULL, NULL,
2865                           INTERNET_SERVICE_HTTP, 0, 0);
2866     ok(con != NULL, "InternetConnect failed\n");
2867
2868     req = HttpOpenRequest(con, "GET", "/", NULL, NULL, NULL,
2869                           INTERNET_FLAG_SECURE, 0);
2870     ok(req != NULL, "HttpOpenRequest failed\n");
2871
2872     ret = HttpSendRequest(req, NULL, 0, NULL, 0);
2873     ok(ret, "HttpSendRequest failed: %d\n", GetLastError());
2874
2875     size = sizeof(flags);
2876     ret = InternetQueryOption(req, INTERNET_OPTION_SECURITY_FLAGS, &flags, &size);
2877     ok(ret, "InternetQueryOption failed: %d\n", GetLastError());
2878     ok(flags & SECURITY_FLAG_SECURE, "expected secure flag to be set\n");
2879
2880     ret = InternetQueryOptionA(req, INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT,
2881                                NULL, &size);
2882     ok(ret || GetLastError() == ERROR_INSUFFICIENT_BUFFER, "InternetQueryOption failed: %d\n", GetLastError());
2883     ok(size == sizeof(INTERNET_CERTIFICATE_INFOA), "size = %d\n", size);
2884     certificate_structA = HeapAlloc(GetProcessHeap(), 0, size);
2885     ret = InternetQueryOption(req, INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT,
2886                               certificate_structA, &size);
2887     ok(ret, "InternetQueryOption failed: %d\n", GetLastError());
2888     if (ret)
2889     {
2890         ok(certificate_structA->lpszSubjectInfo &&
2891            strlen(certificate_structA->lpszSubjectInfo) > 1,
2892            "expected a non-empty subject name\n");
2893         ok(certificate_structA->lpszIssuerInfo &&
2894            strlen(certificate_structA->lpszIssuerInfo) > 1,
2895            "expected a non-empty issuer name\n");
2896         ok(!certificate_structA->lpszSignatureAlgName,
2897            "unexpected signature algorithm name\n");
2898         ok(!certificate_structA->lpszEncryptionAlgName,
2899            "unexpected encryption algorithm name\n");
2900         ok(!certificate_structA->lpszProtocolName,
2901            "unexpected protocol name\n");
2902         ok(certificate_structA->dwKeySize, "expected a non-zero key size\n");
2903         release_cert_info(certificate_structA);
2904     }
2905     HeapFree(GetProcessHeap(), 0, certificate_structA);
2906
2907     /* Querying the same option through InternetQueryOptionW still results in
2908      * ASCII strings being returned.
2909      */
2910     size = 0;
2911     ret = InternetQueryOptionW(req, INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT,
2912                                NULL, &size);
2913     ok(ret || GetLastError() == ERROR_INSUFFICIENT_BUFFER, "InternetQueryOption failed: %d\n", GetLastError());
2914     ok(size == sizeof(INTERNET_CERTIFICATE_INFOW), "size = %d\n", size);
2915     certificate_structW = HeapAlloc(GetProcessHeap(), 0, size);
2916     ret = InternetQueryOption(req, INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT,
2917                               certificate_structW, &size);
2918     certificate_structA = (INTERNET_CERTIFICATE_INFOA *)certificate_structW;
2919     ok(ret, "InternetQueryOption failed: %d\n", GetLastError());
2920     if (ret)
2921     {
2922         ok(certificate_structA->lpszSubjectInfo &&
2923            strlen(certificate_structA->lpszSubjectInfo) > 1,
2924            "expected a non-empty subject name\n");
2925         ok(certificate_structA->lpszIssuerInfo &&
2926            strlen(certificate_structA->lpszIssuerInfo) > 1,
2927            "expected a non-empty issuer name\n");
2928         ok(!certificate_structA->lpszSignatureAlgName,
2929            "unexpected signature algorithm name\n");
2930         ok(!certificate_structA->lpszEncryptionAlgName,
2931            "unexpected encryption algorithm name\n");
2932         ok(!certificate_structA->lpszProtocolName,
2933            "unexpected protocol name\n");
2934         ok(certificate_structA->dwKeySize, "expected a non-zero key size\n");
2935         release_cert_info(certificate_structA);
2936     }
2937     HeapFree(GetProcessHeap(), 0, certificate_structW);
2938
2939     InternetCloseHandle(req);
2940     InternetCloseHandle(con);
2941     InternetCloseHandle(ses);
2942
2943     /* Repeating the tests with the W functions has the same result: */
2944     ses = InternetOpenW(gizmo5, INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
2945     ok(ses != NULL, "InternetOpen failed\n");
2946
2947     con = InternetConnectW(ses, testbot,
2948                           INTERNET_DEFAULT_HTTPS_PORT, NULL, NULL,
2949                           INTERNET_SERVICE_HTTP, 0, 0);
2950     ok(con != NULL, "InternetConnect failed\n");
2951
2952     req = HttpOpenRequestW(con, get, slash, NULL, NULL, NULL,
2953                           INTERNET_FLAG_SECURE, 0);
2954     ok(req != NULL, "HttpOpenRequest failed\n");
2955
2956     ret = HttpSendRequest(req, NULL, 0, NULL, 0);
2957     ok(ret, "HttpSendRequest failed: %d\n", GetLastError());
2958
2959     size = sizeof(flags);
2960     ret = InternetQueryOption(req, INTERNET_OPTION_SECURITY_FLAGS, &flags, &size);
2961     ok(ret, "InternetQueryOption failed: %d\n", GetLastError());
2962     ok(flags & SECURITY_FLAG_SECURE, "expected secure flag to be set\n");
2963
2964     ret = InternetQueryOptionA(req, INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT,
2965                                NULL, &size);
2966     ok(ret || GetLastError() == ERROR_INSUFFICIENT_BUFFER, "InternetQueryOption failed: %d\n", GetLastError());
2967     ok(size == sizeof(INTERNET_CERTIFICATE_INFOA), "size = %d\n", size);
2968     certificate_structA = HeapAlloc(GetProcessHeap(), 0, size);
2969     ret = InternetQueryOptionW(req, INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT,
2970                                certificate_structA, &size);
2971     ok(ret, "InternetQueryOption failed: %d\n", GetLastError());
2972     if (ret)
2973     {
2974         ok(certificate_structA->lpszSubjectInfo &&
2975            strlen(certificate_structA->lpszSubjectInfo) > 1,
2976            "expected a non-empty subject name\n");
2977         ok(certificate_structA->lpszIssuerInfo &&
2978            strlen(certificate_structA->lpszIssuerInfo) > 1,
2979            "expected a non-empty issuer name\n");
2980         ok(!certificate_structA->lpszSignatureAlgName,
2981            "unexpected signature algorithm name\n");
2982         ok(!certificate_structA->lpszEncryptionAlgName,
2983            "unexpected encryption algorithm name\n");
2984         ok(!certificate_structA->lpszProtocolName,
2985            "unexpected protocol name\n");
2986         ok(certificate_structA->dwKeySize, "expected a non-zero key size\n");
2987         release_cert_info(certificate_structA);
2988     }
2989     HeapFree(GetProcessHeap(), 0, certificate_structA);
2990
2991     /* Again, querying the same option through InternetQueryOptionW still
2992      * results in ASCII strings being returned.
2993      */
2994     size = 0;
2995     ret = InternetQueryOptionW(req, INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT,
2996                                NULL, &size);
2997     ok(ret || GetLastError() == ERROR_INSUFFICIENT_BUFFER, "InternetQueryOption failed: %d\n", GetLastError());
2998     ok(size == sizeof(INTERNET_CERTIFICATE_INFOW), "size = %d\n", size);
2999     certificate_structW = HeapAlloc(GetProcessHeap(), 0, size);
3000     ret = InternetQueryOptionW(req, INTERNET_OPTION_SECURITY_CERTIFICATE_STRUCT,
3001                                certificate_structW, &size);
3002     certificate_structA = (INTERNET_CERTIFICATE_INFOA *)certificate_structW;
3003     ok(ret, "InternetQueryOption failed: %d\n", GetLastError());
3004     if (ret)
3005     {
3006         ok(certificate_structA->lpszSubjectInfo &&
3007            strlen(certificate_structA->lpszSubjectInfo) > 1,
3008            "expected a non-empty subject name\n");
3009         ok(certificate_structA->lpszIssuerInfo &&
3010            strlen(certificate_structA->lpszIssuerInfo) > 1,
3011            "expected a non-empty issuer name\n");
3012         ok(!certificate_structA->lpszSignatureAlgName,
3013            "unexpected signature algorithm name\n");
3014         ok(!certificate_structA->lpszEncryptionAlgName,
3015            "unexpected encryption algorithm name\n");
3016         ok(!certificate_structA->lpszProtocolName,
3017            "unexpected protocol name\n");
3018         ok(certificate_structA->dwKeySize, "expected a non-zero key size\n");
3019         release_cert_info(certificate_structA);
3020     }
3021     HeapFree(GetProcessHeap(), 0, certificate_structW);
3022
3023     InternetCloseHandle(req);
3024     InternetCloseHandle(con);
3025     InternetCloseHandle(ses);
3026 }
3027
3028 static void test_user_agent_header(void)
3029 {
3030     HINTERNET ses, con, req;
3031     DWORD size, err;
3032     char buffer[64];
3033     BOOL ret;
3034
3035     ses = InternetOpen("Gizmo5", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
3036     ok(ses != NULL, "InternetOpen failed\n");
3037
3038     con = InternetConnect(ses, "test.winehq.org", 80, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
3039     ok(con != NULL, "InternetConnect failed\n");
3040
3041     req = HttpOpenRequest(con, "GET", "/tests/hello.html", "HTTP/1.0", NULL, NULL, 0, 0);
3042     ok(req != NULL, "HttpOpenRequest failed\n");
3043
3044     size = sizeof(buffer);
3045     ret = HttpQueryInfo(req, HTTP_QUERY_USER_AGENT | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, NULL);
3046     err = GetLastError();
3047     ok(!ret, "HttpQueryInfo succeeded\n");
3048     ok(err == ERROR_HTTP_HEADER_NOT_FOUND, "expected ERROR_HTTP_HEADER_NOT_FOUND, got %u\n", err);
3049
3050     ret = HttpAddRequestHeaders(req, "User-Agent: Gizmo Project\r\n", ~0u, HTTP_ADDREQ_FLAG_ADD_IF_NEW);
3051     ok(ret, "HttpAddRequestHeaders succeeded\n");
3052
3053     size = sizeof(buffer);
3054     ret = HttpQueryInfo(req, HTTP_QUERY_USER_AGENT | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, NULL);
3055     err = GetLastError();
3056     ok(ret, "HttpQueryInfo failed\n");
3057     ok(err == ERROR_HTTP_HEADER_NOT_FOUND, "expected ERROR_HTTP_HEADER_NOT_FOUND, got %u\n", err);
3058
3059     InternetCloseHandle(req);
3060
3061     req = HttpOpenRequest(con, "GET", "/", "HTTP/1.0", NULL, NULL, 0, 0);
3062     ok(req != NULL, "HttpOpenRequest failed\n");
3063
3064     size = sizeof(buffer);
3065     ret = HttpQueryInfo(req, HTTP_QUERY_ACCEPT | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, NULL);
3066     err = GetLastError();
3067     ok(!ret, "HttpQueryInfo succeeded\n");
3068     ok(err == ERROR_HTTP_HEADER_NOT_FOUND, "expected ERROR_HTTP_HEADER_NOT_FOUND, got %u\n", err);
3069
3070     ret = HttpAddRequestHeaders(req, "Accept: audio/*, image/*, text/*\r\nUser-Agent: Gizmo Project\r\n", ~0u, HTTP_ADDREQ_FLAG_ADD_IF_NEW);
3071     ok(ret, "HttpAddRequestHeaders failed\n");
3072
3073     buffer[0] = 0;
3074     size = sizeof(buffer);
3075     ret = HttpQueryInfo(req, HTTP_QUERY_ACCEPT | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, NULL);
3076     ok(ret, "HttpQueryInfo failed: %u\n", GetLastError());
3077     ok(!strcmp(buffer, "audio/*, image/*, text/*"), "got '%s' expected 'audio/*, image/*, text/*'\n", buffer);
3078
3079     InternetCloseHandle(req);
3080     InternetCloseHandle(con);
3081     InternetCloseHandle(ses);
3082 }
3083
3084 static void test_bogus_accept_types_array(void)
3085 {
3086     HINTERNET ses, con, req;
3087     static const char *types[] = { (const char *)6240, "*/*", "%p", "", (const char *)0xffffffff, "*/*", NULL };
3088     DWORD size, error;
3089     char buffer[32];
3090     BOOL ret;
3091
3092     ses = InternetOpen("MERONG(0.9/;p)", INTERNET_OPEN_TYPE_DIRECT, "", "", 0);
3093     con = InternetConnect(ses, "www.winehq.org", 80, NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
3094     req = HttpOpenRequest(con, "POST", "/post/post_action.php", "HTTP/1.0", "", types, INTERNET_FLAG_FORMS_SUBMIT, 0);
3095
3096     ok(req != NULL, "HttpOpenRequest failed: %u\n", GetLastError());
3097
3098     buffer[0] = 0;
3099     size = sizeof(buffer);
3100     SetLastError(0xdeadbeef);
3101     ret = HttpQueryInfo(req, HTTP_QUERY_ACCEPT | HTTP_QUERY_FLAG_REQUEST_HEADERS, buffer, &size, NULL);
3102     error = GetLastError();
3103     ok(!ret || broken(ret), "HttpQueryInfo succeeded\n");
3104     if (!ret) ok(error == ERROR_HTTP_HEADER_NOT_FOUND, "expected ERROR_HTTP_HEADER_NOT_FOUND, got %u\n", error);
3105     ok(broken(!strcmp(buffer, ", */*, %p, , , */*")) /* IE6 */ ||
3106        broken(!strcmp(buffer, "*/*, %p, */*")) /* IE7/8 */ ||
3107        !strcmp(buffer, ""), "got '%s' expected ''\n", buffer);
3108
3109     InternetCloseHandle(req);
3110     InternetCloseHandle(con);
3111     InternetCloseHandle(ses);
3112 }
3113
3114 struct context
3115 {
3116     HANDLE event;
3117     HINTERNET req;
3118 };
3119
3120 static void WINAPI cb(HINTERNET handle, DWORD_PTR context, DWORD status, LPVOID info, DWORD size)
3121 {
3122     INTERNET_ASYNC_RESULT *result = info;
3123     struct context *ctx = (struct context *)context;
3124
3125     trace("%p 0x%08lx %u %p 0x%08x\n", handle, context, status, info, size);
3126
3127     if (status == INTERNET_STATUS_REQUEST_COMPLETE)
3128     {
3129         trace("request handle: 0x%08lx\n", result->dwResult);
3130         ctx->req = (HINTERNET)result->dwResult;
3131         SetEvent(ctx->event);
3132     }
3133     if (status == INTERNET_STATUS_HANDLE_CLOSING)
3134     {
3135         DWORD type = INTERNET_HANDLE_TYPE_CONNECT_HTTP, size = sizeof(type);
3136
3137         if (InternetQueryOption(handle, INTERNET_OPTION_HANDLE_TYPE, &type, &size))
3138             ok(type != INTERNET_HANDLE_TYPE_CONNECT_HTTP, "unexpected callback\n");
3139         SetEvent(ctx->event);
3140     }
3141 }
3142
3143 static void test_open_url_async(void)
3144 {
3145     BOOL ret;
3146     HINTERNET ses, req;
3147     DWORD size, error;
3148     struct context ctx;
3149     ULONG type;
3150
3151     ctx.req = NULL;
3152     ctx.event = CreateEvent(NULL, TRUE, FALSE, "Z:_home_hans_jaman-installer.exe_ev1");
3153
3154     ses = InternetOpen("AdvancedInstaller", 0, NULL, NULL, INTERNET_FLAG_ASYNC);
3155     ok(ses != NULL, "InternetOpen failed\n");
3156
3157     SetLastError(0xdeadbeef);
3158     ret = InternetSetOptionA(NULL, INTERNET_OPTION_CALLBACK, &cb, sizeof(DWORD_PTR));
3159     error = GetLastError();
3160     ok(!ret, "InternetSetOptionA succeeded\n");
3161     ok(error == ERROR_INTERNET_INCORRECT_HANDLE_TYPE, "got %u expected ERROR_INTERNET_INCORRECT_HANDLE_TYPE\n", error);
3162
3163     ret = InternetSetOptionA(ses, INTERNET_OPTION_CALLBACK, &cb, sizeof(DWORD_PTR));
3164     error = GetLastError();
3165     ok(!ret, "InternetSetOptionA failed\n");
3166     ok(error == ERROR_INTERNET_OPTION_NOT_SETTABLE, "got %u expected ERROR_INTERNET_OPTION_NOT_SETTABLE\n", error);
3167
3168     pInternetSetStatusCallbackA(ses, cb);
3169     ResetEvent(ctx.event);
3170
3171     req = InternetOpenUrl(ses, "http://test.winehq.org", NULL, 0, 0, (DWORD_PTR)&ctx);
3172     ok(!req && GetLastError() == ERROR_IO_PENDING, "InternetOpenUrl failed\n");
3173
3174     WaitForSingleObject(ctx.event, INFINITE);
3175
3176     type = 0;
3177     size = sizeof(type);
3178     ret = InternetQueryOption(ctx.req, INTERNET_OPTION_HANDLE_TYPE, &type, &size);
3179     ok(ret, "InternetQueryOption failed: %u\n", GetLastError());
3180     ok(type == INTERNET_HANDLE_TYPE_HTTP_REQUEST,
3181        "expected INTERNET_HANDLE_TYPE_HTTP_REQUEST, got %u\n", type);
3182
3183     size = 0;
3184     ret = HttpQueryInfo(ctx.req, HTTP_QUERY_RAW_HEADERS_CRLF, NULL, &size, NULL);
3185     ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "HttpQueryInfo failed\n");
3186     ok(size > 0, "expected size > 0\n");
3187
3188     ResetEvent(ctx.event);
3189     InternetCloseHandle(ctx.req);
3190     WaitForSingleObject(ctx.event, INFINITE);
3191
3192     InternetCloseHandle(ses);
3193     CloseHandle(ctx.event);
3194 }
3195
3196 enum api
3197 {
3198     internet_connect = 1,
3199     http_open_request,
3200     http_send_request_ex,
3201     internet_writefile,
3202     http_end_request,
3203     internet_close_handle
3204 };
3205
3206 struct notification
3207 {
3208     enum api     function; /* api responsible for notification */
3209     unsigned int status;   /* status received */
3210     int          async;    /* delivered from another thread? */
3211     int          todo;
3212     int          optional;
3213 };
3214
3215 struct info
3216 {
3217     enum api     function;
3218     const struct notification *test;
3219     unsigned int count;
3220     unsigned int index;
3221     HANDLE       wait;
3222     DWORD        thread;
3223     unsigned int line;
3224     DWORD        expect_result;
3225     BOOL         is_aborted;
3226 };
3227
3228 static CRITICAL_SECTION notification_cs;
3229
3230 static void CALLBACK check_notification( HINTERNET handle, DWORD_PTR context, DWORD status, LPVOID buffer, DWORD buflen )
3231 {
3232     BOOL status_ok, function_ok;
3233     struct info *info = (struct info *)context;
3234     unsigned int i;
3235
3236     EnterCriticalSection( &notification_cs );
3237
3238     if(info->is_aborted) {
3239         LeaveCriticalSection(&notification_cs);
3240         return;
3241     }
3242
3243     if (status == INTERNET_STATUS_HANDLE_CREATED)
3244     {
3245         DWORD size = sizeof(struct info *);
3246         HttpQueryInfoA( handle, INTERNET_OPTION_CONTEXT_VALUE, &info, &size, 0 );
3247     }else if(status == INTERNET_STATUS_REQUEST_COMPLETE) {
3248         INTERNET_ASYNC_RESULT *ar = (INTERNET_ASYNC_RESULT*)buffer;
3249
3250         ok(buflen == sizeof(*ar), "unexpected buflen = %d\n", buflen);
3251         if(info->expect_result == ERROR_SUCCESS) {
3252             ok(ar->dwResult == 1, "ar->dwResult = %ld, expected 1\n", ar->dwResult);
3253         }else {
3254             ok(!ar->dwResult, "ar->dwResult = %ld, expected 1\n", ar->dwResult);
3255             ok(ar->dwError == info->expect_result, "ar->dwError = %d, expected %d\n", ar->dwError, info->expect_result);
3256         }
3257     }
3258
3259     i = info->index;
3260     if (i >= info->count)
3261     {
3262         LeaveCriticalSection( &notification_cs );
3263         return;
3264     }
3265
3266     while (info->test[i].status != status &&
3267         (info->test[i].optional || info->test[i].todo) &&
3268         i < info->count - 1 &&
3269         info->test[i].function == info->test[i + 1].function)
3270     {
3271         i++;
3272     }
3273
3274     status_ok   = (info->test[i].status == status);
3275     function_ok = (info->test[i].function == info->function);
3276
3277     if (!info->test[i].todo)
3278     {
3279         ok( status_ok, "%u: expected status %u got %u\n", info->line, info->test[i].status, status );
3280         ok( function_ok, "%u: expected function %u got %u\n", info->line, info->test[i].function, info->function );
3281
3282         if (info->test[i].async)
3283             ok(info->thread != GetCurrentThreadId(), "%u: expected thread %u got %u\n",
3284                info->line, info->thread, GetCurrentThreadId());
3285     }
3286     else
3287     {
3288         todo_wine ok( status_ok, "%u: expected status %u got %u\n", info->line, info->test[i].status, status );
3289         if (status_ok)
3290             todo_wine ok( function_ok, "%u: expected function %u got %u\n", info->line, info->test[i].function, info->function );
3291     }
3292     if (i == info->count - 1 || info->test[i].function != info->test[i + 1].function) SetEvent( info->wait );
3293     info->index = i+1;
3294
3295     LeaveCriticalSection( &notification_cs );
3296 }
3297
3298 static void setup_test( struct info *info, enum api function, unsigned int line, DWORD expect_result )
3299 {
3300     info->function = function;
3301     info->line = line;
3302     info->expect_result = expect_result;
3303 }
3304
3305 struct notification_data
3306 {
3307     const struct notification *test;
3308     const unsigned int count;
3309     const char *method;
3310     const char *host;
3311     const char *path;
3312     const char *data;
3313     BOOL expect_conn_failure;
3314 };
3315
3316 static const struct notification async_send_request_ex_test[] =
3317 {
3318     { internet_connect,      INTERNET_STATUS_HANDLE_CREATED, 0 },
3319     { http_open_request,     INTERNET_STATUS_HANDLE_CREATED, 0 },
3320     { http_send_request_ex,  INTERNET_STATUS_DETECTING_PROXY, 1, 0, 1 },
3321     { http_send_request_ex,  INTERNET_STATUS_RESOLVING_NAME, 1, 0, 1 },
3322     { http_send_request_ex,  INTERNET_STATUS_NAME_RESOLVED, 1, 0, 1 },
3323     { http_send_request_ex,  INTERNET_STATUS_CONNECTING_TO_SERVER, 1 },
3324     { http_send_request_ex,  INTERNET_STATUS_CONNECTED_TO_SERVER, 1 },
3325     { http_send_request_ex,  INTERNET_STATUS_SENDING_REQUEST, 1 },
3326     { http_send_request_ex,  INTERNET_STATUS_REQUEST_SENT, 1 },
3327     { http_send_request_ex,  INTERNET_STATUS_REQUEST_COMPLETE, 1 },
3328     { internet_writefile,    INTERNET_STATUS_SENDING_REQUEST, 0 },
3329     { internet_writefile,    INTERNET_STATUS_REQUEST_SENT, 0 },
3330     { http_end_request,      INTERNET_STATUS_RECEIVING_RESPONSE, 1 },
3331     { http_end_request,      INTERNET_STATUS_RESPONSE_RECEIVED, 1 },
3332     { http_end_request,      INTERNET_STATUS_REQUEST_COMPLETE, 1 },
3333     { internet_close_handle, INTERNET_STATUS_CLOSING_CONNECTION, 0, 0, 1 },
3334     { internet_close_handle, INTERNET_STATUS_CONNECTION_CLOSED, 0, 0, 1 },
3335     { internet_close_handle, INTERNET_STATUS_HANDLE_CLOSING, 0, },
3336     { internet_close_handle, INTERNET_STATUS_HANDLE_CLOSING, 0, }
3337 };
3338
3339 static const struct notification async_send_request_ex_test2[] =
3340 {
3341     { internet_connect,      INTERNET_STATUS_HANDLE_CREATED, 0 },
3342     { http_open_request,     INTERNET_STATUS_HANDLE_CREATED, 0 },
3343     { http_send_request_ex,  INTERNET_STATUS_DETECTING_PROXY, 1, 0, 1 },
3344     { http_send_request_ex,  INTERNET_STATUS_RESOLVING_NAME, 1, 0, 1 },
3345     { http_send_request_ex,  INTERNET_STATUS_NAME_RESOLVED, 1, 0, 1 },
3346     { http_send_request_ex,  INTERNET_STATUS_CONNECTING_TO_SERVER, 1, 1 },
3347     { http_send_request_ex,  INTERNET_STATUS_CONNECTED_TO_SERVER, 1, 1 },
3348     { http_send_request_ex,  INTERNET_STATUS_SENDING_REQUEST, 1 },
3349     { http_send_request_ex,  INTERNET_STATUS_REQUEST_SENT, 1 },
3350     { http_send_request_ex,  INTERNET_STATUS_REQUEST_COMPLETE, 1 },
3351     { http_end_request,      INTERNET_STATUS_RECEIVING_RESPONSE, 1 },
3352     { http_end_request,      INTERNET_STATUS_RESPONSE_RECEIVED, 1 },
3353     { http_end_request,      INTERNET_STATUS_REQUEST_COMPLETE, 1 },
3354     { internet_close_handle, INTERNET_STATUS_CLOSING_CONNECTION, 0, 0, 1 },
3355     { internet_close_handle, INTERNET_STATUS_CONNECTION_CLOSED, 0, 0, 1 },
3356     { internet_close_handle, INTERNET_STATUS_HANDLE_CLOSING, 0, },
3357     { internet_close_handle, INTERNET_STATUS_HANDLE_CLOSING, 0, }
3358 };
3359
3360 static const struct notification async_send_request_ex_resolve_failure_test[] =
3361 {
3362     { internet_connect,      INTERNET_STATUS_HANDLE_CREATED, 0 },
3363     { http_open_request,     INTERNET_STATUS_HANDLE_CREATED, 0 },
3364     { http_send_request_ex,  INTERNET_STATUS_DETECTING_PROXY, 1, 0, 1 },
3365     { http_send_request_ex,  INTERNET_STATUS_RESOLVING_NAME, 1 },
3366     { http_send_request_ex,  INTERNET_STATUS_DETECTING_PROXY, 1, 0, 1 },
3367     { http_send_request_ex,  INTERNET_STATUS_REQUEST_COMPLETE, 1 },
3368     { http_end_request,      INTERNET_STATUS_REQUEST_COMPLETE, 1 },
3369     { internet_close_handle, INTERNET_STATUS_CLOSING_CONNECTION, 0, 0, 1 },
3370     { internet_close_handle, INTERNET_STATUS_CONNECTION_CLOSED, 0, 0, 1 },
3371     { internet_close_handle, INTERNET_STATUS_HANDLE_CLOSING, 0, },
3372     { internet_close_handle, INTERNET_STATUS_HANDLE_CLOSING, 0, }
3373 };
3374
3375 static const struct notification_data notification_data[] = {
3376     {
3377         async_send_request_ex_test,
3378         sizeof(async_send_request_ex_test)/sizeof(async_send_request_ex_test[0]),
3379         "POST",
3380         "test.winehq.org",
3381         "tests/posttest.php",
3382         "Public ID=codeweavers"
3383     },
3384     {
3385         async_send_request_ex_test2,
3386         sizeof(async_send_request_ex_test)/sizeof(async_send_request_ex_test[0]),
3387         "POST",
3388         "test.winehq.org",
3389         "tests/posttest.php"
3390     },
3391     {
3392         async_send_request_ex_resolve_failure_test,
3393         sizeof(async_send_request_ex_resolve_failure_test)/sizeof(async_send_request_ex_resolve_failure_test[0]),
3394         "GET",
3395         "brokenhost",
3396         "index.html",
3397         NULL,
3398         TRUE
3399     }
3400 };
3401
3402 static void test_async_HttpSendRequestEx(const struct notification_data *nd)
3403 {
3404     BOOL ret;
3405     HINTERNET ses, req, con;
3406     struct info info;
3407     DWORD size, written, error;
3408     INTERNET_BUFFERSA b;
3409     static const char *accept[2] = {"*/*", NULL};
3410     char buffer[32];
3411
3412     trace("Async HttpSendRequestEx test (%s %s)\n", nd->method, nd->host);
3413
3414     InitializeCriticalSection( &notification_cs );
3415
3416     info.test  = nd->test;
3417     info.count = nd->count;
3418     info.index = 0;
3419     info.wait = CreateEvent( NULL, FALSE, FALSE, NULL );
3420     info.thread = GetCurrentThreadId();
3421     info.is_aborted = FALSE;
3422
3423     ses = InternetOpen( "winetest", 0, NULL, NULL, INTERNET_FLAG_ASYNC );
3424     ok( ses != NULL, "InternetOpen failed\n" );
3425
3426     pInternetSetStatusCallbackA( ses, check_notification );
3427
3428     setup_test( &info, internet_connect, __LINE__, ERROR_SUCCESS );
3429     con = InternetConnect( ses, nd->host, 80, NULL, NULL, INTERNET_SERVICE_HTTP, 0, (DWORD_PTR)&info );
3430     ok( con != NULL, "InternetConnect failed %u\n", GetLastError() );
3431
3432     WaitForSingleObject( info.wait, 10000 );
3433
3434     setup_test( &info, http_open_request, __LINE__, ERROR_SUCCESS );
3435     req = HttpOpenRequest( con, nd->method, nd->path, NULL, NULL, accept, 0, (DWORD_PTR)&info );
3436     ok( req != NULL, "HttpOpenRequest failed %u\n", GetLastError() );
3437
3438     WaitForSingleObject( info.wait, 10000 );
3439
3440     if(nd->data) {
3441         memset( &b, 0, sizeof(INTERNET_BUFFERSA) );
3442         b.dwStructSize = sizeof(INTERNET_BUFFERSA);
3443         b.lpcszHeader = "Content-Type: application/x-www-form-urlencoded";
3444         b.dwHeadersLength = strlen( b.lpcszHeader );
3445         b.dwBufferTotal = nd->data ? strlen( nd->data ) : 0;
3446     }
3447
3448     setup_test( &info, http_send_request_ex, __LINE__,
3449             nd->expect_conn_failure ? ERROR_INTERNET_NAME_NOT_RESOLVED : ERROR_SUCCESS );
3450     ret = HttpSendRequestExA( req, nd->data ? &b : NULL, NULL, 0x28, 0 );
3451     ok( !ret && GetLastError() == ERROR_IO_PENDING, "HttpSendRequestExA failed %d %u\n", ret, GetLastError() );
3452
3453     error = WaitForSingleObject( info.wait, 10000 );
3454     if(error != WAIT_OBJECT_0) {
3455         skip("WaitForSingleObject returned %d, assuming DNS problem\n", error);
3456         info.is_aborted = TRUE;
3457         goto abort;
3458     }
3459
3460     size = sizeof(buffer);
3461     SetLastError( 0xdeadbeef );
3462     ret = HttpQueryInfoA( req, HTTP_QUERY_CONTENT_ENCODING, buffer, &size, 0 );
3463     error = GetLastError();
3464     ok( !ret, "HttpQueryInfoA failed %u\n", GetLastError() );
3465     if(nd->expect_conn_failure) {
3466         ok(error == ERROR_HTTP_HEADER_NOT_FOUND, "expected ERROR_HTTP_HEADER_NOT_FOUND got %u\n", error );
3467     }else {
3468         todo_wine
3469         ok(error == ERROR_INTERNET_INCORRECT_HANDLE_STATE,
3470             "expected ERROR_INTERNET_INCORRECT_HANDLE_STATE got %u\n", error );
3471     }
3472
3473     if (nd->data)
3474     {
3475         written = 0;
3476         size = strlen( nd->data );
3477         setup_test( &info, internet_writefile, __LINE__, ERROR_SUCCESS );
3478         ret = InternetWriteFile( req, nd->data, size, &written );
3479         ok( ret, "InternetWriteFile failed %u\n", GetLastError() );
3480         ok( written == size, "expected %u got %u\n", written, size );
3481
3482         WaitForSingleObject( info.wait, 10000 );
3483
3484         SetLastError( 0xdeadbeef );
3485         ret = HttpEndRequestA( req, (void *)nd->data, 0x28, 0 );
3486         error = GetLastError();
3487         ok( !ret, "HttpEndRequestA succeeded\n" );
3488         ok( error == ERROR_INVALID_PARAMETER, "expected ERROR_INVALID_PARAMETER got %u\n", error );
3489     }
3490
3491     SetLastError( 0xdeadbeef );
3492     setup_test( &info, http_end_request, __LINE__,
3493             nd->expect_conn_failure ? ERROR_INTERNET_OPERATION_CANCELLED : ERROR_SUCCESS);
3494     ret = HttpEndRequestA( req, NULL, 0x28, 0 );
3495     error = GetLastError();
3496     ok( !ret, "HttpEndRequestA succeeded\n" );
3497     ok( error == ERROR_IO_PENDING, "expected ERROR_IO_PENDING got %u\n", error );
3498
3499     WaitForSingleObject( info.wait, 10000 );
3500
3501     setup_test( &info, internet_close_handle, __LINE__, ERROR_SUCCESS );
3502  abort:
3503     InternetCloseHandle( req );
3504     InternetCloseHandle( con );
3505     InternetCloseHandle( ses );
3506
3507     WaitForSingleObject( info.wait, 10000 );
3508     Sleep(100);
3509     CloseHandle( info.wait );
3510 }
3511
3512 static HINTERNET closetest_session, closetest_req, closetest_conn;
3513 static BOOL closetest_closed;
3514
3515 static void WINAPI closetest_callback(HINTERNET hInternet, DWORD_PTR dwContext, DWORD dwInternetStatus,
3516      LPVOID lpvStatusInformation, DWORD dwStatusInformationLength)
3517 {
3518     DWORD len, type;
3519     BOOL res;
3520
3521     trace("closetest_callback %p: %d\n", hInternet, dwInternetStatus);
3522
3523     ok(hInternet == closetest_session || hInternet == closetest_conn || hInternet == closetest_req,
3524        "Unexpected hInternet %p\n", hInternet);
3525     if(!closetest_closed)
3526         return;
3527
3528     len = sizeof(type);
3529     res = InternetQueryOptionA(closetest_req, INTERNET_OPTION_HANDLE_TYPE, &type, &len);
3530     ok(!res && GetLastError() == ERROR_INVALID_HANDLE,
3531        "InternetQueryOptionA(%p INTERNET_OPTION_HANDLE_TYPE) failed: %x %u, expected TRUE ERROR_INVALID_HANDLE\n",
3532        closetest_req, res, GetLastError());
3533 }
3534
3535 static void test_InternetCloseHandle(void)
3536 {
3537     DWORD len, flags;
3538     BOOL res;
3539
3540     closetest_session = InternetOpenA("", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, INTERNET_FLAG_ASYNC);
3541     ok(closetest_session != NULL,"InternetOpen failed with error %u\n", GetLastError());
3542
3543     pInternetSetStatusCallbackA(closetest_session, closetest_callback);
3544
3545     closetest_conn = InternetConnectA(closetest_session, "source.winehq.org", INTERNET_INVALID_PORT_NUMBER,
3546             NULL, NULL, INTERNET_SERVICE_HTTP, 0x0, 0xdeadbeef);
3547     ok(closetest_conn != NULL,"InternetConnect failed with error %u\n", GetLastError());
3548
3549     closetest_req = HttpOpenRequestA(closetest_conn, "GET", "winegecko.php", NULL, NULL, NULL,
3550             INTERNET_FLAG_KEEP_CONNECTION | INTERNET_FLAG_RESYNCHRONIZE, 0xdeadbead);
3551
3552     res = HttpSendRequestA(closetest_req, NULL, -1, NULL, 0);
3553     ok(!res && (GetLastError() == ERROR_IO_PENDING),
3554        "Asynchronous HttpSendRequest NOT returning 0 with error ERROR_IO_PENDING\n");
3555
3556     len = sizeof(flags);
3557     res = InternetQueryOptionA(closetest_req, INTERNET_OPTION_REQUEST_FLAGS, &flags, &len);
3558     ok(res, "InternetQueryOptionA(%p INTERNET_OPTION_URL) failed: %u\n", closetest_req, GetLastError());
3559
3560     res = InternetCloseHandle(closetest_session);
3561     ok(res, "InternetCloseHandle failed: %u\n", GetLastError());
3562     closetest_closed = TRUE;
3563     trace("Closed session handle\n");
3564
3565     res = InternetCloseHandle(closetest_conn);
3566     ok(!res && GetLastError() == ERROR_INVALID_HANDLE, "InternetCloseConnection(conn) failed: %x %u\n",
3567        res, GetLastError());
3568
3569     res = InternetCloseHandle(closetest_req);
3570     ok(!res && GetLastError() == ERROR_INVALID_HANDLE, "InternetCloseConnection(req) failed: %x %u\n",
3571        res, GetLastError());
3572
3573     len = sizeof(flags);
3574     res = InternetQueryOptionA(closetest_req, INTERNET_OPTION_REQUEST_FLAGS, &flags, &len);
3575     ok(!res && GetLastError() == ERROR_INVALID_HANDLE,
3576        "InternetQueryOptionA(%p INTERNET_OPTION_URL) failed: %x %u, expected TRUE ERROR_INVALID_HANDLE\n",
3577        closetest_req, res, GetLastError());
3578 }
3579
3580 static void init_status_tests(void)
3581 {
3582     memset(expect, 0, sizeof(expect));
3583     memset(optional, 0, sizeof(optional));
3584     memset(wine_allow, 0, sizeof(wine_allow));
3585     memset(notified, 0, sizeof(notified));
3586     memset(status_string, 0, sizeof(status_string));
3587
3588 #define STATUS_STRING(status) status_string[status] = #status
3589     STATUS_STRING(INTERNET_STATUS_RESOLVING_NAME);
3590     STATUS_STRING(INTERNET_STATUS_NAME_RESOLVED);
3591     STATUS_STRING(INTERNET_STATUS_CONNECTING_TO_SERVER);
3592     STATUS_STRING(INTERNET_STATUS_CONNECTED_TO_SERVER);
3593     STATUS_STRING(INTERNET_STATUS_SENDING_REQUEST);
3594     STATUS_STRING(INTERNET_STATUS_REQUEST_SENT);
3595     STATUS_STRING(INTERNET_STATUS_RECEIVING_RESPONSE);
3596     STATUS_STRING(INTERNET_STATUS_RESPONSE_RECEIVED);
3597     STATUS_STRING(INTERNET_STATUS_CTL_RESPONSE_RECEIVED);
3598     STATUS_STRING(INTERNET_STATUS_PREFETCH);
3599     STATUS_STRING(INTERNET_STATUS_CLOSING_CONNECTION);
3600     STATUS_STRING(INTERNET_STATUS_CONNECTION_CLOSED);
3601     STATUS_STRING(INTERNET_STATUS_HANDLE_CREATED);
3602     STATUS_STRING(INTERNET_STATUS_HANDLE_CLOSING);
3603     STATUS_STRING(INTERNET_STATUS_DETECTING_PROXY);
3604     STATUS_STRING(INTERNET_STATUS_REQUEST_COMPLETE);
3605     STATUS_STRING(INTERNET_STATUS_REDIRECT);
3606     STATUS_STRING(INTERNET_STATUS_INTERMEDIATE_RESPONSE);
3607     STATUS_STRING(INTERNET_STATUS_USER_INPUT_REQUIRED);
3608     STATUS_STRING(INTERNET_STATUS_STATE_CHANGE);
3609     STATUS_STRING(INTERNET_STATUS_COOKIE_SENT);
3610     STATUS_STRING(INTERNET_STATUS_COOKIE_RECEIVED);
3611     STATUS_STRING(INTERNET_STATUS_PRIVACY_IMPACTED);
3612     STATUS_STRING(INTERNET_STATUS_P3P_HEADER);
3613     STATUS_STRING(INTERNET_STATUS_P3P_POLICYREF);
3614     STATUS_STRING(INTERNET_STATUS_COOKIE_HISTORY);
3615 #undef STATUS_STRING
3616 }
3617
3618 START_TEST(http)
3619 {
3620     HMODULE hdll;
3621     hdll = GetModuleHandleA("wininet.dll");
3622
3623     if(!GetProcAddress(hdll, "InternetGetCookieExW")) {
3624         win_skip("Too old IE (older than 6.0)\n");
3625         return;
3626     }
3627
3628     pInternetSetStatusCallbackA = (void*)GetProcAddress(hdll, "InternetSetStatusCallbackA");
3629
3630     init_status_tests();
3631     test_InternetCloseHandle();
3632     InternetReadFile_test(INTERNET_FLAG_ASYNC, &test_data[0]);
3633     InternetReadFile_test(INTERNET_FLAG_ASYNC, &test_data[1]);
3634     InternetReadFile_test(0, &test_data[1]);
3635     first_connection_to_test_url = TRUE;
3636     InternetReadFile_test(INTERNET_FLAG_ASYNC, &test_data[2]);
3637     InternetReadFile_test(0, &test_data[2]);
3638     InternetReadFileExA_test(INTERNET_FLAG_ASYNC);
3639     test_open_url_async();
3640     test_async_HttpSendRequestEx(&notification_data[0]);
3641     test_async_HttpSendRequestEx(&notification_data[1]);
3642     test_async_HttpSendRequestEx(&notification_data[2]);
3643     InternetOpenRequest_test();
3644     test_http_cache();
3645     InternetOpenUrlA_test();
3646     HttpHeaders_test();
3647     test_http_connection();
3648     test_secure_connection();
3649     test_user_agent_header();
3650     test_bogus_accept_types_array();
3651     InternetReadFile_chunked_test();
3652     HttpSendRequestEx_test();
3653     InternetReadFile_test(INTERNET_FLAG_ASYNC, &test_data[3]);
3654 }