dlls/urlmon/binding.c

   1 /*
   2  * Copyright 2005 Jacek Caban
   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 <stdarg.h>
  20
  21 #define COBJMACROS
  22 #define NONAMELESSUNION
  23 #define NONAMELESSSTRUCT
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winuser.h"
  28 #include "ole2.h"
  29 #include "urlmon.h"
  30 #include "urlmon_main.h"
  31
  32 #include "wine/debug.h"
  33 #include "wine/unicode.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
  36
  37 typedef struct ProtocolStream ProtocolStream;
  38
  39 typedef struct {
  40     const IBindingVtbl               *lpBindingVtbl;
  41     const IInternetProtocolSinkVtbl  *lpInternetProtocolSinkVtbl;
  42     const IInternetBindInfoVtbl      *lpInternetBindInfoVtbl;
  43     const IServiceProviderVtbl       *lpServiceProviderVtbl;
  44
  45     LONG ref;
  46
  47     IBindStatusCallback *callback;
  48     IInternetProtocol *protocol;
  49     IServiceProvider *service_provider;
  50     ProtocolStream *stream;
  51
  52     BINDINFO bindinfo;
  53     DWORD bindf;
  54     LPWSTR mime;
  55     LPWSTR url;
  56
  57     DWORD apartment_thread;
  58     HWND notif_hwnd;
  59
  60     STGMEDIUM stgmed;
  61 } Binding;
  62
  63 struct ProtocolStream {
  64     const IStreamVtbl *lpStreamVtbl;
  65
  66     LONG ref;
  67
  68     IInternetProtocol *protocol;
  69
  70     BYTE buf[1024*8];
  71     DWORD buf_size;
  72     BOOL init_buf;
  73 };
  74
  75 #define BINDING(x)   ((IBinding*)               &(x)->lpBindingVtbl)
  76 #define PROTSINK(x)  ((IInternetProtocolSink*)  &(x)->lpInternetProtocolSinkVtbl)
  77 #define BINDINF(x)   ((IInternetBindInfo*)      &(x)->lpInternetBindInfoVtbl)
  78 #define SERVPROV(x)  ((IServiceProvider*)       &(x)->lpServiceProviderVtbl)
  79
  80 #define STREAM(x) ((IStream*) &(x)->lpStreamVtbl)
  81
  82 #define WM_MK_ONPROGRESS (WM_USER+100)
  83 #define WM_MK_CONTINUE   (WM_USER+101)
  84
  85 typedef struct {
  86     Binding *binding;
  87     ULONG progress;
  88     ULONG progress_max;
  89     ULONG status_code;
  90     LPWSTR status_text;
  91 } on_progress_data;
  92
  93 typedef struct {
  94     Binding *binding;
  95     PROTOCOLDATA *data;
  96 } switch_data;
  97
  98 static LRESULT WINAPI notif_wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
  99 {
 100     switch(msg) {
 101     case WM_MK_ONPROGRESS: {
 102         on_progress_data *data = (on_progress_data*)lParam;
 103
 104         TRACE("WM_MK_PROGRESS %p\n", data);
 105
 106         IBindStatusCallback_OnProgress(data->binding->callback, data->progress,
 107                 data->progress_max, data->status_code, data->status_text);
 108
 109         IBinding_Release(BINDING(data->binding));
 110         HeapFree(GetProcessHeap(), 0, data->status_text);
 111         HeapFree(GetProcessHeap(), 0, data);
 112
 113         return 0;
 114     }
 115     case WM_MK_CONTINUE: {
 116         switch_data *data = (switch_data*)lParam;
 117
 118         IInternetProtocol_Continue(data->binding->protocol, data->data);
 119
 120         IBinding_Release(BINDING(data->binding));
 121         HeapFree(GetProcessHeap(), 0, data);
 122         return 0;
 123     }
 124     }
 125
 126     return DefWindowProcW(hwnd, msg, wParam, lParam);
 127 }
 128
 129 static HWND get_notif_hwnd(void)
 130 {
 131     static ATOM wnd_class = 0;
 132     HWND hwnd;
 133
 134     static const WCHAR wszURLMonikerNotificationWindow[] =
 135         {'U','R','L',' ','M','o','n','i','k','e','r',' ',
 136          'N','o','t','i','f','i','c','a','t','i','o','n',' ','W','i','n','d','o','w',0};
 137
 138     if(!wnd_class) {
 139         static WNDCLASSEXW wndclass = {
 140             sizeof(wndclass), 0,
 141             notif_wnd_proc, 0, 0,
 142             NULL, NULL, NULL, NULL, NULL,
 143             wszURLMonikerNotificationWindow,
 144             NULL
 145         };
 146
 147         wndclass.hInstance = URLMON_hInstance;
 148
 149         wnd_class = RegisterClassExW(&wndclass);
 150     }
 151
 152     if(!urlmon_tls)
 153         urlmon_tls = TlsAlloc();
 154
 155     hwnd = TlsGetValue(urlmon_tls);
 156     if(hwnd)
 157         return hwnd;
 158
 159     hwnd = CreateWindowExW(0, MAKEINTATOMW(wnd_class),
 160                            wszURLMonikerNotificationWindow, 0, 0, 0, 0, 0, HWND_MESSAGE,
 161                            NULL, URLMON_hInstance, NULL);
 162     TlsSetValue(urlmon_tls, hwnd);
 163
 164     TRACE("hwnd = %p\n", hwnd);
 165
 166     return hwnd;
 167 }
 168
 169 static void on_progress(Binding *This, ULONG progress, ULONG progress_max,
 170                         ULONG status_code, LPCWSTR status_text)
 171 {
 172     on_progress_data *data;
 173
 174     if(GetCurrentThreadId() == This->apartment_thread) {
 175         IBindStatusCallback_OnProgress(This->callback, progress, progress_max,
 176                                        status_code, status_text);
 177         return;
 178     }
 179
 180     data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data));
 181
 182     IBinding_AddRef(BINDING(This));
 183
 184     data->binding = This;
 185     data->progress = progress;
 186     data->progress_max = progress_max;
 187     data->status_code = status_code;
 188
 189     if(status_text) {
 190         DWORD size = (strlenW(status_text)+1)*sizeof(WCHAR);
 191
 192         data->status_text = HeapAlloc(GetProcessHeap(), 0, size);
 193         memcpy(data->status_text, status_text, size);
 194     }else {
 195         data->status_text = NULL;
 196     }
 197
 198     PostMessageW(This->notif_hwnd, WM_MK_ONPROGRESS, 0, (LPARAM)data);
 199 }
 200
 201 static HRESULT WINAPI HttpNegotiate_QueryInterface(IHttpNegotiate2 *iface,
 202                                                    REFIID riid, void **ppv)
 203 {
 204     *ppv = NULL;
 205
 206     if(IsEqualGUID(&IID_IUnknown, riid)) {
 207         TRACE("(IID_IUnknown %p)\n", ppv);
 208         *ppv = iface;
 209     }else if(IsEqualGUID(&IID_IHttpNegotiate, riid)) {
 210         TRACE("(IID_IHttpNegotiate %p)\n", ppv);
 211         *ppv = iface;
 212     }else if(IsEqualGUID(&IID_IHttpNegotiate2, riid)) {
 213         TRACE("(IID_IHttpNegotiate2 %p)\n", ppv);
 214         *ppv = iface;
 215     }
 216
 217     if(*ppv) {
 218         IHttpNegotiate2_AddRef(iface);
 219         return S_OK;
 220     }
 221
 222     WARN("Unsupported interface %s\n", debugstr_guid(riid));
 223     return E_NOINTERFACE;
 224 }
 225
 226 static ULONG WINAPI HttpNegotiate_AddRef(IHttpNegotiate2 *iface)
 227 {
 228     URLMON_LockModule();
 229     return 2;
 230 }
 231
 232 static ULONG WINAPI HttpNegotiate_Release(IHttpNegotiate2 *iface)
 233 {
 234     URLMON_UnlockModule();
 235     return 1;
 236 }
 237
 238 static HRESULT WINAPI HttpNegotiate_BeginningTransaction(IHttpNegotiate2 *iface,
 239         LPCWSTR szURL, LPCWSTR szHeaders, DWORD dwReserved, LPWSTR *pszAdditionalHeaders)
 240 {
 241     TRACE("(%s %s %ld %p)\n", debugstr_w(szURL), debugstr_w(szHeaders), dwReserved,
 242           pszAdditionalHeaders);
 243
 244     *pszAdditionalHeaders = NULL;
 245     return S_OK;
 246 }
 247
 248 static HRESULT WINAPI HttpNegotiate_OnResponse(IHttpNegotiate2 *iface, DWORD dwResponseCode,
 249         LPCWSTR szResponseHeaders, LPCWSTR szRequestHeaders,
 250         LPWSTR *pszAdditionalRequestHeaders)
 251 {
 252     FIXME("(%ld %s %s %p)\n", dwResponseCode, debugstr_w(szResponseHeaders),
 253           debugstr_w(szRequestHeaders), pszAdditionalRequestHeaders);
 254     return E_NOTIMPL;
 255 }
 256
 257 static HRESULT WINAPI HttpNegotiate_GetRootSecurityId(IHttpNegotiate2 *iface,
 258         BYTE *pbSecurityId, DWORD *pcbSecurityId, DWORD_PTR dwReserved)
 259 {
 260     TRACE("(%p %p %ld)\n", pbSecurityId, pcbSecurityId, dwReserved);
 261
 262     /* That's all we have to do here */
 263     return E_FAIL;
 264 }
 265
 266 static const IHttpNegotiate2Vtbl HttpNegotiate2Vtbl = {
 267     HttpNegotiate_QueryInterface,
 268     HttpNegotiate_AddRef,
 269     HttpNegotiate_Release,
 270     HttpNegotiate_BeginningTransaction,
 271     HttpNegotiate_OnResponse,
 272     HttpNegotiate_GetRootSecurityId
 273 };
 274
 275 static IHttpNegotiate2 HttpNegotiate = { &HttpNegotiate2Vtbl };
 276
 277 #define STREAM_THIS(iface) DEFINE_THIS(ProtocolStream, Stream, iface)
 278
 279 static HRESULT WINAPI ProtocolStream_QueryInterface(IStream *iface,
 280                                                           REFIID riid, void **ppv)
 281 {
 282     ProtocolStream *This = STREAM_THIS(iface);
 283
 284     *ppv = NULL;
 285
 286     if(IsEqualGUID(&IID_IUnknown, riid)) {
 287         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 288         *ppv = STREAM(This);
 289     }else if(IsEqualGUID(&IID_ISequentialStream, riid)) {
 290         TRACE("(%p)->(IID_ISequentialStream %p)\n", This, ppv);
 291         *ppv = STREAM(This);
 292     }else if(IsEqualGUID(&IID_IStream, riid)) {
 293         TRACE("(%p)->(IID_IStream %p)\n", This, ppv);
 294         *ppv = STREAM(This);
 295     }
 296
 297     if(*ppv) {
 298         IStream_AddRef(STREAM(This));
 299         return S_OK;
 300     }
 301
 302     WARN("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 303     return E_NOINTERFACE;
 304 }
 305
 306 static ULONG WINAPI ProtocolStream_AddRef(IStream *iface)
 307 {
 308     ProtocolStream *This = STREAM_THIS(iface);
 309     LONG ref = InterlockedIncrement(&This->ref);
 310
 311     TRACE("(%p) ref=%ld\n", This, ref);
 312
 313     return ref;
 314 }
 315
 316 static ULONG WINAPI ProtocolStream_Release(IStream *iface)
 317 {
 318     ProtocolStream *This = STREAM_THIS(iface);
 319     LONG ref = InterlockedDecrement(&This->ref);
 320
 321     TRACE("(%p) ref=%ld\n", This, ref);
 322
 323     if(!ref) {
 324         IInternetProtocol_Release(This->protocol);
 325         HeapFree(GetProcessHeap(), 0, This);
 326
 327         URLMON_UnlockModule();
 328     }
 329
 330     return ref;
 331 }
 332
 333 static HRESULT WINAPI ProtocolStream_Read(IStream *iface, void *pv,
 334                                          ULONG cb, ULONG *pcbRead)
 335 {
 336     ProtocolStream *This = STREAM_THIS(iface);
 337     DWORD read = 0, pread = 0;
 338     HRESULT hres;
 339
 340     TRACE("(%p)->(%p %ld %p)\n", This, pv, cb, pcbRead);
 341
 342     if(This->buf_size) {
 343         read = cb;
 344
 345         if(read > This->buf_size)
 346             read = This->buf_size;
 347
 348         memcpy(pv, This->buf, read);
 349
 350         if(read < This->buf_size)
 351             memmove(This->buf, This->buf+read, This->buf_size-read);
 352         This->buf_size -= read;
 353     }
 354
 355     if(read == cb) {
 356         *pcbRead = read;
 357         return S_OK;
 358     }
 359
 360     hres = IInternetProtocol_Read(This->protocol, (PBYTE)pv+read, cb-read, &pread);
 361     *pcbRead = read + pread;
 362
 363     if(hres == E_PENDING)
 364         return E_PENDING;
 365     else if(FAILED(hres))
 366         FIXME("Read failed: %08lx\n", hres);
 367
 368     return read || pread ? S_OK : S_FALSE;
 369 }
 370
 371 static HRESULT WINAPI ProtocolStream_Write(IStream *iface, const void *pv,
 372                                           ULONG cb, ULONG *pcbWritten)
 373 {
 374     ProtocolStream *This = STREAM_THIS(iface);
 375
 376     TRACE("(%p)->(%p %ld %p)\n", This, pv, cb, pcbWritten);
 377
 378     return STG_E_ACCESSDENIED;
 379 }
 380
 381 static HRESULT WINAPI ProtocolStream_Seek(IStream *iface, LARGE_INTEGER dlibMove,
 382                                          DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
 383 {
 384     ProtocolStream *This = STREAM_THIS(iface);
 385     FIXME("(%p)->(%ld %08lx %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
 386     return E_NOTIMPL;
 387 }
 388
 389 static HRESULT WINAPI ProtocolStream_SetSize(IStream *iface, ULARGE_INTEGER libNewSize)
 390 {
 391     ProtocolStream *This = STREAM_THIS(iface);
 392     FIXME("(%p)->(%ld)\n", This, libNewSize.u.LowPart);
 393     return E_NOTIMPL;
 394 }
 395
 396 static HRESULT WINAPI ProtocolStream_CopyTo(IStream *iface, IStream *pstm,
 397         ULARGE_INTEGER cb, ULARGE_INTEGER *pcbRead, ULARGE_INTEGER *pcbWritten)
 398 {
 399     ProtocolStream *This = STREAM_THIS(iface);
 400     FIXME("(%p)->(%p %ld %p %p)\n", This, pstm, cb.u.LowPart, pcbRead, pcbWritten);
 401     return E_NOTIMPL;
 402 }
 403
 404 static HRESULT WINAPI ProtocolStream_Commit(IStream *iface, DWORD grfCommitFlags)
 405 {
 406     ProtocolStream *This = STREAM_THIS(iface);
 407
 408     TRACE("(%p)->(%08lx)\n", This, grfCommitFlags);
 409
 410     return E_NOTIMPL;
 411 }
 412
 413 static HRESULT WINAPI ProtocolStream_Revert(IStream *iface)
 414 {
 415     ProtocolStream *This = STREAM_THIS(iface);
 416
 417     TRACE("(%p)\n", This);
 418
 419     return E_NOTIMPL;
 420 }
 421
 422 static HRESULT WINAPI ProtocolStream_LockRegion(IStream *iface, ULARGE_INTEGER libOffset,
 423                                                ULARGE_INTEGER cb, DWORD dwLockType)
 424 {
 425     ProtocolStream *This = STREAM_THIS(iface);
 426     FIXME("(%p)->(%ld %ld %ld)\n", This, libOffset.u.LowPart, cb.u.LowPart, dwLockType);
 427     return E_NOTIMPL;
 428 }
 429
 430 static HRESULT WINAPI ProtocolStream_UnlockRegion(IStream *iface,
 431         ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
 432 {
 433     ProtocolStream *This = STREAM_THIS(iface);
 434     FIXME("(%p)->(%ld %ld %ld)\n", This, libOffset.u.LowPart, cb.u.LowPart, dwLockType);
 435     return E_NOTIMPL;
 436 }
 437
 438 static HRESULT WINAPI ProtocolStream_Stat(IStream *iface, STATSTG *pstatstg,
 439                                          DWORD dwStatFlag)
 440 {
 441     ProtocolStream *This = STREAM_THIS(iface);
 442     FIXME("(%p)->(%p %08lx)\n", This, pstatstg, dwStatFlag);
 443     return E_NOTIMPL;
 444 }
 445
 446 static HRESULT WINAPI ProtocolStream_Clone(IStream *iface, IStream **ppstm)
 447 {
 448     ProtocolStream *This = STREAM_THIS(iface);
 449     FIXME("(%p)->(%p)\n", This, ppstm);
 450     return E_NOTIMPL;
 451 }
 452
 453 #undef STREAM_THIS
 454
 455 static const IStreamVtbl ProtocolStreamVtbl = {
 456     ProtocolStream_QueryInterface,
 457     ProtocolStream_AddRef,
 458     ProtocolStream_Release,
 459     ProtocolStream_Read,
 460     ProtocolStream_Write,
 461     ProtocolStream_Seek,
 462     ProtocolStream_SetSize,
 463     ProtocolStream_CopyTo,
 464     ProtocolStream_Commit,
 465     ProtocolStream_Revert,
 466     ProtocolStream_LockRegion,
 467     ProtocolStream_UnlockRegion,
 468     ProtocolStream_Stat,
 469     ProtocolStream_Clone
 470 };
 471
 472 #define BINDING_THIS(iface) DEFINE_THIS(Binding, Binding, iface)
 473
 474 static ProtocolStream *create_stream(IInternetProtocol *protocol)
 475 {
 476     ProtocolStream *ret = HeapAlloc(GetProcessHeap(), 0, sizeof(ProtocolStream));
 477
 478     ret->lpStreamVtbl = &ProtocolStreamVtbl;
 479     ret->ref = 1;
 480     ret->buf_size = 0;
 481     ret->init_buf = FALSE;
 482
 483     IInternetProtocol_AddRef(protocol);
 484     ret->protocol = protocol;
 485
 486     URLMON_LockModule();
 487
 488     return ret;
 489 }
 490
 491 static void fill_stream_buffer(ProtocolStream *This)
 492 {
 493     DWORD read = 0;
 494     HRESULT hres;
 495
 496     hres = IInternetProtocol_Read(This->protocol, This->buf+This->buf_size,
 497                                   sizeof(This->buf)-This->buf_size, &read);
 498     if(SUCCEEDED(hres)) {
 499         This->buf_size += read;
 500         This->init_buf = TRUE;
 501     }
 502 }
 503
 504 static HRESULT WINAPI Binding_QueryInterface(IBinding *iface, REFIID riid, void **ppv)
 505 {
 506     Binding *This = BINDING_THIS(iface);
 507
 508     *ppv = NULL;
 509
 510     if(IsEqualGUID(&IID_IUnknown, riid)) {
 511         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 512         *ppv = BINDING(This);
 513     }else if(IsEqualGUID(&IID_IBinding, riid)) {
 514         TRACE("(%p)->(IID_IBinding %p)\n", This, ppv);
 515         *ppv = BINDING(This);
 516     }else if(IsEqualGUID(&IID_IInternetProtocolSink, riid)) {
 517         TRACE("(%p)->(IID_IInternetProtocolSink %p)\n", This, ppv);
 518         *ppv = PROTSINK(This);
 519     }else if(IsEqualGUID(&IID_IInternetBindInfo, riid)) {
 520         TRACE("(%p)->(IID_IInternetBindInfo %p)\n", This, ppv);
 521         *ppv = BINDINF(This);
 522     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
 523         TRACE("(%p)->(IID_IServiceProvider %p)\n", This, ppv);
 524         *ppv = SERVPROV(This);
 525     }
 526
 527     if(*ppv) {
 528         IBinding_AddRef(BINDING(This));
 529         return S_OK;
 530     }
 531
 532     WARN("Unsupported interface %s\n", debugstr_guid(riid));
 533     return E_NOINTERFACE;
 534 }
 535
 536 static ULONG WINAPI Binding_AddRef(IBinding *iface)
 537 {
 538     Binding *This = BINDING_THIS(iface);
 539     LONG ref = InterlockedIncrement(&This->ref);
 540
 541     TRACE("(%p) ref=%ld\n", This, ref);
 542
 543     return ref;
 544 }
 545
 546 static ULONG WINAPI Binding_Release(IBinding *iface)
 547 {
 548     Binding *This = BINDING_THIS(iface);
 549     LONG ref = InterlockedDecrement(&This->ref);
 550
 551     TRACE("(%p) ref=%ld\n", This, ref);
 552
 553     if(!ref) {
 554         if(This->callback)
 555             IBindStatusCallback_Release(This->callback);
 556         if(This->protocol)
 557             IInternetProtocol_Release(This->protocol);
 558         if(This->service_provider)
 559             IServiceProvider_Release(This->service_provider);
 560         if(This->stream)
 561             IStream_Release(STREAM(This->stream));
 562
 563         ReleaseBindInfo(&This->bindinfo);
 564         HeapFree(GetProcessHeap(), 0, This->mime);
 565         HeapFree(GetProcessHeap(), 0, This->url);
 566
 567         HeapFree(GetProcessHeap(), 0, This);
 568
 569         URLMON_UnlockModule();
 570     }
 571
 572     return ref;
 573 }
 574
 575 static HRESULT WINAPI Binding_Abort(IBinding *iface)
 576 {
 577     Binding *This = BINDING_THIS(iface);
 578     FIXME("(%p)\n", This);
 579     return E_NOTIMPL;
 580 }
 581
 582 static HRESULT WINAPI Binding_Suspend(IBinding *iface)
 583 {
 584     Binding *This = BINDING_THIS(iface);
 585     FIXME("(%p)\n", This);
 586     return E_NOTIMPL;
 587 }
 588
 589 static HRESULT WINAPI Binding_Resume(IBinding *iface)
 590 {
 591     Binding *This = BINDING_THIS(iface);
 592     FIXME("(%p)\n", This);
 593     return E_NOTIMPL;
 594 }
 595
 596 static HRESULT WINAPI Binding_SetPriority(IBinding *iface, LONG nPriority)
 597 {
 598     Binding *This = BINDING_THIS(iface);
 599     FIXME("(%p)->(%ld)\n", This, nPriority);
 600     return E_NOTIMPL;
 601 }
 602
 603 static HRESULT WINAPI Binding_GetPriority(IBinding *iface, LONG *pnPriority)
 604 {
 605     Binding *This = BINDING_THIS(iface);
 606     FIXME("(%p)->(%p)\n", This, pnPriority);
 607     return E_NOTIMPL;
 608 }
 609
 610 static HRESULT WINAPI Binding_GetBindResult(IBinding *iface, CLSID *pclsidProtocol,
 611         DWORD *pdwResult, LPOLESTR *pszResult, DWORD *pdwReserved)
 612 {
 613     Binding *This = BINDING_THIS(iface);
 614     FIXME("(%p)->(%p %p %p %p)\n", This, pclsidProtocol, pdwResult, pszResult, pdwReserved);
 615     return E_NOTIMPL;
 616 }
 617
 618 #undef BINDING_THIS
 619
 620 static const IBindingVtbl BindingVtbl = {
 621     Binding_QueryInterface,
 622     Binding_AddRef,
 623     Binding_Release,
 624     Binding_Abort,
 625     Binding_Suspend,
 626     Binding_Resume,
 627     Binding_SetPriority,
 628     Binding_GetPriority,
 629     Binding_GetBindResult
 630 };
 631
 632 #define PROTSINK_THIS(iface) DEFINE_THIS(Binding, InternetProtocolSink, iface)
 633
 634 static HRESULT WINAPI InternetProtocolSink_QueryInterface(IInternetProtocolSink *iface,
 635         REFIID riid, void **ppv)
 636 {
 637     Binding *This = PROTSINK_THIS(iface);
 638     return IBinding_QueryInterface(BINDING(This), riid, ppv);
 639 }
 640
 641 static ULONG WINAPI InternetProtocolSink_AddRef(IInternetProtocolSink *iface)
 642 {
 643     Binding *This = PROTSINK_THIS(iface);
 644     return IBinding_AddRef(BINDING(This));
 645 }
 646
 647 static ULONG WINAPI InternetProtocolSink_Release(IInternetProtocolSink *iface)
 648 {
 649     Binding *This = PROTSINK_THIS(iface);
 650     return IBinding_Release(BINDING(This));
 651 }
 652
 653 static HRESULT WINAPI InternetProtocolSink_Switch(IInternetProtocolSink *iface,
 654         PROTOCOLDATA *pProtocolData)
 655 {
 656     Binding *This = PROTSINK_THIS(iface);
 657     switch_data *data;
 658
 659     TRACE("(%p)->(%p)\n", This, pProtocolData);
 660
 661     data = HeapAlloc(GetProcessHeap(), 0, sizeof(switch_data));
 662
 663     IBinding_AddRef(BINDING(This));
 664     data->binding = This;
 665     data->data = pProtocolData;
 666
 667     PostMessageW(This->notif_hwnd, WM_MK_CONTINUE, 0, (LPARAM)data);
 668
 669     return S_OK;
 670 }
 671
 672 static HRESULT WINAPI InternetProtocolSink_ReportProgress(IInternetProtocolSink *iface,
 673         ULONG ulStatusCode, LPCWSTR szStatusText)
 674 {
 675     Binding *This = PROTSINK_THIS(iface);
 676
 677     TRACE("(%p)->(%lu %s)\n", This, ulStatusCode, debugstr_w(szStatusText));
 678
 679     switch(ulStatusCode) {
 680     case BINDSTATUS_FINDINGRESOURCE:
 681         on_progress(This, 0, 0, BINDSTATUS_FINDINGRESOURCE, szStatusText);
 682         break;
 683     case BINDSTATUS_CONNECTING:
 684         on_progress(This, 0, 0, BINDSTATUS_CONNECTING, szStatusText);
 685         break;
 686     case BINDSTATUS_MIMETYPEAVAILABLE: {
 687         int len = strlenW(szStatusText)+1;
 688         This->mime = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
 689         memcpy(This->mime, szStatusText, len*sizeof(WCHAR));
 690         break;
 691     }
 692     case BINDSTATUS_SENDINGREQUEST:
 693         on_progress(This, 0, 0, BINDSTATUS_SENDINGREQUEST, szStatusText);
 694         break;
 695     case BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE:
 696         on_progress(This, 0, 0, BINDSTATUS_MIMETYPEAVAILABLE, szStatusText);
 697         break;
 698     case BINDSTATUS_CACHEFILENAMEAVAILABLE:
 699         break;
 700     default:
 701         FIXME("Unhandled status code %ld\n", ulStatusCode);
 702         return E_NOTIMPL;
 703     };
 704
 705     return S_OK;
 706 }
 707
 708 static HRESULT WINAPI InternetProtocolSink_ReportData(IInternetProtocolSink *iface,
 709         DWORD grfBSCF, ULONG ulProgress, ULONG ulProgressMax)
 710 {
 711     Binding *This = PROTSINK_THIS(iface);
 712     FORMATETC formatetc;
 713
 714     TRACE("(%p)->(%ld %lu %lu)\n", This, grfBSCF, ulProgress, ulProgressMax);
 715
 716     if(grfBSCF & BSCF_FIRSTDATANOTIFICATION) {
 717         if(This->mime)
 718             IBindStatusCallback_OnProgress(This->callback, ulProgress, ulProgressMax,
 719                                            BINDSTATUS_MIMETYPEAVAILABLE, This->mime);
 720         IBindStatusCallback_OnProgress(This->callback, ulProgress, ulProgressMax,
 721                                        BINDSTATUS_BEGINDOWNLOADDATA, This->url);
 722     }
 723
 724     if(grfBSCF & BSCF_LASTDATANOTIFICATION)
 725         IBindStatusCallback_OnProgress(This->callback, ulProgress, ulProgressMax,
 726                                        BINDSTATUS_ENDDOWNLOADDATA, This->url);
 727
 728     if(grfBSCF & BSCF_FIRSTDATANOTIFICATION)
 729         IInternetProtocol_LockRequest(This->protocol, 0);
 730
 731     fill_stream_buffer(This->stream);
 732
 733     formatetc.cfFormat = 0; /* FIXME */
 734     formatetc.ptd = NULL;
 735     formatetc.dwAspect = 1;
 736     formatetc.lindex = -1;
 737     formatetc.tymed = TYMED_ISTREAM;
 738
 739     IBindStatusCallback_OnDataAvailable(This->callback, grfBSCF, This->stream->buf_size,
 740             &formatetc, &This->stgmed);
 741
 742     if(grfBSCF & BSCF_LASTDATANOTIFICATION)
 743         IBindStatusCallback_OnStopBinding(This->callback, S_OK, NULL);
 744
 745     return S_OK;
 746 }
 747
 748 static HRESULT WINAPI InternetProtocolSink_ReportResult(IInternetProtocolSink *iface,
 749         HRESULT hrResult, DWORD dwError, LPCWSTR szResult)
 750 {
 751     Binding *This = PROTSINK_THIS(iface);
 752
 753     TRACE("(%p)->(%08lx %ld %s)\n", This, hrResult, dwError, debugstr_w(szResult));
 754
 755     IInternetProtocol_Terminate(This->protocol, 0);
 756     return S_OK;
 757 }
 758
 759 #undef PROTSINK_THIS
 760
 761 static const IInternetProtocolSinkVtbl InternetProtocolSinkVtbl = {
 762     InternetProtocolSink_QueryInterface,
 763     InternetProtocolSink_AddRef,
 764     InternetProtocolSink_Release,
 765     InternetProtocolSink_Switch,
 766     InternetProtocolSink_ReportProgress,
 767     InternetProtocolSink_ReportData,
 768     InternetProtocolSink_ReportResult
 769 };
 770
 771 #define BINDINF_THIS(iface) DEFINE_THIS(Binding, InternetBindInfo, iface)
 772
 773 static HRESULT WINAPI InternetBindInfo_QueryInterface(IInternetBindInfo *iface,
 774         REFIID riid, void **ppv)
 775 {
 776     Binding *This = BINDINF_THIS(iface);
 777     return IBinding_QueryInterface(BINDING(This), riid, ppv);
 778 }
 779
 780 static ULONG WINAPI InternetBindInfo_AddRef(IInternetBindInfo *iface)
 781 {
 782     Binding *This = BINDINF_THIS(iface);
 783     return IBinding_AddRef(BINDING(This));
 784 }
 785
 786 static ULONG WINAPI InternetBindInfo_Release(IInternetBindInfo *iface)
 787 {
 788     Binding *This = BINDINF_THIS(iface);
 789     return IBinding_Release(BINDING(This));
 790 }
 791
 792 static HRESULT WINAPI InternetBindInfo_GetBindInfo(IInternetBindInfo *iface,
 793         DWORD *grfBINDF, BINDINFO *pbindinfo)
 794 {
 795     Binding *This = BINDINF_THIS(iface);
 796
 797     TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
 798
 799     *grfBINDF = This->bindf;
 800
 801     memcpy(pbindinfo, &This->bindinfo, sizeof(BINDINFO));
 802
 803     if(pbindinfo->szExtraInfo || pbindinfo->szCustomVerb)
 804         FIXME("copy strings\n");
 805
 806     if(pbindinfo->pUnk)
 807         IUnknown_AddRef(pbindinfo->pUnk);
 808
 809     return S_OK;
 810 }
 811
 812 static HRESULT WINAPI InternetBindInfo_GetBindString(IInternetBindInfo *iface,
 813         ULONG ulStringType, LPOLESTR *ppwzStr, ULONG cEl, ULONG *pcElFetched)
 814 {
 815     Binding *This = BINDINF_THIS(iface);
 816
 817     TRACE("(%p)->(%ld %p %ld %p)\n", This, ulStringType, ppwzStr, cEl, pcElFetched);
 818
 819     switch(ulStringType) {
 820     case BINDSTRING_ACCEPT_MIMES: {
 821         static const WCHAR wszMimes[] = {'*','/','*',0};
 822
 823         if(!ppwzStr || !pcElFetched)
 824             return E_INVALIDARG;
 825
 826         ppwzStr[0] = CoTaskMemAlloc(sizeof(wszMimes));
 827         memcpy(ppwzStr[0], wszMimes, sizeof(wszMimes));
 828         *pcElFetched = 1;
 829         return S_OK;
 830     }
 831     case BINDSTRING_USER_AGENT: {
 832         IInternetBindInfo *bindinfo = NULL;
 833         HRESULT hres;
 834
 835         hres = IBindStatusCallback_QueryInterface(This->callback, &IID_IInternetBindInfo,
 836                                                   (void**)&bindinfo);
 837         if(FAILED(hres))
 838             return hres;
 839
 840         hres = IInternetBindInfo_GetBindString(bindinfo, ulStringType, ppwzStr,
 841                                                cEl, pcElFetched);
 842         IInternetBindInfo_Release(bindinfo);
 843
 844         return hres;
 845     }
 846     }
 847
 848     FIXME("not supported string type %ld\n", ulStringType);
 849     return E_NOTIMPL;
 850 }
 851
 852 #undef BINDF_THIS
 853
 854 static const IInternetBindInfoVtbl InternetBindInfoVtbl = {
 855     InternetBindInfo_QueryInterface,
 856     InternetBindInfo_AddRef,
 857     InternetBindInfo_Release,
 858     InternetBindInfo_GetBindInfo,
 859     InternetBindInfo_GetBindString
 860 };
 861
 862 #define SERVPROV_THIS(iface) DEFINE_THIS(Binding, ServiceProvider, iface)
 863
 864 static HRESULT WINAPI ServiceProvider_QueryInterface(IServiceProvider *iface,
 865         REFIID riid, void **ppv)
 866 {
 867     Binding *This = SERVPROV_THIS(iface);
 868     return IBinding_QueryInterface(BINDING(This), riid, ppv);
 869 }
 870
 871 static ULONG WINAPI ServiceProvider_AddRef(IServiceProvider *iface)
 872 {
 873     Binding *This = SERVPROV_THIS(iface);
 874     return IBinding_AddRef(BINDING(This));
 875 }
 876
 877 static ULONG WINAPI ServiceProvider_Release(IServiceProvider *iface)
 878 {
 879     Binding *This = SERVPROV_THIS(iface);
 880     return IBinding_Release(BINDING(This));
 881 }
 882
 883 static HRESULT WINAPI ServiceProvider_QueryService(IServiceProvider *iface,
 884         REFGUID guidService, REFIID riid, void **ppv)
 885 {
 886     Binding *This = SERVPROV_THIS(iface);
 887     HRESULT hres;
 888
 889     TRACE("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
 890
 891     if(This->service_provider) {
 892         hres = IServiceProvider_QueryService(This->service_provider, guidService,
 893                                              riid, ppv);
 894         if(SUCCEEDED(hres))
 895             return hres;
 896     }
 897
 898     if(IsEqualGUID(&IID_IHttpNegotiate, guidService)
 899        || IsEqualGUID(&IID_IHttpNegotiate2, guidService))
 900         return IHttpNegotiate2_QueryInterface(&HttpNegotiate, riid, ppv);
 901
 902     WARN("unknown service %s\n", debugstr_guid(guidService));
 903     return E_NOTIMPL;
 904 }
 905
 906 #undef SERVPROV_THIS
 907
 908 static const IServiceProviderVtbl ServiceProviderVtbl = {
 909     ServiceProvider_QueryInterface,
 910     ServiceProvider_AddRef,
 911     ServiceProvider_Release,
 912     ServiceProvider_QueryService
 913 };
 914
 915 static HRESULT get_callback(IBindCtx *pbc, IBindStatusCallback **callback)
 916 {
 917     HRESULT hres;
 918
 919     static WCHAR wszBSCBHolder[] = { '_','B','S','C','B','_','H','o','l','d','e','r','_',0 };
 920
 921     hres = IBindCtx_GetObjectParam(pbc, wszBSCBHolder, (IUnknown**)callback);
 922     if(FAILED(hres))
 923         return MK_E_SYNTAX;
 924
 925     return S_OK;
 926 }
 927
 928 static HRESULT get_protocol(Binding *This, LPCWSTR url)
 929 {
 930     IClassFactory *cf = NULL;
 931     HRESULT hres;
 932
 933     hres = IBindStatusCallback_QueryInterface(This->callback, &IID_IInternetProtocol,
 934             (void**)&This->protocol);
 935     if(SUCCEEDED(hres))
 936         return S_OK;
 937
 938     if(This->service_provider) {
 939         hres = IServiceProvider_QueryService(This->service_provider, &IID_IInternetProtocol,
 940                 &IID_IInternetProtocol, (void**)&This->protocol);
 941         if(SUCCEEDED(hres))
 942             return S_OK;
 943     }
 944
 945     hres = get_protocol_handler(url, &cf);
 946     if(FAILED(hres))
 947         return hres;
 948
 949     hres = IClassFactory_CreateInstance(cf, NULL, &IID_IInternetProtocol, (void**)&This->protocol);
 950     IClassFactory_Release(cf);
 951
 952     return hres;
 953 }
 954
 955 static HRESULT Binding_Create(LPCWSTR url, IBindCtx *pbc, REFIID riid, Binding **binding)
 956 {
 957     Binding *ret;
 958     int len;
 959     HRESULT hres;
 960
 961     static const WCHAR wszFile[] = {'f','i','l','e',':'};
 962
 963     if(!IsEqualGUID(&IID_IStream, riid)) {
 964         FIXME("Unsupported riid %s\n", debugstr_guid(riid));
 965         return E_NOTIMPL;
 966     }
 967
 968     URLMON_LockModule();
 969
 970     ret = HeapAlloc(GetProcessHeap(), 0, sizeof(Binding));
 971
 972     ret->lpBindingVtbl              = &BindingVtbl;
 973     ret->lpInternetProtocolSinkVtbl = &InternetProtocolSinkVtbl;
 974     ret->lpInternetBindInfoVtbl     = &InternetBindInfoVtbl;
 975     ret->lpServiceProviderVtbl      = &ServiceProviderVtbl;
 976
 977     ret->ref = 1;
 978
 979     ret->callback = NULL;
 980     ret->protocol = NULL;
 981     ret->service_provider = NULL;
 982     ret->stream = NULL;
 983     ret->mime = NULL;
 984     ret->url = NULL;
 985     ret->apartment_thread = GetCurrentThreadId();
 986     ret->notif_hwnd = get_notif_hwnd();
 987
 988     memset(&ret->bindinfo, 0, sizeof(BINDINFO));
 989     ret->bindinfo.cbSize = sizeof(BINDINFO);
 990     ret->bindf = 0;
 991
 992     hres = get_callback(pbc, &ret->callback);
 993     if(FAILED(hres)) {
 994         WARN("Could not get IBindStatusCallback\n");
 995         IBinding_Release(BINDING(ret));
 996         return hres;
 997     }
 998
 999     IBindStatusCallback_QueryInterface(ret->callback, &IID_IServiceProvider,
1000                                        (void**)&ret->service_provider);
1001
1002     hres = get_protocol(ret, url);
1003     if(FAILED(hres)) {
1004         WARN("Could not get protocol handler\n");
1005         IBinding_Release(BINDING(ret));
1006         return hres;
1007     }
1008
1009     hres = IBindStatusCallback_GetBindInfo(ret->callback, &ret->bindf, &ret->bindinfo);
1010     if(FAILED(hres)) {
1011         WARN("GetBindInfo failed: %08lx\n", hres);
1012         IBinding_Release(BINDING(ret));
1013         return hres;
1014     }
1015
1016     ret->bindf |= BINDF_FROMURLMON;
1017
1018     len = strlenW(url)+1;
1019
1020     if(len < sizeof(wszFile)/sizeof(WCHAR) || memcmp(wszFile, url, sizeof(wszFile)))
1021         ret->bindf |= BINDF_NEEDFILE;
1022
1023     ret->url = HeapAlloc(GetProcessHeap(), 0, len*sizeof(WCHAR));
1024     memcpy(ret->url, url, len*sizeof(WCHAR));
1025
1026     ret->stream = create_stream(ret->protocol);
1027     ret->stgmed.tymed = TYMED_ISTREAM;
1028     ret->stgmed.u.pstm = STREAM(ret->stream);
1029     ret->stgmed.pUnkForRelease = (IUnknown*)BINDING(ret); /* NOTE: Windows uses other IUnknown */
1030
1031     *binding = ret;
1032     return S_OK;
1033 }
1034
1035 HRESULT start_binding(LPCWSTR url, IBindCtx *pbc, REFIID riid, void **ppv)
1036 {
1037     Binding *binding = NULL;
1038     HRESULT hres;
1039
1040     *ppv = NULL;
1041
1042     hres = Binding_Create(url, pbc, riid, &binding);
1043     if(FAILED(hres))
1044         return hres;
1045
1046     hres = IBindStatusCallback_OnStartBinding(binding->callback, 0, BINDING(binding));
1047     if(FAILED(hres)) {
1048         WARN("OnStartBinding failed: %08lx\n", hres);
1049         IBindStatusCallback_OnStopBinding(binding->callback, 0x800c0008, NULL);
1050         IBinding_Release(BINDING(binding));
1051         return hres;
1052     }
1053
1054     hres = IInternetProtocol_Start(binding->protocol, url, PROTSINK(binding),
1055              BINDINF(binding), 0, 0);
1056
1057     if(FAILED(hres)) {
1058         WARN("Start failed: %08lx\n", hres);
1059
1060         IInternetProtocol_Terminate(binding->protocol, 0);
1061         IBindStatusCallback_OnStopBinding(binding->callback, S_OK, NULL);
1062         IBinding_Release(BINDING(binding));
1063
1064         return hres;
1065     }
1066
1067     if(binding->stream->init_buf) {
1068         IInternetProtocol_UnlockRequest(binding->protocol);
1069
1070         IStream_AddRef(STREAM(binding->stream));
1071         *ppv = binding->stream;
1072
1073         hres = S_OK;
1074     }else {
1075         hres = MK_S_ASYNCHRONOUS;
1076     }
1077
1078     IBinding_Release(BINDING(binding));
1079
1080     return hres;
1081 }