dlls/urlmon/bindprot.c

   1 /*
   2  * Copyright 2007-2009 Jacek Caban for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "urlmon_main.h"
  20 #include "wine/debug.h"
  21
  22 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
  23
  24 typedef void (*task_proc_t)(BindProtocol*,task_header_t*);
  25
  26 struct _task_header_t {
  27     task_proc_t proc;
  28     task_header_t *next;
  29 };
  30
  31 #define BUFFER_SIZE     2048
  32 #define MIME_TEST_SIZE  255
  33
  34 #define WM_MK_CONTINUE   (WM_USER+101)
  35 #define WM_MK_RELEASE    (WM_USER+102)
  36
  37 static void process_tasks(BindProtocol *This)
  38 {
  39     task_header_t *task;
  40
  41     while(1) {
  42         EnterCriticalSection(&This->section);
  43
  44         task = This->task_queue_head;
  45         if(task) {
  46             This->task_queue_head = task->next;
  47             if(!This->task_queue_head)
  48                 This->task_queue_tail = NULL;
  49         }
  50
  51         LeaveCriticalSection(&This->section);
  52
  53         if(!task)
  54             break;
  55
  56         This->continue_call++;
  57         task->proc(This, task);
  58         This->continue_call--;
  59     }
  60 }
  61
  62 static LRESULT WINAPI notif_wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
  63 {
  64     switch(msg) {
  65     case WM_MK_CONTINUE: {
  66         BindProtocol *This = (BindProtocol*)lParam;
  67
  68         process_tasks(This);
  69
  70         IInternetProtocolEx_Release(&This->IInternetProtocolEx_iface);
  71         return 0;
  72     }
  73     case WM_MK_RELEASE: {
  74         tls_data_t *data = get_tls_data();
  75
  76         if(!--data->notif_hwnd_cnt) {
  77             DestroyWindow(hwnd);
  78             data->notif_hwnd = NULL;
  79         }
  80     }
  81     }
  82
  83     return DefWindowProcW(hwnd, msg, wParam, lParam);
  84 }
  85
  86 static ATOM notif_wnd_class;
  87
  88 static BOOL WINAPI register_notif_wnd_class(INIT_ONCE *once, void *param, void **context)
  89 {
  90     static WNDCLASSEXW wndclass = {
  91         sizeof(wndclass), 0, notif_wnd_proc, 0, 0,
  92         NULL, NULL, NULL, NULL, NULL,
  93         L"URL Moniker Notification Window", NULL
  94     };
  95
  96     wndclass.hInstance = hProxyDll;
  97     notif_wnd_class = RegisterClassExW(&wndclass);
  98     return TRUE;
  99 }
 100
 101 void unregister_notif_wnd_class(void)
 102 {
 103     if(notif_wnd_class)
 104         UnregisterClassW(MAKEINTRESOURCEW(notif_wnd_class), hProxyDll);
 105 }
 106
 107 HWND get_notif_hwnd(void)
 108 {
 109     tls_data_t *tls_data;
 110
 111     static INIT_ONCE init_once = INIT_ONCE_STATIC_INIT;
 112
 113     tls_data = get_tls_data();
 114     if(!tls_data)
 115         return NULL;
 116
 117     if(tls_data->notif_hwnd_cnt) {
 118         tls_data->notif_hwnd_cnt++;
 119         return tls_data->notif_hwnd;
 120     }
 121
 122     InitOnceExecuteOnce(&init_once, register_notif_wnd_class, NULL, NULL);
 123     if(!notif_wnd_class)
 124         return NULL;
 125
 126     tls_data->notif_hwnd = CreateWindowExW(0, MAKEINTRESOURCEW(notif_wnd_class),
 127             L"URL Moniker Notification Window", 0, 0, 0, 0, 0, HWND_MESSAGE,
 128             NULL, hProxyDll, NULL);
 129     if(tls_data->notif_hwnd)
 130         tls_data->notif_hwnd_cnt++;
 131
 132     TRACE("hwnd = %p\n", tls_data->notif_hwnd);
 133
 134     return tls_data->notif_hwnd;
 135 }
 136
 137 void release_notif_hwnd(HWND hwnd)
 138 {
 139     tls_data_t *data = get_tls_data();
 140
 141     if(!data)
 142         return;
 143
 144     if(data->notif_hwnd != hwnd) {
 145         PostMessageW(data->notif_hwnd, WM_MK_RELEASE, 0, 0);
 146         return;
 147     }
 148
 149     if(!--data->notif_hwnd_cnt) {
 150         DestroyWindow(data->notif_hwnd);
 151         data->notif_hwnd = NULL;
 152     }
 153 }
 154
 155 static void push_task(BindProtocol *This, task_header_t *task, task_proc_t proc)
 156 {
 157     BOOL do_post = FALSE;
 158
 159     task->proc = proc;
 160     task->next = NULL;
 161
 162     EnterCriticalSection(&This->section);
 163
 164     if(This->task_queue_tail) {
 165         This->task_queue_tail->next = task;
 166         This->task_queue_tail = task;
 167     }else {
 168         This->task_queue_tail = This->task_queue_head = task;
 169         do_post = !This->continue_call;
 170     }
 171
 172     LeaveCriticalSection(&This->section);
 173
 174     if(do_post) {
 175         IInternetProtocolEx_AddRef(&This->IInternetProtocolEx_iface);
 176         PostMessageW(This->notif_hwnd, WM_MK_CONTINUE, 0, (LPARAM)This);
 177     }
 178 }
 179
 180 static inline BOOL is_apartment_thread(BindProtocol *This)
 181 {
 182     return This->apartment_thread == GetCurrentThreadId();
 183 }
 184
 185 static inline BOOL do_direct_notif(BindProtocol *This)
 186 {
 187     return !(This->pi & PI_APARTMENTTHREADED) || (is_apartment_thread(This) && !This->continue_call);
 188 }
 189
 190 static HRESULT handle_mime_filter(BindProtocol *This, IInternetProtocol *mime_filter)
 191 {
 192     PROTOCOLFILTERDATA filter_data = { sizeof(PROTOCOLFILTERDATA), NULL, NULL, NULL, 0 };
 193     HRESULT hres;
 194
 195     hres = IInternetProtocol_QueryInterface(mime_filter, &IID_IInternetProtocolSink, (void**)&This->protocol_sink_handler);
 196     if(FAILED(hres)) {
 197         This->protocol_sink_handler = &This->default_protocol_handler.IInternetProtocolSink_iface;
 198         return hres;
 199     }
 200
 201     IInternetProtocol_AddRef(mime_filter);
 202     This->protocol_handler = mime_filter;
 203
 204     filter_data.pProtocol = &This->default_protocol_handler.IInternetProtocol_iface;
 205     hres = IInternetProtocol_Start(mime_filter, This->mime, &This->default_protocol_handler.IInternetProtocolSink_iface,
 206             &This->IInternetBindInfo_iface, PI_FILTER_MODE|PI_FORCE_ASYNC,
 207             (HANDLE_PTR)&filter_data);
 208     if(FAILED(hres)) {
 209         IInternetProtocolSink_Release(This->protocol_sink_handler);
 210         IInternetProtocol_Release(This->protocol_handler);
 211         This->protocol_sink_handler = &This->default_protocol_handler.IInternetProtocolSink_iface;
 212         This->protocol_handler = &This->default_protocol_handler.IInternetProtocol_iface;
 213         return hres;
 214     }
 215
 216     /* NOTE: IE9 calls it on the new protocol_sink. It doesn't make sense so it seems to be a bug there. */
 217     IInternetProtocolSink_ReportProgress(This->protocol_sink, BINDSTATUS_LOADINGMIMEHANDLER, NULL);
 218
 219     return S_OK;
 220 }
 221
 222 static void mime_available(BindProtocol *This, LPCWSTR mime, BOOL verified)
 223 {
 224     IInternetProtocol *mime_filter;
 225     HRESULT hres;
 226
 227     free(This->mime);
 228     This->mime = wcsdup(mime);
 229
 230     if(This->protocol_handler==&This->default_protocol_handler.IInternetProtocol_iface
 231             && (mime_filter = get_mime_filter(mime))) {
 232         TRACE("Got mime filter for %s\n", debugstr_w(mime));
 233
 234         hres = handle_mime_filter(This, mime_filter);
 235         IInternetProtocol_Release(mime_filter);
 236         if(FAILED(hres))
 237             FIXME("MIME filter failed: %08lx\n", hres);
 238     }
 239
 240     if(This->reported_mime || verified || !(This->pi & PI_MIMEVERIFICATION)) {
 241         This->reported_mime = TRUE;
 242         IInternetProtocolSink_ReportProgress(This->protocol_sink, BINDSTATUS_MIMETYPEAVAILABLE, mime);
 243     }
 244 }
 245
 246 static inline BindProtocol *impl_from_IInternetProtocolEx(IInternetProtocolEx *iface)
 247 {
 248     return CONTAINING_RECORD(iface, BindProtocol, IInternetProtocolEx_iface);
 249 }
 250
 251 static HRESULT WINAPI BindProtocol_QueryInterface(IInternetProtocolEx *iface, REFIID riid, void **ppv)
 252 {
 253     BindProtocol *This = impl_from_IInternetProtocolEx(iface);
 254
 255     *ppv = NULL;
 256     if(IsEqualGUID(&IID_IUnknown, riid)) {
 257         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 258         *ppv = &This->IInternetProtocolEx_iface;
 259     }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) {
 260         TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", This, ppv);
 261         *ppv = &This->IInternetProtocolEx_iface;
 262     }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
 263         TRACE("(%p)->(IID_IInternetProtocol %p)\n", This, ppv);
 264         *ppv = &This->IInternetProtocolEx_iface;
 265     }else if(IsEqualGUID(&IID_IInternetProtocolEx, riid)) {
 266         TRACE("(%p)->(IID_IInternetProtocolEx %p)\n", This, ppv);
 267         *ppv = &This->IInternetProtocolEx_iface;
 268     }else if(IsEqualGUID(&IID_IInternetBindInfo, riid)) {
 269         TRACE("(%p)->(IID_IInternetBindInfo %p)\n", This, ppv);
 270         *ppv = &This->IInternetBindInfo_iface;
 271     }else if(IsEqualGUID(&IID_IInternetPriority, riid)) {
 272         TRACE("(%p)->(IID_IInternetPriority %p)\n", This, ppv);
 273         *ppv = &This->IInternetPriority_iface;
 274     }else if(IsEqualGUID(&IID_IAuthenticate, riid)) {
 275         FIXME("(%p)->(IID_IAuthenticate %p)\n", This, ppv);
 276     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
 277         TRACE("(%p)->(IID_IServiceProvider %p)\n", This, ppv);
 278         *ppv = &This->IServiceProvider_iface;
 279     }else if(IsEqualGUID(&IID_IInternetProtocolSink, riid)) {
 280         TRACE("(%p)->(IID_IInternetProtocolSink %p)\n", This, ppv);
 281         *ppv = &This->IInternetProtocolSink_iface;
 282     }else if(This->protocol_unk) {
 283         HRESULT hres;
 284         hres = IUnknown_QueryInterface(This->protocol_unk, riid, ppv);
 285         TRACE("(%p) aggregated handler returned %08lx for %s\n", This, hres, debugstr_guid(riid));
 286         return hres;
 287     }else {
 288         WARN("not supported interface %s\n", debugstr_guid(riid));
 289     }
 290
 291     if(!*ppv)
 292         return E_NOINTERFACE;
 293
 294     IUnknown_AddRef((IUnknown*)*ppv);
 295     return S_OK;
 296 }
 297
 298 static ULONG WINAPI BindProtocol_AddRef(IInternetProtocolEx *iface)
 299 {
 300     BindProtocol *This = impl_from_IInternetProtocolEx(iface);
 301     LONG ref = InterlockedIncrement(&This->ref);
 302     TRACE("(%p) ref=%ld\n", This, ref);
 303     return ref;
 304 }
 305
 306 static void release_protocol_handler(BindProtocol *This)
 307 {
 308     if(This->protocol) {
 309         IInternetProtocol_Release(This->protocol);
 310         This->protocol = NULL;
 311     }
 312     if(This->protocol_handler && This->protocol_handler != &This->default_protocol_handler.IInternetProtocol_iface) {
 313         IInternetProtocol_Release(This->protocol_handler);
 314         This->protocol_handler = &This->default_protocol_handler.IInternetProtocol_iface;
 315     }
 316     if(This->protocol_sink_handler &&
 317        This->protocol_sink_handler != &This->default_protocol_handler.IInternetProtocolSink_iface) {
 318         IInternetProtocolSink_Release(This->protocol_sink_handler);
 319         This->protocol_sink_handler = &This->default_protocol_handler.IInternetProtocolSink_iface;
 320     }
 321     if(This->protocol_unk) {
 322         IUnknown_Release(This->protocol_unk);
 323         This->protocol_unk = NULL;
 324     }
 325 }
 326
 327 static ULONG WINAPI BindProtocol_Release(IInternetProtocolEx *iface)
 328 {
 329     BindProtocol *This = impl_from_IInternetProtocolEx(iface);
 330     LONG ref = InterlockedDecrement(&This->ref);
 331
 332     TRACE("(%p) ref=%ld\n", This, ref);
 333
 334     if(!ref) {
 335         release_protocol_handler(This);
 336         if(This->redirect_callback)
 337             IBindCallbackRedirect_Release(This->redirect_callback);
 338         if(This->bind_info)
 339             IInternetBindInfo_Release(This->bind_info);
 340         if(This->uri)
 341             IUri_Release(This->uri);
 342         SysFreeString(This->display_uri);
 343
 344         set_binding_sink(This, NULL, NULL);
 345
 346         if(This->notif_hwnd)
 347             release_notif_hwnd(This->notif_hwnd);
 348         This->section.DebugInfo->Spare[0] = 0;
 349         DeleteCriticalSection(&This->section);
 350
 351         free(This->mime);
 352         free(This);
 353
 354         URLMON_UnlockModule();
 355     }
 356
 357     return ref;
 358 }
 359
 360 static HRESULT WINAPI BindProtocol_Start(IInternetProtocolEx *iface, LPCWSTR szUrl,
 361         IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
 362         DWORD grfPI, HANDLE_PTR dwReserved)
 363 {
 364     BindProtocol *This = impl_from_IInternetProtocolEx(iface);
 365     IUri *uri;
 366     HRESULT hres;
 367
 368     TRACE("(%p)->(%s %p %p %08lx %Ix)\n", This, debugstr_w(szUrl), pOIProtSink,
 369             pOIBindInfo, grfPI, dwReserved);
 370
 371     hres = CreateUri(szUrl, Uri_CREATE_FILE_USE_DOS_PATH, 0, &uri);
 372     if(FAILED(hres))
 373         return hres;
 374
 375     hres = IInternetProtocolEx_StartEx(&This->IInternetProtocolEx_iface, uri, pOIProtSink,
 376             pOIBindInfo, grfPI, (HANDLE*)dwReserved);
 377
 378     IUri_Release(uri);
 379     return hres;
 380 }
 381
 382 static HRESULT WINAPI BindProtocol_Continue(IInternetProtocolEx *iface, PROTOCOLDATA *pProtocolData)
 383 {
 384     BindProtocol *This = impl_from_IInternetProtocolEx(iface);
 385
 386     TRACE("(%p)->(%p)\n", This, pProtocolData);
 387
 388     return IInternetProtocol_Continue(This->protocol_handler, pProtocolData);
 389 }
 390
 391 static HRESULT WINAPI BindProtocol_Abort(IInternetProtocolEx *iface, HRESULT hrReason,
 392         DWORD dwOptions)
 393 {
 394     BindProtocol *This = impl_from_IInternetProtocolEx(iface);
 395
 396     TRACE("(%p)->(%08lx %08lx)\n", This, hrReason, dwOptions);
 397
 398     return IInternetProtocol_Abort(This->protocol_handler, hrReason, dwOptions);
 399 }
 400
 401 static HRESULT WINAPI BindProtocol_Terminate(IInternetProtocolEx *iface, DWORD dwOptions)
 402 {
 403     BindProtocol *This = impl_from_IInternetProtocolEx(iface);
 404
 405     TRACE("(%p)->(%08lx)\n", This, dwOptions);
 406
 407     return IInternetProtocol_Terminate(This->protocol_handler, dwOptions);
 408 }
 409
 410 static HRESULT WINAPI BindProtocol_Suspend(IInternetProtocolEx *iface)
 411 {
 412     BindProtocol *This = impl_from_IInternetProtocolEx(iface);
 413     FIXME("(%p)\n", This);
 414     return E_NOTIMPL;
 415 }
 416
 417 static HRESULT WINAPI BindProtocol_Resume(IInternetProtocolEx *iface)
 418 {
 419     BindProtocol *This = impl_from_IInternetProtocolEx(iface);
 420     FIXME("(%p)\n", This);
 421     return E_NOTIMPL;
 422 }
 423
 424 static HRESULT WINAPI BindProtocol_Read(IInternetProtocolEx *iface, void *pv,
 425         ULONG cb, ULONG *pcbRead)
 426 {
 427     BindProtocol *This = impl_from_IInternetProtocolEx(iface);
 428
 429     TRACE("(%p)->(%p %lu %p)\n", This, pv, cb, pcbRead);
 430
 431     if(pcbRead)
 432         *pcbRead = 0;
 433     return IInternetProtocol_Read(This->protocol_handler, pv, cb, pcbRead);
 434 }
 435
 436 static HRESULT WINAPI BindProtocol_Seek(IInternetProtocolEx *iface, LARGE_INTEGER dlibMove,
 437         DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
 438 {
 439     BindProtocol *This = impl_from_IInternetProtocolEx(iface);
 440     FIXME("(%p)->(%ld %ld %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
 441     return E_NOTIMPL;
 442 }
 443
 444 static HRESULT WINAPI BindProtocol_LockRequest(IInternetProtocolEx *iface, DWORD dwOptions)
 445 {
 446     BindProtocol *This = impl_from_IInternetProtocolEx(iface);
 447
 448     TRACE("(%p)->(%08lx)\n", This, dwOptions);
 449
 450     return IInternetProtocol_LockRequest(This->protocol_handler, dwOptions);
 451 }
 452
 453 static HRESULT WINAPI BindProtocol_UnlockRequest(IInternetProtocolEx *iface)
 454 {
 455     BindProtocol *This = impl_from_IInternetProtocolEx(iface);
 456
 457     TRACE("(%p)\n", This);
 458
 459     return IInternetProtocol_UnlockRequest(This->protocol_handler);
 460 }
 461
 462 static HRESULT WINAPI BindProtocol_StartEx(IInternetProtocolEx *iface, IUri *pUri,
 463         IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
 464         DWORD grfPI, HANDLE *dwReserved)
 465 {
 466     BindProtocol *This = impl_from_IInternetProtocolEx(iface);
 467     IInternetProtocol *protocol = NULL;
 468     IInternetProtocolEx *protocolex;
 469     IInternetPriority *priority;
 470     IServiceProvider *service_provider;
 471     CLSID clsid = IID_NULL;
 472     IUnknown *protocol_unk = NULL;
 473     LPOLESTR clsid_str;
 474     HRESULT hres;
 475
 476     TRACE("(%p)->(%p %p %p %08lx %p)\n", This, pUri, pOIProtSink, pOIBindInfo, grfPI, dwReserved);
 477
 478     if(!pUri || !pOIProtSink || !pOIBindInfo)
 479         return E_INVALIDARG;
 480
 481     This->pi = grfPI;
 482
 483     if(This->uri) {
 484         SysFreeString(This->display_uri);
 485         IUri_Release(This->uri);
 486     }
 487     IUri_AddRef(pUri);
 488     This->uri = pUri;
 489
 490     hres = IInternetProtocolSink_QueryInterface(pOIProtSink, &IID_IServiceProvider,
 491                                                 (void**)&service_provider);
 492     if(SUCCEEDED(hres)) {
 493         /* FIXME: What's protocol CLSID here? */
 494         IServiceProvider_QueryService(service_provider, &IID_IInternetProtocol,
 495                 &IID_IInternetProtocol, (void**)&protocol);
 496         IServiceProvider_Release(service_provider);
 497     }
 498
 499     if(!protocol) {
 500         IClassFactory *cf;
 501
 502         hres = get_protocol_handler(pUri, &clsid, &cf);
 503         if(FAILED(hres))
 504             return hres;
 505
 506         hres = IClassFactory_CreateInstance(cf, (IUnknown*)&This->IInternetBindInfo_iface,
 507                 &IID_IUnknown, (void**)&protocol_unk);
 508         if(SUCCEEDED(hres)) {
 509             hres = IUnknown_QueryInterface(protocol_unk, &IID_IInternetProtocol, (void**)&protocol);
 510             if(SUCCEEDED(hres))
 511                 This->protocol_unk = protocol_unk;
 512             else
 513                 IUnknown_Release(protocol_unk);
 514         }
 515         else if(hres == CLASS_E_NOAGGREGATION)
 516             hres = IClassFactory_CreateInstance(cf, NULL, &IID_IInternetProtocol, (void**)&protocol);
 517
 518         IClassFactory_Release(cf);
 519         if(FAILED(hres))
 520             return hres;
 521     }
 522
 523     StringFromCLSID(&clsid, &clsid_str);
 524     IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_PROTOCOLCLASSID, clsid_str);
 525     CoTaskMemFree(clsid_str);
 526
 527     This->protocol_unk = protocol_unk;
 528     This->protocol = protocol;
 529
 530     if(!protocol_unk)
 531         protocol_unk = (IUnknown*)protocol;
 532
 533     set_binding_sink(This, pOIProtSink, pOIBindInfo);
 534
 535     hres = IUnknown_QueryInterface(protocol_unk, &IID_IInternetPriority, (void**)&priority);
 536     if(SUCCEEDED(hres)) {
 537         IInternetPriority_SetPriority(priority, This->priority);
 538         IInternetPriority_Release(priority);
 539     }
 540
 541     hres = IUnknown_QueryInterface(protocol_unk, &IID_IInternetProtocolEx, (void**)&protocolex);
 542     if(SUCCEEDED(hres)) {
 543         hres = IInternetProtocolEx_StartEx(protocolex, pUri, &This->IInternetProtocolSink_iface,
 544                 &This->IInternetBindInfo_iface, 0, NULL);
 545         IInternetProtocolEx_Release(protocolex);
 546     }else {
 547         hres = IUri_GetDisplayUri(pUri, &This->display_uri);
 548         if(FAILED(hres))
 549             return hres;
 550
 551         hres = IInternetProtocol_Start(protocol, This->display_uri, &This->IInternetProtocolSink_iface,
 552                 &This->IInternetBindInfo_iface, 0, 0);
 553     }
 554
 555     if(SUCCEEDED(hres))
 556         process_tasks(This);
 557     return hres;
 558 }
 559
 560 void set_binding_sink(BindProtocol *This, IInternetProtocolSink *sink, IInternetBindInfo *bind_info)
 561 {
 562     IInternetProtocolSink *prev_sink;
 563     IServiceProvider *service_provider = NULL;
 564
 565     if(sink)
 566         IInternetProtocolSink_AddRef(sink);
 567     prev_sink = InterlockedExchangePointer((void**)&This->protocol_sink, sink);
 568     if(prev_sink)
 569         IInternetProtocolSink_Release(prev_sink);
 570
 571     if(sink)
 572         IInternetProtocolSink_QueryInterface(sink, &IID_IServiceProvider, (void**)&service_provider);
 573     service_provider = InterlockedExchangePointer((void**)&This->service_provider, service_provider);
 574     if(service_provider)
 575         IServiceProvider_Release(service_provider);
 576
 577     if(bind_info)
 578         IInternetBindInfo_AddRef(bind_info);
 579     bind_info = InterlockedExchangePointer((void**)&This->bind_info, bind_info);
 580     if(bind_info)
 581         IInternetBindInfo_Release(bind_info);
 582 }
 583
 584 static const IInternetProtocolExVtbl BindProtocolVtbl = {
 585     BindProtocol_QueryInterface,
 586     BindProtocol_AddRef,
 587     BindProtocol_Release,
 588     BindProtocol_Start,
 589     BindProtocol_Continue,
 590     BindProtocol_Abort,
 591     BindProtocol_Terminate,
 592     BindProtocol_Suspend,
 593     BindProtocol_Resume,
 594     BindProtocol_Read,
 595     BindProtocol_Seek,
 596     BindProtocol_LockRequest,
 597     BindProtocol_UnlockRequest,
 598     BindProtocol_StartEx
 599 };
 600
 601 static inline BindProtocol *impl_from_IInternetProtocol(IInternetProtocol *iface)
 602 {
 603     return CONTAINING_RECORD(iface, BindProtocol, default_protocol_handler.IInternetProtocol_iface);
 604 }
 605
 606 static HRESULT WINAPI ProtocolHandler_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
 607 {
 608     BindProtocol *This = impl_from_IInternetProtocol(iface);
 609
 610     *ppv = NULL;
 611     if(IsEqualGUID(&IID_IUnknown, riid)) {
 612         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
 613         *ppv = &This->default_protocol_handler.IInternetProtocol_iface;
 614     }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) {
 615         TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", This, ppv);
 616         *ppv = &This->default_protocol_handler.IInternetProtocol_iface;
 617     }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
 618         TRACE("(%p)->(IID_IInternetProtocol %p)\n", This, ppv);
 619         *ppv = &This->default_protocol_handler.IInternetProtocol_iface;
 620     }else if(IsEqualGUID(&IID_IInternetProtocolSink, riid)) {
 621         TRACE("(%p)->(IID_IInternetProtocolSink %p)\n", This, ppv);
 622         *ppv = &This->default_protocol_handler.IInternetProtocolSink_iface;
 623     }
 624
 625     if(*ppv) {
 626         IInternetProtocol_AddRef(iface);
 627         return S_OK;
 628     }
 629
 630     WARN("not supported interface %s\n", debugstr_guid(riid));
 631     return E_NOINTERFACE;
 632 }
 633
 634 static ULONG WINAPI ProtocolHandler_AddRef(IInternetProtocol *iface)
 635 {
 636     BindProtocol *This = impl_from_IInternetProtocol(iface);
 637     return IInternetProtocolEx_AddRef(&This->IInternetProtocolEx_iface);
 638 }
 639
 640 static ULONG WINAPI ProtocolHandler_Release(IInternetProtocol *iface)
 641 {
 642     BindProtocol *This = impl_from_IInternetProtocol(iface);
 643     return IInternetProtocolEx_Release(&This->IInternetProtocolEx_iface);
 644 }
 645
 646 static HRESULT WINAPI ProtocolHandler_Start(IInternetProtocol *iface, LPCWSTR szUrl,
 647         IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
 648         DWORD grfPI, HANDLE_PTR dwReserved)
 649 {
 650     ERR("Should not be called\n");
 651     return E_NOTIMPL;
 652 }
 653
 654 static HRESULT WINAPI ProtocolHandler_Continue(IInternetProtocol *iface, PROTOCOLDATA *pProtocolData)
 655 {
 656     BindProtocol *This = impl_from_IInternetProtocol(iface);
 657     IInternetProtocol *protocol = NULL;
 658     HRESULT hres;
 659
 660     TRACE("(%p)->(%p)\n", This, pProtocolData);
 661
 662     /* FIXME: This should not be needed. */
 663     if(!This->protocol) {
 664         if(!This->protocol_unk)
 665             return E_FAIL;
 666         hres = IUnknown_QueryInterface(This->protocol_unk, &IID_IInternetProtocol, (void**)&protocol);
 667         if(FAILED(hres))
 668             return E_FAIL;
 669     }
 670
 671     hres = IInternetProtocol_Continue(protocol ? protocol : This->protocol, pProtocolData);
 672
 673     free(pProtocolData);
 674     if(protocol)
 675         IInternetProtocol_Release(protocol);
 676     return hres;
 677 }
 678
 679 static HRESULT WINAPI ProtocolHandler_Abort(IInternetProtocol *iface, HRESULT hrReason,
 680         DWORD dwOptions)
 681 {
 682     BindProtocol *This = impl_from_IInternetProtocol(iface);
 683
 684     TRACE("(%p)->(%08lx %08lx)\n", This, hrReason, dwOptions);
 685
 686     if(This->protocol && !This->reported_result)
 687         return IInternetProtocol_Abort(This->protocol, hrReason, dwOptions);
 688
 689     return S_OK;
 690 }
 691
 692 static HRESULT WINAPI ProtocolHandler_Terminate(IInternetProtocol *iface, DWORD dwOptions)
 693 {
 694     BindProtocol *This = impl_from_IInternetProtocol(iface);
 695
 696     TRACE("(%p)->(%08lx)\n", This, dwOptions);
 697
 698     if(!This->reported_result)
 699         return E_FAIL;
 700
 701     /* This may get released in Terminate call. */
 702     IInternetProtocolEx_AddRef(&This->IInternetProtocolEx_iface);
 703
 704     if(This->protocol) {
 705         IInternetProtocol_Terminate(This->protocol, 0);
 706
 707         if (This->protocol_unk) {
 708             IInternetProtocol_Release(This->protocol);
 709             This->protocol = NULL;
 710         }
 711     }
 712
 713     set_binding_sink(This, NULL, NULL);
 714
 715     if(This->bind_info) {
 716         IInternetBindInfo_Release(This->bind_info);
 717         This->bind_info = NULL;
 718     }
 719
 720     if(This->redirect_callback) {
 721         IBindCallbackRedirect_Release(This->redirect_callback);
 722         This->redirect_callback = NULL;
 723     }
 724
 725     IInternetProtocolEx_Release(&This->IInternetProtocolEx_iface);
 726     return S_OK;
 727 }
 728
 729 static HRESULT WINAPI ProtocolHandler_Suspend(IInternetProtocol *iface)
 730 {
 731     BindProtocol *This = impl_from_IInternetProtocol(iface);
 732     FIXME("(%p)\n", This);
 733     return E_NOTIMPL;
 734 }
 735
 736 static HRESULT WINAPI ProtocolHandler_Resume(IInternetProtocol *iface)
 737 {
 738     BindProtocol *This = impl_from_IInternetProtocol(iface);
 739     FIXME("(%p)\n", This);
 740     return E_NOTIMPL;
 741 }
 742
 743 static HRESULT WINAPI ProtocolHandler_Read(IInternetProtocol *iface, void *pv,
 744         ULONG cb, ULONG *pcbRead)
 745 {
 746     BindProtocol *This = impl_from_IInternetProtocol(iface);
 747     ULONG read = 0;
 748     HRESULT hres = S_OK;
 749
 750     TRACE("(%p)->(%p %lu %p)\n", This, pv, cb, pcbRead);
 751
 752     if(This->buf_size) {
 753         read = min(cb, This->buf_size);
 754         memcpy(pv, This->buf, read);
 755
 756         if(read == This->buf_size) {
 757             free(This->buf);
 758             This->buf = NULL;
 759         }else {
 760             memmove(This->buf, This->buf+cb, This->buf_size-cb);
 761         }
 762
 763         This->buf_size -= read;
 764     }
 765
 766     if(read < cb) {
 767         IInternetProtocol *protocol;
 768         ULONG cread = 0;
 769
 770         /* FIXME: We shouldn't need it, but out binding code currently depends on it. */
 771         if(!This->protocol && This->protocol_unk) {
 772             hres = IUnknown_QueryInterface(This->protocol_unk, &IID_IInternetProtocol,
 773                                            (void**)&protocol);
 774             if(FAILED(hres))
 775                 return E_ABORT;
 776         }else {
 777             protocol = This->protocol;
 778         }
 779
 780         if(is_apartment_thread(This))
 781             This->continue_call++;
 782         hres = IInternetProtocol_Read(protocol, (BYTE*)pv+read, cb-read, &cread);
 783         if(is_apartment_thread(This))
 784             This->continue_call--;
 785         read += cread;
 786
 787         if(!This->protocol)
 788             IInternetProtocol_Release(protocol);
 789     }
 790
 791     *pcbRead = read;
 792     return hres;
 793 }
 794
 795 static HRESULT WINAPI ProtocolHandler_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove,
 796         DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
 797 {
 798     BindProtocol *This = impl_from_IInternetProtocol(iface);
 799     FIXME("(%p)->(%ld %ld %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
 800     return E_NOTIMPL;
 801 }
 802
 803 static HRESULT WINAPI ProtocolHandler_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
 804 {
 805     BindProtocol *This = impl_from_IInternetProtocol(iface);
 806
 807     TRACE("(%p)->(%08lx)\n", This, dwOptions);
 808
 809     return IInternetProtocol_LockRequest(This->protocol, dwOptions);
 810 }
 811
 812 static HRESULT WINAPI ProtocolHandler_UnlockRequest(IInternetProtocol *iface)
 813 {
 814     BindProtocol *This = impl_from_IInternetProtocol(iface);
 815
 816     TRACE("(%p)\n", This);
 817
 818     return IInternetProtocol_UnlockRequest(This->protocol);
 819 }
 820
 821 static const IInternetProtocolVtbl InternetProtocolHandlerVtbl = {
 822     ProtocolHandler_QueryInterface,
 823     ProtocolHandler_AddRef,
 824     ProtocolHandler_Release,
 825     ProtocolHandler_Start,
 826     ProtocolHandler_Continue,
 827     ProtocolHandler_Abort,
 828     ProtocolHandler_Terminate,
 829     ProtocolHandler_Suspend,
 830     ProtocolHandler_Resume,
 831     ProtocolHandler_Read,
 832     ProtocolHandler_Seek,
 833     ProtocolHandler_LockRequest,
 834     ProtocolHandler_UnlockRequest
 835 };
 836
 837 static inline BindProtocol *impl_from_IInternetProtocolSinkHandler(IInternetProtocolSink *iface)
 838 {
 839     return CONTAINING_RECORD(iface, BindProtocol, default_protocol_handler.IInternetProtocolSink_iface);
 840 }
 841
 842 static HRESULT WINAPI ProtocolSinkHandler_QueryInterface(IInternetProtocolSink *iface,
 843         REFIID riid, void **ppvObject)
 844 {
 845     BindProtocol *This = impl_from_IInternetProtocolSinkHandler(iface);
 846     return IInternetProtocol_QueryInterface(&This->default_protocol_handler.IInternetProtocol_iface,
 847             riid, ppvObject);
 848 }
 849
 850 static ULONG WINAPI ProtocolSinkHandler_AddRef(IInternetProtocolSink *iface)
 851 {
 852     BindProtocol *This = impl_from_IInternetProtocolSinkHandler(iface);
 853     return IInternetProtocolEx_AddRef(&This->IInternetProtocolEx_iface);
 854 }
 855
 856 static ULONG WINAPI ProtocolSinkHandler_Release(IInternetProtocolSink *iface)
 857 {
 858     BindProtocol *This = impl_from_IInternetProtocolSinkHandler(iface);
 859     return IInternetProtocolEx_Release(&This->IInternetProtocolEx_iface);
 860 }
 861
 862 static HRESULT WINAPI ProtocolSinkHandler_Switch(IInternetProtocolSink *iface,
 863         PROTOCOLDATA *pProtocolData)
 864 {
 865     BindProtocol *This = impl_from_IInternetProtocolSinkHandler(iface);
 866
 867     TRACE("(%p)->(%p)\n", This, pProtocolData);
 868
 869     if(!This->protocol_sink) {
 870         IInternetProtocol_Continue(This->protocol_handler, pProtocolData);
 871         return S_OK;
 872     }
 873
 874     return IInternetProtocolSink_Switch(This->protocol_sink, pProtocolData);
 875 }
 876
 877 static HRESULT WINAPI ProtocolSinkHandler_ReportProgress(IInternetProtocolSink *iface,
 878         ULONG status_code, LPCWSTR status_text)
 879 {
 880     BindProtocol *This = impl_from_IInternetProtocolSinkHandler(iface);
 881
 882     TRACE("(%p)->(%s %s)\n", This, debugstr_bindstatus(status_code), debugstr_w(status_text));
 883
 884     if(!This->protocol_sink)
 885         return S_OK;
 886
 887     switch(status_code) {
 888     case BINDSTATUS_FINDINGRESOURCE:
 889     case BINDSTATUS_CONNECTING:
 890     case BINDSTATUS_REDIRECTING:
 891     case BINDSTATUS_SENDINGREQUEST:
 892     case BINDSTATUS_CACHEFILENAMEAVAILABLE:
 893     case BINDSTATUS_DIRECTBIND:
 894     case BINDSTATUS_ACCEPTRANGES:
 895     case BINDSTATUS_DECODING:
 896         IInternetProtocolSink_ReportProgress(This->protocol_sink, status_code, status_text);
 897         break;
 898
 899     case BINDSTATUS_BEGINDOWNLOADDATA:
 900         IInternetProtocolSink_ReportData(This->protocol_sink, This->bscf, This->progress, This->progress_max);
 901         break;
 902
 903     case BINDSTATUS_MIMETYPEAVAILABLE:
 904         mime_available(This, status_text, FALSE);
 905         break;
 906
 907     case BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE:
 908         mime_available(This, status_text, TRUE);
 909         break;
 910
 911     default:
 912         FIXME("unsupported ulStatusCode %lu\n", status_code);
 913     }
 914
 915     return S_OK;
 916 }
 917
 918 static HRESULT report_data(BindProtocol *This)
 919 {
 920     DWORD bscf = This->bscf;
 921     HRESULT hres;
 922
 923     if((This->pi & PI_MIMEVERIFICATION) && !This->reported_mime) {
 924         BYTE buf[BUFFER_SIZE];
 925         DWORD read = 0;
 926         LPWSTR mime;
 927
 928         do {
 929             read = 0;
 930             hres = IInternetProtocol_Read(This->protocol, buf,
 931                     sizeof(buf)-This->buf_size, &read);
 932             if(FAILED(hres) && hres != E_PENDING)
 933                 return hres;
 934
 935             if(!This->buf) {
 936                 This->buf = malloc(BUFFER_SIZE);
 937                 if(!This->buf)
 938                     return E_OUTOFMEMORY;
 939             }else if(read + This->buf_size > BUFFER_SIZE) {
 940                 BYTE *tmp;
 941
 942                 tmp = realloc(This->buf, read + This->buf_size);
 943                 if(!tmp)
 944                     return E_OUTOFMEMORY;
 945                 This->buf = tmp;
 946             }
 947
 948             memcpy(This->buf+This->buf_size, buf, read);
 949             This->buf_size += read;
 950         }while(This->buf_size < MIME_TEST_SIZE && hres == S_OK);
 951
 952         if(This->buf_size < MIME_TEST_SIZE && hres != S_FALSE)
 953             return S_OK;
 954
 955         bscf = BSCF_FIRSTDATANOTIFICATION;
 956         if(hres == S_FALSE)
 957             bscf |= BSCF_LASTDATANOTIFICATION|BSCF_DATAFULLYAVAILABLE;
 958
 959         if(!This->reported_mime) {
 960             BSTR raw_uri;
 961
 962             hres = IUri_GetRawUri(This->uri, &raw_uri);
 963             if(FAILED(hres))
 964                 return hres;
 965
 966             hres = FindMimeFromData(NULL, raw_uri, This->buf, min(This->buf_size, MIME_TEST_SIZE),
 967                     This->mime, 0, &mime, 0);
 968             SysFreeString(raw_uri);
 969             if(FAILED(hres))
 970                 return hres;
 971
 972             free(This->mime);
 973             This->mime = wcsdup(mime);
 974             CoTaskMemFree(mime);
 975             This->reported_mime = TRUE;
 976             if(This->protocol_sink)
 977                 IInternetProtocolSink_ReportProgress(This->protocol_sink, BINDSTATUS_MIMETYPEAVAILABLE, This->mime);
 978         }
 979     }
 980
 981     if(!This->protocol_sink)
 982         return S_OK;
 983
 984     return IInternetProtocolSink_ReportData(This->protocol_sink, bscf, This->progress, This->progress_max);
 985 }
 986
 987 static HRESULT WINAPI ProtocolSinkHandler_ReportData(IInternetProtocolSink *iface,
 988         DWORD bscf, ULONG progress, ULONG progress_max)
 989 {
 990     BindProtocol *This = impl_from_IInternetProtocolSinkHandler(iface);
 991     HRESULT hres;
 992
 993     TRACE("(%p)->(%lx %lu %lu)\n", This, bscf, progress, progress_max);
 994
 995     This->bscf = bscf;
 996     This->progress = progress;
 997     This->progress_max = progress_max;
 998
 999     if(!This->protocol_sink)
1000         return S_OK;
1001
1002     if(is_apartment_thread(This))
1003         This->continue_call++;
1004
1005     hres = report_data(This);
1006
1007     if(is_apartment_thread(This)) {
1008         This->continue_call--;
1009         process_tasks(This);
1010     }
1011     return hres;
1012 }
1013
1014 static HRESULT handle_redirect(BindProtocol *This, const WCHAR *url)
1015 {
1016     HRESULT hres;
1017
1018     if(This->redirect_callback) {
1019         VARIANT_BOOL cancel = VARIANT_FALSE;
1020         IBindCallbackRedirect_Redirect(This->redirect_callback, url, &cancel);
1021         if(cancel)
1022             return INET_E_REDIRECT_FAILED;
1023     }
1024
1025     if(This->protocol_sink) {
1026         hres = IInternetProtocolSink_ReportProgress(This->protocol_sink, BINDSTATUS_REDIRECTING, url);
1027         if(FAILED(hres))
1028             return hres;
1029     }
1030
1031     IInternetProtocol_Terminate(This->protocol, 0); /* should this be done in StartEx? */
1032     release_protocol_handler(This);
1033
1034     return IInternetProtocolEx_Start(&This->IInternetProtocolEx_iface, url, This->protocol_sink, This->bind_info, This->pi, 0);
1035 }
1036
1037 static HRESULT WINAPI ProtocolSinkHandler_ReportResult(IInternetProtocolSink *iface,
1038         HRESULT hrResult, DWORD dwError, LPCWSTR szResult)
1039 {
1040     BindProtocol *This = impl_from_IInternetProtocolSinkHandler(iface);
1041
1042     TRACE("(%p)->(%08lx %ld %s)\n", This, hrResult, dwError, debugstr_w(szResult));
1043
1044     if(hrResult == INET_E_REDIRECT_FAILED) {
1045         hrResult = handle_redirect(This, szResult);
1046         if(hrResult == S_OK)
1047             return S_OK;
1048         szResult = NULL;
1049     }
1050
1051     if(This->protocol_sink)
1052         return IInternetProtocolSink_ReportResult(This->protocol_sink, hrResult, dwError, szResult);
1053     return S_OK;
1054 }
1055
1056 static const IInternetProtocolSinkVtbl InternetProtocolSinkHandlerVtbl = {
1057     ProtocolSinkHandler_QueryInterface,
1058     ProtocolSinkHandler_AddRef,
1059     ProtocolSinkHandler_Release,
1060     ProtocolSinkHandler_Switch,
1061     ProtocolSinkHandler_ReportProgress,
1062     ProtocolSinkHandler_ReportData,
1063     ProtocolSinkHandler_ReportResult
1064 };
1065
1066 static inline BindProtocol *impl_from_IInternetBindInfo(IInternetBindInfo *iface)
1067 {
1068     return CONTAINING_RECORD(iface, BindProtocol, IInternetBindInfo_iface);
1069 }
1070
1071 static HRESULT WINAPI BindInfo_QueryInterface(IInternetBindInfo *iface,
1072         REFIID riid, void **ppv)
1073 {
1074     BindProtocol *This = impl_from_IInternetBindInfo(iface);
1075     return IInternetProtocolEx_QueryInterface(&This->IInternetProtocolEx_iface, riid, ppv);
1076 }
1077
1078 static ULONG WINAPI BindInfo_AddRef(IInternetBindInfo *iface)
1079 {
1080     BindProtocol *This = impl_from_IInternetBindInfo(iface);
1081     return IInternetProtocolEx_AddRef(&This->IInternetProtocolEx_iface);
1082 }
1083
1084 static ULONG WINAPI BindInfo_Release(IInternetBindInfo *iface)
1085 {
1086     BindProtocol *This = impl_from_IInternetBindInfo(iface);
1087     return IInternetProtocolEx_Release(&This->IInternetProtocolEx_iface);
1088 }
1089
1090 static HRESULT WINAPI BindInfo_GetBindInfo(IInternetBindInfo *iface,
1091         DWORD *grfBINDF, BINDINFO *pbindinfo)
1092 {
1093     BindProtocol *This = impl_from_IInternetBindInfo(iface);
1094     HRESULT hres;
1095
1096     TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
1097
1098     hres = IInternetBindInfo_GetBindInfo(This->bind_info, grfBINDF, pbindinfo);
1099     if(FAILED(hres)) {
1100         WARN("GetBindInfo failed: %08lx\n", hres);
1101         return hres;
1102     }
1103
1104     if((pbindinfo->dwOptions & BINDINFO_OPTIONS_DISABLEAUTOREDIRECTS) && !This->redirect_callback) {
1105         IServiceProvider *service_provider;
1106
1107         hres = IInternetProtocolSink_QueryInterface(This->protocol_sink, &IID_IServiceProvider, (void**)&service_provider);
1108         if(SUCCEEDED(hres)) {
1109             hres = IServiceProvider_QueryService(service_provider, &IID_IBindCallbackRedirect, &IID_IBindCallbackRedirect,
1110                                                  (void**)&This->redirect_callback);
1111             IServiceProvider_Release(service_provider);
1112         }
1113     }
1114
1115     *grfBINDF |= BINDF_FROMURLMON;
1116     return hres;
1117 }
1118
1119 static HRESULT WINAPI BindInfo_GetBindString(IInternetBindInfo *iface,
1120         ULONG ulStringType, LPOLESTR *ppwzStr, ULONG cEl, ULONG *pcElFetched)
1121 {
1122     BindProtocol *This = impl_from_IInternetBindInfo(iface);
1123
1124     TRACE("(%p)->(%ld %p %ld %p)\n", This, ulStringType, ppwzStr, cEl, pcElFetched);
1125
1126     return IInternetBindInfo_GetBindString(This->bind_info, ulStringType, ppwzStr, cEl, pcElFetched);
1127 }
1128
1129 static const IInternetBindInfoVtbl InternetBindInfoVtbl = {
1130     BindInfo_QueryInterface,
1131     BindInfo_AddRef,
1132     BindInfo_Release,
1133     BindInfo_GetBindInfo,
1134     BindInfo_GetBindString
1135 };
1136
1137 static inline BindProtocol *impl_from_IInternetPriority(IInternetPriority *iface)
1138 {
1139     return CONTAINING_RECORD(iface, BindProtocol, IInternetPriority_iface);
1140 }
1141
1142 static HRESULT WINAPI InternetPriority_QueryInterface(IInternetPriority *iface,
1143         REFIID riid, void **ppv)
1144 {
1145     BindProtocol *This = impl_from_IInternetPriority(iface);
1146     return IInternetProtocolEx_QueryInterface(&This->IInternetProtocolEx_iface, riid, ppv);
1147 }
1148
1149 static ULONG WINAPI InternetPriority_AddRef(IInternetPriority *iface)
1150 {
1151     BindProtocol *This = impl_from_IInternetPriority(iface);
1152     return IInternetProtocolEx_AddRef(&This->IInternetProtocolEx_iface);
1153 }
1154
1155 static ULONG WINAPI InternetPriority_Release(IInternetPriority *iface)
1156 {
1157     BindProtocol *This = impl_from_IInternetPriority(iface);
1158     return IInternetProtocolEx_Release(&This->IInternetProtocolEx_iface);
1159 }
1160
1161 static HRESULT WINAPI InternetPriority_SetPriority(IInternetPriority *iface, LONG nPriority)
1162 {
1163     BindProtocol *This = impl_from_IInternetPriority(iface);
1164
1165     TRACE("(%p)->(%ld)\n", This, nPriority);
1166
1167     This->priority = nPriority;
1168     return S_OK;
1169 }
1170
1171 static HRESULT WINAPI InternetPriority_GetPriority(IInternetPriority *iface, LONG *pnPriority)
1172 {
1173     BindProtocol *This = impl_from_IInternetPriority(iface);
1174
1175     TRACE("(%p)->(%p)\n", This, pnPriority);
1176
1177     *pnPriority = This->priority;
1178     return S_OK;
1179 }
1180
1181 static const IInternetPriorityVtbl InternetPriorityVtbl = {
1182     InternetPriority_QueryInterface,
1183     InternetPriority_AddRef,
1184     InternetPriority_Release,
1185     InternetPriority_SetPriority,
1186     InternetPriority_GetPriority
1187
1188 };
1189
1190 static inline BindProtocol *impl_from_IInternetProtocolSink(IInternetProtocolSink *iface)
1191 {
1192     return CONTAINING_RECORD(iface, BindProtocol, IInternetProtocolSink_iface);
1193 }
1194
1195 static HRESULT WINAPI BPInternetProtocolSink_QueryInterface(IInternetProtocolSink *iface,
1196         REFIID riid, void **ppv)
1197 {
1198     BindProtocol *This = impl_from_IInternetProtocolSink(iface);
1199     return IInternetProtocolEx_QueryInterface(&This->IInternetProtocolEx_iface, riid, ppv);
1200 }
1201
1202 static ULONG WINAPI BPInternetProtocolSink_AddRef(IInternetProtocolSink *iface)
1203 {
1204     BindProtocol *This = impl_from_IInternetProtocolSink(iface);
1205     return IInternetProtocolEx_AddRef(&This->IInternetProtocolEx_iface);
1206 }
1207
1208 static ULONG WINAPI BPInternetProtocolSink_Release(IInternetProtocolSink *iface)
1209 {
1210     BindProtocol *This = impl_from_IInternetProtocolSink(iface);
1211     return IInternetProtocolEx_Release(&This->IInternetProtocolEx_iface);
1212 }
1213
1214 typedef struct {
1215     task_header_t header;
1216     PROTOCOLDATA *data;
1217 } switch_task_t;
1218
1219 static void switch_proc(BindProtocol *bind, task_header_t *t)
1220 {
1221     switch_task_t *task = (switch_task_t*)t;
1222
1223     IInternetProtocol_Continue(bind->protocol_handler, task->data);
1224
1225     free(task);
1226 }
1227
1228 static HRESULT WINAPI BPInternetProtocolSink_Switch(IInternetProtocolSink *iface,
1229         PROTOCOLDATA *pProtocolData)
1230 {
1231     BindProtocol *This = impl_from_IInternetProtocolSink(iface);
1232     PROTOCOLDATA *data;
1233
1234     TRACE("(%p)->(%p)\n", This, pProtocolData);
1235
1236     TRACE("flags %lx state %lx data %p cb %lu\n", pProtocolData->grfFlags, pProtocolData->dwState,
1237           pProtocolData->pData, pProtocolData->cbData);
1238
1239     data = malloc(sizeof(PROTOCOLDATA));
1240     if(!data)
1241         return E_OUTOFMEMORY;
1242     memcpy(data, pProtocolData, sizeof(PROTOCOLDATA));
1243
1244     if((This->pi&PI_APARTMENTTHREADED && pProtocolData->grfFlags&PI_FORCE_ASYNC)
1245             || !do_direct_notif(This)) {
1246         switch_task_t *task;
1247
1248         task = malloc(sizeof(switch_task_t));
1249         if(!task)
1250         {
1251             free(data);
1252             return E_OUTOFMEMORY;
1253         }
1254
1255         task->data = data;
1256
1257         push_task(This, &task->header, switch_proc);
1258         return S_OK;
1259     }
1260
1261     return IInternetProtocolSink_Switch(This->protocol_sink_handler, data);
1262 }
1263
1264 typedef struct {
1265     task_header_t header;
1266
1267     ULONG status_code;
1268     LPWSTR status_text;
1269 } on_progress_task_t;
1270
1271 static void on_progress_proc(BindProtocol *This, task_header_t *t)
1272 {
1273     on_progress_task_t *task = (on_progress_task_t*)t;
1274
1275     IInternetProtocolSink_ReportProgress(This->protocol_sink_handler, task->status_code, task->status_text);
1276
1277     free(task->status_text);
1278     free(task);
1279 }
1280
1281 static HRESULT WINAPI BPInternetProtocolSink_ReportProgress(IInternetProtocolSink *iface,
1282         ULONG ulStatusCode, LPCWSTR szStatusText)
1283 {
1284     BindProtocol *This = impl_from_IInternetProtocolSink(iface);
1285
1286     TRACE("(%p)->(%lu %s)\n", This, ulStatusCode, debugstr_w(szStatusText));
1287
1288     if(do_direct_notif(This)) {
1289         IInternetProtocolSink_ReportProgress(This->protocol_sink_handler, ulStatusCode, szStatusText);
1290     }else {
1291         on_progress_task_t *task;
1292
1293         task = malloc(sizeof(on_progress_task_t));
1294
1295         task->status_code = ulStatusCode;
1296         task->status_text = wcsdup(szStatusText);
1297
1298         push_task(This, &task->header, on_progress_proc);
1299     }
1300
1301     return S_OK;
1302 }
1303
1304 typedef struct {
1305     task_header_t header;
1306     DWORD bscf;
1307     ULONG progress;
1308     ULONG progress_max;
1309 } report_data_task_t;
1310
1311 static void report_data_proc(BindProtocol *This, task_header_t *t)
1312 {
1313     report_data_task_t *task = (report_data_task_t*)t;
1314
1315     IInternetProtocolSink_ReportData(This->protocol_sink_handler,
1316             task->bscf, task->progress, task->progress_max);
1317
1318     free(task);
1319 }
1320
1321 static HRESULT WINAPI BPInternetProtocolSink_ReportData(IInternetProtocolSink *iface,
1322         DWORD grfBSCF, ULONG ulProgress, ULONG ulProgressMax)
1323 {
1324     BindProtocol *This = impl_from_IInternetProtocolSink(iface);
1325
1326     TRACE("(%p)->(%lx %lu %lu)\n", This, grfBSCF, ulProgress, ulProgressMax);
1327
1328     if(!This->protocol_sink)
1329         return S_OK;
1330
1331     if(!do_direct_notif(This)) {
1332         report_data_task_t *task;
1333
1334         task = malloc(sizeof(report_data_task_t));
1335         if(!task)
1336             return E_OUTOFMEMORY;
1337
1338         task->bscf = grfBSCF;
1339         task->progress = ulProgress;
1340         task->progress_max = ulProgressMax;
1341
1342         push_task(This, &task->header, report_data_proc);
1343         return S_OK;
1344     }
1345
1346     return IInternetProtocolSink_ReportData(This->protocol_sink_handler,
1347             grfBSCF, ulProgress, ulProgressMax);
1348 }
1349
1350 typedef struct {
1351     task_header_t header;
1352
1353     HRESULT hres;
1354     DWORD err;
1355     LPWSTR str;
1356 } report_result_task_t;
1357
1358 static void report_result_proc(BindProtocol *This, task_header_t *t)
1359 {
1360     report_result_task_t *task = (report_result_task_t*)t;
1361
1362     IInternetProtocolSink_ReportResult(This->protocol_sink_handler, task->hres, task->err, task->str);
1363
1364     free(task->str);
1365     free(task);
1366 }
1367
1368 static HRESULT WINAPI BPInternetProtocolSink_ReportResult(IInternetProtocolSink *iface,
1369         HRESULT hrResult, DWORD dwError, LPCWSTR szResult)
1370 {
1371     BindProtocol *This = impl_from_IInternetProtocolSink(iface);
1372
1373     TRACE("(%p)->(%08lx %ld %s)\n", This, hrResult, dwError, debugstr_w(szResult));
1374
1375     if(!This->protocol_sink)
1376         return E_FAIL;
1377     This->reported_result = TRUE;
1378
1379     if(!do_direct_notif(This)) {
1380         report_result_task_t *task;
1381
1382         task = malloc(sizeof(report_result_task_t));
1383         if(!task)
1384             return E_OUTOFMEMORY;
1385
1386         task->hres = hrResult;
1387         task->err = dwError;
1388         task->str = wcsdup(szResult);
1389
1390         push_task(This, &task->header, report_result_proc);
1391         return S_OK;
1392     }
1393
1394     return IInternetProtocolSink_ReportResult(This->protocol_sink_handler, hrResult, dwError, szResult);
1395 }
1396
1397 static const IInternetProtocolSinkVtbl InternetProtocolSinkVtbl = {
1398     BPInternetProtocolSink_QueryInterface,
1399     BPInternetProtocolSink_AddRef,
1400     BPInternetProtocolSink_Release,
1401     BPInternetProtocolSink_Switch,
1402     BPInternetProtocolSink_ReportProgress,
1403     BPInternetProtocolSink_ReportData,
1404     BPInternetProtocolSink_ReportResult
1405 };
1406
1407 static inline BindProtocol *impl_from_IServiceProvider(IServiceProvider *iface)
1408 {
1409     return CONTAINING_RECORD(iface, BindProtocol, IServiceProvider_iface);
1410 }
1411
1412 static HRESULT WINAPI BPServiceProvider_QueryInterface(IServiceProvider *iface,
1413         REFIID riid, void **ppv)
1414 {
1415     BindProtocol *This = impl_from_IServiceProvider(iface);
1416     return IInternetProtocolEx_QueryInterface(&This->IInternetProtocolEx_iface, riid, ppv);
1417 }
1418
1419 static ULONG WINAPI BPServiceProvider_AddRef(IServiceProvider *iface)
1420 {
1421     BindProtocol *This = impl_from_IServiceProvider(iface);
1422     return IInternetProtocolEx_AddRef(&This->IInternetProtocolEx_iface);
1423 }
1424
1425 static ULONG WINAPI BPServiceProvider_Release(IServiceProvider *iface)
1426 {
1427     BindProtocol *This = impl_from_IServiceProvider(iface);
1428     return IInternetProtocolEx_Release(&This->IInternetProtocolEx_iface);
1429 }
1430
1431 static HRESULT WINAPI BPServiceProvider_QueryService(IServiceProvider *iface,
1432         REFGUID guidService, REFIID riid, void **ppv)
1433 {
1434     BindProtocol *This = impl_from_IServiceProvider(iface);
1435
1436     TRACE("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
1437
1438     if(!This->service_provider)
1439         return E_NOINTERFACE;
1440
1441     return IServiceProvider_QueryService(This->service_provider, guidService, riid, ppv);
1442 }
1443
1444 static const IServiceProviderVtbl ServiceProviderVtbl = {
1445     BPServiceProvider_QueryInterface,
1446     BPServiceProvider_AddRef,
1447     BPServiceProvider_Release,
1448     BPServiceProvider_QueryService
1449 };
1450
1451 HRESULT create_binding_protocol(BindProtocol **protocol)
1452 {
1453     BindProtocol *ret = calloc(1, sizeof(BindProtocol));
1454
1455     ret->IInternetProtocolEx_iface.lpVtbl   = &BindProtocolVtbl;
1456     ret->IInternetBindInfo_iface.lpVtbl     = &InternetBindInfoVtbl;
1457     ret->IInternetPriority_iface.lpVtbl     = &InternetPriorityVtbl;
1458     ret->IServiceProvider_iface.lpVtbl      = &ServiceProviderVtbl;
1459     ret->IInternetProtocolSink_iface.lpVtbl = &InternetProtocolSinkVtbl;
1460
1461     ret->default_protocol_handler.IInternetProtocol_iface.lpVtbl = &InternetProtocolHandlerVtbl;
1462     ret->default_protocol_handler.IInternetProtocolSink_iface.lpVtbl = &InternetProtocolSinkHandlerVtbl;
1463
1464     ret->ref = 1;
1465     ret->apartment_thread = GetCurrentThreadId();
1466     ret->notif_hwnd = get_notif_hwnd();
1467     ret->protocol_handler = &ret->default_protocol_handler.IInternetProtocol_iface;
1468     ret->protocol_sink_handler = &ret->default_protocol_handler.IInternetProtocolSink_iface;
1469     InitializeCriticalSection(&ret->section);
1470     ret->section.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": BindProtocol.section");
1471
1472     URLMON_LockModule();
1473
1474     *protocol = ret;
1475     return S_OK;
1476 }