dlls/urlmon/tests/url.c

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