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