projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[URLMON_WINETEST] Sync with Wine Staging 1.9.23. CORE-12409
[reactos.git] / rostests / winetests / urlmon / url.c
1 /*
2 * UrlMon URL tests
3 *
4 * Copyright 2004 Kevin Koltzau
5 * Copyright 2004-2007 Jacek Caban for CodeWeavers
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #define WIN32_NO_STATUS
23 #define _INC_WINDOWS
24 #define COM_NO_WINDOWS_H
25
26 //#include <stdarg.h>
27 #include <stdio.h>
28
29 #define COBJMACROS
30 #define NONAMELESSUNION
31 #define CONST_VTABLE
32
33 #include <windef.h>
34 #include <winbase.h>
35 #include <winnls.h>
36 #include <winreg.h>
37 #include <wingdi.h>
38 #include <objbase.h>
39 //#include "initguid.h"
40 //#include "urlmon.h"
41 #include <wininet.h>
42 #include <mshtml.h>
43
44 #include <wine/test.h>
45
46 static HRESULT (WINAPI *pCreateAsyncBindCtxEx)(IBindCtx *, DWORD,
47 IBindStatusCallback *, IEnumFORMATETC *, IBindCtx **, DWORD);
48 static HRESULT (WINAPI *pCreateUri)(LPCWSTR, DWORD, DWORD_PTR, IUri**);
49
50 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
51 DEFINE_GUID(CLSID_IdentityUnmarshal,0x0000001b,0x0000,0x0000,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46);
52 DEFINE_GUID(IID_IBindStatusCallbackHolder,0x79eac9cc,0xbaf9,0x11ce,0x8c,0x82,0x00,0xaa,0x00,0x4b,0xa9,0x0b);
53 static const IID IID_undocumentedIE11 = {0xd5ae15f6,0x2032,0x488e,{0x8f,0x96,0xf9,0x24,0x06,0xd8,0xd8,0xb4}};
54 extern CLSID CLSID_AboutProtocol;
55
56 #define DEFINE_EXPECT(func) \
57 static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
58
59 #define SET_EXPECT(func) \
60 do { called_ ## func = FALSE; expect_ ## func = TRUE; } while(0)
61
62 #define CHECK_EXPECT2(func) \
63 do { \
64 ok(expect_ ##func, "unexpected call " #func "\n"); \
65 called_ ## func = TRUE; \
66 }while(0)
67
68 #define CHECK_EXPECT(func) \
69 do { \
70 CHECK_EXPECT2(func); \
71 expect_ ## func = FALSE; \
72 }while(0)
73
74 #define CHECK_CALLED(func) \
75 do { \
76 ok(called_ ## func, "expected " #func "\n"); \
77 expect_ ## func = called_ ## func = FALSE; \
78 }while(0)
79
80 #define CHECK_NOT_CALLED(func) \
81 do { \
82 ok(!called_ ## func, "unexpected " #func "\n"); \
83 expect_ ## func = called_ ## func = FALSE; \
84 }while(0)
85
86 #define CHECK_CALLED_BROKEN(func) \
87 do { \
88 ok(called_ ## func || broken(!called_ ## func), "expected " #func "\n"); \
89 expect_ ## func = called_ ## func = FALSE; \
90 }while(0)
91
92 #define CLEAR_CALLED(func) \
93 expect_ ## func = called_ ## func = FALSE
94
95 DEFINE_EXPECT(QueryInterface_IServiceProvider);
96 DEFINE_EXPECT(QueryInterface_IHttpNegotiate);
97 DEFINE_EXPECT(QueryInterface_IBindStatusCallback);
98 DEFINE_EXPECT(QueryInterface_IBindStatusCallbackEx);
99 DEFINE_EXPECT(QueryInterface_IBindStatusCallbackHolder);
100 DEFINE_EXPECT(QueryInterface_IAuthenticate);
101 DEFINE_EXPECT(QueryInterface_IInternetProtocol);
102 DEFINE_EXPECT(QueryInterface_IWindowForBindingUI);
103 DEFINE_EXPECT(QueryInterface_IHttpSecurity);
104 DEFINE_EXPECT(QueryService_IAuthenticate);
105 DEFINE_EXPECT(QueryService_IInternetProtocol);
106 DEFINE_EXPECT(QueryService_IInternetBindInfo);
107 DEFINE_EXPECT(QueryService_IWindowForBindingUI);
108 DEFINE_EXPECT(QueryService_IHttpSecurity);
109 DEFINE_EXPECT(BeginningTransaction);
110 DEFINE_EXPECT(OnResponse);
111 DEFINE_EXPECT(QueryInterface_IHttpNegotiate2);
112 DEFINE_EXPECT(GetRootSecurityId);
113 DEFINE_EXPECT(GetBindInfo);
114 DEFINE_EXPECT(GetBindInfoEx);
115 DEFINE_EXPECT(OnStartBinding);
116 DEFINE_EXPECT(OnProgress_FINDINGRESOURCE);
117 DEFINE_EXPECT(OnProgress_CONNECTING);
118 DEFINE_EXPECT(OnProgress_REDIRECTING);
119 DEFINE_EXPECT(OnProgress_SENDINGREQUEST);
120 DEFINE_EXPECT(OnProgress_MIMETYPEAVAILABLE);
121 DEFINE_EXPECT(OnProgress_BEGINDOWNLOADDATA);
122 DEFINE_EXPECT(OnProgress_DOWNLOADINGDATA);
123 DEFINE_EXPECT(OnProgress_ENDDOWNLOADDATA);
124 DEFINE_EXPECT(OnProgress_CACHEFILENAMEAVAILABLE);
125 DEFINE_EXPECT(OnStopBinding);
126 DEFINE_EXPECT(OnDataAvailable);
127 DEFINE_EXPECT(OnObjectAvailable);
128 DEFINE_EXPECT(Obj_OnStartBinding);
129 DEFINE_EXPECT(Obj_OnStopBinding);
130 DEFINE_EXPECT(Obj_GetBindInfo);
131 DEFINE_EXPECT(Obj_OnProgress_BEGINDOWNLOADDATA);
132 DEFINE_EXPECT(Obj_OnProgress_ENDDOWNLOADDATA);
133 DEFINE_EXPECT(Obj_OnProgress_SENDINGREQUEST);
134 DEFINE_EXPECT(Obj_OnProgress_MIMETYPEAVAILABLE);
135 DEFINE_EXPECT(Obj_OnProgress_CLASSIDAVAILABLE);
136 DEFINE_EXPECT(Obj_OnProgress_BEGINSYNCOPERATION);
137 DEFINE_EXPECT(Obj_OnProgress_ENDSYNCOPERATION);
138 DEFINE_EXPECT(Obj_OnProgress_FINDINGRESOURCE);
139 DEFINE_EXPECT(Obj_OnProgress_CONNECTING);
140 DEFINE_EXPECT(Obj_OnProgress_REDIRECTING);
141 DEFINE_EXPECT(Obj_OnProgress_CACHEFILENAMEAVAILABLE);
142 DEFINE_EXPECT(Start);
143 DEFINE_EXPECT(Read);
144 DEFINE_EXPECT(LockRequest);
145 DEFINE_EXPECT(Terminate);
146 DEFINE_EXPECT(UnlockRequest);
147 DEFINE_EXPECT(Continue);
148 DEFINE_EXPECT(Abort);
149 DEFINE_EXPECT(CreateInstance);
150 DEFINE_EXPECT(Load);
151 DEFINE_EXPECT(PutProperty_MIMETYPEPROP);
152 DEFINE_EXPECT(PutProperty_CLASSIDPROP);
153 DEFINE_EXPECT(SetPriority);
154 DEFINE_EXPECT(GetWindow_IHttpSecurity);
155 DEFINE_EXPECT(GetWindow_IWindowForBindingUI);
156 DEFINE_EXPECT(GetWindow_ICodeInstall);
157 DEFINE_EXPECT(OnSecurityProblem);
158
159 static const WCHAR winetest_data_urlW[] =
160 {'h','t','t','p',':','/','/','t','e','s','t','.','w','i','n','e','h','q','.','o','r','g','/',
161 't','e','s','t','s','/','d','a','t','a','.','p','h','p',0};
162 static const WCHAR about_blankW[] = {'a','b','o','u','t',':','b','l','a','n','k',0};
163
164 static const WCHAR wszTextHtml[] = {'t','e','x','t','/','h','t','m','l',0};
165
166 static WCHAR BSCBHolder[] = { '_','B','S','C','B','_','H','o','l','d','e','r','_',0 };
167
168 static const WCHAR wszWineHQSite[] =
169 {'w','w','w','.','w','i','n','e','h','q','.','o','r','g',0};
170 static const WCHAR wszWineHQIP[] =
171 {'2','0','9','.','3','2','.','1','4','1','.','3',0};
172 static const CHAR wszIndexHtmlA[] = "index.html";
173 static const WCHAR cache_fileW[] = {'c',':','\\','c','a','c','h','e','.','h','t','m',0};
174 static const CHAR dwl_htmlA[] = "dwl.html";
175 static const WCHAR dwl_htmlW[] = {'d','w','l','.','h','t','m','l',0};
176 static const CHAR test_txtA[] = "test.txt";
177 static const WCHAR emptyW[] = {0};
178
179 static BOOL stopped_binding = FALSE, stopped_obj_binding = FALSE, emulate_protocol = FALSE,
180 data_available = FALSE, http_is_first = TRUE, bind_to_object = FALSE, filedwl_api, post_test;
181 static DWORD read = 0, bindf = 0, prot_state = 0, thread_id, tymed, security_problem;
182 static const WCHAR *reported_url;
183 static CHAR mime_type[512];
184 static IInternetProtocolSink *protocol_sink = NULL;
185 static IBinding *current_binding;
186 static HANDLE complete_event, complete_event2;
187 static HRESULT binding_hres;
188 static HRESULT onsecurityproblem_hres;
189 static HRESULT abort_hres;
190 static BOOL have_IHttpNegotiate2, use_bscex, is_async_prot;
191 static BOOL test_redirect, use_cache_file, callback_read, no_callback, test_abort;
192 static WCHAR cache_file_name[MAX_PATH];
193 static BOOL only_check_prot_args = FALSE;
194 static BOOL invalid_cn_accepted = FALSE;
195 static BOOL abort_start = FALSE;
196 static BOOL abort_progress = FALSE;
197 static BOOL async_switch = FALSE;
198 static BOOL strict_bsc_qi;
199 static DWORD bindtest_flags;
200 static const char *test_file;
201
202 static WCHAR file_url[INTERNET_MAX_URL_LENGTH], current_url[INTERNET_MAX_URL_LENGTH];
203
204 static enum {
205 HTTP_TEST,
206 ABOUT_TEST,
207 FILE_TEST,
208 ITS_TEST,
209 MK_TEST,
210 HTTPS_TEST,
211 FTP_TEST,
212 WINETEST_TEST,
213 WINETEST_SYNC_TEST
214 } test_protocol;
215
216 static enum {
217 BEFORE_DOWNLOAD,
218 DOWNLOADING,
219 END_DOWNLOAD
220 } download_state;
221
222 static BOOL proxy_active(void)
223 {
224 HKEY internet_settings;
225 DWORD proxy_enable;
226 DWORD size;
227
228 if (RegOpenKeyExA(HKEY_CURRENT_USER, "Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",
229 0, KEY_QUERY_VALUE, &internet_settings) != ERROR_SUCCESS)
230 return FALSE;
231
232 size = sizeof(DWORD);
233 if (RegQueryValueExA(internet_settings, "ProxyEnable", NULL, NULL, (LPBYTE) &proxy_enable, &size) != ERROR_SUCCESS)
234 proxy_enable = 0;
235
236 RegCloseKey(internet_settings);
237
238 return proxy_enable != 0;
239 }
240
241 static BOOL is_urlmon_protocol(int prot)
242 {
243 return prot == FILE_TEST || prot == HTTP_TEST || prot == HTTPS_TEST || prot == FTP_TEST || prot == MK_TEST;
244 }
245
246 static void test_CreateURLMoniker(LPCWSTR url1, LPCWSTR url2)
247 {
248 HRESULT hr;
249 IMoniker *mon1 = NULL;
250 IMoniker *mon2 = NULL;
251
252 hr = CreateURLMoniker(NULL, NULL, NULL);
253 ok(hr == E_INVALIDARG,
254 "Expected CreateURLMoniker to return E_INVALIDARG, got 0x%08x\n", hr);
255
256 mon1 = (IMoniker *)0xdeadbeef;
257 hr = CreateURLMoniker(NULL, NULL, &mon1);
258 ok(hr == E_INVALIDARG,
259 "Expected CreateURLMoniker to return E_INVALIDARG, got 0x%08x\n", hr);
260 ok(mon1 == NULL, "Expected the output pointer to be NULL, got %p\n", mon1);
261
262 hr = CreateURLMoniker(NULL, emptyW, NULL);
263 ok(hr == E_INVALIDARG,
264 "Expected CreateURLMoniker to return E_INVALIDARG, got 0x%08x\n", hr);
265
266 hr = CreateURLMoniker(NULL, emptyW, &mon1);
267 ok(hr == S_OK ||
268 broken(hr == MK_E_SYNTAX), /* IE5/IE5.01/IE6 SP2 */
269 "Expected CreateURLMoniker to return S_OK, got 0x%08x\n", hr);
270 if(mon1) IMoniker_Release(mon1);
271
272 hr = CreateURLMoniker(NULL, url1, &mon1);
273 ok(hr == S_OK, "failed to create moniker: 0x%08x\n", hr);
274 if(hr == S_OK) {
275 hr = CreateURLMoniker(mon1, url2, &mon2);
276 ok(hr == S_OK, "failed to create moniker: 0x%08x\n", hr);
277 }
278 if(mon1) IMoniker_Release(mon1);
279 if(mon2) IMoniker_Release(mon2);
280 }
281
282 static void test_create(void)
283 {
284 static const WCHAR relativeW[] = {'a','/','b','.','t','x','t',0};
285 IStream *stream;
286 IMoniker *mon;
287 IBindCtx *bctx;
288 HRESULT hr;
289
290 static const WCHAR TEST_PART_URL_1[] = {'/','t','e','s','t','s','/','d','a','t','a','.','p','h','p',0};
291
292 test_CreateURLMoniker(winetest_data_urlW, TEST_PART_URL_1);
293
294 mon = (void*)0xdeadbeef;
295 hr = CreateURLMoniker(NULL, relativeW, &mon);
296 ok(hr == S_OK, "got 0x%08x\n", hr);
297
298 hr = CreateBindCtx(0, &bctx);
299 ok(hr == S_OK, "got 0x%08x\n", hr);
300
301 stream = (void*)0xdeadbeef;
302 hr = IMoniker_BindToStorage(mon, bctx, NULL, &IID_IStream, (void**)&stream);
303 todo_wine ok(hr == INET_E_UNKNOWN_PROTOCOL, "got 0x%08x\n", hr);
304 ok(stream == NULL, "got %p\n", stream);
305
306 hr = IMoniker_BindToStorage(mon, bctx, NULL, &IID_IStream, NULL);
307 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
308
309 stream = (void*)0xdeadbeef;
310 hr = IMoniker_BindToStorage(mon, NULL, NULL, &IID_IStream, (void**)&stream);
311 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
312 ok(stream == NULL || broken(stream == (void*)0xdeadbeef) /* starting XP SP3 it's set to null */,
313 "got %p\n", stream);
314
315 IMoniker_Release(mon);
316
317 mon = (void*)0xdaedbeef;
318 hr = CreateURLMoniker(NULL, winetest_data_urlW, &mon);
319 ok(hr == S_OK, "got 0x%08x\n", hr);
320
321 stream = (void*)0xdeadbeef;
322 hr = IMoniker_BindToStorage(mon, NULL, NULL, &IID_IStream, (void**)&stream);
323 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
324 ok(stream == NULL || broken(stream == (void*)0xdeadbeef) /* starting XP SP3 it's set to null */,
325 "got %p\n", stream);
326
327 hr = IMoniker_BindToStorage(mon, bctx, NULL, &IID_IStream, NULL);
328 ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
329
330 IMoniker_Release(mon);
331 IBindCtx_Release(bctx);
332 }
333
334 static HRESULT WINAPI Priority_QueryInterface(IInternetPriority *iface, REFIID riid, void **ppv)
335 {
336 ok(0, "unexpected call\n");
337 return E_NOINTERFACE;
338 }
339
340 static ULONG WINAPI Priority_AddRef(IInternetPriority *iface)
341 {
342 return 2;
343 }
344
345 static ULONG WINAPI Priority_Release(IInternetPriority *iface)
346 {
347 return 1;
348 }
349
350 static HRESULT WINAPI Priority_SetPriority(IInternetPriority *iface, LONG nPriority)
351 {
352 CHECK_EXPECT(SetPriority);
353 ok(!nPriority, "nPriority = %d\n", nPriority);
354 return S_OK;
355 }
356
357 static HRESULT WINAPI Priority_GetPriority(IInternetPriority *iface, LONG *pnPriority)
358 {
359 ok(0, "unexpected call\n");
360 return S_OK;
361 }
362
363 static const IInternetPriorityVtbl InternetPriorityVtbl = {
364 Priority_QueryInterface,
365 Priority_AddRef,
366 Priority_Release,
367 Priority_SetPriority,
368 Priority_GetPriority
369 };
370
371 static IInternetPriority InternetPriority = { &InternetPriorityVtbl };
372
373 static HRESULT WINAPI Protocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
374 {
375 static const IID IID_undocumentedIE10 = {0x7daf9908,0x8415,0x4005,{0x95,0xae,0xbd,0x27,0xf6,0xe3,0xdc,0x00}};
376
377 *ppv = NULL;
378
379 if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetProtocol, riid)) {
380 *ppv = iface;
381 return S_OK;
382 }
383
384 if(IsEqualGUID(&IID_IInternetPriority, riid)) {
385 if(!is_urlmon_protocol(test_protocol))
386 return E_NOINTERFACE;
387
388 *ppv = &InternetPriority;
389 return S_OK;
390 }
391
392 if(IsEqualGUID(&IID_IInternetProtocolEx, riid))
393 return E_NOINTERFACE; /* TODO */
394
395 if(IsEqualGUID(&IID_undocumentedIE10, riid)) {
396 trace("QI(%s)\n", wine_dbgstr_guid(riid));
397 return E_NOINTERFACE; /* TODO */
398 }
399
400 ok(0, "unexpected call %s\n", wine_dbgstr_guid(riid));
401 return E_NOINTERFACE;
402 }
403
404 static ULONG WINAPI Protocol_AddRef(IInternetProtocol *iface)
405 {
406 return 2;
407 }
408
409 static ULONG WINAPI Protocol_Release(IInternetProtocol *iface)
410 {
411 return 1;
412 }
413
414 static void test_switch_fail(void)
415 {
416 IInternetProtocolSink *binding_sink;
417 PROTOCOLDATA protocoldata = {0};
418 HRESULT hres;
419
420 static BOOL tested_switch_fail;
421
422 if(tested_switch_fail)
423 return;
424
425 tested_switch_fail = TRUE;
426
427 hres = IBinding_QueryInterface(current_binding, &IID_IInternetProtocolSink, (void**)&binding_sink);
428 ok(hres == S_OK, "Could not get IInternetProtocolSink iface: %08x\n", hres);
429 if(SUCCEEDED(hres)) {
430 hres = IInternetProtocolSink_Switch(binding_sink, &protocoldata);
431 ok(hres == E_FAIL, "Switch failed: %08x, expected E_FAIL\n", hres);
432 IInternetProtocolSink_Release(binding_sink);
433 }
434 }
435
436 static DWORD WINAPI thread_proc(PVOID arg)
437 {
438 PROTOCOLDATA protocoldata = {0};
439 HRESULT hres;
440
441 if(!no_callback) {
442 if(bind_to_object)
443 SET_EXPECT(Obj_OnProgress_FINDINGRESOURCE);
444 else
445 SET_EXPECT(OnProgress_FINDINGRESOURCE);
446 }
447 hres = IInternetProtocolSink_ReportProgress(protocol_sink,
448 BINDSTATUS_FINDINGRESOURCE, wszWineHQSite);
449 ok(hres == S_OK, "ReportProgress failed: %08x\n", hres);
450 if(!no_callback) {
451 ok( WaitForSingleObject(complete_event, 90000) == WAIT_OBJECT_0, "wait timed out\n" );
452 if(bind_to_object)
453 CHECK_CALLED(Obj_OnProgress_FINDINGRESOURCE);
454 else
455 CHECK_CALLED(OnProgress_FINDINGRESOURCE);
456 }
457
458 if(!no_callback) {
459 if(bind_to_object)
460 SET_EXPECT(Obj_OnProgress_CONNECTING);
461 else
462 SET_EXPECT(OnProgress_CONNECTING);
463 }
464 hres = IInternetProtocolSink_ReportProgress(protocol_sink,
465 BINDSTATUS_CONNECTING, wszWineHQIP);
466 ok(hres == S_OK, "ReportProgress failed: %08x\n", hres);
467 if(!no_callback) {
468 ok( WaitForSingleObject(complete_event, 90000) == WAIT_OBJECT_0, "wait timed out\n" );
469 if(bind_to_object)
470 CHECK_CALLED(Obj_OnProgress_CONNECTING);
471 else
472 CHECK_CALLED(OnProgress_CONNECTING);
473 }
474
475 if(!no_callback) {
476 if(bind_to_object)
477 SET_EXPECT(Obj_OnProgress_SENDINGREQUEST);
478 else
479 SET_EXPECT(OnProgress_SENDINGREQUEST);
480 }
481 hres = IInternetProtocolSink_ReportProgress(protocol_sink,
482 BINDSTATUS_SENDINGREQUEST, NULL);
483 ok(hres == S_OK, "ReportProgress failed: %08x\n", hres);
484 if(!no_callback) {
485 ok( WaitForSingleObject(complete_event, 90000) == WAIT_OBJECT_0, "wait timed out\n" );
486 if(bind_to_object)
487 CHECK_CALLED(Obj_OnProgress_SENDINGREQUEST);
488 else
489 CHECK_CALLED(OnProgress_SENDINGREQUEST);
490 }
491
492 if(test_redirect) {
493 if(bind_to_object)
494 SET_EXPECT(Obj_OnProgress_REDIRECTING);
495 else
496 SET_EXPECT(OnProgress_REDIRECTING);
497 hres = IInternetProtocolSink_ReportProgress(protocol_sink, BINDSTATUS_REDIRECTING, winetest_data_urlW);
498 ok(hres == S_OK, "ReportProgress(BINDSTATUS_REFIRECTING) failed: %08x\n", hres);
499 ok( WaitForSingleObject(complete_event, 90000) == WAIT_OBJECT_0, "wait timed out\n" );
500 if(bind_to_object)
501 CHECK_CALLED(Obj_OnProgress_REDIRECTING);
502 else
503 CHECK_CALLED(OnProgress_REDIRECTING);
504 }
505
506 test_switch_fail();
507
508 SET_EXPECT(Continue);
509 prot_state = 1;
510 hres = IInternetProtocolSink_Switch(protocol_sink, &protocoldata);
511 ok(hres == S_OK, "Switch failed: %08x\n", hres);
512 ok( WaitForSingleObject(complete_event, 90000) == WAIT_OBJECT_0, "wait timed out\n" );
513
514 CHECK_CALLED(Continue);
515 CHECK_CALLED(Read);
516 if(bind_to_object) {
517 CHECK_CALLED(Obj_OnProgress_MIMETYPEAVAILABLE);
518 CHECK_CALLED(Obj_OnProgress_BEGINDOWNLOADDATA);
519 CHECK_CALLED(Obj_OnProgress_CLASSIDAVAILABLE);
520 CHECK_CALLED(Obj_OnProgress_BEGINSYNCOPERATION);
521 CHECK_CALLED(CreateInstance);
522 CHECK_CALLED(PutProperty_MIMETYPEPROP);
523 CHECK_CALLED_BROKEN(PutProperty_CLASSIDPROP);
524 CHECK_CALLED(Load);
525 CHECK_CALLED(Obj_OnProgress_ENDSYNCOPERATION);
526 CHECK_CALLED(OnObjectAvailable);
527 CHECK_CALLED(Obj_OnStopBinding);
528 }else if(!no_callback) {
529 CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
530 CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
531 CHECK_CALLED(OnDataAvailable);
532 }else {
533 CHECK_CALLED(LockRequest);
534 }
535
536 SET_EXPECT(Continue);
537 prot_state = 2;
538 hres = IInternetProtocolSink_Switch(protocol_sink, &protocoldata);
539 ok(hres == S_OK, "Switch failed: %08x\n", hres);
540 ok( WaitForSingleObject(complete_event, 90000) == WAIT_OBJECT_0, "wait timed out\n" );
541 CHECK_CALLED(Continue);
542 if(test_abort) {
543 CHECK_CALLED(OnProgress_DOWNLOADINGDATA);
544 CHECK_CALLED(OnStopBinding);
545 SetEvent(complete_event2);
546 return 0;
547 }else {
548 CHECK_CALLED(Read);
549 if(!no_callback) {
550 CHECK_CALLED(OnProgress_DOWNLOADINGDATA);
551 CHECK_CALLED(OnDataAvailable);
552 }
553 }
554
555 SET_EXPECT(Continue);
556 prot_state = 2;
557 hres = IInternetProtocolSink_Switch(protocol_sink, &protocoldata);
558 ok(hres == S_OK, "Switch failed: %08x\n", hres);
559 ok( WaitForSingleObject(complete_event, 90000) == WAIT_OBJECT_0, "wait timed out\n" );
560 CHECK_CALLED(Continue);
561 CHECK_CALLED(Read);
562 if(!no_callback) {
563 CHECK_CALLED(OnProgress_DOWNLOADINGDATA);
564 CHECK_CALLED(OnDataAvailable);
565 }
566
567 SET_EXPECT(Continue);
568 prot_state = 3;
569 hres = IInternetProtocolSink_Switch(protocol_sink, &protocoldata);
570 ok(hres == S_OK, "Switch failed: %08x\n", hres);
571 ok( WaitForSingleObject(complete_event, 90000) == WAIT_OBJECT_0, "wait timed out\n" );
572 CHECK_CALLED(Continue);
573 CHECK_CALLED(Read);
574 if(!no_callback) {
575 CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
576 CHECK_CALLED(OnDataAvailable);
577 CHECK_CALLED(OnStopBinding);
578 }
579
580 SET_EXPECT(Read);
581
582 SetEvent(complete_event2);
583 return 0;
584 }
585
586 static HRESULT WINAPI Protocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
587 IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
588 DWORD grfPI, HANDLE_PTR dwReserved)
589 {
590 BINDINFO bindinfo;
591 DWORD bind_info, bscf = BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION;
592 HRESULT hres;
593
594 static const STGMEDIUM stgmed_zero = {0};
595 static const SECURITY_ATTRIBUTES sa_zero = {0};
596
597 CHECK_EXPECT(Start);
598
599 read = 0;
600
601 reported_url = szUrl;
602 if(!filedwl_api) /* FIXME */
603 ok(szUrl && !lstrcmpW(szUrl, current_url), "wrong url %s\n", wine_dbgstr_w(szUrl));
604 ok(pOIProtSink != NULL, "pOIProtSink == NULL\n");
605 ok(pOIBindInfo != NULL, "pOIBindInfo == NULL\n");
606 ok(grfPI == 0, "grfPI=%d, expected 0\n", grfPI);
607 ok(dwReserved == 0, "dwReserved=%lx, expected 0\n", dwReserved);
608
609 if(!filedwl_api && binding_hres != S_OK) {
610 SET_EXPECT(OnStopBinding);
611 SET_EXPECT(Terminate);
612 hres = IInternetProtocolSink_ReportResult(pOIProtSink, binding_hres, 0, NULL);
613 ok(hres == S_OK, "ReportResult failed: %08x\n", hres);
614 CHECK_CALLED(OnStopBinding);
615 CHECK_CALLED(Terminate);
616
617 return S_OK;
618 }
619
620 memset(&bindinfo, 0, sizeof(bindinfo));
621 bindinfo.cbSize = 0;
622 hres = IInternetBindInfo_GetBindInfo(pOIBindInfo, &bind_info, &bindinfo);
623 ok(hres == E_INVALIDARG, "GetBindInfo returned: %08x, expected E_INVALIDARG\n", hres);
624
625 memset(&bindinfo, 0, sizeof(bindinfo));
626 bindinfo.cbSize = sizeof(bindinfo);
627 hres = IInternetBindInfo_GetBindInfo(pOIBindInfo, &bind_info, &bindinfo);
628 ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
629
630 ok(bind_info & BINDF_FROMURLMON, "BINDF_FROMURLMON is not set\n");
631
632 if(filedwl_api || !is_urlmon_protocol(test_protocol) || tymed != TYMED_ISTREAM ||
633 !(bindf&BINDF_ASYNCSTORAGE) || !(bindf&BINDF_PULLDATA))
634 ok(bind_info & BINDF_NEEDFILE, "BINDF_NEEDFILE is not set\n");
635 else if(test_protocol != MK_TEST) /* IE10 sets BINDF_NEEDFILE for mk: protocol */
636 ok(!(bind_info & BINDF_NEEDFILE), "BINDF_NEEDFILE is set\n");
637
638 bind_info &= ~(BINDF_NEEDFILE|BINDF_FROMURLMON);
639 if(filedwl_api || no_callback)
640 ok(bind_info == BINDF_PULLDATA, "bind_info = %x, expected BINDF_PULLDATA\n", bind_info);
641 else
642 ok(bind_info == (bindf & ~(BINDF_NEEDFILE|BINDF_FROMURLMON)), "bind_info = %x, expected %x\n",
643 bind_info, (bindf & ~(BINDF_NEEDFILE|BINDF_FROMURLMON)));
644
645 ok(bindinfo.cbSize == sizeof(bindinfo), "bindinfo.cbSize = %d\n", bindinfo.cbSize);
646 ok(!bindinfo.szExtraInfo, "bindinfo.szExtraInfo = %p\n", bindinfo.szExtraInfo);
647 ok(!memcmp(&bindinfo.stgmedData, &stgmed_zero, sizeof(STGMEDIUM)), "wrong stgmedData\n");
648 ok(!bindinfo.grfBindInfoF, "bindinfo.grfBindInfoF = %d\n", bindinfo.grfBindInfoF);
649 ok(!bindinfo.dwBindVerb, "bindinfo.dwBindVerb = %d\n", bindinfo.dwBindVerb);
650 ok(!bindinfo.szCustomVerb, "bindinfo.szCustomVerb = %p\n", bindinfo.szCustomVerb);
651 ok(!bindinfo.cbstgmedData, "bindinfo.cbstgmedData = %d\n", bindinfo.cbstgmedData);
652 ok(bindinfo.dwOptions == (bind_to_object ? 0x100000 : 0), "bindinfo.dwOptions = %x\n", bindinfo.dwOptions);
653 ok(!bindinfo.dwOptionsFlags, "bindinfo.dwOptionsFlags = %d\n", bindinfo.dwOptionsFlags);
654 ok(!bindinfo.dwCodePage, "bindinfo.dwCodePage = %d\n", bindinfo.dwCodePage);
655 ok(!memcmp(&bindinfo.securityAttributes, &sa_zero, sizeof(sa_zero)), "wrong bindinfo.securityAttributes\n");
656 ok(IsEqualGUID(&bindinfo.iid, &IID_NULL), "wrong bindinfo.iid\n");
657 ok(!bindinfo.pUnk, "bindinfo.pUnk = %p\n", bindinfo.pUnk);
658 ok(!bindinfo.dwReserved, "bindinfo.dwReserved = %d\n", bindinfo.dwReserved);
659
660 if(only_check_prot_args)
661 return E_FAIL;
662
663 switch(test_protocol) {
664 case MK_TEST:
665 hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
666 BINDSTATUS_DIRECTBIND, NULL);
667 ok(hres == S_OK,
668 "ReportProgress(BINDSTATUS_SENDINGREQUEST) failed: %08x\n", hres);
669
670 case FILE_TEST:
671 case ITS_TEST:
672 if(bind_to_object)
673 SET_EXPECT(Obj_OnProgress_SENDINGREQUEST);
674 else
675 SET_EXPECT(OnProgress_SENDINGREQUEST);
676 hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
677 BINDSTATUS_SENDINGREQUEST, emptyW);
678 ok(hres == S_OK,
679 "ReportProgress(BINDSTATUS_SENDINGREQUEST) failed: %08x\n", hres);
680 if(bind_to_object)
681 CHECK_CALLED(Obj_OnProgress_SENDINGREQUEST);
682 else
683 CHECK_CALLED(OnProgress_SENDINGREQUEST);
684 case WINETEST_SYNC_TEST:
685 IInternetProtocolSink_AddRef(pOIProtSink);
686 protocol_sink = pOIProtSink;
687 default:
688 break;
689 }
690
691 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST) {
692 IServiceProvider *service_provider;
693 IHttpNegotiate *http_negotiate;
694 IHttpNegotiate2 *http_negotiate2;
695 IHttpSecurity *http_security;
696 LPWSTR ua = (LPWSTR)0xdeadbeef, accept_mimes[256];
697 LPWSTR additional_headers = (LPWSTR)0xdeadbeef;
698 BYTE sec_id[100];
699 DWORD fetched = 256, size = 100;
700 DWORD tid;
701
702 static const WCHAR wszMimes[] = {'*','/','*',0};
703
704 SET_EXPECT(QueryService_IInternetBindInfo);
705 hres = IInternetBindInfo_GetBindString(pOIBindInfo, BINDSTRING_USER_AGENT,
706 &ua, 1, &fetched);
707 CLEAR_CALLED(QueryService_IInternetBindInfo); /* IE <8 */
708
709 ok(hres == E_NOINTERFACE,
710 "GetBindString(BINDSTRING_USER_AGETNT) failed: %08x\n", hres);
711 ok(fetched == 256, "fetched = %d, expected 254\n", fetched);
712 ok(ua == (LPWSTR)0xdeadbeef, "ua = %p\n", ua);
713
714 hres = IInternetBindInfo_GetBindString(pOIBindInfo, BINDSTRING_ACCEPT_MIMES,
715 accept_mimes, 256, &fetched);
716 ok(hres == S_OK,
717 "GetBindString(BINDSTRING_ACCEPT_MIMES) failed: %08x\n", hres);
718 ok(fetched == 1, "fetched = %d, expected 1\n", fetched);
719 ok(!lstrcmpW(wszMimes, accept_mimes[0]), "unexpected mimes\n");
720 CoTaskMemFree(accept_mimes[0]);
721
722 hres = IInternetBindInfo_GetBindString(pOIBindInfo, BINDSTRING_ACCEPT_MIMES,
723 NULL, 256, &fetched);
724 ok(hres == E_INVALIDARG,
725 "GetBindString(BINDSTRING_ACCEPT_MIMES) failed: %08x\n", hres);
726
727 hres = IInternetBindInfo_GetBindString(pOIBindInfo, BINDSTRING_ACCEPT_MIMES,
728 accept_mimes, 256, NULL);
729 ok(hres == E_INVALIDARG,
730 "GetBindString(BINDSTRING_ACCEPT_MIMES) failed: %08x\n", hres);
731
732 hres = IInternetBindInfo_QueryInterface(pOIBindInfo, &IID_IServiceProvider,
733 (void**)&service_provider);
734 ok(hres == S_OK, "QueryInterface failed: %08x\n", hres);
735
736 SET_EXPECT(QueryInterface_IHttpNegotiate);
737 hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate,
738 &IID_IHttpNegotiate, (void**)&http_negotiate);
739 CLEAR_CALLED(QueryInterface_IHttpNegotiate); /* IE <8 */
740 ok(hres == S_OK, "QueryService failed: %08x\n", hres);
741
742 if(!no_callback) {
743 SET_EXPECT(BeginningTransaction);
744 SET_EXPECT(QueryInterface_IHttpNegotiate);
745 }
746 hres = IHttpNegotiate_BeginningTransaction(http_negotiate, current_url,
747 NULL, 0, &additional_headers);
748 if(!no_callback) {
749 CHECK_CALLED_BROKEN(QueryInterface_IHttpNegotiate);
750 CHECK_CALLED(BeginningTransaction);
751 }
752 IHttpNegotiate_Release(http_negotiate);
753 ok(hres == S_OK, "BeginningTransction failed: %08x\n", hres);
754 ok(additional_headers == NULL, "additional_headers=%p\n", additional_headers);
755
756 SET_EXPECT(QueryInterface_IHttpNegotiate2);
757 hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate2,
758 &IID_IHttpNegotiate2, (void**)&http_negotiate2);
759 CLEAR_CALLED(QueryInterface_IHttpNegotiate2); /* IE <8 */
760 ok(hres == S_OK, "QueryService failed: %08x\n", hres);
761
762 size = 512;
763 if(!no_callback) {
764 SET_EXPECT(QueryInterface_IHttpNegotiate2);
765 SET_EXPECT(GetRootSecurityId);
766 }
767 hres = IHttpNegotiate2_GetRootSecurityId(http_negotiate2, sec_id, &size, 0);
768 if(!no_callback) {
769 CHECK_CALLED_BROKEN(QueryInterface_IHttpNegotiate2);
770 CHECK_CALLED(GetRootSecurityId);
771 }
772 IHttpNegotiate2_Release(http_negotiate2);
773 ok(hres == E_FAIL, "GetRootSecurityId failed: %08x, expected E_FAIL\n", hres);
774 ok(size == (no_callback ? 512 : 13), "size=%d\n", size);
775
776 if(!no_callback) {
777 SET_EXPECT(QueryService_IHttpSecurity);
778 SET_EXPECT(QueryInterface_IHttpSecurity);
779 }
780 hres = IServiceProvider_QueryService(service_provider, &IID_IHttpSecurity,
781 &IID_IHttpSecurity, (void**)&http_security);
782 ok(hres == (no_callback ? E_NOINTERFACE : S_OK), "QueryService failed: 0x%08x\n", hres);
783 if(!no_callback) {
784 CHECK_CALLED(QueryService_IHttpSecurity);
785 CHECK_CALLED(QueryInterface_IHttpSecurity);
786 }
787
788 IServiceProvider_Release(service_provider);
789
790 IInternetProtocolSink_AddRef(pOIProtSink);
791 protocol_sink = pOIProtSink;
792
793 if(async_switch) {
794 PROTOCOLDATA data;
795
796 memset(&data, 0, sizeof(data));
797 data.grfFlags = PI_FORCE_ASYNC;
798 prot_state = 0;
799 hres = IInternetProtocolSink_Switch(pOIProtSink, &data);
800 ok(hres == S_OK, "Switch failed: %08x\n", hres);
801 SET_EXPECT(Continue);
802 SetEvent(complete_event2);
803 return E_PENDING;
804 } else {
805 CreateThread(NULL, 0, thread_proc, NULL, 0, &tid);
806 return S_OK;
807 }
808 }
809
810 if(test_protocol == FILE_TEST) {
811 hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
812 BINDSTATUS_CACHEFILENAMEAVAILABLE, file_url+7);
813 ok(hres == S_OK,
814 "ReportProgress(BINDSTATUS_CACHEFILENAMEAVAILABLE) failed: %08x\n", hres);
815
816 if(bind_to_object)
817 SET_EXPECT(Obj_OnProgress_MIMETYPEAVAILABLE);
818 else
819 SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
820 hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
821 BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE, wszTextHtml);
822 ok(hres == S_OK,
823 "ReportProgress(BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE) failed: %08x\n", hres);
824 if(bind_to_object)
825 CHECK_CALLED(Obj_OnProgress_MIMETYPEAVAILABLE);
826 else
827 CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
828 }else if(test_protocol == WINETEST_SYNC_TEST) {
829 SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
830 hres = IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE, wszTextHtml);
831 ok(hres == S_OK,
832 "ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE) failed: %08x\n", hres);
833 CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
834 }else {
835 hres = IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_MIMETYPEAVAILABLE, wszTextHtml);
836 ok(hres == S_OK,
837 "ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE) failed: %08x\n", hres);
838 }
839
840 if(test_protocol == ABOUT_TEST)
841 bscf |= BSCF_DATAFULLYAVAILABLE;
842 if(test_protocol == ITS_TEST)
843 bscf = BSCF_FIRSTDATANOTIFICATION|BSCF_DATAFULLYAVAILABLE;
844
845 SET_EXPECT(Read);
846 if(bind_to_object) {
847 if(test_protocol != FILE_TEST && test_protocol != MK_TEST && test_protocol != WINETEST_SYNC_TEST)
848 SET_EXPECT(Obj_OnProgress_MIMETYPEAVAILABLE);
849 SET_EXPECT(Obj_OnProgress_BEGINDOWNLOADDATA);
850 if(test_protocol == FILE_TEST)
851 SET_EXPECT(Obj_OnProgress_CACHEFILENAMEAVAILABLE);
852 SET_EXPECT(Obj_OnProgress_ENDDOWNLOADDATA);
853 SET_EXPECT(Obj_OnProgress_CLASSIDAVAILABLE);
854 SET_EXPECT(Obj_OnProgress_BEGINSYNCOPERATION);
855 SET_EXPECT(CreateInstance);
856 SET_EXPECT(PutProperty_MIMETYPEPROP);
857 SET_EXPECT(PutProperty_CLASSIDPROP);
858 SET_EXPECT(Load);
859 SET_EXPECT(Obj_OnProgress_ENDSYNCOPERATION);
860 SET_EXPECT(OnObjectAvailable);
861 SET_EXPECT(Obj_OnStopBinding);
862 }else {
863 if(test_protocol != FILE_TEST && test_protocol != MK_TEST)
864 SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
865 SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
866 if(test_protocol == FILE_TEST)
867 SET_EXPECT(OnProgress_CACHEFILENAMEAVAILABLE);
868 SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
869 SET_EXPECT(LockRequest);
870 if(!filedwl_api)
871 SET_EXPECT(OnDataAvailable);
872 if(test_protocol != WINETEST_SYNC_TEST) /* Set in Read after ReportResult call */
873 SET_EXPECT(OnStopBinding);
874 }
875
876 hres = IInternetProtocolSink_ReportData(pOIProtSink, bscf, 13, 13);
877 ok(hres == S_OK, "ReportData failed: %08x\n", hres);
878
879 CHECK_CALLED(Read);
880 if(bind_to_object) {
881 if(test_protocol != FILE_TEST && test_protocol != MK_TEST)
882 CHECK_CALLED(Obj_OnProgress_MIMETYPEAVAILABLE);
883 CHECK_CALLED(Obj_OnProgress_BEGINDOWNLOADDATA);
884 if(test_protocol == FILE_TEST)
885 CHECK_CALLED(Obj_OnProgress_CACHEFILENAMEAVAILABLE);
886 CHECK_CALLED(Obj_OnProgress_ENDDOWNLOADDATA);
887 CHECK_CALLED(Obj_OnProgress_CLASSIDAVAILABLE);
888 CHECK_CALLED(Obj_OnProgress_BEGINSYNCOPERATION);
889 CHECK_CALLED(CreateInstance);
890 CHECK_CALLED(PutProperty_MIMETYPEPROP);
891 CHECK_CALLED_BROKEN(PutProperty_CLASSIDPROP);
892 CHECK_CALLED(Load);
893 CHECK_CALLED(Obj_OnProgress_ENDSYNCOPERATION);
894 CHECK_CALLED(OnObjectAvailable);
895 CHECK_CALLED(Obj_OnStopBinding);
896 }else {
897 if(test_protocol != FILE_TEST && test_protocol != MK_TEST && test_protocol != WINETEST_SYNC_TEST)
898 CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
899 CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
900 if(test_protocol == FILE_TEST)
901 CHECK_CALLED(OnProgress_CACHEFILENAMEAVAILABLE);
902 CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
903 CHECK_CALLED(LockRequest);
904 if(!filedwl_api)
905 CHECK_CALLED(OnDataAvailable);
906 CHECK_CALLED(OnStopBinding);
907 }
908
909 if(test_protocol == ITS_TEST) {
910 SET_EXPECT(Read);
911 hres = IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_BEGINDOWNLOADDATA, NULL);
912 ok(hres == S_OK, "ReportProgress(BINDSTATUS_BEGINDOWNLOADDATA) failed: %08x\n", hres);
913 CHECK_CALLED(Read);
914 }else if(!bind_to_object && test_protocol == FILE_TEST) {
915 SET_EXPECT(Read);
916 hres = IInternetProtocolSink_ReportData(pOIProtSink, bscf, 13, 13);
917 ok(hres == S_OK, "ReportData failed: %08x\n", hres);
918 CHECK_CALLED(Read);
919 }
920
921 if(test_protocol != WINETEST_SYNC_TEST) {
922 SET_EXPECT(Terminate);
923 hres = IInternetProtocolSink_ReportResult(pOIProtSink, S_OK, 0, NULL);
924 ok(hres == S_OK, "ReportResult failed: %08x\n", hres);
925 CHECK_CALLED(Terminate);
926 }
927
928 return S_OK;
929 }
930
931 static HRESULT WINAPI Protocol_Continue(IInternetProtocol *iface,
932 PROTOCOLDATA *pProtocolData)
933 {
934 DWORD bscf = 0;
935 HRESULT hres;
936
937 CHECK_EXPECT(Continue);
938
939 ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
940
941 if(!bind_to_object)
942 ok(reported_url && !lstrcmpW(reported_url, current_url), "wrong url %s\n", wine_dbgstr_w(reported_url));
943
944 ok(pProtocolData != NULL, "pProtocolData == NULL\n");
945 if(!pProtocolData)
946 return S_OK;
947
948 switch(prot_state) {
949 case 0:
950 hres = IInternetProtocolSink_ReportProgress(protocol_sink,
951 BINDSTATUS_SENDINGREQUEST, NULL);
952 ok(hres == S_OK, "ReportProgress failed: %08x\n", hres);
953
954 hres = IInternetProtocolSink_ReportProgress(protocol_sink,
955 BINDSTATUS_MIMETYPEAVAILABLE, wszTextHtml);
956 ok(hres == S_OK,
957 "ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE) failed: %08x\n", hres);
958
959 bscf |= BSCF_FIRSTDATANOTIFICATION|BSCF_INTERMEDIATEDATANOTIFICATION;
960 break;
961 case 1: {
962 IServiceProvider *service_provider;
963 IHttpNegotiate *http_negotiate;
964 static const WCHAR header[] = {'?',0};
965
966 hres = IInternetProtocolSink_QueryInterface(protocol_sink, &IID_IServiceProvider,
967 (void**)&service_provider);
968 ok(hres == S_OK, "Could not get IServiceProvicder\n");
969
970 hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate,
971 &IID_IHttpNegotiate, (void**)&http_negotiate);
972 ok(hres == S_OK, "Could not get IHttpNegotiate\n");
973
974 if(!no_callback) {
975 SET_EXPECT(QueryInterface_IHttpNegotiate);
976 SET_EXPECT(OnResponse);
977 }
978 hres = IHttpNegotiate_OnResponse(http_negotiate, 200, header, NULL, NULL);
979 if(!no_callback) {
980 CHECK_CALLED_BROKEN(QueryInterface_IHttpNegotiate);
981 CHECK_CALLED(OnResponse);
982 }
983 IHttpNegotiate_Release(http_negotiate);
984 ok(hres == S_OK, "OnResponse failed: %08x\n", hres);
985
986 if(test_protocol == HTTPS_TEST || test_redirect) {
987 hres = IInternetProtocolSink_ReportProgress(protocol_sink, BINDSTATUS_ACCEPTRANGES, NULL);
988 ok(hres == S_OK, "ReportProgress(BINDSTATUS_ACCEPTRANGES) failed: %08x\n", hres);
989 }
990
991 hres = IInternetProtocolSink_ReportProgress(protocol_sink,
992 BINDSTATUS_MIMETYPEAVAILABLE, wszTextHtml);
993 ok(hres == S_OK,
994 "ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE) failed: %08x\n", hres);
995
996 hres = IInternetProtocolSink_ReportProgress(protocol_sink,
997 BINDSTATUS_CACHEFILENAMEAVAILABLE, use_cache_file ? cache_file_name : cache_fileW);
998 ok(hres == S_OK, "ReportProgress(BINDSTATUS_CACHEFILENAMEAVAILABLE) failed: %08x\n", hres);
999
1000 bscf |= BSCF_FIRSTDATANOTIFICATION;
1001 break;
1002 }
1003 case 2:
1004 case 3:
1005 bscf = BSCF_INTERMEDIATEDATANOTIFICATION;
1006 break;
1007 }
1008
1009 hres = IInternetProtocolSink_ReportData(protocol_sink, bscf, 100, 400);
1010 ok(hres == S_OK, "ReportData failed: %08x\n", hres);
1011
1012 if(prot_state != 2 || !test_abort)
1013 SET_EXPECT(Read);
1014 switch(prot_state) {
1015 case 0:
1016 hres = IInternetProtocolSink_ReportResult(protocol_sink, S_OK, 0, NULL);
1017 ok(hres == S_OK, "ReportResult failed: %08x\n", hres);
1018 SET_EXPECT(OnProgress_SENDINGREQUEST);
1019 SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
1020 SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
1021 SET_EXPECT(LockRequest);
1022 SET_EXPECT(OnStopBinding);
1023 break;
1024 case 1:
1025 if(bind_to_object) {
1026 SET_EXPECT(Obj_OnProgress_MIMETYPEAVAILABLE);
1027 SET_EXPECT(Obj_OnProgress_BEGINDOWNLOADDATA);
1028 SET_EXPECT(Obj_OnProgress_CLASSIDAVAILABLE);
1029 SET_EXPECT(Obj_OnProgress_BEGINSYNCOPERATION);
1030 SET_EXPECT(CreateInstance);
1031 SET_EXPECT(PutProperty_MIMETYPEPROP);
1032 SET_EXPECT(PutProperty_CLASSIDPROP);
1033 SET_EXPECT(Load);
1034 SET_EXPECT(Obj_OnProgress_ENDSYNCOPERATION);
1035 SET_EXPECT(OnObjectAvailable);
1036 SET_EXPECT(Obj_OnStopBinding);
1037 }else if(!no_callback) {
1038 SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
1039 SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
1040 SET_EXPECT(LockRequest);
1041 }else {
1042 SET_EXPECT(LockRequest);
1043 }
1044 break;
1045 case 2:
1046 if(!no_callback)
1047 SET_EXPECT(OnProgress_DOWNLOADINGDATA);
1048 break;
1049 case 3:
1050 SET_EXPECT(OnProgress_DOWNLOADINGDATA);
1051 SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
1052 }
1053 if(!no_callback) {
1054 if((!bind_to_object || prot_state >= 2) && (!test_abort || prot_state != 2))
1055 SET_EXPECT(OnDataAvailable);
1056 if(prot_state == 3 || (test_abort && prot_state == 2))
1057 SET_EXPECT(OnStopBinding);
1058 }
1059 return S_OK;
1060 }
1061
1062 static HRESULT WINAPI Protocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
1063 DWORD dwOptions)
1064 {
1065 HRESULT hres;
1066
1067 CHECK_EXPECT(Abort);
1068
1069 ok(hrReason == E_ABORT, "hrReason = %08x\n", hrReason);
1070 ok(!dwOptions, "dwOptions = %x\n", dwOptions);
1071
1072 hres = IInternetProtocolSink_ReportResult(protocol_sink, E_ABORT, ERROR_SUCCESS, NULL);
1073 ok(hres == S_OK, "ReportResult failed: %08x\n", hres);
1074
1075 return S_OK;
1076 }
1077
1078 static HRESULT WINAPI Protocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
1079 {
1080 CHECK_EXPECT(Terminate);
1081
1082 ok(dwOptions == 0, "dwOptions=%d, expected 0\n", dwOptions);
1083
1084 if(protocol_sink) {
1085 IInternetProtocolSink_Release(protocol_sink);
1086 protocol_sink = NULL;
1087 }
1088
1089 if(no_callback)
1090 SetEvent(complete_event);
1091 return S_OK;
1092 }
1093
1094 static HRESULT WINAPI Protocol_Suspend(IInternetProtocol *iface)
1095 {
1096 ok(0, "unexpected call\n");
1097 return E_NOTIMPL;
1098 }
1099
1100 static HRESULT WINAPI Protocol_Resume(IInternetProtocol *iface)
1101 {
1102 ok(0, "unexpected call\n");
1103 return E_NOTIMPL;
1104 }
1105
1106 static HRESULT WINAPI Protocol_Read(IInternetProtocol *iface, void *pv,
1107 ULONG cb, ULONG *pcbRead)
1108 {
1109 HRESULT hres;
1110
1111 static const char data[] = "<HTML></HTML>";
1112
1113 CHECK_EXPECT2(Read);
1114
1115 ok(pv != NULL, "pv == NULL\n");
1116 ok(cb != 0, "cb == 0\n");
1117 ok(pcbRead != NULL, "pcbRead == NULL\n");
1118
1119 if(async_switch) {
1120 if(prot_state++ > 1) {
1121 *pcbRead = 0;
1122 return S_FALSE;
1123 } else {
1124 memset(pv, '?', cb);
1125 *pcbRead = cb;
1126 return S_OK;
1127 }
1128 }
1129
1130 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST) {
1131 static BOOL pending = TRUE;
1132
1133 pending = !pending;
1134
1135 switch(prot_state) {
1136 case 1:
1137 case 2:
1138 if(pending) {
1139 *pcbRead = 10;
1140 memset(pv, '?', 10);
1141 if(prot_state == 2 && no_callback)
1142 SetEvent(complete_event);
1143 return E_PENDING;
1144 }else {
1145 memset(pv, '?', cb);
1146 *pcbRead = cb;
1147 read++;
1148 return S_OK;
1149 }
1150 case 3:
1151 prot_state++;
1152
1153 *pcbRead = 0;
1154
1155 hres = IInternetProtocolSink_ReportData(protocol_sink,
1156 BSCF_LASTDATANOTIFICATION|BSCF_INTERMEDIATEDATANOTIFICATION, 2000, 2000);
1157 ok(hres == S_OK, "ReportData failed: %08x\n", hres);
1158
1159 hres = IInternetProtocolSink_ReportResult(protocol_sink, S_OK, 0, NULL);
1160 ok(hres == S_OK, "ReportResult failed: %08x\n", hres);
1161
1162 return S_FALSE;
1163 case 4:
1164 *pcbRead = 0;
1165 return S_FALSE;
1166 }
1167 }
1168
1169 if(read) {
1170 *pcbRead = 0;
1171 return S_FALSE;
1172 }
1173
1174 if(test_protocol == WINETEST_SYNC_TEST) {
1175 hres = IInternetProtocolSink_ReportResult(protocol_sink, S_OK, 0, NULL);
1176 ok(hres == S_OK, "ReportResult failed: %08x\n", hres);
1177
1178 SET_EXPECT(OnStopBinding);
1179 }
1180
1181 ok(*pcbRead == 0, "*pcbRead=%d, expected 0\n", *pcbRead);
1182 read += *pcbRead = sizeof(data)-1;
1183 memcpy(pv, data, sizeof(data));
1184 return S_OK;
1185 }
1186
1187 static HRESULT WINAPI Protocol_Seek(IInternetProtocol *iface,
1188 LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
1189 {
1190 ok(0, "unexpected call\n");
1191 return E_NOTIMPL;
1192 }
1193
1194 static HRESULT WINAPI Protocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
1195 {
1196 CHECK_EXPECT(LockRequest);
1197 if(no_callback)
1198 SetEvent(complete_event);
1199 return S_OK;
1200 }
1201
1202 static HRESULT WINAPI Protocol_UnlockRequest(IInternetProtocol *iface)
1203 {
1204 CHECK_EXPECT(UnlockRequest);
1205 return S_OK;
1206 }
1207
1208 static const IInternetProtocolVtbl ProtocolVtbl = {
1209 Protocol_QueryInterface,
1210 Protocol_AddRef,
1211 Protocol_Release,
1212 Protocol_Start,
1213 Protocol_Continue,
1214 Protocol_Abort,
1215 Protocol_Terminate,
1216 Protocol_Suspend,
1217 Protocol_Resume,
1218 Protocol_Read,
1219 Protocol_Seek,
1220 Protocol_LockRequest,
1221 Protocol_UnlockRequest
1222 };
1223
1224 static IInternetProtocol Protocol = { &ProtocolVtbl };
1225
1226 static HRESULT WINAPI HttpNegotiate_QueryInterface(IHttpNegotiate2 *iface, REFIID riid, void **ppv)
1227 {
1228 if(IsEqualGUID(&IID_IUnknown, riid)
1229 || IsEqualGUID(&IID_IHttpNegotiate, riid)
1230 || IsEqualGUID(&IID_IHttpNegotiate2, riid)) {
1231 *ppv = iface;
1232 return S_OK;
1233 }
1234
1235 ok(0, "unexpected call\n");
1236 return E_NOINTERFACE;
1237 }
1238
1239 static ULONG WINAPI HttpNegotiate_AddRef(IHttpNegotiate2 *iface)
1240 {
1241 return 2;
1242 }
1243
1244 static ULONG WINAPI HttpNegotiate_Release(IHttpNegotiate2 *iface)
1245 {
1246 return 1;
1247 }
1248
1249 static HRESULT WINAPI HttpNegotiate_BeginningTransaction(IHttpNegotiate2 *iface, LPCWSTR szURL,
1250 LPCWSTR szHeaders, DWORD dwReserved, LPWSTR *pszAdditionalHeaders)
1251 {
1252 if(onsecurityproblem_hres == S_OK)
1253 CHECK_EXPECT2(BeginningTransaction);
1254 else
1255 CHECK_EXPECT(BeginningTransaction);
1256
1257 ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1258
1259 ok(!lstrcmpW(szURL, current_url), "szURL != current_url\n");
1260 ok(!dwReserved, "dwReserved=%d, expected 0\n", dwReserved);
1261 ok(pszAdditionalHeaders != NULL, "pszAdditionalHeaders == NULL\n");
1262 if(pszAdditionalHeaders)
1263 ok(*pszAdditionalHeaders == NULL, "*pszAdditionalHeaders != NULL\n");
1264
1265 return S_OK;
1266 }
1267
1268 static HRESULT WINAPI HttpNegotiate_OnResponse(IHttpNegotiate2 *iface, DWORD dwResponseCode,
1269 LPCWSTR szResponseHeaders, LPCWSTR szRequestHeaders, LPWSTR *pszAdditionalRequestHeaders)
1270 {
1271 CHECK_EXPECT(OnResponse);
1272
1273 ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1274
1275 ok(dwResponseCode == 200, "dwResponseCode=%d, expected 200\n", dwResponseCode);
1276 ok(szResponseHeaders != NULL, "szResponseHeaders == NULL\n");
1277 ok(szRequestHeaders == NULL, "szRequestHeaders != NULL\n");
1278 /* Note: in protocol.c tests, OnResponse pszAdditionalRequestHeaders _is_ NULL */
1279 ok(pszAdditionalRequestHeaders != NULL, "pszAdditionalHeaders == NULL\n");
1280 if(pszAdditionalRequestHeaders)
1281 ok(*pszAdditionalRequestHeaders == NULL, "*pszAdditionalHeaders != NULL\n");
1282
1283 return S_OK;
1284 }
1285
1286 static HRESULT WINAPI HttpNegotiate_GetRootSecurityId(IHttpNegotiate2 *iface,
1287 BYTE *pbSecurityId, DWORD *pcbSecurityId, DWORD_PTR dwReserved)
1288 {
1289 static const BYTE sec_id[] = {'h','t','t','p',':','t','e','s','t',1,0,0,0};
1290
1291 CHECK_EXPECT(GetRootSecurityId);
1292
1293 ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1294
1295 ok(!dwReserved, "dwReserved=%ld, expected 0\n", dwReserved);
1296 ok(pbSecurityId != NULL, "pbSecurityId == NULL\n");
1297 ok(pcbSecurityId != NULL, "pcbSecurityId == NULL\n");
1298
1299 if(pbSecurityId == (void*)0xdeadbeef)
1300 return E_NOTIMPL;
1301
1302 if(pcbSecurityId) {
1303 ok(*pcbSecurityId == 512, "*pcbSecurityId=%d, expected 512\n", *pcbSecurityId);
1304 *pcbSecurityId = sizeof(sec_id);
1305 }
1306
1307 if(pbSecurityId)
1308 memcpy(pbSecurityId, sec_id, sizeof(sec_id));
1309
1310 return E_FAIL;
1311 }
1312
1313 static IHttpNegotiate2Vtbl HttpNegotiateVtbl = {
1314 HttpNegotiate_QueryInterface,
1315 HttpNegotiate_AddRef,
1316 HttpNegotiate_Release,
1317 HttpNegotiate_BeginningTransaction,
1318 HttpNegotiate_OnResponse,
1319 HttpNegotiate_GetRootSecurityId
1320 };
1321
1322 static IHttpNegotiate2 HttpNegotiate = { &HttpNegotiateVtbl };
1323
1324 static HRESULT WINAPI HttpSecurity_QueryInterface(IHttpSecurity *iface, REFIID riid, void **ppv)
1325 {
1326 ok(0, "Unexpected call\n");
1327 *ppv = NULL;
1328 if(IsEqualGUID(&IID_IHttpSecurity, riid) ||
1329 IsEqualGUID(&IID_IWindowForBindingUI, riid) ||
1330 IsEqualGUID(&IID_IUnknown, riid))
1331 {
1332 *ppv = iface;
1333 return S_OK;
1334 }
1335
1336 ok(0, "Unexpected interface requested.\n");
1337
1338 return E_NOINTERFACE;
1339 }
1340
1341 static ULONG WINAPI HttpSecurity_AddRef(IHttpSecurity *iface)
1342 {
1343 return 2;
1344 }
1345
1346 static ULONG WINAPI HttpSecurity_Release(IHttpSecurity *iface)
1347 {
1348 return 1;
1349 }
1350
1351 static HRESULT WINAPI HttpSecurity_GetWindow(IHttpSecurity *iface, REFGUID rguidReason, HWND *phwnd)
1352 {
1353 if(IsEqualGUID(rguidReason, &IID_IHttpSecurity))
1354 CHECK_EXPECT(GetWindow_IHttpSecurity);
1355 else if(IsEqualGUID(rguidReason, &IID_IWindowForBindingUI))
1356 CHECK_EXPECT2(GetWindow_IWindowForBindingUI);
1357 else if(IsEqualGUID(rguidReason, &IID_ICodeInstall))
1358 CHECK_EXPECT(GetWindow_ICodeInstall);
1359 else
1360 ok(0, "Unexpected rguidReason: %s\n", wine_dbgstr_guid(rguidReason));
1361
1362 *phwnd = NULL;
1363 return S_OK;
1364 }
1365
1366 static HRESULT WINAPI HttpSecurity_OnSecurityProblem(IHttpSecurity *iface, DWORD dwProblem)
1367 {
1368 CHECK_EXPECT(OnSecurityProblem);
1369 if(!security_problem) {
1370 ok(dwProblem == ERROR_INTERNET_SEC_CERT_CN_INVALID ||
1371 broken(dwProblem == ERROR_INTERNET_SEC_CERT_ERRORS) /* Some versions of IE6 */,
1372 "Got problem: %d\n", dwProblem);
1373 security_problem = dwProblem;
1374
1375 if(dwProblem == ERROR_INTERNET_SEC_CERT_ERRORS)
1376 binding_hres = INET_E_SECURITY_PROBLEM;
1377 }else
1378 ok(dwProblem == security_problem, "Got problem: %d\n", dwProblem);
1379
1380 return onsecurityproblem_hres;
1381 }
1382
1383 static const IHttpSecurityVtbl HttpSecurityVtbl = {
1384 HttpSecurity_QueryInterface,
1385 HttpSecurity_AddRef,
1386 HttpSecurity_Release,
1387 HttpSecurity_GetWindow,
1388 HttpSecurity_OnSecurityProblem
1389 };
1390
1391 static IHttpSecurity HttpSecurity = { &HttpSecurityVtbl };
1392
1393 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppv)
1394 {
1395 ok(0, "unexpected call\n");
1396 return E_NOINTERFACE;
1397 }
1398
1399 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
1400 {
1401 return 2;
1402 }
1403
1404 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
1405 {
1406 return 1;
1407 }
1408
1409 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface,
1410 REFGUID guidService, REFIID riid, void **ppv)
1411 {
1412 if(IsEqualGUID(&IID_IAuthenticate, guidService)) {
1413 CHECK_EXPECT(QueryService_IAuthenticate);
1414 return E_NOTIMPL;
1415 }
1416
1417 if(IsEqualGUID(&IID_IInternetProtocol, guidService)) {
1418 CHECK_EXPECT2(QueryService_IInternetProtocol);
1419 return E_NOTIMPL;
1420 }
1421
1422 if(IsEqualGUID(&IID_IInternetBindInfo, guidService)) {
1423 CHECK_EXPECT(QueryService_IInternetBindInfo);
1424 return E_NOTIMPL;
1425 }
1426
1427 if(IsEqualGUID(&IID_IWindowForBindingUI, guidService)) {
1428 CHECK_EXPECT2(QueryService_IWindowForBindingUI);
1429 *ppv = &HttpSecurity;
1430 return S_OK;
1431 }
1432
1433 if(IsEqualGUID(&IID_IHttpSecurity, guidService)) {
1434 CHECK_EXPECT(QueryService_IHttpSecurity);
1435 *ppv = &HttpSecurity;
1436 return S_OK;
1437 }
1438
1439 if(IsEqualGUID(&IID_IGetBindHandle, guidService)) {
1440 trace("QueryService(IID_IGetBindHandle)\n");
1441 *ppv = NULL;
1442 return E_NOINTERFACE;
1443 }
1444
1445 if(IsEqualGUID(&IID_undocumentedIE11, guidService)) {
1446 trace("QueryService(IID_undocumentedIE11)\n");
1447 *ppv = NULL;
1448 return E_NOINTERFACE;
1449 }
1450
1451 ok(0, "unexpected service %s\n", wine_dbgstr_guid(guidService));
1452 return E_NOINTERFACE;
1453 }
1454
1455 static IServiceProviderVtbl ServiceProviderVtbl = {
1456 ServiceProvider_QueryInterface,
1457 ServiceProvider_AddRef,
1458 ServiceProvider_Release,
1459 ServiceProvider_QueryService
1460 };
1461
1462 static IServiceProvider ServiceProvider = { &ServiceProviderVtbl };
1463
1464 static IBindStatusCallbackEx objbsc;
1465
1466 static void test_WinInetHttpInfo(IWinInetHttpInfo *http_info, DWORD progress)
1467 {
1468 DWORD status, size;
1469 HRESULT hres, expect;
1470
1471 /* QueryInfo changes its behavior during this request */
1472 if(progress == BINDSTATUS_SENDINGREQUEST)
1473 return;
1474
1475 if(test_protocol==FTP_TEST && download_state==BEFORE_DOWNLOAD
1476 && progress!=BINDSTATUS_MIMETYPEAVAILABLE)
1477 expect = E_FAIL;
1478 else if(test_protocol == FTP_TEST)
1479 expect = S_FALSE;
1480 else
1481 expect = S_OK;
1482
1483 size = sizeof(DWORD);
1484 hres = IWinInetHttpInfo_QueryInfo(http_info, HTTP_QUERY_STATUS_CODE|HTTP_QUERY_FLAG_NUMBER,
1485 &status, &size, NULL, NULL);
1486 ok(hres == expect || ((progress == BINDSTATUS_COOKIE_SENT || progress == BINDSTATUS_PROXYDETECTING) && hres == S_FALSE),
1487 "progress %u: hres = %x, expected %x\n", progress, hres, expect);
1488 if(hres == S_OK) {
1489 if(download_state == BEFORE_DOWNLOAD && progress != BINDSTATUS_MIMETYPEAVAILABLE && progress != BINDSTATUS_DECODING)
1490 ok(status == 0, "progress %u: status = %d\n", progress, status);
1491 else
1492 ok(status == HTTP_STATUS_OK, "progress %u: status = %d\n", progress, status);
1493 ok(size == sizeof(DWORD), "size = %d\n", size);
1494 }
1495
1496 size = sizeof(DWORD);
1497 hres = IWinInetHttpInfo_QueryOption(http_info, INTERNET_OPTION_HANDLE_TYPE, &status, &size);
1498 if(test_protocol == FTP_TEST) {
1499 if(download_state==BEFORE_DOWNLOAD && progress!=BINDSTATUS_MIMETYPEAVAILABLE)
1500 ok(hres == E_FAIL, "hres = %x\n", hres);
1501 else
1502 ok(hres == S_OK, "hres = %x\n", hres);
1503
1504 if(hres == S_OK)
1505 ok(status == INTERNET_HANDLE_TYPE_FTP_FILE, "status = %d\n", status);
1506 } else {
1507 ok(hres == S_OK, "hres = %x\n", hres);
1508 ok(status == INTERNET_HANDLE_TYPE_HTTP_REQUEST, "status = %d\n", status);
1509 }
1510 }
1511
1512 static HRESULT WINAPI statusclb_QueryInterface(IBindStatusCallbackEx *iface, REFIID riid, void **ppv)
1513 {
1514 static const IID IID_undocumentedIE10 = {0xf286fa56,0xc1fd,0x4270,{0x8e,0x67,0xb3,0xeb,0x79,0x0a,0x81,0xe8}};
1515
1516 ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1517
1518 if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
1519 CHECK_EXPECT2(QueryInterface_IInternetProtocol);
1520 if(emulate_protocol) {
1521 *ppv = &Protocol;
1522 return S_OK;
1523 }else {
1524 return E_NOINTERFACE;
1525 }
1526 }else if (IsEqualGUID(&IID_IServiceProvider, riid)) {
1527 CHECK_EXPECT2(QueryInterface_IServiceProvider);
1528 *ppv = &ServiceProvider;
1529 return S_OK;
1530 }else if (IsEqualGUID(&IID_IHttpNegotiate, riid)) {
1531 CHECK_EXPECT2(QueryInterface_IHttpNegotiate);
1532 *ppv = &HttpNegotiate;
1533 return S_OK;
1534 }else if (IsEqualGUID(&IID_IHttpNegotiate2, riid)) {
1535 CHECK_EXPECT(QueryInterface_IHttpNegotiate2);
1536 *ppv = &HttpNegotiate;
1537 return S_OK;
1538 }else if (IsEqualGUID(&IID_IAuthenticate, riid)) {
1539 CHECK_EXPECT(QueryInterface_IAuthenticate);
1540 return E_NOINTERFACE;
1541 }else if(IsEqualGUID(&IID_IBindStatusCallback, riid)) {
1542 if(strict_bsc_qi)
1543 CHECK_EXPECT2(QueryInterface_IBindStatusCallback);
1544 *ppv = iface;
1545 return S_OK;
1546 }else if(IsEqualGUID(&IID_IBindStatusCallbackHolder, riid)) {
1547 CHECK_EXPECT2(QueryInterface_IBindStatusCallbackHolder);
1548 return E_NOINTERFACE;
1549 }else if(IsEqualGUID(&IID_IBindStatusCallbackEx, riid)) {
1550 CHECK_EXPECT(QueryInterface_IBindStatusCallbackEx);
1551 if(!use_bscex)
1552 return E_NOINTERFACE;
1553 *ppv = iface;
1554 return S_OK;
1555 }else if(IsEqualGUID(&IID_IInternetBindInfo, riid)) {
1556 /* TODO */
1557 }else if(IsEqualGUID(&IID_IWindowForBindingUI, riid)) {
1558 CHECK_EXPECT2(QueryInterface_IWindowForBindingUI);
1559 return E_NOINTERFACE;
1560 }else if(IsEqualGUID(&IID_IHttpSecurity, riid)) {
1561 CHECK_EXPECT2(QueryInterface_IHttpSecurity);
1562 return E_NOINTERFACE;
1563 }else if(IsEqualGUID(&IID_IGetBindHandle, riid)) {
1564 trace("QI(IID_IGetBindHandle)\n");
1565 *ppv = NULL;
1566 return E_NOINTERFACE;
1567 }else if(IsEqualGUID(&IID_undocumentedIE10, riid)) {
1568 trace("QI(IID_undocumentedIE10)\n");
1569 *ppv = NULL;
1570 return E_NOINTERFACE;
1571 }else if(IsEqualGUID(&IID_undocumentedIE11, riid)) {
1572 trace("QI(IID_undocumentedIE11)\n");
1573 *ppv = NULL;
1574 return E_NOINTERFACE;
1575 }else {
1576 ok(0, "unexpected interface %s\n", wine_dbgstr_guid(riid));
1577 }
1578
1579 return E_NOINTERFACE;
1580 }
1581
1582 static ULONG WINAPI statusclb_AddRef(IBindStatusCallbackEx *iface)
1583 {
1584 return 2;
1585 }
1586
1587 static ULONG WINAPI statusclb_Release(IBindStatusCallbackEx *iface)
1588 {
1589 return 1;
1590 }
1591
1592 static HRESULT WINAPI statusclb_OnStartBinding(IBindStatusCallbackEx *iface, DWORD dwReserved,
1593 IBinding *pib)
1594 {
1595 IWinInetHttpInfo *http_info;
1596 HRESULT hres;
1597 IMoniker *mon;
1598 DWORD res;
1599 CLSID clsid;
1600 LPOLESTR res_str;
1601
1602 if(iface == &objbsc)
1603 CHECK_EXPECT(Obj_OnStartBinding);
1604 else
1605 CHECK_EXPECT(OnStartBinding);
1606
1607 ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1608
1609 ok(pib != NULL, "pib should not be NULL\n");
1610 ok(dwReserved == 0xff, "dwReserved=%x\n", dwReserved);
1611
1612 if(pib == (void*)0xdeadbeef)
1613 return S_OK;
1614
1615 current_binding = pib;
1616
1617 hres = IBinding_QueryInterface(pib, &IID_IMoniker, (void**)&mon);
1618 ok(hres == E_NOINTERFACE, "IBinding should not have IMoniker interface\n");
1619 if(SUCCEEDED(hres))
1620 IMoniker_Release(mon);
1621
1622 hres = IBinding_QueryInterface(pib, &IID_IWinInetHttpInfo, (void**)&http_info);
1623 ok(hres == E_NOINTERFACE, "Could not get IID_IWinInetHttpInfo: %08x\n", hres);
1624
1625 if(0) { /* crashes with native urlmon */
1626 hres = IBinding_GetBindResult(pib, NULL, &res, &res_str, NULL);
1627 ok(hres == E_INVALIDARG, "GetBindResult failed: %08x\n", hres);
1628 }
1629 hres = IBinding_GetBindResult(pib, &clsid, NULL, &res_str, NULL);
1630 ok(hres == E_INVALIDARG, "GetBindResult failed: %08x\n", hres);
1631 hres = IBinding_GetBindResult(pib, &clsid, &res, NULL, NULL);
1632 ok(hres == E_INVALIDARG, "GetBindResult failed: %08x\n", hres);
1633 hres = IBinding_GetBindResult(pib, &clsid, &res, &res_str, (void*)0xdeadbeef);
1634 ok(hres == E_INVALIDARG, "GetBindResult failed: %08x\n", hres);
1635
1636 hres = IBinding_GetBindResult(pib, &clsid, &res, &res_str, NULL);
1637 ok(hres == S_OK, "GetBindResult failed: %08x, expected S_OK\n", hres);
1638 ok(IsEqualCLSID(&clsid, &CLSID_NULL), "incorrect clsid: %s\n", wine_dbgstr_guid(&clsid));
1639 ok(!res, "incorrect res: %x\n", res);
1640 ok(!res_str, "incorrect res_str: %s\n", wine_dbgstr_w(res_str));
1641
1642 if(abort_start) {
1643 binding_hres = abort_hres;
1644 return abort_hres;
1645 }
1646
1647 return S_OK;
1648 }
1649
1650 static HRESULT WINAPI statusclb_GetPriority(IBindStatusCallbackEx *iface, LONG *pnPriority)
1651 {
1652 ok(0, "unexpected call\n");
1653 return E_NOTIMPL;
1654 }
1655
1656 static HRESULT WINAPI statusclb_OnLowResource(IBindStatusCallbackEx *iface, DWORD reserved)
1657 {
1658 ok(0, "unexpected call\n");
1659 return E_NOTIMPL;
1660 }
1661
1662 static HRESULT WINAPI statusclb_OnProgress(IBindStatusCallbackEx *iface, ULONG ulProgress,
1663 ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
1664 {
1665 ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1666
1667 switch(ulStatusCode) {
1668 case BINDSTATUS_FINDINGRESOURCE:
1669 if(iface == &objbsc)
1670 CHECK_EXPECT(Obj_OnProgress_FINDINGRESOURCE);
1671 else if(test_protocol == FTP_TEST)
1672 todo_wine CHECK_EXPECT(OnProgress_FINDINGRESOURCE);
1673 else if(test_protocol == HTTPS_TEST && !bindtest_flags)
1674 todo_wine CHECK_EXPECT(OnProgress_FINDINGRESOURCE);
1675 else
1676 CHECK_EXPECT(OnProgress_FINDINGRESOURCE);
1677 if(emulate_protocol && (test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST))
1678 SetEvent(complete_event);
1679 break;
1680 case BINDSTATUS_CONNECTING:
1681 if(iface == &objbsc)
1682 CHECK_EXPECT(Obj_OnProgress_CONNECTING);
1683 else if(test_protocol == FTP_TEST)
1684 todo_wine CHECK_EXPECT(OnProgress_CONNECTING);
1685 else if(onsecurityproblem_hres == S_OK)
1686 CHECK_EXPECT2(OnProgress_CONNECTING);
1687 else
1688 CHECK_EXPECT(OnProgress_CONNECTING);
1689 if(emulate_protocol && (test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST))
1690 SetEvent(complete_event);
1691 break;
1692 case BINDSTATUS_REDIRECTING:
1693 if(iface == &objbsc)
1694 CHECK_EXPECT(Obj_OnProgress_REDIRECTING);
1695 else
1696 CHECK_EXPECT(OnProgress_REDIRECTING);
1697 ok(!lstrcmpW(szStatusText, winetest_data_urlW), "unexpected status text %s\n",
1698 wine_dbgstr_w(szStatusText));
1699 if(emulate_protocol && (test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST)
1700 && (!bind_to_object || iface == &objbsc))
1701 SetEvent(complete_event);
1702 break;
1703 case BINDSTATUS_SENDINGREQUEST:
1704 if(iface == &objbsc)
1705 CHECK_EXPECT(Obj_OnProgress_SENDINGREQUEST);
1706 else if(test_protocol == FTP_TEST)
1707 CHECK_EXPECT2(OnProgress_SENDINGREQUEST);
1708 else
1709 CHECK_EXPECT(OnProgress_SENDINGREQUEST);
1710 if(emulate_protocol && (test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST))
1711 SetEvent(complete_event);
1712
1713 if(abort_progress) {
1714 if(filedwl_api)
1715 binding_hres = E_ABORT;
1716 return E_ABORT;
1717 }
1718
1719 break;
1720 case BINDSTATUS_MIMETYPEAVAILABLE:
1721 if(iface == &objbsc)
1722 CHECK_EXPECT(Obj_OnProgress_MIMETYPEAVAILABLE);
1723 else
1724 CHECK_EXPECT(OnProgress_MIMETYPEAVAILABLE);
1725 if(!bind_to_object)
1726 ok(download_state == BEFORE_DOWNLOAD, "Download state was %d, expected BEFORE_DOWNLOAD\n",
1727 download_state);
1728 WideCharToMultiByte(CP_ACP, 0, szStatusText, -1, mime_type, sizeof(mime_type)-1, NULL, NULL);
1729 break;
1730 case BINDSTATUS_BEGINDOWNLOADDATA:
1731 if(iface == &objbsc)
1732 CHECK_EXPECT(Obj_OnProgress_BEGINDOWNLOADDATA);
1733 else
1734 CHECK_EXPECT(OnProgress_BEGINDOWNLOADDATA);
1735 ok(szStatusText != NULL, "szStatusText == NULL\n");
1736 if(szStatusText) {
1737 if(filedwl_api) {
1738 /* FIXME */
1739 }else {
1740 ok(!lstrcmpW(szStatusText, current_url), "wrong szStatusText %s\n", wine_dbgstr_w(szStatusText));
1741 }
1742 }
1743 if(!bind_to_object)
1744 ok(download_state == BEFORE_DOWNLOAD, "Download state was %d, expected BEFORE_DOWNLOAD\n",
1745 download_state);
1746 download_state = DOWNLOADING;
1747 break;
1748 case BINDSTATUS_DOWNLOADINGDATA:
1749 CHECK_EXPECT2(OnProgress_DOWNLOADINGDATA);
1750 ok(iface != &objbsc, "unexpected call\n");
1751 ok(download_state == DOWNLOADING, "Download state was %d, expected DOWNLOADING\n",
1752 download_state);
1753 if(test_abort) {
1754 HRESULT hres;
1755
1756 SET_EXPECT(Abort);
1757 hres = IBinding_Abort(current_binding);
1758 ok(hres == S_OK, "Abort failed: %08x\n", hres);
1759 CHECK_CALLED(Abort);
1760
1761 hres = IBinding_Abort(current_binding);
1762 ok(hres == E_FAIL, "Abort failed: %08x\n", hres);
1763
1764 binding_hres = E_ABORT;
1765 }
1766 break;
1767 case BINDSTATUS_ENDDOWNLOADDATA:
1768 if(iface == &objbsc)
1769 CHECK_EXPECT(Obj_OnProgress_ENDDOWNLOADDATA);
1770 else
1771 CHECK_EXPECT(OnProgress_ENDDOWNLOADDATA);
1772 ok(szStatusText != NULL, "szStatusText == NULL\n");
1773 if(szStatusText) {
1774 if(filedwl_api) {
1775 /* FIXME */
1776 }else {
1777 ok(!lstrcmpW(szStatusText, current_url), "wrong szStatusText %s\n", wine_dbgstr_w(szStatusText));
1778 }
1779 }
1780 ok(download_state == DOWNLOADING, "Download state was %d, expected DOWNLOADING\n",
1781 download_state);
1782 download_state = END_DOWNLOAD;
1783 break;
1784 case BINDSTATUS_CACHEFILENAMEAVAILABLE:
1785 if(test_protocol != HTTP_TEST && test_protocol != HTTPS_TEST && test_protocol != WINETEST_TEST) {
1786 if(iface == &objbsc)
1787 CHECK_EXPECT(Obj_OnProgress_CACHEFILENAMEAVAILABLE);
1788 else
1789 CHECK_EXPECT(OnProgress_CACHEFILENAMEAVAILABLE);
1790 }else { /* FIXME */
1791 CLEAR_CALLED(OnProgress_CACHEFILENAMEAVAILABLE);
1792 CLEAR_CALLED(Obj_OnProgress_CACHEFILENAMEAVAILABLE);
1793 }
1794
1795 ok(szStatusText != NULL, "szStatusText == NULL\n");
1796 if(szStatusText && test_protocol == FILE_TEST)
1797 ok(!lstrcmpW(file_url+7, szStatusText), "wrong szStatusText %s\n", wine_dbgstr_w(szStatusText));
1798 break;
1799 case BINDSTATUS_CLASSIDAVAILABLE:
1800 {
1801 CLSID clsid;
1802 HRESULT hr;
1803 if(iface != &objbsc)
1804 ok(0, "unexpected call\n");
1805 else
1806 CHECK_EXPECT(Obj_OnProgress_CLASSIDAVAILABLE);
1807 hr = CLSIDFromString((LPCOLESTR)szStatusText, &clsid);
1808 ok(hr == S_OK, "CLSIDFromString failed with error 0x%08x\n", hr);
1809 ok(IsEqualCLSID(&clsid, &CLSID_HTMLDocument),
1810 "Expected clsid to be CLSID_HTMLDocument instead of %s\n", wine_dbgstr_guid(&clsid));
1811 break;
1812 }
1813 case BINDSTATUS_BEGINSYNCOPERATION:
1814 CHECK_EXPECT(Obj_OnProgress_BEGINSYNCOPERATION);
1815 if(iface != &objbsc)
1816 ok(0, "unexpected call\n");
1817 ok(szStatusText == NULL, "Expected szStatusText to be NULL\n");
1818 break;
1819 case BINDSTATUS_ENDSYNCOPERATION:
1820 CHECK_EXPECT(Obj_OnProgress_ENDSYNCOPERATION);
1821 if(iface != &objbsc)
1822 ok(0, "unexpected call\n");
1823 ok(szStatusText == NULL, "Expected szStatusText to be NULL\n");
1824 break;
1825 case BINDSTATUS_PROXYDETECTING:
1826 trace("BINDSTATUS_PROXYDETECTING\n");
1827 break;
1828 case BINDSTATUS_COOKIE_SENT:
1829 trace("BINDSTATUS_COOKIE_SENT\n");
1830 break;
1831 case BINDSTATUS_DECODING:
1832 trace("BINDSTATUS_DECODING\n");
1833 break;
1834 default:
1835 ok(0, "unexpected code %d\n", ulStatusCode);
1836 };
1837
1838 if(current_binding) {
1839 IWinInetHttpInfo *http_info;
1840 HRESULT hres;
1841
1842 hres = IBinding_QueryInterface(current_binding, &IID_IWinInetHttpInfo, (void**)&http_info);
1843 if(!emulate_protocol && test_protocol != FILE_TEST && is_urlmon_protocol(test_protocol)) {
1844 ok(hres == S_OK, "Could not get IWinInetHttpInfo iface: %08x\n", hres);
1845 test_WinInetHttpInfo(http_info, ulStatusCode);
1846 } else
1847 ok(hres == E_NOINTERFACE,
1848 "QueryInterface(IID_IWinInetHttpInfo) returned: %08x, expected E_NOINTERFACE\n", hres);
1849 if(SUCCEEDED(hres))
1850 IWinInetHttpInfo_Release(http_info);
1851 }
1852
1853 return S_OK;
1854 }
1855
1856 static HRESULT WINAPI statusclb_OnStopBinding(IBindStatusCallbackEx *iface, HRESULT hresult, LPCWSTR szError)
1857 {
1858 if(iface == &objbsc) {
1859 CHECK_EXPECT(Obj_OnStopBinding);
1860 stopped_obj_binding = TRUE;
1861 }else {
1862 CHECK_EXPECT(OnStopBinding);
1863 stopped_binding = TRUE;
1864 }
1865
1866 ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1867
1868 if(only_check_prot_args) {
1869 todo_wine ok(hresult == S_OK, "Got %08x\n", hresult);
1870 return S_OK;
1871 }
1872
1873 /* ignore DNS failure */
1874 if (hresult == HRESULT_FROM_WIN32(ERROR_INTERNET_NAME_NOT_RESOLVED))
1875 return S_OK;
1876
1877 if(filedwl_api) {
1878 if(!abort_progress && !abort_start)
1879 ok(SUCCEEDED(hresult), "binding failed: %08x\n", hresult);
1880 else if(abort_start && abort_hres == E_NOTIMPL)
1881 todo_wine ok(hresult == S_FALSE, "binding failed: %08x, expected S_FALSE\n", hresult);
1882 else
1883 ok(hresult == E_ABORT, "binding failed: %08x, expected E_ABORT\n", hresult);
1884 } else
1885 ok(hresult == binding_hres, "binding failed: %08x, expected %08x\n", hresult, binding_hres);
1886 ok(szError == NULL, "szError should be NULL\n");
1887
1888 if(current_binding) {
1889 CLSID clsid;
1890 DWORD res;
1891 LPOLESTR res_str;
1892 HRESULT hres;
1893
1894 hres = IBinding_GetBindResult(current_binding, &clsid, &res, &res_str, NULL);
1895 ok(hres == S_OK, "GetBindResult failed: %08x, expected S_OK\n", hres);
1896 ok(res == hresult, "res = %08x, expected %08x\n", res, binding_hres);
1897 ok(!res_str, "incorrect res_str = %s\n", wine_dbgstr_w(res_str));
1898
1899 if(hresult==S_OK || (abort_start && hresult!=S_FALSE) || hresult == REGDB_E_CLASSNOTREG) {
1900 ok(IsEqualCLSID(&clsid, &CLSID_NULL),
1901 "incorrect protocol CLSID: %s, expected CLSID_NULL\n",
1902 wine_dbgstr_guid(&clsid));
1903 }else if(emulate_protocol) {
1904 todo_wine ok(IsEqualCLSID(&clsid, &CLSID_FtpProtocol),
1905 "incorrect protocol CLSID: %s, expected CLSID_FtpProtocol\n",
1906 wine_dbgstr_guid(&clsid));
1907 }else if(test_protocol == FTP_TEST) {
1908 ok(IsEqualCLSID(&clsid, &CLSID_FtpProtocol),
1909 "incorrect protocol CLSID: %s, expected CLSID_FtpProtocol\n",
1910 wine_dbgstr_guid(&clsid));
1911 }else if(test_protocol == FILE_TEST) {
1912 ok(IsEqualCLSID(&clsid, &CLSID_FileProtocol),
1913 "incorrect protocol CLSID: %s, expected CLSID_FileProtocol\n",
1914 wine_dbgstr_guid(&clsid));
1915 }else if(test_protocol == HTTP_TEST) {
1916 ok(IsEqualCLSID(&clsid, &CLSID_HttpProtocol),
1917 "incorrect protocol CLSID: %s, expected CLSID_HttpProtocol\n",
1918 wine_dbgstr_guid(&clsid));
1919 }else if(test_protocol == HTTPS_TEST) {
1920 ok(IsEqualCLSID(&clsid, &CLSID_HttpSProtocol),
1921 "incorrect protocol CLSID: %s, expected CLSID_HttpSProtocol\n",
1922 wine_dbgstr_guid(&clsid));
1923 }else if(test_protocol == ABOUT_TEST) {
1924 ok(IsEqualCLSID(&clsid, &CLSID_AboutProtocol),
1925 "incorrect protocol CLSID: %s, expected CLSID_AboutProtocol\n",
1926 wine_dbgstr_guid(&clsid));
1927 }else {
1928 ok(0, "unexpected (%d)\n", test_protocol);
1929 }
1930 }
1931
1932 if((test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST) && emulate_protocol) {
1933 SetEvent(complete_event);
1934 if(iface != &objbsc)
1935 ok( WaitForSingleObject(complete_event2, 90000) == WAIT_OBJECT_0, "wait timed out\n" );
1936 }
1937
1938 return S_OK;
1939 }
1940
1941 static HRESULT WINAPI statusclb_GetBindInfo(IBindStatusCallbackEx *iface, DWORD *grfBINDF, BINDINFO *pbindinfo)
1942 {
1943 DWORD cbSize;
1944
1945 if(iface == &objbsc)
1946 CHECK_EXPECT(Obj_GetBindInfo);
1947 else
1948 CHECK_EXPECT(GetBindInfo);
1949
1950 ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1951
1952 *grfBINDF = bindf;
1953 cbSize = pbindinfo->cbSize;
1954 memset(pbindinfo, 0, cbSize);
1955 pbindinfo->cbSize = cbSize;
1956
1957 return S_OK;
1958 }
1959
1960 static HRESULT WINAPI statusclb_OnDataAvailable(IBindStatusCallbackEx *iface, DWORD grfBSCF,
1961 DWORD dwSize, FORMATETC* pformatetc, STGMEDIUM* pstgmed)
1962 {
1963 HRESULT hres;
1964 DWORD readed;
1965 BYTE buf[512];
1966 CHAR clipfmt[512];
1967
1968 if(iface == &objbsc)
1969 ok(0, "unexpected call\n");
1970
1971 CHECK_EXPECT2(OnDataAvailable);
1972
1973 ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
1974
1975 ok(download_state == DOWNLOADING || download_state == END_DOWNLOAD,
1976 "Download state was %d, expected DOWNLOADING or END_DOWNLOAD\n",
1977 download_state);
1978 data_available = TRUE;
1979
1980 if(bind_to_object && !is_async_prot)
1981 ok(grfBSCF == (BSCF_FIRSTDATANOTIFICATION|BSCF_LASTDATANOTIFICATION), "grfBSCF = %x\n", grfBSCF);
1982
1983 ok(pformatetc != NULL, "pformatetx == NULL\n");
1984 if(pformatetc) {
1985 if (mime_type[0]) {
1986 INT ret;
1987 clipfmt[0] = 0;
1988 ret = GetClipboardFormatNameA(pformatetc->cfFormat, clipfmt, sizeof(clipfmt)-1);
1989 ok(ret, "GetClipboardFormatName failed, error %d\n", GetLastError());
1990 ok(!strcmp(clipfmt, mime_type), "clipformat %x != mime_type, \"%s\" != \"%s\"\n",
1991 pformatetc->cfFormat, clipfmt, mime_type);
1992 } else {
1993 ok(pformatetc->cfFormat == 0, "clipformat=%x\n", pformatetc->cfFormat);
1994 }
1995 ok(pformatetc->ptd == NULL, "ptd = %p\n", pformatetc->ptd);
1996 ok(pformatetc->dwAspect == 1, "dwAspect=%u\n", pformatetc->dwAspect);
1997 ok(pformatetc->lindex == -1, "lindex=%d\n", pformatetc->lindex);
1998 ok(pformatetc->tymed == tymed, "tymed=%u, expected %u\n", pformatetc->tymed, tymed);
1999 }
2000
2001 ok(pstgmed != NULL, "stgmeg == NULL\n");
2002 ok(pstgmed->tymed == tymed, "tymed=%u, expected %u\n", pstgmed->tymed, tymed);
2003 ok(pstgmed->pUnkForRelease != NULL, "pUnkForRelease == NULL\n");
2004
2005 switch(pstgmed->tymed) {
2006 case TYMED_ISTREAM:
2007 if(grfBSCF & BSCF_FIRSTDATANOTIFICATION) {
2008 STATSTG stat;
2009
2010 hres = IStream_Write(U(*pstgmed).pstm, buf, 10, NULL);
2011 ok(hres == STG_E_ACCESSDENIED,
2012 "Write failed: %08x, expected STG_E_ACCESSDENIED\n", hres);
2013
2014 hres = IStream_Commit(U(*pstgmed).pstm, 0);
2015 ok(hres == E_NOTIMPL, "Commit failed: %08x, expected E_NOTIMPL\n", hres);
2016
2017 hres = IStream_Revert(U(*pstgmed).pstm);
2018 ok(hres == E_NOTIMPL, "Revert failed: %08x, expected E_NOTIMPL\n", hres);
2019
2020 hres = IStream_Stat(U(*pstgmed).pstm, NULL, STATFLAG_NONAME);
2021 ok(hres == E_FAIL, "hres = %x\n", hres);
2022 if(use_cache_file && emulate_protocol) {
2023 hres = IStream_Stat(U(*pstgmed).pstm, &stat, STATFLAG_DEFAULT);
2024 ok(hres == S_OK, "hres = %x\n", hres);
2025 ok(!lstrcmpW(stat.pwcsName, cache_file_name),
2026 "stat.pwcsName = %s, cache_file_name = %s\n",
2027 wine_dbgstr_w(stat.pwcsName), wine_dbgstr_w(cache_file_name));
2028 CoTaskMemFree(stat.pwcsName);
2029 ok(U(stat.cbSize).LowPart == (bindf&BINDF_ASYNCHRONOUS?0:6500),
2030 "stat.cbSize.LowPart = %u\n", U(stat.cbSize).LowPart);
2031 } else {
2032 hres = IStream_Stat(U(*pstgmed).pstm, &stat, STATFLAG_NONAME);
2033 ok(hres == S_OK, "hres = %x\n", hres);
2034 ok(!stat.pwcsName || broken(stat.pwcsName!=NULL),
2035 "stat.pwcsName = %s\n", wine_dbgstr_w(stat.pwcsName));
2036 }
2037 ok(stat.type == STGTY_STREAM, "stat.type = %x\n", stat.type);
2038 ok(U(stat.cbSize).HighPart == 0, "stat.cbSize.HighPart != 0\n");
2039 ok(stat.grfMode == (U(stat.cbSize).LowPart?GENERIC_READ:0), "stat.grfMode = %x\n", stat.grfMode);
2040 ok(stat.grfLocksSupported == 0, "stat.grfLocksSupported = %x\n", stat.grfLocksSupported);
2041 ok(stat.grfStateBits == 0, "stat.grfStateBits = %x\n", stat.grfStateBits);
2042 ok(stat.reserved == 0, "stat.reserved = %x\n", stat.reserved);
2043 }
2044
2045 ok(U(*pstgmed).pstm != NULL, "U(*pstgmed).pstm == NULL\n");
2046 if(callback_read) {
2047 do {
2048 hres = IStream_Read(U(*pstgmed).pstm, buf, 512, &readed);
2049 if(test_protocol == HTTP_TEST && emulate_protocol && readed)
2050 ok(buf[0] == (use_cache_file && !(bindf&BINDF_ASYNCHRONOUS) ? 'X' : '?'), "buf[0] = '%c'\n", buf[0]);
2051 }while(hres == S_OK);
2052 ok(hres == S_FALSE || hres == E_PENDING, "IStream_Read returned %08x\n", hres);
2053 }
2054 break;
2055
2056 case TYMED_FILE:
2057 if(test_protocol == FILE_TEST)
2058 ok(!lstrcmpW(pstgmed->u.lpszFileName, file_url+7),
2059 "unexpected file name %s\n", wine_dbgstr_w(pstgmed->u.lpszFileName));
2060 else if(emulate_protocol)
2061 ok(!lstrcmpW(pstgmed->u.lpszFileName, cache_fileW),
2062 "unexpected file name %s\n", wine_dbgstr_w(pstgmed->u.lpszFileName));
2063 else
2064 ok(pstgmed->u.lpszFileName != NULL, "lpszFileName == NULL\n");
2065 }
2066
2067 if((test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST)
2068 && emulate_protocol && prot_state < 4 && (!bind_to_object || prot_state > 1))
2069 SetEvent(complete_event);
2070
2071 return S_OK;
2072 }
2073
2074 static HRESULT WINAPI statusclb_OnObjectAvailable(IBindStatusCallbackEx *iface, REFIID riid, IUnknown *punk)
2075 {
2076 CHECK_EXPECT(OnObjectAvailable);
2077
2078 if(iface != &objbsc)
2079 ok(0, "unexpected call\n");
2080
2081 ok(IsEqualGUID(&IID_IUnknown, riid), "riid = %s\n", wine_dbgstr_guid(riid));
2082 ok(punk != NULL, "punk == NULL\n");
2083
2084 return S_OK;
2085 }
2086
2087 static HRESULT WINAPI statusclb_GetBindInfoEx(IBindStatusCallbackEx *iface, DWORD *grfBINDF, BINDINFO *pbindinfo,
2088 DWORD *grfBINDF2, DWORD *pdwReserved)
2089 {
2090 CHECK_EXPECT(GetBindInfoEx);
2091
2092 ok(grfBINDF != NULL, "grfBINDF == NULL\n");
2093 ok(grfBINDF2 != NULL, "grfBINDF2 == NULL\n");
2094 ok(pbindinfo != NULL, "pbindinfo == NULL\n");
2095 ok(pdwReserved != NULL, "dwReserved == NULL\n");
2096
2097 return S_OK;
2098 }
2099
2100 static const IBindStatusCallbackExVtbl BindStatusCallbackVtbl = {
2101 statusclb_QueryInterface,
2102 statusclb_AddRef,
2103 statusclb_Release,
2104 statusclb_OnStartBinding,
2105 statusclb_GetPriority,
2106 statusclb_OnLowResource,
2107 statusclb_OnProgress,
2108 statusclb_OnStopBinding,
2109 statusclb_GetBindInfo,
2110 statusclb_OnDataAvailable,
2111 statusclb_OnObjectAvailable,
2112 statusclb_GetBindInfoEx
2113 };
2114
2115 static IBindStatusCallbackEx bsc = { &BindStatusCallbackVtbl };
2116 static IBindStatusCallbackEx bsc2 = { &BindStatusCallbackVtbl };
2117 static IBindStatusCallbackEx objbsc = { &BindStatusCallbackVtbl };
2118
2119 static HRESULT WINAPI MonikerProp_QueryInterface(IMonikerProp *iface, REFIID riid, void **ppv)
2120 {
2121 *ppv = NULL;
2122 ok(0, "unexpected riid %s\n", wine_dbgstr_guid(riid));
2123 return E_NOINTERFACE;
2124 }
2125
2126 static ULONG WINAPI MonikerProp_AddRef(IMonikerProp *iface)
2127 {
2128 return 2;
2129 }
2130
2131 static ULONG WINAPI MonikerProp_Release(IMonikerProp *iface)
2132 {
2133 return 1;
2134 }
2135
2136 static HRESULT WINAPI MonikerProp_PutProperty(IMonikerProp *iface, MONIKERPROPERTY mkp, LPCWSTR val)
2137 {
2138 switch(mkp) {
2139 case MIMETYPEPROP:
2140 CHECK_EXPECT(PutProperty_MIMETYPEPROP);
2141 ok(!lstrcmpW(val, wszTextHtml), "val = %s\n", wine_dbgstr_w(val));
2142 break;
2143 case CLASSIDPROP:
2144 CHECK_EXPECT(PutProperty_CLASSIDPROP);
2145 break;
2146 default:
2147 break;
2148 }
2149
2150 return S_OK;
2151 }
2152
2153 static const IMonikerPropVtbl MonikerPropVtbl = {
2154 MonikerProp_QueryInterface,
2155 MonikerProp_AddRef,
2156 MonikerProp_Release,
2157 MonikerProp_PutProperty
2158 };
2159
2160 static IMonikerProp MonikerProp = { &MonikerPropVtbl };
2161
2162 static HRESULT WINAPI PersistMoniker_QueryInterface(IPersistMoniker *iface, REFIID riid, void **ppv)
2163 {
2164 *ppv = NULL;
2165
2166 if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IPersistMoniker, riid))
2167 *ppv = iface;
2168 else if(IsEqualGUID(&IID_IMonikerProp, riid))
2169 *ppv = &MonikerProp;
2170
2171 if(*ppv)
2172 return S_OK;
2173
2174 ok(0, "unexpected riid %s\n", wine_dbgstr_guid(riid));
2175 return E_NOINTERFACE;
2176 }
2177
2178 static ULONG WINAPI PersistMoniker_AddRef(IPersistMoniker *iface)
2179 {
2180 return 2;
2181 }
2182
2183 static ULONG WINAPI PersistMoniker_Release(IPersistMoniker *iface)
2184 {
2185 return 1;
2186 }
2187
2188 static HRESULT WINAPI PersistMoniker_GetClassID(IPersistMoniker *iface, CLSID *pClassID)
2189 {
2190 ok(0, "unexpected call\n");
2191 return E_NOTIMPL;
2192 }
2193
2194 static HRESULT WINAPI PersistMoniker_IsDirty(IPersistMoniker *iface)
2195 {
2196 ok(0, "unexpected call\n");
2197 return E_NOTIMPL;
2198 }
2199
2200 static HRESULT WINAPI PersistMoniker_Load(IPersistMoniker *iface, BOOL fFullyAvailable,
2201 IMoniker *pimkName, LPBC pibc, DWORD grfMode)
2202 {
2203 IUnknown *unk;
2204 HRESULT hres;
2205
2206 static WCHAR cbinding_contextW[] =
2207 {'C','B','i','n','d','i','n','g',' ','C','o','n','t','e','x','t',0};
2208
2209 CHECK_EXPECT(Load);
2210 ok(GetCurrentThreadId() == thread_id, "wrong thread %d\n", GetCurrentThreadId());
2211
2212 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
2213 ok(!fFullyAvailable, "fFullyAvailable = %x\n", fFullyAvailable);
2214 else
2215 ok(fFullyAvailable, "fFullyAvailable = %x\n", fFullyAvailable);
2216 ok(pimkName != NULL, "pimkName == NULL\n");
2217 ok(pibc != NULL, "pibc == NULL\n");
2218 ok(grfMode == 0x12, "grfMode = %x\n", grfMode);
2219
2220 hres = IBindCtx_GetObjectParam(pibc, cbinding_contextW, &unk);
2221 ok(hres == S_OK, "GetObjectParam(CBinding Context) failed: %08x\n", hres);
2222 if(SUCCEEDED(hres)) {
2223 IBinding *binding;
2224
2225 hres = IUnknown_QueryInterface(unk, &IID_IBinding, (void**)&binding);
2226 ok(hres == S_OK, "Could not get IBinding: %08x\n", hres);
2227
2228 IBinding_Release(binding);
2229 IUnknown_Release(unk);
2230 }
2231
2232 SET_EXPECT(QueryInterface_IServiceProvider);
2233 hres = RegisterBindStatusCallback(pibc, (IBindStatusCallback*)&bsc, NULL, 0);
2234 ok(hres == S_OK, "RegisterBindStatusCallback failed: %08x\n", hres);
2235 CHECK_CALLED(QueryInterface_IServiceProvider);
2236
2237 SET_EXPECT(QueryInterface_IBindStatusCallbackEx);
2238 SET_EXPECT(GetBindInfo);
2239 SET_EXPECT(OnStartBinding);
2240 if(test_redirect)
2241 SET_EXPECT(OnProgress_REDIRECTING);
2242 SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
2243 if(test_protocol == FILE_TEST)
2244 SET_EXPECT(OnProgress_CACHEFILENAMEAVAILABLE);
2245 if(test_protocol != HTTP_TEST && test_protocol != HTTPS_TEST)
2246 SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
2247 SET_EXPECT(LockRequest);
2248 SET_EXPECT(OnDataAvailable);
2249 if(test_protocol != HTTP_TEST && test_protocol != HTTPS_TEST)
2250 SET_EXPECT(OnStopBinding);
2251
2252 hres = IMoniker_BindToStorage(pimkName, pibc, NULL, &IID_IStream, (void**)&unk);
2253 ok(hres == S_OK, "Load failed: %08x\n", hres);
2254
2255 CLEAR_CALLED(QueryInterface_IBindStatusCallbackEx); /* IE 8 */
2256 CHECK_CALLED(GetBindInfo);
2257 CHECK_CALLED(OnStartBinding);
2258 if(test_redirect)
2259 CHECK_CALLED(OnProgress_REDIRECTING);
2260 CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
2261 if(test_protocol == FILE_TEST)
2262 CHECK_CALLED(OnProgress_CACHEFILENAMEAVAILABLE);
2263 if(test_protocol != HTTP_TEST && test_protocol != HTTPS_TEST)
2264 CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
2265 CHECK_CALLED(LockRequest);
2266 CHECK_CALLED(OnDataAvailable);
2267 if(test_protocol != HTTP_TEST && test_protocol != HTTPS_TEST)
2268 CHECK_CALLED(OnStopBinding);
2269
2270 if(unk)
2271 IUnknown_Release(unk);
2272
2273 return S_OK;
2274 }
2275
2276 static HRESULT WINAPI PersistMoniker_Save(IPersistMoniker *iface, IMoniker *pimkName, LPBC pbc, BOOL fRemember)
2277 {
2278 ok(0, "unexpected call\n");
2279 return E_NOTIMPL;
2280 }
2281
2282 static HRESULT WINAPI PersistMoniker_SaveCompleted(IPersistMoniker *iface, IMoniker *pimkName, LPBC pibc)
2283 {
2284 ok(0, "unexpected call\n");
2285 return E_NOTIMPL;
2286 }
2287
2288 static HRESULT WINAPI PersistMoniker_GetCurMoniker(IPersistMoniker *iface, IMoniker **pimkName)
2289 {
2290 ok(0, "unexpected call\n");
2291 return E_NOTIMPL;
2292 }
2293
2294 static const IPersistMonikerVtbl PersistMonikerVtbl = {
2295 PersistMoniker_QueryInterface,
2296 PersistMoniker_AddRef,
2297 PersistMoniker_Release,
2298 PersistMoniker_GetClassID,
2299 PersistMoniker_IsDirty,
2300 PersistMoniker_Load,
2301 PersistMoniker_Save,
2302 PersistMoniker_SaveCompleted,
2303 PersistMoniker_GetCurMoniker
2304 };
2305
2306 static IPersistMoniker PersistMoniker = { &PersistMonikerVtbl };
2307
2308 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
2309 {
2310 *ppv = NULL;
2311
2312 if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
2313 *ppv = iface;
2314 return S_OK;
2315 }
2316
2317 if(IsEqualGUID(&IID_IMarshal, riid))
2318 return E_NOINTERFACE;
2319 if(IsEqualGUID(&CLSID_IdentityUnmarshal, riid))
2320 return E_NOINTERFACE;
2321
2322 ok(0, "unexpected riid %s\n", wine_dbgstr_guid(riid));
2323 return E_NOTIMPL;
2324 }
2325
2326 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
2327 {
2328 return 2;
2329 }
2330
2331 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
2332 {
2333 return 1;
2334 }
2335
2336 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
2337 {
2338 CHECK_EXPECT(CreateInstance);
2339 ok(!outer, "outer = %p\n", outer);
2340 ok(IsEqualGUID(&IID_IUnknown, riid), "unexpected riid %s\n", wine_dbgstr_guid(riid));
2341 *ppv = &PersistMoniker;
2342 return S_OK;
2343 }
2344
2345 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
2346 {
2347 ok(0, "unexpected call\n");
2348 return S_OK;
2349 }
2350
2351 static const IClassFactoryVtbl ClassFactoryVtbl = {
2352 ClassFactory_QueryInterface,
2353 ClassFactory_AddRef,
2354 ClassFactory_Release,
2355 ClassFactory_CreateInstance,
2356 ClassFactory_LockServer
2357 };
2358
2359 static IClassFactory mime_cf = { &ClassFactoryVtbl };
2360
2361 static HRESULT WINAPI ProtocolCF_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
2362 {
2363 *ppv = NULL;
2364
2365 if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
2366 *ppv = iface;
2367 return S_OK;
2368 }
2369
2370 if(IsEqualGUID(&IID_IInternetProtocolInfo, riid))
2371 return E_NOINTERFACE;
2372
2373 ok(0, "unexpected riid %s\n", wine_dbgstr_guid(riid));
2374 return E_NOTIMPL;
2375 }
2376
2377 static HRESULT WINAPI ProtocolCF_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
2378 {
2379 if(IsEqualGUID(&IID_IInternetProtocolInfo, riid))
2380 return E_NOINTERFACE;
2381
2382 todo_wine ok(outer != NULL, "outer == NULL\n");
2383 todo_wine ok(IsEqualGUID(&IID_IUnknown, riid), "unexpected riid %s\n", wine_dbgstr_guid(riid));
2384 *ppv = &Protocol;
2385 return S_OK;
2386 }
2387
2388 static const IClassFactoryVtbl ProtocolCFVtbl = {
2389 ProtocolCF_QueryInterface,
2390 ClassFactory_AddRef,
2391 ClassFactory_Release,
2392 ProtocolCF_CreateInstance,
2393 ClassFactory_LockServer
2394 };
2395
2396 static IClassFactory protocol_cf = { &ProtocolCFVtbl };
2397
2398 static void test_CreateAsyncBindCtx(void)
2399 {
2400 IBindCtx *bctx = (IBindCtx*)0x0ff00ff0;
2401 IUnknown *unk;
2402 HRESULT hres;
2403 ULONG ref;
2404 BIND_OPTS bindopts;
2405
2406 hres = CreateAsyncBindCtx(0, NULL, NULL, &bctx);
2407 ok(hres == E_INVALIDARG, "CreateAsyncBindCtx failed. expected: E_INVALIDARG, got: %08x\n", hres);
2408 ok(bctx == (IBindCtx*)0x0ff00ff0, "bctx should not be changed\n");
2409
2410 hres = CreateAsyncBindCtx(0, NULL, NULL, NULL);
2411 ok(hres == E_INVALIDARG, "CreateAsyncBindCtx failed. expected: E_INVALIDARG, got: %08x\n", hres);
2412
2413 SET_EXPECT(QueryInterface_IServiceProvider);
2414 hres = CreateAsyncBindCtx(0, (IBindStatusCallback*)&bsc, NULL, &bctx);
2415 ok(hres == S_OK, "CreateAsyncBindCtx failed: %08x\n", hres);
2416 CHECK_CALLED(QueryInterface_IServiceProvider);
2417
2418 bindopts.cbStruct = sizeof(bindopts);
2419 hres = IBindCtx_GetBindOptions(bctx, &bindopts);
2420 ok(hres == S_OK, "IBindCtx_GetBindOptions failed: %08x\n", hres);
2421 ok(bindopts.grfFlags == BIND_MAYBOTHERUSER,
2422 "bindopts.grfFlags = %08x, expected: BIND_MAYBOTHERUSER\n", bindopts.grfFlags);
2423 ok(bindopts.grfMode == (STGM_READWRITE | STGM_SHARE_EXCLUSIVE),
2424 "bindopts.grfMode = %08x, expected: STGM_READWRITE | STGM_SHARE_EXCLUSIVE\n",
2425 bindopts.grfMode);
2426 ok(bindopts.dwTickCountDeadline == 0,
2427 "bindopts.dwTickCountDeadline = %08x, expected: 0\n", bindopts.dwTickCountDeadline);
2428
2429 hres = IBindCtx_QueryInterface(bctx, &IID_IAsyncBindCtx, (void**)&unk);
2430 ok(hres == E_NOINTERFACE, "QueryInterface(IID_IAsyncBindCtx) failed: %08x, expected E_NOINTERFACE\n", hres);
2431 if(SUCCEEDED(hres))
2432 IUnknown_Release(unk);
2433
2434 ref = IBindCtx_Release(bctx);
2435 ok(ref == 0, "bctx should be destroyed here\n");
2436 }
2437
2438 static void test_CreateAsyncBindCtxEx(void)
2439 {
2440 IBindCtx *bctx = NULL, *bctx2 = NULL, *bctx_arg = NULL;
2441 IUnknown *unk;
2442 BIND_OPTS bindopts;
2443 HRESULT hres;
2444
2445 static WCHAR testW[] = {'t','e','s','t',0};
2446
2447 if (!pCreateAsyncBindCtxEx) {
2448 win_skip("CreateAsyncBindCtxEx not present\n");
2449 return;
2450 }
2451
2452 hres = pCreateAsyncBindCtxEx(NULL, 0, NULL, NULL, NULL, 0);
2453 ok(hres == E_INVALIDARG, "CreateAsyncBindCtx failed: %08x, expected E_INVALIDARG\n", hres);
2454
2455 hres = pCreateAsyncBindCtxEx(NULL, 0, NULL, NULL, &bctx, 0);
2456 ok(hres == S_OK, "CreateAsyncBindCtxEx failed: %08x\n", hres);
2457
2458 if(SUCCEEDED(hres)) {
2459 bindopts.cbStruct = sizeof(bindopts);
2460 hres = IBindCtx_GetBindOptions(bctx, &bindopts);
2461 ok(hres == S_OK, "IBindCtx_GetBindOptions failed: %08x\n", hres);
2462 ok(bindopts.grfFlags == BIND_MAYBOTHERUSER,
2463 "bindopts.grfFlags = %08x, expected: BIND_MAYBOTHERUSER\n", bindopts.grfFlags);
2464 ok(bindopts.grfMode == (STGM_READWRITE | STGM_SHARE_EXCLUSIVE),
2465 "bindopts.grfMode = %08x, expected: STGM_READWRITE | STGM_SHARE_EXCLUSIVE\n",
2466 bindopts.grfMode);
2467 ok(bindopts.dwTickCountDeadline == 0,
2468 "bindopts.dwTickCountDeadline = %08x, expected: 0\n", bindopts.dwTickCountDeadline);
2469
2470 IBindCtx_Release(bctx);
2471 }
2472
2473 CreateBindCtx(0, &bctx_arg);
2474 hres = pCreateAsyncBindCtxEx(NULL, 0, NULL, NULL, &bctx, 0);
2475 ok(hres == S_OK, "CreateAsyncBindCtxEx failed: %08x\n", hres);
2476
2477 if(SUCCEEDED(hres)) {
2478 bindopts.cbStruct = sizeof(bindopts);
2479 hres = IBindCtx_GetBindOptions(bctx, &bindopts);
2480 ok(hres == S_OK, "IBindCtx_GetBindOptions failed: %08x\n", hres);
2481 ok(bindopts.grfFlags == BIND_MAYBOTHERUSER,
2482 "bindopts.grfFlags = %08x, expected: BIND_MAYBOTHERUSER\n", bindopts.grfFlags);
2483 ok(bindopts.grfMode == (STGM_READWRITE | STGM_SHARE_EXCLUSIVE),
2484 "bindopts.grfMode = %08x, expected: STGM_READWRITE | STGM_SHARE_EXCLUSIVE\n",
2485 bindopts.grfMode);
2486 ok(bindopts.dwTickCountDeadline == 0,
2487 "bindopts.dwTickCountDeadline = %08x, expected: 0\n", bindopts.dwTickCountDeadline);
2488
2489 IBindCtx_Release(bctx);
2490 }
2491
2492 IBindCtx_Release(bctx_arg);
2493
2494 SET_EXPECT(QueryInterface_IServiceProvider);
2495 hres = pCreateAsyncBindCtxEx(NULL, 0, (IBindStatusCallback*)&bsc, NULL, &bctx, 0);
2496 ok(hres == S_OK, "CreateAsyncBindCtxEx failed: %08x\n", hres);
2497 CHECK_CALLED(QueryInterface_IServiceProvider);
2498
2499 hres = IBindCtx_QueryInterface(bctx, &IID_IAsyncBindCtx, (void**)&unk);
2500 ok(hres == S_OK, "QueryInterface(IID_IAsyncBindCtx) failed: %08x\n", hres);
2501 if(SUCCEEDED(hres))
2502 IUnknown_Release(unk);
2503
2504 IBindCtx_Release(bctx);
2505
2506 hres = CreateBindCtx(0, &bctx2);
2507 ok(hres == S_OK, "CreateBindCtx failed: %08x\n", hres);
2508
2509 hres = pCreateAsyncBindCtxEx(bctx2, 0, NULL, NULL, &bctx, 0);
2510 ok(hres == S_OK, "CreateAsyncBindCtxEx failed: %08x\n", hres);
2511
2512 hres = IBindCtx_RegisterObjectParam(bctx2, testW, (IUnknown*)&Protocol);
2513 ok(hres == S_OK, "RegisterObjectParam failed: %08x\n", hres);
2514
2515 hres = IBindCtx_GetObjectParam(bctx, testW, &unk);
2516 ok(hres == S_OK, "GetObjectParam failed: %08x\n", hres);
2517 ok(unk == (IUnknown*)&Protocol, "unexpected unk %p\n", unk);
2518
2519 IBindCtx_Release(bctx);
2520 IBindCtx_Release(bctx2);
2521 }
2522
2523 static void test_GetBindInfoEx(IBindStatusCallback *holder)
2524 {
2525 IBindStatusCallbackEx *bscex;
2526 BINDINFO bindinfo = {sizeof(bindinfo)};
2527 DWORD bindf, bindf2, dw;
2528 HRESULT hres;
2529
2530 hres = IBindStatusCallback_QueryInterface(holder, &IID_IBindStatusCallbackEx, (void**)&bscex);
2531 if(FAILED(hres)) {
2532 win_skip("IBindStatusCallbackEx not supported\n");
2533 return;
2534 }
2535
2536 use_bscex = TRUE;
2537
2538 bindf = 0;
2539 SET_EXPECT(QueryInterface_IBindStatusCallbackEx);
2540 SET_EXPECT(GetBindInfoEx);
2541 hres = IBindStatusCallback_GetBindInfo(holder, &bindf, &bindinfo);
2542 ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
2543 CHECK_CALLED(QueryInterface_IBindStatusCallbackEx);
2544 CHECK_CALLED(GetBindInfoEx);
2545
2546 bindf = bindf2 = dw = 0;
2547 SET_EXPECT(QueryInterface_IBindStatusCallbackEx);
2548 SET_EXPECT(GetBindInfoEx);
2549 hres = IBindStatusCallbackEx_GetBindInfoEx(bscex, &bindf, &bindinfo, &bindf2, &dw);
2550 ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
2551 CHECK_CALLED(QueryInterface_IBindStatusCallbackEx);
2552 CHECK_CALLED(GetBindInfoEx);
2553
2554 use_bscex = FALSE;
2555
2556 bindf = bindf2 = dw = 0xdeadbeef;
2557 SET_EXPECT(QueryInterface_IBindStatusCallbackEx);
2558 SET_EXPECT(GetBindInfo);
2559 hres = IBindStatusCallbackEx_GetBindInfoEx(bscex, &bindf, &bindinfo, &bindf2, &dw);
2560 ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
2561 CHECK_CALLED(QueryInterface_IBindStatusCallbackEx);
2562 CHECK_CALLED(GetBindInfo);
2563 ok(bindf2 == 0xdeadbeef, "bindf2 = %x\n", bindf2);
2564 ok(dw == 0xdeadbeef, "dw = %x\n", dw);
2565
2566 IBindStatusCallbackEx_Release(bscex);
2567 }
2568
2569 static BOOL test_bscholder(IBindStatusCallback *holder)
2570 {
2571 IServiceProvider *serv_prov;
2572 IHttpNegotiate *http_negotiate, *http_negotiate_serv;
2573 IHttpNegotiate2 *http_negotiate2, *http_negotiate2_serv;
2574 IAuthenticate *authenticate, *authenticate_serv;
2575 IInternetBindInfo *bind_info;
2576 IInternetProtocol *protocol;
2577 BINDINFO bindinfo = {sizeof(bindinfo)};
2578 BOOL ret = TRUE;
2579 LPWSTR wstr;
2580 DWORD dw;
2581 HRESULT hres;
2582
2583 hres = IBindStatusCallback_QueryInterface(holder, &IID_IServiceProvider, (void**)&serv_prov);
2584 ok(hres == S_OK, "Could not get IServiceProvider interface: %08x\n", hres);
2585
2586 dw = 0xdeadbeef;
2587 SET_EXPECT(QueryInterface_IBindStatusCallbackEx);
2588 SET_EXPECT(GetBindInfo);
2589 hres = IBindStatusCallback_GetBindInfo(holder, &dw, &bindinfo);
2590 ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
2591 CLEAR_CALLED(QueryInterface_IBindStatusCallbackEx); /* IE 8 */
2592 CHECK_CALLED(GetBindInfo);
2593
2594 test_GetBindInfoEx(holder);
2595
2596 SET_EXPECT(OnStartBinding);
2597 hres = IBindStatusCallback_OnStartBinding(holder, 0, (void*)0xdeadbeef);
2598 ok(hres == S_OK, "OnStartBinding failed: %08x\n", hres);
2599 CHECK_CALLED(OnStartBinding);
2600
2601 hres = IBindStatusCallback_QueryInterface(holder, &IID_IHttpNegotiate, (void**)&http_negotiate);
2602 ok(hres == S_OK, "Could not get IHttpNegotiate interface: %08x\n", hres);
2603
2604 SET_EXPECT(QueryInterface_IHttpNegotiate);
2605 hres = IServiceProvider_QueryService(serv_prov, &IID_IHttpNegotiate, &IID_IHttpNegotiate,
2606 (void**)&http_negotiate_serv);
2607 ok(hres == S_OK, "Could not get IHttpNegotiate service: %08x\n", hres);
2608 CLEAR_CALLED(QueryInterface_IHttpNegotiate); /* IE <8 */
2609
2610 ok(http_negotiate == http_negotiate_serv, "http_negotiate != http_negotiate_serv\n");
2611
2612 wstr = (void*)0xdeadbeef;
2613 SET_EXPECT(QueryInterface_IHttpNegotiate);
2614 SET_EXPECT(BeginningTransaction);
2615 hres = IHttpNegotiate_BeginningTransaction(http_negotiate_serv, current_url, emptyW, 0, &wstr);
2616 CHECK_CALLED_BROKEN(QueryInterface_IHttpNegotiate); /* IE8 */
2617 CHECK_CALLED(BeginningTransaction);
2618 ok(hres == S_OK, "BeginningTransaction failed: %08x\n", hres);
2619 ok(wstr == NULL, "wstr = %p\n", wstr);
2620
2621 IHttpNegotiate_Release(http_negotiate_serv);
2622
2623 hres = IServiceProvider_QueryService(serv_prov, &IID_IHttpNegotiate, &IID_IHttpNegotiate,
2624 (void**)&http_negotiate_serv);
2625 ok(hres == S_OK, "Could not get IHttpNegotiate service: %08x\n", hres);
2626 ok(http_negotiate == http_negotiate_serv, "http_negotiate != http_negotiate_serv\n");
2627 IHttpNegotiate_Release(http_negotiate_serv);
2628
2629 hres = IBindStatusCallback_QueryInterface(holder, &IID_IHttpNegotiate2, (void**)&http_negotiate2);
2630 if(SUCCEEDED(hres)) {
2631 have_IHttpNegotiate2 = TRUE;
2632
2633 SET_EXPECT(QueryInterface_IHttpNegotiate2);
2634 hres = IServiceProvider_QueryService(serv_prov, &IID_IHttpNegotiate2, &IID_IHttpNegotiate2,
2635 (void**)&http_negotiate2_serv);
2636 ok(hres == S_OK, "Could not get IHttpNegotiate2 service: %08x\n", hres);
2637 CLEAR_CALLED(QueryInterface_IHttpNegotiate2); /* IE <8 */
2638 ok(http_negotiate2 == http_negotiate2_serv, "http_negotiate != http_negotiate_serv\n");
2639
2640 SET_EXPECT(QueryInterface_IHttpNegotiate2);
2641 SET_EXPECT(GetRootSecurityId);
2642 hres = IHttpNegotiate2_GetRootSecurityId(http_negotiate2, (void*)0xdeadbeef, (void*)0xdeadbeef, 0);
2643 ok(hres == E_NOTIMPL, "GetRootSecurityId failed: %08x\n", hres);
2644 CHECK_CALLED_BROKEN(QueryInterface_IHttpNegotiate2); /* IE8 */
2645 CHECK_CALLED(GetRootSecurityId);
2646
2647 IHttpNegotiate2_Release(http_negotiate2_serv);
2648 IHttpNegotiate2_Release(http_negotiate2);
2649 }else {
2650 skip("Could not get IHttpNegotiate2\n");
2651 ret = FALSE;
2652 }
2653
2654 SET_EXPECT(OnProgress_FINDINGRESOURCE);
2655 hres = IBindStatusCallback_OnProgress(holder, 0, 0, BINDSTATUS_FINDINGRESOURCE, NULL);
2656 ok(hres == S_OK, "OnProgress failed: %08x\n", hres);
2657 CHECK_CALLED(OnProgress_FINDINGRESOURCE);
2658
2659 SET_EXPECT(QueryInterface_IHttpNegotiate);
2660 SET_EXPECT(OnResponse);
2661 wstr = (void*)0xdeadbeef;
2662 hres = IHttpNegotiate_OnResponse(http_negotiate, 200, emptyW, NULL, NULL);
2663 ok(hres == S_OK, "OnResponse failed: %08x\n", hres);
2664 CHECK_CALLED_BROKEN(QueryInterface_IHttpNegotiate); /* IE8 */
2665 CHECK_CALLED(OnResponse);
2666
2667 IHttpNegotiate_Release(http_negotiate);
2668
2669 hres = IBindStatusCallback_QueryInterface(holder, &IID_IAuthenticate, (void**)&authenticate);
2670 ok(hres == S_OK, "Could not get IAuthenticate interface: %08x\n", hres);
2671
2672 SET_EXPECT(QueryInterface_IAuthenticate);
2673 SET_EXPECT(QueryService_IAuthenticate);
2674 hres = IServiceProvider_QueryService(serv_prov, &IID_IAuthenticate, &IID_IAuthenticate,
2675 (void**)&authenticate_serv);
2676 ok(hres == S_OK, "Could not get IAuthenticate service: %08x\n", hres);
2677 CLEAR_CALLED(QueryInterface_IAuthenticate); /* IE <8 */
2678 CLEAR_CALLED(QueryService_IAuthenticate); /* IE <8 */
2679 ok(authenticate == authenticate_serv, "authenticate != authenticate_serv\n");
2680 IAuthenticate_Release(authenticate_serv);
2681
2682 hres = IServiceProvider_QueryService(serv_prov, &IID_IAuthenticate, &IID_IAuthenticate,
2683 (void**)&authenticate_serv);
2684 ok(hres == S_OK, "Could not get IAuthenticate service: %08x\n", hres);
2685 ok(authenticate == authenticate_serv, "authenticate != authenticate_serv\n");
2686
2687 IAuthenticate_Release(authenticate);
2688 IAuthenticate_Release(authenticate_serv);
2689
2690 hres = IBindStatusCallback_QueryInterface(holder, &IID_IInternetBindInfo, (void**)&bind_info);
2691 ok(hres == S_OK || broken(hres == E_NOINTERFACE /* win2k */), "Could not get IInternetBindInfo interface: %08x\n", hres);
2692
2693 if(SUCCEEDED(hres)) {
2694 hres = IInternetBindInfo_GetBindString(bind_info, BINDSTRING_USER_AGENT, &wstr, 1, &dw);
2695 ok(hres == E_NOINTERFACE, "GetBindString(BINDSTRING_USER_AGENT) failed: %08x\n", hres);
2696
2697 IInternetBindInfo_Release(bind_info);
2698 }
2699
2700 SET_EXPECT(OnStopBinding);
2701 hres = IBindStatusCallback_OnStopBinding(holder, S_OK, NULL);
2702 ok(hres == S_OK, "OnStopBinding failed: %08x\n", hres);
2703 CHECK_CALLED(OnStopBinding);
2704
2705 SET_EXPECT(QueryInterface_IInternetProtocol);
2706 SET_EXPECT(QueryService_IInternetProtocol);
2707 hres = IServiceProvider_QueryService(serv_prov, &IID_IInternetProtocol, &IID_IInternetProtocol,
2708 (void**)&protocol);
2709 ok(hres == E_NOINTERFACE, "QueryService(IInternetProtocol) failed: %08x\n", hres);
2710 CHECK_CALLED(QueryInterface_IInternetProtocol);
2711 CHECK_CALLED(QueryService_IInternetProtocol);
2712
2713 IServiceProvider_Release(serv_prov);
2714 return ret;
2715 }
2716
2717 static BOOL test_RegisterBindStatusCallback(void)
2718 {
2719 IBindStatusCallback *prevbsc, *clb, *prev_clb;
2720 IBindCtx *bindctx;
2721 BOOL ret = TRUE;
2722 IUnknown *unk;
2723 HRESULT hres;
2724
2725 strict_bsc_qi = TRUE;
2726
2727 hres = CreateBindCtx(0, &bindctx);
2728 ok(hres == S_OK, "BindCtx failed: %08x\n", hres);
2729
2730 SET_EXPECT(QueryInterface_IServiceProvider);
2731
2732 hres = IBindCtx_RegisterObjectParam(bindctx, BSCBHolder, (IUnknown*)&bsc);
2733 ok(hres == S_OK, "RegisterObjectParam failed: %08x\n", hres);
2734
2735 SET_EXPECT(QueryInterface_IBindStatusCallback);
2736 SET_EXPECT(QueryInterface_IBindStatusCallbackHolder);
2737 prevbsc = (void*)0xdeadbeef;
2738 hres = RegisterBindStatusCallback(bindctx, (IBindStatusCallback*)&bsc, &prevbsc, 0);
2739 ok(hres == S_OK, "RegisterBindStatusCallback failed: %08x\n", hres);
2740 ok(prevbsc == (IBindStatusCallback*)&bsc, "prevbsc=%p\n", prevbsc);
2741 CHECK_CALLED(QueryInterface_IBindStatusCallback);
2742 CHECK_CALLED(QueryInterface_IBindStatusCallbackHolder);
2743
2744 CHECK_CALLED(QueryInterface_IServiceProvider);
2745
2746 hres = IBindCtx_GetObjectParam(bindctx, BSCBHolder, &unk);
2747 ok(hres == S_OK, "GetObjectParam failed: %08x\n", hres);
2748
2749 hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&clb);
2750 IUnknown_Release(unk);
2751 ok(hres == S_OK, "QueryInterface(IID_IBindStatusCallback) failed: %08x\n", hres);
2752 ok(clb != (IBindStatusCallback*)&bsc, "bsc == clb\n");
2753
2754 if(!test_bscholder(clb))
2755 ret = FALSE;
2756
2757 IBindStatusCallback_Release(clb);
2758
2759 hres = RevokeBindStatusCallback(bindctx, (IBindStatusCallback*)&bsc);
2760 ok(hres == S_OK, "RevokeBindStatusCallback failed: %08x\n", hres);
2761
2762 unk = (void*)0xdeadbeef;
2763 hres = IBindCtx_GetObjectParam(bindctx, BSCBHolder, &unk);
2764 ok(hres == E_FAIL, "GetObjectParam failed: %08x\n", hres);
2765 ok(unk == NULL, "unk != NULL\n");
2766
2767 if(unk)
2768 IUnknown_Release(unk);
2769
2770 hres = RevokeBindStatusCallback(bindctx, (void*)0xdeadbeef);
2771 ok(hres == S_OK, "RevokeBindStatusCallback failed: %08x\n", hres);
2772
2773 hres = RevokeBindStatusCallback(NULL, (void*)0xdeadbeef);
2774 ok(hres == E_INVALIDARG, "RevokeBindStatusCallback failed: %08x\n", hres);
2775
2776 hres = RevokeBindStatusCallback(bindctx, NULL);
2777 ok(hres == E_INVALIDARG, "RevokeBindStatusCallback failed: %08x\n", hres);
2778
2779 SET_EXPECT(QueryInterface_IServiceProvider);
2780 prevbsc = (void*)0xdeadbeef;
2781 hres = RegisterBindStatusCallback(bindctx, (IBindStatusCallback*)&bsc, &prevbsc, 0);
2782 ok(hres == S_OK, "RegisterBindStatusCallback failed: %08x\n", hres);
2783 ok(!prevbsc, "prevbsc=%p\n", prevbsc);
2784 CHECK_CALLED(QueryInterface_IServiceProvider);
2785
2786 hres = IBindCtx_GetObjectParam(bindctx, BSCBHolder, &unk);
2787 ok(hres == S_OK, "GetObjectParam failed: %08x\n", hres);
2788
2789 hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&prev_clb);
2790 IUnknown_Release(unk);
2791 ok(hres == S_OK, "QueryInterface(IID_IBindStatusCallback) failed: %08x\n", hres);
2792 ok(prev_clb != (IBindStatusCallback*)&bsc, "bsc == clb\n");
2793
2794 SET_EXPECT(QueryInterface_IServiceProvider);
2795 prevbsc = (void*)0xdeadbeef;
2796 hres = RegisterBindStatusCallback(bindctx, (IBindStatusCallback*)&bsc2, &prevbsc, 0);
2797 ok(hres == S_OK, "RegisterBindStatusCallback failed: %08x\n", hres);
2798 ok(prevbsc == (IBindStatusCallback*)&bsc, "prevbsc != bsc\n");
2799 CHECK_CALLED(QueryInterface_IServiceProvider);
2800
2801 hres = IBindCtx_GetObjectParam(bindctx, BSCBHolder, &unk);
2802 ok(hres == S_OK, "GetObjectParam failed: %08x\n", hres);
2803
2804 hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&clb);
2805 IUnknown_Release(unk);
2806 ok(hres == S_OK, "QueryInterface(IID_IBindStatusCallback) failed: %08x\n", hres);
2807 ok(prev_clb == clb, "bsc != clb\n");
2808
2809 IBindStatusCallback_Release(clb);
2810 IBindStatusCallback_Release(prev_clb);
2811
2812 IBindCtx_Release(bindctx);
2813
2814 strict_bsc_qi = FALSE;
2815 return ret;
2816 }
2817
2818 #define BINDTEST_EMULATE 0x0001
2819 #define BINDTEST_TOOBJECT 0x0002
2820 #define BINDTEST_FILEDWLAPI 0x0004
2821 #define BINDTEST_HTTPRESPONSE 0x0008
2822 #define BINDTEST_REDIRECT 0x0010
2823 #define BINDTEST_USE_CACHE 0x0020
2824 #define BINDTEST_NO_CALLBACK_READ 0x0040
2825 #define BINDTEST_NO_CALLBACK 0x0080
2826 #define BINDTEST_ABORT 0x0100
2827 #define BINDTEST_INVALID_CN 0x0200
2828 #define BINDTEST_ABORT_START 0x0400
2829 #define BINDTEST_ABORT_PROGRESS 0x0800
2830 #define BINDTEST_ASYNC_SWITCH 0x1000
2831 #define BINDTEST_ALLOW_FINDINGRESOURCE 0x2000
2832
2833 static void init_bind_test(int protocol, DWORD flags, DWORD t)
2834 {
2835 const char *url_a = NULL;
2836
2837 test_protocol = protocol;
2838 bindtest_flags = flags;
2839 emulate_protocol = (flags & BINDTEST_EMULATE) != 0;
2840 download_state = BEFORE_DOWNLOAD;
2841 stopped_binding = FALSE;
2842 stopped_obj_binding = FALSE;
2843 data_available = FALSE;
2844 mime_type[0] = 0;
2845 binding_hres = S_OK;
2846 bind_to_object = (flags & BINDTEST_TOOBJECT) != 0;
2847 tymed = t;
2848 filedwl_api = (flags & BINDTEST_FILEDWLAPI) != 0;
2849 post_test = (flags & BINDTEST_HTTPRESPONSE) != 0;
2850
2851 switch(protocol) {
2852 case HTTP_TEST:
2853 if(post_test)
2854 url_a = "http://test.winehq.org/tests/post.php";
2855 else
2856 lstrcpyW(current_url, winetest_data_urlW);
2857 break;
2858 case ABOUT_TEST:
2859 url_a = "about:blank";
2860 break;
2861 case FILE_TEST:
2862 lstrcpyW(current_url, file_url);
2863 break;
2864 case MK_TEST:
2865 url_a = "mk:@MSITStore:test.chm::/blank.html";
2866 break;
2867 case ITS_TEST:
2868 url_a = "its:test.chm::/blank.html";
2869 break;
2870 case HTTPS_TEST:
2871 url_a = (flags & BINDTEST_INVALID_CN) ? "https://209.46.25.134/favicon.ico" : "https://test.winehq.org/tests/hello.html";
2872 break;
2873 case FTP_TEST:
2874 url_a = "ftp://ftp.winehq.org/welcome.msg";
2875 break;
2876 default:
2877 url_a = "winetest:test";
2878 }
2879
2880 if(url_a)
2881 MultiByteToWideChar(CP_ACP, 0, url_a, -1, current_url, sizeof(current_url)/sizeof(*current_url));
2882
2883 test_redirect = (flags & BINDTEST_REDIRECT) != 0;
2884 use_cache_file = (flags & BINDTEST_USE_CACHE) != 0;
2885 callback_read = !(flags & BINDTEST_NO_CALLBACK_READ);
2886 no_callback = (flags & BINDTEST_NO_CALLBACK) != 0;
2887 test_abort = (flags & BINDTEST_ABORT) != 0;
2888 abort_start = (flags & BINDTEST_ABORT_START) != 0;
2889 abort_progress = (flags & BINDTEST_ABORT_PROGRESS) != 0;
2890 async_switch = (flags & BINDTEST_ASYNC_SWITCH) != 0;
2891 is_async_prot = protocol == HTTP_TEST || protocol == HTTPS_TEST || protocol == FTP_TEST || protocol == WINETEST_TEST;
2892 prot_state = 0;
2893 ResetEvent(complete_event);
2894
2895 trace("URL: %s\n", wine_dbgstr_w(current_url));
2896 }
2897
2898 static void test_BindToStorage(int protocol, DWORD flags, DWORD t)
2899 {
2900 IMoniker *mon;
2901 HRESULT hres;
2902 LPOLESTR display_name;
2903 IBindCtx *bctx = NULL;
2904 MSG msg;
2905 IBindStatusCallback *previousclb;
2906 IUnknown *unk = (IUnknown*)0x00ff00ff;
2907 BOOL allow_finding_resource;
2908 IBinding *bind;
2909
2910 init_bind_test(protocol, flags, t);
2911 allow_finding_resource = (flags & BINDTEST_ALLOW_FINDINGRESOURCE) != 0;
2912
2913 if(no_callback) {
2914 hres = CreateBindCtx(0, &bctx);
2915 ok(hres == S_OK, "CreateBindCtx failed: %08x\n", hres);
2916 }else {
2917 SET_EXPECT(QueryInterface_IServiceProvider);
2918 hres = CreateAsyncBindCtx(0, (IBindStatusCallback*)&bsc, NULL, &bctx);
2919 ok(hres == S_OK, "CreateAsyncBindCtx failed: %08x\n\n", hres);
2920 CHECK_CALLED(QueryInterface_IServiceProvider);
2921 if(FAILED(hres))
2922 return;
2923
2924 SET_EXPECT(QueryInterface_IServiceProvider);
2925 hres = RegisterBindStatusCallback(bctx, (IBindStatusCallback*)&bsc, &previousclb, 0);
2926 ok(hres == S_OK, "RegisterBindStatusCallback failed: %08x\n", hres);
2927 ok(previousclb == (IBindStatusCallback*)&bsc, "previousclb(%p) != sclb(%p)\n", previousclb, &bsc);
2928 CHECK_CALLED(QueryInterface_IServiceProvider);
2929 if(previousclb)
2930 IBindStatusCallback_Release(previousclb);
2931 }
2932
2933 hres = CreateURLMoniker(NULL, current_url, &mon);
2934 ok(hres == S_OK, "failed to create moniker: %08x\n", hres);
2935 if(FAILED(hres))
2936 return;
2937
2938 hres = IMoniker_QueryInterface(mon, &IID_IBinding, (void**)&bind);
2939 ok(hres == E_NOINTERFACE, "IMoniker should not have IBinding interface\n");
2940 if(SUCCEEDED(hres))
2941 IBinding_Release(bind);
2942
2943 hres = IMoniker_GetDisplayName(mon, bctx, NULL, &display_name);
2944 ok(hres == S_OK, "GetDisplayName failed %08x\n", hres);
2945 ok(!lstrcmpW(display_name, current_url), "GetDisplayName got wrong name %s, expected %s\n",
2946 wine_dbgstr_w(display_name), wine_dbgstr_w(current_url));
2947 CoTaskMemFree(display_name);
2948
2949 if(tymed == TYMED_FILE && (test_protocol == ABOUT_TEST || test_protocol == ITS_TEST))
2950 binding_hres = INET_E_DATA_NOT_AVAILABLE;
2951 if((flags & BINDTEST_INVALID_CN) && !invalid_cn_accepted &&
2952 (onsecurityproblem_hres != S_OK || security_problem == ERROR_INTERNET_SEC_CERT_ERRORS)) {
2953 if(security_problem == ERROR_INTERNET_SEC_CERT_ERRORS)
2954 binding_hres = INET_E_SECURITY_PROBLEM;
2955 else
2956 binding_hres = INET_E_INVALID_CERTIFICATE;
2957 }
2958
2959
2960 if(only_check_prot_args)
2961 SET_EXPECT(OnStopBinding);
2962 if(!no_callback) {
2963 SET_EXPECT(QueryInterface_IBindStatusCallbackEx);
2964 SET_EXPECT(GetBindInfo);
2965 SET_EXPECT(QueryInterface_IInternetProtocol);
2966 if(!emulate_protocol)
2967 SET_EXPECT(QueryService_IInternetProtocol);
2968 SET_EXPECT(OnStartBinding);
2969 }
2970 if(emulate_protocol) {
2971 if(is_urlmon_protocol(test_protocol))
2972 SET_EXPECT(SetPriority);
2973 SET_EXPECT(Start);
2974 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST
2975 || test_protocol == WINETEST_SYNC_TEST)
2976 SET_EXPECT(Terminate);
2977 if(tymed != TYMED_FILE || (test_protocol != ABOUT_TEST && test_protocol != ITS_TEST))
2978 SET_EXPECT(UnlockRequest);
2979 }else {
2980 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST) {
2981 SET_EXPECT(QueryService_IInternetBindInfo);
2982 if(!abort_start)
2983 SET_EXPECT(QueryInterface_IHttpNegotiate);
2984 SET_EXPECT(QueryInterface_IWindowForBindingUI);
2985 SET_EXPECT(QueryService_IWindowForBindingUI);
2986 SET_EXPECT(GetWindow_IWindowForBindingUI);
2987 if(!abort_start) {
2988 SET_EXPECT(BeginningTransaction);
2989 SET_EXPECT(QueryInterface_IHttpNegotiate2);
2990 SET_EXPECT(GetRootSecurityId);
2991 if(http_is_first || allow_finding_resource)
2992 SET_EXPECT(OnProgress_FINDINGRESOURCE);
2993 SET_EXPECT(OnProgress_CONNECTING);
2994 }
2995 if(flags & BINDTEST_INVALID_CN) {
2996 SET_EXPECT(QueryInterface_IHttpSecurity);
2997 SET_EXPECT(QueryService_IHttpSecurity);
2998 SET_EXPECT(OnSecurityProblem);
2999 if(SUCCEEDED(onsecurityproblem_hres))
3000 SET_EXPECT(GetWindow_IHttpSecurity);
3001 }
3002 }
3003 if(!no_callback) {
3004 if((test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == FTP_TEST
3005 || test_protocol == FILE_TEST || test_protocol == WINETEST_TEST) && !abort_start)
3006 SET_EXPECT(OnProgress_SENDINGREQUEST);
3007 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST) {
3008 SET_EXPECT(QueryInterface_IHttpNegotiate);
3009 SET_EXPECT(OnResponse);
3010 }
3011 if(!abort_start) {
3012 SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
3013 SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
3014 }
3015 if(test_protocol == FILE_TEST)
3016 SET_EXPECT(OnProgress_CACHEFILENAMEAVAILABLE);
3017 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == FTP_TEST || test_protocol == WINETEST_TEST)
3018 SET_EXPECT(OnProgress_DOWNLOADINGDATA);
3019 if(!abort_start)
3020 SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
3021 if((tymed != TYMED_FILE || test_protocol != ABOUT_TEST) && !abort_start)
3022 SET_EXPECT(OnDataAvailable);
3023 SET_EXPECT(OnStopBinding);
3024 }
3025 }
3026
3027 hres = IMoniker_BindToStorage(mon, bctx, NULL, tymed == TYMED_ISTREAM ? &IID_IStream : &IID_IUnknown, (void**)&unk);
3028 if ((test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3029 && hres == HRESULT_FROM_WIN32(ERROR_INTERNET_NAME_NOT_RESOLVED))
3030 {
3031 skip("Network unreachable, skipping tests\n");
3032 return;
3033 }
3034
3035 if(only_check_prot_args) {
3036 ok(hres == E_FAIL, "Got %08x\n", hres);
3037 CHECK_CALLED(OnStopBinding);
3038 } else if(abort_start)
3039 ok(hres == abort_hres, "IMoniker_BindToStorage failed: %08x, expected %08x\n", hres, abort_hres);
3040 else if(abort_progress)
3041 ok(hres == MK_S_ASYNCHRONOUS, "IMoniker_BindToStorage failed: %08x\n", hres);
3042 else if(no_callback) {
3043 if(emulate_protocol)
3044 ok( WaitForSingleObject(complete_event2, 90000) == WAIT_OBJECT_0, "wait timed out\n" );
3045 ok(hres == S_OK, "IMoniker_BindToStorage failed: %08x\n", hres);
3046 ok(unk != NULL, "unk == NULL\n");
3047 }else if(!(bindf & BINDF_ASYNCHRONOUS) && tymed == TYMED_FILE) {
3048 ok(hres == S_OK, "IMoniker_BindToStorage failed: %08x\n", hres);
3049 ok(unk == NULL, "unk != NULL\n");
3050 }else if(((bindf & BINDF_ASYNCHRONOUS) && !data_available)
3051 || (tymed == TYMED_FILE && test_protocol == FILE_TEST)) {
3052 ok(hres == MK_S_ASYNCHRONOUS, "IMoniker_BindToStorage failed: %08x\n", hres);
3053 ok(unk == NULL, "istr should be NULL\n");
3054 }else if(tymed == TYMED_FILE && test_protocol == ABOUT_TEST) {
3055 ok(hres == INET_E_DATA_NOT_AVAILABLE,
3056 "IMoniker_BindToStorage failed: %08x, expected INET_E_DATA_NOT_AVAILABLE\n", hres);
3057 ok(unk == NULL, "istr should be NULL\n");
3058 }else if((flags & BINDTEST_INVALID_CN) && binding_hres != S_OK) {
3059 ok(hres == binding_hres, "Got %08x\n", hres);
3060 ok(unk == NULL, "Got %p\n", unk);
3061 }else if((flags & BINDTEST_INVALID_CN) && invalid_cn_accepted) {
3062 ok(hres == S_OK, "IMoniker_BindToStorage failed: %08x\n", hres);
3063 ok(unk != NULL, "unk == NULL\n");
3064 if(unk == NULL) {
3065 ok(0, "Expected security problem to be ignored.\n");
3066 invalid_cn_accepted = FALSE;
3067 binding_hres = INET_E_INVALID_CERTIFICATE;
3068 }
3069 }else {
3070 ok(hres == S_OK, "IMoniker_BindToStorage failed: %08x\n", hres);
3071 ok(unk != NULL, "unk == NULL\n");
3072 }
3073 if(unk && callback_read && !no_callback) {
3074 IUnknown_Release(unk);
3075 unk = NULL;
3076 }
3077
3078 if(FAILED(hres) && !(flags & BINDTEST_INVALID_CN) && !(flags & BINDTEST_ABORT_START))
3079 return;
3080
3081 if((bindf & BINDF_ASYNCHRONOUS) && !no_callback) {
3082 while(!stopped_binding && GetMessageA(&msg,NULL,0,0)) {
3083 TranslateMessage(&msg);
3084 DispatchMessageA(&msg);
3085 }
3086 }
3087
3088 if(async_switch) {
3089 CHECK_CALLED(OnProgress_SENDINGREQUEST);
3090 CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
3091 CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
3092 CHECK_CALLED(LockRequest);
3093 CHECK_CALLED(OnStopBinding);
3094 }
3095 if(!no_callback) {
3096 CLEAR_CALLED(QueryInterface_IBindStatusCallbackEx); /* IE 8 */
3097 CHECK_CALLED(GetBindInfo);
3098 todo_wine_if(abort_start)
3099 CHECK_CALLED(QueryInterface_IInternetProtocol);
3100 if(!emulate_protocol) {
3101 todo_wine_if(abort_start)
3102 CHECK_CALLED(QueryService_IInternetProtocol);
3103 }
3104 CHECK_CALLED(OnStartBinding);
3105 }
3106 if(emulate_protocol) {
3107 if(is_urlmon_protocol(test_protocol))
3108 CLEAR_CALLED(SetPriority); /* Not called by IE11 */
3109 CHECK_CALLED(Start);
3110 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST
3111 || test_protocol == WINETEST_SYNC_TEST) {
3112 if(tymed == TYMED_FILE)
3113 CLEAR_CALLED(Read);
3114 CHECK_CALLED(Terminate);
3115 }
3116 if(tymed != TYMED_FILE || (test_protocol != ABOUT_TEST && test_protocol != ITS_TEST))
3117 CHECK_CALLED(UnlockRequest);
3118 }else {
3119 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST) {
3120 CLEAR_CALLED(QueryService_IInternetBindInfo);
3121 if(!abort_start)
3122 CHECK_CALLED(QueryInterface_IHttpNegotiate);
3123 CLEAR_CALLED(QueryInterface_IWindowForBindingUI);
3124 CLEAR_CALLED(QueryService_IWindowForBindingUI);
3125 CLEAR_CALLED(GetWindow_IWindowForBindingUI);
3126 if(!abort_start)
3127 CHECK_CALLED(BeginningTransaction);
3128 if (have_IHttpNegotiate2 && !abort_start)
3129 {
3130 CHECK_CALLED(QueryInterface_IHttpNegotiate2);
3131 CHECK_CALLED(GetRootSecurityId);
3132 }
3133 if(http_is_first) {
3134 if (! proxy_active())
3135 {
3136 CHECK_CALLED(OnProgress_FINDINGRESOURCE);
3137 CHECK_CALLED(OnProgress_CONNECTING);
3138 }
3139 else
3140 {
3141 CLEAR_CALLED(OnProgress_FINDINGRESOURCE);
3142 CLEAR_CALLED(OnProgress_CONNECTING);
3143 }
3144 }else if(!abort_start) {
3145 if(allow_finding_resource)
3146 CLEAR_CALLED(OnProgress_FINDINGRESOURCE);
3147 /* IE7 does call this */
3148 CLEAR_CALLED(OnProgress_CONNECTING);
3149 }
3150 if((flags & BINDTEST_INVALID_CN) && !invalid_cn_accepted) {
3151 CHECK_CALLED(QueryInterface_IHttpSecurity);
3152 CHECK_CALLED(QueryService_IHttpSecurity);
3153 CHECK_CALLED(OnSecurityProblem);
3154 }else {
3155 CHECK_NOT_CALLED(QueryInterface_IHttpSecurity);
3156 CHECK_NOT_CALLED(QueryService_IHttpSecurity);
3157 CHECK_NOT_CALLED(OnSecurityProblem);
3158 }
3159 }
3160 if(!no_callback) {
3161 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == FILE_TEST || test_protocol == WINETEST_TEST) {
3162 if(flags & BINDTEST_INVALID_CN)
3163 CLEAR_CALLED(OnProgress_SENDINGREQUEST);
3164 else if(!abort_start)
3165 CHECK_CALLED(OnProgress_SENDINGREQUEST);
3166 } else if(test_protocol == FTP_TEST)
3167 todo_wine CHECK_CALLED(OnProgress_SENDINGREQUEST);
3168 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST) {
3169 CLEAR_CALLED(QueryInterface_IHttpNegotiate);
3170 if((!(flags & BINDTEST_INVALID_CN) || (binding_hres == S_OK)) && !abort_start) {
3171 CHECK_CALLED(OnResponse);
3172 }
3173 }
3174 if((!(flags & BINDTEST_INVALID_CN) || binding_hres == S_OK) && !abort_start) {
3175 CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
3176 CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
3177 CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
3178 }
3179 if(test_protocol == FILE_TEST)
3180 CHECK_CALLED(OnProgress_CACHEFILENAMEAVAILABLE);
3181 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == FTP_TEST || test_protocol == WINETEST_TEST)
3182 CLEAR_CALLED(OnProgress_DOWNLOADINGDATA);
3183 if((flags & BINDTEST_INVALID_CN)) {
3184 if(binding_hres == S_OK)
3185 CHECK_CALLED(OnDataAvailable);
3186 else
3187 CHECK_NOT_CALLED(OnDataAvailable);
3188 }else if((tymed != TYMED_FILE || test_protocol != ABOUT_TEST) && !abort_start)
3189 CHECK_CALLED(OnDataAvailable);
3190 CHECK_CALLED(OnStopBinding);
3191 }
3192 }
3193
3194 ok(IMoniker_Release(mon) == 0, "mon should be destroyed here\n");
3195 if(bctx)
3196 ok(IBindCtx_Release(bctx) == 0, "bctx should be destroyed here\n");
3197
3198 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3199 http_is_first = FALSE;
3200
3201 if((flags & BINDTEST_INVALID_CN) && onsecurityproblem_hres == S_OK && security_problem != ERROR_INTERNET_SEC_CERT_ERRORS)
3202 invalid_cn_accepted = TRUE;
3203
3204 if(unk) {
3205 BYTE buf[512];
3206 DWORD readed;
3207 IStream *stream;
3208
3209 hres = IUnknown_QueryInterface(unk, &IID_IStream, (void**)&stream);
3210 ok(hres == S_OK, "Could not get IStream iface: %08x\n", hres);
3211 IUnknown_Release(unk);
3212
3213 do {
3214 readed = 0xdeadbeef;
3215 hres = IStream_Read(stream, buf, sizeof(buf), &readed);
3216 ok(readed != 0xdeadbeef, "readed = 0xdeadbeef\n");
3217 if(emulate_protocol && test_protocol == HTTP_TEST && readed)
3218 ok(buf[0] == (use_cache_file && !(bindf&BINDF_ASYNCHRONOUS) ? 'X' : '?'), "buf[0] = '%c'\n", buf[0]);
3219 }while(hres == S_OK);
3220 ok(hres == S_FALSE, "IStream_Read returned %08x\n", hres);
3221 ok(!readed, "readed = %d\n", readed);
3222
3223 IStream_Release(stream);
3224 }
3225 }
3226
3227 static void test_BindToObject(int protocol, DWORD flags, HRESULT exhres)
3228 {
3229 IMoniker *mon;
3230 HRESULT hres;
3231 LPOLESTR display_name;
3232 IBindCtx *bctx;
3233 DWORD regid;
3234 MSG msg;
3235 IUnknown *unk = (IUnknown*)0x00ff00ff;
3236 IBinding *bind;
3237
3238 init_bind_test(protocol, BINDTEST_TOOBJECT|flags, TYMED_ISTREAM);
3239 binding_hres = exhres;
3240
3241 if(emulate_protocol)
3242 CoRegisterClassObject(&CLSID_HTMLDocument, (IUnknown *)&mime_cf,
3243 CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
3244
3245 SET_EXPECT(QueryInterface_IServiceProvider);
3246 hres = CreateAsyncBindCtx(0, (IBindStatusCallback*)&objbsc, NULL, &bctx);
3247 ok(hres == S_OK, "CreateAsyncBindCtx failed: %08x\n\n", hres);
3248 CHECK_CALLED(QueryInterface_IServiceProvider);
3249 if(FAILED(hres))
3250 return;
3251
3252 hres = CreateURLMoniker(NULL, current_url, &mon);
3253 ok(hres == S_OK, "failed to create moniker: %08x\n", hres);
3254 if(FAILED(hres)) {
3255 IBindCtx_Release(bctx);
3256 return;
3257 }
3258
3259 hres = IMoniker_QueryInterface(mon, &IID_IBinding, (void**)&bind);
3260 ok(hres == E_NOINTERFACE, "IMoniker should not have IBinding interface\n");
3261 if(SUCCEEDED(hres))
3262 IBinding_Release(bind);
3263
3264 hres = IMoniker_GetDisplayName(mon, bctx, NULL, &display_name);
3265 ok(hres == S_OK, "GetDisplayName failed %08x\n", hres);
3266 ok(!lstrcmpW(display_name, current_url), "GetDisplayName got wrong name\n");
3267 CoTaskMemFree(display_name);
3268
3269 SET_EXPECT(QueryInterface_IBindStatusCallbackEx);
3270 SET_EXPECT(Obj_GetBindInfo);
3271 SET_EXPECT(QueryInterface_IInternetProtocol);
3272 if(!emulate_protocol)
3273 SET_EXPECT(QueryService_IInternetProtocol);
3274 SET_EXPECT(Obj_OnStartBinding);
3275 if(emulate_protocol) {
3276 if(is_urlmon_protocol(test_protocol))
3277 SET_EXPECT(SetPriority);
3278 SET_EXPECT(Start);
3279 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3280 SET_EXPECT(Terminate);
3281 if(test_protocol == FILE_TEST)
3282 SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
3283 SET_EXPECT(UnlockRequest);
3284 }else {
3285 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
3286 SET_EXPECT(QueryInterface_IHttpNegotiate);
3287 SET_EXPECT(BeginningTransaction);
3288 SET_EXPECT(QueryInterface_IHttpNegotiate2);
3289 SET_EXPECT(GetRootSecurityId);
3290 if(http_is_first)
3291 SET_EXPECT(Obj_OnProgress_FINDINGRESOURCE);
3292 SET_EXPECT(Obj_OnProgress_CONNECTING);
3293 SET_EXPECT(QueryInterface_IWindowForBindingUI);
3294 SET_EXPECT(QueryService_IWindowForBindingUI);
3295 SET_EXPECT(GetWindow_IWindowForBindingUI);
3296 }
3297 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == FILE_TEST)
3298 SET_EXPECT(Obj_OnProgress_SENDINGREQUEST);
3299 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
3300 SET_EXPECT(QueryInterface_IHttpNegotiate);
3301 SET_EXPECT(OnResponse);
3302 }
3303 SET_EXPECT(Obj_OnProgress_MIMETYPEAVAILABLE);
3304 SET_EXPECT(Obj_OnProgress_BEGINDOWNLOADDATA);
3305 if(test_protocol == FILE_TEST)
3306 SET_EXPECT(Obj_OnProgress_CACHEFILENAMEAVAILABLE);
3307 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3308 SET_EXPECT(OnProgress_DOWNLOADINGDATA);
3309 SET_EXPECT(Obj_OnProgress_ENDDOWNLOADDATA);
3310 if(SUCCEEDED(hres))
3311 SET_EXPECT(Obj_OnProgress_CLASSIDAVAILABLE);
3312 SET_EXPECT(Obj_OnProgress_BEGINSYNCOPERATION);
3313 if(exhres == REGDB_E_CLASSNOTREG) {
3314 SET_EXPECT(QueryInterface_IWindowForBindingUI);
3315 SET_EXPECT(QueryService_IWindowForBindingUI);
3316 SET_EXPECT(GetWindow_ICodeInstall);
3317 }
3318 SET_EXPECT(Obj_OnProgress_ENDSYNCOPERATION);
3319 if(SUCCEEDED(hres))
3320 SET_EXPECT(OnObjectAvailable);
3321 SET_EXPECT(Obj_OnStopBinding);
3322 }
3323
3324 hres = IMoniker_BindToObject(mon, bctx, NULL, &IID_IUnknown, (void**)&unk);
3325
3326 if ((test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3327 && hres == HRESULT_FROM_WIN32(ERROR_INTERNET_NAME_NOT_RESOLVED))
3328 {
3329 skip( "Network unreachable, skipping tests\n" );
3330 return;
3331 }
3332
3333 if(FAILED(exhres)) {
3334 ok(hres == exhres, "BindToObject failed: %08x, expected %08x\n", hres, exhres);
3335 ok(!unk, "unk = %p, expected NULL\n", unk);
3336 }else if(bindf & BINDF_ASYNCHRONOUS) {
3337 ok(hres == MK_S_ASYNCHRONOUS, "IMoniker_BindToObject failed: %08x\n", hres);
3338 ok(unk == NULL, "istr should be NULL\n");
3339 }else {
3340 ok(hres == S_OK, "IMoniker_BindToStorage failed: %08x\n", hres);
3341 ok(unk != NULL, "unk == NULL\n");
3342 if(emulate_protocol)
3343 ok(unk == (IUnknown*)&PersistMoniker, "unk != PersistMoniker\n");
3344 }
3345 if(unk)
3346 IUnknown_Release(unk);
3347
3348 while((bindf & BINDF_ASYNCHRONOUS) &&
3349 !((!emulate_protocol || stopped_binding) && stopped_obj_binding) && GetMessageA(&msg,NULL,0,0)) {
3350 TranslateMessage(&msg);
3351 DispatchMessageA(&msg);
3352 }
3353
3354 CLEAR_CALLED(QueryInterface_IBindStatusCallbackEx);
3355 CHECK_CALLED(Obj_GetBindInfo);
3356 CHECK_CALLED(QueryInterface_IInternetProtocol);
3357 if(!emulate_protocol)
3358 CHECK_CALLED(QueryService_IInternetProtocol);
3359 CHECK_CALLED(Obj_OnStartBinding);
3360 if(emulate_protocol) {
3361 if(is_urlmon_protocol(test_protocol))
3362 CLEAR_CALLED(SetPriority); /* Not called by IE11 */
3363 CHECK_CALLED(Start);
3364 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3365 CHECK_CALLED(Terminate);
3366 if(test_protocol == FILE_TEST)
3367 CLEAR_CALLED(OnProgress_MIMETYPEAVAILABLE); /* not called in IE7 */
3368 CHECK_CALLED(UnlockRequest);
3369 }else {
3370 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
3371 CHECK_CALLED(QueryInterface_IHttpNegotiate);
3372 CHECK_CALLED(BeginningTransaction);
3373 if (have_IHttpNegotiate2)
3374 {
3375 CHECK_CALLED(QueryInterface_IHttpNegotiate2);
3376 CHECK_CALLED(GetRootSecurityId);
3377 }
3378 if(http_is_first) {
3379 CHECK_CALLED(Obj_OnProgress_FINDINGRESOURCE);
3380 CHECK_CALLED(Obj_OnProgress_CONNECTING);
3381 }else {
3382 /* IE7 does call this */
3383 CLEAR_CALLED(Obj_OnProgress_CONNECTING);
3384 }
3385 CLEAR_CALLED(QueryInterface_IWindowForBindingUI);
3386 CLEAR_CALLED(QueryService_IWindowForBindingUI);
3387 CLEAR_CALLED(GetWindow_IWindowForBindingUI);
3388 }
3389 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == FILE_TEST) {
3390 if(post_test)
3391 CLEAR_CALLED(Obj_OnProgress_SENDINGREQUEST);
3392 else
3393 CHECK_CALLED(Obj_OnProgress_SENDINGREQUEST);
3394 }
3395 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
3396 CLEAR_CALLED(QueryInterface_IHttpNegotiate);
3397 CHECK_CALLED(OnResponse);
3398 }
3399 CHECK_CALLED(Obj_OnProgress_MIMETYPEAVAILABLE);
3400 CHECK_CALLED(Obj_OnProgress_BEGINDOWNLOADDATA);
3401 if(test_protocol == FILE_TEST)
3402 CHECK_CALLED(Obj_OnProgress_CACHEFILENAMEAVAILABLE);
3403 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3404 CLEAR_CALLED(OnProgress_DOWNLOADINGDATA);
3405 CLEAR_CALLED(Obj_OnProgress_ENDDOWNLOADDATA);
3406 if(SUCCEEDED(hres))
3407 CHECK_CALLED(Obj_OnProgress_CLASSIDAVAILABLE);
3408 CHECK_CALLED(Obj_OnProgress_BEGINSYNCOPERATION);
3409 if(exhres == REGDB_E_CLASSNOTREG) {
3410 todo_wine CHECK_CALLED(QueryInterface_IWindowForBindingUI);
3411 todo_wine CHECK_CALLED(QueryService_IWindowForBindingUI);
3412 todo_wine CHECK_CALLED(GetWindow_ICodeInstall);
3413 }
3414 CHECK_CALLED(Obj_OnProgress_ENDSYNCOPERATION);
3415 if(SUCCEEDED(hres))
3416 CHECK_CALLED(OnObjectAvailable);
3417 CHECK_CALLED(Obj_OnStopBinding);
3418 }
3419
3420 ok(IMoniker_Release(mon) == 0, "mon should be destroyed here\n");
3421 IBindCtx_Release(bctx);
3422
3423 if(emulate_protocol)
3424 CoRevokeClassObject(regid);
3425
3426 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3427 http_is_first = FALSE;
3428 }
3429
3430 static void test_URLDownloadToFile(DWORD prot, BOOL emul)
3431 {
3432 BOOL res;
3433 HRESULT hres;
3434
3435 init_bind_test(prot, BINDTEST_FILEDWLAPI | (emul ? BINDTEST_EMULATE : 0), TYMED_FILE);
3436
3437 SET_EXPECT(GetBindInfo);
3438 SET_EXPECT(QueryInterface_IInternetProtocol);
3439 SET_EXPECT(QueryInterface_IServiceProvider);
3440 if(!emulate_protocol)
3441 SET_EXPECT(QueryService_IInternetProtocol);
3442 SET_EXPECT(OnStartBinding);
3443 if(emulate_protocol) {
3444 if(is_urlmon_protocol(test_protocol))
3445 SET_EXPECT(SetPriority);
3446 SET_EXPECT(Start);
3447 SET_EXPECT(UnlockRequest);
3448 }else {
3449 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
3450 SET_EXPECT(QueryInterface_IHttpNegotiate);
3451 SET_EXPECT(BeginningTransaction);
3452 SET_EXPECT(QueryInterface_IHttpNegotiate2);
3453 SET_EXPECT(GetRootSecurityId);
3454 SET_EXPECT(QueryInterface_IWindowForBindingUI);
3455 SET_EXPECT(OnProgress_CONNECTING);
3456 }
3457 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == FILE_TEST)
3458 SET_EXPECT(OnProgress_SENDINGREQUEST);
3459 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
3460 SET_EXPECT(QueryInterface_IHttpNegotiate);
3461 SET_EXPECT(OnResponse);
3462 }
3463 SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
3464 SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
3465 if(test_protocol == FILE_TEST)
3466 SET_EXPECT(OnProgress_CACHEFILENAMEAVAILABLE);
3467 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3468 SET_EXPECT(OnProgress_DOWNLOADINGDATA);
3469 SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
3470 SET_EXPECT(OnStopBinding);
3471 }
3472
3473 hres = URLDownloadToFileW(NULL, current_url, dwl_htmlW, 0, (IBindStatusCallback*)&bsc);
3474 ok(hres == S_OK, "URLDownloadToFile failed: %08x\n", hres);
3475
3476 CHECK_CALLED(GetBindInfo);
3477 CHECK_CALLED(QueryInterface_IInternetProtocol);
3478 if(!emulate_protocol) {
3479 CHECK_CALLED(QueryInterface_IServiceProvider);
3480 CHECK_CALLED(QueryService_IInternetProtocol);
3481 }else {
3482 CLEAR_CALLED(QueryInterface_IServiceProvider);
3483 }
3484 CHECK_CALLED(OnStartBinding);
3485 if(emulate_protocol) {
3486 if(is_urlmon_protocol(test_protocol))
3487 CLEAR_CALLED(SetPriority); /* Not called by IE11 */
3488 CHECK_CALLED(Start);
3489 CHECK_CALLED(UnlockRequest);
3490 }else {
3491 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
3492 CHECK_CALLED(QueryInterface_IHttpNegotiate);
3493 CHECK_CALLED(BeginningTransaction);
3494 if (have_IHttpNegotiate2)
3495 {
3496 CHECK_CALLED(QueryInterface_IHttpNegotiate2);
3497 CHECK_CALLED(GetRootSecurityId);
3498 }
3499 CLEAR_CALLED(QueryInterface_IWindowForBindingUI);
3500 CLEAR_CALLED(OnProgress_CONNECTING);
3501 }
3502 if(test_protocol == FILE_TEST)
3503 CHECK_CALLED(OnProgress_SENDINGREQUEST);
3504 else if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3505 CLEAR_CALLED(OnProgress_SENDINGREQUEST); /* not called by IE7 */
3506 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
3507 CLEAR_CALLED(QueryInterface_IHttpNegotiate);
3508 CHECK_CALLED(OnResponse);
3509 }
3510 CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
3511 CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
3512 if(test_protocol == FILE_TEST)
3513 CHECK_CALLED(OnProgress_CACHEFILENAMEAVAILABLE);
3514 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3515 CLEAR_CALLED(OnProgress_DOWNLOADINGDATA);
3516 CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
3517 CHECK_CALLED(OnStopBinding);
3518 }
3519
3520 res = DeleteFileA(dwl_htmlA);
3521 ok(res, "DeleteFile failed: %u\n", GetLastError());
3522
3523 if(prot != FILE_TEST || emul)
3524 return;
3525
3526 hres = URLDownloadToFileW(NULL, current_url, dwl_htmlW, 0, NULL);
3527 ok(hres == S_OK, "URLDownloadToFile failed: %08x\n", hres);
3528
3529 res = DeleteFileA(dwl_htmlA);
3530 ok(res, "DeleteFile failed: %u\n", GetLastError());
3531 }
3532
3533 static void test_URLDownloadToFile_abort(void)
3534 {
3535 HRESULT hres;
3536
3537 init_bind_test(HTTP_TEST, BINDTEST_FILEDWLAPI|BINDTEST_ABORT_PROGRESS, TYMED_FILE);
3538
3539 SET_EXPECT(GetBindInfo);
3540 SET_EXPECT(QueryInterface_IInternetProtocol);
3541 SET_EXPECT(QueryInterface_IServiceProvider);
3542 SET_EXPECT(QueryService_IInternetProtocol);
3543 SET_EXPECT(OnStartBinding);
3544 SET_EXPECT(QueryInterface_IHttpNegotiate);
3545 SET_EXPECT(QueryInterface_IHttpNegotiate2);
3546 SET_EXPECT(BeginningTransaction);
3547 SET_EXPECT(GetRootSecurityId);
3548 SET_EXPECT(QueryInterface_IWindowForBindingUI);
3549 SET_EXPECT(OnProgress_CONNECTING);
3550 SET_EXPECT(OnProgress_SENDINGREQUEST);
3551 SET_EXPECT(OnStopBinding);
3552
3553 hres = URLDownloadToFileW(NULL, current_url, dwl_htmlW, 0, (IBindStatusCallback*)&bsc);
3554 ok(hres == E_ABORT, "URLDownloadToFile failed: %08x, expected E_ABORT\n", hres);
3555
3556 CHECK_CALLED(GetBindInfo);
3557 CHECK_CALLED(QueryInterface_IInternetProtocol);
3558 CHECK_CALLED(QueryInterface_IServiceProvider);
3559 CHECK_CALLED(QueryService_IInternetProtocol);
3560 CHECK_CALLED(OnStartBinding);
3561 CHECK_CALLED(QueryInterface_IHttpNegotiate);
3562 CHECK_CALLED(QueryInterface_IHttpNegotiate2);
3563 CHECK_CALLED(BeginningTransaction);
3564 CHECK_CALLED(GetRootSecurityId);
3565 CLEAR_CALLED(QueryInterface_IWindowForBindingUI);
3566 CHECK_CALLED(OnProgress_SENDINGREQUEST);
3567 CLEAR_CALLED(OnProgress_CONNECTING);
3568 CHECK_CALLED(OnStopBinding);
3569
3570 init_bind_test(HTTP_TEST, BINDTEST_FILEDWLAPI|BINDTEST_ABORT_START, TYMED_FILE);
3571
3572 SET_EXPECT(GetBindInfo);
3573 SET_EXPECT(QueryInterface_IInternetProtocol);
3574 SET_EXPECT(QueryInterface_IServiceProvider);
3575 SET_EXPECT(QueryService_IInternetProtocol);
3576 SET_EXPECT(OnStartBinding);
3577 SET_EXPECT(OnStopBinding);
3578
3579 abort_hres = E_ABORT;
3580 hres = URLDownloadToFileW(NULL, current_url, dwl_htmlW, 0, (IBindStatusCallback*)&bsc);
3581 ok(hres == E_ABORT, "URLDownloadToFile failed: %08x, expected E_ABORT\n", hres);
3582
3583 CHECK_CALLED(GetBindInfo);
3584 todo_wine CHECK_CALLED(QueryInterface_IInternetProtocol);
3585 todo_wine CHECK_CALLED(QueryInterface_IServiceProvider);
3586 todo_wine CHECK_CALLED(QueryService_IInternetProtocol);
3587 CHECK_CALLED(OnStartBinding);
3588 CHECK_CALLED(OnStopBinding);
3589
3590 init_bind_test(HTTP_TEST, BINDTEST_FILEDWLAPI|BINDTEST_ABORT_START, TYMED_FILE);
3591
3592 SET_EXPECT(GetBindInfo);
3593 SET_EXPECT(QueryInterface_IInternetProtocol);
3594 SET_EXPECT(QueryInterface_IServiceProvider);
3595 SET_EXPECT(QueryService_IInternetProtocol);
3596 SET_EXPECT(OnStartBinding);
3597 SET_EXPECT(QueryInterface_IHttpNegotiate);
3598 SET_EXPECT(QueryInterface_IHttpNegotiate2);
3599 SET_EXPECT(BeginningTransaction);
3600 SET_EXPECT(GetRootSecurityId);
3601 SET_EXPECT(QueryInterface_IWindowForBindingUI);
3602 SET_EXPECT(OnResponse);
3603 SET_EXPECT(OnProgress_CONNECTING);
3604 SET_EXPECT(OnProgress_SENDINGREQUEST);
3605 SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
3606 SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
3607 SET_EXPECT(OnProgress_DOWNLOADINGDATA);
3608 SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
3609 SET_EXPECT(OnStopBinding);
3610
3611 /* URLDownloadToFile doesn't abort if E_NOTIMPL is returned from the
3612 * IBindStatusCallback's OnStartBinding function.
3613 */
3614 abort_hres = E_NOTIMPL;
3615 hres = URLDownloadToFileW(NULL, current_url, dwl_htmlW, 0, (IBindStatusCallback*)&bsc);
3616 ok(hres == S_OK, "URLDownloadToFile failed: %08x\n", hres);
3617
3618 CHECK_CALLED(GetBindInfo);
3619 CHECK_CALLED(QueryInterface_IInternetProtocol);
3620 CHECK_CALLED(QueryInterface_IServiceProvider);
3621 CHECK_CALLED(QueryService_IInternetProtocol);
3622 CHECK_CALLED(OnStartBinding);
3623 CHECK_CALLED(QueryInterface_IHttpNegotiate);
3624 CHECK_CALLED(QueryInterface_IHttpNegotiate2);
3625 CHECK_CALLED(BeginningTransaction);
3626 CHECK_CALLED(GetRootSecurityId);
3627 CLEAR_CALLED(QueryInterface_IWindowForBindingUI);
3628 CHECK_CALLED(OnResponse);
3629 CLEAR_CALLED(OnProgress_CONNECTING);
3630 CHECK_CALLED(OnProgress_SENDINGREQUEST);
3631 CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
3632 CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
3633 CHECK_CALLED(OnProgress_DOWNLOADINGDATA);
3634 CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
3635 CHECK_CALLED(OnStopBinding);
3636
3637 DeleteFileA(dwl_htmlA);
3638 }
3639
3640 static void set_file_url(char *path)
3641 {
3642 CHAR file_urlA[INTERNET_MAX_URL_LENGTH];
3643
3644 lstrcpyA(file_urlA, "file://");
3645 lstrcatA(file_urlA, path);
3646 MultiByteToWideChar(CP_ACP, 0, file_urlA, -1, file_url, INTERNET_MAX_URL_LENGTH);
3647 }
3648
3649 static void create_file(const char *file_name, const char *content)
3650 {
3651 HANDLE file;
3652 DWORD size;
3653 CHAR path[MAX_PATH];
3654
3655 file = CreateFileA(file_name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
3656 FILE_ATTRIBUTE_NORMAL, NULL);
3657 ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n");
3658 if(file == INVALID_HANDLE_VALUE)
3659 return;
3660
3661 if(test_file)
3662 DeleteFileA(test_file);
3663 test_file = file_name;
3664 WriteFile(file, content, strlen(content), &size, NULL);
3665 CloseHandle(file);
3666
3667 GetCurrentDirectoryA(MAX_PATH, path);
3668 lstrcatA(path, "\\");
3669 lstrcatA(path, file_name);
3670 set_file_url(path);
3671 }
3672
3673 static void create_html_file(void)
3674 {
3675 create_file(wszIndexHtmlA, "<HTML></HTML>");
3676 }
3677
3678 static void create_cache_file(void)
3679 {
3680 char buf[6500], curdir[MAX_PATH];
3681 HANDLE file;
3682 DWORD size;
3683
3684 file = CreateFileA(test_txtA, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
3685 FILE_ATTRIBUTE_NORMAL, NULL);
3686 ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n");
3687 if(file == INVALID_HANDLE_VALUE)
3688 return;
3689
3690 memset(buf, 'X', sizeof(buf));
3691 WriteFile(file, buf, sizeof(buf), &size, NULL);
3692 CloseHandle(file);
3693
3694 memset(curdir, 0, sizeof(curdir));
3695 GetCurrentDirectoryA(MAX_PATH, curdir);
3696 lstrcatA(curdir, "\\");
3697 lstrcatA(curdir, test_txtA);
3698
3699 MultiByteToWideChar(CP_ACP, 0, curdir, -1, cache_file_name, MAX_PATH);
3700 }
3701
3702 static void test_ReportResult(HRESULT exhres)
3703 {
3704 IMoniker *mon = NULL;
3705 IBindCtx *bctx = NULL;
3706 IUnknown *unk = (void*)0xdeadbeef;
3707 HRESULT hres;
3708
3709 init_bind_test(ABOUT_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
3710 binding_hres = exhres;
3711
3712 hres = CreateURLMoniker(NULL, about_blankW, &mon);
3713 ok(hres == S_OK, "CreateURLMoniker failed: %08x\n", hres);
3714
3715 SET_EXPECT(QueryInterface_IServiceProvider);
3716 hres = CreateAsyncBindCtx(0, (IBindStatusCallback*)&bsc, NULL, &bctx);
3717 ok(hres == S_OK, "CreateAsyncBindCtx failed: %08x\n\n", hres);
3718 CHECK_CALLED(QueryInterface_IServiceProvider);
3719
3720 SET_EXPECT(QueryInterface_IBindStatusCallbackEx);
3721 SET_EXPECT(GetBindInfo);
3722 SET_EXPECT(QueryInterface_IInternetProtocol);
3723 SET_EXPECT(OnStartBinding);
3724 if(is_urlmon_protocol(test_protocol))
3725 SET_EXPECT(SetPriority);
3726 SET_EXPECT(Start);
3727
3728 hres = IMoniker_BindToStorage(mon, bctx, NULL, &IID_IStream, (void**)&unk);
3729 if(SUCCEEDED(exhres))
3730 ok(hres == S_OK || hres == MK_S_ASYNCHRONOUS, "BindToStorage failed: %08x\n", hres);
3731 else
3732 ok(hres == exhres || hres == MK_S_ASYNCHRONOUS,
3733 "BindToStorage failed: %08x, expected %08x or MK_S_ASYNCHRONOUS\n", hres, exhres);
3734
3735 CLEAR_CALLED(QueryInterface_IBindStatusCallbackEx); /* IE 8 */
3736 CHECK_CALLED(GetBindInfo);
3737 CHECK_CALLED(QueryInterface_IInternetProtocol);
3738 CHECK_CALLED(OnStartBinding);
3739 if(is_urlmon_protocol(test_protocol))
3740 CLEAR_CALLED(SetPriority); /* Not called by IE11 */
3741 CHECK_CALLED(Start);
3742
3743 ok(unk == NULL, "unk=%p\n", unk);
3744
3745 IBindCtx_Release(bctx);
3746 IMoniker_Release(mon);
3747 }
3748
3749 static void test_BindToStorage_fail(void)
3750 {
3751 IMoniker *mon = NULL;
3752 IBindCtx *bctx = NULL;
3753 IUnknown *unk;
3754 HRESULT hres;
3755
3756 hres = CreateURLMoniker(NULL, about_blankW, &mon);
3757 ok(hres == S_OK, "CreateURLMoniker failed: %08x\n", hres);
3758 if(FAILED(hres))
3759 return;
3760
3761 hres = pCreateAsyncBindCtxEx(NULL, 0, NULL, NULL, &bctx, 0);
3762 ok(hres == S_OK, "CreateAsyncBindCtxEx failed: %08x\n", hres);
3763
3764 unk = (void*)0xdeadbeef;
3765 hres = IMoniker_BindToStorage(mon, bctx, NULL, &IID_IStream, (void**)&unk);
3766 ok(hres == MK_E_SYNTAX || hres == INET_E_DATA_NOT_AVAILABLE,
3767 "hres=%08x, expected MK_E_SYNTAX or INET_E_DATA_NOT_AVAILABLE\n", hres);
3768 ok(unk == NULL, "got %p\n", unk);
3769
3770 IBindCtx_Release(bctx);
3771
3772 IMoniker_Release(mon);
3773
3774 test_ReportResult(E_NOTIMPL);
3775 test_ReportResult(S_FALSE);
3776 }
3777
3778 static void test_StdURLMoniker(void)
3779 {
3780 IMoniker *mon, *async_mon;
3781 LPOLESTR display_name;
3782 IBindCtx *bctx;
3783 IUnknown *unk;
3784 HRESULT hres;
3785
3786 hres = CoCreateInstance(&IID_IInternet, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
3787 &IID_IMoniker, (void**)&mon);
3788 ok(hres == S_OK, "Could not create IInternet instance: %08x\n", hres);
3789 if(FAILED(hres))
3790 return;
3791
3792 hres = IMoniker_QueryInterface(mon, &IID_IAsyncMoniker, (void**)&async_mon);
3793 ok(hres == S_OK, "Could not get IAsyncMoniker iface: %08x\n", hres);
3794 ok(mon == async_mon, "mon != async_mon\n");
3795 IMoniker_Release(async_mon);
3796
3797 hres = IMoniker_GetDisplayName(mon, NULL, NULL, &display_name);
3798 ok(hres == E_OUTOFMEMORY, "GetDisplayName failed: %08x, expected E_OUTOFMEMORY\n", hres);
3799
3800 if(pCreateUri) {
3801 IUriContainer *uri_container;
3802 IUri *uri;
3803
3804 hres = IMoniker_QueryInterface(mon, &IID_IUriContainer, (void**)&uri_container);
3805 ok(hres == S_OK, "Could not get IUriMoniker iface: %08x\n", hres);
3806
3807
3808 uri = (void*)0xdeadbeef;
3809 hres = IUriContainer_GetIUri(uri_container, &uri);
3810 ok(hres == S_FALSE, "GetIUri failed: %08x\n", hres);
3811 ok(!uri, "uri = %p, expected NULL\n", uri);
3812
3813 IUriContainer_Release(uri_container);
3814 }
3815
3816 SET_EXPECT(QueryInterface_IServiceProvider);
3817 hres = CreateAsyncBindCtx(0, (IBindStatusCallback*)&bsc, NULL, &bctx);
3818 ok(hres == S_OK, "CreateAsyncBindCtx failed: %08x\n\n", hres);
3819 CHECK_CALLED(QueryInterface_IServiceProvider);
3820
3821 if(pCreateUri) { /* Skip these tests on old IEs */
3822 unk = (void*)0xdeadbeef;
3823 hres = IMoniker_BindToStorage(mon, bctx, NULL, &IID_IStream, (void**)&unk);
3824 ok(hres == MK_E_SYNTAX, "BindToStorage failed: %08x, expected MK_E_SYNTAX\n", hres);
3825 ok(!unk, "unk = %p\n", unk);
3826
3827 unk = (void*)0xdeadbeef;
3828 hres = IMoniker_BindToObject(mon, bctx, NULL, &IID_IUnknown, (void**)&unk);
3829 ok(hres == MK_E_SYNTAX, "BindToStorage failed: %08x, expected MK_E_SYNTAX\n", hres);
3830 ok(!unk, "unk = %p\n", unk);
3831 }
3832
3833 IMoniker_Release(mon);
3834 }
3835
3836 static void register_protocols(void)
3837 {
3838 IInternetSession *session;
3839 HRESULT hres;
3840
3841 static const WCHAR winetestW[] = {'w','i','n','e','t','e','s','t',0};
3842
3843 hres = CoInternetGetSession(0, &session, 0);
3844 ok(hres == S_OK, "CoInternetGetSession failed: %08x\n", hres);
3845 if(FAILED(hres))
3846 return;
3847
3848 hres = IInternetSession_RegisterNameSpace(session, &protocol_cf, &IID_NULL,
3849 winetestW, 0, NULL, 0);
3850 ok(hres == S_OK, "RegisterNameSpace failed: %08x\n", hres);
3851
3852 IInternetSession_Release(session);
3853 }
3854
3855 static BOOL can_do_https(void)
3856 {
3857 HINTERNET ses, con, req;
3858 BOOL ret;
3859
3860 ses = InternetOpenA("winetest", INTERNET_OPEN_TYPE_PRECONFIG, NULL, NULL, 0);
3861 ok(ses != NULL, "InternetOpen failed\n");
3862
3863 con = InternetConnectA(ses, "test.winehq.org", INTERNET_DEFAULT_HTTPS_PORT,
3864 NULL, NULL, INTERNET_SERVICE_HTTP, 0, 0);
3865 ok(con != NULL, "InternetConnect failed\n");
3866
3867 req = HttpOpenRequestA(con, "GET", "/tests/hello.html", NULL, NULL, NULL,
3868 INTERNET_FLAG_SECURE, 0);
3869 ok(req != NULL, "HttpOpenRequest failed\n");
3870
3871 ret = HttpSendRequestA(req, NULL, 0, NULL, 0);
3872 ok(ret || broken(GetLastError() == ERROR_INTERNET_CANNOT_CONNECT),
3873 "request failed: %u\n", GetLastError());
3874
3875 InternetCloseHandle(req);
3876 InternetCloseHandle(con);
3877 InternetCloseHandle(ses);
3878 return ret;
3879 }
3880
3881 START_TEST(url)
3882 {
3883 HMODULE hurlmon;
3884
3885 hurlmon = GetModuleHandleA("urlmon.dll");
3886 pCreateAsyncBindCtxEx = (void*) GetProcAddress(hurlmon, "CreateAsyncBindCtxEx");
3887
3888 if(!GetProcAddress(hurlmon, "CompareSecurityIds")) {
3889 win_skip("Too old IE\n");
3890 return;
3891 }
3892
3893 pCreateUri = (void*) GetProcAddress(hurlmon, "CreateUri");
3894 if(!pCreateUri)
3895 win_skip("IUri not supported\n");
3896
3897 complete_event = CreateEventW(NULL, FALSE, FALSE, NULL);
3898 complete_event2 = CreateEventW(NULL, FALSE, FALSE, NULL);
3899 thread_id = GetCurrentThreadId();
3900 create_html_file();
3901 create_cache_file();
3902 register_protocols();
3903
3904 test_create();
3905
3906 trace("test CreateAsyncBindCtx...\n");
3907 test_CreateAsyncBindCtx();
3908
3909 trace("test CreateAsyncBindCtxEx...\n");
3910 test_CreateAsyncBindCtxEx();
3911
3912 trace("test RegisterBindStatusCallback...\n");
3913 if(test_RegisterBindStatusCallback()) {
3914 trace("test BindToStorage failures...\n");
3915 test_BindToStorage_fail();
3916
3917 trace("synchronous http test (COM not initialised)...\n");
3918 test_BindToStorage(HTTP_TEST, 0, TYMED_ISTREAM);
3919
3920 CoInitialize(NULL);
3921
3922 trace("test StdURLMoniker...\n");
3923 test_StdURLMoniker();
3924
3925 trace("synchronous http test...\n");
3926 test_BindToStorage(HTTP_TEST, 0, TYMED_ISTREAM);
3927
3928 trace("emulated synchronous http test (to file)...\n");
3929 test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE, TYMED_FILE);
3930
3931 trace("synchronous http test (to object)...\n");
3932 test_BindToObject(HTTP_TEST, 0, S_OK);
3933
3934 trace("emulated synchronous http test (with cache)...\n");
3935 test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE|BINDTEST_USE_CACHE, TYMED_ISTREAM);
3936
3937 trace("emulated synchronous http test (with cache, no read)...\n");
3938 test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE|BINDTEST_USE_CACHE|BINDTEST_NO_CALLBACK_READ, TYMED_ISTREAM);
3939
3940 trace("synchronous http test (with cache, no read)...\n");
3941 test_BindToStorage(HTTP_TEST, BINDTEST_USE_CACHE|BINDTEST_NO_CALLBACK_READ, TYMED_ISTREAM);
3942
3943 trace("synchronous file test...\n");
3944 test_BindToStorage(FILE_TEST, 0, TYMED_ISTREAM);
3945
3946 trace("emulated synchronous file test (to file)...\n");
3947 test_BindToStorage(FILE_TEST, BINDTEST_EMULATE, TYMED_FILE);
3948
3949 trace("synchronous file test (to object)...\n");
3950 test_BindToObject(FILE_TEST, 0, S_OK);
3951
3952 trace("bind to an object of not registered MIME type...\n");
3953 create_file("test.winetest", "\x01\x02\x03xxxxxxxxxxxxxxxxxxxxxxxxx");
3954 test_BindToObject(FILE_TEST, 0, REGDB_E_CLASSNOTREG);
3955 create_html_file();
3956
3957 trace("file test (no callback)...\n");
3958 test_BindToStorage(FILE_TEST, BINDTEST_NO_CALLBACK, TYMED_ISTREAM);
3959
3960 if(can_do_https()) {
3961 trace("synchronous https test (invalid CN, dialog)\n");
3962 onsecurityproblem_hres = S_FALSE;
3963 http_is_first = TRUE;
3964 test_BindToStorage(HTTPS_TEST, BINDTEST_INVALID_CN, TYMED_ISTREAM);
3965
3966 bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA;
3967
3968 trace("asynchronous https test (invalid CN, fail)\n");
3969 onsecurityproblem_hres = E_FAIL;
3970 test_BindToStorage(HTTPS_TEST, BINDTEST_INVALID_CN, TYMED_ISTREAM);
3971
3972 trace("asynchronous https test (invalid CN, accept)\n");
3973 onsecurityproblem_hres = S_OK;
3974 test_BindToStorage(HTTPS_TEST, BINDTEST_INVALID_CN, TYMED_ISTREAM);
3975
3976 trace("asynchronous https test (invalid CN, dialog 2)\n");
3977 onsecurityproblem_hres = S_FALSE;
3978 test_BindToStorage(HTTPS_TEST, BINDTEST_INVALID_CN, TYMED_ISTREAM);
3979 invalid_cn_accepted = FALSE;
3980
3981 trace("asynchronous https test...\n");
3982 test_BindToStorage(HTTPS_TEST, 0, TYMED_ISTREAM);
3983 }else {
3984 win_skip("Skipping https testt\n");
3985 }
3986
3987 bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA;
3988
3989 trace("winetest test (async switch)...\n");
3990 test_BindToStorage(WINETEST_TEST, BINDTEST_EMULATE|BINDTEST_ASYNC_SWITCH, TYMED_ISTREAM);
3991
3992 trace("about test (no read)...\n");
3993 test_BindToStorage(ABOUT_TEST, BINDTEST_NO_CALLBACK_READ, TYMED_ISTREAM);
3994
3995 trace("http test...\n");
3996 test_BindToStorage(HTTP_TEST, 0, TYMED_ISTREAM);
3997
3998 trace("http test (to file)...\n");
3999 test_BindToStorage(HTTP_TEST, 0, TYMED_FILE);
4000
4001 trace("http test (to object)...\n");
4002 test_BindToObject(HTTP_TEST, 0, S_OK);
4003
4004 trace("http test (short response)...\n");
4005 test_BindToStorage(HTTP_TEST, BINDTEST_HTTPRESPONSE|BINDTEST_ALLOW_FINDINGRESOURCE, TYMED_ISTREAM);
4006
4007 trace("http test (short response, to object)...\n");
4008 test_BindToObject(HTTP_TEST, 0, S_OK);
4009
4010 trace("http test (abort start binding E_NOTIMPL)...\n");
4011 abort_hres = E_NOTIMPL;
4012 test_BindToStorage(HTTP_TEST, BINDTEST_ABORT_START, TYMED_FILE);
4013
4014 trace("http test (abort start binding E_ABORT)...\n");
4015 abort_hres = E_ABORT;
4016 test_BindToStorage(HTTP_TEST, BINDTEST_ABORT_START, TYMED_FILE);
4017
4018 trace("http test (abort progress)...\n");
4019 test_BindToStorage(HTTP_TEST, BINDTEST_ABORT_PROGRESS|BINDTEST_ALLOW_FINDINGRESOURCE, TYMED_FILE);
4020
4021 trace("emulated http test...\n");
4022 test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
4023
4024 trace("emulated http test (to object)...\n");
4025 test_BindToObject(HTTP_TEST, BINDTEST_EMULATE, S_OK);
4026
4027 trace("emulated http test (to object, redirect)...\n");
4028 test_BindToObject(HTTP_TEST, BINDTEST_EMULATE|BINDTEST_REDIRECT, S_OK);
4029
4030 trace("emulated http test (to file)...\n");
4031 test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE, TYMED_FILE);
4032
4033 trace("emulated http test (redirect)...\n");
4034 test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE|BINDTEST_REDIRECT, TYMED_ISTREAM);
4035
4036 trace("emulated http test (with cache)...\n");
4037 test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE|BINDTEST_USE_CACHE, TYMED_ISTREAM);
4038
4039 trace("winetest test (no callback)...\n");
4040 test_BindToStorage(WINETEST_TEST, BINDTEST_EMULATE|BINDTEST_NO_CALLBACK|BINDTEST_USE_CACHE, TYMED_ISTREAM);
4041
4042 trace("emulated https test...\n");
4043 test_BindToStorage(HTTPS_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
4044
4045 trace("about test...\n");
4046 test_BindToStorage(ABOUT_TEST, 0, TYMED_ISTREAM);
4047
4048 trace("about test (to file)...\n");
4049 test_BindToStorage(ABOUT_TEST, 0, TYMED_FILE);
4050
4051 trace("about test (to object)...\n");
4052 test_BindToObject(ABOUT_TEST, 0, S_OK);
4053
4054 trace("emulated about test...\n");
4055 test_BindToStorage(ABOUT_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
4056
4057 trace("emulated about test (to file)...\n");
4058 test_BindToStorage(ABOUT_TEST, BINDTEST_EMULATE, TYMED_FILE);
4059
4060 trace("emulated about test (to object)...\n");
4061 test_BindToObject(ABOUT_TEST, BINDTEST_EMULATE, S_OK);
4062
4063 trace("emulalated test reporting result in read...\n");
4064 test_BindToStorage(WINETEST_SYNC_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
4065
4066 trace("file test...\n");
4067 test_BindToStorage(FILE_TEST, 0, TYMED_ISTREAM);
4068
4069 trace("file test (to file)...\n");
4070 test_BindToStorage(FILE_TEST, 0, TYMED_FILE);
4071
4072 trace("file test (to object)...\n");
4073 test_BindToObject(FILE_TEST, 0, S_OK);
4074
4075 trace("emulated file test...\n");
4076 test_BindToStorage(FILE_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
4077
4078 trace("emulated file test (to file)...\n");
4079 test_BindToStorage(FILE_TEST, BINDTEST_EMULATE, TYMED_FILE);
4080
4081 trace("emulated file test (to object)...\n");
4082 test_BindToObject(FILE_TEST, BINDTEST_EMULATE, S_OK);
4083
4084 trace("emulated its test...\n");
4085 test_BindToStorage(ITS_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
4086
4087 trace("emulated its test (to file)...\n");
4088 test_BindToStorage(ITS_TEST, BINDTEST_EMULATE, TYMED_FILE);
4089
4090 trace("emulated mk test...\n");
4091 test_BindToStorage(MK_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
4092
4093 trace("test URLDownloadToFile for file protocol...\n");
4094 test_URLDownloadToFile(FILE_TEST, FALSE);
4095
4096 trace("test URLDownloadToFile for emulated file protocol...\n");
4097 test_URLDownloadToFile(FILE_TEST, TRUE);
4098
4099 trace("test URLDownloadToFile for http protocol...\n");
4100 test_URLDownloadToFile(HTTP_TEST, FALSE);
4101
4102 trace("test URLDownloadToFile abort...\n");
4103 test_URLDownloadToFile_abort();
4104
4105 trace("test emulated http abort...\n");
4106 test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE|BINDTEST_ABORT, TYMED_ISTREAM);
4107
4108 bindf |= BINDF_NOWRITECACHE;
4109
4110 trace("ftp test...\n");
4111 test_BindToStorage(FTP_TEST, 0, TYMED_ISTREAM);
4112
4113 trace("test failures...\n");
4114 test_BindToStorage_fail();
4115
4116 bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE;
4117 only_check_prot_args = TRUE; /* Fail after checking arguments to Protocol_Start */
4118
4119 trace("check emulated http protocol arguments...\n");
4120 test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
4121 }
4122
4123 DeleteFileA(test_file);
4124 DeleteFileA(test_txtA);
4125 CloseHandle(complete_event);
4126 CloseHandle(complete_event2);
4127 CoUninitialize();
4128 }
A free Windows-compatible Operating System