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