projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[URLMON_WINETEST] Skip test_ftp_protocol() because of timeouts. ROSTESTS-165
[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 IInternetProtocol *protocol;
2576 BINDINFO bindinfo = {sizeof(bindinfo)};
2577 BOOL ret = TRUE;
2578 LPWSTR wstr;
2579 DWORD dw;
2580 HRESULT hres;
2581
2582 hres = IBindStatusCallback_QueryInterface(holder, &IID_IServiceProvider, (void**)&serv_prov);
2583 ok(hres == S_OK, "Could not get IServiceProvider interface: %08x\n", hres);
2584
2585 dw = 0xdeadbeef;
2586 SET_EXPECT(QueryInterface_IBindStatusCallbackEx);
2587 SET_EXPECT(GetBindInfo);
2588 hres = IBindStatusCallback_GetBindInfo(holder, &dw, &bindinfo);
2589 ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
2590 CLEAR_CALLED(QueryInterface_IBindStatusCallbackEx); /* IE 8 */
2591 CHECK_CALLED(GetBindInfo);
2592
2593 test_GetBindInfoEx(holder);
2594
2595 SET_EXPECT(OnStartBinding);
2596 hres = IBindStatusCallback_OnStartBinding(holder, 0, (void*)0xdeadbeef);
2597 ok(hres == S_OK, "OnStartBinding failed: %08x\n", hres);
2598 CHECK_CALLED(OnStartBinding);
2599
2600 hres = IBindStatusCallback_QueryInterface(holder, &IID_IHttpNegotiate, (void**)&http_negotiate);
2601 ok(hres == S_OK, "Could not get IHttpNegotiate interface: %08x\n", hres);
2602
2603 SET_EXPECT(QueryInterface_IHttpNegotiate);
2604 hres = IServiceProvider_QueryService(serv_prov, &IID_IHttpNegotiate, &IID_IHttpNegotiate,
2605 (void**)&http_negotiate_serv);
2606 ok(hres == S_OK, "Could not get IHttpNegotiate service: %08x\n", hres);
2607 CLEAR_CALLED(QueryInterface_IHttpNegotiate); /* IE <8 */
2608
2609 ok(http_negotiate == http_negotiate_serv, "http_negotiate != http_negotiate_serv\n");
2610
2611 wstr = (void*)0xdeadbeef;
2612 SET_EXPECT(QueryInterface_IHttpNegotiate);
2613 SET_EXPECT(BeginningTransaction);
2614 hres = IHttpNegotiate_BeginningTransaction(http_negotiate_serv, current_url, emptyW, 0, &wstr);
2615 CHECK_CALLED_BROKEN(QueryInterface_IHttpNegotiate); /* IE8 */
2616 CHECK_CALLED(BeginningTransaction);
2617 ok(hres == S_OK, "BeginningTransaction failed: %08x\n", hres);
2618 ok(wstr == NULL, "wstr = %p\n", wstr);
2619
2620 IHttpNegotiate_Release(http_negotiate_serv);
2621
2622 hres = IServiceProvider_QueryService(serv_prov, &IID_IHttpNegotiate, &IID_IHttpNegotiate,
2623 (void**)&http_negotiate_serv);
2624 ok(hres == S_OK, "Could not get IHttpNegotiate service: %08x\n", hres);
2625 ok(http_negotiate == http_negotiate_serv, "http_negotiate != http_negotiate_serv\n");
2626 IHttpNegotiate_Release(http_negotiate_serv);
2627
2628 hres = IBindStatusCallback_QueryInterface(holder, &IID_IHttpNegotiate2, (void**)&http_negotiate2);
2629 if(SUCCEEDED(hres)) {
2630 have_IHttpNegotiate2 = TRUE;
2631
2632 SET_EXPECT(QueryInterface_IHttpNegotiate2);
2633 hres = IServiceProvider_QueryService(serv_prov, &IID_IHttpNegotiate2, &IID_IHttpNegotiate2,
2634 (void**)&http_negotiate2_serv);
2635 ok(hres == S_OK, "Could not get IHttpNegotiate2 service: %08x\n", hres);
2636 CLEAR_CALLED(QueryInterface_IHttpNegotiate2); /* IE <8 */
2637 ok(http_negotiate2 == http_negotiate2_serv, "http_negotiate != http_negotiate_serv\n");
2638
2639 SET_EXPECT(QueryInterface_IHttpNegotiate2);
2640 SET_EXPECT(GetRootSecurityId);
2641 hres = IHttpNegotiate2_GetRootSecurityId(http_negotiate2, (void*)0xdeadbeef, (void*)0xdeadbeef, 0);
2642 ok(hres == E_NOTIMPL, "GetRootSecurityId failed: %08x\n", hres);
2643 CHECK_CALLED_BROKEN(QueryInterface_IHttpNegotiate2); /* IE8 */
2644 CHECK_CALLED(GetRootSecurityId);
2645
2646 IHttpNegotiate2_Release(http_negotiate2_serv);
2647 IHttpNegotiate2_Release(http_negotiate2);
2648 }else {
2649 skip("Could not get IHttpNegotiate2\n");
2650 ret = FALSE;
2651 }
2652
2653 SET_EXPECT(OnProgress_FINDINGRESOURCE);
2654 hres = IBindStatusCallback_OnProgress(holder, 0, 0, BINDSTATUS_FINDINGRESOURCE, NULL);
2655 ok(hres == S_OK, "OnProgress failed: %08x\n", hres);
2656 CHECK_CALLED(OnProgress_FINDINGRESOURCE);
2657
2658 SET_EXPECT(QueryInterface_IHttpNegotiate);
2659 SET_EXPECT(OnResponse);
2660 wstr = (void*)0xdeadbeef;
2661 hres = IHttpNegotiate_OnResponse(http_negotiate, 200, emptyW, NULL, NULL);
2662 ok(hres == S_OK, "OnResponse failed: %08x\n", hres);
2663 CHECK_CALLED_BROKEN(QueryInterface_IHttpNegotiate); /* IE8 */
2664 CHECK_CALLED(OnResponse);
2665
2666 IHttpNegotiate_Release(http_negotiate);
2667
2668 hres = IBindStatusCallback_QueryInterface(holder, &IID_IAuthenticate, (void**)&authenticate);
2669 ok(hres == S_OK, "Could not get IAuthenticate interface: %08x\n", hres);
2670
2671 SET_EXPECT(QueryInterface_IAuthenticate);
2672 SET_EXPECT(QueryService_IAuthenticate);
2673 hres = IServiceProvider_QueryService(serv_prov, &IID_IAuthenticate, &IID_IAuthenticate,
2674 (void**)&authenticate_serv);
2675 ok(hres == S_OK, "Could not get IAuthenticate service: %08x\n", hres);
2676 CLEAR_CALLED(QueryInterface_IAuthenticate); /* IE <8 */
2677 CLEAR_CALLED(QueryService_IAuthenticate); /* IE <8 */
2678 ok(authenticate == authenticate_serv, "authenticate != authenticate_serv\n");
2679 IAuthenticate_Release(authenticate_serv);
2680
2681 hres = IServiceProvider_QueryService(serv_prov, &IID_IAuthenticate, &IID_IAuthenticate,
2682 (void**)&authenticate_serv);
2683 ok(hres == S_OK, "Could not get IAuthenticate service: %08x\n", hres);
2684 ok(authenticate == authenticate_serv, "authenticate != authenticate_serv\n");
2685
2686 IAuthenticate_Release(authenticate);
2687 IAuthenticate_Release(authenticate_serv);
2688
2689 SET_EXPECT(OnStopBinding);
2690 hres = IBindStatusCallback_OnStopBinding(holder, S_OK, NULL);
2691 ok(hres == S_OK, "OnStopBinding failed: %08x\n", hres);
2692 CHECK_CALLED(OnStopBinding);
2693
2694 SET_EXPECT(QueryInterface_IInternetProtocol);
2695 SET_EXPECT(QueryService_IInternetProtocol);
2696 hres = IServiceProvider_QueryService(serv_prov, &IID_IInternetProtocol, &IID_IInternetProtocol,
2697 (void**)&protocol);
2698 ok(hres == E_NOINTERFACE, "QueryService(IInternetProtocol) failed: %08x\n", hres);
2699 CHECK_CALLED(QueryInterface_IInternetProtocol);
2700 CHECK_CALLED(QueryService_IInternetProtocol);
2701
2702 IServiceProvider_Release(serv_prov);
2703 return ret;
2704 }
2705
2706 static BOOL test_RegisterBindStatusCallback(void)
2707 {
2708 IBindStatusCallback *prevbsc, *clb, *prev_clb;
2709 IBindCtx *bindctx;
2710 BOOL ret = TRUE;
2711 IUnknown *unk;
2712 HRESULT hres;
2713
2714 strict_bsc_qi = TRUE;
2715
2716 hres = CreateBindCtx(0, &bindctx);
2717 ok(hres == S_OK, "BindCtx failed: %08x\n", hres);
2718
2719 SET_EXPECT(QueryInterface_IServiceProvider);
2720
2721 hres = IBindCtx_RegisterObjectParam(bindctx, BSCBHolder, (IUnknown*)&bsc);
2722 ok(hres == S_OK, "RegisterObjectParam failed: %08x\n", hres);
2723
2724 SET_EXPECT(QueryInterface_IBindStatusCallback);
2725 SET_EXPECT(QueryInterface_IBindStatusCallbackHolder);
2726 prevbsc = (void*)0xdeadbeef;
2727 hres = RegisterBindStatusCallback(bindctx, (IBindStatusCallback*)&bsc, &prevbsc, 0);
2728 ok(hres == S_OK, "RegisterBindStatusCallback failed: %08x\n", hres);
2729 ok(prevbsc == (IBindStatusCallback*)&bsc, "prevbsc=%p\n", prevbsc);
2730 CHECK_CALLED(QueryInterface_IBindStatusCallback);
2731 CHECK_CALLED(QueryInterface_IBindStatusCallbackHolder);
2732
2733 CHECK_CALLED(QueryInterface_IServiceProvider);
2734
2735 hres = IBindCtx_GetObjectParam(bindctx, BSCBHolder, &unk);
2736 ok(hres == S_OK, "GetObjectParam failed: %08x\n", hres);
2737
2738 hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&clb);
2739 IUnknown_Release(unk);
2740 ok(hres == S_OK, "QueryInterface(IID_IBindStatusCallback) failed: %08x\n", hres);
2741 ok(clb != (IBindStatusCallback*)&bsc, "bsc == clb\n");
2742
2743 if(!test_bscholder(clb))
2744 ret = FALSE;
2745
2746 IBindStatusCallback_Release(clb);
2747
2748 hres = RevokeBindStatusCallback(bindctx, (IBindStatusCallback*)&bsc);
2749 ok(hres == S_OK, "RevokeBindStatusCallback failed: %08x\n", hres);
2750
2751 unk = (void*)0xdeadbeef;
2752 hres = IBindCtx_GetObjectParam(bindctx, BSCBHolder, &unk);
2753 ok(hres == E_FAIL, "GetObjectParam failed: %08x\n", hres);
2754 ok(unk == NULL, "unk != NULL\n");
2755
2756 if(unk)
2757 IUnknown_Release(unk);
2758
2759 hres = RevokeBindStatusCallback(bindctx, (void*)0xdeadbeef);
2760 ok(hres == S_OK, "RevokeBindStatusCallback failed: %08x\n", hres);
2761
2762 hres = RevokeBindStatusCallback(NULL, (void*)0xdeadbeef);
2763 ok(hres == E_INVALIDARG, "RevokeBindStatusCallback failed: %08x\n", hres);
2764
2765 hres = RevokeBindStatusCallback(bindctx, NULL);
2766 ok(hres == E_INVALIDARG, "RevokeBindStatusCallback failed: %08x\n", hres);
2767
2768 SET_EXPECT(QueryInterface_IServiceProvider);
2769 prevbsc = (void*)0xdeadbeef;
2770 hres = RegisterBindStatusCallback(bindctx, (IBindStatusCallback*)&bsc, &prevbsc, 0);
2771 ok(hres == S_OK, "RegisterBindStatusCallback failed: %08x\n", hres);
2772 ok(!prevbsc, "prevbsc=%p\n", prevbsc);
2773 CHECK_CALLED(QueryInterface_IServiceProvider);
2774
2775 hres = IBindCtx_GetObjectParam(bindctx, BSCBHolder, &unk);
2776 ok(hres == S_OK, "GetObjectParam failed: %08x\n", hres);
2777
2778 hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&prev_clb);
2779 IUnknown_Release(unk);
2780 ok(hres == S_OK, "QueryInterface(IID_IBindStatusCallback) failed: %08x\n", hres);
2781 ok(prev_clb != (IBindStatusCallback*)&bsc, "bsc == clb\n");
2782
2783 SET_EXPECT(QueryInterface_IServiceProvider);
2784 prevbsc = (void*)0xdeadbeef;
2785 hres = RegisterBindStatusCallback(bindctx, (IBindStatusCallback*)&bsc2, &prevbsc, 0);
2786 ok(hres == S_OK, "RegisterBindStatusCallback failed: %08x\n", hres);
2787 ok(prevbsc == (IBindStatusCallback*)&bsc, "prevbsc != bsc\n");
2788 CHECK_CALLED(QueryInterface_IServiceProvider);
2789
2790 hres = IBindCtx_GetObjectParam(bindctx, BSCBHolder, &unk);
2791 ok(hres == S_OK, "GetObjectParam failed: %08x\n", hres);
2792
2793 hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&clb);
2794 IUnknown_Release(unk);
2795 ok(hres == S_OK, "QueryInterface(IID_IBindStatusCallback) failed: %08x\n", hres);
2796 ok(prev_clb == clb, "bsc != clb\n");
2797
2798 IBindStatusCallback_Release(clb);
2799 IBindStatusCallback_Release(prev_clb);
2800
2801 IBindCtx_Release(bindctx);
2802
2803 strict_bsc_qi = FALSE;
2804 return ret;
2805 }
2806
2807 #define BINDTEST_EMULATE 0x0001
2808 #define BINDTEST_TOOBJECT 0x0002
2809 #define BINDTEST_FILEDWLAPI 0x0004
2810 #define BINDTEST_HTTPRESPONSE 0x0008
2811 #define BINDTEST_REDIRECT 0x0010
2812 #define BINDTEST_USE_CACHE 0x0020
2813 #define BINDTEST_NO_CALLBACK_READ 0x0040
2814 #define BINDTEST_NO_CALLBACK 0x0080
2815 #define BINDTEST_ABORT 0x0100
2816 #define BINDTEST_INVALID_CN 0x0200
2817 #define BINDTEST_ABORT_START 0x0400
2818 #define BINDTEST_ABORT_PROGRESS 0x0800
2819 #define BINDTEST_ASYNC_SWITCH 0x1000
2820 #define BINDTEST_ALLOW_FINDINGRESOURCE 0x2000
2821
2822 static void init_bind_test(int protocol, DWORD flags, DWORD t)
2823 {
2824 const char *url_a = NULL;
2825
2826 test_protocol = protocol;
2827 bindtest_flags = flags;
2828 emulate_protocol = (flags & BINDTEST_EMULATE) != 0;
2829 download_state = BEFORE_DOWNLOAD;
2830 stopped_binding = FALSE;
2831 stopped_obj_binding = FALSE;
2832 data_available = FALSE;
2833 mime_type[0] = 0;
2834 binding_hres = S_OK;
2835 bind_to_object = (flags & BINDTEST_TOOBJECT) != 0;
2836 tymed = t;
2837 filedwl_api = (flags & BINDTEST_FILEDWLAPI) != 0;
2838 post_test = (flags & BINDTEST_HTTPRESPONSE) != 0;
2839
2840 switch(protocol) {
2841 case HTTP_TEST:
2842 if(post_test)
2843 url_a = "http://test.winehq.org/tests/post.php";
2844 else
2845 lstrcpyW(current_url, winetest_data_urlW);
2846 break;
2847 case ABOUT_TEST:
2848 url_a = "about:blank";
2849 break;
2850 case FILE_TEST:
2851 lstrcpyW(current_url, file_url);
2852 break;
2853 case MK_TEST:
2854 url_a = "mk:@MSITStore:test.chm::/blank.html";
2855 break;
2856 case ITS_TEST:
2857 url_a = "its:test.chm::/blank.html";
2858 break;
2859 case HTTPS_TEST:
2860 url_a = (flags & BINDTEST_INVALID_CN) ? "https://209.46.25.134/favicon.ico" : "https://test.winehq.org/tests/hello.html";
2861 break;
2862 case FTP_TEST:
2863 url_a = "ftp://ftp.winehq.org/pub/other/winelogo.xcf.tar.bz2";
2864 break;
2865 default:
2866 url_a = "winetest:test";
2867 }
2868
2869 if(url_a)
2870 MultiByteToWideChar(CP_ACP, 0, url_a, -1, current_url, sizeof(current_url)/sizeof(*current_url));
2871
2872 test_redirect = (flags & BINDTEST_REDIRECT) != 0;
2873 use_cache_file = (flags & BINDTEST_USE_CACHE) != 0;
2874 callback_read = !(flags & BINDTEST_NO_CALLBACK_READ);
2875 no_callback = (flags & BINDTEST_NO_CALLBACK) != 0;
2876 test_abort = (flags & BINDTEST_ABORT) != 0;
2877 abort_start = (flags & BINDTEST_ABORT_START) != 0;
2878 abort_progress = (flags & BINDTEST_ABORT_PROGRESS) != 0;
2879 async_switch = (flags & BINDTEST_ASYNC_SWITCH) != 0;
2880 is_async_prot = protocol == HTTP_TEST || protocol == HTTPS_TEST || protocol == FTP_TEST || protocol == WINETEST_TEST;
2881 prot_state = 0;
2882 ResetEvent(complete_event);
2883
2884 trace("URL: %s\n", wine_dbgstr_w(current_url));
2885 }
2886
2887 static void test_BindToStorage(int protocol, DWORD flags, DWORD t)
2888 {
2889 IMoniker *mon;
2890 HRESULT hres;
2891 LPOLESTR display_name;
2892 IBindCtx *bctx = NULL;
2893 MSG msg;
2894 IBindStatusCallback *previousclb;
2895 IUnknown *unk = (IUnknown*)0x00ff00ff;
2896 BOOL allow_finding_resource;
2897 IBinding *bind;
2898
2899 init_bind_test(protocol, flags, t);
2900 allow_finding_resource = (flags & BINDTEST_ALLOW_FINDINGRESOURCE) != 0;
2901
2902 if(no_callback) {
2903 hres = CreateBindCtx(0, &bctx);
2904 ok(hres == S_OK, "CreateBindCtx failed: %08x\n", hres);
2905 }else {
2906 SET_EXPECT(QueryInterface_IServiceProvider);
2907 hres = CreateAsyncBindCtx(0, (IBindStatusCallback*)&bsc, NULL, &bctx);
2908 ok(hres == S_OK, "CreateAsyncBindCtx failed: %08x\n\n", hres);
2909 CHECK_CALLED(QueryInterface_IServiceProvider);
2910 if(FAILED(hres))
2911 return;
2912
2913 SET_EXPECT(QueryInterface_IServiceProvider);
2914 hres = RegisterBindStatusCallback(bctx, (IBindStatusCallback*)&bsc, &previousclb, 0);
2915 ok(hres == S_OK, "RegisterBindStatusCallback failed: %08x\n", hres);
2916 ok(previousclb == (IBindStatusCallback*)&bsc, "previousclb(%p) != sclb(%p)\n", previousclb, &bsc);
2917 CHECK_CALLED(QueryInterface_IServiceProvider);
2918 if(previousclb)
2919 IBindStatusCallback_Release(previousclb);
2920 }
2921
2922 hres = CreateURLMoniker(NULL, current_url, &mon);
2923 ok(hres == S_OK, "failed to create moniker: %08x\n", hres);
2924 if(FAILED(hres))
2925 return;
2926
2927 hres = IMoniker_QueryInterface(mon, &IID_IBinding, (void**)&bind);
2928 ok(hres == E_NOINTERFACE, "IMoniker should not have IBinding interface\n");
2929 if(SUCCEEDED(hres))
2930 IBinding_Release(bind);
2931
2932 hres = IMoniker_GetDisplayName(mon, bctx, NULL, &display_name);
2933 ok(hres == S_OK, "GetDisplayName failed %08x\n", hres);
2934 ok(!lstrcmpW(display_name, current_url), "GetDisplayName got wrong name %s, expected %s\n",
2935 wine_dbgstr_w(display_name), wine_dbgstr_w(current_url));
2936 CoTaskMemFree(display_name);
2937
2938 if(tymed == TYMED_FILE && (test_protocol == ABOUT_TEST || test_protocol == ITS_TEST))
2939 binding_hres = INET_E_DATA_NOT_AVAILABLE;
2940 if((flags & BINDTEST_INVALID_CN) && !invalid_cn_accepted &&
2941 (onsecurityproblem_hres != S_OK || security_problem == ERROR_INTERNET_SEC_CERT_ERRORS)) {
2942 if(security_problem == ERROR_INTERNET_SEC_CERT_ERRORS)
2943 binding_hres = INET_E_SECURITY_PROBLEM;
2944 else
2945 binding_hres = INET_E_INVALID_CERTIFICATE;
2946 }
2947
2948
2949 if(only_check_prot_args)
2950 SET_EXPECT(OnStopBinding);
2951 if(!no_callback) {
2952 SET_EXPECT(QueryInterface_IBindStatusCallbackEx);
2953 SET_EXPECT(GetBindInfo);
2954 SET_EXPECT(QueryInterface_IInternetProtocol);
2955 if(!emulate_protocol)
2956 SET_EXPECT(QueryService_IInternetProtocol);
2957 SET_EXPECT(OnStartBinding);
2958 }
2959 if(emulate_protocol) {
2960 if(is_urlmon_protocol(test_protocol))
2961 SET_EXPECT(SetPriority);
2962 SET_EXPECT(Start);
2963 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST
2964 || test_protocol == WINETEST_SYNC_TEST)
2965 SET_EXPECT(Terminate);
2966 if(tymed != TYMED_FILE || (test_protocol != ABOUT_TEST && test_protocol != ITS_TEST))
2967 SET_EXPECT(UnlockRequest);
2968 }else {
2969 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST) {
2970 SET_EXPECT(QueryService_IInternetBindInfo);
2971 if(!abort_start)
2972 SET_EXPECT(QueryInterface_IHttpNegotiate);
2973 SET_EXPECT(QueryInterface_IWindowForBindingUI);
2974 SET_EXPECT(QueryService_IWindowForBindingUI);
2975 SET_EXPECT(GetWindow_IWindowForBindingUI);
2976 if(!abort_start) {
2977 SET_EXPECT(BeginningTransaction);
2978 SET_EXPECT(QueryInterface_IHttpNegotiate2);
2979 SET_EXPECT(GetRootSecurityId);
2980 if(http_is_first || allow_finding_resource)
2981 SET_EXPECT(OnProgress_FINDINGRESOURCE);
2982 SET_EXPECT(OnProgress_CONNECTING);
2983 }
2984 if(flags & BINDTEST_INVALID_CN) {
2985 SET_EXPECT(QueryInterface_IHttpSecurity);
2986 SET_EXPECT(QueryService_IHttpSecurity);
2987 SET_EXPECT(OnSecurityProblem);
2988 if(SUCCEEDED(onsecurityproblem_hres))
2989 SET_EXPECT(GetWindow_IHttpSecurity);
2990 }
2991 }
2992 if(!no_callback) {
2993 if((test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == FTP_TEST
2994 || test_protocol == FILE_TEST || test_protocol == WINETEST_TEST) && !abort_start)
2995 SET_EXPECT(OnProgress_SENDINGREQUEST);
2996 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST) {
2997 SET_EXPECT(QueryInterface_IHttpNegotiate);
2998 SET_EXPECT(OnResponse);
2999 }
3000 if(!abort_start) {
3001 SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
3002 SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
3003 }
3004 if(test_protocol == FILE_TEST)
3005 SET_EXPECT(OnProgress_CACHEFILENAMEAVAILABLE);
3006 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == FTP_TEST || test_protocol == WINETEST_TEST)
3007 SET_EXPECT(OnProgress_DOWNLOADINGDATA);
3008 if(!abort_start)
3009 SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
3010 if((tymed != TYMED_FILE || test_protocol != ABOUT_TEST) && !abort_start)
3011 SET_EXPECT(OnDataAvailable);
3012 SET_EXPECT(OnStopBinding);
3013 }
3014 }
3015
3016 hres = IMoniker_BindToStorage(mon, bctx, NULL, tymed == TYMED_ISTREAM ? &IID_IStream : &IID_IUnknown, (void**)&unk);
3017 if ((test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3018 && hres == HRESULT_FROM_WIN32(ERROR_INTERNET_NAME_NOT_RESOLVED))
3019 {
3020 skip("Network unreachable, skipping tests\n");
3021 return;
3022 }
3023
3024 if(only_check_prot_args) {
3025 ok(hres == E_FAIL, "Got %08x\n", hres);
3026 CHECK_CALLED(OnStopBinding);
3027 } else if(abort_start)
3028 ok(hres == abort_hres, "IMoniker_BindToStorage failed: %08x, expected %08x\n", hres, abort_hres);
3029 else if(abort_progress)
3030 ok(hres == MK_S_ASYNCHRONOUS, "IMoniker_BindToStorage failed: %08x\n", hres);
3031 else if(no_callback) {
3032 if(emulate_protocol)
3033 ok( WaitForSingleObject(complete_event2, 90000) == WAIT_OBJECT_0, "wait timed out\n" );
3034 ok(hres == S_OK, "IMoniker_BindToStorage failed: %08x\n", hres);
3035 ok(unk != NULL, "unk == NULL\n");
3036 }else if(!(bindf & BINDF_ASYNCHRONOUS) && tymed == TYMED_FILE) {
3037 ok(hres == S_OK, "IMoniker_BindToStorage failed: %08x\n", hres);
3038 ok(unk == NULL, "unk != NULL\n");
3039 }else if(((bindf & BINDF_ASYNCHRONOUS) && !data_available)
3040 || (tymed == TYMED_FILE && test_protocol == FILE_TEST)) {
3041 ok(hres == MK_S_ASYNCHRONOUS, "IMoniker_BindToStorage failed: %08x\n", hres);
3042 ok(unk == NULL, "istr should be NULL\n");
3043 }else if(tymed == TYMED_FILE && test_protocol == ABOUT_TEST) {
3044 ok(hres == INET_E_DATA_NOT_AVAILABLE,
3045 "IMoniker_BindToStorage failed: %08x, expected INET_E_DATA_NOT_AVAILABLE\n", hres);
3046 ok(unk == NULL, "istr should be NULL\n");
3047 }else if((flags & BINDTEST_INVALID_CN) && binding_hres != S_OK) {
3048 ok(hres == binding_hres, "Got %08x\n", hres);
3049 ok(unk == NULL, "Got %p\n", unk);
3050 }else if((flags & BINDTEST_INVALID_CN) && invalid_cn_accepted) {
3051 ok(hres == S_OK, "IMoniker_BindToStorage failed: %08x\n", hres);
3052 ok(unk != NULL, "unk == NULL\n");
3053 if(unk == NULL) {
3054 ok(0, "Expected security problem to be ignored.\n");
3055 invalid_cn_accepted = FALSE;
3056 binding_hres = INET_E_INVALID_CERTIFICATE;
3057 }
3058 }else {
3059 ok(hres == S_OK, "IMoniker_BindToStorage failed: %08x\n", hres);
3060 ok(unk != NULL, "unk == NULL\n");
3061 }
3062 if(unk && callback_read && !no_callback) {
3063 IUnknown_Release(unk);
3064 unk = NULL;
3065 }
3066
3067 if(FAILED(hres) && !(flags & BINDTEST_INVALID_CN) && !(flags & BINDTEST_ABORT_START))
3068 return;
3069
3070 if((bindf & BINDF_ASYNCHRONOUS) && !no_callback) {
3071 while(!stopped_binding && GetMessageA(&msg,NULL,0,0)) {
3072 TranslateMessage(&msg);
3073 DispatchMessageA(&msg);
3074 }
3075 }
3076
3077 if(async_switch) {
3078 CHECK_CALLED(OnProgress_SENDINGREQUEST);
3079 CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
3080 CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
3081 CHECK_CALLED(LockRequest);
3082 CHECK_CALLED(OnStopBinding);
3083 }
3084 if(!no_callback) {
3085 CLEAR_CALLED(QueryInterface_IBindStatusCallbackEx); /* IE 8 */
3086 CHECK_CALLED(GetBindInfo);
3087 if(abort_start)
3088 todo_wine CHECK_CALLED(QueryInterface_IInternetProtocol);
3089 else
3090 CHECK_CALLED(QueryInterface_IInternetProtocol);
3091 if(!emulate_protocol) {
3092 if(abort_start)
3093 todo_wine CHECK_CALLED(QueryService_IInternetProtocol);
3094 else
3095 CHECK_CALLED(QueryService_IInternetProtocol);
3096 }
3097 CHECK_CALLED(OnStartBinding);
3098 }
3099 if(emulate_protocol) {
3100 if(is_urlmon_protocol(test_protocol))
3101 CLEAR_CALLED(SetPriority); /* Not called by IE11 */
3102 CHECK_CALLED(Start);
3103 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST
3104 || test_protocol == WINETEST_SYNC_TEST) {
3105 if(tymed == TYMED_FILE)
3106 CLEAR_CALLED(Read);
3107 CHECK_CALLED(Terminate);
3108 }
3109 if(tymed != TYMED_FILE || (test_protocol != ABOUT_TEST && test_protocol != ITS_TEST))
3110 CHECK_CALLED(UnlockRequest);
3111 }else {
3112 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST) {
3113 CLEAR_CALLED(QueryService_IInternetBindInfo);
3114 if(!abort_start)
3115 CHECK_CALLED(QueryInterface_IHttpNegotiate);
3116 CLEAR_CALLED(QueryInterface_IWindowForBindingUI);
3117 CLEAR_CALLED(QueryService_IWindowForBindingUI);
3118 CLEAR_CALLED(GetWindow_IWindowForBindingUI);
3119 if(!abort_start)
3120 CHECK_CALLED(BeginningTransaction);
3121 if (have_IHttpNegotiate2 && !abort_start)
3122 {
3123 CHECK_CALLED(QueryInterface_IHttpNegotiate2);
3124 CHECK_CALLED(GetRootSecurityId);
3125 }
3126 if(http_is_first) {
3127 if (! proxy_active())
3128 {
3129 CHECK_CALLED(OnProgress_FINDINGRESOURCE);
3130 CHECK_CALLED(OnProgress_CONNECTING);
3131 }
3132 else
3133 {
3134 CLEAR_CALLED(OnProgress_FINDINGRESOURCE);
3135 CLEAR_CALLED(OnProgress_CONNECTING);
3136 }
3137 }else if(!abort_start) {
3138 if(allow_finding_resource)
3139 CLEAR_CALLED(OnProgress_FINDINGRESOURCE);
3140 /* IE7 does call this */
3141 CLEAR_CALLED(OnProgress_CONNECTING);
3142 }
3143 if((flags & BINDTEST_INVALID_CN) && !invalid_cn_accepted) {
3144 CHECK_CALLED(QueryInterface_IHttpSecurity);
3145 CHECK_CALLED(QueryService_IHttpSecurity);
3146 CHECK_CALLED(OnSecurityProblem);
3147 }else {
3148 CHECK_NOT_CALLED(QueryInterface_IHttpSecurity);
3149 CHECK_NOT_CALLED(QueryService_IHttpSecurity);
3150 CHECK_NOT_CALLED(OnSecurityProblem);
3151 }
3152 }
3153 if(!no_callback) {
3154 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == FILE_TEST || test_protocol == WINETEST_TEST) {
3155 if(flags & BINDTEST_INVALID_CN)
3156 CLEAR_CALLED(OnProgress_SENDINGREQUEST);
3157 else if(!abort_start)
3158 CHECK_CALLED(OnProgress_SENDINGREQUEST);
3159 } else if(test_protocol == FTP_TEST)
3160 todo_wine CHECK_CALLED(OnProgress_SENDINGREQUEST);
3161 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == WINETEST_TEST) {
3162 CLEAR_CALLED(QueryInterface_IHttpNegotiate);
3163 if((!(flags & BINDTEST_INVALID_CN) || (binding_hres == S_OK)) && !abort_start) {
3164 CHECK_CALLED(OnResponse);
3165 }
3166 }
3167 if((!(flags & BINDTEST_INVALID_CN) || binding_hres == S_OK) && !abort_start) {
3168 CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
3169 CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
3170 CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
3171 }
3172 if(test_protocol == FILE_TEST)
3173 CHECK_CALLED(OnProgress_CACHEFILENAMEAVAILABLE);
3174 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == FTP_TEST || test_protocol == WINETEST_TEST)
3175 CLEAR_CALLED(OnProgress_DOWNLOADINGDATA);
3176 if((flags & BINDTEST_INVALID_CN)) {
3177 if(binding_hres == S_OK)
3178 CHECK_CALLED(OnDataAvailable);
3179 else
3180 CHECK_NOT_CALLED(OnDataAvailable);
3181 }else if((tymed != TYMED_FILE || test_protocol != ABOUT_TEST) && !abort_start)
3182 CHECK_CALLED(OnDataAvailable);
3183 CHECK_CALLED(OnStopBinding);
3184 }
3185 }
3186
3187 ok(IMoniker_Release(mon) == 0, "mon should be destroyed here\n");
3188 if(bctx)
3189 ok(IBindCtx_Release(bctx) == 0, "bctx should be destroyed here\n");
3190
3191 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3192 http_is_first = FALSE;
3193
3194 if((flags & BINDTEST_INVALID_CN) && onsecurityproblem_hres == S_OK && security_problem != ERROR_INTERNET_SEC_CERT_ERRORS)
3195 invalid_cn_accepted = TRUE;
3196
3197 if(unk) {
3198 BYTE buf[512];
3199 DWORD readed;
3200 IStream *stream;
3201
3202 hres = IUnknown_QueryInterface(unk, &IID_IStream, (void**)&stream);
3203 ok(hres == S_OK, "Could not get IStream iface: %08x\n", hres);
3204 IUnknown_Release(unk);
3205
3206 do {
3207 readed = 0xdeadbeef;
3208 hres = IStream_Read(stream, buf, sizeof(buf), &readed);
3209 ok(readed != 0xdeadbeef, "readed = 0xdeadbeef\n");
3210 if(emulate_protocol && test_protocol == HTTP_TEST && readed)
3211 ok(buf[0] == (use_cache_file && !(bindf&BINDF_ASYNCHRONOUS) ? 'X' : '?'), "buf[0] = '%c'\n", buf[0]);
3212 }while(hres == S_OK);
3213 ok(hres == S_FALSE, "IStream_Read returned %08x\n", hres);
3214 ok(!readed, "readed = %d\n", readed);
3215
3216 IStream_Release(stream);
3217 }
3218 }
3219
3220 static void test_BindToObject(int protocol, DWORD flags, HRESULT exhres)
3221 {
3222 IMoniker *mon;
3223 HRESULT hres;
3224 LPOLESTR display_name;
3225 IBindCtx *bctx;
3226 DWORD regid;
3227 MSG msg;
3228 IUnknown *unk = (IUnknown*)0x00ff00ff;
3229 IBinding *bind;
3230
3231 init_bind_test(protocol, BINDTEST_TOOBJECT|flags, TYMED_ISTREAM);
3232 binding_hres = exhres;
3233
3234 if(emulate_protocol)
3235 CoRegisterClassObject(&CLSID_HTMLDocument, (IUnknown *)&mime_cf,
3236 CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &regid);
3237
3238 SET_EXPECT(QueryInterface_IServiceProvider);
3239 hres = CreateAsyncBindCtx(0, (IBindStatusCallback*)&objbsc, NULL, &bctx);
3240 ok(hres == S_OK, "CreateAsyncBindCtx failed: %08x\n\n", hres);
3241 CHECK_CALLED(QueryInterface_IServiceProvider);
3242 if(FAILED(hres))
3243 return;
3244
3245 hres = CreateURLMoniker(NULL, current_url, &mon);
3246 ok(hres == S_OK, "failed to create moniker: %08x\n", hres);
3247 if(FAILED(hres)) {
3248 IBindCtx_Release(bctx);
3249 return;
3250 }
3251
3252 hres = IMoniker_QueryInterface(mon, &IID_IBinding, (void**)&bind);
3253 ok(hres == E_NOINTERFACE, "IMoniker should not have IBinding interface\n");
3254 if(SUCCEEDED(hres))
3255 IBinding_Release(bind);
3256
3257 hres = IMoniker_GetDisplayName(mon, bctx, NULL, &display_name);
3258 ok(hres == S_OK, "GetDisplayName failed %08x\n", hres);
3259 ok(!lstrcmpW(display_name, current_url), "GetDisplayName got wrong name\n");
3260 CoTaskMemFree(display_name);
3261
3262 SET_EXPECT(QueryInterface_IBindStatusCallbackEx);
3263 SET_EXPECT(Obj_GetBindInfo);
3264 SET_EXPECT(QueryInterface_IInternetProtocol);
3265 if(!emulate_protocol)
3266 SET_EXPECT(QueryService_IInternetProtocol);
3267 SET_EXPECT(Obj_OnStartBinding);
3268 if(emulate_protocol) {
3269 if(is_urlmon_protocol(test_protocol))
3270 SET_EXPECT(SetPriority);
3271 SET_EXPECT(Start);
3272 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3273 SET_EXPECT(Terminate);
3274 if(test_protocol == FILE_TEST)
3275 SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
3276 SET_EXPECT(UnlockRequest);
3277 }else {
3278 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
3279 SET_EXPECT(QueryInterface_IHttpNegotiate);
3280 SET_EXPECT(BeginningTransaction);
3281 SET_EXPECT(QueryInterface_IHttpNegotiate2);
3282 SET_EXPECT(GetRootSecurityId);
3283 if(http_is_first)
3284 SET_EXPECT(Obj_OnProgress_FINDINGRESOURCE);
3285 SET_EXPECT(Obj_OnProgress_CONNECTING);
3286 SET_EXPECT(QueryInterface_IWindowForBindingUI);
3287 SET_EXPECT(QueryService_IWindowForBindingUI);
3288 SET_EXPECT(GetWindow_IWindowForBindingUI);
3289 }
3290 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == FILE_TEST)
3291 SET_EXPECT(Obj_OnProgress_SENDINGREQUEST);
3292 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
3293 SET_EXPECT(QueryInterface_IHttpNegotiate);
3294 SET_EXPECT(OnResponse);
3295 }
3296 SET_EXPECT(Obj_OnProgress_MIMETYPEAVAILABLE);
3297 SET_EXPECT(Obj_OnProgress_BEGINDOWNLOADDATA);
3298 if(test_protocol == FILE_TEST)
3299 SET_EXPECT(Obj_OnProgress_CACHEFILENAMEAVAILABLE);
3300 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3301 SET_EXPECT(OnProgress_DOWNLOADINGDATA);
3302 SET_EXPECT(Obj_OnProgress_ENDDOWNLOADDATA);
3303 if(SUCCEEDED(hres))
3304 SET_EXPECT(Obj_OnProgress_CLASSIDAVAILABLE);
3305 SET_EXPECT(Obj_OnProgress_BEGINSYNCOPERATION);
3306 if(exhres == REGDB_E_CLASSNOTREG) {
3307 SET_EXPECT(QueryInterface_IWindowForBindingUI);
3308 SET_EXPECT(QueryService_IWindowForBindingUI);
3309 SET_EXPECT(GetWindow_ICodeInstall);
3310 }
3311 SET_EXPECT(Obj_OnProgress_ENDSYNCOPERATION);
3312 if(SUCCEEDED(hres))
3313 SET_EXPECT(OnObjectAvailable);
3314 SET_EXPECT(Obj_OnStopBinding);
3315 }
3316
3317 hres = IMoniker_BindToObject(mon, bctx, NULL, &IID_IUnknown, (void**)&unk);
3318
3319 if ((test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3320 && hres == HRESULT_FROM_WIN32(ERROR_INTERNET_NAME_NOT_RESOLVED))
3321 {
3322 skip( "Network unreachable, skipping tests\n" );
3323 return;
3324 }
3325
3326 if(FAILED(exhres)) {
3327 ok(hres == exhres, "BindToObject failed: %08x, expected %08x\n", hres, exhres);
3328 ok(!unk, "unk = %p, expected NULL\n", unk);
3329 }else if(bindf & BINDF_ASYNCHRONOUS) {
3330 ok(hres == MK_S_ASYNCHRONOUS, "IMoniker_BindToObject failed: %08x\n", hres);
3331 ok(unk == NULL, "istr should be NULL\n");
3332 }else {
3333 ok(hres == S_OK, "IMoniker_BindToStorage failed: %08x\n", hres);
3334 ok(unk != NULL, "unk == NULL\n");
3335 if(emulate_protocol)
3336 ok(unk == (IUnknown*)&PersistMoniker, "unk != PersistMoniker\n");
3337 }
3338 if(unk)
3339 IUnknown_Release(unk);
3340
3341 while((bindf & BINDF_ASYNCHRONOUS) &&
3342 !((!emulate_protocol || stopped_binding) && stopped_obj_binding) && GetMessageA(&msg,NULL,0,0)) {
3343 TranslateMessage(&msg);
3344 DispatchMessageA(&msg);
3345 }
3346
3347 CLEAR_CALLED(QueryInterface_IBindStatusCallbackEx);
3348 CHECK_CALLED(Obj_GetBindInfo);
3349 CHECK_CALLED(QueryInterface_IInternetProtocol);
3350 if(!emulate_protocol)
3351 CHECK_CALLED(QueryService_IInternetProtocol);
3352 CHECK_CALLED(Obj_OnStartBinding);
3353 if(emulate_protocol) {
3354 if(is_urlmon_protocol(test_protocol))
3355 CLEAR_CALLED(SetPriority); /* Not called by IE11 */
3356 CHECK_CALLED(Start);
3357 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3358 CHECK_CALLED(Terminate);
3359 if(test_protocol == FILE_TEST)
3360 CLEAR_CALLED(OnProgress_MIMETYPEAVAILABLE); /* not called in IE7 */
3361 CHECK_CALLED(UnlockRequest);
3362 }else {
3363 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
3364 CHECK_CALLED(QueryInterface_IHttpNegotiate);
3365 CHECK_CALLED(BeginningTransaction);
3366 if (have_IHttpNegotiate2)
3367 {
3368 CHECK_CALLED(QueryInterface_IHttpNegotiate2);
3369 CHECK_CALLED(GetRootSecurityId);
3370 }
3371 if(http_is_first) {
3372 CHECK_CALLED(Obj_OnProgress_FINDINGRESOURCE);
3373 CHECK_CALLED(Obj_OnProgress_CONNECTING);
3374 }else {
3375 /* IE7 does call this */
3376 CLEAR_CALLED(Obj_OnProgress_CONNECTING);
3377 }
3378 CLEAR_CALLED(QueryInterface_IWindowForBindingUI);
3379 CLEAR_CALLED(QueryService_IWindowForBindingUI);
3380 CLEAR_CALLED(GetWindow_IWindowForBindingUI);
3381 }
3382 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == FILE_TEST) {
3383 if(post_test)
3384 CLEAR_CALLED(Obj_OnProgress_SENDINGREQUEST);
3385 else
3386 CHECK_CALLED(Obj_OnProgress_SENDINGREQUEST);
3387 }
3388 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
3389 CLEAR_CALLED(QueryInterface_IHttpNegotiate);
3390 CHECK_CALLED(OnResponse);
3391 }
3392 CHECK_CALLED(Obj_OnProgress_MIMETYPEAVAILABLE);
3393 CHECK_CALLED(Obj_OnProgress_BEGINDOWNLOADDATA);
3394 if(test_protocol == FILE_TEST)
3395 CHECK_CALLED(Obj_OnProgress_CACHEFILENAMEAVAILABLE);
3396 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3397 CLEAR_CALLED(OnProgress_DOWNLOADINGDATA);
3398 CLEAR_CALLED(Obj_OnProgress_ENDDOWNLOADDATA);
3399 if(SUCCEEDED(hres))
3400 CHECK_CALLED(Obj_OnProgress_CLASSIDAVAILABLE);
3401 CHECK_CALLED(Obj_OnProgress_BEGINSYNCOPERATION);
3402 if(exhres == REGDB_E_CLASSNOTREG) {
3403 todo_wine CHECK_CALLED(QueryInterface_IWindowForBindingUI);
3404 todo_wine CHECK_CALLED(QueryService_IWindowForBindingUI);
3405 todo_wine CHECK_CALLED(GetWindow_ICodeInstall);
3406 }
3407 CHECK_CALLED(Obj_OnProgress_ENDSYNCOPERATION);
3408 if(SUCCEEDED(hres))
3409 CHECK_CALLED(OnObjectAvailable);
3410 CHECK_CALLED(Obj_OnStopBinding);
3411 }
3412
3413 ok(IMoniker_Release(mon) == 0, "mon should be destroyed here\n");
3414 if(test_protocol != HTTP_TEST || emulate_protocol || !(bindf & BINDF_ASYNCHRONOUS))
3415 ok(IBindCtx_Release(bctx) == 0, "bctx should be destroyed here\n");
3416 else
3417 IBindCtx_Release(bctx);
3418
3419 if(emulate_protocol)
3420 CoRevokeClassObject(regid);
3421
3422 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3423 http_is_first = FALSE;
3424 }
3425
3426 static void test_URLDownloadToFile(DWORD prot, BOOL emul)
3427 {
3428 BOOL res;
3429 HRESULT hres;
3430
3431 init_bind_test(prot, BINDTEST_FILEDWLAPI | (emul ? BINDTEST_EMULATE : 0), TYMED_FILE);
3432
3433 SET_EXPECT(GetBindInfo);
3434 SET_EXPECT(QueryInterface_IInternetProtocol);
3435 SET_EXPECT(QueryInterface_IServiceProvider);
3436 if(!emulate_protocol)
3437 SET_EXPECT(QueryService_IInternetProtocol);
3438 SET_EXPECT(OnStartBinding);
3439 if(emulate_protocol) {
3440 if(is_urlmon_protocol(test_protocol))
3441 SET_EXPECT(SetPriority);
3442 SET_EXPECT(Start);
3443 SET_EXPECT(UnlockRequest);
3444 }else {
3445 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
3446 SET_EXPECT(QueryInterface_IHttpNegotiate);
3447 SET_EXPECT(BeginningTransaction);
3448 SET_EXPECT(QueryInterface_IHttpNegotiate2);
3449 SET_EXPECT(GetRootSecurityId);
3450 SET_EXPECT(QueryInterface_IWindowForBindingUI);
3451 SET_EXPECT(OnProgress_CONNECTING);
3452 }
3453 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST || test_protocol == FILE_TEST)
3454 SET_EXPECT(OnProgress_SENDINGREQUEST);
3455 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
3456 SET_EXPECT(QueryInterface_IHttpNegotiate);
3457 SET_EXPECT(OnResponse);
3458 }
3459 SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
3460 SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
3461 if(test_protocol == FILE_TEST)
3462 SET_EXPECT(OnProgress_CACHEFILENAMEAVAILABLE);
3463 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3464 SET_EXPECT(OnProgress_DOWNLOADINGDATA);
3465 SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
3466 SET_EXPECT(OnStopBinding);
3467 }
3468
3469 hres = URLDownloadToFileW(NULL, current_url, dwl_htmlW, 0, (IBindStatusCallback*)&bsc);
3470 ok(hres == S_OK, "URLDownloadToFile failed: %08x\n", hres);
3471
3472 CHECK_CALLED(GetBindInfo);
3473 CHECK_CALLED(QueryInterface_IInternetProtocol);
3474 if(!emulate_protocol) {
3475 CHECK_CALLED(QueryInterface_IServiceProvider);
3476 CHECK_CALLED(QueryService_IInternetProtocol);
3477 }else {
3478 CLEAR_CALLED(QueryInterface_IServiceProvider);
3479 }
3480 CHECK_CALLED(OnStartBinding);
3481 if(emulate_protocol) {
3482 if(is_urlmon_protocol(test_protocol))
3483 CLEAR_CALLED(SetPriority); /* Not called by IE11 */
3484 CHECK_CALLED(Start);
3485 CHECK_CALLED(UnlockRequest);
3486 }else {
3487 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
3488 CHECK_CALLED(QueryInterface_IHttpNegotiate);
3489 CHECK_CALLED(BeginningTransaction);
3490 if (have_IHttpNegotiate2)
3491 {
3492 CHECK_CALLED(QueryInterface_IHttpNegotiate2);
3493 CHECK_CALLED(GetRootSecurityId);
3494 }
3495 CLEAR_CALLED(QueryInterface_IWindowForBindingUI);
3496 CLEAR_CALLED(OnProgress_CONNECTING);
3497 }
3498 if(test_protocol == FILE_TEST)
3499 CHECK_CALLED(OnProgress_SENDINGREQUEST);
3500 else if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3501 CLEAR_CALLED(OnProgress_SENDINGREQUEST); /* not called by IE7 */
3502 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST) {
3503 CLEAR_CALLED(QueryInterface_IHttpNegotiate);
3504 CHECK_CALLED(OnResponse);
3505 }
3506 CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
3507 CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
3508 if(test_protocol == FILE_TEST)
3509 CHECK_CALLED(OnProgress_CACHEFILENAMEAVAILABLE);
3510 if(test_protocol == HTTP_TEST || test_protocol == HTTPS_TEST)
3511 CLEAR_CALLED(OnProgress_DOWNLOADINGDATA);
3512 CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
3513 CHECK_CALLED(OnStopBinding);
3514 }
3515
3516 res = DeleteFileA(dwl_htmlA);
3517 ok(res, "DeleteFile failed: %u\n", GetLastError());
3518
3519 if(prot != FILE_TEST || emul)
3520 return;
3521
3522 hres = URLDownloadToFileW(NULL, current_url, dwl_htmlW, 0, NULL);
3523 ok(hres == S_OK, "URLDownloadToFile failed: %08x\n", hres);
3524
3525 res = DeleteFileA(dwl_htmlA);
3526 ok(res, "DeleteFile failed: %u\n", GetLastError());
3527 }
3528
3529 static void test_URLDownloadToFile_abort(void)
3530 {
3531 HRESULT hres;
3532
3533 init_bind_test(HTTP_TEST, BINDTEST_FILEDWLAPI|BINDTEST_ABORT_PROGRESS, TYMED_FILE);
3534
3535 SET_EXPECT(GetBindInfo);
3536 SET_EXPECT(QueryInterface_IInternetProtocol);
3537 SET_EXPECT(QueryInterface_IServiceProvider);
3538 SET_EXPECT(QueryService_IInternetProtocol);
3539 SET_EXPECT(OnStartBinding);
3540 SET_EXPECT(QueryInterface_IHttpNegotiate);
3541 SET_EXPECT(QueryInterface_IHttpNegotiate2);
3542 SET_EXPECT(BeginningTransaction);
3543 SET_EXPECT(GetRootSecurityId);
3544 SET_EXPECT(QueryInterface_IWindowForBindingUI);
3545 SET_EXPECT(OnProgress_CONNECTING);
3546 SET_EXPECT(OnProgress_SENDINGREQUEST);
3547 SET_EXPECT(OnStopBinding);
3548
3549 hres = URLDownloadToFileW(NULL, current_url, dwl_htmlW, 0, (IBindStatusCallback*)&bsc);
3550 ok(hres == E_ABORT, "URLDownloadToFile failed: %08x, expected E_ABORT\n", hres);
3551
3552 CHECK_CALLED(GetBindInfo);
3553 CHECK_CALLED(QueryInterface_IInternetProtocol);
3554 CHECK_CALLED(QueryInterface_IServiceProvider);
3555 CHECK_CALLED(QueryService_IInternetProtocol);
3556 CHECK_CALLED(OnStartBinding);
3557 CHECK_CALLED(QueryInterface_IHttpNegotiate);
3558 CHECK_CALLED(QueryInterface_IHttpNegotiate2);
3559 CHECK_CALLED(BeginningTransaction);
3560 CHECK_CALLED(GetRootSecurityId);
3561 CLEAR_CALLED(QueryInterface_IWindowForBindingUI);
3562 CHECK_CALLED(OnProgress_SENDINGREQUEST);
3563 CLEAR_CALLED(OnProgress_CONNECTING);
3564 CHECK_CALLED(OnStopBinding);
3565
3566 init_bind_test(HTTP_TEST, BINDTEST_FILEDWLAPI|BINDTEST_ABORT_START, TYMED_FILE);
3567
3568 SET_EXPECT(GetBindInfo);
3569 SET_EXPECT(QueryInterface_IInternetProtocol);
3570 SET_EXPECT(QueryInterface_IServiceProvider);
3571 SET_EXPECT(QueryService_IInternetProtocol);
3572 SET_EXPECT(OnStartBinding);
3573 SET_EXPECT(OnStopBinding);
3574
3575 abort_hres = E_ABORT;
3576 hres = URLDownloadToFileW(NULL, current_url, dwl_htmlW, 0, (IBindStatusCallback*)&bsc);
3577 ok(hres == E_ABORT, "URLDownloadToFile failed: %08x, expected E_ABORT\n", hres);
3578
3579 CHECK_CALLED(GetBindInfo);
3580 todo_wine CHECK_CALLED(QueryInterface_IInternetProtocol);
3581 todo_wine CHECK_CALLED(QueryInterface_IServiceProvider);
3582 todo_wine CHECK_CALLED(QueryService_IInternetProtocol);
3583 CHECK_CALLED(OnStartBinding);
3584 CHECK_CALLED(OnStopBinding);
3585
3586 init_bind_test(HTTP_TEST, BINDTEST_FILEDWLAPI|BINDTEST_ABORT_START, TYMED_FILE);
3587
3588 SET_EXPECT(GetBindInfo);
3589 SET_EXPECT(QueryInterface_IInternetProtocol);
3590 SET_EXPECT(QueryInterface_IServiceProvider);
3591 SET_EXPECT(QueryService_IInternetProtocol);
3592 SET_EXPECT(OnStartBinding);
3593 SET_EXPECT(QueryInterface_IHttpNegotiate);
3594 SET_EXPECT(QueryInterface_IHttpNegotiate2);
3595 SET_EXPECT(BeginningTransaction);
3596 SET_EXPECT(GetRootSecurityId);
3597 SET_EXPECT(QueryInterface_IWindowForBindingUI);
3598 SET_EXPECT(OnResponse);
3599 SET_EXPECT(OnProgress_CONNECTING);
3600 SET_EXPECT(OnProgress_SENDINGREQUEST);
3601 SET_EXPECT(OnProgress_MIMETYPEAVAILABLE);
3602 SET_EXPECT(OnProgress_BEGINDOWNLOADDATA);
3603 SET_EXPECT(OnProgress_DOWNLOADINGDATA);
3604 SET_EXPECT(OnProgress_ENDDOWNLOADDATA);
3605 SET_EXPECT(OnStopBinding);
3606
3607 /* URLDownloadToFile doesn't abort if E_NOTIMPL is returned from the
3608 * IBindStatusCallback's OnStartBinding function.
3609 */
3610 abort_hres = E_NOTIMPL;
3611 hres = URLDownloadToFileW(NULL, current_url, dwl_htmlW, 0, (IBindStatusCallback*)&bsc);
3612 ok(hres == S_OK, "URLDownloadToFile failed: %08x\n", hres);
3613
3614 CHECK_CALLED(GetBindInfo);
3615 CHECK_CALLED(QueryInterface_IInternetProtocol);
3616 CHECK_CALLED(QueryInterface_IServiceProvider);
3617 CHECK_CALLED(QueryService_IInternetProtocol);
3618 CHECK_CALLED(OnStartBinding);
3619 CHECK_CALLED(QueryInterface_IHttpNegotiate);
3620 CHECK_CALLED(QueryInterface_IHttpNegotiate2);
3621 CHECK_CALLED(BeginningTransaction);
3622 CHECK_CALLED(GetRootSecurityId);
3623 CLEAR_CALLED(QueryInterface_IWindowForBindingUI);
3624 CHECK_CALLED(OnResponse);
3625 CLEAR_CALLED(OnProgress_CONNECTING);
3626 CHECK_CALLED(OnProgress_SENDINGREQUEST);
3627 CHECK_CALLED(OnProgress_MIMETYPEAVAILABLE);
3628 CHECK_CALLED(OnProgress_BEGINDOWNLOADDATA);
3629 CHECK_CALLED(OnProgress_DOWNLOADINGDATA);
3630 CHECK_CALLED(OnProgress_ENDDOWNLOADDATA);
3631 CHECK_CALLED(OnStopBinding);
3632
3633 DeleteFileA(dwl_htmlA);
3634 }
3635
3636 static void set_file_url(char *path)
3637 {
3638 CHAR file_urlA[INTERNET_MAX_URL_LENGTH];
3639
3640 lstrcpyA(file_urlA, "file://");
3641 lstrcatA(file_urlA, path);
3642 MultiByteToWideChar(CP_ACP, 0, file_urlA, -1, file_url, INTERNET_MAX_URL_LENGTH);
3643 }
3644
3645 static void create_file(const char *file_name, const char *content)
3646 {
3647 HANDLE file;
3648 DWORD size;
3649 CHAR path[MAX_PATH];
3650
3651 file = CreateFileA(file_name, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
3652 FILE_ATTRIBUTE_NORMAL, NULL);
3653 ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n");
3654 if(file == INVALID_HANDLE_VALUE)
3655 return;
3656
3657 if(test_file)
3658 DeleteFileA(test_file);
3659 test_file = file_name;
3660 WriteFile(file, content, strlen(content), &size, NULL);
3661 CloseHandle(file);
3662
3663 GetCurrentDirectoryA(MAX_PATH, path);
3664 lstrcatA(path, "\\");
3665 lstrcatA(path, file_name);
3666 set_file_url(path);
3667 }
3668
3669 static void create_html_file(void)
3670 {
3671 create_file(wszIndexHtmlA, "<HTML></HTML>");
3672 }
3673
3674 static void create_cache_file(void)
3675 {
3676 char buf[6500], curdir[MAX_PATH];
3677 HANDLE file;
3678 DWORD size;
3679
3680 file = CreateFileA(test_txtA, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
3681 FILE_ATTRIBUTE_NORMAL, NULL);
3682 ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n");
3683 if(file == INVALID_HANDLE_VALUE)
3684 return;
3685
3686 memset(buf, 'X', sizeof(buf));
3687 WriteFile(file, buf, sizeof(buf), &size, NULL);
3688 CloseHandle(file);
3689
3690 memset(curdir, 0, sizeof(curdir));
3691 GetCurrentDirectoryA(MAX_PATH, curdir);
3692 lstrcatA(curdir, "\\");
3693 lstrcatA(curdir, test_txtA);
3694
3695 MultiByteToWideChar(CP_ACP, 0, curdir, -1, cache_file_name, MAX_PATH);
3696 }
3697
3698 static void test_ReportResult(HRESULT exhres)
3699 {
3700 IMoniker *mon = NULL;
3701 IBindCtx *bctx = NULL;
3702 IUnknown *unk = (void*)0xdeadbeef;
3703 HRESULT hres;
3704
3705 init_bind_test(ABOUT_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
3706 binding_hres = exhres;
3707
3708 hres = CreateURLMoniker(NULL, about_blankW, &mon);
3709 ok(hres == S_OK, "CreateURLMoniker failed: %08x\n", hres);
3710
3711 SET_EXPECT(QueryInterface_IServiceProvider);
3712 hres = CreateAsyncBindCtx(0, (IBindStatusCallback*)&bsc, NULL, &bctx);
3713 ok(hres == S_OK, "CreateAsyncBindCtx failed: %08x\n\n", hres);
3714 CHECK_CALLED(QueryInterface_IServiceProvider);
3715
3716 SET_EXPECT(QueryInterface_IBindStatusCallbackEx);
3717 SET_EXPECT(GetBindInfo);
3718 SET_EXPECT(QueryInterface_IInternetProtocol);
3719 SET_EXPECT(OnStartBinding);
3720 if(is_urlmon_protocol(test_protocol))
3721 SET_EXPECT(SetPriority);
3722 SET_EXPECT(Start);
3723
3724 hres = IMoniker_BindToStorage(mon, bctx, NULL, &IID_IStream, (void**)&unk);
3725 if(SUCCEEDED(exhres))
3726 ok(hres == S_OK || hres == MK_S_ASYNCHRONOUS, "BindToStorage failed: %08x\n", hres);
3727 else
3728 ok(hres == exhres || hres == MK_S_ASYNCHRONOUS,
3729 "BindToStorage failed: %08x, expected %08x or MK_S_ASYNCHRONOUS\n", hres, exhres);
3730
3731 CLEAR_CALLED(QueryInterface_IBindStatusCallbackEx); /* IE 8 */
3732 CHECK_CALLED(GetBindInfo);
3733 CHECK_CALLED(QueryInterface_IInternetProtocol);
3734 CHECK_CALLED(OnStartBinding);
3735 if(is_urlmon_protocol(test_protocol))
3736 CLEAR_CALLED(SetPriority); /* Not called by IE11 */
3737 CHECK_CALLED(Start);
3738
3739 ok(unk == NULL, "unk=%p\n", unk);
3740
3741 IBindCtx_Release(bctx);
3742 IMoniker_Release(mon);
3743 }
3744
3745 static void test_BindToStorage_fail(void)
3746 {
3747 IMoniker *mon = NULL;
3748 IBindCtx *bctx = NULL;
3749 IUnknown *unk;
3750 HRESULT hres;
3751
3752 hres = CreateURLMoniker(NULL, about_blankW, &mon);
3753 ok(hres == S_OK, "CreateURLMoniker failed: %08x\n", hres);
3754 if(FAILED(hres))
3755 return;
3756
3757 hres = pCreateAsyncBindCtxEx(NULL, 0, NULL, NULL, &bctx, 0);
3758 ok(hres == S_OK, "CreateAsyncBindCtxEx failed: %08x\n", hres);
3759
3760 unk = (void*)0xdeadbeef;
3761 hres = IMoniker_BindToStorage(mon, bctx, NULL, &IID_IStream, (void**)&unk);
3762 ok(hres == MK_E_SYNTAX || hres == INET_E_DATA_NOT_AVAILABLE,
3763 "hres=%08x, expected MK_E_SYNTAX or INET_E_DATA_NOT_AVAILABLE\n", hres);
3764 ok(unk == NULL, "got %p\n", unk);
3765
3766 IBindCtx_Release(bctx);
3767
3768 IMoniker_Release(mon);
3769
3770 test_ReportResult(E_NOTIMPL);
3771 test_ReportResult(S_FALSE);
3772 }
3773
3774 static void test_StdURLMoniker(void)
3775 {
3776 IMoniker *mon, *async_mon;
3777 LPOLESTR display_name;
3778 IBindCtx *bctx;
3779 IUnknown *unk;
3780 HRESULT hres;
3781
3782 hres = CoCreateInstance(&IID_IInternet, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
3783 &IID_IMoniker, (void**)&mon);
3784 ok(hres == S_OK, "Could not create IInternet instance: %08x\n", hres);
3785 if(FAILED(hres))
3786 return;
3787
3788 hres = IMoniker_QueryInterface(mon, &IID_IAsyncMoniker, (void**)&async_mon);
3789 ok(hres == S_OK, "Could not get IAsyncMoniker iface: %08x\n", hres);
3790 ok(mon == async_mon, "mon != async_mon\n");
3791 IMoniker_Release(async_mon);
3792
3793 hres = IMoniker_GetDisplayName(mon, NULL, NULL, &display_name);
3794 ok(hres == E_OUTOFMEMORY, "GetDisplayName failed: %08x, expected E_OUTOFMEMORY\n", hres);
3795
3796 if(pCreateUri) {
3797 IUriContainer *uri_container;
3798 IUri *uri;
3799
3800 hres = IMoniker_QueryInterface(mon, &IID_IUriContainer, (void**)&uri_container);
3801 ok(hres == S_OK, "Could not get IUriMoniker iface: %08x\n", hres);
3802
3803
3804 uri = (void*)0xdeadbeef;
3805 hres = IUriContainer_GetIUri(uri_container, &uri);
3806 ok(hres == S_FALSE, "GetIUri failed: %08x\n", hres);
3807 ok(!uri, "uri = %p, expected NULL\n", uri);
3808
3809 IUriContainer_Release(uri_container);
3810 }
3811
3812 SET_EXPECT(QueryInterface_IServiceProvider);
3813 hres = CreateAsyncBindCtx(0, (IBindStatusCallback*)&bsc, NULL, &bctx);
3814 ok(hres == S_OK, "CreateAsyncBindCtx failed: %08x\n\n", hres);
3815 CHECK_CALLED(QueryInterface_IServiceProvider);
3816
3817 if(pCreateUri) { /* Skip these tests on old IEs */
3818 unk = (void*)0xdeadbeef;
3819 hres = IMoniker_BindToStorage(mon, bctx, NULL, &IID_IStream, (void**)&unk);
3820 ok(hres == MK_E_SYNTAX, "BindToStorage failed: %08x, expected MK_E_SYNTAX\n", hres);
3821 ok(!unk, "unk = %p\n", unk);
3822
3823 unk = (void*)0xdeadbeef;
3824 hres = IMoniker_BindToObject(mon, bctx, NULL, &IID_IUnknown, (void**)&unk);
3825 ok(hres == MK_E_SYNTAX, "BindToStorage failed: %08x, expected MK_E_SYNTAX\n", hres);
3826 ok(!unk, "unk = %p\n", unk);
3827 }
3828
3829 IMoniker_Release(mon);
3830 }
3831
3832 static void register_protocols(void)
3833 {
3834 IInternetSession *session;
3835 HRESULT hres;
3836
3837 static const WCHAR winetestW[] = {'w','i','n','e','t','e','s','t',0};
3838
3839 hres = CoInternetGetSession(0, &session, 0);
3840 ok(hres == S_OK, "CoInternetGetSession failed: %08x\n", hres);
3841 if(FAILED(hres))
3842 return;
3843
3844 hres = IInternetSession_RegisterNameSpace(session, &protocol_cf, &IID_NULL,
3845 winetestW, 0, NULL, 0);
3846 ok(hres == S_OK, "RegisterNameSpace failed: %08x\n", hres);
3847
3848 IInternetSession_Release(session);
3849 }
3850
3851 START_TEST(url)
3852 {
3853 HMODULE hurlmon;
3854
3855 hurlmon = GetModuleHandleA("urlmon.dll");
3856 pCreateAsyncBindCtxEx = (void*) GetProcAddress(hurlmon, "CreateAsyncBindCtxEx");
3857
3858 if(!GetProcAddress(hurlmon, "CompareSecurityIds")) {
3859 win_skip("Too old IE\n");
3860 return;
3861 }
3862
3863 pCreateUri = (void*) GetProcAddress(hurlmon, "CreateUri");
3864 if(!pCreateUri)
3865 win_skip("IUri not supported\n");
3866
3867 complete_event = CreateEventW(NULL, FALSE, FALSE, NULL);
3868 complete_event2 = CreateEventW(NULL, FALSE, FALSE, NULL);
3869 thread_id = GetCurrentThreadId();
3870 create_html_file();
3871 create_cache_file();
3872 register_protocols();
3873
3874 test_create();
3875
3876 trace("test CreateAsyncBindCtx...\n");
3877 test_CreateAsyncBindCtx();
3878
3879 trace("test CreateAsyncBindCtxEx...\n");
3880 test_CreateAsyncBindCtxEx();
3881
3882 trace("test RegisterBindStatusCallback...\n");
3883 if(test_RegisterBindStatusCallback()) {
3884 trace("test BindToStorage failures...\n");
3885 test_BindToStorage_fail();
3886
3887 trace("synchronous http test (COM not initialised)...\n");
3888 test_BindToStorage(HTTP_TEST, 0, TYMED_ISTREAM);
3889
3890 CoInitialize(NULL);
3891
3892 trace("test StdURLMoniker...\n");
3893 test_StdURLMoniker();
3894
3895 trace("synchronous http test...\n");
3896 test_BindToStorage(HTTP_TEST, 0, TYMED_ISTREAM);
3897
3898 trace("emulated synchronous http test (to file)...\n");
3899 test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE, TYMED_FILE);
3900
3901 trace("synchronous http test (to object)...\n");
3902 test_BindToObject(HTTP_TEST, 0, S_OK);
3903
3904 trace("emulated synchronous http test (with cache)...\n");
3905 test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE|BINDTEST_USE_CACHE, TYMED_ISTREAM);
3906
3907 trace("emulated synchronous http test (with cache, no read)...\n");
3908 test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE|BINDTEST_USE_CACHE|BINDTEST_NO_CALLBACK_READ, TYMED_ISTREAM);
3909
3910 trace("synchronous http test (with cache, no read)...\n");
3911 test_BindToStorage(HTTP_TEST, BINDTEST_USE_CACHE|BINDTEST_NO_CALLBACK_READ, TYMED_ISTREAM);
3912
3913 trace("synchronous file test...\n");
3914 test_BindToStorage(FILE_TEST, 0, TYMED_ISTREAM);
3915
3916 trace("emulated synchronous file test (to file)...\n");
3917 test_BindToStorage(FILE_TEST, BINDTEST_EMULATE, TYMED_FILE);
3918
3919 trace("synchronous file test (to object)...\n");
3920 test_BindToObject(FILE_TEST, 0, S_OK);
3921
3922 trace("bind to an object of not registered MIME type...\n");
3923 create_file("test.winetest", "\x01\x02\x03xxxxxxxxxxxxxxxxxxxxxxxxx");
3924 test_BindToObject(FILE_TEST, 0, REGDB_E_CLASSNOTREG);
3925 create_html_file();
3926
3927 trace("file test (no callback)...\n");
3928 test_BindToStorage(FILE_TEST, BINDTEST_NO_CALLBACK, TYMED_ISTREAM);
3929
3930 trace("synchronous https test (invalid CN, dialog)\n");
3931 onsecurityproblem_hres = S_FALSE;
3932 http_is_first = TRUE;
3933 test_BindToStorage(HTTPS_TEST, BINDTEST_INVALID_CN, TYMED_ISTREAM);
3934
3935 bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA;
3936
3937 trace("asynchronous https test (invalid CN, fail)\n");
3938 onsecurityproblem_hres = E_FAIL;
3939 test_BindToStorage(HTTPS_TEST, BINDTEST_INVALID_CN, TYMED_ISTREAM);
3940
3941 trace("asynchronous https test (invalid CN, accept)\n");
3942 onsecurityproblem_hres = S_OK;
3943 test_BindToStorage(HTTPS_TEST, BINDTEST_INVALID_CN, TYMED_ISTREAM);
3944
3945 trace("asynchronous https test (invalid CN, dialog 2)\n");
3946 onsecurityproblem_hres = S_FALSE;
3947 test_BindToStorage(HTTPS_TEST, BINDTEST_INVALID_CN, TYMED_ISTREAM);
3948 invalid_cn_accepted = FALSE;
3949
3950 trace("winetest test (async switch)...\n");
3951 test_BindToStorage(WINETEST_TEST, BINDTEST_EMULATE|BINDTEST_ASYNC_SWITCH, TYMED_ISTREAM);
3952
3953 trace("about test (no read)...\n");
3954 test_BindToStorage(ABOUT_TEST, BINDTEST_NO_CALLBACK_READ, TYMED_ISTREAM);
3955
3956 trace("http test...\n");
3957 test_BindToStorage(HTTP_TEST, 0, TYMED_ISTREAM);
3958
3959 trace("http test (to file)...\n");
3960 test_BindToStorage(HTTP_TEST, 0, TYMED_FILE);
3961
3962 trace("http test (to object)...\n");
3963 test_BindToObject(HTTP_TEST, 0, S_OK);
3964
3965 trace("http test (short response)...\n");
3966 test_BindToStorage(HTTP_TEST, BINDTEST_HTTPRESPONSE|BINDTEST_ALLOW_FINDINGRESOURCE, TYMED_ISTREAM);
3967
3968 trace("http test (short response, to object)...\n");
3969 test_BindToObject(HTTP_TEST, 0, S_OK);
3970
3971 trace("http test (abort start binding E_NOTIMPL)...\n");
3972 abort_hres = E_NOTIMPL;
3973 test_BindToStorage(HTTP_TEST, BINDTEST_ABORT_START, TYMED_FILE);
3974
3975 trace("http test (abort start binding E_ABORT)...\n");
3976 abort_hres = E_ABORT;
3977 test_BindToStorage(HTTP_TEST, BINDTEST_ABORT_START, TYMED_FILE);
3978
3979 trace("http test (abort progress)...\n");
3980 test_BindToStorage(HTTP_TEST, BINDTEST_ABORT_PROGRESS|BINDTEST_ALLOW_FINDINGRESOURCE, TYMED_FILE);
3981
3982 trace("emulated http test...\n");
3983 test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
3984
3985 trace("emulated http test (to object)...\n");
3986 test_BindToObject(HTTP_TEST, BINDTEST_EMULATE, S_OK);
3987
3988 trace("emulated http test (to object, redirect)...\n");
3989 test_BindToObject(HTTP_TEST, BINDTEST_EMULATE|BINDTEST_REDIRECT, S_OK);
3990
3991 trace("emulated http test (to file)...\n");
3992 test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE, TYMED_FILE);
3993
3994 trace("emulated http test (redirect)...\n");
3995 test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE|BINDTEST_REDIRECT, TYMED_ISTREAM);
3996
3997 trace("emulated http test (with cache)...\n");
3998 test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE|BINDTEST_USE_CACHE, TYMED_ISTREAM);
3999
4000 trace("winetest test (no callback)...\n");
4001 test_BindToStorage(WINETEST_TEST, BINDTEST_EMULATE|BINDTEST_NO_CALLBACK|BINDTEST_USE_CACHE, TYMED_ISTREAM);
4002
4003 trace("asynchronous https test...\n");
4004 test_BindToStorage(HTTPS_TEST, 0, TYMED_ISTREAM);
4005
4006 trace("emulated https test...\n");
4007 test_BindToStorage(HTTPS_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
4008
4009 trace("about test...\n");
4010 test_BindToStorage(ABOUT_TEST, 0, TYMED_ISTREAM);
4011
4012 trace("about test (to file)...\n");
4013 test_BindToStorage(ABOUT_TEST, 0, TYMED_FILE);
4014
4015 trace("about test (to object)...\n");
4016 test_BindToObject(ABOUT_TEST, 0, S_OK);
4017
4018 trace("emulated about test...\n");
4019 test_BindToStorage(ABOUT_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
4020
4021 trace("emulated about test (to file)...\n");
4022 test_BindToStorage(ABOUT_TEST, BINDTEST_EMULATE, TYMED_FILE);
4023
4024 trace("emulated about test (to object)...\n");
4025 test_BindToObject(ABOUT_TEST, BINDTEST_EMULATE, S_OK);
4026
4027 trace("emulalated test reporting result in read...\n");
4028 test_BindToStorage(WINETEST_SYNC_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
4029
4030 trace("file test...\n");
4031 test_BindToStorage(FILE_TEST, 0, TYMED_ISTREAM);
4032
4033 trace("file test (to file)...\n");
4034 test_BindToStorage(FILE_TEST, 0, TYMED_FILE);
4035
4036 trace("file test (to object)...\n");
4037 test_BindToObject(FILE_TEST, 0, S_OK);
4038
4039 trace("emulated file test...\n");
4040 test_BindToStorage(FILE_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
4041
4042 trace("emulated file test (to file)...\n");
4043 test_BindToStorage(FILE_TEST, BINDTEST_EMULATE, TYMED_FILE);
4044
4045 trace("emulated file test (to object)...\n");
4046 test_BindToObject(FILE_TEST, BINDTEST_EMULATE, S_OK);
4047
4048 trace("emulated its test...\n");
4049 test_BindToStorage(ITS_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
4050
4051 trace("emulated its test (to file)...\n");
4052 test_BindToStorage(ITS_TEST, BINDTEST_EMULATE, TYMED_FILE);
4053
4054 trace("emulated mk test...\n");
4055 test_BindToStorage(MK_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
4056
4057 trace("test URLDownloadToFile for file protocol...\n");
4058 test_URLDownloadToFile(FILE_TEST, FALSE);
4059
4060 trace("test URLDownloadToFile for emulated file protocol...\n");
4061 test_URLDownloadToFile(FILE_TEST, TRUE);
4062
4063 trace("test URLDownloadToFile for http protocol...\n");
4064 test_URLDownloadToFile(HTTP_TEST, FALSE);
4065
4066 trace("test URLDownloadToFile abort...\n");
4067 test_URLDownloadToFile_abort();
4068
4069 trace("test emulated http abort...\n");
4070 test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE|BINDTEST_ABORT, TYMED_ISTREAM);
4071
4072 bindf |= BINDF_NOWRITECACHE;
4073
4074 trace("ftp test...\n");
4075 test_BindToStorage(FTP_TEST, 0, TYMED_ISTREAM);
4076
4077 trace("test failures...\n");
4078 test_BindToStorage_fail();
4079
4080 bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE;
4081 only_check_prot_args = TRUE; /* Fail after checking arguments to Protocol_Start */
4082
4083 trace("check emulated http protocol arguments...\n");
4084 test_BindToStorage(HTTP_TEST, BINDTEST_EMULATE, TYMED_ISTREAM);
4085 }
4086
4087 DeleteFileA(test_file);
4088 DeleteFileA(test_txtA);
4089 CloseHandle(complete_event);
4090 CloseHandle(complete_event2);
4091 CoUninitialize();
4092 }
A free Windows-compatible Operating System