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