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