?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
urlmon/tests: Remove stray ok() call.
[wine/multimedia.git] / dlls / urlmon / tests / protocol.c
blob889f3a9e0a73387230181a53d9aff2c722666f92
1 /*
2 * Copyright 2005-2011 Jacek Caban for CodeWeavers
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19 #define COBJMACROS
20 #define CONST_VTABLE
21
22 #include <wine/test.h>
23 #include <stdarg.h>
24 #include <stdio.h>
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "ole2.h"
29 #include "urlmon.h"
30 #include "wininet.h"
31
32 static HRESULT (WINAPI *pCoInternetGetSession)(DWORD, IInternetSession **, DWORD);
33 static HRESULT (WINAPI *pReleaseBindInfo)(BINDINFO*);
34 static HRESULT (WINAPI *pCreateUri)(LPCWSTR, DWORD, DWORD_PTR, IUri**);
35
36 #define DEFINE_EXPECT(func) \
37 static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
38
39 #define SET_EXPECT(func) \
40 expect_ ## func = TRUE
41
42 #define CHECK_EXPECT2(func) \
43 do { \
44 ok(expect_ ##func, "unexpected call " #func "\n"); \
45 called_ ## func = TRUE; \
46 }while(0)
47
48 #define CHECK_EXPECT(func) \
49 do { \
50 CHECK_EXPECT2(func); \
51 expect_ ## func = FALSE; \
52 }while(0)
53
54 #define CHECK_CALLED(func) \
55 do { \
56 ok(called_ ## func, "expected " #func "\n"); \
57 expect_ ## func = called_ ## func = FALSE; \
58 }while(0)
59
60 #define CHECK_NOT_CALLED(func) \
61 do { \
62 ok(!called_ ## func, "unexpected " #func "\n"); \
63 expect_ ## func = called_ ## func = FALSE; \
64 }while(0)
65
66 #define CLEAR_CALLED(func) \
67 expect_ ## func = called_ ## func = FALSE
68
69 DEFINE_EXPECT(GetBindInfo);
70 DEFINE_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
71 DEFINE_EXPECT(ReportProgress_DIRECTBIND);
72 DEFINE_EXPECT(ReportProgress_RAWMIMETYPE);
73 DEFINE_EXPECT(ReportProgress_FINDINGRESOURCE);
74 DEFINE_EXPECT(ReportProgress_CONNECTING);
75 DEFINE_EXPECT(ReportProgress_SENDINGREQUEST);
76 DEFINE_EXPECT(ReportProgress_CACHEFILENAMEAVAILABLE);
77 DEFINE_EXPECT(ReportProgress_VERIFIEDMIMETYPEAVAILABLE);
78 DEFINE_EXPECT(ReportProgress_PROTOCOLCLASSID);
79 DEFINE_EXPECT(ReportProgress_COOKIE_SENT);
80 DEFINE_EXPECT(ReportProgress_REDIRECTING);
81 DEFINE_EXPECT(ReportProgress_ENCODING);
82 DEFINE_EXPECT(ReportProgress_ACCEPTRANGES);
83 DEFINE_EXPECT(ReportProgress_PROXYDETECTING);
84 DEFINE_EXPECT(ReportProgress_LOADINGMIMEHANDLER);
85 DEFINE_EXPECT(ReportProgress_DECODING);
86 DEFINE_EXPECT(ReportData);
87 DEFINE_EXPECT(ReportData2);
88 DEFINE_EXPECT(ReportResult);
89 DEFINE_EXPECT(GetBindString_ACCEPT_MIMES);
90 DEFINE_EXPECT(GetBindString_USER_AGENT);
91 DEFINE_EXPECT(GetBindString_POST_COOKIE);
92 DEFINE_EXPECT(GetBindString_URL);
93 DEFINE_EXPECT(QueryService_HttpNegotiate);
94 DEFINE_EXPECT(QueryService_InternetProtocol);
95 DEFINE_EXPECT(QueryService_HttpSecurity);
96 DEFINE_EXPECT(QueryInterface_IWinInetInfo);
97 DEFINE_EXPECT(QueryInterface_IWinInetHttpInfo);
98 DEFINE_EXPECT(BeginningTransaction);
99 DEFINE_EXPECT(GetRootSecurityId);
100 DEFINE_EXPECT(OnResponse);
101 DEFINE_EXPECT(Switch);
102 DEFINE_EXPECT(Continue);
103 DEFINE_EXPECT(CreateInstance);
104 DEFINE_EXPECT(Start);
105 DEFINE_EXPECT(StartEx);
106 DEFINE_EXPECT(Terminate);
107 DEFINE_EXPECT(Read);
108 DEFINE_EXPECT(Read2);
109 DEFINE_EXPECT(SetPriority);
110 DEFINE_EXPECT(LockRequest);
111 DEFINE_EXPECT(UnlockRequest);
112 DEFINE_EXPECT(Abort);
113 DEFINE_EXPECT(MimeFilter_CreateInstance);
114 DEFINE_EXPECT(MimeFilter_Start);
115 DEFINE_EXPECT(MimeFilter_ReportData);
116 DEFINE_EXPECT(MimeFilter_ReportResult);
117 DEFINE_EXPECT(MimeFilter_Terminate);
118 DEFINE_EXPECT(MimeFilter_LockRequest);
119 DEFINE_EXPECT(MimeFilter_UnlockRequest);
120 DEFINE_EXPECT(MimeFilter_Read);
121 DEFINE_EXPECT(MimeFilter_Switch);
122 DEFINE_EXPECT(MimeFilter_Continue);
123 DEFINE_EXPECT(Stream_Seek);
124 DEFINE_EXPECT(Stream_Read);
125
126 static const WCHAR wszIndexHtml[] = {'i','n','d','e','x','.','h','t','m','l',0};
127 static const WCHAR index_url[] =
128 {'f','i','l','e',':','i','n','d','e','x','.','h','t','m','l',0};
129
130 static const WCHAR acc_mimeW[] = {'*','/','*',0};
131 static const WCHAR user_agentW[] = {'W','i','n','e',0};
132 static const WCHAR text_htmlW[] = {'t','e','x','t','/','h','t','m','l',0};
133 static const WCHAR hostW[] = {'w','w','w','.','w','i','n','e','h','q','.','o','r','g',0};
134 static const WCHAR winehq_ipW[] = {'2','0','9','.','4','6','.','2','5','.','1','3','4',0};
135 static const WCHAR emptyW[] = {0};
136 static const WCHAR pjpegW[] = {'i','m','a','g','e','/','p','j','p','e','g',0};
137 static const WCHAR gifW[] = {'i','m','a','g','e','/','g','i','f',0};
138
139 static HRESULT expect_hrResult;
140 static LPCWSTR file_name, http_url, expect_wsz;
141 static IInternetProtocol *async_protocol = NULL;
142 static BOOL first_data_notif, http_is_first, test_redirect;
143 static int prot_state, read_report_data, post_stream_read;
144 static DWORD bindf, ex_priority , pi;
145 static IInternetProtocol *binding_protocol, *filtered_protocol;
146 static IInternetBindInfo *prot_bind_info;
147 static IInternetProtocolSink *binding_sink, *filtered_sink;
148 static void *expect_pv;
149 static HANDLE event_complete, event_complete2, event_continue, event_continue_done;
150 static BOOL binding_test;
151 static PROTOCOLDATA protocoldata, *pdata, continue_protdata;
152 static DWORD prot_read, filter_state, http_post_test, thread_id;
153 static BOOL security_problem, test_async_req, impl_protex;
154 static BOOL async_read_pending, mimefilter_test, direct_read, wait_for_switch, emulate_prot, short_read, test_abort;
155 static BOOL empty_file, no_mime;
156
157 enum {
158 STATE_CONNECTING,
159 STATE_SENDINGREQUEST,
160 STATE_STARTDOWNLOADING,
161 STATE_DOWNLOADING
162 } state;
163
164 static enum {
165 FILE_TEST,
166 HTTP_TEST,
167 HTTPS_TEST,
168 FTP_TEST,
169 MK_TEST,
170 ITS_TEST,
171 BIND_TEST
172 } tested_protocol;
173
174 static const WCHAR protocol_names[][10] = {
175 {'f','i','l','e',0},
176 {'h','t','t','p',0},
177 {'h','t','t','p','s',0},
178 {'f','t','p',0},
179 {'m','k',0},
180 {'i','t','s',0},
181 {'t','e','s','t',0}
182 };
183
184 static const WCHAR binding_urls[][130] = {
185 {'f','i','l','e',':','t','e','s','t','.','h','t','m','l',0},
186 {'h','t','t','p',':','/','/','w','w','w','.','w','i','n','e','h','q','.',
187 'o','r','g','/','s','i','t','e','/','a','b','o','u','t',0},
188 {'h','t','t','p','s',':','/','/','w','w','w','.','c','o','d','e','w','e','a','v','e','r','s',
189 '.','c','o','m','/','t','e','s','t','.','h','t','m','l',0},
190 {'f','t','p',':','/','/','f','t','p','.','w','i','n','e','h','q','.','o','r','g',
191 '/','p','u','b','/','o','t','h','e','r',
192 '/','w','i','n','e','l','o','g','o','.','x','c','f','.','t','a','r','.','b','z','2',0},
193 {'m','k',':','t','e','s','t',0},
194 {'i','t','s',':','t','e','s','t','.','c','h','m',':',':','/','b','l','a','n','k','.','h','t','m','l',0},
195 {'t','e','s','t',':','/','/','f','i','l','e','.','h','t','m','l',0}
196 };
197
198 static const CHAR post_data[] = "mode=Test";
199
200 static const char *debugstr_guid(REFIID riid)
201 {
202 static char buf[50];
203
204 sprintf(buf, "{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}",
205 riid->Data1, riid->Data2, riid->Data3, riid->Data4[0],
206 riid->Data4[1], riid->Data4[2], riid->Data4[3], riid->Data4[4],
207 riid->Data4[5], riid->Data4[6], riid->Data4[7]);
208
209 return buf;
210 }
211
212 static int strcmp_wa(LPCWSTR strw, const char *stra)
213 {
214 CHAR buf[512];
215 WideCharToMultiByte(CP_ACP, 0, strw, -1, buf, sizeof(buf), NULL, NULL);
216 return lstrcmpA(stra, buf);
217 }
218
219 static HRESULT WINAPI HttpSecurity_QueryInterface(IHttpSecurity *iface, REFIID riid, void **ppv)
220 {
221 if(IsEqualGUID(&IID_IUnknown, riid)
222 || IsEqualGUID(&IID_IHttpSecurity, riid)) {
223 *ppv = iface;
224 return S_OK;
225 }
226
227 ok(0, "unexpected call\n");
228 return E_NOINTERFACE;
229 }
230
231 static ULONG WINAPI HttpSecurity_AddRef(IHttpSecurity *iface)
232 {
233 return 2;
234 }
235
236 static ULONG WINAPI HttpSecurity_Release(IHttpSecurity *iface)
237 {
238 return 1;
239 }
240
241 static HRESULT WINAPI HttpSecurity_GetWindow(IHttpSecurity* iface, REFGUID rguidReason, HWND *phwnd)
242 {
243 trace("HttpSecurity_GetWindow\n");
244
245 return S_FALSE;
246 }
247
248 static HRESULT WINAPI HttpSecurity_OnSecurityProblem(IHttpSecurity *iface, DWORD dwProblem)
249 {
250 trace("Security problem: %u\n", dwProblem);
251 ok(dwProblem == ERROR_INTERNET_SEC_CERT_REV_FAILED, "Expected ERROR_INTERNET_SEC_CERT_REV_FAILED got %u\n", dwProblem);
252
253 /* Only retry once */
254 if (security_problem)
255 return E_ABORT;
256
257 security_problem = TRUE;
258 SET_EXPECT(BeginningTransaction);
259
260 return RPC_E_RETRY;
261 }
262
263 static IHttpSecurityVtbl HttpSecurityVtbl = {
264 HttpSecurity_QueryInterface,
265 HttpSecurity_AddRef,
266 HttpSecurity_Release,
267 HttpSecurity_GetWindow,
268 HttpSecurity_OnSecurityProblem
269 };
270
271 static IHttpSecurity http_security = { &HttpSecurityVtbl };
272
273 static HRESULT WINAPI HttpNegotiate_QueryInterface(IHttpNegotiate2 *iface, REFIID riid, void **ppv)
274 {
275 if(IsEqualGUID(&IID_IUnknown, riid)
276 || IsEqualGUID(&IID_IHttpNegotiate, riid)
277 || IsEqualGUID(&IID_IHttpNegotiate2, riid)) {
278 *ppv = iface;
279 return S_OK;
280 }
281
282 ok(0, "unexpected call\n");
283 return E_NOINTERFACE;
284 }
285
286 static ULONG WINAPI HttpNegotiate_AddRef(IHttpNegotiate2 *iface)
287 {
288 return 2;
289 }
290
291 static ULONG WINAPI HttpNegotiate_Release(IHttpNegotiate2 *iface)
292 {
293 return 1;
294 }
295
296 static HRESULT WINAPI HttpNegotiate_BeginningTransaction(IHttpNegotiate2 *iface, LPCWSTR szURL,
297 LPCWSTR szHeaders, DWORD dwReserved, LPWSTR *pszAdditionalHeaders)
298 {
299 LPWSTR addl_headers;
300
301 static const WCHAR wszHeaders[] =
302 {'C','o','n','t','e','n','t','-','T','y','p','e',':',' ','a','p','p','l','i','c','a','t',
303 'i','o','n','/','x','-','w','w','w','-','f','o','r','m','-','u','r','l','e','n','c','o',
304 'd','e','d','\r','\n',0};
305
306 CHECK_EXPECT(BeginningTransaction);
307
308 if(binding_test)
309 ok(!lstrcmpW(szURL, binding_urls[tested_protocol]), "szURL != http_url\n");
310 else
311 ok(!lstrcmpW(szURL, http_url), "szURL != http_url\n");
312 ok(!dwReserved, "dwReserved=%d, expected 0\n", dwReserved);
313 ok(pszAdditionalHeaders != NULL, "pszAdditionalHeaders == NULL\n");
314 if(pszAdditionalHeaders)
315 {
316 ok(*pszAdditionalHeaders == NULL, "*pszAdditionalHeaders != NULL\n");
317 if (http_post_test)
318 {
319 addl_headers = CoTaskMemAlloc(sizeof(wszHeaders));
320 memcpy(addl_headers, wszHeaders, sizeof(wszHeaders));
321 *pszAdditionalHeaders = addl_headers;
322 }
323 }
324
325 return S_OK;
326 }
327
328 static HRESULT WINAPI HttpNegotiate_OnResponse(IHttpNegotiate2 *iface, DWORD dwResponseCode,
329 LPCWSTR szResponseHeaders, LPCWSTR szRequestHeaders, LPWSTR *pszAdditionalRequestHeaders)
330 {
331 CHECK_EXPECT(OnResponse);
332
333 ok(dwResponseCode == 200, "dwResponseCode=%d, expected 200\n", dwResponseCode);
334 ok(szResponseHeaders != NULL, "szResponseHeaders == NULL\n");
335 ok(szRequestHeaders == NULL, "szRequestHeaders != NULL\n");
336 ok(pszAdditionalRequestHeaders == NULL, "pszAdditionalHeaders != NULL\n");
337
338 return S_OK;
339 }
340
341 static HRESULT WINAPI HttpNegotiate_GetRootSecurityId(IHttpNegotiate2 *iface,
342 BYTE *pbSecurityId, DWORD *pcbSecurityId, DWORD_PTR dwReserved)
343 {
344 static const BYTE sec_id[] = {'h','t','t','p',':','t','e','s','t',1,0,0,0};
345
346 CHECK_EXPECT(GetRootSecurityId);
347
348 ok(!dwReserved, "dwReserved=%ld, expected 0\n", dwReserved);
349 ok(pbSecurityId != NULL, "pbSecurityId == NULL\n");
350 ok(pcbSecurityId != NULL, "pcbSecurityId == NULL\n");
351
352 if(pcbSecurityId) {
353 ok(*pcbSecurityId == 512, "*pcbSecurityId=%d, expected 512\n", *pcbSecurityId);
354 *pcbSecurityId = sizeof(sec_id);
355 }
356
357 if(pbSecurityId)
358 memcpy(pbSecurityId, sec_id, sizeof(sec_id));
359
360 return E_FAIL;
361 }
362
363 static IHttpNegotiate2Vtbl HttpNegotiateVtbl = {
364 HttpNegotiate_QueryInterface,
365 HttpNegotiate_AddRef,
366 HttpNegotiate_Release,
367 HttpNegotiate_BeginningTransaction,
368 HttpNegotiate_OnResponse,
369 HttpNegotiate_GetRootSecurityId
370 };
371
372 static IHttpNegotiate2 http_negotiate = { &HttpNegotiateVtbl };
373
374 static HRESULT QueryInterface(REFIID,void**);
375
376 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppv)
377 {
378 return QueryInterface(riid, ppv);
379 }
380
381 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
382 {
383 return 2;
384 }
385
386 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
387 {
388 return 1;
389 }
390
391 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface, REFGUID guidService,
392 REFIID riid, void **ppv)
393 {
394 if(IsEqualGUID(&IID_IHttpNegotiate, guidService) || IsEqualGUID(&IID_IHttpNegotiate2, riid)) {
395 CHECK_EXPECT2(QueryService_HttpNegotiate);
396 return IHttpNegotiate2_QueryInterface(&http_negotiate, riid, ppv);
397 }
398
399 if(IsEqualGUID(&IID_IInternetProtocol, guidService)) {
400 ok(IsEqualGUID(&IID_IInternetProtocol, riid), "unexpected riid\n");
401 CHECK_EXPECT(QueryService_InternetProtocol);
402 return E_NOINTERFACE;
403 }
404
405 if(IsEqualGUID(&IID_IHttpSecurity, guidService)) {
406 ok(IsEqualGUID(&IID_IHttpSecurity, riid), "unexpected riid\n");
407 CHECK_EXPECT(QueryService_HttpSecurity);
408 return IHttpSecurity_QueryInterface(&http_security, riid, ppv);
409 }
410
411 ok(0, "unexpected service %s\n", debugstr_guid(guidService));
412 return E_FAIL;
413 }
414
415 static const IServiceProviderVtbl ServiceProviderVtbl = {
416 ServiceProvider_QueryInterface,
417 ServiceProvider_AddRef,
418 ServiceProvider_Release,
419 ServiceProvider_QueryService
420 };
421
422 static IServiceProvider service_provider = { &ServiceProviderVtbl };
423
424 static HRESULT WINAPI Stream_QueryInterface(IStream *iface, REFIID riid, void **ppv)
425 {
426 ok(0, "unexpected call\n");
427 return E_NOINTERFACE;
428 }
429
430 static ULONG WINAPI Stream_AddRef(IStream *iface)
431 {
432 return 2;
433 }
434
435 static ULONG WINAPI Stream_Release(IStream *iface)
436 {
437 return 1;
438 }
439
440 static HRESULT WINAPI Stream_Read(IStream *iface, void *pv,
441 ULONG cb, ULONG *pcbRead)
442 {
443 CHECK_EXPECT2(Stream_Read);
444
445 ok(GetCurrentThreadId() != thread_id, "wrong thread %d\n", GetCurrentThreadId());
446
447 ok(pv != NULL, "pv == NULL\n");
448 ok(cb == 0x20000 || broken(cb == 0x2000), "cb = %d\n", cb);
449 ok(pcbRead != NULL, "pcbRead == NULL\n");
450
451 if(post_stream_read) {
452 *pcbRead = 0;
453 return S_FALSE;
454 }
455
456 memcpy(pv, post_data, sizeof(post_data)-1);
457 post_stream_read += *pcbRead = sizeof(post_data)-1;
458 return S_OK;
459 }
460
461 static HRESULT WINAPI Stream_Write(IStream *iface, const void *pv,
462 ULONG cb, ULONG *pcbWritten)
463 {
464 ok(0, "unexpected call\n");
465 return E_NOTIMPL;
466 }
467
468 static HRESULT WINAPI Stream_Seek(IStream *iface, LARGE_INTEGER dlibMove,
469 DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
470 {
471 CHECK_EXPECT(Stream_Seek);
472
473 ok(!dlibMove.QuadPart, "dlibMove != 0\n");
474 ok(dwOrigin == STREAM_SEEK_SET, "dwOrigin = %d\n", dwOrigin);
475 ok(!plibNewPosition, "plibNewPosition == NULL\n");
476
477 return S_OK;
478 }
479
480 static HRESULT WINAPI Stream_SetSize(IStream *iface, ULARGE_INTEGER libNewSize)
481 {
482 ok(0, "unexpected call\n");
483 return E_NOTIMPL;
484 }
485
486 static HRESULT WINAPI Stream_CopyTo(IStream *iface, IStream *pstm,
487 ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
488 {
489 ok(0, "unexpected call\n");
490 return E_NOTIMPL;
491 }
492
493 static HRESULT WINAPI Stream_Commit(IStream *iface, DWORD grfCommitFlags)
494 {
495 ok(0, "unexpected call\n");
496 return E_NOTIMPL;
497 }
498
499 static HRESULT WINAPI Stream_Revert(IStream *iface)
500 {
501 ok(0, "unexpected call\n");
502 return E_NOTIMPL;
503 }
504
505 static HRESULT WINAPI Stream_LockRegion(IStream *iface, ULARGE_INTEGER libOffset,
506 ULARGE_INTEGER cb, DWORD dwLockType)
507 {
508 ok(0, "unexpected call\n");
509 return E_NOTIMPL;
510 }
511
512 static HRESULT WINAPI Stream_UnlockRegion(IStream *iface,
513 ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
514 {
515 ok(0, "unexpected call\n");
516 return E_NOTIMPL;
517 }
518
519 static HRESULT WINAPI Stream_Stat(IStream *iface, STATSTG *pstatstg,
520 DWORD dwStatFlag)
521 {
522 ok(0, "unexpected call\n");
523 return E_NOTIMPL;
524 }
525
526 static HRESULT WINAPI Stream_Clone(IStream *iface, IStream **ppstm)
527 {
528 ok(0, "unexpected call\n");
529 return E_NOTIMPL;
530 }
531
532 static const IStreamVtbl StreamVtbl = {
533 Stream_QueryInterface,
534 Stream_AddRef,
535 Stream_Release,
536 Stream_Read,
537 Stream_Write,
538 Stream_Seek,
539 Stream_SetSize,
540 Stream_CopyTo,
541 Stream_Commit,
542 Stream_Revert,
543 Stream_LockRegion,
544 Stream_UnlockRegion,
545 Stream_Stat,
546 Stream_Clone
547 };
548
549 static IStream Stream = { &StreamVtbl };
550
551 static HRESULT WINAPI ProtocolSink_QueryInterface(IInternetProtocolSink *iface, REFIID riid, void **ppv)
552 {
553 return QueryInterface(riid, ppv);
554 }
555
556 static ULONG WINAPI ProtocolSink_AddRef(IInternetProtocolSink *iface)
557 {
558 return 2;
559 }
560
561 static ULONG WINAPI ProtocolSink_Release(IInternetProtocolSink *iface)
562 {
563 return 1;
564 }
565
566 static void call_continue(PROTOCOLDATA *protocol_data)
567 {
568 HRESULT hres;
569
570 if(state == STATE_CONNECTING) {
571 if(tested_protocol == HTTP_TEST || tested_protocol == HTTPS_TEST || tested_protocol == FTP_TEST) {
572 if (http_is_first){
573 CLEAR_CALLED(ReportProgress_FINDINGRESOURCE);
574 CLEAR_CALLED(ReportProgress_PROXYDETECTING);
575 }
576 CLEAR_CALLED(ReportProgress_CONNECTING);
577 }
578 if(tested_protocol == FTP_TEST)
579 todo_wine CHECK_CALLED(ReportProgress_SENDINGREQUEST);
580 else if (tested_protocol != HTTPS_TEST)
581 CHECK_CALLED(ReportProgress_SENDINGREQUEST);
582 if(test_redirect)
583 CHECK_CALLED(ReportProgress_REDIRECTING);
584 state = test_async_req ? STATE_SENDINGREQUEST : STATE_STARTDOWNLOADING;
585 }
586
587 switch(state) {
588 case STATE_SENDINGREQUEST:
589 SET_EXPECT(Stream_Read);
590 SET_EXPECT(ReportProgress_SENDINGREQUEST);
591 break;
592 case STATE_STARTDOWNLOADING:
593 if(tested_protocol == HTTP_TEST || tested_protocol == HTTPS_TEST) {
594 SET_EXPECT(OnResponse);
595 if(tested_protocol == HTTPS_TEST || test_redirect || test_abort || empty_file)
596 SET_EXPECT(ReportProgress_ACCEPTRANGES);
597 SET_EXPECT(ReportProgress_ENCODING);
598 SET_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
599 if(bindf & BINDF_NEEDFILE)
600 SET_EXPECT(ReportProgress_CACHEFILENAMEAVAILABLE);
601 }
602 default:
603 break;
604 }
605
606 if(state != STATE_SENDINGREQUEST)
607 SET_EXPECT(ReportData);
608 hres = IInternetProtocol_Continue(async_protocol, protocol_data);
609 ok(hres == S_OK, "Continue failed: %08x\n", hres);
610 if(tested_protocol == FTP_TEST || security_problem)
611 CLEAR_CALLED(ReportData);
612 else if(state != STATE_SENDINGREQUEST)
613 CHECK_CALLED(ReportData);
614
615 switch(state) {
616 case STATE_SENDINGREQUEST:
617 CHECK_CALLED(Stream_Read);
618 CHECK_CALLED(ReportProgress_SENDINGREQUEST);
619 state = STATE_STARTDOWNLOADING;
620 break;
621 case STATE_STARTDOWNLOADING:
622 if (! security_problem)
623 {
624 state = STATE_DOWNLOADING;
625 if(tested_protocol == HTTP_TEST || tested_protocol == HTTPS_TEST) {
626 CHECK_CALLED(OnResponse);
627 if(tested_protocol == HTTPS_TEST || empty_file)
628 CHECK_CALLED(ReportProgress_ACCEPTRANGES);
629 else if(test_redirect || test_abort)
630 CLEAR_CALLED(ReportProgress_ACCEPTRANGES);
631 CLEAR_CALLED(ReportProgress_ENCODING);
632 CHECK_CALLED(ReportProgress_MIMETYPEAVAILABLE);
633 if(bindf & BINDF_NEEDFILE)
634 CHECK_CALLED(ReportProgress_CACHEFILENAMEAVAILABLE);
635 }
636 }
637 else
638 {
639 security_problem = FALSE;
640 SET_EXPECT(ReportProgress_CONNECTING);
641 }
642 default:
643 break;
644 }
645 }
646
647 static HRESULT WINAPI ProtocolSink_Switch(IInternetProtocolSink *iface, PROTOCOLDATA *pProtocolData)
648 {
649 if(tested_protocol == FTP_TEST)
650 CHECK_EXPECT2(Switch);
651 else
652 CHECK_EXPECT(Switch);
653
654 ok(pProtocolData != NULL, "pProtocolData == NULL\n");
655 if(binding_test) {
656 ok(pProtocolData != &protocoldata, "pProtocolData == &protocoldata\n");
657 ok(pProtocolData->grfFlags == protocoldata.grfFlags, "grfFlags wrong %x/%x\n",
658 pProtocolData->grfFlags, protocoldata.grfFlags );
659 ok(pProtocolData->dwState == protocoldata.dwState, "dwState wrong %x/%x\n",
660 pProtocolData->dwState, protocoldata.dwState );
661 ok(pProtocolData->pData == protocoldata.pData, "pData wrong %p/%p\n",
662 pProtocolData->pData, protocoldata.pData );
663 ok(pProtocolData->cbData == protocoldata.cbData, "cbData wrong %x/%x\n",
664 pProtocolData->cbData, protocoldata.cbData );
665 }
666
667 pdata = pProtocolData;
668
669 if(binding_test) {
670 SetEvent(event_complete);
671 WaitForSingleObject(event_complete2, INFINITE);
672 return S_OK;
673 }if(direct_read) {
674 continue_protdata = *pProtocolData;
675 SetEvent(event_continue);
676 WaitForSingleObject(event_continue_done, INFINITE);
677 }else {
678 call_continue(pProtocolData);
679 SetEvent(event_complete);
680 }
681
682 return S_OK;
683 }
684
685 static const char *status_names[] =
686 {
687 "0",
688 "FINDINGRESOURCE",
689 "CONNECTING",
690 "REDIRECTING",
691 "BEGINDOWNLOADDATA",
692 "DOWNLOADINGDATA",
693 "ENDDOWNLOADDATA",
694 "BEGINDOWNLOADCOMPONENTS",
695 "INSTALLINGCOMPONENTS",
696 "ENDDOWNLOADCOMPONENTS",
697 "USINGCACHEDCOPY",
698 "SENDINGREQUEST",
699 "CLASSIDAVAILABLE",
700 "MIMETYPEAVAILABLE",
701 "CACHEFILENAMEAVAILABLE",
702 "BEGINSYNCOPERATION",
703 "ENDSYNCOPERATION",
704 "BEGINUPLOADDATA",
705 "UPLOADINGDATA",
706 "ENDUPLOADINGDATA",
707 "PROTOCOLCLASSID",
708 "ENCODING",
709 "VERIFIEDMIMETYPEAVAILABLE",
710 "CLASSINSTALLLOCATION",
711 "DECODING",
712 "LOADINGMIMEHANDLER",
713 "CONTENTDISPOSITIONATTACH",
714 "FILTERREPORTMIMETYPE",
715 "CLSIDCANINSTANTIATE",
716 "IUNKNOWNAVAILABLE",
717 "DIRECTBIND",
718 "RAWMIMETYPE",
719 "PROXYDETECTING",
720 "ACCEPTRANGES",
721 "COOKIE_SENT",
722 "COMPACT_POLICY_RECEIVED",
723 "COOKIE_SUPPRESSED",
724 "COOKIE_STATE_UNKNOWN",
725 "COOKIE_STATE_ACCEPT",
726 "COOKIE_STATE_REJECT",
727 "COOKIE_STATE_PROMPT",
728 "COOKIE_STATE_LEASH",
729 "COOKIE_STATE_DOWNGRADE",
730 "POLICY_HREF",
731 "P3P_HEADER",
732 "SESSION_COOKIE_RECEIVED",
733 "PERSISTENT_COOKIE_RECEIVED",
734 "SESSION_COOKIES_ALLOWED",
735 "CACHECONTROL",
736 "CONTENTDISPOSITIONFILENAME",
737 "MIMETEXTPLAINMISMATCH",
738 "PUBLISHERAVAILABLE",
739 "DISPLAYNAMEAVAILABLE"
740 };
741
742 static HRESULT WINAPI ProtocolSink_ReportProgress(IInternetProtocolSink *iface, ULONG ulStatusCode,
743 LPCWSTR szStatusText)
744 {
745 static const WCHAR null_guid[] = {'{','0','0','0','0','0','0','0','0','-','0','0','0','0','-',
746 '0','0','0','0','-','0','0','0','0','-','0','0','0','0','0','0','0','0','0','0','0','0','}',0};
747 static const WCHAR text_plain[] = {'t','e','x','t','/','p','l','a','i','n',0};
748
749 if (ulStatusCode < sizeof(status_names)/sizeof(status_names[0]))
750 trace( "progress: %s %s\n", status_names[ulStatusCode], wine_dbgstr_w(szStatusText) );
751 else
752 trace( "progress: %u %s\n", ulStatusCode, wine_dbgstr_w(szStatusText) );
753
754 switch(ulStatusCode) {
755 case BINDSTATUS_MIMETYPEAVAILABLE:
756 CHECK_EXPECT2(ReportProgress_MIMETYPEAVAILABLE);
757 if(tested_protocol != FILE_TEST && tested_protocol != ITS_TEST && !mimefilter_test && (pi & PI_MIMEVERIFICATION)) {
758 if(!short_read || !direct_read)
759 CHECK_CALLED(Read); /* set in Continue */
760 else if(short_read)
761 CHECK_CALLED(Read2); /* set in Read */
762 }
763 ok(szStatusText != NULL, "szStatusText == NULL\n");
764 if(szStatusText) {
765 if(tested_protocol == BIND_TEST)
766 ok(!lstrcmpW(szStatusText, expect_wsz), "unexpected szStatusText %s\n", wine_dbgstr_w(szStatusText));
767 else if (http_post_test)
768 ok(lstrlenW(text_plain) <= lstrlenW(szStatusText) &&
769 !memcmp(szStatusText, text_plain, lstrlenW(text_plain)*sizeof(WCHAR)),
770 "szStatusText != text/plain\n");
771 else if(empty_file)
772 ok(!strcmp_wa(szStatusText, "application/javascript"), "szStatusText = %s\n", wine_dbgstr_w(szStatusText));
773 else if((pi & PI_MIMEVERIFICATION) && emulate_prot && !mimefilter_test
774 && tested_protocol==HTTP_TEST && !short_read)
775 ok(lstrlenW(gifW) <= lstrlenW(szStatusText) &&
776 !memcmp(szStatusText, gifW, lstrlenW(gifW)*sizeof(WCHAR)),
777 "szStatusText != image/gif\n");
778 else if(!mimefilter_test)
779 ok(lstrlenW(text_htmlW) <= lstrlenW(szStatusText) &&
780 !memcmp(szStatusText, text_htmlW, lstrlenW(text_htmlW)*sizeof(WCHAR)),
781 "szStatusText != text/html\n");
782 }
783 break;
784 case BINDSTATUS_DIRECTBIND:
785 CHECK_EXPECT2(ReportProgress_DIRECTBIND);
786 ok(szStatusText == NULL, "szStatusText != NULL\n");
787 break;
788 case BINDSTATUS_RAWMIMETYPE:
789 CHECK_EXPECT2(ReportProgress_RAWMIMETYPE);
790 ok(szStatusText != NULL, "szStatusText == NULL\n");
791 if(szStatusText)
792 ok(lstrlenW(szStatusText) < lstrlenW(text_htmlW) ||
793 !memcmp(szStatusText, text_htmlW, lstrlenW(text_htmlW)*sizeof(WCHAR)),
794 "szStatusText != text/html\n");
795 break;
796 case BINDSTATUS_CACHEFILENAMEAVAILABLE:
797 CHECK_EXPECT(ReportProgress_CACHEFILENAMEAVAILABLE);
798 ok(szStatusText != NULL, "szStatusText == NULL\n");
799 if(szStatusText) {
800 if(binding_test)
801 ok(!lstrcmpW(szStatusText, expect_wsz), "unexpected szStatusText\n");
802 else if(tested_protocol == FILE_TEST)
803 ok(!lstrcmpW(szStatusText, file_name), "szStatusText = %s\n", wine_dbgstr_w(szStatusText));
804 else
805 ok(szStatusText != NULL, "szStatusText == NULL\n");
806 }
807 break;
808 case BINDSTATUS_FINDINGRESOURCE:
809 CHECK_EXPECT2(ReportProgress_FINDINGRESOURCE);
810 ok(szStatusText != NULL, "szStatusText == NULL\n");
811 break;
812 case BINDSTATUS_CONNECTING:
813 CHECK_EXPECT2(ReportProgress_CONNECTING);
814 ok(szStatusText != NULL, "szStatusText == NULL\n");
815 break;
816 case BINDSTATUS_SENDINGREQUEST:
817 CHECK_EXPECT2(ReportProgress_SENDINGREQUEST);
818 if(tested_protocol == FILE_TEST || tested_protocol == ITS_TEST) {
819 ok(szStatusText != NULL, "szStatusText == NULL\n");
820 if(szStatusText)
821 ok(!*szStatusText, "wrong szStatusText\n");
822 }
823 break;
824 case BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE:
825 CHECK_EXPECT(ReportProgress_VERIFIEDMIMETYPEAVAILABLE);
826 ok(szStatusText != NULL, "szStatusText == NULL\n");
827 if(szStatusText)
828 ok(!strcmp_wa(szStatusText, "text/html"), "szStatusText != text/html\n");
829 break;
830 case BINDSTATUS_PROTOCOLCLASSID:
831 CHECK_EXPECT(ReportProgress_PROTOCOLCLASSID);
832 ok(szStatusText != NULL, "szStatusText == NULL\n");
833 ok(!lstrcmpW(szStatusText, null_guid), "unexpected classid %s\n", wine_dbgstr_w(szStatusText));
834 break;
835 case BINDSTATUS_COOKIE_SENT:
836 CHECK_EXPECT2(ReportProgress_COOKIE_SENT);
837 ok(szStatusText == NULL, "szStatusText != NULL\n");
838 break;
839 case BINDSTATUS_REDIRECTING:
840 CHECK_EXPECT(ReportProgress_REDIRECTING);
841 if(test_redirect)
842 ok(!strcmp_wa(szStatusText, "http://test.winehq.org/tests/hello.html"), "szStatusText = %s\n", wine_dbgstr_w(szStatusText));
843 else
844 ok(szStatusText == NULL, "szStatusText = %s\n", wine_dbgstr_w(szStatusText));
845 break;
846 case BINDSTATUS_ENCODING:
847 CHECK_EXPECT(ReportProgress_ENCODING);
848 ok(!strcmp_wa(szStatusText, "gzip"), "szStatusText = %s\n", wine_dbgstr_w(szStatusText));
849 break;
850 case BINDSTATUS_ACCEPTRANGES:
851 CHECK_EXPECT(ReportProgress_ACCEPTRANGES);
852 ok(!szStatusText, "szStatusText = %s\n", wine_dbgstr_w(szStatusText));
853 break;
854 case BINDSTATUS_PROXYDETECTING:
855 if(!called_ReportProgress_PROXYDETECTING)
856 SET_EXPECT(ReportProgress_CONNECTING);
857 CHECK_EXPECT2(ReportProgress_PROXYDETECTING);
858 ok(!szStatusText, "szStatusText = %s\n", wine_dbgstr_w(szStatusText));
859 break;
860 case BINDSTATUS_LOADINGMIMEHANDLER:
861 CHECK_EXPECT(ReportProgress_LOADINGMIMEHANDLER);
862 ok(!szStatusText, "szStatusText = %s\n", wine_dbgstr_w(szStatusText));
863 break;
864 case BINDSTATUS_DECODING:
865 CHECK_EXPECT(ReportProgress_DECODING);
866 ok(!lstrcmpW(szStatusText, pjpegW), "szStatusText = %s\n", wine_dbgstr_w(szStatusText));
867 break;
868 default:
869 ok(0, "Unexpected status %d\n", ulStatusCode);
870 };
871
872 return S_OK;
873 }
874
875 static HRESULT WINAPI ProtocolSink_ReportData(IInternetProtocolSink *iface, DWORD grfBSCF,
876 ULONG ulProgress, ULONG ulProgressMax)
877 {
878 HRESULT hres;
879
880 static int rec_depth;
881 rec_depth++;
882
883 if(!mimefilter_test && (tested_protocol == FILE_TEST || tested_protocol == ITS_TEST)) {
884 CHECK_EXPECT2(ReportData);
885
886 ok(ulProgress == ulProgressMax, "ulProgress (%d) != ulProgressMax (%d)\n",
887 ulProgress, ulProgressMax);
888 ok(ulProgressMax == 13, "ulProgressMax=%d, expected 13\n", ulProgressMax);
889 /* BSCF_SKIPDRAINDATAFORFILEURLS added in IE8 */
890 if(tested_protocol == FILE_TEST)
891 ok((grfBSCF == (BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION)) ||
892 (grfBSCF == (BSCF_FIRSTDATANOTIFICATION | BSCF_LASTDATANOTIFICATION | BSCF_SKIPDRAINDATAFORFILEURLS)),
893 "grcfBSCF = %08x\n", grfBSCF);
894 else
895 ok(grfBSCF == (BSCF_FIRSTDATANOTIFICATION | BSCF_DATAFULLYAVAILABLE), "grcfBSCF = %08x\n", grfBSCF);
896 }else if(direct_read) {
897 BYTE buf[14096];
898 ULONG read;
899
900 if(!read_report_data && rec_depth == 1) {
901 BOOL reported_all_data = called_ReportData2;
902
903 CHECK_EXPECT2(ReportData);
904
905 if(short_read) {
906 ok(grfBSCF == (BSCF_FIRSTDATANOTIFICATION|BSCF_LASTDATANOTIFICATION|BSCF_DATAFULLYAVAILABLE)
907 || grfBSCF == BSCF_FIRSTDATANOTIFICATION, /* < IE8 */
908 "grcfBSCF = %08x\n", grfBSCF);
909 CHECK_CALLED(Read); /* Set in Continue */
910 first_data_notif = FALSE;
911 }else if(first_data_notif) {
912 ok(grfBSCF == BSCF_FIRSTDATANOTIFICATION, "grcfBSCF = %08x\n", grfBSCF);
913 first_data_notif = FALSE;
914 }else if(reported_all_data) {
915 ok(grfBSCF == (BSCF_LASTDATANOTIFICATION|BSCF_INTERMEDIATEDATANOTIFICATION),
916 "grcfBSCF = %08x\n", grfBSCF);
917 }else if(!direct_read) {
918 ok(grfBSCF == BSCF_INTERMEDIATEDATANOTIFICATION, "grcfBSCF = %08x\n", grfBSCF);
919 }
920
921 do {
922 read = 0;
923 if(emulate_prot)
924 SET_EXPECT(Read);
925 else
926 SET_EXPECT(ReportData2);
927 SET_EXPECT(ReportResult);
928 if(!emulate_prot)
929 SET_EXPECT(Switch);
930 hres = IInternetProtocol_Read(binding_test ? binding_protocol : async_protocol, expect_pv = buf, sizeof(buf), &read);
931 ok(hres == E_PENDING || hres == S_FALSE || hres == S_OK, "Read failed: %08x\n", hres);
932 if(hres == S_OK)
933 ok(read, "read == 0\n");
934 if(reported_all_data)
935 ok(hres == S_FALSE, "Read failed: %08x, expected S_FALSE\n", hres);
936 if(!emulate_prot && hres != E_PENDING)
937 CHECK_NOT_CALLED(Switch); /* otherwise checked in wait_for_switch loop */
938 if(emulate_prot)
939 CHECK_CALLED(Read);
940 if(!reported_all_data && called_ReportData2) {
941 if(!emulate_prot)
942 CHECK_CALLED(ReportData2);
943 CHECK_CALLED(ReportResult);
944 reported_all_data = TRUE;
945 }else {
946 if(!emulate_prot)
947 CHECK_NOT_CALLED(ReportData2);
948 CHECK_NOT_CALLED(ReportResult);
949 }
950 }while(hres == S_OK);
951 if(hres == S_FALSE)
952 wait_for_switch = FALSE;
953 }else {
954 CHECK_EXPECT(ReportData2);
955
956 ok(grfBSCF & BSCF_LASTDATANOTIFICATION, "grfBSCF = %08x\n", grfBSCF);
957
958 read = 0xdeadbeef;
959 if(emulate_prot)
960 SET_EXPECT(Read2);
961 hres = IInternetProtocol_Read(binding_test ? binding_protocol : async_protocol, expect_pv = buf, sizeof(buf), &read);
962 if(emulate_prot)
963 CHECK_CALLED(Read2);
964 ok(hres == S_FALSE, "Read returned: %08x, expected E_FALSE\n", hres);
965 ok(!read, "read = %d\n", read);
966 }
967 }else if(!binding_test && (tested_protocol == HTTP_TEST || tested_protocol == HTTPS_TEST
968 || tested_protocol == FTP_TEST)) {
969 if(empty_file)
970 CHECK_EXPECT2(ReportData);
971 else if(!(grfBSCF & BSCF_LASTDATANOTIFICATION) || (grfBSCF & BSCF_DATAFULLYAVAILABLE))
972 CHECK_EXPECT(ReportData);
973 else if (http_post_test)
974 ok(ulProgress == 13, "Read %u bytes instead of 13\n", ulProgress);
975
976 if(empty_file) {
977 ok(!ulProgress, "ulProgress = %d\n", ulProgress);
978 ok(!ulProgressMax, "ulProgressMax = %d\n", ulProgressMax);
979 }else {
980 ok(ulProgress, "ulProgress == 0\n");
981 }
982
983 if(empty_file) {
984 ok(grfBSCF == (BSCF_FIRSTDATANOTIFICATION|BSCF_LASTDATANOTIFICATION),
985 "grcfBSCF = %08x\n", grfBSCF);
986 first_data_notif = FALSE;
987 }else if(first_data_notif) {
988 ok(grfBSCF == BSCF_FIRSTDATANOTIFICATION
989 || grfBSCF == (BSCF_LASTDATANOTIFICATION|BSCF_DATAFULLYAVAILABLE),
990 "grcfBSCF = %08x\n", grfBSCF);
991 first_data_notif = FALSE;
992 } else {
993 ok(grfBSCF == BSCF_INTERMEDIATEDATANOTIFICATION
994 || grfBSCF == (BSCF_LASTDATANOTIFICATION|BSCF_INTERMEDIATEDATANOTIFICATION)
995 || broken(grfBSCF == (BSCF_FIRSTDATANOTIFICATION|BSCF_LASTDATANOTIFICATION)),
996 "grcfBSCF = %08x\n", grfBSCF);
997 }
998
999 if(!(bindf & BINDF_FROMURLMON) &&
1000 !(grfBSCF & BSCF_LASTDATANOTIFICATION)) {
1001 if(state == STATE_CONNECTING) {
1002 state = STATE_DOWNLOADING;
1003 if(http_is_first) {
1004 CHECK_CALLED(ReportProgress_FINDINGRESOURCE);
1005 CHECK_CALLED(ReportProgress_CONNECTING);
1006 }
1007 CHECK_CALLED(ReportProgress_SENDINGREQUEST);
1008 CHECK_CALLED(OnResponse);
1009 CHECK_CALLED(ReportProgress_RAWMIMETYPE);
1010 }
1011 SetEvent(event_complete);
1012 }
1013 }else if(!read_report_data) {
1014 BYTE buf[1000];
1015 ULONG read;
1016 HRESULT hres;
1017
1018 CHECK_EXPECT(ReportData);
1019
1020 if(tested_protocol != BIND_TEST) {
1021 do {
1022 if(mimefilter_test)
1023 SET_EXPECT(MimeFilter_Read);
1024 else if(rec_depth > 1)
1025 SET_EXPECT(Read2);
1026 else
1027 SET_EXPECT(Read);
1028 hres = IInternetProtocol_Read(binding_protocol, expect_pv=buf, sizeof(buf), &read);
1029 if(mimefilter_test)
1030 CHECK_CALLED(MimeFilter_Read);
1031 else if(rec_depth > 1)
1032 CHECK_CALLED(Read2);
1033 else
1034 CHECK_CALLED(Read);
1035 }while(hres == S_OK);
1036 }
1037 }
1038
1039 rec_depth--;
1040 return S_OK;
1041 }
1042
1043 static HRESULT WINAPI ProtocolSink_ReportResult(IInternetProtocolSink *iface, HRESULT hrResult,
1044 DWORD dwError, LPCWSTR szResult)
1045 {
1046 CHECK_EXPECT(ReportResult);
1047
1048 if(tested_protocol == FTP_TEST)
1049 ok(hrResult == E_PENDING || hrResult == S_OK, "hrResult = %08x, expected E_PENDING or S_OK\n", hrResult);
1050 else
1051 ok(hrResult == expect_hrResult, "hrResult = %08x, expected: %08x\n",
1052 hrResult, expect_hrResult);
1053 if(SUCCEEDED(hrResult) || tested_protocol == FTP_TEST || test_abort)
1054 ok(dwError == ERROR_SUCCESS, "dwError = %d, expected ERROR_SUCCESS\n", dwError);
1055 else
1056 ok(dwError != ERROR_SUCCESS ||
1057 broken(tested_protocol == MK_TEST), /* WinME and NT4 */
1058 "dwError == ERROR_SUCCESS\n");
1059 ok(!szResult, "szResult != NULL\n");
1060
1061 if(direct_read)
1062 SET_EXPECT(ReportData); /* checked after main loop */
1063
1064 return S_OK;
1065 }
1066
1067 static IInternetProtocolSinkVtbl protocol_sink_vtbl = {
1068 ProtocolSink_QueryInterface,
1069 ProtocolSink_AddRef,
1070 ProtocolSink_Release,
1071 ProtocolSink_Switch,
1072 ProtocolSink_ReportProgress,
1073 ProtocolSink_ReportData,
1074 ProtocolSink_ReportResult
1075 };
1076
1077 static IInternetProtocolSink protocol_sink = { &protocol_sink_vtbl };
1078
1079 static HRESULT WINAPI MimeProtocolSink_QueryInterface(IInternetProtocolSink *iface, REFIID riid, void **ppv)
1080 {
1081 ok(0, "unexpected call\n");
1082 return E_NOTIMPL;
1083 }
1084
1085 static ULONG WINAPI MimeProtocolSink_AddRef(IInternetProtocolSink *iface)
1086 {
1087 return 2;
1088 }
1089
1090 static ULONG WINAPI MimeProtocolSink_Release(IInternetProtocolSink *iface)
1091 {
1092 return 1;
1093 }
1094
1095 static HRESULT WINAPI MimeProtocolSink_Switch(IInternetProtocolSink *iface, PROTOCOLDATA *pProtocolData)
1096 {
1097 HRESULT hres;
1098
1099 CHECK_EXPECT(MimeFilter_Switch);
1100
1101 SET_EXPECT(Switch);
1102 hres = IInternetProtocolSink_Switch(filtered_sink, pProtocolData);
1103 ok(hres == S_OK, "Switch failed: %08x\n", hres);
1104 CHECK_CALLED(Switch);
1105
1106 return S_OK;
1107 }
1108
1109 static HRESULT WINAPI MimeProtocolSink_ReportProgress(IInternetProtocolSink *iface, ULONG ulStatusCode,
1110 LPCWSTR szStatusText)
1111 {
1112 switch(ulStatusCode) {
1113 case BINDSTATUS_LOADINGMIMEHANDLER:
1114 /*
1115 * IE9 for some reason (bug?) calls this on mime handler's protocol sink instead of the
1116 * main protocol sink. We check ReportProgress_LOADINGMIMEHANDLER both here and in
1117 * ProtocolSink_ReportProgress to workaround it.
1118 */
1119 CHECK_EXPECT(ReportProgress_LOADINGMIMEHANDLER);
1120 ok(!szStatusText, "szStatusText = %s\n", wine_dbgstr_w(szStatusText));
1121 break;
1122 default:
1123 ok(0, "Unexpected status code %d\n", ulStatusCode);
1124 }
1125
1126 return S_OK;
1127 }
1128
1129 static HRESULT WINAPI MimeProtocolSink_ReportData(IInternetProtocolSink *iface, DWORD grfBSCF,
1130 ULONG ulProgress, ULONG ulProgressMax)
1131 {
1132 DWORD read = 0;
1133 BYTE buf[8192];
1134 HRESULT hres;
1135 BOOL report_mime = FALSE;
1136
1137 CHECK_EXPECT(MimeFilter_ReportData);
1138
1139 if(!filter_state && !no_mime) {
1140 SET_EXPECT(Read);
1141 hres = IInternetProtocol_Read(filtered_protocol, buf, sizeof(buf), &read);
1142 if(tested_protocol == HTTP_TEST)
1143 ok(hres == S_OK || hres == E_PENDING || hres == S_FALSE, "Read failed: %08x\n", hres);
1144 else
1145 ok(hres == S_OK, "Read failed: %08x\n", hres);
1146 CHECK_CALLED(Read);
1147
1148 SET_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
1149 hres = IInternetProtocolSink_ReportProgress(filtered_sink, BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE, text_htmlW);
1150 ok(hres == S_OK, "ReportProgress failed: %08x\n", hres);
1151 CHECK_CALLED(ReportProgress_MIMETYPEAVAILABLE);
1152
1153 SET_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
1154 hres = IInternetProtocolSink_ReportProgress(filtered_sink, BINDSTATUS_MIMETYPEAVAILABLE, text_htmlW);
1155 ok(hres == S_OK, "ReportProgress failed: %08x\n", hres);
1156 CHECK_CALLED(ReportProgress_MIMETYPEAVAILABLE);
1157
1158 /* FIXME: test BINDSTATUS_CACHEFILENAMEAVAILABLE */
1159 }
1160
1161 if(no_mime && prot_read<200) {
1162 SET_EXPECT(Read);
1163 }else if(no_mime && prot_read<300) {
1164 report_mime = TRUE;
1165 SET_EXPECT(Read);
1166 SET_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
1167 SET_EXPECT(ReportData);
1168 }else if(!read_report_data) {
1169 SET_EXPECT(ReportData);
1170 }
1171 hres = IInternetProtocolSink_ReportData(filtered_sink, grfBSCF, ulProgress, ulProgressMax);
1172 ok(hres == S_OK, "ReportData failed: %08x\n", hres);
1173 if(no_mime && prot_read<=200) {
1174 CHECK_CALLED(Read);
1175 }else if(report_mime) {
1176 CHECK_CALLED(ReportProgress_MIMETYPEAVAILABLE);
1177 CHECK_CALLED(ReportData);
1178 }else if(!read_report_data) {
1179 CHECK_CALLED(ReportData);
1180 }
1181
1182 if(!filter_state)
1183 filter_state = 1;
1184
1185 return S_OK;
1186 }
1187
1188 static HRESULT WINAPI MimeProtocolSink_ReportResult(IInternetProtocolSink *iface, HRESULT hrResult,
1189 DWORD dwError, LPCWSTR szResult)
1190 {
1191 HRESULT hres;
1192
1193 CHECK_EXPECT(MimeFilter_ReportResult);
1194
1195 ok(hrResult == S_OK, "hrResult = %08x\n", hrResult);
1196 ok(dwError == ERROR_SUCCESS, "dwError = %u\n", dwError);
1197 ok(!szResult, "szResult = %s\n", wine_dbgstr_w(szResult));
1198
1199 SET_EXPECT(ReportResult);
1200 hres = IInternetProtocolSink_ReportResult(filtered_sink, hrResult, dwError, szResult);
1201 ok(SUCCEEDED(hres), "ReportResult failed: %08x\n", hres);
1202 CHECK_CALLED(ReportResult);
1203
1204 return S_OK;
1205 }
1206
1207 static IInternetProtocolSinkVtbl mime_protocol_sink_vtbl = {
1208 MimeProtocolSink_QueryInterface,
1209 MimeProtocolSink_AddRef,
1210 MimeProtocolSink_Release,
1211 MimeProtocolSink_Switch,
1212 MimeProtocolSink_ReportProgress,
1213 MimeProtocolSink_ReportData,
1214 MimeProtocolSink_ReportResult
1215 };
1216
1217 static IInternetProtocolSink mime_protocol_sink = { &mime_protocol_sink_vtbl };
1218
1219 static HRESULT QueryInterface(REFIID riid, void **ppv)
1220 {
1221 static const IID IID_undocumented = {0x58DFC7D0,0x5381,0x43E5,{0x9D,0x72,0x4C,0xDD,0xE4,0xCB,0x0F,0x1A}};
1222
1223 *ppv = NULL;
1224
1225 if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetProtocolSink, riid))
1226 *ppv = &protocol_sink;
1227 if(IsEqualGUID(&IID_IServiceProvider, riid))
1228 *ppv = &service_provider;
1229 if(IsEqualGUID(&IID_IUriContainer, riid))
1230 return E_NOINTERFACE; /* TODO */
1231
1232 /* NOTE: IE8 queries for undocumented {58DFC7D0-5381-43E5-9D72-4CDDE4CB0F1A} interface. */
1233 if(IsEqualGUID(&IID_undocumented, riid))
1234 return E_NOINTERFACE;
1235
1236 if(*ppv)
1237 return S_OK;
1238
1239 ok(0, "unexpected call %s\n", debugstr_guid(riid));
1240 return E_NOINTERFACE;
1241 }
1242
1243 static HRESULT WINAPI BindInfo_QueryInterface(IInternetBindInfo *iface, REFIID riid, void **ppv)
1244 {
1245 if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetBindInfo, riid)) {
1246 *ppv = iface;
1247 return S_OK;
1248 }
1249 return E_NOINTERFACE;
1250 }
1251
1252 static ULONG WINAPI BindInfo_AddRef(IInternetBindInfo *iface)
1253 {
1254 return 2;
1255 }
1256
1257 static ULONG WINAPI BindInfo_Release(IInternetBindInfo *iface)
1258 {
1259 return 1;
1260 }
1261
1262 static HRESULT WINAPI BindInfo_GetBindInfo(IInternetBindInfo *iface, DWORD *grfBINDF, BINDINFO *pbindinfo)
1263 {
1264 DWORD cbSize;
1265
1266 CHECK_EXPECT(GetBindInfo);
1267
1268 ok(grfBINDF != NULL, "grfBINDF == NULL\n");
1269 ok(pbindinfo != NULL, "pbindinfo == NULL\n");
1270 ok(pbindinfo->cbSize == sizeof(BINDINFO), "wrong size of pbindinfo: %d\n", pbindinfo->cbSize);
1271
1272 *grfBINDF = bindf;
1273 if(binding_test)
1274 *grfBINDF |= BINDF_FROMURLMON;
1275 cbSize = pbindinfo->cbSize;
1276 memset(pbindinfo, 0, cbSize);
1277 pbindinfo->cbSize = cbSize;
1278
1279 if(http_post_test)
1280 {
1281 pbindinfo->cbstgmedData = sizeof(post_data)-1;
1282 pbindinfo->dwBindVerb = BINDVERB_POST;
1283 pbindinfo->stgmedData.tymed = http_post_test;
1284
1285 if(http_post_test == TYMED_HGLOBAL) {
1286 HGLOBAL data;
1287
1288 /* Must be GMEM_FIXED, GMEM_MOVABLE does not work properly */
1289 data = GlobalAlloc(GPTR, sizeof(post_data));
1290 memcpy(data, post_data, sizeof(post_data));
1291 U(pbindinfo->stgmedData).hGlobal = data;
1292 }else {
1293 IStream *post_stream;
1294 HGLOBAL data;
1295 HRESULT hres;
1296
1297 if(0) {
1298 /* Must be GMEM_FIXED, GMEM_MOVABLE does not work properly */
1299 data = GlobalAlloc(GPTR, sizeof(post_data));
1300 memcpy(data, post_data, sizeof(post_data));
1301 U(pbindinfo->stgmedData).hGlobal = data;
1302
1303 hres = CreateStreamOnHGlobal(data, FALSE, &post_stream);
1304 ok(hres == S_OK, "CreateStreamOnHGlobal failed: %08x\n", hres);
1305
1306 U(pbindinfo->stgmedData).pstm =post_stream;/* &Stream; */
1307 }
1308 U(pbindinfo->stgmedData).pstm = &Stream;
1309 }
1310 }
1311
1312 return S_OK;
1313 }
1314
1315 static HRESULT WINAPI BindInfo_GetBindString(IInternetBindInfo *iface, ULONG ulStringType,
1316 LPOLESTR *ppwzStr, ULONG cEl, ULONG *pcElFetched)
1317 {
1318 ok(ppwzStr != NULL, "ppwzStr == NULL\n");
1319 ok(pcElFetched != NULL, "pcElFetched == NULL\n");
1320
1321 switch(ulStringType) {
1322 case BINDSTRING_ACCEPT_MIMES:
1323 CHECK_EXPECT(GetBindString_ACCEPT_MIMES);
1324 ok(cEl == 256, "cEl=%d, expected 256\n", cEl);
1325 if(pcElFetched) {
1326 ok(*pcElFetched == 256, "*pcElFetched=%d, expected 256\n", *pcElFetched);
1327 *pcElFetched = 1;
1328 }
1329 if(ppwzStr) {
1330 *ppwzStr = CoTaskMemAlloc(sizeof(acc_mimeW));
1331 memcpy(*ppwzStr, acc_mimeW, sizeof(acc_mimeW));
1332 }
1333 return S_OK;
1334 case BINDSTRING_USER_AGENT:
1335 CHECK_EXPECT(GetBindString_USER_AGENT);
1336 ok(cEl == 1, "cEl=%d, expected 1\n", cEl);
1337 if(pcElFetched) {
1338 ok(*pcElFetched == 0, "*pcElFetch=%d, expectd 0\n", *pcElFetched);
1339 *pcElFetched = 1;
1340 }
1341 if(ppwzStr) {
1342 *ppwzStr = CoTaskMemAlloc(sizeof(user_agentW));
1343 memcpy(*ppwzStr, user_agentW, sizeof(user_agentW));
1344 }
1345 return S_OK;
1346 case BINDSTRING_POST_COOKIE:
1347 CHECK_EXPECT(GetBindString_POST_COOKIE);
1348 ok(cEl == 1, "cEl=%d, expected 1\n", cEl);
1349 if(pcElFetched)
1350 ok(*pcElFetched == 0, "*pcElFetch=%d, expectd 0\n", *pcElFetched);
1351 return S_OK;
1352 case BINDSTRING_URL: {
1353 DWORD size;
1354
1355 CHECK_EXPECT(GetBindString_URL);
1356 ok(cEl == 1, "cEl=%d, expected 1\n", cEl);
1357 ok(*pcElFetched == 0, "*pcElFetch=%d, expectd 0\n", *pcElFetched);
1358 *pcElFetched = 1;
1359
1360 size = (lstrlenW(binding_urls[tested_protocol])+1)*sizeof(WCHAR);
1361 *ppwzStr = CoTaskMemAlloc(size);
1362 memcpy(*ppwzStr, binding_urls[tested_protocol], size);
1363 return S_OK;
1364 }
1365 default:
1366 ok(0, "unexpected call\n");
1367 }
1368
1369 return E_NOTIMPL;
1370 }
1371
1372 static IInternetBindInfoVtbl bind_info_vtbl = {
1373 BindInfo_QueryInterface,
1374 BindInfo_AddRef,
1375 BindInfo_Release,
1376 BindInfo_GetBindInfo,
1377 BindInfo_GetBindString
1378 };
1379
1380 static IInternetBindInfo bind_info = { &bind_info_vtbl };
1381
1382 static HRESULT WINAPI InternetPriority_QueryInterface(IInternetPriority *iface,
1383 REFIID riid, void **ppv)
1384 {
1385 ok(0, "unexpected call\n");
1386 return E_NOINTERFACE;
1387 }
1388
1389 static ULONG WINAPI InternetPriority_AddRef(IInternetPriority *iface)
1390 {
1391 return 2;
1392 }
1393
1394 static ULONG WINAPI InternetPriority_Release(IInternetPriority *iface)
1395 {
1396 return 1;
1397 }
1398
1399 static HRESULT WINAPI InternetPriority_SetPriority(IInternetPriority *iface, LONG nPriority)
1400 {
1401 CHECK_EXPECT(SetPriority);
1402 ok(nPriority == ex_priority, "nPriority=%d\n", nPriority);
1403 return S_OK;
1404 }
1405
1406 static HRESULT WINAPI InternetPriority_GetPriority(IInternetPriority *iface, LONG *pnPriority)
1407 {
1408 ok(0, "unexpected call\n");
1409 return E_NOTIMPL;
1410 }
1411
1412
1413 static const IInternetPriorityVtbl InternetPriorityVtbl = {
1414 InternetPriority_QueryInterface,
1415 InternetPriority_AddRef,
1416 InternetPriority_Release,
1417 InternetPriority_SetPriority,
1418 InternetPriority_GetPriority
1419 };
1420
1421 static IInternetPriority InternetPriority = { &InternetPriorityVtbl };
1422
1423 static ULONG WINAPI Protocol_AddRef(IInternetProtocolEx *iface)
1424 {
1425 return 2;
1426 }
1427
1428 static ULONG WINAPI Protocol_Release(IInternetProtocolEx *iface)
1429 {
1430 return 1;
1431 }
1432
1433 static HRESULT WINAPI Protocol_Abort(IInternetProtocolEx *iface, HRESULT hrReason,
1434 DWORD dwOptions)
1435 {
1436 HRESULT hres;
1437
1438 CHECK_EXPECT(Abort);
1439
1440 SET_EXPECT(ReportResult);
1441 hres = IInternetProtocolSink_ReportResult(binding_sink, S_OK, ERROR_SUCCESS, NULL);
1442 ok(hres == S_OK, "ReportResult failed: %08x\n", hres);
1443 CHECK_CALLED(ReportResult);
1444
1445 return S_OK;
1446 }
1447
1448 static HRESULT WINAPI Protocol_Suspend(IInternetProtocolEx *iface)
1449 {
1450 ok(0, "unexpected call\n");
1451 return E_NOTIMPL;
1452 }
1453
1454 static HRESULT WINAPI Protocol_Resume(IInternetProtocolEx *iface)
1455 {
1456 ok(0, "unexpected call\n");
1457 return E_NOTIMPL;
1458 }
1459
1460 static HRESULT WINAPI Protocol_Seek(IInternetProtocolEx *iface,
1461 LARGE_INTEGER dlibMove, DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
1462 {
1463 ok(0, "unexpected call\n");
1464 return E_NOTIMPL;
1465 }
1466
1467 static HRESULT WINAPI ProtocolEmul_QueryInterface(IInternetProtocolEx *iface, REFIID riid, void **ppv)
1468 {
1469 if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetProtocol, riid)) {
1470 *ppv = iface;
1471 return S_OK;
1472 }
1473
1474 if(IsEqualGUID(&IID_IInternetProtocolEx, riid)) {
1475 if(impl_protex) {
1476 *ppv = iface;
1477 return S_OK;
1478 }
1479 *ppv = NULL;
1480 return E_NOINTERFACE;
1481 }
1482
1483 if(IsEqualGUID(&IID_IInternetPriority, riid)) {
1484 *ppv = &InternetPriority;
1485 return S_OK;
1486 }
1487
1488 if(IsEqualGUID(&IID_IWinInetInfo, riid)) {
1489 CHECK_EXPECT(QueryInterface_IWinInetInfo);
1490 *ppv = NULL;
1491 return E_NOINTERFACE;
1492 }
1493
1494 if(IsEqualGUID(&IID_IWinInetHttpInfo, riid)) {
1495 CHECK_EXPECT(QueryInterface_IWinInetHttpInfo);
1496 *ppv = NULL;
1497 return E_NOINTERFACE;
1498 }
1499
1500 ok(0, "unexpected riid %s\n", debugstr_guid(riid));
1501 *ppv = NULL;
1502 return E_NOINTERFACE;
1503 }
1504
1505 static DWORD WINAPI thread_proc(PVOID arg)
1506 {
1507 HRESULT hres;
1508
1509 memset(&protocoldata, -1, sizeof(protocoldata));
1510
1511 prot_state = 0;
1512
1513 SET_EXPECT(ReportProgress_FINDINGRESOURCE);
1514 hres = IInternetProtocolSink_ReportProgress(binding_sink,
1515 BINDSTATUS_FINDINGRESOURCE, hostW);
1516 CHECK_CALLED(ReportProgress_FINDINGRESOURCE);
1517 ok(hres == S_OK, "ReportProgress failed: %08x\n", hres);
1518
1519 SET_EXPECT(ReportProgress_CONNECTING);
1520 hres = IInternetProtocolSink_ReportProgress(binding_sink,
1521 BINDSTATUS_CONNECTING, winehq_ipW);
1522 CHECK_CALLED(ReportProgress_CONNECTING);
1523 ok(hres == S_OK, "ReportProgress failed: %08x\n", hres);
1524
1525 SET_EXPECT(ReportProgress_SENDINGREQUEST);
1526 hres = IInternetProtocolSink_ReportProgress(binding_sink,
1527 BINDSTATUS_SENDINGREQUEST, NULL);
1528 CHECK_CALLED(ReportProgress_SENDINGREQUEST);
1529 ok(hres == S_OK, "ReportProgress failed: %08x\n", hres);
1530
1531 prot_state = 1;
1532 SET_EXPECT(Switch);
1533 hres = IInternetProtocolSink_Switch(binding_sink, &protocoldata);
1534 CHECK_CALLED(Switch);
1535 ok(hres == S_OK, "Switch failed: %08x\n", hres);
1536
1537 if(!short_read) {
1538 prot_state = 2;
1539 if(mimefilter_test)
1540 SET_EXPECT(MimeFilter_Switch);
1541 else
1542 SET_EXPECT(Switch);
1543 hres = IInternetProtocolSink_Switch(binding_sink, &protocoldata);
1544 ok(hres == S_OK, "Switch failed: %08x\n", hres);
1545 if(mimefilter_test)
1546 CHECK_CALLED(MimeFilter_Switch);
1547 else
1548 CHECK_CALLED(Switch);
1549
1550 if(test_abort) {
1551 SetEvent(event_complete);
1552 return 0;
1553 }
1554
1555 prot_state = 2;
1556 if(mimefilter_test)
1557 SET_EXPECT(MimeFilter_Switch);
1558 else
1559 SET_EXPECT(Switch);
1560 hres = IInternetProtocolSink_Switch(binding_sink, &protocoldata);
1561 ok(hres == S_OK, "Switch failed: %08x\n", hres);
1562 if(mimefilter_test)
1563 CHECK_CALLED(MimeFilter_Switch);
1564 else
1565 CHECK_CALLED(Switch);
1566
1567 prot_state = 3;
1568 if(mimefilter_test)
1569 SET_EXPECT(MimeFilter_Switch);
1570 else
1571 SET_EXPECT(Switch);
1572 hres = IInternetProtocolSink_Switch(binding_sink, &protocoldata);
1573 ok(hres == S_OK, "Switch failed: %08x\n", hres);
1574 if(mimefilter_test)
1575 CHECK_CALLED(MimeFilter_Switch);
1576 else
1577 CHECK_CALLED(Switch);
1578 }
1579
1580 SetEvent(event_complete);
1581
1582 return 0;
1583 }
1584
1585 static void protocol_start(IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo, DWORD pi)
1586 {
1587 BINDINFO bindinfo, exp_bindinfo;
1588 DWORD cbindf = 0;
1589 HRESULT hres;
1590
1591 ok(pOIProtSink != NULL, "pOIProtSink == NULL\n");
1592 ok(pOIBindInfo != NULL, "pOIBindInfo == NULL\n");
1593 ok(pOIProtSink != &protocol_sink, "unexpected pOIProtSink\n");
1594 ok(pOIBindInfo != &bind_info, "unexpected pOIBindInfo\n");
1595 ok(!pi, "pi = %x\n", pi);
1596
1597 if(binding_test)
1598 ok(pOIProtSink == binding_sink, "pOIProtSink != binding_sink\n");
1599
1600 memset(&bindinfo, 0, sizeof(bindinfo));
1601 bindinfo.cbSize = sizeof(bindinfo);
1602 memcpy(&exp_bindinfo, &bindinfo, sizeof(bindinfo));
1603 SET_EXPECT(GetBindInfo);
1604 hres = IInternetBindInfo_GetBindInfo(pOIBindInfo, &cbindf, &bindinfo);
1605 ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
1606 CHECK_CALLED(GetBindInfo);
1607 ok(cbindf == (bindf|BINDF_FROMURLMON), "bindf = %x, expected %x\n",
1608 cbindf, (bindf|BINDF_FROMURLMON));
1609 ok(!memcmp(&exp_bindinfo, &bindinfo, sizeof(bindinfo)), "unexpected bindinfo\n");
1610 pReleaseBindInfo(&bindinfo);
1611
1612 SET_EXPECT(ReportProgress_SENDINGREQUEST);
1613 hres = IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_SENDINGREQUEST, emptyW);
1614 ok(hres == S_OK, "ReportProgress(BINDSTATUS_SENDINGREQUEST) failed: %08x\n", hres);
1615 CHECK_CALLED(ReportProgress_SENDINGREQUEST);
1616
1617 if(tested_protocol == HTTP_TEST || tested_protocol == HTTPS_TEST) {
1618 IServiceProvider *service_provider;
1619 IHttpNegotiate *http_negotiate;
1620 IHttpNegotiate2 *http_negotiate2;
1621 LPWSTR ua = (LPWSTR)0xdeadbeef, accept_mimes[256];
1622 LPWSTR additional_headers = NULL;
1623 BYTE sec_id[100];
1624 DWORD fetched = 0, size = 100;
1625 DWORD tid;
1626
1627 SET_EXPECT(GetBindString_USER_AGENT);
1628 hres = IInternetBindInfo_GetBindString(pOIBindInfo, BINDSTRING_USER_AGENT,
1629 &ua, 1, &fetched);
1630 CHECK_CALLED(GetBindString_USER_AGENT);
1631 ok(hres == S_OK, "GetBindString(BINDSTRING_USER_AGETNT) failed: %08x\n", hres);
1632 ok(fetched == 1, "fetched = %d, expected 254\n", fetched);
1633 ok(ua != NULL, "ua = %p\n", ua);
1634 ok(!lstrcmpW(ua, user_agentW), "unexpected user agent %s\n", wine_dbgstr_w(ua));
1635 CoTaskMemFree(ua);
1636
1637 fetched = 256;
1638 SET_EXPECT(GetBindString_ACCEPT_MIMES);
1639 hres = IInternetBindInfo_GetBindString(pOIBindInfo, BINDSTRING_ACCEPT_MIMES,
1640 accept_mimes, 256, &fetched);
1641 CHECK_CALLED(GetBindString_ACCEPT_MIMES);
1642
1643 ok(hres == S_OK,
1644 "GetBindString(BINDSTRING_ACCEPT_MIMES) failed: %08x\n", hres);
1645 ok(fetched == 1, "fetched = %d, expected 1\n", fetched);
1646 ok(!lstrcmpW(acc_mimeW, accept_mimes[0]), "unexpected mimes %s\n", wine_dbgstr_w(accept_mimes[0]));
1647 CoTaskMemFree(accept_mimes[0]);
1648
1649 hres = IInternetBindInfo_QueryInterface(pOIBindInfo, &IID_IServiceProvider,
1650 (void**)&service_provider);
1651 ok(hres == S_OK, "QueryInterface failed: %08x\n", hres);
1652
1653 SET_EXPECT(QueryService_HttpNegotiate);
1654 hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate,
1655 &IID_IHttpNegotiate, (void**)&http_negotiate);
1656 CHECK_CALLED(QueryService_HttpNegotiate);
1657 ok(hres == S_OK, "QueryService failed: %08x\n", hres);
1658
1659 SET_EXPECT(BeginningTransaction);
1660 hres = IHttpNegotiate_BeginningTransaction(http_negotiate, binding_urls[tested_protocol],
1661 NULL, 0, &additional_headers);
1662 CHECK_CALLED(BeginningTransaction);
1663 IHttpNegotiate_Release(http_negotiate);
1664 ok(hres == S_OK, "BeginningTransction failed: %08x\n", hres);
1665 ok(additional_headers == NULL, "additional_headers=%p\n", additional_headers);
1666
1667 SET_EXPECT(QueryService_HttpNegotiate);
1668 hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate2,
1669 &IID_IHttpNegotiate2, (void**)&http_negotiate2);
1670 CHECK_CALLED(QueryService_HttpNegotiate);
1671 ok(hres == S_OK, "QueryService failed: %08x\n", hres);
1672
1673 size = 512;
1674 SET_EXPECT(GetRootSecurityId);
1675 hres = IHttpNegotiate2_GetRootSecurityId(http_negotiate2, sec_id, &size, 0);
1676 CHECK_CALLED(GetRootSecurityId);
1677 IHttpNegotiate2_Release(http_negotiate2);
1678 ok(hres == E_FAIL, "GetRootSecurityId failed: %08x, expected E_FAIL\n", hres);
1679 ok(size == 13, "size=%d\n", size);
1680
1681 IServiceProvider_Release(service_provider);
1682
1683 CreateThread(NULL, 0, thread_proc, NULL, 0, &tid);
1684 return;
1685 }
1686
1687 SET_EXPECT(ReportProgress_CACHEFILENAMEAVAILABLE);
1688 hres = IInternetProtocolSink_ReportProgress(pOIProtSink,
1689 BINDSTATUS_CACHEFILENAMEAVAILABLE, expect_wsz = emptyW);
1690 ok(hres == S_OK, "ReportProgress(BINDSTATUS_CACHEFILENAMEAVAILABLE) failed: %08x\n", hres);
1691 CHECK_CALLED(ReportProgress_CACHEFILENAMEAVAILABLE);
1692
1693 if(mimefilter_test) {
1694 SET_EXPECT(MimeFilter_CreateInstance);
1695 SET_EXPECT(MimeFilter_Start);
1696 SET_EXPECT(ReportProgress_LOADINGMIMEHANDLER);
1697 }
1698 SET_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
1699 hres = IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE,
1700 mimefilter_test ? pjpegW : (expect_wsz = text_htmlW));
1701 ok(hres == S_OK,
1702 "ReportProgress(BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE) failed: %08x\n", hres);
1703 if(mimefilter_test) {
1704 CHECK_CALLED(MimeFilter_CreateInstance);
1705 CHECK_CALLED(MimeFilter_Start);
1706 CHECK_CALLED(ReportProgress_LOADINGMIMEHANDLER);
1707 CHECK_CALLED(ReportProgress_MIMETYPEAVAILABLE);
1708 }else {
1709 CHECK_CALLED(ReportProgress_MIMETYPEAVAILABLE);
1710 }
1711
1712 if(mimefilter_test)
1713 SET_EXPECT(MimeFilter_ReportData);
1714 else
1715 SET_EXPECT(ReportData);
1716 hres = IInternetProtocolSink_ReportData(pOIProtSink,
1717 BSCF_FIRSTDATANOTIFICATION | (tested_protocol == ITS_TEST ? BSCF_DATAFULLYAVAILABLE : BSCF_LASTDATANOTIFICATION),
1718 13, 13);
1719 ok(hres == S_OK, "ReportData failed: %08x\n", hres);
1720 if(mimefilter_test)
1721 CHECK_CALLED(MimeFilter_ReportData);
1722 else
1723 CHECK_CALLED(ReportData);
1724
1725 if(tested_protocol == ITS_TEST) {
1726 SET_EXPECT(ReportData);
1727 hres = IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_BEGINDOWNLOADDATA, NULL);
1728 ok(hres == S_OK, "ReportProgress(BINDSTATUS_BEGINDOWNLOADDATA) failed: %08x\n", hres);
1729 CHECK_CALLED(ReportData);
1730 }
1731
1732 if(tested_protocol == BIND_TEST) {
1733 hres = IInternetProtocol_Terminate(binding_protocol, 0);
1734 ok(hres == E_FAIL, "Termiante failed: %08x\n", hres);
1735 }
1736
1737 if(mimefilter_test)
1738 SET_EXPECT(MimeFilter_ReportResult);
1739 else
1740 SET_EXPECT(ReportResult);
1741 hres = IInternetProtocolSink_ReportResult(pOIProtSink, S_OK, 0, NULL);
1742 ok(hres == S_OK, "ReportResult failed: %08x\n", hres);
1743 if(mimefilter_test)
1744 CHECK_CALLED(MimeFilter_ReportResult);
1745 else
1746 CHECK_CALLED(ReportResult);
1747 }
1748
1749 static HRESULT WINAPI ProtocolEmul_Start(IInternetProtocolEx *iface, LPCWSTR szUrl,
1750 IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
1751 DWORD grfPI, HANDLE_PTR dwReserved)
1752 {
1753 CHECK_EXPECT(Start);
1754
1755 ok(!dwReserved, "dwReserved = %lx\n", dwReserved);
1756 protocol_start(pOIProtSink, pOIBindInfo, grfPI);
1757 return S_OK;
1758 }
1759
1760 static HRESULT WINAPI ProtocolEmul_Continue(IInternetProtocolEx *iface,
1761 PROTOCOLDATA *pProtocolData)
1762 {
1763 DWORD bscf = 0, pr;
1764 HRESULT hres;
1765
1766 CHECK_EXPECT(Continue);
1767
1768 ok(pProtocolData != NULL, "pProtocolData == NULL\n");
1769 if(!pProtocolData || tested_protocol == BIND_TEST)
1770 return S_OK;
1771 if(binding_test) {
1772 ok(pProtocolData != &protocoldata, "pProtocolData == &protocoldata\n");
1773 ok(pProtocolData->grfFlags == protocoldata.grfFlags, "grfFlags wrong %x/%x\n",
1774 pProtocolData->grfFlags, protocoldata.grfFlags );
1775 ok(pProtocolData->dwState == protocoldata.dwState, "dwState wrong %x/%x\n",
1776 pProtocolData->dwState, protocoldata.dwState );
1777 ok(pProtocolData->pData == protocoldata.pData, "pData wrong %p/%p\n",
1778 pProtocolData->pData, protocoldata.pData );
1779 ok(pProtocolData->cbData == protocoldata.cbData, "cbData wrong %x/%x\n",
1780 pProtocolData->cbData, protocoldata.cbData );
1781 }
1782
1783 switch(prot_state) {
1784 case 1: {
1785 IServiceProvider *service_provider;
1786 IHttpNegotiate *http_negotiate;
1787 static WCHAR header[] = {'?',0};
1788
1789 hres = IInternetProtocolSink_QueryInterface(binding_sink, &IID_IServiceProvider,
1790 (void**)&service_provider);
1791 ok(hres == S_OK, "Could not get IServiceProvicder\n");
1792
1793 SET_EXPECT(QueryService_HttpNegotiate);
1794 hres = IServiceProvider_QueryService(service_provider, &IID_IHttpNegotiate,
1795 &IID_IHttpNegotiate, (void**)&http_negotiate);
1796 IServiceProvider_Release(service_provider);
1797 CHECK_CALLED(QueryService_HttpNegotiate);
1798 ok(hres == S_OK, "Could not get IHttpNegotiate\n");
1799
1800 SET_EXPECT(OnResponse);
1801 hres = IHttpNegotiate_OnResponse(http_negotiate, 200, header, NULL, NULL);
1802 IHttpNegotiate_Release(http_negotiate);
1803 CHECK_CALLED(OnResponse);
1804 IHttpNegotiate_Release(http_negotiate);
1805 ok(hres == S_OK, "OnResponse failed: %08x\n", hres);
1806
1807 if(mimefilter_test) {
1808 SET_EXPECT(MimeFilter_CreateInstance);
1809 SET_EXPECT(MimeFilter_Start);
1810 SET_EXPECT(ReportProgress_LOADINGMIMEHANDLER);
1811 }else if(!(pi & PI_MIMEVERIFICATION)) {
1812 SET_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
1813 }
1814 hres = IInternetProtocolSink_ReportProgress(binding_sink,
1815 BINDSTATUS_MIMETYPEAVAILABLE, mimefilter_test ? pjpegW : text_htmlW);
1816 if(mimefilter_test) {
1817 CHECK_CALLED(MimeFilter_CreateInstance);
1818 CHECK_CALLED(MimeFilter_Start);
1819 CHECK_CALLED(ReportProgress_LOADINGMIMEHANDLER);
1820 }else if(!(pi & PI_MIMEVERIFICATION)) {
1821 CHECK_CALLED(ReportProgress_MIMETYPEAVAILABLE);
1822 }
1823 ok(hres == S_OK,
1824 "ReportProgress(BINDSTATUS_MIMETYPEAVAILABLE) failed: %08x\n", hres);
1825
1826 bscf |= BSCF_FIRSTDATANOTIFICATION;
1827 break;
1828 }
1829 case 2:
1830 case 3:
1831 bscf = BSCF_INTERMEDIATEDATANOTIFICATION;
1832 break;
1833 }
1834
1835 pr = prot_read;
1836 if(mimefilter_test)
1837 SET_EXPECT(MimeFilter_ReportData);
1838 if((!mimefilter_test || no_mime) && (pi & PI_MIMEVERIFICATION)) {
1839 if(pr < 200)
1840 SET_EXPECT(Read); /* checked in ReportData for short_read */
1841 if(pr == 200) {
1842 if(!mimefilter_test)
1843 SET_EXPECT(Read); /* checked in BINDSTATUS_MIMETYPEAVAILABLE or ReportData */
1844 SET_EXPECT(GetBindInfo);
1845 SET_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
1846 }
1847 if(pr >= 200)
1848 SET_EXPECT(ReportData);
1849 }else {
1850 SET_EXPECT(ReportData);
1851 }
1852
1853 hres = IInternetProtocolSink_ReportData(binding_sink, bscf, pr, 400);
1854 ok(hres == S_OK, "ReportData failed: %08x\n", hres);
1855
1856 if(mimefilter_test) {
1857 SET_EXPECT(MimeFilter_ReportData);
1858 }else if(pi & PI_MIMEVERIFICATION) {
1859 if(!short_read && pr < 200)
1860 CHECK_CALLED(Read);
1861 if(pr == 200) {
1862 CLEAR_CALLED(GetBindInfo); /* IE9 */
1863 CHECK_CALLED(ReportProgress_MIMETYPEAVAILABLE);
1864 }
1865 }else {
1866 CHECK_CALLED(ReportData);
1867 }
1868
1869 if(prot_state == 3)
1870 prot_state = 4;
1871
1872 return S_OK;
1873 }
1874
1875 static HRESULT WINAPI ProtocolEmul_Terminate(IInternetProtocolEx *iface, DWORD dwOptions)
1876 {
1877 CHECK_EXPECT(Terminate);
1878 ok(!dwOptions, "dwOptions=%d\n", dwOptions);
1879 return S_OK;
1880 }
1881
1882 static HRESULT WINAPI ProtocolEmul_Read(IInternetProtocolEx *iface, void *pv,
1883 ULONG cb, ULONG *pcbRead)
1884 {
1885 if(read_report_data)
1886 CHECK_EXPECT2(Read2);
1887
1888 if(mimefilter_test || short_read) {
1889 if(!read_report_data)
1890 CHECK_EXPECT2(Read);
1891 }else if((pi & PI_MIMEVERIFICATION)) {
1892 if(!read_report_data)
1893 CHECK_EXPECT2(Read);
1894
1895 if(prot_read < 300) {
1896 ok(pv != expect_pv, "pv == expect_pv\n");
1897 if(prot_read < 300)
1898 ok(cb == 2048-prot_read, "cb=%d\n", cb);
1899 else
1900 ok(cb == 700, "cb=%d\n", cb);
1901 }else {
1902 ok(expect_pv <= pv && (BYTE*)pv < (BYTE*)expect_pv + cb, "pv != expect_pv\n");
1903 }
1904 }else {
1905 if(!read_report_data)
1906 CHECK_EXPECT(Read);
1907
1908 ok(pv == expect_pv, "pv != expect_pv\n");
1909 ok(cb == 1000, "cb=%d\n", cb);
1910 ok(!*pcbRead, "*pcbRead = %d\n", *pcbRead);
1911 }
1912 ok(pcbRead != NULL, "pcbRead == NULL\n");
1913
1914 if(prot_state == 3 || (short_read && prot_state != 4)) {
1915 HRESULT hres;
1916
1917 prot_state = 4;
1918 if(short_read) {
1919 SET_EXPECT(Read2); /* checked in BINDSTATUS_MIMETYPEAVAILABLE */
1920 SET_EXPECT(GetBindInfo);
1921 SET_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
1922 }
1923 if(mimefilter_test)
1924 SET_EXPECT(MimeFilter_ReportData);
1925 else if(direct_read)
1926 SET_EXPECT(ReportData2);
1927 read_report_data++;
1928 hres = IInternetProtocolSink_ReportData(binding_sink,
1929 BSCF_LASTDATANOTIFICATION|BSCF_INTERMEDIATEDATANOTIFICATION, 0, 0);
1930 read_report_data--;
1931 ok(hres == S_OK, "ReportData failed: %08x\n", hres);
1932 if(short_read) {
1933 CLEAR_CALLED(GetBindInfo); /* IE9 */
1934 CHECK_CALLED(ReportProgress_MIMETYPEAVAILABLE);
1935 }
1936 if(mimefilter_test)
1937 CHECK_CALLED(MimeFilter_ReportData);
1938 else if(direct_read)
1939 CHECK_CALLED(ReportData2);
1940
1941 if(mimefilter_test)
1942 SET_EXPECT(MimeFilter_ReportResult);
1943 else
1944 SET_EXPECT(ReportResult);
1945 hres = IInternetProtocolSink_ReportResult(binding_sink, S_OK, ERROR_SUCCESS, NULL);
1946 ok(hres == S_OK, "ReportResult failed: %08x\n", hres);
1947 if(mimefilter_test)
1948 CHECK_CALLED(MimeFilter_ReportResult);
1949 else
1950 CHECK_CALLED(ReportResult);
1951
1952 if(cb > 100)
1953 cb = 100;
1954 memset(pv, 'x', cb);
1955 if(cb>6)
1956 memcpy(pv, "gif87a", 6);
1957 prot_read += *pcbRead = cb;
1958 return S_OK;
1959 }if(prot_state == 4) {
1960 *pcbRead = 0;
1961 return S_FALSE;
1962 }
1963
1964 if((async_read_pending = !async_read_pending)) {
1965 *pcbRead = 0;
1966 return tested_protocol == HTTP_TEST || tested_protocol == HTTPS_TEST ? E_PENDING : S_FALSE;
1967 }
1968
1969 if(cb > 100)
1970 cb = 100;
1971 memset(pv, 'x', cb);
1972 if(cb>6)
1973 memcpy(pv, "gif87a", 6);
1974 prot_read += *pcbRead = cb;
1975 return S_OK;
1976 }
1977
1978 static HRESULT WINAPI ProtocolEmul_LockRequest(IInternetProtocolEx *iface, DWORD dwOptions)
1979 {
1980 CHECK_EXPECT(LockRequest);
1981 ok(dwOptions == 0, "dwOptions=%x\n", dwOptions);
1982 return S_OK;
1983 }
1984
1985 static HRESULT WINAPI ProtocolEmul_UnlockRequest(IInternetProtocolEx *iface)
1986 {
1987 CHECK_EXPECT(UnlockRequest);
1988 return S_OK;
1989 }
1990
1991 static HRESULT WINAPI ProtocolEmul_StartEx(IInternetProtocolEx *iface, IUri *pUri,
1992 IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
1993 DWORD grfPI, HANDLE *dwReserved)
1994 {
1995 CHECK_EXPECT(StartEx);
1996 ok(!dwReserved, "dwReserved = %p\n", dwReserved);
1997 protocol_start(pOIProtSink, pOIBindInfo, grfPI);
1998 return S_OK;
1999 }
2000
2001 static const IInternetProtocolExVtbl ProtocolVtbl = {
2002 ProtocolEmul_QueryInterface,
2003 Protocol_AddRef,
2004 Protocol_Release,
2005 ProtocolEmul_Start,
2006 ProtocolEmul_Continue,
2007 Protocol_Abort,
2008 ProtocolEmul_Terminate,
2009 Protocol_Suspend,
2010 Protocol_Resume,
2011 ProtocolEmul_Read,
2012 Protocol_Seek,
2013 ProtocolEmul_LockRequest,
2014 ProtocolEmul_UnlockRequest,
2015 ProtocolEmul_StartEx
2016 };
2017
2018 static IInternetProtocolEx Protocol = { &ProtocolVtbl };
2019
2020 static HRESULT WINAPI MimeProtocol_QueryInterface(IInternetProtocolEx *iface, REFIID riid, void **ppv)
2021 {
2022 if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IInternetProtocol, riid)) {
2023 *ppv = iface;
2024 return S_OK;
2025 }
2026
2027 if(IsEqualGUID(&IID_IInternetProtocolSink, riid)) {
2028 *ppv = &mime_protocol_sink;
2029 return S_OK;
2030 }
2031
2032 ok(0, "unexpected riid %s\n", debugstr_guid(riid));
2033 *ppv = NULL;
2034 return E_NOINTERFACE;
2035 }
2036
2037 static HRESULT WINAPI MimeProtocol_Start(IInternetProtocolEx *iface, LPCWSTR szUrl,
2038 IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
2039 DWORD grfPI, HANDLE_PTR dwReserved)
2040 {
2041 PROTOCOLFILTERDATA *data;
2042 LPOLESTR url_str = NULL;
2043 DWORD fetched = 0;
2044 BINDINFO bindinfo;
2045 DWORD cbindf = 0;
2046 HRESULT hres;
2047
2048 CHECK_EXPECT(MimeFilter_Start);
2049
2050 ok(!lstrcmpW(szUrl, pjpegW), "wrong url %s\n", wine_dbgstr_w(szUrl));
2051 ok(grfPI == (PI_FILTER_MODE|PI_FORCE_ASYNC), "grfPI=%x, expected PI_FILTER_MODE|PI_FORCE_ASYNC\n", grfPI);
2052 ok(dwReserved, "dwReserved == 0\n");
2053 ok(pOIProtSink != NULL, "pOIProtSink == NULL\n");
2054 ok(pOIBindInfo != NULL, "pOIBindInfo == NULL\n");
2055
2056 if(binding_test) {
2057 ok(pOIProtSink != binding_sink, "pOIProtSink == protocol_sink\n");
2058 ok(pOIBindInfo == prot_bind_info, "pOIBindInfo != bind_info\n");
2059 }else {
2060 ok(pOIProtSink == &protocol_sink, "pOIProtSink != protocol_sink\n");
2061 ok(pOIBindInfo == &bind_info, "pOIBindInfo != bind_info\n");
2062 }
2063
2064 data = (void*)dwReserved;
2065 ok(data->cbSize == sizeof(*data), "data->cbSize = %d\n", data->cbSize);
2066 ok(!data->pProtocolSink, "data->pProtocolSink != NULL\n");
2067 ok(data->pProtocol != NULL, "data->pProtocol == NULL\n");
2068 ok(!data->pUnk, "data->pUnk != NULL\n");
2069 ok(!data->dwFilterFlags, "data->dwProtocolFlags = %x\n", data->dwFilterFlags);
2070 if(binding_test) {
2071 IInternetProtocolSink *prot_sink;
2072
2073 IInternetProtocol_QueryInterface(data->pProtocol, &IID_IInternetProtocolSink, (void**)&prot_sink);
2074 ok(prot_sink == pOIProtSink, "QI(data->pProtocol, IID_IInternetProtocolSink) != pOIProtSink\n");
2075 IInternetProtocolSink_Release(prot_sink);
2076
2077 ok(data->pProtocol != binding_protocol, "data->pProtocol == binding_protocol\n");
2078
2079 filtered_protocol = data->pProtocol;
2080 IInternetProtocol_AddRef(filtered_protocol);
2081 }else {
2082 IInternetProtocol *prot;
2083
2084 IInternetProtocol_QueryInterface(data->pProtocol, &IID_IInternetProtocol, (void**)&prot);
2085 ok(prot == async_protocol, "QI(data->pProtocol, IID_IInternetProtocol) != async_protocol\n");
2086 IInternetProtocol_Release(prot);
2087
2088 ok(data->pProtocol != async_protocol, "data->pProtocol == async_protocol\n");
2089 }
2090
2091 filtered_sink = pOIProtSink;
2092
2093 SET_EXPECT(ReportProgress_DECODING);
2094 hres = IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_DECODING, pjpegW);
2095 ok(hres == S_OK, "ReportProgress(BINDSTATUS_DECODING) failed: %08x\n", hres);
2096 CHECK_CALLED(ReportProgress_DECODING);
2097
2098 SET_EXPECT(GetBindInfo);
2099 memset(&bindinfo, 0, sizeof(bindinfo));
2100 bindinfo.cbSize = sizeof(bindinfo);
2101 hres = IInternetBindInfo_GetBindInfo(pOIBindInfo, &cbindf, &bindinfo);
2102 ok(hres == S_OK, "GetBindInfo failed: %08x\n", hres);
2103 ok(cbindf == (bindf|BINDF_FROMURLMON), "cbindf = %x, expected %x\n", cbindf, bindf);
2104 CHECK_CALLED(GetBindInfo);
2105
2106 SET_EXPECT(GetBindString_URL);
2107 hres = IInternetBindInfo_GetBindString(pOIBindInfo, BINDSTRING_URL, &url_str, 1, &fetched);
2108 ok(hres == S_OK, "GetBindString(BINDSTRING_URL) failed: %08x\n", hres);
2109 ok(fetched == 1, "fetched = %d\n", fetched);
2110 ok(!lstrcmpW(url_str, binding_urls[tested_protocol]), "wrong url_str %s\n", wine_dbgstr_w(url_str));
2111 CoTaskMemFree(url_str);
2112 CHECK_CALLED(GetBindString_URL);
2113
2114 return S_OK;
2115 }
2116
2117 static HRESULT WINAPI Protocol_Continue(IInternetProtocolEx *iface,
2118 PROTOCOLDATA *pProtocolData)
2119 {
2120 CHECK_EXPECT(MimeFilter_Continue);
2121 return E_NOTIMPL;
2122 }
2123
2124 static HRESULT WINAPI MimeProtocol_Terminate(IInternetProtocolEx *iface, DWORD dwOptions)
2125 {
2126 HRESULT hres;
2127
2128 CHECK_EXPECT(MimeFilter_Terminate);
2129
2130 ok(!dwOptions, "dwOptions = %x\n", dwOptions);
2131
2132 SET_EXPECT(Terminate);
2133 hres = IInternetProtocol_Terminate(filtered_protocol, dwOptions);
2134 ok(hres == S_OK, "Terminate failed: %08x\n", hres);
2135 CHECK_CALLED(Terminate);
2136
2137 return S_OK;
2138 }
2139
2140 static HRESULT WINAPI MimeProtocol_Read(IInternetProtocolEx *iface, void *pv,
2141 ULONG cb, ULONG *pcbRead)
2142 {
2143 BYTE buf[2096];
2144 DWORD read = 0;
2145 HRESULT hres;
2146
2147 CHECK_EXPECT(MimeFilter_Read);
2148
2149 ok(pv != NULL, "pv == NULL\n");
2150 ok(cb != 0, "cb == 0\n");
2151 ok(pcbRead != NULL, "pcbRead == NULL\n");
2152
2153 if(read_report_data)
2154 SET_EXPECT(Read2);
2155 else
2156 SET_EXPECT(Read);
2157 hres = IInternetProtocol_Read(filtered_protocol, buf, sizeof(buf), &read);
2158 ok(hres == S_OK || hres == S_FALSE || hres == E_PENDING, "Read failed: %08x\n", hres);
2159 if(read_report_data)
2160 CHECK_CALLED(Read2);
2161 else
2162 CHECK_CALLED(Read);
2163
2164 if(pcbRead) {
2165 ok(*pcbRead == 0, "*pcbRead=%d, expected 0\n", *pcbRead);
2166 *pcbRead = read;
2167 }
2168
2169 memset(pv, 'x', read);
2170 return hres;
2171 }
2172
2173 static HRESULT WINAPI MimeProtocol_LockRequest(IInternetProtocolEx *iface, DWORD dwOptions)
2174 {
2175 HRESULT hres;
2176
2177 CHECK_EXPECT(MimeFilter_LockRequest);
2178
2179 ok(!dwOptions, "dwOptions = %x\n", dwOptions);
2180
2181 SET_EXPECT(LockRequest);
2182 hres = IInternetProtocol_LockRequest(filtered_protocol, dwOptions);
2183 ok(hres == S_OK, "LockRequest failed: %08x\n", hres);
2184 CHECK_CALLED(LockRequest);
2185
2186 return S_OK;
2187 }
2188
2189 static HRESULT WINAPI MimeProtocol_UnlockRequest(IInternetProtocolEx *iface)
2190 {
2191 HRESULT hres;
2192
2193 CHECK_EXPECT(MimeFilter_UnlockRequest);
2194
2195 SET_EXPECT(UnlockRequest);
2196 hres = IInternetProtocol_UnlockRequest(filtered_protocol);
2197 ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
2198 CHECK_CALLED(UnlockRequest);
2199
2200 return S_OK;
2201 }
2202
2203 static const IInternetProtocolExVtbl MimeProtocolVtbl = {
2204 MimeProtocol_QueryInterface,
2205 Protocol_AddRef,
2206 Protocol_Release,
2207 MimeProtocol_Start,
2208 Protocol_Continue,
2209 Protocol_Abort,
2210 MimeProtocol_Terminate,
2211 Protocol_Suspend,
2212 Protocol_Resume,
2213 MimeProtocol_Read,
2214 Protocol_Seek,
2215 MimeProtocol_LockRequest,
2216 MimeProtocol_UnlockRequest
2217 };
2218
2219 static IInternetProtocolEx MimeProtocol = { &MimeProtocolVtbl };
2220
2221 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
2222 {
2223 ok(0, "unexpected call\n");
2224 return E_NOINTERFACE;
2225 }
2226
2227 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
2228 {
2229 return 2;
2230 }
2231
2232 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
2233 {
2234 return 1;
2235 }
2236
2237 static HRESULT WINAPI ClassFactory_CreateInstance(IClassFactory *iface, IUnknown *pOuter,
2238 REFIID riid, void **ppv)
2239 {
2240 CHECK_EXPECT(CreateInstance);
2241
2242 ok(pOuter == (IUnknown*)prot_bind_info, "pOuter != protocol_unk\n");
2243 ok(IsEqualGUID(&IID_IUnknown, riid), "unexpected riid %s\n", debugstr_guid(riid));
2244 ok(ppv != NULL, "ppv == NULL\n");
2245
2246 *ppv = &Protocol;
2247 return S_OK;
2248 }
2249
2250 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL dolock)
2251 {
2252 ok(0, "unexpected call\n");
2253 return S_OK;
2254 }
2255
2256 static const IClassFactoryVtbl ClassFactoryVtbl = {
2257 ClassFactory_QueryInterface,
2258 ClassFactory_AddRef,
2259 ClassFactory_Release,
2260 ClassFactory_CreateInstance,
2261 ClassFactory_LockServer
2262 };
2263
2264 static IClassFactory ClassFactory = { &ClassFactoryVtbl };
2265
2266 static HRESULT WINAPI MimeFilter_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
2267 {
2268 CHECK_EXPECT(MimeFilter_CreateInstance);
2269
2270 ok(!outer, "outer = %p\n", outer);
2271 ok(IsEqualGUID(&IID_IInternetProtocol, riid), "unexpected riid %s\n", debugstr_guid(riid));
2272
2273 *ppv = &MimeProtocol;
2274 return S_OK;
2275 }
2276
2277 static const IClassFactoryVtbl MimeFilterCFVtbl = {
2278 ClassFactory_QueryInterface,
2279 ClassFactory_AddRef,
2280 ClassFactory_Release,
2281 MimeFilter_CreateInstance,
2282 ClassFactory_LockServer
2283 };
2284
2285 static IClassFactory mimefilter_cf = { &MimeFilterCFVtbl };
2286
2287 #define TEST_BINDING 0x0001
2288 #define TEST_FILTER 0x0002
2289 #define TEST_FIRST_HTTP 0x0004
2290 #define TEST_DIRECT_READ 0x0008
2291 #define TEST_POST 0x0010
2292 #define TEST_EMULATEPROT 0x0020
2293 #define TEST_SHORT_READ 0x0040
2294 #define TEST_REDIRECT 0x0080
2295 #define TEST_ABORT 0x0100
2296 #define TEST_ASYNCREQ 0x0200
2297 #define TEST_USEIURI 0x0400
2298 #define TEST_IMPLPROTEX 0x0800
2299 #define TEST_EMPTY 0x1000
2300 #define TEST_NOMIME 0x2000
2301
2302 static void register_filter(BOOL do_register)
2303 {
2304 IInternetSession *session;
2305 HRESULT hres;
2306
2307 hres = pCoInternetGetSession(0, &session, 0);
2308 ok(hres == S_OK, "CoInternetGetSession failed: %08x\n", hres);
2309
2310 if(do_register) {
2311 hres = IInternetSession_RegisterMimeFilter(session, &mimefilter_cf, &IID_IInternetProtocol, pjpegW);
2312 ok(hres == S_OK, "RegisterMimeFilter failed: %08x\n", hres);
2313 hres = IInternetSession_RegisterMimeFilter(session, &mimefilter_cf, &IID_IInternetProtocol, gifW);
2314 ok(hres == S_OK, "RegisterMimeFilter failed: %08x\n", hres);
2315 }else {
2316 hres = IInternetSession_UnregisterMimeFilter(session, &mimefilter_cf, pjpegW);
2317 ok(hres == S_OK, "RegisterMimeFilter failed: %08x\n", hres);
2318 hres = IInternetSession_UnregisterMimeFilter(session, &mimefilter_cf, gifW);
2319 ok(hres == S_OK, "RegisterMimeFilter failed: %08x\n", hres);
2320 }
2321
2322 IInternetSession_Release(session);
2323 }
2324
2325 static void init_test(int prot, DWORD flags)
2326 {
2327 tested_protocol = prot;
2328 binding_test = (flags & TEST_BINDING) != 0;
2329 first_data_notif = TRUE;
2330 prot_read = 0;
2331 prot_state = 0;
2332 async_read_pending = TRUE;
2333 mimefilter_test = (flags & TEST_FILTER) != 0;
2334 no_mime = (flags & TEST_NOMIME) != 0;
2335 filter_state = 0;
2336 post_stream_read = 0;
2337 ResetEvent(event_complete);
2338 ResetEvent(event_complete2);
2339 ResetEvent(event_continue);
2340 ResetEvent(event_continue_done);
2341 async_protocol = binding_protocol = filtered_protocol = NULL;
2342 filtered_sink = NULL;
2343 http_is_first = (flags & TEST_FIRST_HTTP) != 0;
2344 first_data_notif = TRUE;
2345 state = STATE_CONNECTING;
2346 test_async_req = (flags & TEST_ASYNCREQ) != 0;
2347 direct_read = (flags & TEST_DIRECT_READ) != 0;
2348 emulate_prot = (flags & TEST_EMULATEPROT) != 0;
2349 wait_for_switch = TRUE;
2350 short_read = (flags & TEST_SHORT_READ) != 0;
2351 http_post_test = TYMED_NULL;
2352 test_redirect = (flags & TEST_REDIRECT) != 0;
2353 test_abort = (flags & TEST_ABORT) != 0;
2354 impl_protex = (flags & TEST_IMPLPROTEX) != 0;
2355 empty_file = (flags & TEST_EMPTY) != 0;
2356
2357 register_filter(mimefilter_test);
2358 }
2359
2360 static void test_priority(IInternetProtocol *protocol)
2361 {
2362 IInternetPriority *priority;
2363 LONG pr;
2364 HRESULT hres;
2365
2366 hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetPriority,
2367 (void**)&priority);
2368 ok(hres == S_OK, "QueryInterface(IID_IInternetPriority) failed: %08x\n", hres);
2369 if(FAILED(hres))
2370 return;
2371
2372 hres = IInternetPriority_GetPriority(priority, &pr);
2373 ok(hres == S_OK, "GetPriority failed: %08x\n", hres);
2374 ok(pr == 0, "pr=%d, expected 0\n", pr);
2375
2376 hres = IInternetPriority_SetPriority(priority, 1);
2377 ok(hres == S_OK, "SetPriority failed: %08x\n", hres);
2378
2379 hres = IInternetPriority_GetPriority(priority, &pr);
2380 ok(hres == S_OK, "GetPriority failed: %08x\n", hres);
2381 ok(pr == 1, "pr=%d, expected 1\n", pr);
2382
2383 IInternetPriority_Release(priority);
2384 }
2385
2386 static void test_early_abort(const CLSID *clsid)
2387 {
2388 IInternetProtocol *protocol;
2389 HRESULT hres;
2390
2391 hres = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
2392 &IID_IInternetProtocol, (void**)&protocol);
2393 ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
2394
2395 hres = IInternetProtocol_Abort(protocol, E_ABORT, 0);
2396 ok(hres == S_OK, "Abort failed: %08x\n", hres);
2397
2398 hres = IInternetProtocol_Abort(protocol, E_FAIL, 0);
2399 ok(hres == S_OK, "Abort failed: %08x\n", hres);
2400
2401 IInternetProtocol_Release(protocol);
2402 }
2403
2404 static BOOL file_protocol_start(IInternetProtocol *protocol, LPCWSTR url,
2405 IInternetProtocolEx *protocolex, IUri *uri, BOOL is_first)
2406 {
2407 HRESULT hres;
2408
2409 SET_EXPECT(GetBindInfo);
2410 if(!(bindf & BINDF_FROMURLMON))
2411 SET_EXPECT(ReportProgress_DIRECTBIND);
2412 if(is_first) {
2413 SET_EXPECT(ReportProgress_SENDINGREQUEST);
2414 SET_EXPECT(ReportProgress_CACHEFILENAMEAVAILABLE);
2415 if(bindf & BINDF_FROMURLMON)
2416 SET_EXPECT(ReportProgress_VERIFIEDMIMETYPEAVAILABLE);
2417 else
2418 SET_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
2419 }
2420 SET_EXPECT(ReportData);
2421 if(is_first)
2422 SET_EXPECT(ReportResult);
2423
2424 expect_hrResult = S_OK;
2425
2426 if(protocolex) {
2427 hres = IInternetProtocolEx_StartEx(protocolex, uri, &protocol_sink, &bind_info, 0, 0);
2428 ok(hres == S_OK, "StartEx failed: %08x\n", hres);
2429 }else {
2430 hres = IInternetProtocol_Start(protocol, url, &protocol_sink, &bind_info, 0, 0);
2431 if(hres == INET_E_RESOURCE_NOT_FOUND) {
2432 win_skip("Start failed\n");
2433 return FALSE;
2434 }
2435 ok(hres == S_OK, "Start failed: %08x\n", hres);
2436 }
2437
2438 CHECK_CALLED(GetBindInfo);
2439 if(!(bindf & BINDF_FROMURLMON))
2440 CHECK_CALLED(ReportProgress_DIRECTBIND);
2441 if(is_first) {
2442 CHECK_CALLED(ReportProgress_SENDINGREQUEST);
2443 CHECK_CALLED(ReportProgress_CACHEFILENAMEAVAILABLE);
2444 if(bindf & BINDF_FROMURLMON)
2445 CHECK_CALLED(ReportProgress_VERIFIEDMIMETYPEAVAILABLE);
2446 else
2447 CHECK_CALLED(ReportProgress_MIMETYPEAVAILABLE);
2448 }
2449 CHECK_CALLED(ReportData);
2450 if(is_first)
2451 CHECK_CALLED(ReportResult);
2452
2453 return TRUE;
2454 }
2455
2456 static void test_file_protocol_url(LPCWSTR url)
2457 {
2458 IInternetProtocolInfo *protocol_info;
2459 IUnknown *unk;
2460 IClassFactory *factory;
2461 IInternetProtocol *protocol;
2462 BYTE buf[512];
2463 ULONG cb;
2464 HRESULT hres;
2465
2466 hres = CoGetClassObject(&CLSID_FileProtocol, CLSCTX_INPROC_SERVER, NULL,
2467 &IID_IUnknown, (void**)&unk);
2468 ok(hres == S_OK, "CoGetClassObject failed: %08x\n", hres);
2469 if(FAILED(hres))
2470 return;
2471
2472 hres = IUnknown_QueryInterface(unk, &IID_IInternetProtocolInfo, (void**)&protocol_info);
2473 ok(hres == E_NOINTERFACE,
2474 "Could not get IInternetProtocolInfo interface: %08x, expected E_NOINTERFACE\n", hres);
2475
2476 hres = IUnknown_QueryInterface(unk, &IID_IClassFactory, (void**)&factory);
2477 ok(hres == S_OK, "Could not get IClassFactory interface\n");
2478 IUnknown_Release(unk);
2479 if(FAILED(hres))
2480 return;
2481
2482 hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocol, (void**)&protocol);
2483 ok(hres == S_OK, "Could not get IInternetProtocol: %08x\n", hres);
2484
2485 if(SUCCEEDED(hres)) {
2486 if(file_protocol_start(protocol, url, NULL, NULL, TRUE)) {
2487 hres = IInternetProtocol_Read(protocol, buf, 2, &cb);
2488 ok(hres == S_OK, "Read failed: %08x\n", hres);
2489 ok(cb == 2, "cb=%u expected 2\n", cb);
2490 hres = IInternetProtocol_Read(protocol, buf, sizeof(buf), &cb);
2491 ok(hres == S_FALSE, "Read failed: %08x\n", hres);
2492 hres = IInternetProtocol_Read(protocol, buf, sizeof(buf), &cb);
2493 ok(hres == S_FALSE, "Read failed: %08x expected S_FALSE\n", hres);
2494 ok(cb == 0, "cb=%u expected 0\n", cb);
2495 hres = IInternetProtocol_UnlockRequest(protocol);
2496 ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
2497 }
2498
2499 if(file_protocol_start(protocol, url, NULL, NULL, FALSE)) {
2500 hres = IInternetProtocol_Read(protocol, buf, 2, &cb);
2501 ok(hres == S_FALSE, "Read failed: %08x\n", hres);
2502 hres = IInternetProtocol_LockRequest(protocol, 0);
2503 ok(hres == S_OK, "LockRequest failed: %08x\n", hres);
2504 hres = IInternetProtocol_UnlockRequest(protocol);
2505 ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
2506 }
2507
2508 IInternetProtocol_Release(protocol);
2509 }
2510
2511 hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocol, (void**)&protocol);
2512 ok(hres == S_OK, "Could not get IInternetProtocol: %08x\n", hres);
2513 if(SUCCEEDED(hres)) {
2514 if(file_protocol_start(protocol, url, NULL, NULL, TRUE)) {
2515 hres = IInternetProtocol_LockRequest(protocol, 0);
2516 ok(hres == S_OK, "LockRequest failed: %08x\n", hres);
2517 hres = IInternetProtocol_Terminate(protocol, 0);
2518 ok(hres == S_OK, "Terminate failed: %08x\n", hres);
2519 hres = IInternetProtocol_Read(protocol, buf, 2, &cb);
2520 ok(hres == S_OK, "Read failed: %08x\n\n", hres);
2521 hres = IInternetProtocol_UnlockRequest(protocol);
2522 ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
2523 hres = IInternetProtocol_Read(protocol, buf, 2, &cb);
2524 ok(hres == S_OK, "Read failed: %08x\n", hres);
2525 hres = IInternetProtocol_Terminate(protocol, 0);
2526 ok(hres == S_OK, "Terminate failed: %08x\n", hres);
2527 }
2528
2529 IInternetProtocol_Release(protocol);
2530 }
2531
2532 hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocol, (void**)&protocol);
2533 ok(hres == S_OK, "Could not get IInternetProtocol: %08x\n", hres);
2534 if(SUCCEEDED(hres)) {
2535 if(file_protocol_start(protocol, url, NULL, NULL, TRUE)) {
2536 hres = IInternetProtocol_Terminate(protocol, 0);
2537 ok(hres == S_OK, "Terminate failed: %08x\n", hres);
2538 hres = IInternetProtocol_Read(protocol, buf, 2, &cb);
2539 ok(hres == S_OK, "Read failed: %08x\n", hres);
2540 ok(cb == 2, "cb=%u expected 2\n", cb);
2541 }
2542
2543 IInternetProtocol_Release(protocol);
2544 }
2545
2546 if(pCreateUri) {
2547 IInternetProtocolEx *protocolex;
2548 IUri *uri;
2549
2550 hres = pCreateUri(url, Uri_CREATE_FILE_USE_DOS_PATH, 0, &uri);
2551 ok(hres == S_OK, "CreateUri failed: %08x\n", hres);
2552
2553 hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocolEx, (void**)&protocolex);
2554 ok(hres == S_OK, "Could not get IInternetProtocolEx: %08x\n", hres);
2555
2556 if(file_protocol_start(NULL, NULL, protocolex, uri, TRUE)) {
2557 hres = IInternetProtocolEx_Read(protocolex, buf, 2, &cb);
2558 ok(hres == S_OK, "Read failed: %08x\n", hres);
2559 hres = IInternetProtocolEx_LockRequest(protocolex, 0);
2560 ok(hres == S_OK, "LockRequest failed: %08x\n", hres);
2561 hres = IInternetProtocolEx_UnlockRequest(protocolex);
2562 ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
2563 }
2564
2565 IUri_Release(uri);
2566 IInternetProtocolEx_Release(protocolex);
2567
2568 hres = pCreateUri(url, 0, 0, &uri);
2569 ok(hres == S_OK, "CreateUri failed: %08x\n", hres);
2570
2571 hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocolEx, (void**)&protocolex);
2572 ok(hres == S_OK, "Could not get IInternetProtocolEx: %08x\n", hres);
2573
2574 if(file_protocol_start(NULL, NULL, protocolex, uri, TRUE)) {
2575 hres = IInternetProtocolEx_Read(protocolex, buf, 2, &cb);
2576 ok(hres == S_OK, "Read failed: %08x\n", hres);
2577 hres = IInternetProtocolEx_LockRequest(protocolex, 0);
2578 ok(hres == S_OK, "LockRequest failed: %08x\n", hres);
2579 hres = IInternetProtocolEx_UnlockRequest(protocolex);
2580 ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
2581 }
2582
2583 IUri_Release(uri);
2584 IInternetProtocolEx_Release(protocolex);
2585 }else {
2586 win_skip("Skipping file protocol StartEx tests\n");
2587 }
2588
2589 IClassFactory_Release(factory);
2590 }
2591
2592 static void test_file_protocol_fail(void)
2593 {
2594 IInternetProtocol *protocol;
2595 HRESULT hres;
2596
2597 static const WCHAR index_url2[] =
2598 {'f','i','l','e',':','/','/','i','n','d','e','x','.','h','t','m','l',0};
2599
2600 hres = CoCreateInstance(&CLSID_FileProtocol, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
2601 &IID_IInternetProtocol, (void**)&protocol);
2602 ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
2603 if(FAILED(hres))
2604 return;
2605
2606 SET_EXPECT(GetBindInfo);
2607 expect_hrResult = MK_E_SYNTAX;
2608 hres = IInternetProtocol_Start(protocol, wszIndexHtml, &protocol_sink, &bind_info, 0, 0);
2609 ok(hres == MK_E_SYNTAX ||
2610 hres == E_INVALIDARG,
2611 "Start failed: %08x, expected MK_E_SYNTAX or E_INVALIDARG\n", hres);
2612 CLEAR_CALLED(GetBindInfo); /* GetBindInfo not called in IE7 */
2613
2614 SET_EXPECT(GetBindInfo);
2615 if(!(bindf & BINDF_FROMURLMON))
2616 SET_EXPECT(ReportProgress_DIRECTBIND);
2617 SET_EXPECT(ReportProgress_SENDINGREQUEST);
2618 SET_EXPECT(ReportResult);
2619 expect_hrResult = INET_E_RESOURCE_NOT_FOUND;
2620 hres = IInternetProtocol_Start(protocol, index_url, &protocol_sink, &bind_info, 0, 0);
2621 ok(hres == INET_E_RESOURCE_NOT_FOUND,
2622 "Start failed: %08x expected INET_E_RESOURCE_NOT_FOUND\n", hres);
2623 CHECK_CALLED(GetBindInfo);
2624 if(!(bindf & BINDF_FROMURLMON))
2625 CHECK_CALLED(ReportProgress_DIRECTBIND);
2626 CHECK_CALLED(ReportProgress_SENDINGREQUEST);
2627 CHECK_CALLED(ReportResult);
2628
2629 IInternetProtocol_Release(protocol);
2630
2631 hres = CoCreateInstance(&CLSID_FileProtocol, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
2632 &IID_IInternetProtocol, (void**)&protocol);
2633 ok(hres == S_OK, "CoCreateInstance failed: %08x\n", hres);
2634 if(FAILED(hres))
2635 return;
2636
2637 SET_EXPECT(GetBindInfo);
2638 if(!(bindf & BINDF_FROMURLMON))
2639 SET_EXPECT(ReportProgress_DIRECTBIND);
2640 SET_EXPECT(ReportProgress_SENDINGREQUEST);
2641 SET_EXPECT(ReportResult);
2642 expect_hrResult = INET_E_RESOURCE_NOT_FOUND;
2643
2644 hres = IInternetProtocol_Start(protocol, index_url2, &protocol_sink, &bind_info, 0, 0);
2645 ok(hres == INET_E_RESOURCE_NOT_FOUND,
2646 "Start failed: %08x, expected INET_E_RESOURCE_NOT_FOUND\n", hres);
2647 CHECK_CALLED(GetBindInfo);
2648 if(!(bindf & BINDF_FROMURLMON))
2649 CHECK_CALLED(ReportProgress_DIRECTBIND);
2650 CHECK_CALLED(ReportProgress_SENDINGREQUEST);
2651 CHECK_CALLED(ReportResult);
2652
2653 SET_EXPECT(GetBindInfo);
2654 hres = IInternetProtocol_Start(protocol, NULL, &protocol_sink, &bind_info, 0, 0);
2655 ok(hres == E_INVALIDARG, "Start failed: %08x, expected E_INVALIDARG\n", hres);
2656 CLEAR_CALLED(GetBindInfo); /* GetBindInfo not called in IE7 */
2657
2658 SET_EXPECT(GetBindInfo);
2659 hres = IInternetProtocol_Start(protocol, emptyW, &protocol_sink, &bind_info, 0, 0);
2660 ok(hres == E_INVALIDARG, "Start failed: %08x, expected E_INVALIDARG\n", hres);
2661 CLEAR_CALLED(GetBindInfo); /* GetBindInfo not called in IE7 */
2662
2663 IInternetProtocol_Release(protocol);
2664 }
2665
2666 static void test_file_protocol(void) {
2667 WCHAR buf[INTERNET_MAX_URL_LENGTH], file_name_buf[MAX_PATH];
2668 DWORD size;
2669 ULONG len;
2670 HANDLE file;
2671
2672 static const WCHAR wszFile[] = {'f','i','l','e',':',0};
2673 static const WCHAR wszFile2[] = {'f','i','l','e',':','/','/',0};
2674 static const WCHAR wszFile3[] = {'f','i','l','e',':','/','/','/',0};
2675 static const WCHAR wszFile4[] = {'f','i','l','e',':','\\','\\',0};
2676 static const char html_doc[] = "<HTML></HTML>";
2677
2678 trace("Testing file protocol...\n");
2679 init_test(FILE_TEST, 0);
2680
2681 SetLastError(0xdeadbeef);
2682 file = CreateFileW(wszIndexHtml, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
2683 FILE_ATTRIBUTE_NORMAL, NULL);
2684 ok(file != INVALID_HANDLE_VALUE, "CreateFile failed\n");
2685 if(file == INVALID_HANDLE_VALUE)
2686 return;
2687 WriteFile(file, html_doc, sizeof(html_doc)-1, &size, NULL);
2688 CloseHandle(file);
2689
2690 file_name = wszIndexHtml;
2691 bindf = 0;
2692 test_file_protocol_url(index_url);
2693 bindf = BINDF_FROMURLMON;
2694 test_file_protocol_url(index_url);
2695 bindf = BINDF_FROMURLMON | BINDF_NEEDFILE;
2696 test_file_protocol_url(index_url);
2697
2698 memcpy(buf, wszFile, sizeof(wszFile));
2699 len = sizeof(wszFile)/sizeof(WCHAR)-1;
2700 len += GetCurrentDirectoryW(sizeof(buf)/sizeof(WCHAR)-len, buf+len);
2701 buf[len++] = '\\';
2702 memcpy(buf+len, wszIndexHtml, sizeof(wszIndexHtml));
2703
2704 file_name = buf + sizeof(wszFile)/sizeof(WCHAR)-1;
2705 bindf = 0;
2706 test_file_protocol_url(buf);
2707 bindf = BINDF_FROMURLMON;
2708 test_file_protocol_url(buf);
2709
2710 memcpy(buf, wszFile2, sizeof(wszFile2));
2711 len = GetCurrentDirectoryW(sizeof(file_name_buf)/sizeof(WCHAR), file_name_buf);
2712 file_name_buf[len++] = '\\';
2713 memcpy(file_name_buf+len, wszIndexHtml, sizeof(wszIndexHtml));
2714 lstrcpyW(buf+sizeof(wszFile2)/sizeof(WCHAR)-1, file_name_buf);
2715 file_name = file_name_buf;
2716 bindf = 0;
2717 test_file_protocol_url(buf);
2718 bindf = BINDF_FROMURLMON;
2719 test_file_protocol_url(buf);
2720
2721 buf[sizeof(wszFile2)/sizeof(WCHAR)] = '|';
2722 test_file_protocol_url(buf);
2723
2724 memcpy(buf, wszFile3, sizeof(wszFile3));
2725 len = sizeof(wszFile3)/sizeof(WCHAR)-1;
2726 len += GetCurrentDirectoryW(sizeof(buf)/sizeof(WCHAR)-len, buf+len);
2727 buf[len++] = '\\';
2728 memcpy(buf+len, wszIndexHtml, sizeof(wszIndexHtml));
2729
2730 file_name = buf + sizeof(wszFile3)/sizeof(WCHAR)-1;
2731 bindf = 0;
2732 test_file_protocol_url(buf);
2733 bindf = BINDF_FROMURLMON;
2734 test_file_protocol_url(buf);
2735
2736 memcpy(buf, wszFile4, sizeof(wszFile4));
2737 len = GetCurrentDirectoryW(sizeof(file_name_buf)/sizeof(WCHAR), file_name_buf);
2738 file_name_buf[len++] = '\\';
2739 memcpy(file_name_buf+len, wszIndexHtml, sizeof(wszIndexHtml));
2740 lstrcpyW(buf+sizeof(wszFile4)/sizeof(WCHAR)-1, file_name_buf);
2741 file_name = file_name_buf;
2742 bindf = 0;
2743 test_file_protocol_url(buf);
2744 bindf = BINDF_FROMURLMON;
2745 test_file_protocol_url(buf);
2746
2747 buf[sizeof(wszFile4)/sizeof(WCHAR)] = '|';
2748 test_file_protocol_url(buf);
2749
2750 DeleteFileW(wszIndexHtml);
2751
2752 bindf = 0;
2753 test_file_protocol_fail();
2754 bindf = BINDF_FROMURLMON;
2755 test_file_protocol_fail();
2756 }
2757
2758 static BOOL http_protocol_start(LPCWSTR url, BOOL use_iuri)
2759 {
2760 static BOOL got_user_agent = FALSE;
2761 IUri *uri = NULL;
2762 HRESULT hres;
2763
2764 if(use_iuri && pCreateUri) {
2765 hres = pCreateUri(url, 0, 0, &uri);
2766 ok(hres == S_OK, "CreateUri failed: %08x\n", hres);
2767 }
2768
2769 SET_EXPECT(GetBindInfo);
2770 if (!(bindf & BINDF_FROMURLMON))
2771 SET_EXPECT(ReportProgress_DIRECTBIND);
2772 if(!got_user_agent)
2773 SET_EXPECT(GetBindString_USER_AGENT);
2774 SET_EXPECT(GetBindString_ACCEPT_MIMES);
2775 SET_EXPECT(QueryService_HttpNegotiate);
2776 SET_EXPECT(BeginningTransaction);
2777 SET_EXPECT(GetRootSecurityId);
2778 if(http_post_test) {
2779 SET_EXPECT(GetBindString_POST_COOKIE);
2780 if(http_post_test == TYMED_ISTREAM)
2781 SET_EXPECT(Stream_Seek);
2782 }
2783
2784 if(uri) {
2785 IInternetProtocolEx *protocolex;
2786
2787 hres = IInternetProtocol_QueryInterface(async_protocol, &IID_IInternetProtocolEx, (void**)&protocolex);
2788 ok(hres == S_OK, "Could not get IInternetProtocolEx iface: %08x\n", hres);
2789
2790 hres = IInternetProtocolEx_StartEx(protocolex, uri, &protocol_sink, &bind_info, 0, 0);
2791 ok(hres == S_OK, "Start failed: %08x\n", hres);
2792
2793 IInternetProtocolEx_Release(protocolex);
2794 IUri_Release(uri);
2795 }else {
2796 hres = IInternetProtocol_Start(async_protocol, url, &protocol_sink, &bind_info, 0, 0);
2797 ok(hres == S_OK, "Start failed: %08x\n", hres);
2798 }
2799 if(FAILED(hres))
2800 return FALSE;
2801
2802 CHECK_CALLED(GetBindInfo);
2803 if (!(bindf & BINDF_FROMURLMON))
2804 CHECK_CALLED(ReportProgress_DIRECTBIND);
2805 if (!got_user_agent)
2806 {
2807 CHECK_CALLED(GetBindString_USER_AGENT);
2808 got_user_agent = TRUE;
2809 }
2810 CHECK_CALLED(GetBindString_ACCEPT_MIMES);
2811 CHECK_CALLED(QueryService_HttpNegotiate);
2812 CHECK_CALLED(BeginningTransaction);
2813 /* GetRootSecurityId called on WinXP but not on Win98 */
2814 CLEAR_CALLED(GetRootSecurityId);
2815 if(http_post_test) {
2816 CHECK_CALLED(GetBindString_POST_COOKIE);
2817 if(http_post_test == TYMED_ISTREAM)
2818 CHECK_CALLED(Stream_Seek);
2819 }
2820
2821 return TRUE;
2822 }
2823
2824 static void test_protocol_terminate(IInternetProtocol *protocol)
2825 {
2826 BYTE buf[3600];
2827 DWORD cb;
2828 HRESULT hres;
2829
2830 hres = IInternetProtocol_LockRequest(protocol, 0);
2831 ok(hres == S_OK, "LockRequest failed: %08x\n", hres);
2832
2833 hres = IInternetProtocol_Read(protocol, buf, 1, &cb);
2834 ok(hres == test_abort ? S_OK : S_FALSE, "Read failed: %08x\n", hres);
2835
2836 hres = IInternetProtocol_Terminate(protocol, 0);
2837 ok(hres == S_OK, "Terminate failed: %08x\n", hres);
2838
2839 /* This wait is to give the internet handles being freed in Terminate
2840 * enough time to actually terminate in all cases. Internet handles
2841 * terminate asynchronously and native reuses the main InternetOpen
2842 * handle. The only case in which this seems to be necessary is on
2843 * wine with native wininet and urlmon, resulting in the next time
2844 * test_http_protocol_url being called the first data notification actually
2845 * being an extra last data notification from the previous connection
2846 * about once out of every ten times. */
2847 Sleep(100);
2848
2849 hres = IInternetProtocol_UnlockRequest(protocol);
2850 ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
2851 }
2852
2853 static void test_http_info(IInternetProtocol *protocol)
2854 {
2855 IWinInetHttpInfo *info;
2856 HRESULT hres;
2857
2858 hres = IInternetProtocol_QueryInterface(protocol, &IID_IWinInetHttpInfo, (void**)&info);
2859 ok(hres == S_OK, "Could not get IWinInterHttpInfo iface: %08x\n", hres);
2860
2861 /* TODO */
2862
2863 IWinInetHttpInfo_Release(info);
2864 }
2865
2866 /* is_first refers to whether this is the first call to this function
2867 * _for this url_ */
2868 static void test_http_protocol_url(LPCWSTR url, int prot, DWORD flags, DWORD tymed)
2869 {
2870 IInternetProtocolInfo *protocol_info;
2871 IClassFactory *factory;
2872 IUnknown *unk;
2873 HRESULT hres;
2874
2875 init_test(prot, flags);
2876 http_url = url;
2877 http_post_test = tymed;
2878
2879 hres = CoGetClassObject(prot == HTTPS_TEST ? &CLSID_HttpSProtocol : &CLSID_HttpProtocol,
2880 CLSCTX_INPROC_SERVER, NULL, &IID_IUnknown, (void**)&unk);
2881 ok(hres == S_OK, "CoGetClassObject failed: %08x\n", hres);
2882 if(FAILED(hres))
2883 return;
2884
2885 hres = IUnknown_QueryInterface(unk, &IID_IInternetProtocolInfo, (void**)&protocol_info);
2886 ok(hres == E_NOINTERFACE,
2887 "Could not get IInternetProtocolInfo interface: %08x, expected E_NOINTERFACE\n",
2888 hres);
2889
2890 hres = IUnknown_QueryInterface(unk, &IID_IClassFactory, (void**)&factory);
2891 ok(hres == S_OK, "Could not get IClassFactory interface\n");
2892 IUnknown_Release(unk);
2893 if(FAILED(hres))
2894 return;
2895
2896 hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocol,
2897 (void**)&async_protocol);
2898 ok(hres == S_OK, "Could not get IInternetProtocol: %08x\n", hres);
2899 if(SUCCEEDED(hres)) {
2900 BYTE buf[3600];
2901 DWORD cb;
2902 ULONG ref;
2903
2904 test_priority(async_protocol);
2905 test_http_info(async_protocol);
2906
2907 SET_EXPECT(ReportProgress_COOKIE_SENT);
2908 if(http_is_first) {
2909 SET_EXPECT(ReportProgress_FINDINGRESOURCE);
2910 SET_EXPECT(ReportProgress_CONNECTING);
2911 }
2912 SET_EXPECT(ReportProgress_SENDINGREQUEST);
2913 if(test_redirect)
2914 SET_EXPECT(ReportProgress_REDIRECTING);
2915 SET_EXPECT(ReportProgress_PROXYDETECTING);
2916 if(prot == HTTP_TEST)
2917 SET_EXPECT(ReportProgress_CACHEFILENAMEAVAILABLE);
2918 else
2919 SET_EXPECT(QueryService_HttpSecurity);
2920 if(!(bindf & BINDF_FROMURLMON)) {
2921 SET_EXPECT(OnResponse);
2922 SET_EXPECT(ReportProgress_RAWMIMETYPE);
2923 SET_EXPECT(ReportData);
2924 } else {
2925 SET_EXPECT(Switch);
2926 }
2927
2928 if(!http_protocol_start(url, (flags & TEST_USEIURI) != 0))
2929 return;
2930
2931 if(!direct_read && !test_abort)
2932 SET_EXPECT(ReportResult);
2933 expect_hrResult = test_abort ? E_ABORT : S_OK;
2934
2935 if(direct_read) {
2936 SET_EXPECT(Switch);
2937 while(wait_for_switch) {
2938 WaitForSingleObject(event_continue, INFINITE);
2939 CHECK_CALLED(Switch); /* Set in ReportData */
2940 call_continue(&continue_protdata);
2941 SetEvent(event_continue_done);
2942 }
2943 }else {
2944 hres = IInternetProtocol_Read(async_protocol, buf, 1, &cb);
2945 ok((hres == E_PENDING && cb==0) ||
2946 (hres == S_OK && cb==1), "Read failed: %08x (%d bytes)\n", hres, cb);
2947
2948 WaitForSingleObject(event_complete, INFINITE);
2949 if(bindf & BINDF_FROMURLMON)
2950 CHECK_CALLED(Switch);
2951 else
2952 CHECK_CALLED(ReportData);
2953 if(prot == HTTPS_TEST)
2954 CLEAR_CALLED(QueryService_HttpSecurity);
2955
2956 while(1) {
2957 if(bindf & BINDF_FROMURLMON)
2958 SET_EXPECT(Switch);
2959 else
2960 SET_EXPECT(ReportData);
2961 hres = IInternetProtocol_Read(async_protocol, buf, sizeof(buf), &cb);
2962 if(hres == E_PENDING) {
2963 hres = IInternetProtocol_Read(async_protocol, buf, 1, &cb);
2964 ok((hres == E_PENDING && cb==0) ||
2965 (hres == S_OK && cb==1), "Read failed: %08x (%d bytes)\n", hres, cb);
2966 WaitForSingleObject(event_complete, INFINITE);
2967 if(bindf & BINDF_FROMURLMON)
2968 CHECK_CALLED(Switch);
2969 else
2970 CHECK_CALLED(ReportData);
2971
2972 if(test_abort) {
2973 HRESULT hres;
2974
2975 SET_EXPECT(ReportResult);
2976 hres = IInternetProtocol_Abort(async_protocol, E_ABORT, 0);
2977 ok(hres == S_OK, "Abort failed: %08x\n", hres);
2978 CHECK_CALLED(ReportResult);
2979
2980 hres = IInternetProtocol_Abort(async_protocol, E_ABORT, 0);
2981 ok(hres == INET_E_RESULT_DISPATCHED, "Abort failed: %08x\n", hres);
2982 break;
2983 }
2984 }else {
2985 if(bindf & BINDF_FROMURLMON)
2986 CHECK_NOT_CALLED(Switch);
2987 else
2988 CHECK_NOT_CALLED(ReportData);
2989 if(cb == 0) break;
2990 }
2991 }
2992 if(!test_abort) {
2993 ok(hres == S_FALSE, "Read failed: %08x\n", hres);
2994 CHECK_CALLED(ReportResult);
2995 }
2996 }
2997 if(prot == HTTPS_TEST)
2998 CLEAR_CALLED(ReportProgress_SENDINGREQUEST);
2999
3000 if (prot == HTTP_TEST || prot == HTTPS_TEST)
3001 CLEAR_CALLED(ReportProgress_COOKIE_SENT);
3002
3003 hres = IInternetProtocol_Abort(async_protocol, E_ABORT, 0);
3004 ok(hres == INET_E_RESULT_DISPATCHED, "Abort failed: %08x\n", hres);
3005
3006 test_protocol_terminate(async_protocol);
3007
3008 hres = IInternetProtocol_Abort(async_protocol, E_ABORT, 0);
3009 ok(hres == S_OK, "Abort failed: %08x\n", hres);
3010
3011 ref = IInternetProtocol_Release(async_protocol);
3012 ok(!ref, "ref=%x\n", ref);
3013 }
3014
3015 IClassFactory_Release(factory);
3016 }
3017
3018 static void test_http_protocol(void)
3019 {
3020 static const WCHAR posttest_url[] =
3021 {'h','t','t','p',':','/','/','t','e','s','t','.','w','i','n','e','h','q','.','o','r','g','/',
3022 't','e','s','t','s','/','p','o','s','t','.','p','h','p',0};
3023 static const WCHAR redirect_url[] =
3024 {'h','t','t','p',':','/','/','t','e','s','t','.','w','i','n','e','h','q','.','o','r','g','/',
3025 't','e','s','t','s','/','r','e','d','i','r','e','c','t',0};
3026 static const WCHAR winetest_url[] =
3027 {'h','t','t','p',':','/','/','t','e','s','t','.','w','i','n','e','h','q','.','o','r','g','/',
3028 't','e','s','t','s','/','d','a','t','a','.','p','h','p',0};
3029 static const WCHAR empty_url[] =
3030 {'h','t','t','p',':','/','/','t','e','s','t','.','w','i','n','e','h','q','.','o','r','g','/',
3031 't','e','s','t','s','/','e','m','p','t','y','.','j','s',0};
3032
3033 trace("Testing http protocol (not from urlmon)...\n");
3034 bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA;
3035 test_http_protocol_url(winetest_url, HTTP_TEST, TEST_FIRST_HTTP, TYMED_NULL);
3036
3037 trace("Testing http protocol (from urlmon)...\n");
3038 bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA | BINDF_FROMURLMON;
3039 test_http_protocol_url(winetest_url, HTTP_TEST, 0, TYMED_NULL);
3040
3041 trace("Testing http protocol (to file)...\n");
3042 bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA | BINDF_FROMURLMON | BINDF_NEEDFILE;
3043 test_http_protocol_url(winetest_url, HTTP_TEST, 0, TYMED_NULL);
3044
3045 trace("Testing http protocol (post data)...\n");
3046 bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA | BINDF_FROMURLMON;
3047 test_http_protocol_url(posttest_url, HTTP_TEST, TEST_FIRST_HTTP|TEST_POST, TYMED_HGLOBAL);
3048
3049 trace("Testing http protocol (post data stream)...\n");
3050 test_http_protocol_url(posttest_url, HTTP_TEST, TEST_FIRST_HTTP|TEST_POST|TEST_ASYNCREQ, TYMED_ISTREAM);
3051
3052 trace("Testing http protocol (direct read)...\n");
3053 bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA | BINDF_FROMURLMON;
3054 test_http_protocol_url(winetest_url, HTTP_TEST, TEST_DIRECT_READ|TEST_USEIURI, TYMED_NULL);
3055
3056 trace("Testing http protocol (redirected)...\n");
3057 bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA | BINDF_FROMURLMON | BINDF_NOWRITECACHE;
3058 test_http_protocol_url(redirect_url, HTTP_TEST, TEST_REDIRECT, TYMED_NULL);
3059
3060 trace("Testing http protocol empty file...\n");
3061 test_http_protocol_url(empty_url, HTTP_TEST, TEST_EMPTY, TYMED_NULL);
3062
3063 trace("Testing http protocol abort...\n");
3064 test_http_protocol_url(winetest_url, HTTP_TEST, TEST_ABORT, TYMED_NULL);
3065
3066 test_early_abort(&CLSID_HttpProtocol);
3067 test_early_abort(&CLSID_HttpSProtocol);
3068 }
3069
3070 static void test_https_protocol(void)
3071 {
3072 static const WCHAR codeweavers_url[] =
3073 {'h','t','t','p','s',':','/','/','w','w','w','.','c','o','d','e','w','e','a','v','e','r','s',
3074 '.','c','o','m','/','t','e','s','t','.','h','t','m','l',0};
3075
3076 trace("Testing https protocol (from urlmon)...\n");
3077 bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA | BINDF_FROMURLMON | BINDF_NOWRITECACHE;
3078 test_http_protocol_url(codeweavers_url, HTTPS_TEST, TEST_FIRST_HTTP, TYMED_NULL);
3079 }
3080
3081
3082 static void test_ftp_protocol(void)
3083 {
3084 IInternetProtocolInfo *protocol_info;
3085 IClassFactory *factory;
3086 IUnknown *unk;
3087 BYTE buf[4096];
3088 ULONG ref;
3089 DWORD cb;
3090 HRESULT hres;
3091
3092 static const WCHAR ftp_urlW[] = {'f','t','p',':','/','/','f','t','p','.','w','i','n','e','h','q','.','o','r','g',
3093 '/','p','u','b','/','o','t','h','e','r','/',
3094 'w','i','n','e','l','o','g','o','.','x','c','f','.','t','a','r','.','b','z','2',0};
3095
3096 trace("Testing ftp protocol...\n");
3097
3098 bindf = BINDF_ASYNCHRONOUS | BINDF_ASYNCSTORAGE | BINDF_PULLDATA | BINDF_FROMURLMON | BINDF_NOWRITECACHE;
3099 state = STATE_STARTDOWNLOADING;
3100 tested_protocol = FTP_TEST;
3101 first_data_notif = TRUE;
3102 expect_hrResult = E_PENDING;
3103
3104 hres = CoGetClassObject(&CLSID_FtpProtocol, CLSCTX_INPROC_SERVER, NULL, &IID_IUnknown, (void**)&unk);
3105 ok(hres == S_OK, "CoGetClassObject failed: %08x\n", hres);
3106 if(FAILED(hres))
3107 return;
3108
3109 hres = IUnknown_QueryInterface(unk, &IID_IInternetProtocolInfo, (void**)&protocol_info);
3110 ok(hres == E_NOINTERFACE, "Could not get IInternetProtocolInfo interface: %08x, expected E_NOINTERFACE\n", hres);
3111
3112 hres = IUnknown_QueryInterface(unk, &IID_IClassFactory, (void**)&factory);
3113 ok(hres == S_OK, "Could not get IClassFactory interface\n");
3114 IUnknown_Release(unk);
3115 if(FAILED(hres))
3116 return;
3117
3118 hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocol,
3119 (void**)&async_protocol);
3120 IClassFactory_Release(factory);
3121 ok(hres == S_OK, "Could not get IInternetProtocol: %08x\n", hres);
3122
3123 test_priority(async_protocol);
3124 test_http_info(async_protocol);
3125
3126 SET_EXPECT(GetBindInfo);
3127 SET_EXPECT(ReportProgress_FINDINGRESOURCE);
3128 SET_EXPECT(ReportProgress_CONNECTING);
3129 SET_EXPECT(ReportProgress_SENDINGREQUEST);
3130 SET_EXPECT(Switch);
3131
3132 hres = IInternetProtocol_Start(async_protocol, ftp_urlW, &protocol_sink, &bind_info, 0, 0);
3133 ok(hres == S_OK, "Start failed: %08x\n", hres);
3134 CHECK_CALLED(GetBindInfo);
3135
3136 SET_EXPECT(ReportResult);
3137
3138 hres = IInternetProtocol_Read(async_protocol, buf, 1, &cb);
3139 ok((hres == E_PENDING && cb==0) ||
3140 (hres == S_OK && cb==1), "Read failed: %08x (%d bytes)\n", hres, cb);
3141
3142 WaitForSingleObject(event_complete, INFINITE);
3143
3144 while(1) {
3145 hres = IInternetProtocol_Read(async_protocol, buf, sizeof(buf), &cb);
3146 if(hres == E_PENDING)
3147 WaitForSingleObject(event_complete, INFINITE);
3148 else
3149 if(cb == 0) break;
3150 }
3151
3152 ok(hres == S_FALSE, "Read failed: %08x\n", hres);
3153 CHECK_CALLED(ReportResult);
3154 CHECK_CALLED(Switch);
3155
3156 test_protocol_terminate(async_protocol);
3157
3158 if(pCreateUri) {
3159 IInternetProtocolEx *protocolex;
3160
3161 hres = IInternetProtocol_QueryInterface(async_protocol, &IID_IInternetProtocolEx, (void**)&protocolex);
3162 ok(hres == S_OK, "Could not get IInternetProtocolEx iface: %08x\n", hres);
3163 IInternetProtocolEx_Release(protocolex);
3164 }
3165
3166 ref = IInternetProtocol_Release(async_protocol);
3167 ok(!ref, "ref=%d\n", ref);
3168
3169 test_early_abort(&CLSID_FtpProtocol);
3170 }
3171
3172 static void test_gopher_protocol(void)
3173 {
3174 IInternetProtocolInfo *protocol_info;
3175 IClassFactory *factory;
3176 IUnknown *unk;
3177 HRESULT hres;
3178
3179 trace("Testing gopher protocol...\n");
3180
3181 hres = CoGetClassObject(&CLSID_GopherProtocol, CLSCTX_INPROC_SERVER, NULL, &IID_IUnknown, (void**)&unk);
3182 ok(hres == S_OK ||
3183 hres == REGDB_E_CLASSNOTREG, /* Gopher protocol has been removed as of Vista */
3184 "CoGetClassObject failed: %08x\n", hres);
3185 if(FAILED(hres))
3186 return;
3187
3188 hres = IUnknown_QueryInterface(unk, &IID_IInternetProtocolInfo, (void**)&protocol_info);
3189 ok(hres == E_NOINTERFACE, "Could not get IInternetProtocolInfo interface: %08x, expected E_NOINTERFACE\n", hres);
3190
3191 hres = IUnknown_QueryInterface(unk, &IID_IClassFactory, (void**)&factory);
3192 ok(hres == S_OK, "Could not get IClassFactory interface\n");
3193 IUnknown_Release(unk);
3194 if(FAILED(hres))
3195 return;
3196
3197 hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocol,
3198 (void**)&async_protocol);
3199 IClassFactory_Release(factory);
3200 ok(hres == S_OK, "Could not get IInternetProtocol: %08x\n", hres);
3201
3202 test_priority(async_protocol);
3203
3204 IInternetProtocol_Release(async_protocol);
3205
3206 test_early_abort(&CLSID_GopherProtocol);
3207 }
3208
3209 static void test_mk_protocol(void)
3210 {
3211 IInternetProtocolInfo *protocol_info;
3212 IInternetProtocol *protocol;
3213 IClassFactory *factory;
3214 IUnknown *unk;
3215 HRESULT hres;
3216
3217 static const WCHAR wrong_url1[] = {'t','e','s','t',':','@','M','S','I','T','S','t','o','r','e',
3218 ':',':','/','t','e','s','t','.','h','t','m','l',0};
3219 static const WCHAR wrong_url2[] = {'m','k',':','/','t','e','s','t','.','h','t','m','l',0};
3220
3221 trace("Testing mk protocol...\n");
3222 init_test(MK_TEST, 0);
3223
3224 hres = CoGetClassObject(&CLSID_MkProtocol, CLSCTX_INPROC_SERVER, NULL,
3225 &IID_IUnknown, (void**)&unk);
3226 ok(hres == S_OK, "CoGetClassObject failed: %08x\n", hres);
3227
3228 hres = IUnknown_QueryInterface(unk, &IID_IInternetProtocolInfo, (void**)&protocol_info);
3229 ok(hres == E_NOINTERFACE,
3230 "Could not get IInternetProtocolInfo interface: %08x, expected E_NOINTERFACE\n",
3231 hres);
3232
3233 hres = IUnknown_QueryInterface(unk, &IID_IClassFactory, (void**)&factory);
3234 ok(hres == S_OK, "Could not get IClassFactory interface\n");
3235 IUnknown_Release(unk);
3236 if(FAILED(hres))
3237 return;
3238
3239 hres = IClassFactory_CreateInstance(factory, NULL, &IID_IInternetProtocol,
3240 (void**)&protocol);
3241 IClassFactory_Release(factory);
3242 ok(hres == S_OK, "Could not get IInternetProtocol: %08x\n", hres);
3243
3244 SET_EXPECT(GetBindInfo);
3245 hres = IInternetProtocol_Start(protocol, wrong_url1, &protocol_sink, &bind_info, 0, 0);
3246 ok(hres == MK_E_SYNTAX || hres == INET_E_INVALID_URL,
3247 "Start failed: %08x, expected MK_E_SYNTAX or INET_E_INVALID_URL\n", hres);
3248 CLEAR_CALLED(GetBindInfo);
3249
3250 SET_EXPECT(GetBindInfo);
3251 SET_EXPECT(ReportProgress_DIRECTBIND);
3252 SET_EXPECT(ReportProgress_SENDINGREQUEST);
3253 SET_EXPECT(ReportProgress_MIMETYPEAVAILABLE);
3254 SET_EXPECT(ReportResult);
3255 expect_hrResult = INET_E_RESOURCE_NOT_FOUND;
3256
3257 hres = IInternetProtocol_Start(protocol, wrong_url2, &protocol_sink, &bind_info, 0, 0);
3258 ok(hres == INET_E_RESOURCE_NOT_FOUND ||
3259 hres == INET_E_INVALID_URL, /* win2k3 */
3260 "Start failed: %08x, expected INET_E_RESOURCE_NOT_FOUND or INET_E_INVALID_URL\n", hres);
3261
3262 if (hres == INET_E_RESOURCE_NOT_FOUND) {
3263 CHECK_CALLED(GetBindInfo);
3264 CLEAR_CALLED(ReportProgress_DIRECTBIND);
3265 CHECK_CALLED(ReportProgress_SENDINGREQUEST);
3266 CHECK_CALLED(ReportProgress_MIMETYPEAVAILABLE);
3267 CHECK_CALLED(ReportResult);
3268 }else {
3269 CLEAR_CALLED(GetBindInfo);
3270 CLEAR_CALLED(ReportProgress_DIRECTBIND);
3271 CLEAR_CALLED(ReportProgress_SENDINGREQUEST);
3272 CLEAR_CALLED(ReportProgress_MIMETYPEAVAILABLE);
3273 CLEAR_CALLED(ReportResult);
3274 }
3275
3276 IInternetProtocol_Release(protocol);
3277 }
3278
3279 static void test_CreateBinding(void)
3280 {
3281 IInternetProtocol *protocol;
3282 IInternetPriority *priority;
3283 IInternetSession *session;
3284 IWinInetHttpInfo *http_info;
3285 IWinInetInfo *inet_info;
3286 LONG p;
3287 BYTE buf[1000];
3288 DWORD read;
3289 HRESULT hres;
3290
3291 static const WCHAR test_url[] =
3292 {'t','e','s','t',':','/','/','f','i','l','e','.','h','t','m','l',0};
3293 static const WCHAR wsz_test[] = {'t','e','s','t',0};
3294
3295 trace("Testing CreateBinding...\n");
3296 init_test(BIND_TEST, TEST_BINDING);
3297
3298 hres = pCoInternetGetSession(0, &session, 0);
3299 ok(hres == S_OK, "CoInternetGetSession failed: %08x\n", hres);
3300
3301 hres = IInternetSession_RegisterNameSpace(session, &ClassFactory, &IID_NULL, wsz_test, 0, NULL, 0);
3302 ok(hres == S_OK, "RegisterNameSpace failed: %08x\n", hres);
3303
3304 hres = IInternetSession_CreateBinding(session, NULL, test_url, NULL, NULL, &protocol, 0);
3305 binding_protocol = protocol;
3306 ok(hres == S_OK, "CreateBinding failed: %08x\n", hres);
3307 ok(protocol != NULL, "protocol == NULL\n");
3308
3309 hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetBindInfo, (void**)&prot_bind_info);
3310 ok(hres == S_OK, "QueryInterface(IID_IInternetBindInfo) failed: %08x\n", hres);
3311
3312 hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetProtocolSink, (void**)&binding_sink);
3313 ok(hres == S_OK, "Could not get IInternetProtocolSink: %08x\n", hres);
3314
3315 hres = IInternetProtocol_Start(protocol, test_url, NULL, &bind_info, 0, 0);
3316 ok(hres == E_INVALIDARG, "Start failed: %08x, expected E_INVALIDARG\n", hres);
3317 hres = IInternetProtocol_Start(protocol, test_url, &protocol_sink, NULL, 0, 0);
3318 ok(hres == E_INVALIDARG, "Start failed: %08x, expected E_INVALIDARG\n", hres);
3319 hres = IInternetProtocol_Start(protocol, NULL, &protocol_sink, &bind_info, 0, 0);
3320 ok(hres == E_INVALIDARG, "Start failed: %08x, expected E_INVALIDARG\n", hres);
3321
3322 hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetPriority, (void**)&priority);
3323 ok(hres == S_OK, "QueryInterface(IID_IInternetPriority) failed: %08x\n", hres);
3324
3325 p = 0xdeadbeef;
3326 hres = IInternetPriority_GetPriority(priority, &p);
3327 ok(hres == S_OK, "GetPriority failed: %08x\n", hres);
3328 ok(!p, "p=%d\n", p);
3329
3330 ex_priority = 100;
3331 hres = IInternetPriority_SetPriority(priority, 100);
3332 ok(hres == S_OK, "SetPriority failed: %08x\n", hres);
3333
3334 p = 0xdeadbeef;
3335 hres = IInternetPriority_GetPriority(priority, &p);
3336 ok(hres == S_OK, "GetPriority failed: %08x\n", hres);
3337 ok(p == 100, "p=%d\n", p);
3338
3339 hres = IInternetProtocol_QueryInterface(protocol, &IID_IWinInetInfo, (void**)&inet_info);
3340 ok(hres == E_NOINTERFACE, "Could not get IWinInetInfo protocol: %08x\n", hres);
3341
3342 SET_EXPECT(QueryService_InternetProtocol);
3343 SET_EXPECT(CreateInstance);
3344 SET_EXPECT(ReportProgress_PROTOCOLCLASSID);
3345 SET_EXPECT(SetPriority);
3346 SET_EXPECT(Start);
3347
3348 expect_hrResult = S_OK;
3349 hres = IInternetProtocol_Start(protocol, test_url, &protocol_sink, &bind_info, 0, 0);
3350 ok(hres == S_OK, "Start failed: %08x\n", hres);
3351
3352 CHECK_CALLED(QueryService_InternetProtocol);
3353 CHECK_CALLED(CreateInstance);
3354 CHECK_CALLED(ReportProgress_PROTOCOLCLASSID);
3355 CHECK_CALLED(SetPriority);
3356 CHECK_CALLED(Start);
3357
3358 SET_EXPECT(QueryInterface_IWinInetInfo);
3359 hres = IInternetProtocol_QueryInterface(protocol, &IID_IWinInetInfo, (void**)&inet_info);
3360 ok(hres == E_NOINTERFACE, "Could not get IWinInetInfo protocol: %08x\n", hres);
3361 CHECK_CALLED(QueryInterface_IWinInetInfo);
3362
3363 SET_EXPECT(QueryInterface_IWinInetInfo);
3364 hres = IInternetProtocol_QueryInterface(protocol, &IID_IWinInetInfo, (void**)&inet_info);
3365 ok(hres == E_NOINTERFACE, "Could not get IWinInetInfo protocol: %08x\n", hres);
3366 CHECK_CALLED(QueryInterface_IWinInetInfo);
3367
3368 SET_EXPECT(QueryInterface_IWinInetHttpInfo);
3369 hres = IInternetProtocol_QueryInterface(protocol, &IID_IWinInetHttpInfo, (void**)&http_info);
3370 ok(hres == E_NOINTERFACE, "Could not get IWinInetInfo protocol: %08x\n", hres);
3371 CHECK_CALLED(QueryInterface_IWinInetHttpInfo);
3372
3373 SET_EXPECT(Read);
3374 read = 0xdeadbeef;
3375 hres = IInternetProtocol_Read(protocol, expect_pv = buf, sizeof(buf), &read);
3376 ok(hres == S_OK, "Read failed: %08x\n", hres);
3377 ok(read == 100, "read = %d\n", read);
3378 CHECK_CALLED(Read);
3379
3380 SET_EXPECT(Read);
3381 read = 0xdeadbeef;
3382 hres = IInternetProtocol_Read(protocol, expect_pv = buf, sizeof(buf), &read);
3383 ok(hres == S_FALSE, "Read failed: %08x\n", hres);
3384 ok(!read, "read = %d\n", read);
3385 CHECK_CALLED(Read);
3386
3387 p = 0xdeadbeef;
3388 hres = IInternetPriority_GetPriority(priority, &p);
3389 ok(hres == S_OK, "GetPriority failed: %08x\n", hres);
3390 ok(p == 100, "p=%d\n", p);
3391
3392 hres = IInternetPriority_SetPriority(priority, 101);
3393 ok(hres == S_OK, "SetPriority failed: %08x\n", hres);
3394
3395 SET_EXPECT(Terminate);
3396 hres = IInternetProtocol_Terminate(protocol, 0xdeadbeef);
3397 ok(hres == S_OK, "Terminate failed: %08x\n", hres);
3398 CHECK_CALLED(Terminate);
3399
3400 SET_EXPECT(Continue);
3401 hres = IInternetProtocolSink_Switch(binding_sink, &protocoldata);
3402 ok(hres == S_OK, "Switch failed: %08x\n", hres);
3403 CHECK_CALLED(Continue);
3404
3405 hres = IInternetProtocolSink_ReportProgress(binding_sink,
3406 BINDSTATUS_CACHEFILENAMEAVAILABLE, expect_wsz = emptyW);
3407 ok(hres == S_OK, "ReportProgress(BINDSTATUS_CACHEFILENAMEAVAILABLE) failed: %08x\n", hres);
3408
3409 hres = IInternetProtocolSink_ReportResult(binding_sink, S_OK, ERROR_SUCCESS, NULL);
3410 ok(hres == E_FAIL, "ReportResult failed: %08x, expected E_FAIL\n", hres);
3411
3412 hres = IInternetProtocolSink_ReportData(binding_sink, 0, 0, 0);
3413 ok(hres == S_OK, "ReportData failed: %08x\n", hres);
3414
3415 IInternetProtocolSink_Release(binding_sink);
3416 IInternetPriority_Release(priority);
3417 IInternetBindInfo_Release(prot_bind_info);
3418 IInternetProtocol_Release(protocol);
3419
3420 hres = IInternetSession_CreateBinding(session, NULL, test_url, NULL, NULL, &protocol, 0);
3421 ok(hres == S_OK, "CreateBinding failed: %08x\n", hres);
3422 ok(protocol != NULL, "protocol == NULL\n");
3423
3424 hres = IInternetProtocol_Abort(protocol, E_ABORT, 0);
3425 ok(hres == S_OK, "Abort failed: %08x\n", hres);
3426
3427 hres = IInternetProtocol_Abort(protocol, E_FAIL, 0);
3428 ok(hres == S_OK, "Abort failed: %08x\n", hres);
3429
3430 IInternetProtocol_Release(protocol);
3431
3432 hres = IInternetSession_UnregisterNameSpace(session, &ClassFactory, wsz_test);
3433 ok(hres == S_OK, "UnregisterNameSpace failed: %08x\n", hres);
3434
3435 hres = IInternetSession_CreateBinding(session, NULL, test_url, NULL, NULL, &protocol, 0);
3436 ok(hres == S_OK, "CreateBinding failed: %08x\n", hres);
3437 ok(protocol != NULL, "protocol == NULL\n");
3438
3439 SET_EXPECT(QueryService_InternetProtocol);
3440 hres = IInternetProtocol_Start(protocol, test_url, &protocol_sink, &bind_info, 0, 0);
3441 ok(hres == MK_E_SYNTAX, "Start failed: %08x, expected MK_E_SYNTAX\n", hres);
3442 CHECK_CALLED(QueryService_InternetProtocol);
3443
3444 IInternetProtocol_Release(protocol);
3445
3446 IInternetSession_Release(session);
3447 }
3448
3449 static void test_binding(int prot, DWORD grf_pi, DWORD test_flags)
3450 {
3451 IInternetProtocolEx *protocolex = NULL;
3452 IInternetProtocol *protocol;
3453 IInternetSession *session;
3454 IUri *uri = NULL;
3455 ULONG ref;
3456 HRESULT hres;
3457
3458 pi = grf_pi;
3459
3460 init_test(prot, test_flags|TEST_BINDING);
3461
3462 hres = pCoInternetGetSession(0, &session, 0);
3463 ok(hres == S_OK, "CoInternetGetSession failed: %08x\n", hres);
3464
3465 if(test_flags & TEST_EMULATEPROT) {
3466 hres = IInternetSession_RegisterNameSpace(session, &ClassFactory, &IID_NULL, protocol_names[prot], 0, NULL, 0);
3467 ok(hres == S_OK, "RegisterNameSpace failed: %08x\n", hres);
3468 }
3469
3470 hres = IInternetSession_CreateBinding(session, NULL, binding_urls[prot], NULL, NULL, &protocol, 0);
3471 binding_protocol = protocol;
3472 ok(hres == S_OK, "CreateBinding failed: %08x\n", hres);
3473 ok(protocol != NULL, "protocol == NULL\n");
3474
3475 hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetBindInfo, (void**)&prot_bind_info);
3476 ok(hres == S_OK, "QueryInterface(IID_IInternetBindInfo) failed: %08x\n", hres);
3477
3478 hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetProtocolSink, (void**)&binding_sink);
3479 ok(hres == S_OK, "QueryInterface(IID_IInternetProtocolSink) failed: %08x\n", hres);
3480
3481 if(test_flags & TEST_USEIURI) {
3482 hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetProtocolEx, (void**)&protocolex);
3483 ok(hres == S_OK, "Could not get IInternetProtocolEx iface: %08x\n", hres);
3484
3485 hres = pCreateUri(binding_urls[prot], Uri_CREATE_FILE_USE_DOS_PATH, 0, &uri);
3486 ok(hres == S_OK, "CreateUri failed: %08x\n", hres);
3487 }
3488
3489 ex_priority = 0;
3490 SET_EXPECT(QueryService_InternetProtocol);
3491 SET_EXPECT(CreateInstance);
3492 SET_EXPECT(ReportProgress_PROTOCOLCLASSID);
3493 SET_EXPECT(SetPriority);
3494 if(impl_protex)
3495 SET_EXPECT(StartEx);
3496 else
3497 SET_EXPECT(Start);
3498
3499 expect_hrResult = S_OK;
3500
3501 if(protocolex) {
3502 hres = IInternetProtocolEx_StartEx(protocolex, uri, &protocol_sink, &bind_info, pi, 0);
3503 ok(hres == S_OK, "StartEx failed: %08x\n", hres);
3504 }else {
3505 hres = IInternetProtocol_Start(protocol, binding_urls[prot], &protocol_sink, &bind_info, pi, 0);
3506 ok(hres == S_OK, "Start failed: %08x\n", hres);
3507 }
3508
3509 CHECK_CALLED(QueryService_InternetProtocol);
3510 CHECK_CALLED(CreateInstance);
3511 CHECK_CALLED(ReportProgress_PROTOCOLCLASSID);
3512 CHECK_CALLED(SetPriority);
3513 if(impl_protex)
3514 CHECK_CALLED(StartEx);
3515 else
3516 CHECK_CALLED(Start);
3517
3518 if(protocolex)
3519 IInternetProtocolEx_Release(protocolex);
3520 if(uri)
3521 IUri_Release(uri);
3522
3523 if(prot == HTTP_TEST || prot == HTTPS_TEST) {
3524 while(prot_state < 4) {
3525 WaitForSingleObject(event_complete, INFINITE);
3526 if(mimefilter_test && filtered_protocol) {
3527 SET_EXPECT(Continue);
3528 IInternetProtocol_Continue(filtered_protocol, pdata);
3529 CHECK_CALLED(Continue);
3530 }else {
3531 SET_EXPECT(Continue);
3532 IInternetProtocol_Continue(protocol, pdata);
3533 CHECK_CALLED(Continue);
3534 }
3535 if(test_abort && prot_state == 2) {
3536 SET_EXPECT(Abort);
3537 hres = IInternetProtocol_Abort(protocol, E_ABORT, 0);
3538 ok(hres == S_OK, "Abort failed: %08x\n", hres);
3539 CHECK_CALLED(Abort);
3540
3541 hres = IInternetProtocol_Abort(protocol, E_ABORT, 0);
3542 ok(hres == S_OK, "Abort failed: %08x\n", hres);
3543 SetEvent(event_complete2);
3544 break;
3545 }
3546 SetEvent(event_complete2);
3547 }
3548 if(direct_read)
3549 CHECK_CALLED(ReportData); /* Set in ReportResult */
3550 WaitForSingleObject(event_complete, INFINITE);
3551 }else {
3552 if(mimefilter_test)
3553 SET_EXPECT(MimeFilter_LockRequest);
3554 else
3555 SET_EXPECT(LockRequest);
3556 hres = IInternetProtocol_LockRequest(protocol, 0);
3557 ok(hres == S_OK, "LockRequest failed: %08x\n", hres);
3558 if(mimefilter_test)
3559 CHECK_CALLED(MimeFilter_LockRequest);
3560 else
3561 CHECK_CALLED(LockRequest);
3562
3563 if(mimefilter_test)
3564 SET_EXPECT(MimeFilter_UnlockRequest);
3565 else
3566 SET_EXPECT(UnlockRequest);
3567 hres = IInternetProtocol_UnlockRequest(protocol);
3568 ok(hres == S_OK, "UnlockRequest failed: %08x\n", hres);
3569 if(mimefilter_test)
3570 CHECK_CALLED(MimeFilter_UnlockRequest);
3571 else
3572 CHECK_CALLED(UnlockRequest);
3573 }
3574
3575 if(mimefilter_test)
3576 SET_EXPECT(MimeFilter_Terminate);
3577 else
3578 SET_EXPECT(Terminate);
3579 hres = IInternetProtocol_Terminate(protocol, 0);
3580 ok(hres == S_OK, "Terminate failed: %08x\n", hres);
3581 if(mimefilter_test)
3582 CLEAR_CALLED(MimeFilter_Terminate);
3583 else
3584 CHECK_CALLED(Terminate);
3585
3586 if(filtered_protocol)
3587 IInternetProtocol_Release(filtered_protocol);
3588 IInternetBindInfo_Release(prot_bind_info);
3589 IInternetProtocolSink_Release(binding_sink);
3590 ref = IInternetProtocol_Release(protocol);
3591 ok(!ref, "ref=%u, expected 0\n", ref);
3592
3593 if(test_flags & TEST_EMULATEPROT) {
3594 hres = IInternetSession_UnregisterNameSpace(session, &ClassFactory, protocol_names[prot]);
3595 ok(hres == S_OK, "UnregisterNameSpace failed: %08x\n", hres);
3596 }
3597
3598 IInternetSession_Release(session);
3599 }
3600
3601 START_TEST(protocol)
3602 {
3603 HMODULE hurlmon;
3604
3605 hurlmon = GetModuleHandle("urlmon.dll");
3606 pCoInternetGetSession = (void*) GetProcAddress(hurlmon, "CoInternetGetSession");
3607 pReleaseBindInfo = (void*) GetProcAddress(hurlmon, "ReleaseBindInfo");
3608 pCreateUri = (void*) GetProcAddress(hurlmon, "CreateUri");
3609
3610 if(!GetProcAddress(hurlmon, "CompareSecurityIds")) {
3611 win_skip("Various needed functions not present, too old IE\n");
3612 return;
3613 }
3614
3615 if(!pCreateUri)
3616 win_skip("CreateUri not supported\n");
3617
3618 OleInitialize(NULL);
3619
3620 event_complete = CreateEvent(NULL, FALSE, FALSE, NULL);
3621 event_complete2 = CreateEvent(NULL, FALSE, FALSE, NULL);
3622 event_continue = CreateEvent(NULL, FALSE, FALSE, NULL);
3623 event_continue_done = CreateEvent(NULL, FALSE, FALSE, NULL);
3624 thread_id = GetCurrentThreadId();
3625
3626 test_file_protocol();
3627 test_http_protocol();
3628 test_https_protocol();
3629 test_ftp_protocol();
3630 test_gopher_protocol();
3631 test_mk_protocol();
3632 test_CreateBinding();
3633
3634 bindf &= ~BINDF_FROMURLMON;
3635 trace("Testing file binding (mime verification, emulate prot)...\n");
3636 test_binding(FILE_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT);
3637 trace("Testing http binding (mime verification, emulate prot)...\n");
3638 test_binding(HTTP_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT);
3639 trace("Testing its binding (mime verification, emulate prot)...\n");
3640 test_binding(ITS_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT);
3641 trace("Testing http binding (mime verification, emulate prot, short read, direct read)...\n");
3642 test_binding(HTTP_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT|TEST_SHORT_READ|TEST_DIRECT_READ);
3643 trace("Testing file binding (mime verification, emulate prot, mime filter)...\n");
3644 test_binding(FILE_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT|TEST_FILTER);
3645 trace("Testing http binding (mime verification, emulate prot, mime filter)...\n");
3646 test_binding(HTTP_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT|TEST_FILTER);
3647 trace("Testing http binding (mime verification, emulate prot, mime filter, no mime)...\n");
3648 test_binding(HTTP_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT|TEST_FILTER|TEST_NOMIME);
3649 trace("Testing http binding (mime verification, emulate prot, direct read)...\n");
3650 test_binding(HTTP_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT|TEST_DIRECT_READ);
3651 trace("Testing http binding (mime verification, emulate prot, abort)...\n");
3652 test_binding(HTTP_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT|TEST_ABORT);
3653 if(pCreateUri) {
3654 trace("Testing file binding (use IUri, mime verification, emulate prot)...\n");
3655 test_binding(FILE_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT|TEST_USEIURI);
3656 trace("Testing file binding (use IUri, impl StartEx, mime verification, emulate prot)...\n");
3657 test_binding(FILE_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT|TEST_USEIURI|TEST_IMPLPROTEX);
3658 trace("Testing file binding (impl StartEx, mime verification, emulate prot)...\n");
3659 test_binding(FILE_TEST, PI_MIMEVERIFICATION, TEST_EMULATEPROT|TEST_IMPLPROTEX);
3660 }
3661
3662 CloseHandle(event_complete);
3663 CloseHandle(event_complete2);
3664 CloseHandle(event_continue);
3665 CloseHandle(event_continue_done);
3666
3667 OleUninitialize();
3668 }
Maarten's multimedia branch