git.oblomov.eu Git - wine/blob - dlls/urlmon/binding.c

   1 /*
   2  * Copyright 2005-2007 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "urlmon_main.h"
  20 #include "winreg.h"
  21 #include "shlwapi.h"
  22
  23 #include "wine/debug.h"
  24
  25 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
  26
  27 static WCHAR cbinding_contextW[] = {'C','B','i','n','d','i','n','g',' ','C','o','n','t','e','x','t',0};
  28 static WCHAR bscb_holderW[] = { '_','B','S','C','B','_','H','o','l','d','e','r','_',0 };
  29
  30 typedef struct {
  31     IUnknown IUnknown_iface;
  32
  33     LONG ref;
  34
  35     IInternetProtocolEx *protocol;
  36
  37     HANDLE file;
  38     HRESULT hres;
  39
  40     LPWSTR cache_file;
  41 } stgmed_buf_t;
  42
  43 typedef struct _stgmed_obj_t stgmed_obj_t;
  44
  45 typedef struct {
  46     void (*release)(stgmed_obj_t*);
  47     HRESULT (*fill_stgmed)(stgmed_obj_t*,STGMEDIUM*);
  48     HRESULT (*get_result)(stgmed_obj_t*,DWORD,void**);
  49 } stgmed_obj_vtbl;
  50
  51 struct _stgmed_obj_t {
  52     const stgmed_obj_vtbl *vtbl;
  53 };
  54
  55 typedef enum {
  56     BEFORE_DOWNLOAD,
  57     DOWNLOADING,
  58     END_DOWNLOAD
  59 } download_state_t;
  60
  61 #define BINDING_LOCKED    0x0001
  62 #define BINDING_STOPPED   0x0002
  63 #define BINDING_OBJAVAIL  0x0004
  64 #define BINDING_ABORTED   0x0008
  65
  66 typedef struct {
  67     IBinding              IBinding_iface;
  68     IInternetProtocolSink IInternetProtocolSink_iface;
  69     IInternetBindInfo     IInternetBindInfo_iface;
  70     IWinInetHttpInfo      IWinInetHttpInfo_iface;
  71     IServiceProvider      IServiceProvider_iface;
  72
  73     LONG ref;
  74
  75     IBindStatusCallback *callback;
  76     IServiceProvider *service_provider;
  77
  78     BindProtocol *protocol;
  79
  80     stgmed_buf_t *stgmed_buf;
  81     stgmed_obj_t *stgmed_obj;
  82
  83     BINDINFO bindinfo;
  84     DWORD bindf;
  85     BOOL to_object;
  86     LPWSTR mime;
  87     UINT clipboard_format;
  88     LPWSTR url;
  89     LPWSTR redirect_url;
  90     IID iid;
  91     BOOL report_mime;
  92     BOOL use_cache_file;
  93     DWORD state;
  94     HRESULT hres;
  95     download_state_t download_state;
  96     IUnknown *obj;
  97     IMoniker *mon;
  98     IBindCtx *bctx;
  99     HWND notif_hwnd;
 100
 101     CRITICAL_SECTION section;
 102 } Binding;
 103
 104 static void read_protocol_data(stgmed_buf_t *stgmed_buf)
 105 {
 106     BYTE buf[8192];
 107     DWORD read;
 108     HRESULT hres;
 109
 110     do hres = IInternetProtocol_Read(stgmed_buf->protocol, buf, sizeof(buf), &read);
 111     while(hres == S_OK);
 112 }
 113
 114 static void dump_BINDINFO(BINDINFO *bi)
 115 {
 116     static const char * const BINDINFOF_str[] = {
 117         "#0",
 118         "BINDINFOF_URLENCODESTGMEDDATA",
 119         "BINDINFOF_URLENCODEDEXTRAINFO"
 120     };
 121
 122     static const char * const BINDVERB_str[] = {
 123         "BINDVERB_GET",
 124         "BINDVERB_POST",
 125         "BINDVERB_PUT",
 126         "BINDVERB_CUSTOM"
 127     };
 128
 129     TRACE("\n"
 130             "BINDINFO = {\n"
 131             "    %d, %s,\n"
 132             "    {%d, %p, %p},\n"
 133             "    %s,\n"
 134             "    %s,\n"
 135             "    %s,\n"
 136             "    %d, %08x, %d, %d\n"
 137             "    {%d %p %x},\n"
 138             "    %s\n"
 139             "    %p, %d\n"
 140             "}\n",
 141
 142             bi->cbSize, debugstr_w(bi->szExtraInfo),
 143             bi->stgmedData.tymed, bi->stgmedData.u.hGlobal, bi->stgmedData.pUnkForRelease,
 144             bi->grfBindInfoF > BINDINFOF_URLENCODEDEXTRAINFO
 145                 ? "unknown" : BINDINFOF_str[bi->grfBindInfoF],
 146             bi->dwBindVerb > BINDVERB_CUSTOM
 147                 ? "unknown" : BINDVERB_str[bi->dwBindVerb],
 148             debugstr_w(bi->szCustomVerb),
 149             bi->cbstgmedData, bi->dwOptions, bi->dwOptionsFlags, bi->dwCodePage,
 150             bi->securityAttributes.nLength,
 151             bi->securityAttributes.lpSecurityDescriptor,
 152             bi->securityAttributes.bInheritHandle,
 153             debugstr_guid(&bi->iid),
 154             bi->pUnk, bi->dwReserved
 155             );
 156 }
 157
 158 static void mime_available(Binding *This, LPCWSTR mime)
 159 {
 160     heap_free(This->mime);
 161     This->mime = heap_strdupW(mime);
 162
 163     if(!This->mime || !This->report_mime)
 164         return;
 165
 166     IBindStatusCallback_OnProgress(This->callback, 0, 0, BINDSTATUS_MIMETYPEAVAILABLE, This->mime);
 167
 168     This->clipboard_format = RegisterClipboardFormatW(This->mime);
 169 }
 170
 171 static void stop_binding(Binding *binding, HRESULT hres, LPCWSTR str)
 172 {
 173     if(binding->state & BINDING_LOCKED) {
 174         IInternetProtocolEx_UnlockRequest(&binding->protocol->IInternetProtocolEx_iface);
 175         binding->state &= ~BINDING_LOCKED;
 176     }
 177
 178     if(!(binding->state & BINDING_STOPPED)) {
 179         binding->state |= BINDING_STOPPED;
 180
 181         IBindStatusCallback_OnStopBinding(binding->callback, hres, str);
 182         binding->hres = hres;
 183     }
 184 }
 185
 186 static LPWSTR get_mime_clsid(LPCWSTR mime, CLSID *clsid)
 187 {
 188     LPWSTR key_name, ret;
 189     DWORD res, type, size;
 190     HKEY hkey;
 191     int len;
 192     HRESULT hres;
 193
 194     static const WCHAR mime_keyW[] =
 195         {'M','I','M','E','\\','D','a','t','a','b','a','s','e','\\',
 196          'C','o','n','t','e','n','t',' ','T','y','p','e','\\'};
 197     static const WCHAR clsidW[] = {'C','L','S','I','D',0};
 198
 199     len = strlenW(mime)+1;
 200     key_name = heap_alloc(sizeof(mime_keyW) + len*sizeof(WCHAR));
 201     memcpy(key_name, mime_keyW, sizeof(mime_keyW));
 202     strcpyW(key_name + sizeof(mime_keyW)/sizeof(WCHAR), mime);
 203
 204     res = RegOpenKeyW(HKEY_CLASSES_ROOT, key_name, &hkey);
 205     heap_free(key_name);
 206     if(res != ERROR_SUCCESS) {
 207         WARN("Could not open MIME key: %x\n", res);
 208         return NULL;
 209     }
 210
 211     size = 50*sizeof(WCHAR);
 212     ret = heap_alloc(size);
 213     res = RegQueryValueExW(hkey, clsidW, NULL, &type, (LPBYTE)ret, &size);
 214     RegCloseKey(hkey);
 215     if(res != ERROR_SUCCESS) {
 216         WARN("Could not get CLSID: %08x\n", res);
 217         heap_free(ret);
 218         return NULL;
 219     }
 220
 221     hres = CLSIDFromString(ret, clsid);
 222     if(FAILED(hres)) {
 223         WARN("Could not parse CLSID: %08x\n", hres);
 224         heap_free(ret);
 225         return NULL;
 226     }
 227
 228     return ret;
 229 }
 230
 231 static void load_doc_mon(Binding *binding, IPersistMoniker *persist)
 232 {
 233     IBindCtx *bctx;
 234     HRESULT hres;
 235
 236     hres = CreateAsyncBindCtxEx(binding->bctx, 0, NULL, NULL, &bctx, 0);
 237     if(FAILED(hres)) {
 238         WARN("CreateAsyncBindCtxEx failed: %08x\n", hres);
 239         return;
 240     }
 241
 242     IBindCtx_RevokeObjectParam(bctx, bscb_holderW);
 243     IBindCtx_RegisterObjectParam(bctx, cbinding_contextW, (IUnknown*)&binding->IBinding_iface);
 244
 245     hres = IPersistMoniker_Load(persist, binding->download_state == END_DOWNLOAD, binding->mon, bctx, 0x12);
 246     IBindCtx_RevokeObjectParam(bctx, cbinding_contextW);
 247     IBindCtx_Release(bctx);
 248     if(FAILED(hres))
 249         FIXME("Load failed: %08x\n", hres);
 250 }
 251
 252 static HRESULT create_mime_object(Binding *binding, const CLSID *clsid, LPCWSTR clsid_str)
 253 {
 254     IPersistMoniker *persist;
 255     HRESULT hres;
 256
 257     hres = CoCreateInstance(clsid, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
 258                             &binding->iid, (void**)&binding->obj);
 259     if(FAILED(hres)) {
 260         WARN("CoCreateInstance failed: %08x\n", hres);
 261         return INET_E_CANNOT_INSTANTIATE_OBJECT;
 262     }
 263
 264     binding->state |= BINDING_OBJAVAIL;
 265
 266     hres = IUnknown_QueryInterface(binding->obj, &IID_IPersistMoniker, (void**)&persist);
 267     if(SUCCEEDED(hres)) {
 268         IMonikerProp *prop;
 269
 270         hres = IPersistMoniker_QueryInterface(persist, &IID_IMonikerProp, (void**)&prop);
 271         if(SUCCEEDED(hres)) {
 272             IMonikerProp_PutProperty(prop, MIMETYPEPROP, binding->mime);
 273             IMonikerProp_PutProperty(prop, CLASSIDPROP, clsid_str);
 274             IMonikerProp_Release(prop);
 275         }
 276
 277         load_doc_mon(binding, persist);
 278
 279         IPersistMoniker_Release(persist);
 280     }else {
 281         FIXME("Could not get IPersistMoniker: %08x\n", hres);
 282         /* FIXME: Try query IPersistFile */
 283     }
 284
 285     IBindStatusCallback_OnObjectAvailable(binding->callback, &binding->iid, binding->obj);
 286
 287     return S_OK;
 288 }
 289
 290 static void create_object(Binding *binding)
 291 {
 292     LPWSTR clsid_str;
 293     CLSID clsid;
 294     HRESULT hres;
 295
 296     if(!binding->mime) {
 297         FIXME("MIME not available\n");
 298         return;
 299     }
 300
 301     if(!(clsid_str = get_mime_clsid(binding->mime, &clsid))) {
 302         FIXME("Could not find object for MIME %s\n", debugstr_w(binding->mime));
 303         return;
 304     }
 305
 306     IBindStatusCallback_OnProgress(binding->callback, 0, 0, BINDSTATUS_CLASSIDAVAILABLE, clsid_str);
 307     IBindStatusCallback_OnProgress(binding->callback, 0, 0, BINDSTATUS_BEGINSYNCOPERATION, NULL);
 308
 309     hres = create_mime_object(binding, &clsid, clsid_str);
 310     heap_free(clsid_str);
 311
 312     IBindStatusCallback_OnProgress(binding->callback, 0, 0, BINDSTATUS_ENDSYNCOPERATION, NULL);
 313
 314     stop_binding(binding, hres, NULL);
 315     if(FAILED(hres))
 316         IInternetProtocolEx_Terminate(&binding->protocol->IInternetProtocolEx_iface, 0);
 317 }
 318
 319 static void cache_file_available(Binding *This, const WCHAR *file_name)
 320 {
 321     heap_free(This->stgmed_buf->cache_file);
 322     This->stgmed_buf->cache_file = heap_strdupW(file_name);
 323
 324     if(This->use_cache_file) {
 325         This->stgmed_buf->file = CreateFileW(file_name, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, NULL,
 326                 OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 327         if(This->stgmed_buf->file == INVALID_HANDLE_VALUE)
 328             WARN("CreateFile failed: %u\n", GetLastError());
 329     }
 330 }
 331
 332 static inline stgmed_buf_t *impl_from_IUnknown(IUnknown *iface)
 333 {
 334     return CONTAINING_RECORD(iface, stgmed_buf_t, IUnknown_iface);
 335 }
 336
 337 static HRESULT WINAPI StgMedUnk_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
 338 {
 339     stgmed_buf_t *This = impl_from_IUnknown(iface);
 340
 341     *ppv = NULL;
 342
 343     if(IsEqualGUID(riid, &IID_IUnknown)) {
 344         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 345
 346         *ppv = &This->IUnknown_iface;
 347         IUnknown_AddRef(&This->IUnknown_iface);
 348         return S_OK;
 349     }
 350
 351     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 352     return E_NOINTERFACE;
 353 }
 354
 355 static ULONG WINAPI StgMedUnk_AddRef(IUnknown *iface)
 356 {
 357     stgmed_buf_t *This = impl_from_IUnknown(iface);
 358     LONG ref = InterlockedIncrement(&This->ref);
 359
 360     TRACE("(%p) ref=%d\n", This, ref);
 361
 362     return ref;
 363 }
 364
 365 static ULONG WINAPI StgMedUnk_Release(IUnknown *iface)
 366 {
 367     stgmed_buf_t *This = impl_from_IUnknown(iface);
 368     LONG ref = InterlockedDecrement(&This->ref);
 369
 370     TRACE("(%p) ref=%d\n", This, ref);
 371
 372     if(!ref) {
 373         if(This->file != INVALID_HANDLE_VALUE)
 374             CloseHandle(This->file);
 375         IInternetProtocol_Release(This->protocol);
 376         heap_free(This->cache_file);
 377         heap_free(This);
 378
 379         URLMON_UnlockModule();
 380     }
 381
 382     return ref;
 383 }
 384
 385 static const IUnknownVtbl StgMedUnkVtbl = {
 386     StgMedUnk_QueryInterface,
 387     StgMedUnk_AddRef,
 388     StgMedUnk_Release
 389 };
 390
 391 static stgmed_buf_t *create_stgmed_buf(IInternetProtocolEx *protocol)
 392 {
 393     stgmed_buf_t *ret = heap_alloc(sizeof(*ret));
 394
 395     ret->IUnknown_iface.lpVtbl = &StgMedUnkVtbl;
 396     ret->ref = 1;
 397     ret->file = INVALID_HANDLE_VALUE;
 398     ret->hres = S_OK;
 399     ret->cache_file = NULL;
 400
 401     IInternetProtocol_AddRef(protocol);
 402     ret->protocol = protocol;
 403
 404     URLMON_LockModule();
 405
 406     return ret;
 407 }
 408
 409 typedef struct {
 410     stgmed_obj_t stgmed_obj;
 411     IStream IStream_iface;
 412
 413     LONG ref;
 414
 415     stgmed_buf_t *buf;
 416 } ProtocolStream;
 417
 418 static inline ProtocolStream *impl_from_IStream(IStream *iface)
 419 {
 420     return CONTAINING_RECORD(iface, ProtocolStream, IStream_iface);
 421 }
 422
 423 static HRESULT WINAPI ProtocolStream_QueryInterface(IStream *iface,
 424                                                           REFIID riid, void **ppv)
 425 {
 426     ProtocolStream *This = impl_from_IStream(iface);
 427
 428     *ppv = NULL;
 429
 430     if(IsEqualGUID(&IID_IUnknown, riid)) {
 431         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 432         *ppv = &This->IStream_iface;
 433     }else if(IsEqualGUID(&IID_ISequentialStream, riid)) {
 434         TRACE("(%p)->(IID_ISequentialStream %p)\n", This, ppv);
 435         *ppv = &This->IStream_iface;
 436     }else if(IsEqualGUID(&IID_IStream, riid)) {
 437         TRACE("(%p)->(IID_IStream %p)\n", This, ppv);
 438         *ppv = &This->IStream_iface;
 439     }
 440
 441     if(*ppv) {
 442         IStream_AddRef(&This->IStream_iface);
 443         return S_OK;
 444     }
 445
 446     WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 447     return E_NOINTERFACE;
 448 }
 449
 450 static ULONG WINAPI ProtocolStream_AddRef(IStream *iface)
 451 {
 452     ProtocolStream *This = impl_from_IStream(iface);
 453     LONG ref = InterlockedIncrement(&This->ref);
 454
 455     TRACE("(%p) ref=%d\n", This, ref);
 456
 457     return ref;
 458 }
 459
 460 static ULONG WINAPI ProtocolStream_Release(IStream *iface)
 461 {
 462     ProtocolStream *This = impl_from_IStream(iface);
 463     LONG ref = InterlockedDecrement(&This->ref);
 464
 465     TRACE("(%p) ref=%d\n", This, ref);
 466
 467     if(!ref) {
 468         IUnknown_Release(&This->buf->IUnknown_iface);
 469         heap_free(This);
 470
 471         URLMON_UnlockModule();
 472     }
 473
 474     return ref;
 475 }
 476
 477 static HRESULT WINAPI ProtocolStream_Read(IStream *iface, void *pv,
 478                                           ULONG cb, ULONG *pcbRead)
 479 {
 480     ProtocolStream *This = impl_from_IStream(iface);
 481     DWORD read = 0;
 482     HRESULT hres;
 483
 484     TRACE("(%p)->(%p %d %p)\n", This, pv, cb, pcbRead);
 485
 486     if(This->buf->file == INVALID_HANDLE_VALUE) {
 487         hres = This->buf->hres = IInternetProtocol_Read(This->buf->protocol, (PBYTE)pv, cb, &read);
 488     }else {
 489         hres = ReadFile(This->buf->file, pv, cb, &read, NULL) ? S_OK : INET_E_DOWNLOAD_FAILURE;
 490     }
 491
 492     if (pcbRead)
 493         *pcbRead = read;
 494
 495     if(hres == E_PENDING)
 496         return E_PENDING;
 497     else if(FAILED(hres))
 498         FIXME("Read failed: %08x\n", hres);
 499
 500     return read ? S_OK : S_FALSE;
 501 }
 502
 503 static HRESULT WINAPI ProtocolStream_Write(IStream *iface, const void *pv,
 504                                           ULONG cb, ULONG *pcbWritten)
 505 {
 506     ProtocolStream *This = impl_from_IStream(iface);
 507
 508     TRACE("(%p)->(%p %d %p)\n", This, pv, cb, pcbWritten);
 509
 510     return STG_E_ACCESSDENIED;
 511 }
 512
 513 static HRESULT WINAPI ProtocolStream_Seek(IStream *iface, LARGE_INTEGER dlibMove,
 514                                          DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
 515 {
 516     ProtocolStream *This = impl_from_IStream(iface);
 517     FIXME("(%p)->(%d %08x %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
 518     return E_NOTIMPL;
 519 }
 520
 521 static HRESULT WINAPI ProtocolStream_SetSize(IStream *iface, ULARGE_INTEGER libNewSize)
 522 {
 523     ProtocolStream *This = impl_from_IStream(iface);
 524     FIXME("(%p)->(%d)\n", This, libNewSize.u.LowPart);
 525     return E_NOTIMPL;
 526 }
 527
 528 static HRESULT WINAPI ProtocolStream_CopyTo(IStream *iface, IStream *pstm,
 529         ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
 530 {
 531     ProtocolStream *This = impl_from_IStream(iface);
 532     FIXME("(%p)->(%p %d %p %p)\n", This, pstm, cb.u.LowPart, pcbRead, pcbWritten);
 533     return E_NOTIMPL;
 534 }
 535
 536 static HRESULT WINAPI ProtocolStream_Commit(IStream *iface, DWORD grfCommitFlags)
 537 {
 538     ProtocolStream *This = impl_from_IStream(iface);
 539
 540     TRACE("(%p)->(%08x)\n", This, grfCommitFlags);
 541
 542     return E_NOTIMPL;
 543 }
 544
 545 static HRESULT WINAPI ProtocolStream_Revert(IStream *iface)
 546 {
 547     ProtocolStream *This = impl_from_IStream(iface);
 548
 549     TRACE("(%p)\n", This);
 550
 551     return E_NOTIMPL;
 552 }
 553
 554 static HRESULT WINAPI ProtocolStream_LockRegion(IStream *iface, ULARGE_INTEGER libOffset,
 555                                                ULARGE_INTEGER cb, DWORD dwLockType)
 556 {
 557     ProtocolStream *This = impl_from_IStream(iface);
 558     FIXME("(%p)->(%d %d %d)\n", This, libOffset.u.LowPart, cb.u.LowPart, dwLockType);
 559     return E_NOTIMPL;
 560 }
 561
 562 static HRESULT WINAPI ProtocolStream_UnlockRegion(IStream *iface,
 563         ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
 564 {
 565     ProtocolStream *This = impl_from_IStream(iface);
 566     FIXME("(%p)->(%d %d %d)\n", This, libOffset.u.LowPart, cb.u.LowPart, dwLockType);
 567     return E_NOTIMPL;
 568 }
 569
 570 static HRESULT WINAPI ProtocolStream_Stat(IStream *iface, STATSTG *pstatstg,
 571                                          DWORD dwStatFlag)
 572 {
 573     ProtocolStream *This = impl_from_IStream(iface);
 574     TRACE("(%p)->(%p %08x)\n", This, pstatstg, dwStatFlag);
 575
 576     if(!pstatstg)
 577         return E_FAIL;
 578
 579     memset(pstatstg, 0, sizeof(STATSTG));
 580
 581     if(!(dwStatFlag&STATFLAG_NONAME) && This->buf->cache_file) {
 582         pstatstg->pwcsName = CoTaskMemAlloc((lstrlenW(This->buf->cache_file)+1)*sizeof(WCHAR));
 583         if(!pstatstg->pwcsName)
 584             return STG_E_INSUFFICIENTMEMORY;
 585
 586         lstrcpyW(pstatstg->pwcsName, This->buf->cache_file);
 587     }
 588
 589     pstatstg->type = STGTY_STREAM;
 590     if(This->buf->file != INVALID_HANDLE_VALUE) {
 591         GetFileSizeEx(This->buf->file, (PLARGE_INTEGER)&pstatstg->cbSize);
 592         GetFileTime(This->buf->file, &pstatstg->ctime, &pstatstg->atime, &pstatstg->mtime);
 593         if(pstatstg->cbSize.QuadPart)
 594             pstatstg->grfMode = GENERIC_READ;
 595     }
 596
 597     return S_OK;
 598 }
 599
 600 static HRESULT WINAPI ProtocolStream_Clone(IStream *iface, IStream **ppstm)
 601 {
 602     ProtocolStream *This = impl_from_IStream(iface);
 603     FIXME("(%p)->(%p)\n", This, ppstm);
 604     return E_NOTIMPL;
 605 }
 606
 607 static const IStreamVtbl ProtocolStreamVtbl = {
 608     ProtocolStream_QueryInterface,
 609     ProtocolStream_AddRef,
 610     ProtocolStream_Release,
 611     ProtocolStream_Read,
 612     ProtocolStream_Write,
 613     ProtocolStream_Seek,
 614     ProtocolStream_SetSize,
 615     ProtocolStream_CopyTo,
 616     ProtocolStream_Commit,
 617     ProtocolStream_Revert,
 618     ProtocolStream_LockRegion,
 619     ProtocolStream_UnlockRegion,
 620     ProtocolStream_Stat,
 621     ProtocolStream_Clone
 622 };
 623
 624 static void stgmed_stream_release(stgmed_obj_t *obj)
 625 {
 626     ProtocolStream *stream = (ProtocolStream*)obj;
 627     IStream_Release(&stream->IStream_iface);
 628 }
 629
 630 static HRESULT stgmed_stream_fill_stgmed(stgmed_obj_t *obj, STGMEDIUM *stgmed)
 631 {
 632     ProtocolStream *stream = (ProtocolStream*)obj;
 633
 634     stgmed->tymed = TYMED_ISTREAM;
 635     stgmed->u.pstm = &stream->IStream_iface;
 636     stgmed->pUnkForRelease = &stream->buf->IUnknown_iface;
 637
 638     return S_OK;
 639 }
 640
 641 static HRESULT stgmed_stream_get_result(stgmed_obj_t *obj, DWORD bindf, void **result)
 642 {
 643     ProtocolStream *stream = (ProtocolStream*)obj;
 644
 645     if(!(bindf & BINDF_ASYNCHRONOUS) && stream->buf->file == INVALID_HANDLE_VALUE
 646        && stream->buf->hres != S_FALSE)
 647         return INET_E_DATA_NOT_AVAILABLE;
 648
 649     IStream_AddRef(&stream->IStream_iface);
 650     *result = &stream->IStream_iface;
 651     return S_OK;
 652 }
 653
 654 static const stgmed_obj_vtbl stgmed_stream_vtbl = {
 655     stgmed_stream_release,
 656     stgmed_stream_fill_stgmed,
 657     stgmed_stream_get_result
 658 };
 659
 660 typedef struct {
 661     stgmed_obj_t stgmed_obj;
 662     stgmed_buf_t *buf;
 663 } stgmed_file_obj_t;
 664
 665 static stgmed_obj_t *create_stgmed_stream(stgmed_buf_t *buf)
 666 {
 667     ProtocolStream *ret = heap_alloc(sizeof(ProtocolStream));
 668
 669     ret->stgmed_obj.vtbl = &stgmed_stream_vtbl;
 670     ret->IStream_iface.lpVtbl = &ProtocolStreamVtbl;
 671     ret->ref = 1;
 672
 673     IUnknown_AddRef(&buf->IUnknown_iface);
 674     ret->buf = buf;
 675
 676     URLMON_LockModule();
 677
 678     return &ret->stgmed_obj;
 679 }
 680
 681 static void stgmed_file_release(stgmed_obj_t *obj)
 682 {
 683     stgmed_file_obj_t *file_obj = (stgmed_file_obj_t*)obj;
 684
 685     IUnknown_Release(&file_obj->buf->IUnknown_iface);
 686     heap_free(file_obj);
 687 }
 688
 689 static HRESULT stgmed_file_fill_stgmed(stgmed_obj_t *obj, STGMEDIUM *stgmed)
 690 {
 691     stgmed_file_obj_t *file_obj = (stgmed_file_obj_t*)obj;
 692
 693     if(!file_obj->buf->cache_file) {
 694         WARN("cache_file not set\n");
 695         return INET_E_DATA_NOT_AVAILABLE;
 696     }
 697
 698     read_protocol_data(file_obj->buf);
 699
 700     stgmed->tymed = TYMED_FILE;
 701     stgmed->u.lpszFileName = file_obj->buf->cache_file;
 702     stgmed->pUnkForRelease = &file_obj->buf->IUnknown_iface;
 703
 704     return S_OK;
 705 }
 706
 707 static HRESULT stgmed_file_get_result(stgmed_obj_t *obj, DWORD bindf, void **result)
 708 {
 709     return bindf & BINDF_ASYNCHRONOUS ? MK_S_ASYNCHRONOUS : S_OK;
 710 }
 711
 712 static const stgmed_obj_vtbl stgmed_file_vtbl = {
 713     stgmed_file_release,
 714     stgmed_file_fill_stgmed,
 715     stgmed_file_get_result
 716 };
 717
 718 static stgmed_obj_t *create_stgmed_file(stgmed_buf_t *buf)
 719 {
 720     stgmed_file_obj_t *ret = heap_alloc(sizeof(*ret));
 721
 722     ret->stgmed_obj.vtbl = &stgmed_file_vtbl;
 723
 724     IUnknown_AddRef(&buf->IUnknown_iface);
 725     ret->buf = buf;
 726
 727     return &ret->stgmed_obj;
 728 }
 729
 730 static inline Binding *impl_from_IBinding(IBinding *iface)
 731 {
 732     return CONTAINING_RECORD(iface, Binding, IBinding_iface);
 733 }
 734
 735 static HRESULT WINAPI Binding_QueryInterface(IBinding *iface, REFIID riid, void **ppv)
 736 {
 737     Binding *This = impl_from_IBinding(iface);
 738
 739     *ppv = NULL;
 740
 741     if(IsEqualGUID(&IID_IUnknown, riid)) {
 742         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 743         *ppv = &This->IBinding_iface;
 744     }else if(IsEqualGUID(&IID_IBinding, riid)) {
 745         TRACE("(%p)->(IID_IBinding %p)\n", This, ppv);
 746         *ppv = &This->IBinding_iface;
 747     }else if(IsEqualGUID(&IID_IInternetProtocolSink, riid)) {
 748         TRACE("(%p)->(IID_IInternetProtocolSink %p)\n", This, ppv);
 749         *ppv = &This->IInternetProtocolSink_iface;
 750     }else if(IsEqualGUID(&IID_IInternetBindInfo, riid)) {
 751         TRACE("(%p)->(IID_IInternetBindInfo %p)\n", This, ppv);
 752         *ppv = &This->IInternetBindInfo_iface;
 753     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
 754         TRACE("(%p)->(IID_IServiceProvider %p)\n", This, ppv);
 755         *ppv = &This->IServiceProvider_iface;
 756     }else if(IsEqualGUID(&IID_IWinInetInfo, riid)) {
 757         TRACE("(%p)->(IID_IWinInetInfo %p)\n", This, ppv);
 758
 759         /* NOTE: This violidates COM rules, but tests prove that we should do it */
 760         if(!This->protocol->wininet_info)
 761            return E_NOINTERFACE;
 762
 763         *ppv = &This->IWinInetHttpInfo_iface;
 764     }else if(IsEqualGUID(&IID_IWinInetHttpInfo, riid)) {
 765         IWinInetHttpInfo *http_info;
 766         HRESULT hres;
 767
 768         TRACE("(%p)->(IID_IWinInetHttpInfo %p)\n", This, ppv);
 769
 770         if(!This->protocol->wininet_info)
 771             return E_NOINTERFACE;
 772
 773         hres = IWinInetInfo_QueryInterface(This->protocol->wininet_info, &IID_IWinInetHttpInfo, (void**)&http_info);
 774         if(FAILED(hres))
 775             return E_NOINTERFACE;
 776
 777         IWinInetHttpInfo_Release(http_info);
 778         *ppv = &This->IWinInetHttpInfo_iface;
 779     }
 780
 781     if(*ppv) {
 782         IBinding_AddRef(&This->IBinding_iface);
 783         return S_OK;
 784     }
 785
 786     WARN("Unsupported interface %s\n", debugstr_guid(riid));
 787     return E_NOINTERFACE;
 788 }
 789
 790 static ULONG WINAPI Binding_AddRef(IBinding *iface)
 791 {
 792     Binding *This = impl_from_IBinding(iface);
 793     LONG ref = InterlockedIncrement(&This->ref);
 794
 795     TRACE("(%p) ref=%d\n", This, ref);
 796
 797     return ref;
 798 }
 799
 800 static ULONG WINAPI Binding_Release(IBinding *iface)
 801 {
 802     Binding *This = impl_from_IBinding(iface);
 803     LONG ref = InterlockedDecrement(&This->ref);
 804
 805     TRACE("(%p) ref=%d\n", This, ref);
 806
 807     if(!ref) {
 808         if(This->notif_hwnd)
 809             release_notif_hwnd(This->notif_hwnd);
 810         if(This->mon)
 811             IMoniker_Release(This->mon);
 812         if(This->callback)
 813             IBindStatusCallback_Release(This->callback);
 814         if(This->protocol)
 815             IInternetProtocolEx_Release(&This->protocol->IInternetProtocolEx_iface);
 816         if(This->service_provider)
 817             IServiceProvider_Release(This->service_provider);
 818         if(This->stgmed_buf)
 819             IUnknown_Release(&This->stgmed_buf->IUnknown_iface);
 820         if(This->stgmed_obj)
 821             This->stgmed_obj->vtbl->release(This->stgmed_obj);
 822         if(This->obj)
 823             IUnknown_Release(This->obj);
 824         if(This->bctx)
 825             IBindCtx_Release(This->bctx);
 826
 827         ReleaseBindInfo(&This->bindinfo);
 828         This->section.DebugInfo->Spare[0] = 0;
 829         DeleteCriticalSection(&This->section);
 830         SysFreeString(This->url);
 831         heap_free(This->mime);
 832         heap_free(This->redirect_url);
 833         heap_free(This);
 834
 835         URLMON_UnlockModule();
 836     }
 837
 838     return ref;
 839 }
 840
 841 static HRESULT WINAPI Binding_Abort(IBinding *iface)
 842 {
 843     Binding *This = impl_from_IBinding(iface);
 844     HRESULT hres;
 845
 846     TRACE("(%p)\n", This);
 847
 848     if(This->state & BINDING_ABORTED)
 849         return E_FAIL;
 850
 851     hres = IInternetProtocolEx_Abort(&This->protocol->IInternetProtocolEx_iface, E_ABORT,
 852             ERROR_SUCCESS);
 853     if(FAILED(hres))
 854         return hres;
 855
 856     This->state |= BINDING_ABORTED;
 857     return S_OK;
 858 }
 859
 860 static HRESULT WINAPI Binding_Suspend(IBinding *iface)
 861 {
 862     Binding *This = impl_from_IBinding(iface);
 863     FIXME("(%p)\n", This);
 864     return E_NOTIMPL;
 865 }
 866
 867 static HRESULT WINAPI Binding_Resume(IBinding *iface)
 868 {
 869     Binding *This = impl_from_IBinding(iface);
 870     FIXME("(%p)\n", This);
 871     return E_NOTIMPL;
 872 }
 873
 874 static HRESULT WINAPI Binding_SetPriority(IBinding *iface, LONG nPriority)
 875 {
 876     Binding *This = impl_from_IBinding(iface);
 877     FIXME("(%p)->(%d)\n", This, nPriority);
 878     return E_NOTIMPL;
 879 }
 880
 881 static HRESULT WINAPI Binding_GetPriority(IBinding *iface, LONG *pnPriority)
 882 {
 883     Binding *This = impl_from_IBinding(iface);
 884     FIXME("(%p)->(%p)\n", This, pnPriority);
 885     return E_NOTIMPL;
 886 }
 887
 888 static HRESULT WINAPI Binding_GetBindResult(IBinding *iface, CLSID *pclsidProtocol,
 889         DWORD *pdwResult, LPOLESTR *pszResult, DWORD *pdwReserved)
 890 {
 891     Binding *This = impl_from_IBinding(iface);
 892     FIXME("(%p)->(%p %p %p %p)\n", This, pclsidProtocol, pdwResult, pszResult, pdwReserved);
 893     return E_NOTIMPL;
 894 }
 895
 896 static const IBindingVtbl BindingVtbl = {
 897     Binding_QueryInterface,
 898     Binding_AddRef,
 899     Binding_Release,
 900     Binding_Abort,
 901     Binding_Suspend,
 902     Binding_Resume,
 903     Binding_SetPriority,
 904     Binding_GetPriority,
 905     Binding_GetBindResult
 906 };
 907
 908 static Binding *get_bctx_binding(IBindCtx *bctx)
 909 {
 910     IBinding *binding;
 911     IUnknown *unk;
 912     HRESULT hres;
 913
 914     hres = IBindCtx_GetObjectParam(bctx, cbinding_contextW, &unk);
 915     if(FAILED(hres))
 916         return NULL;
 917
 918     hres = IUnknown_QueryInterface(unk, &IID_IBinding, (void*)&binding);
 919     IUnknown_Release(unk);
 920     if(FAILED(hres))
 921         return NULL;
 922
 923     if (binding->lpVtbl != &BindingVtbl)
 924         return NULL;
 925     return impl_from_IBinding(binding);
 926 }
 927
 928 static inline Binding *impl_from_IInternetProtocolSink(IInternetProtocolSink *iface)
 929 {
 930     return CONTAINING_RECORD(iface, Binding, IInternetProtocolSink_iface);
 931 }
 932
 933 static HRESULT WINAPI InternetProtocolSink_QueryInterface(IInternetProtocolSink *iface,
 934         REFIID riid, void **ppv)
 935 {
 936     Binding *This = impl_from_IInternetProtocolSink(iface);
 937     return IBinding_QueryInterface(&This->IBinding_iface, riid, ppv);
 938 }
 939
 940 static ULONG WINAPI InternetProtocolSink_AddRef(IInternetProtocolSink *iface)
 941 {
 942     Binding *This = impl_from_IInternetProtocolSink(iface);
 943     return IBinding_AddRef(&This->IBinding_iface);
 944 }
 945
 946 static ULONG WINAPI InternetProtocolSink_Release(IInternetProtocolSink *iface)
 947 {
 948     Binding *This = impl_from_IInternetProtocolSink(iface);
 949     return IBinding_Release(&This->IBinding_iface);
 950 }
 951
 952 static HRESULT WINAPI InternetProtocolSink_Switch(IInternetProtocolSink *iface,
 953         PROTOCOLDATA *pProtocolData)
 954 {
 955     Binding *This = impl_from_IInternetProtocolSink(iface);
 956
 957     WARN("(%p)->(%p)\n", This, pProtocolData);
 958
 959     return E_FAIL;
 960 }
 961
 962 static void on_progress(Binding *This, ULONG progress, ULONG progress_max,
 963                         ULONG status_code, LPCWSTR status_text)
 964 {
 965     IBindStatusCallback_OnProgress(This->callback, progress, progress_max,
 966             status_code, status_text);
 967 }
 968
 969 static HRESULT WINAPI InternetProtocolSink_ReportProgress(IInternetProtocolSink *iface,
 970         ULONG ulStatusCode, LPCWSTR szStatusText)
 971 {
 972     Binding *This = impl_from_IInternetProtocolSink(iface);
 973
 974     TRACE("(%p)->(%u %s)\n", This, ulStatusCode, debugstr_w(szStatusText));
 975
 976     switch(ulStatusCode) {
 977     case BINDSTATUS_FINDINGRESOURCE:
 978         on_progress(This, 0, 0, BINDSTATUS_FINDINGRESOURCE, szStatusText);
 979         break;
 980     case BINDSTATUS_CONNECTING:
 981         on_progress(This, 0, 0, BINDSTATUS_CONNECTING, szStatusText);
 982         break;
 983     case BINDSTATUS_REDIRECTING:
 984         heap_free(This->redirect_url);
 985         This->redirect_url = heap_strdupW(szStatusText);
 986         on_progress(This, 0, 0, BINDSTATUS_REDIRECTING, szStatusText);
 987         break;
 988     case BINDSTATUS_BEGINDOWNLOADDATA:
 989         break;
 990     case BINDSTATUS_SENDINGREQUEST:
 991         on_progress(This, 0, 0, BINDSTATUS_SENDINGREQUEST, szStatusText);
 992         break;
 993     case BINDSTATUS_PROTOCOLCLASSID:
 994         break;
 995     case BINDSTATUS_MIMETYPEAVAILABLE:
 996     case BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE:
 997         mime_available(This, szStatusText);
 998         break;
 999     case BINDSTATUS_CACHEFILENAMEAVAILABLE:
1000         cache_file_available(This, szStatusText);
1001         break;
1002     case BINDSTATUS_DECODING:
1003         IBindStatusCallback_OnProgress(This->callback, 0, 0, BINDSTATUS_DECODING, szStatusText);
1004         break;
1005     case BINDSTATUS_LOADINGMIMEHANDLER:
1006         on_progress(This, 0, 0, BINDSTATUS_LOADINGMIMEHANDLER, szStatusText);
1007         break;
1008     case BINDSTATUS_DIRECTBIND: /* FIXME: Handle BINDSTATUS_DIRECTBIND in BindProtocol */
1009         This->report_mime = FALSE;
1010         break;
1011     case BINDSTATUS_ACCEPTRANGES:
1012         break;
1013     default:
1014         FIXME("Unhandled status code %d\n", ulStatusCode);
1015         return E_NOTIMPL;
1016     };
1017
1018     return S_OK;
1019 }
1020
1021 static void report_data(Binding *This, DWORD bscf, ULONG progress, ULONG progress_max)
1022 {
1023     FORMATETC formatetc = {0, NULL, 1, -1, TYMED_ISTREAM};
1024     BOOL sent_begindownloaddata = FALSE;
1025
1026     TRACE("(%p)->(%d %u %u)\n", This, bscf, progress, progress_max);
1027
1028     if(This->download_state == END_DOWNLOAD || (This->state & BINDING_ABORTED)) {
1029         read_protocol_data(This->stgmed_buf);
1030         return;
1031     }
1032
1033     if(This->state & BINDING_STOPPED)
1034         return;
1035
1036     if(This->stgmed_buf->file != INVALID_HANDLE_VALUE)
1037         read_protocol_data(This->stgmed_buf);
1038
1039     if(This->download_state == BEFORE_DOWNLOAD) {
1040         This->download_state = DOWNLOADING;
1041         sent_begindownloaddata = TRUE;
1042         IBindStatusCallback_OnProgress(This->callback, progress, progress_max,
1043                 BINDSTATUS_BEGINDOWNLOADDATA, This->url);
1044
1045         if(This->stgmed_buf->cache_file)
1046             IBindStatusCallback_OnProgress(This->callback, progress, progress_max,
1047                     BINDSTATUS_CACHEFILENAMEAVAILABLE, This->stgmed_buf->cache_file);
1048     }
1049
1050     if(This->stgmed_buf->hres == S_FALSE || (bscf & BSCF_LASTDATANOTIFICATION)) {
1051         This->download_state = END_DOWNLOAD;
1052         IBindStatusCallback_OnProgress(This->callback, progress, progress_max,
1053                 BINDSTATUS_ENDDOWNLOADDATA, This->url);
1054     }else if(!sent_begindownloaddata) {
1055         IBindStatusCallback_OnProgress(This->callback, progress, progress_max,
1056                 BINDSTATUS_DOWNLOADINGDATA, This->url);
1057     }
1058
1059     if(This->state & (BINDING_STOPPED|BINDING_ABORTED))
1060         return;
1061
1062     if(This->to_object) {
1063         if(!(This->state & BINDING_OBJAVAIL)) {
1064             IBinding_AddRef(&This->IBinding_iface);
1065             create_object(This);
1066             IBinding_Release(&This->IBinding_iface);
1067         }
1068     }else {
1069         STGMEDIUM stgmed;
1070         HRESULT hres;
1071
1072         if(!(This->state & BINDING_LOCKED)) {
1073             HRESULT hres = IInternetProtocolEx_LockRequest(
1074                     &This->protocol->IInternetProtocolEx_iface, 0);
1075             if(SUCCEEDED(hres))
1076                 This->state |= BINDING_LOCKED;
1077         }
1078
1079         hres = This->stgmed_obj->vtbl->fill_stgmed(This->stgmed_obj, &stgmed);
1080         if(FAILED(hres)) {
1081             stop_binding(This, hres, NULL);
1082             return;
1083         }
1084
1085         formatetc.tymed = stgmed.tymed;
1086         formatetc.cfFormat = This->clipboard_format;
1087
1088         IBindStatusCallback_OnDataAvailable(This->callback, bscf, progress,
1089                 &formatetc, &stgmed);
1090
1091         if(This->download_state == END_DOWNLOAD)
1092             stop_binding(This, S_OK, NULL);
1093     }
1094 }
1095
1096 static HRESULT WINAPI InternetProtocolSink_ReportData(IInternetProtocolSink *iface,
1097         DWORD grfBSCF, ULONG ulProgress, ULONG ulProgressMax)
1098 {
1099     Binding *This = impl_from_IInternetProtocolSink(iface);
1100
1101     TRACE("(%p)->(%d %u %u)\n", This, grfBSCF, ulProgress, ulProgressMax);
1102
1103     report_data(This, grfBSCF, ulProgress, ulProgressMax);
1104     return S_OK;
1105 }
1106
1107 static HRESULT WINAPI InternetProtocolSink_ReportResult(IInternetProtocolSink *iface,
1108         HRESULT hrResult, DWORD dwError, LPCWSTR szResult)
1109 {
1110     Binding *This = impl_from_IInternetProtocolSink(iface);
1111
1112     TRACE("(%p)->(%08x %d %s)\n", This, hrResult, dwError, debugstr_w(szResult));
1113
1114     stop_binding(This, hrResult, szResult);
1115     IInternetProtocolEx_Terminate(&This->protocol->IInternetProtocolEx_iface, 0);
1116     return S_OK;
1117 }
1118
1119 static const IInternetProtocolSinkVtbl InternetProtocolSinkVtbl = {
1120     InternetProtocolSink_QueryInterface,
1121     InternetProtocolSink_AddRef,
1122     InternetProtocolSink_Release,
1123     InternetProtocolSink_Switch,
1124     InternetProtocolSink_ReportProgress,
1125     InternetProtocolSink_ReportData,
1126     InternetProtocolSink_ReportResult
1127 };
1128
1129 static inline Binding *impl_from_IInternetBindInfo(IInternetBindInfo *iface)
1130 {
1131     return CONTAINING_RECORD(iface, Binding, IInternetBindInfo_iface);
1132 }
1133
1134 static HRESULT WINAPI InternetBindInfo_QueryInterface(IInternetBindInfo *iface,
1135         REFIID riid, void **ppv)
1136 {
1137     Binding *This = impl_from_IInternetBindInfo(iface);
1138     return IBinding_QueryInterface(&This->IBinding_iface, riid, ppv);
1139 }
1140
1141 static ULONG WINAPI InternetBindInfo_AddRef(IInternetBindInfo *iface)
1142 {
1143     Binding *This = impl_from_IInternetBindInfo(iface);
1144     return IBinding_AddRef(&This->IBinding_iface);
1145 }
1146
1147 static ULONG WINAPI InternetBindInfo_Release(IInternetBindInfo *iface)
1148 {
1149     Binding *This = impl_from_IInternetBindInfo(iface);
1150     return IBinding_Release(&This->IBinding_iface);
1151 }
1152
1153 static HRESULT WINAPI InternetBindInfo_GetBindInfo(IInternetBindInfo *iface,
1154         DWORD *grfBINDF, BINDINFO *pbindinfo)
1155 {
1156     Binding *This = impl_from_IInternetBindInfo(iface);
1157
1158     TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
1159
1160     *grfBINDF = This->bindf;
1161
1162     *pbindinfo = This->bindinfo;
1163
1164     if(pbindinfo->szExtraInfo || pbindinfo->szCustomVerb)
1165         FIXME("copy strings\n");
1166
1167     if(pbindinfo->stgmedData.pUnkForRelease)
1168         IUnknown_AddRef(pbindinfo->stgmedData.pUnkForRelease);
1169
1170     if(pbindinfo->pUnk)
1171         IUnknown_AddRef(pbindinfo->pUnk);
1172
1173     return S_OK;
1174 }
1175
1176 static HRESULT WINAPI InternetBindInfo_GetBindString(IInternetBindInfo *iface,
1177         ULONG ulStringType, LPOLESTR *ppwzStr, ULONG cEl, ULONG *pcElFetched)
1178 {
1179     Binding *This = impl_from_IInternetBindInfo(iface);
1180
1181     TRACE("(%p)->(%d %p %d %p)\n", This, ulStringType, ppwzStr, cEl, pcElFetched);
1182
1183     switch(ulStringType) {
1184     case BINDSTRING_ACCEPT_MIMES: {
1185         static const WCHAR wszMimes[] = {'*','/','*',0};
1186
1187         if(!ppwzStr || !pcElFetched)
1188             return E_INVALIDARG;
1189
1190         ppwzStr[0] = CoTaskMemAlloc(sizeof(wszMimes));
1191         memcpy(ppwzStr[0], wszMimes, sizeof(wszMimes));
1192         *pcElFetched = 1;
1193         return S_OK;
1194     }
1195     case BINDSTRING_USER_AGENT: {
1196         IInternetBindInfo *bindinfo = NULL;
1197         HRESULT hres;
1198
1199         hres = IBindStatusCallback_QueryInterface(This->callback, &IID_IInternetBindInfo,
1200                                                   (void**)&bindinfo);
1201         if(FAILED(hres))
1202             return hres;
1203
1204         hres = IInternetBindInfo_GetBindString(bindinfo, ulStringType, ppwzStr,
1205                                                cEl, pcElFetched);
1206         IInternetBindInfo_Release(bindinfo);
1207
1208         return hres;
1209     }
1210     case BINDSTRING_URL: {
1211         DWORD size = (SysStringLen(This->url)+1) * sizeof(WCHAR);
1212
1213         if(!ppwzStr || !pcElFetched)
1214             return E_INVALIDARG;
1215
1216         *ppwzStr = CoTaskMemAlloc(size);
1217         memcpy(*ppwzStr, This->url, size);
1218         *pcElFetched = 1;
1219         return S_OK;
1220     }
1221     }
1222
1223     FIXME("not supported string type %d\n", ulStringType);
1224     return E_NOTIMPL;
1225 }
1226
1227 static const IInternetBindInfoVtbl InternetBindInfoVtbl = {
1228     InternetBindInfo_QueryInterface,
1229     InternetBindInfo_AddRef,
1230     InternetBindInfo_Release,
1231     InternetBindInfo_GetBindInfo,
1232     InternetBindInfo_GetBindString
1233 };
1234
1235 static inline Binding *impl_from_IWinInetHttpInfo(IWinInetHttpInfo *iface)
1236 {
1237     return CONTAINING_RECORD(iface, Binding, IWinInetHttpInfo_iface);
1238 }
1239
1240 static HRESULT WINAPI WinInetHttpInfo_QueryInterface(IWinInetHttpInfo *iface, REFIID riid, void **ppv)
1241 {
1242     Binding *This = impl_from_IWinInetHttpInfo(iface);
1243     return IBinding_QueryInterface(&This->IBinding_iface, riid, ppv);
1244 }
1245
1246 static ULONG WINAPI WinInetHttpInfo_AddRef(IWinInetHttpInfo *iface)
1247 {
1248     Binding *This = impl_from_IWinInetHttpInfo(iface);
1249     return IBinding_AddRef(&This->IBinding_iface);
1250 }
1251
1252 static ULONG WINAPI WinInetHttpInfo_Release(IWinInetHttpInfo *iface)
1253 {
1254     Binding *This = impl_from_IWinInetHttpInfo(iface);
1255     return IBinding_Release(&This->IBinding_iface);
1256 }
1257
1258 static HRESULT WINAPI WinInetHttpInfo_QueryOption(IWinInetHttpInfo *iface, DWORD dwOption,
1259         void *pBuffer, DWORD *pcbBuffer)
1260 {
1261     Binding *This = impl_from_IWinInetHttpInfo(iface);
1262     FIXME("(%p)->(%x %p %p)\n", This, dwOption, pBuffer, pcbBuffer);
1263     return E_NOTIMPL;
1264 }
1265
1266 static HRESULT WINAPI WinInetHttpInfo_QueryInfo(IWinInetHttpInfo *iface, DWORD dwOption,
1267         void *pBuffer, DWORD *pcbBuffer, DWORD *pdwFlags, DWORD *pdwReserved)
1268 {
1269     Binding *This = impl_from_IWinInetHttpInfo(iface);
1270     FIXME("(%p)->(%x %p %p %p %p)\n", This, dwOption, pBuffer, pcbBuffer, pdwFlags, pdwReserved);
1271     return E_NOTIMPL;
1272 }
1273
1274 static const IWinInetHttpInfoVtbl WinInetHttpInfoVtbl = {
1275     WinInetHttpInfo_QueryInterface,
1276     WinInetHttpInfo_AddRef,
1277     WinInetHttpInfo_Release,
1278     WinInetHttpInfo_QueryOption,
1279     WinInetHttpInfo_QueryInfo
1280 };
1281
1282 static inline Binding *impl_from_IServiceProvider(IServiceProvider *iface)
1283 {
1284     return CONTAINING_RECORD(iface, Binding, IServiceProvider_iface);
1285 }
1286
1287 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface,
1288         REFIID riid, void **ppv)
1289 {
1290     Binding *This = impl_from_IServiceProvider(iface);
1291     return IBinding_QueryInterface(&This->IBinding_iface, riid, ppv);
1292 }
1293
1294 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
1295 {
1296     Binding *This = impl_from_IServiceProvider(iface);
1297     return IBinding_AddRef(&This->IBinding_iface);
1298 }
1299
1300 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
1301 {
1302     Binding *This = impl_from_IServiceProvider(iface);
1303     return IBinding_Release(&This->IBinding_iface);
1304 }
1305
1306 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface,
1307         REFGUID guidService, REFIID riid, void **ppv)
1308 {
1309     Binding *This = impl_from_IServiceProvider(iface);
1310     HRESULT hres;
1311
1312     TRACE("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
1313
1314     if(This->service_provider) {
1315         hres = IServiceProvider_QueryService(This->service_provider, guidService,
1316                                              riid, ppv);
1317         if(SUCCEEDED(hres))
1318             return hres;
1319     }
1320
1321     WARN("unknown service %s\n", debugstr_guid(guidService));
1322     return E_NOINTERFACE;
1323 }
1324
1325 static const IServiceProviderVtbl ServiceProviderVtbl = {
1326     ServiceProvider_QueryInterface,
1327     ServiceProvider_AddRef,
1328     ServiceProvider_Release,
1329     ServiceProvider_QueryService
1330 };
1331
1332 static HRESULT get_callback(IBindCtx *pbc, IBindStatusCallback **callback)
1333 {
1334     IUnknown *unk;
1335     HRESULT hres;
1336
1337     hres = IBindCtx_GetObjectParam(pbc, bscb_holderW, &unk);
1338     if(FAILED(hres))
1339         return create_default_callback(callback);
1340
1341     hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)callback);
1342     IUnknown_Release(unk);
1343     return hres;
1344 }
1345
1346 static BOOL is_urlmon_protocol(IUri *uri)
1347 {
1348     DWORD scheme;
1349     HRESULT hres;
1350
1351     hres = IUri_GetScheme(uri, &scheme);
1352     if(FAILED(hres))
1353         return FALSE;
1354
1355     switch(scheme) {
1356     case URL_SCHEME_FILE:
1357     case URL_SCHEME_FTP:
1358     case URL_SCHEME_GOPHER:
1359     case URL_SCHEME_HTTP:
1360     case URL_SCHEME_HTTPS:
1361     case URL_SCHEME_MK:
1362         return TRUE;
1363     }
1364
1365     return FALSE;
1366 }
1367
1368 static HRESULT Binding_Create(IMoniker *mon, Binding *binding_ctx, IUri *uri, IBindCtx *pbc,
1369         BOOL to_obj, REFIID riid, Binding **binding)
1370 {
1371     Binding *ret;
1372     HRESULT hres;
1373
1374     URLMON_LockModule();
1375
1376     ret = heap_alloc_zero(sizeof(Binding));
1377
1378     ret->IBinding_iface.lpVtbl = &BindingVtbl;
1379     ret->IInternetProtocolSink_iface.lpVtbl = &InternetProtocolSinkVtbl;
1380     ret->IInternetBindInfo_iface.lpVtbl = &InternetBindInfoVtbl;
1381     ret->IWinInetHttpInfo_iface.lpVtbl = &WinInetHttpInfoVtbl;
1382     ret->IServiceProvider_iface.lpVtbl = &ServiceProviderVtbl;
1383
1384     ret->ref = 1;
1385
1386     ret->to_object = to_obj;
1387     ret->iid = *riid;
1388     ret->notif_hwnd = get_notif_hwnd();
1389     ret->report_mime = !binding_ctx;
1390     ret->download_state = BEFORE_DOWNLOAD;
1391
1392     if(to_obj) {
1393         IBindCtx_AddRef(pbc);
1394         ret->bctx = pbc;
1395     }
1396
1397     if(mon) {
1398         IMoniker_AddRef(mon);
1399         ret->mon = mon;
1400     }
1401
1402     ret->bindinfo.cbSize = sizeof(BINDINFO);
1403
1404     InitializeCriticalSection(&ret->section);
1405     ret->section.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": Binding.section");
1406
1407     hres = get_callback(pbc, &ret->callback);
1408     if(FAILED(hres)) {
1409         WARN("Could not get IBindStatusCallback\n");
1410         IBinding_Release(&ret->IBinding_iface);
1411         return hres;
1412     }
1413
1414     IBindStatusCallback_QueryInterface(ret->callback, &IID_IServiceProvider,
1415                                        (void**)&ret->service_provider);
1416
1417     if(binding_ctx) {
1418         ret->protocol = binding_ctx->protocol;
1419         IInternetProtocolEx_AddRef(&ret->protocol->IInternetProtocolEx_iface);
1420     }else {
1421         hres = create_binding_protocol(TRUE, &ret->protocol);
1422         if(FAILED(hres)) {
1423             WARN("Could not get protocol handler\n");
1424             IBinding_Release(&ret->IBinding_iface);
1425             return hres;
1426         }
1427     }
1428
1429     hres = IBindStatusCallback_GetBindInfo(ret->callback, &ret->bindf, &ret->bindinfo);
1430     if(FAILED(hres)) {
1431         WARN("GetBindInfo failed: %08x\n", hres);
1432         IBinding_Release(&ret->IBinding_iface);
1433         return hres;
1434     }
1435
1436     TRACE("bindf %08x\n", ret->bindf);
1437     dump_BINDINFO(&ret->bindinfo);
1438
1439     ret->bindf |= BINDF_FROMURLMON;
1440     if(to_obj)
1441         ret->bindinfo.dwOptions |= 0x100000;
1442
1443     if(!(ret->bindf & BINDF_ASYNCHRONOUS) || !(ret->bindf & BINDF_PULLDATA)) {
1444         ret->bindf |= BINDF_NEEDFILE;
1445         ret->use_cache_file = TRUE;
1446     }else if(!is_urlmon_protocol(uri)) {
1447         ret->bindf |= BINDF_NEEDFILE;
1448     }
1449
1450     hres = IUri_GetDisplayUri(uri, &ret->url);
1451     if(FAILED(hres)) {
1452         IBinding_Release(&ret->IBinding_iface);
1453         return hres;
1454     }
1455
1456     if(binding_ctx) {
1457         ret->stgmed_buf = binding_ctx->stgmed_buf;
1458         IUnknown_AddRef(&ret->stgmed_buf->IUnknown_iface);
1459         ret->clipboard_format = binding_ctx->clipboard_format;
1460     }else {
1461         ret->stgmed_buf = create_stgmed_buf(&ret->protocol->IInternetProtocolEx_iface);
1462     }
1463
1464     if(to_obj) {
1465         ret->stgmed_obj = NULL;
1466     }else if(IsEqualGUID(&IID_IStream, riid)) {
1467         ret->stgmed_obj = create_stgmed_stream(ret->stgmed_buf);
1468     }else if(IsEqualGUID(&IID_IUnknown, riid)) {
1469         ret->bindf |= BINDF_NEEDFILE;
1470         ret->stgmed_obj = create_stgmed_file(ret->stgmed_buf);
1471     }else {
1472         FIXME("Unsupported riid %s\n", debugstr_guid(riid));
1473         IBinding_Release(&ret->IBinding_iface);
1474         return E_NOTIMPL;
1475     }
1476
1477     *binding = ret;
1478     return S_OK;
1479 }
1480
1481 static HRESULT start_binding(IMoniker *mon, Binding *binding_ctx, IUri *uri, IBindCtx *pbc,
1482                              BOOL to_obj, REFIID riid, Binding **ret)
1483 {
1484     Binding *binding = NULL;
1485     HRESULT hres;
1486     MSG msg;
1487
1488     hres = Binding_Create(mon, binding_ctx, uri, pbc, to_obj, riid, &binding);
1489     if(FAILED(hres))
1490         return hres;
1491
1492     hres = IBindStatusCallback_OnStartBinding(binding->callback, 0, &binding->IBinding_iface);
1493     if(FAILED(hres)) {
1494         WARN("OnStartBinding failed: %08x\n", hres);
1495         stop_binding(binding, INET_E_DOWNLOAD_FAILURE, NULL);
1496         IBinding_Release(&binding->IBinding_iface);
1497         return hres;
1498     }
1499
1500     if(binding_ctx) {
1501         set_binding_sink(binding->protocol, &binding->IInternetProtocolSink_iface,
1502                 &binding->IInternetBindInfo_iface);
1503         if(binding_ctx->redirect_url)
1504             IBindStatusCallback_OnProgress(binding->callback, 0, 0, BINDSTATUS_REDIRECTING, binding_ctx->redirect_url);
1505         report_data(binding, BSCF_FIRSTDATANOTIFICATION | (binding_ctx->download_state == END_DOWNLOAD ? BSCF_LASTDATANOTIFICATION : 0),
1506                 0, 0);
1507     }else {
1508         hres = IInternetProtocolEx_StartEx(&binding->protocol->IInternetProtocolEx_iface, uri,
1509                 &binding->IInternetProtocolSink_iface, &binding->IInternetBindInfo_iface,
1510                 PI_APARTMENTTHREADED|PI_MIMEVERIFICATION, 0);
1511
1512         TRACE("start ret %08x\n", hres);
1513
1514         if(FAILED(hres) && hres != E_PENDING) {
1515             stop_binding(binding, hres, NULL);
1516             IBinding_Release(&binding->IBinding_iface);
1517
1518             return hres;
1519         }
1520     }
1521
1522     while(!(binding->bindf & BINDF_ASYNCHRONOUS) &&
1523           !(binding->state & BINDING_STOPPED)) {
1524         MsgWaitForMultipleObjects(0, NULL, FALSE, 5000, QS_POSTMESSAGE);
1525         while (PeekMessageW(&msg, binding->notif_hwnd, WM_USER, WM_USER+117, PM_REMOVE|PM_NOYIELD)) {
1526             TranslateMessage(&msg);
1527             DispatchMessageW(&msg);
1528         }
1529     }
1530
1531     *ret = binding;
1532     return S_OK;
1533 }
1534
1535 HRESULT bind_to_storage(IUri *uri, IBindCtx *pbc, REFIID riid, void **ppv)
1536 {
1537     Binding *binding = NULL, *binding_ctx;
1538     HRESULT hres;
1539
1540     *ppv = NULL;
1541
1542     binding_ctx = get_bctx_binding(pbc);
1543
1544     hres = start_binding(NULL, binding_ctx, uri, pbc, FALSE, riid, &binding);
1545     if(binding_ctx)
1546         IBinding_Release(&binding_ctx->IBinding_iface);
1547     if(FAILED(hres))
1548         return hres;
1549
1550     if(binding->hres == S_OK && binding->download_state != BEFORE_DOWNLOAD /* FIXME */) {
1551         if((binding->state & BINDING_STOPPED) && (binding->state & BINDING_LOCKED))
1552             IInternetProtocolEx_UnlockRequest(&binding->protocol->IInternetProtocolEx_iface);
1553
1554         hres = binding->stgmed_obj->vtbl->get_result(binding->stgmed_obj, binding->bindf, ppv);
1555     }else if(binding->bindf & BINDF_ASYNCHRONOUS) {
1556         hres = MK_S_ASYNCHRONOUS;
1557     }else {
1558         hres = FAILED(binding->hres) ? binding->hres : S_OK;
1559     }
1560
1561     IBinding_Release(&binding->IBinding_iface);
1562
1563     return hres;
1564 }
1565
1566 HRESULT bind_to_object(IMoniker *mon, IUri *uri, IBindCtx *pbc, REFIID riid, void **ppv)
1567 {
1568     Binding *binding;
1569     HRESULT hres;
1570
1571     *ppv = NULL;
1572
1573     hres = start_binding(mon, NULL, uri, pbc, TRUE, riid, &binding);
1574     if(FAILED(hres))
1575         return hres;
1576
1577     if(binding->hres != S_OK) {
1578         hres = SUCCEEDED(binding->hres) ? S_OK : binding->hres;
1579     }else if(binding->bindf & BINDF_ASYNCHRONOUS) {
1580         hres = MK_S_ASYNCHRONOUS;
1581     }else {
1582         *ppv = binding->obj;
1583         IUnknown_AddRef(binding->obj);
1584         hres = S_OK;
1585     }
1586
1587     IBinding_Release(&binding->IBinding_iface);
1588
1589     return hres;
1590 }