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