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     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(PROTOCOLEX(binding->protocol));
 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(PROTOCOLEX(binding->protocol), 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(PROTOCOLEX(This->protocol));
 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(PROTOCOLEX(This->protocol), E_ABORT, ERROR_SUCCESS);
 902     if(FAILED(hres))
 903         return hres;
 904
 905     This->state |= BINDING_ABORTED;
 906     return S_OK;
 907 }
 908
 909 static HRESULT WINAPI Binding_Suspend(IBinding *iface)
 910 {
 911     Binding *This = BINDING_THIS(iface);
 912     FIXME("(%p)\n", This);
 913     return E_NOTIMPL;
 914 }
 915
 916 static HRESULT WINAPI Binding_Resume(IBinding *iface)
 917 {
 918     Binding *This = BINDING_THIS(iface);
 919     FIXME("(%p)\n", This);
 920     return E_NOTIMPL;
 921 }
 922
 923 static HRESULT WINAPI Binding_SetPriority(IBinding *iface, LONG nPriority)
 924 {
 925     Binding *This = BINDING_THIS(iface);
 926     FIXME("(%p)->(%d)\n", This, nPriority);
 927     return E_NOTIMPL;
 928 }
 929
 930 static HRESULT WINAPI Binding_GetPriority(IBinding *iface, LONG *pnPriority)
 931 {
 932     Binding *This = BINDING_THIS(iface);
 933     FIXME("(%p)->(%p)\n", This, pnPriority);
 934     return E_NOTIMPL;
 935 }
 936
 937 static HRESULT WINAPI Binding_GetBindResult(IBinding *iface, CLSID *pclsidProtocol,
 938         DWORD *pdwResult, LPOLESTR *pszResult, DWORD *pdwReserved)
 939 {
 940     Binding *This = BINDING_THIS(iface);
 941     FIXME("(%p)->(%p %p %p %p)\n", This, pclsidProtocol, pdwResult, pszResult, pdwReserved);
 942     return E_NOTIMPL;
 943 }
 944
 945 static Binding *get_bctx_binding(IBindCtx *bctx)
 946 {
 947     IBinding *binding;
 948     IUnknown *unk;
 949     HRESULT hres;
 950
 951     hres = IBindCtx_GetObjectParam(bctx, cbinding_contextW, &unk);
 952     if(FAILED(hres))
 953         return NULL;
 954
 955     hres = IUnknown_QueryInterface(unk, &IID_IBinding, (void*)&binding);
 956     IUnknown_Release(unk);
 957     if(FAILED(hres))
 958         return NULL;
 959
 960     /* FIXME!!! */
 961     return BINDING_THIS(binding);
 962 }
 963
 964 #undef BINDING_THIS
 965
 966 static const IBindingVtbl BindingVtbl = {
 967     Binding_QueryInterface,
 968     Binding_AddRef,
 969     Binding_Release,
 970     Binding_Abort,
 971     Binding_Suspend,
 972     Binding_Resume,
 973     Binding_SetPriority,
 974     Binding_GetPriority,
 975     Binding_GetBindResult
 976 };
 977
 978 #define PROTSINK_THIS(iface) DEFINE_THIS(Binding, IInternetProtocolSink, iface)
 979
 980 static HRESULT WINAPI InternetProtocolSink_QueryInterface(IInternetProtocolSink *iface,
 981         REFIID riid, void **ppv)
 982 {
 983     Binding *This = PROTSINK_THIS(iface);
 984     return IBinding_QueryInterface(BINDING(This), riid, ppv);
 985 }
 986
 987 static ULONG WINAPI InternetProtocolSink_AddRef(IInternetProtocolSink *iface)
 988 {
 989     Binding *This = PROTSINK_THIS(iface);
 990     return IBinding_AddRef(BINDING(This));
 991 }
 992
 993 static ULONG WINAPI InternetProtocolSink_Release(IInternetProtocolSink *iface)
 994 {
 995     Binding *This = PROTSINK_THIS(iface);
 996     return IBinding_Release(BINDING(This));
 997 }
 998
 999 static HRESULT WINAPI InternetProtocolSink_Switch(IInternetProtocolSink *iface,
1000         PROTOCOLDATA *pProtocolData)
1001 {
1002     Binding *This = PROTSINK_THIS(iface);
1003
1004     WARN("(%p)->(%p)\n", This, pProtocolData);
1005
1006     return E_FAIL;
1007 }
1008
1009 static void on_progress(Binding *This, ULONG progress, ULONG progress_max,
1010                         ULONG status_code, LPCWSTR status_text)
1011 {
1012     IBindStatusCallback_OnProgress(This->callback, progress, progress_max,
1013             status_code, status_text);
1014 }
1015
1016 static HRESULT WINAPI InternetProtocolSink_ReportProgress(IInternetProtocolSink *iface,
1017         ULONG ulStatusCode, LPCWSTR szStatusText)
1018 {
1019     Binding *This = PROTSINK_THIS(iface);
1020
1021     TRACE("(%p)->(%u %s)\n", This, ulStatusCode, debugstr_w(szStatusText));
1022
1023     switch(ulStatusCode) {
1024     case BINDSTATUS_FINDINGRESOURCE:
1025         on_progress(This, 0, 0, BINDSTATUS_FINDINGRESOURCE, szStatusText);
1026         break;
1027     case BINDSTATUS_CONNECTING:
1028         on_progress(This, 0, 0, BINDSTATUS_CONNECTING, szStatusText);
1029         break;
1030     case BINDSTATUS_REDIRECTING:
1031         heap_free(This->redirect_url);
1032         This->redirect_url = heap_strdupW(szStatusText);
1033         on_progress(This, 0, 0, BINDSTATUS_REDIRECTING, szStatusText);
1034         break;
1035     case BINDSTATUS_BEGINDOWNLOADDATA:
1036         fill_stgmed_buffer(This->stgmed_buf);
1037         break;
1038     case BINDSTATUS_SENDINGREQUEST:
1039         on_progress(This, 0, 0, BINDSTATUS_SENDINGREQUEST, szStatusText);
1040         break;
1041     case BINDSTATUS_PROTOCOLCLASSID:
1042         break;
1043     case BINDSTATUS_MIMETYPEAVAILABLE:
1044     case BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE:
1045         mime_available(This, szStatusText);
1046         break;
1047     case BINDSTATUS_CACHEFILENAMEAVAILABLE:
1048         cache_file_available(This, szStatusText);
1049         break;
1050     case BINDSTATUS_DECODING:
1051         IBindStatusCallback_OnProgress(This->callback, 0, 0, BINDSTATUS_DECODING, szStatusText);
1052         break;
1053     case BINDSTATUS_LOADINGMIMEHANDLER:
1054         on_progress(This, 0, 0, BINDSTATUS_LOADINGMIMEHANDLER, szStatusText);
1055         break;
1056     case BINDSTATUS_DIRECTBIND: /* FIXME: Handle BINDSTATUS_DIRECTBIND in BindProtocol */
1057         This->report_mime = FALSE;
1058         break;
1059     case BINDSTATUS_ACCEPTRANGES:
1060         break;
1061     default:
1062         FIXME("Unhandled status code %d\n", ulStatusCode);
1063         return E_NOTIMPL;
1064     };
1065
1066     return S_OK;
1067 }
1068
1069 static void report_data(Binding *This, DWORD bscf, ULONG progress, ULONG progress_max)
1070 {
1071     FORMATETC formatetc = {0, NULL, 1, -1, TYMED_ISTREAM};
1072     BOOL sent_begindownloaddata = FALSE;
1073
1074     TRACE("(%p)->(%d %u %u)\n", This, bscf, progress, progress_max);
1075
1076     if(This->download_state == END_DOWNLOAD || (This->state & (BINDING_STOPPED|BINDING_ABORTED)))
1077         return;
1078
1079     if(This->stgmed_buf->file != INVALID_HANDLE_VALUE)
1080         read_protocol_data(This->stgmed_buf);
1081     else if(This->download_state == BEFORE_DOWNLOAD)
1082         fill_stgmed_buffer(This->stgmed_buf);
1083
1084     if(This->download_state == BEFORE_DOWNLOAD) {
1085         This->download_state = DOWNLOADING;
1086         sent_begindownloaddata = TRUE;
1087         IBindStatusCallback_OnProgress(This->callback, progress, progress_max,
1088                 BINDSTATUS_BEGINDOWNLOADDATA, This->url);
1089
1090         if(This->stgmed_buf->cache_file)
1091             IBindStatusCallback_OnProgress(This->callback, progress, progress_max,
1092                     BINDSTATUS_CACHEFILENAMEAVAILABLE, This->stgmed_buf->cache_file);
1093     }
1094
1095     if(This->stgmed_buf->hres == S_FALSE || (bscf & BSCF_LASTDATANOTIFICATION)) {
1096         This->download_state = END_DOWNLOAD;
1097         IBindStatusCallback_OnProgress(This->callback, progress, progress_max,
1098                 BINDSTATUS_ENDDOWNLOADDATA, This->url);
1099     }else if(!sent_begindownloaddata) {
1100         IBindStatusCallback_OnProgress(This->callback, progress, progress_max,
1101                 BINDSTATUS_DOWNLOADINGDATA, This->url);
1102     }
1103
1104     if(This->state & (BINDING_STOPPED|BINDING_ABORTED))
1105         return;
1106
1107     if(This->to_object) {
1108         if(!(This->state & BINDING_OBJAVAIL)) {
1109             IBinding_AddRef(BINDING(This));
1110             create_object(This);
1111             IBinding_Release(BINDING(This));
1112         }
1113     }else {
1114         STGMEDIUM stgmed;
1115         HRESULT hres;
1116
1117         if(!(This->state & BINDING_LOCKED)) {
1118             HRESULT hres = IInternetProtocolEx_LockRequest(PROTOCOLEX(This->protocol), 0);
1119             if(SUCCEEDED(hres))
1120                 This->state |= BINDING_LOCKED;
1121         }
1122
1123         hres = This->stgmed_obj->vtbl->fill_stgmed(This->stgmed_obj, &stgmed);
1124         if(FAILED(hres)) {
1125             stop_binding(This, hres, NULL);
1126             return;
1127         }
1128
1129         formatetc.tymed = stgmed.tymed;
1130         formatetc.cfFormat = This->clipboard_format;
1131
1132         IBindStatusCallback_OnDataAvailable(This->callback, bscf, progress,
1133                 &formatetc, &stgmed);
1134
1135         if(This->download_state == END_DOWNLOAD)
1136             stop_binding(This, S_OK, NULL);
1137     }
1138 }
1139
1140 static HRESULT WINAPI InternetProtocolSink_ReportData(IInternetProtocolSink *iface,
1141         DWORD grfBSCF, ULONG ulProgress, ULONG ulProgressMax)
1142 {
1143     Binding *This = PROTSINK_THIS(iface);
1144
1145     TRACE("(%p)->(%d %u %u)\n", This, grfBSCF, ulProgress, ulProgressMax);
1146
1147     report_data(This, grfBSCF, ulProgress, ulProgressMax);
1148     return S_OK;
1149 }
1150
1151 static HRESULT WINAPI InternetProtocolSink_ReportResult(IInternetProtocolSink *iface,
1152         HRESULT hrResult, DWORD dwError, LPCWSTR szResult)
1153 {
1154     Binding *This = PROTSINK_THIS(iface);
1155
1156     TRACE("(%p)->(%08x %d %s)\n", This, hrResult, dwError, debugstr_w(szResult));
1157
1158     stop_binding(This, hrResult, szResult);
1159     IInternetProtocolEx_Terminate(PROTOCOLEX(This->protocol), 0);
1160     return S_OK;
1161 }
1162
1163 #undef PROTSINK_THIS
1164
1165 static const IInternetProtocolSinkVtbl InternetProtocolSinkVtbl = {
1166     InternetProtocolSink_QueryInterface,
1167     InternetProtocolSink_AddRef,
1168     InternetProtocolSink_Release,
1169     InternetProtocolSink_Switch,
1170     InternetProtocolSink_ReportProgress,
1171     InternetProtocolSink_ReportData,
1172     InternetProtocolSink_ReportResult
1173 };
1174
1175 #define BINDINF_THIS(iface) DEFINE_THIS(Binding, InternetBindInfo, iface)
1176
1177 static HRESULT WINAPI InternetBindInfo_QueryInterface(IInternetBindInfo *iface,
1178         REFIID riid, void **ppv)
1179 {
1180     Binding *This = BINDINF_THIS(iface);
1181     return IBinding_QueryInterface(BINDING(This), riid, ppv);
1182 }
1183
1184 static ULONG WINAPI InternetBindInfo_AddRef(IInternetBindInfo *iface)
1185 {
1186     Binding *This = BINDINF_THIS(iface);
1187     return IBinding_AddRef(BINDING(This));
1188 }
1189
1190 static ULONG WINAPI InternetBindInfo_Release(IInternetBindInfo *iface)
1191 {
1192     Binding *This = BINDINF_THIS(iface);
1193     return IBinding_Release(BINDING(This));
1194 }
1195
1196 static HRESULT WINAPI InternetBindInfo_GetBindInfo(IInternetBindInfo *iface,
1197         DWORD *grfBINDF, BINDINFO *pbindinfo)
1198 {
1199     Binding *This = BINDINF_THIS(iface);
1200
1201     TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
1202
1203     *grfBINDF = This->bindf;
1204
1205     *pbindinfo = This->bindinfo;
1206
1207     if(pbindinfo->szExtraInfo || pbindinfo->szCustomVerb)
1208         FIXME("copy strings\n");
1209
1210     if(pbindinfo->stgmedData.pUnkForRelease)
1211         IUnknown_AddRef(pbindinfo->stgmedData.pUnkForRelease);
1212
1213     if(pbindinfo->pUnk)
1214         IUnknown_AddRef(pbindinfo->pUnk);
1215
1216     return S_OK;
1217 }
1218
1219 static HRESULT WINAPI InternetBindInfo_GetBindString(IInternetBindInfo *iface,
1220         ULONG ulStringType, LPOLESTR *ppwzStr, ULONG cEl, ULONG *pcElFetched)
1221 {
1222     Binding *This = BINDINF_THIS(iface);
1223
1224     TRACE("(%p)->(%d %p %d %p)\n", This, ulStringType, ppwzStr, cEl, pcElFetched);
1225
1226     switch(ulStringType) {
1227     case BINDSTRING_ACCEPT_MIMES: {
1228         static const WCHAR wszMimes[] = {'*','/','*',0};
1229
1230         if(!ppwzStr || !pcElFetched)
1231             return E_INVALIDARG;
1232
1233         ppwzStr[0] = CoTaskMemAlloc(sizeof(wszMimes));
1234         memcpy(ppwzStr[0], wszMimes, sizeof(wszMimes));
1235         *pcElFetched = 1;
1236         return S_OK;
1237     }
1238     case BINDSTRING_USER_AGENT: {
1239         IInternetBindInfo *bindinfo = NULL;
1240         HRESULT hres;
1241
1242         hres = IBindStatusCallback_QueryInterface(This->callback, &IID_IInternetBindInfo,
1243                                                   (void**)&bindinfo);
1244         if(FAILED(hres))
1245             return hres;
1246
1247         hres = IInternetBindInfo_GetBindString(bindinfo, ulStringType, ppwzStr,
1248                                                cEl, pcElFetched);
1249         IInternetBindInfo_Release(bindinfo);
1250
1251         return hres;
1252     }
1253     case BINDSTRING_URL: {
1254         DWORD size = (SysStringLen(This->url)+1) * sizeof(WCHAR);
1255
1256         if(!ppwzStr || !pcElFetched)
1257             return E_INVALIDARG;
1258
1259         *ppwzStr = CoTaskMemAlloc(size);
1260         memcpy(*ppwzStr, This->url, size);
1261         *pcElFetched = 1;
1262         return S_OK;
1263     }
1264     }
1265
1266     FIXME("not supported string type %d\n", ulStringType);
1267     return E_NOTIMPL;
1268 }
1269
1270 #undef BINDF_THIS
1271
1272 static const IInternetBindInfoVtbl InternetBindInfoVtbl = {
1273     InternetBindInfo_QueryInterface,
1274     InternetBindInfo_AddRef,
1275     InternetBindInfo_Release,
1276     InternetBindInfo_GetBindInfo,
1277     InternetBindInfo_GetBindString
1278 };
1279
1280 #define INETINFO_THIS(iface) DEFINE_THIS(Binding, WinInetHttpInfo, iface)
1281
1282 static HRESULT WINAPI WinInetHttpInfo_QueryInterface(IWinInetHttpInfo *iface, REFIID riid, void **ppv)
1283 {
1284     Binding *This = INETINFO_THIS(iface);
1285     return IBinding_QueryInterface(BINDING(This), riid, ppv);
1286 }
1287
1288 static ULONG WINAPI WinInetHttpInfo_AddRef(IWinInetHttpInfo *iface)
1289 {
1290     Binding *This = INETINFO_THIS(iface);
1291     return IBinding_AddRef(BINDING(This));
1292 }
1293
1294 static ULONG WINAPI WinInetHttpInfo_Release(IWinInetHttpInfo *iface)
1295 {
1296     Binding *This = INETINFO_THIS(iface);
1297     return IBinding_Release(BINDING(This));
1298 }
1299
1300 static HRESULT WINAPI WinInetHttpInfo_QueryOption(IWinInetHttpInfo *iface, DWORD dwOption,
1301         void *pBuffer, DWORD *pcbBuffer)
1302 {
1303     Binding *This = INETINFO_THIS(iface);
1304     FIXME("(%p)->(%x %p %p)\n", This, dwOption, pBuffer, pcbBuffer);
1305     return E_NOTIMPL;
1306 }
1307
1308 static HRESULT WINAPI WinInetHttpInfo_QueryInfo(IWinInetHttpInfo *iface, DWORD dwOption,
1309         void *pBuffer, DWORD *pcbBuffer, DWORD *pdwFlags, DWORD *pdwReserved)
1310 {
1311     Binding *This = INETINFO_THIS(iface);
1312     FIXME("(%p)->(%x %p %p %p %p)\n", This, dwOption, pBuffer, pcbBuffer, pdwFlags, pdwReserved);
1313     return E_NOTIMPL;
1314 }
1315
1316 #undef INETINFO_THIS
1317
1318 static const IWinInetHttpInfoVtbl WinInetHttpInfoVtbl = {
1319     WinInetHttpInfo_QueryInterface,
1320     WinInetHttpInfo_AddRef,
1321     WinInetHttpInfo_Release,
1322     WinInetHttpInfo_QueryOption,
1323     WinInetHttpInfo_QueryInfo
1324 };
1325
1326 #define SERVPROV_THIS(iface) DEFINE_THIS(Binding, ServiceProvider, iface)
1327
1328 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface,
1329         REFIID riid, void **ppv)
1330 {
1331     Binding *This = SERVPROV_THIS(iface);
1332     return IBinding_QueryInterface(BINDING(This), riid, ppv);
1333 }
1334
1335 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
1336 {
1337     Binding *This = SERVPROV_THIS(iface);
1338     return IBinding_AddRef(BINDING(This));
1339 }
1340
1341 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
1342 {
1343     Binding *This = SERVPROV_THIS(iface);
1344     return IBinding_Release(BINDING(This));
1345 }
1346
1347 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface,
1348         REFGUID guidService, REFIID riid, void **ppv)
1349 {
1350     Binding *This = SERVPROV_THIS(iface);
1351     HRESULT hres;
1352
1353     TRACE("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
1354
1355     if(This->service_provider) {
1356         hres = IServiceProvider_QueryService(This->service_provider, guidService,
1357                                              riid, ppv);
1358         if(SUCCEEDED(hres))
1359             return hres;
1360     }
1361
1362     WARN("unknown service %s\n", debugstr_guid(guidService));
1363     return E_NOINTERFACE;
1364 }
1365
1366 #undef SERVPROV_THIS
1367
1368 static const IServiceProviderVtbl ServiceProviderVtbl = {
1369     ServiceProvider_QueryInterface,
1370     ServiceProvider_AddRef,
1371     ServiceProvider_Release,
1372     ServiceProvider_QueryService
1373 };
1374
1375 static HRESULT get_callback(IBindCtx *pbc, IBindStatusCallback **callback)
1376 {
1377     IUnknown *unk;
1378     HRESULT hres;
1379
1380     hres = IBindCtx_GetObjectParam(pbc, bscb_holderW, &unk);
1381     if(FAILED(hres))
1382         return create_default_callback(callback);
1383
1384     hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)callback);
1385     IUnknown_Release(unk);
1386     return hres;
1387 }
1388
1389 static BOOL is_urlmon_protocol(IUri *uri)
1390 {
1391     DWORD scheme;
1392     HRESULT hres;
1393
1394     hres = IUri_GetScheme(uri, &scheme);
1395     if(FAILED(hres))
1396         return FALSE;
1397
1398     switch(scheme) {
1399     case URL_SCHEME_FILE:
1400     case URL_SCHEME_FTP:
1401     case URL_SCHEME_GOPHER:
1402     case URL_SCHEME_HTTP:
1403     case URL_SCHEME_HTTPS:
1404     case URL_SCHEME_MK:
1405         return TRUE;
1406     }
1407
1408     return FALSE;
1409 }
1410
1411 static HRESULT Binding_Create(IMoniker *mon, Binding *binding_ctx, IUri *uri, IBindCtx *pbc,
1412         BOOL to_obj, REFIID riid, Binding **binding)
1413 {
1414     Binding *ret;
1415     HRESULT hres;
1416
1417     URLMON_LockModule();
1418
1419     ret = heap_alloc_zero(sizeof(Binding));
1420
1421     ret->lpBindingVtbl              = &BindingVtbl;
1422     ret->lpIInternetProtocolSinkVtbl = &InternetProtocolSinkVtbl;
1423     ret->lpInternetBindInfoVtbl     = &InternetBindInfoVtbl;
1424     ret->lpWinInetHttpInfoVtbl      = &WinInetHttpInfoVtbl;
1425     ret->lpServiceProviderVtbl      = &ServiceProviderVtbl;
1426
1427     ret->ref = 1;
1428
1429     ret->to_object = to_obj;
1430     ret->iid = *riid;
1431     ret->notif_hwnd = get_notif_hwnd();
1432     ret->report_mime = !binding_ctx;
1433     ret->download_state = BEFORE_DOWNLOAD;
1434
1435     if(to_obj) {
1436         IBindCtx_AddRef(pbc);
1437         ret->bctx = pbc;
1438     }
1439
1440     if(mon) {
1441         IMoniker_AddRef(mon);
1442         ret->mon = mon;
1443     }
1444
1445     ret->bindinfo.cbSize = sizeof(BINDINFO);
1446
1447     InitializeCriticalSection(&ret->section);
1448     ret->section.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": Binding.section");
1449
1450     hres = get_callback(pbc, &ret->callback);
1451     if(FAILED(hres)) {
1452         WARN("Could not get IBindStatusCallback\n");
1453         IBinding_Release(BINDING(ret));
1454         return hres;
1455     }
1456
1457     IBindStatusCallback_QueryInterface(ret->callback, &IID_IServiceProvider,
1458                                        (void**)&ret->service_provider);
1459
1460     if(binding_ctx) {
1461         ret->protocol = binding_ctx->protocol;
1462         IInternetProtocolEx_AddRef(PROTOCOLEX(ret->protocol));
1463     }else {
1464         hres = create_binding_protocol(TRUE, &ret->protocol);
1465         if(FAILED(hres)) {
1466             WARN("Could not get protocol handler\n");
1467             IBinding_Release(BINDING(ret));
1468             return hres;
1469         }
1470     }
1471
1472     hres = IBindStatusCallback_GetBindInfo(ret->callback, &ret->bindf, &ret->bindinfo);
1473     if(FAILED(hres)) {
1474         WARN("GetBindInfo failed: %08x\n", hres);
1475         IBinding_Release(BINDING(ret));
1476         return hres;
1477     }
1478
1479     TRACE("bindf %08x\n", ret->bindf);
1480     dump_BINDINFO(&ret->bindinfo);
1481
1482     ret->bindf |= BINDF_FROMURLMON;
1483     if(to_obj)
1484         ret->bindinfo.dwOptions |= 0x100000;
1485
1486     if(!(ret->bindf & BINDF_ASYNCHRONOUS) || !(ret->bindf & BINDF_PULLDATA)) {
1487         ret->bindf |= BINDF_NEEDFILE;
1488         ret->use_cache_file = TRUE;
1489     }else if(!is_urlmon_protocol(uri)) {
1490         ret->bindf |= BINDF_NEEDFILE;
1491     }
1492
1493     hres = IUri_GetDisplayUri(uri, &ret->url);
1494     if(FAILED(hres)) {
1495         IBinding_Release(BINDING(ret));
1496         return hres;
1497     }
1498
1499     if(binding_ctx) {
1500         ret->stgmed_buf = binding_ctx->stgmed_buf;
1501         IUnknown_AddRef(&ret->stgmed_buf->IUnknown_iface);
1502         ret->clipboard_format = binding_ctx->clipboard_format;
1503     }else {
1504         ret->stgmed_buf = create_stgmed_buf(PROTOCOLEX(ret->protocol));
1505     }
1506
1507     if(to_obj) {
1508         ret->stgmed_obj = NULL;
1509     }else if(IsEqualGUID(&IID_IStream, riid)) {
1510         ret->stgmed_obj = create_stgmed_stream(ret->stgmed_buf);
1511     }else if(IsEqualGUID(&IID_IUnknown, riid)) {
1512         ret->bindf |= BINDF_NEEDFILE;
1513         ret->stgmed_obj = create_stgmed_file(ret->stgmed_buf);
1514     }else {
1515         FIXME("Unsupported riid %s\n", debugstr_guid(riid));
1516         IBinding_Release(BINDING(ret));
1517         return E_NOTIMPL;
1518     }
1519
1520     *binding = ret;
1521     return S_OK;
1522 }
1523
1524 static HRESULT start_binding(IMoniker *mon, Binding *binding_ctx, IUri *uri, IBindCtx *pbc,
1525                              BOOL to_obj, REFIID riid, Binding **ret)
1526 {
1527     Binding *binding = NULL;
1528     HRESULT hres;
1529     MSG msg;
1530
1531     hres = Binding_Create(mon, binding_ctx, uri, pbc, to_obj, riid, &binding);
1532     if(FAILED(hres))
1533         return hres;
1534
1535     hres = IBindStatusCallback_OnStartBinding(binding->callback, 0, BINDING(binding));
1536     if(FAILED(hres)) {
1537         WARN("OnStartBinding failed: %08x\n", hres);
1538         stop_binding(binding, INET_E_DOWNLOAD_FAILURE, NULL);
1539         IBinding_Release(BINDING(binding));
1540         return hres;
1541     }
1542
1543     if(binding_ctx) {
1544         set_binding_sink(binding->protocol, PROTSINK(binding), BINDINF(binding));
1545         if(binding_ctx->redirect_url)
1546             IBindStatusCallback_OnProgress(binding->callback, 0, 0, BINDSTATUS_REDIRECTING, binding_ctx->redirect_url);
1547         report_data(binding, BSCF_FIRSTDATANOTIFICATION | (binding_ctx->download_state == END_DOWNLOAD ? BSCF_LASTDATANOTIFICATION : 0),
1548                 0, 0);
1549     }else {
1550         hres = IInternetProtocolEx_StartEx(PROTOCOLEX(binding->protocol), uri, PROTSINK(binding),
1551                  BINDINF(binding), PI_APARTMENTTHREADED|PI_MIMEVERIFICATION, 0);
1552
1553         TRACE("start ret %08x\n", hres);
1554
1555         if(FAILED(hres) && hres != E_PENDING) {
1556             stop_binding(binding, hres, NULL);
1557             IBinding_Release(BINDING(binding));
1558
1559             return hres;
1560         }
1561     }
1562
1563     while(!(binding->bindf & BINDF_ASYNCHRONOUS) &&
1564           !(binding->state & BINDING_STOPPED)) {
1565         MsgWaitForMultipleObjects(0, NULL, FALSE, 5000, QS_POSTMESSAGE);
1566         while (PeekMessageW(&msg, binding->notif_hwnd, WM_USER, WM_USER+117, PM_REMOVE|PM_NOYIELD)) {
1567             TranslateMessage(&msg);
1568             DispatchMessageW(&msg);
1569         }
1570     }
1571
1572     *ret = binding;
1573     return S_OK;
1574 }
1575
1576 HRESULT bind_to_storage(IUri *uri, IBindCtx *pbc, REFIID riid, void **ppv)
1577 {
1578     Binding *binding = NULL, *binding_ctx;
1579     HRESULT hres;
1580
1581     *ppv = NULL;
1582
1583     binding_ctx = get_bctx_binding(pbc);
1584
1585     hres = start_binding(NULL, binding_ctx, uri, pbc, FALSE, riid, &binding);
1586     if(binding_ctx)
1587         IBinding_Release(BINDING(binding_ctx));
1588     if(FAILED(hres))
1589         return hres;
1590
1591     if(binding->hres == S_OK && binding->stgmed_buf->init) {
1592         if((binding->state & BINDING_STOPPED) && (binding->state & BINDING_LOCKED))
1593             IInternetProtocolEx_UnlockRequest(PROTOCOLEX(binding->protocol));
1594
1595         hres = binding->stgmed_obj->vtbl->get_result(binding->stgmed_obj, binding->bindf, ppv);
1596     }else if(binding->bindf & BINDF_ASYNCHRONOUS) {
1597         hres = MK_S_ASYNCHRONOUS;
1598     }else {
1599         hres = FAILED(binding->hres) ? binding->hres : S_OK;
1600     }
1601
1602     IBinding_Release(BINDING(binding));
1603
1604     return hres;
1605 }
1606
1607 HRESULT bind_to_object(IMoniker *mon, IUri *uri, IBindCtx *pbc, REFIID riid, void **ppv)
1608 {
1609     Binding *binding;
1610     HRESULT hres;
1611
1612     *ppv = NULL;
1613
1614     hres = start_binding(mon, NULL, uri, pbc, TRUE, riid, &binding);
1615     if(FAILED(hres))
1616         return hres;
1617
1618     if(binding->hres != S_OK) {
1619         hres = SUCCEEDED(binding->hres) ? S_OK : binding->hres;
1620     }else if(binding->bindf & BINDF_ASYNCHRONOUS) {
1621         hres = MK_S_ASYNCHRONOUS;
1622     }else {
1623         *ppv = binding->obj;
1624         IUnknown_AddRef(binding->obj);
1625         hres = S_OK;
1626     }
1627
1628     IBinding_Release(BINDING(binding));
1629
1630     return hres;
1631 }