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