urlmon: Use cache file to read in synchronous binding.
[wine] / 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 struct BindProtocol BindProtocol;
25
26 struct _task_header_t;
27
28 typedef void (*task_proc_t)(BindProtocol*,struct _task_header_t*);
29
30 typedef struct _task_header_t {
31     task_proc_t proc;
32     struct _task_header_t *next;
33 } task_header_t;
34
35 struct BindProtocol {
36     const IInternetProtocolVtbl      *lpIInternetProtocolVtbl;
37     const IInternetBindInfoVtbl      *lpInternetBindInfoVtbl;
38     const IInternetPriorityVtbl      *lpInternetPriorityVtbl;
39     const IServiceProviderVtbl       *lpServiceProviderVtbl;
40     const IInternetProtocolSinkVtbl  *lpIInternetProtocolSinkVtbl;
41     const IWinInetHttpInfoVtbl       *lpIWinInetHttpInfoVtbl;
42
43     const IInternetProtocolVtbl *lpIInternetProtocolHandlerVtbl;
44
45     LONG ref;
46
47     IInternetProtocol *protocol;
48     IInternetProtocol *protocol_handler;
49     IInternetBindInfo *bind_info;
50     IInternetProtocolSink *protocol_sink;
51     IServiceProvider *service_provider;
52     IWinInetInfo *wininet_info;
53
54     LONG priority;
55
56     BOOL reported_result;
57     BOOL reported_mime;
58     BOOL from_urlmon;
59     DWORD pi;
60
61     DWORD apartment_thread;
62     HWND notif_hwnd;
63     DWORD continue_call;
64
65     CRITICAL_SECTION section;
66     task_header_t *task_queue_head, *task_queue_tail;
67
68     BYTE *buf;
69     DWORD buf_size;
70     LPWSTR mime;
71     LPWSTR url;
72     ProtocolProxy *filter_proxy;
73 };
74
75 #define BINDINFO(x)  ((IInternetBindInfo*) &(x)->lpInternetBindInfoVtbl)
76 #define PRIORITY(x)  ((IInternetPriority*) &(x)->lpInternetPriorityVtbl)
77 #define HTTPINFO(x)  ((IWinInetHttpInfo*)  &(x)->lpIWinInetHttpInfoVtbl)
78 #define SERVPROV(x)  ((IServiceProvider*)  &(x)->lpServiceProviderVtbl)
79
80 #define PROTOCOLHANDLER(x)  ((IInternetProtocol*)  &(x)->lpIInternetProtocolHandlerVtbl)
81
82 #define BUFFER_SIZE     2048
83 #define MIME_TEST_SIZE  255
84
85 #define WM_MK_CONTINUE   (WM_USER+101)
86 #define WM_MK_RELEASE    (WM_USER+102)
87
88 static LRESULT WINAPI notif_wnd_proc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
89 {
90     switch(msg) {
91     case WM_MK_CONTINUE: {
92         BindProtocol *This = (BindProtocol*)lParam;
93         task_header_t *task;
94
95         while(1) {
96             EnterCriticalSection(&This->section);
97
98             task = This->task_queue_head;
99             if(task) {
100                 This->task_queue_head = task->next;
101                 if(!This->task_queue_head)
102                     This->task_queue_tail = NULL;
103             }
104
105             LeaveCriticalSection(&This->section);
106
107             if(!task)
108                 break;
109
110             This->continue_call++;
111             task->proc(This, task);
112             This->continue_call--;
113         }
114
115         IInternetProtocol_Release(PROTOCOL(This));
116         return 0;
117     }
118     case WM_MK_RELEASE: {
119         tls_data_t *data = get_tls_data();
120
121         if(!--data->notif_hwnd_cnt) {
122             DestroyWindow(hwnd);
123             data->notif_hwnd = NULL;
124         }
125     }
126     }
127
128     return DefWindowProcW(hwnd, msg, wParam, lParam);
129 }
130
131 HWND get_notif_hwnd(void)
132 {
133     static ATOM wnd_class = 0;
134     tls_data_t *tls_data;
135
136     static const WCHAR wszURLMonikerNotificationWindow[] =
137         {'U','R','L',' ','M','o','n','i','k','e','r',' ',
138          'N','o','t','i','f','i','c','a','t','i','o','n',' ','W','i','n','d','o','w',0};
139
140     tls_data = get_tls_data();
141     if(!tls_data)
142         return NULL;
143
144     if(tls_data->notif_hwnd_cnt) {
145         tls_data->notif_hwnd_cnt++;
146         return tls_data->notif_hwnd;
147     }
148
149     if(!wnd_class) {
150         static WNDCLASSEXW wndclass = {
151             sizeof(wndclass), 0,
152             notif_wnd_proc, 0, 0,
153             NULL, NULL, NULL, NULL, NULL,
154             wszURLMonikerNotificationWindow,
155             NULL
156         };
157
158         wndclass.hInstance = hProxyDll;
159
160         wnd_class = RegisterClassExW(&wndclass);
161         if (!wnd_class && GetLastError() == ERROR_CLASS_ALREADY_EXISTS)
162             wnd_class = 1;
163     }
164
165     tls_data->notif_hwnd = CreateWindowExW(0, wszURLMonikerNotificationWindow,
166             wszURLMonikerNotificationWindow, 0, 0, 0, 0, 0, HWND_MESSAGE,
167             NULL, hProxyDll, NULL);
168     if(tls_data->notif_hwnd)
169         tls_data->notif_hwnd_cnt++;
170
171     TRACE("hwnd = %p\n", tls_data->notif_hwnd);
172
173     return tls_data->notif_hwnd;
174 }
175
176 void release_notif_hwnd(HWND hwnd)
177 {
178     tls_data_t *data = get_tls_data();
179
180     if(!data)
181         return;
182
183     if(data->notif_hwnd != hwnd) {
184         PostMessageW(data->notif_hwnd, WM_MK_RELEASE, 0, 0);
185         return;
186     }
187
188     if(!--data->notif_hwnd_cnt) {
189         DestroyWindow(data->notif_hwnd);
190         data->notif_hwnd = NULL;
191     }
192 }
193
194 static void push_task(BindProtocol *This, task_header_t *task, task_proc_t proc)
195 {
196     BOOL do_post = FALSE;
197
198     task->proc = proc;
199     task->next = NULL;
200
201     EnterCriticalSection(&This->section);
202
203     if(This->task_queue_tail) {
204         This->task_queue_tail->next = task;
205         This->task_queue_tail = task;
206     }else {
207         This->task_queue_tail = This->task_queue_head = task;
208         do_post = !This->continue_call;
209     }
210
211     LeaveCriticalSection(&This->section);
212
213     if(do_post) {
214         IInternetProtocol_AddRef(PROTOCOL(This));
215         PostMessageW(This->notif_hwnd, WM_MK_CONTINUE, 0, (LPARAM)This);
216     }
217 }
218
219 static inline BOOL do_direct_notif(BindProtocol *This)
220 {
221     return !(This->pi & PI_APARTMENTTHREADED) || (This->apartment_thread == GetCurrentThreadId() && !This->continue_call);
222 }
223
224 static HRESULT handle_mime_filter(BindProtocol *This, IInternetProtocol *mime_filter, LPCWSTR mime)
225 {
226     PROTOCOLFILTERDATA filter_data = { sizeof(PROTOCOLFILTERDATA), NULL, NULL, NULL, 0 };
227     IInternetProtocolSink *protocol_sink, *old_sink;
228     ProtocolProxy *filter_proxy;
229     HRESULT hres;
230
231     hres = IInternetProtocol_QueryInterface(mime_filter, &IID_IInternetProtocolSink, (void**)&protocol_sink);
232     if(FAILED(hres))
233         return hres;
234
235     hres = create_protocol_proxy(PROTOCOLHANDLER(This), This->protocol_sink, &filter_proxy);
236     if(FAILED(hres)) {
237         IInternetProtocolSink_Release(protocol_sink);
238         return hres;
239     }
240
241     old_sink = This->protocol_sink;
242     This->protocol_sink = protocol_sink;
243     This->filter_proxy = filter_proxy;
244
245     IInternetProtocol_AddRef(mime_filter);
246     This->protocol_handler = mime_filter;
247
248     filter_data.pProtocol = PROTOCOL(filter_proxy);
249     hres = IInternetProtocol_Start(mime_filter, mime, PROTSINK(filter_proxy), BINDINFO(This),
250             PI_FILTER_MODE|PI_FORCE_ASYNC, (HANDLE_PTR)&filter_data);
251     if(FAILED(hres)) {
252         IInternetProtocolSink_Release(old_sink);
253         return hres;
254     }
255
256     IInternetProtocolSink_ReportProgress(old_sink, BINDSTATUS_LOADINGMIMEHANDLER, NULL);
257     IInternetProtocolSink_Release(old_sink);
258
259     This->pi &= ~PI_MIMEVERIFICATION; /* FIXME: more tests */
260     return S_OK;
261 }
262
263 static void mime_available(BindProtocol *This, LPCWSTR mime, BOOL verified)
264 {
265     IInternetProtocol *mime_filter;
266     HRESULT hres;
267
268     heap_free(This->mime);
269     This->mime = NULL;
270
271     mime_filter = get_mime_filter(mime);
272     if(mime_filter) {
273         TRACE("Got mime filter for %s\n", debugstr_w(mime));
274
275         hres = handle_mime_filter(This, mime_filter, mime);
276         IInternetProtocol_Release(mime_filter);
277         if(FAILED(hres))
278             FIXME("MIME filter failed: %08x\n", hres);
279     }else {
280         This->mime = heap_strdupW(mime);
281
282         if(verified || !(This->pi & PI_MIMEVERIFICATION)) {
283             This->reported_mime = TRUE;
284
285             if(This->protocol_sink)
286                 IInternetProtocolSink_ReportProgress(This->protocol_sink, BINDSTATUS_MIMETYPEAVAILABLE, mime);
287         }
288     }
289 }
290
291 #define PROTOCOL_THIS(iface) DEFINE_THIS(BindProtocol, IInternetProtocol, iface)
292
293 static HRESULT WINAPI BindProtocol_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
294 {
295     BindProtocol *This = PROTOCOL_THIS(iface);
296
297     *ppv = NULL;
298     if(IsEqualGUID(&IID_IUnknown, riid)) {
299         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
300         *ppv = PROTOCOL(This);
301     }else if(IsEqualGUID(&IID_IInternetProtocolRoot, riid)) {
302         TRACE("(%p)->(IID_IInternetProtocolRoot %p)\n", This, ppv);
303         *ppv = PROTOCOL(This);
304     }else if(IsEqualGUID(&IID_IInternetProtocol, riid)) {
305         TRACE("(%p)->(IID_IInternetProtocol %p)\n", This, ppv);
306         *ppv = PROTOCOL(This);
307     }else if(IsEqualGUID(&IID_IInternetBindInfo, riid)) {
308         TRACE("(%p)->(IID_IInternetBindInfo %p)\n", This, ppv);
309         *ppv = BINDINFO(This);
310     }else if(IsEqualGUID(&IID_IInternetPriority, riid)) {
311         TRACE("(%p)->(IID_IInternetPriority %p)\n", This, ppv);
312         *ppv = PRIORITY(This);
313     }else if(IsEqualGUID(&IID_IAuthenticate, riid)) {
314         FIXME("(%p)->(IID_IAuthenticate %p)\n", This, ppv);
315     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
316         TRACE("(%p)->(IID_IServiceProvider %p)\n", This, ppv);
317         *ppv = SERVPROV(This);
318     }else if(IsEqualGUID(&IID_IInternetProtocolSink, riid)) {
319         TRACE("(%p)->(IID_IInternetProtocolSink %p)\n", This, ppv);
320         *ppv = PROTSINK(This);
321     }else if(IsEqualGUID(&IID_IWinInetInfo, riid)) {
322         TRACE("(%p)->(IID_IWinInetInfo %p)\n", This, ppv);
323
324         if(This->protocol) {
325             IWinInetInfo *inet_info;
326             HRESULT hres;
327
328             hres = IInternetProtocol_QueryInterface(This->protocol, &IID_IWinInetInfo, (void**)&inet_info);
329             if(SUCCEEDED(hres)) {
330                 *ppv = HTTPINFO(This);
331                 IWinInetInfo_Release(inet_info);
332             }
333         }
334     }else if(IsEqualGUID(&IID_IWinInetHttpInfo, riid)) {
335         TRACE("(%p)->(IID_IWinInetHttpInfo %p)\n", This, ppv);
336
337         if(This->protocol) {
338             IWinInetHttpInfo *http_info;
339             HRESULT hres;
340
341             hres = IInternetProtocol_QueryInterface(This->protocol, &IID_IWinInetHttpInfo, (void**)&http_info);
342             if(SUCCEEDED(hres)) {
343                 *ppv = HTTPINFO(This);
344                 IWinInetHttpInfo_Release(http_info);
345             }
346         }
347     }else {
348         WARN("not supported interface %s\n", debugstr_guid(riid));
349     }
350
351     if(!*ppv)
352         return E_NOINTERFACE;
353
354     IUnknown_AddRef((IUnknown*)*ppv);
355     return S_OK;
356 }
357
358 static ULONG WINAPI BindProtocol_AddRef(IInternetProtocol *iface)
359 {
360     BindProtocol *This = PROTOCOL_THIS(iface);
361     LONG ref = InterlockedIncrement(&This->ref);
362     TRACE("(%p) ref=%d\n", This, ref);
363     return ref;
364 }
365
366 static ULONG WINAPI BindProtocol_Release(IInternetProtocol *iface)
367 {
368     BindProtocol *This = PROTOCOL_THIS(iface);
369     LONG ref = InterlockedDecrement(&This->ref);
370
371     TRACE("(%p) ref=%d\n", This, ref);
372
373     if(!ref) {
374         if(This->wininet_info)
375             IWinInetInfo_Release(This->wininet_info);
376         if(This->protocol)
377             IInternetProtocol_Release(This->protocol);
378         if(This->bind_info)
379             IInternetBindInfo_Release(This->bind_info);
380         if(This->protocol_handler && This->protocol_handler != PROTOCOLHANDLER(This))
381             IInternetProtocol_Release(This->protocol_handler);
382         if(This->filter_proxy)
383             IInternetProtocol_Release(PROTOCOL(This->filter_proxy));
384
385         set_binding_sink(PROTOCOL(This), NULL);
386
387         if(This->notif_hwnd)
388             release_notif_hwnd(This->notif_hwnd);
389         DeleteCriticalSection(&This->section);
390
391         heap_free(This->mime);
392         heap_free(This->url);
393         heap_free(This);
394
395         URLMON_UnlockModule();
396     }
397
398     return ref;
399 }
400
401 static HRESULT WINAPI BindProtocol_Start(IInternetProtocol *iface, LPCWSTR szUrl,
402         IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
403         DWORD grfPI, HANDLE_PTR dwReserved)
404 {
405     BindProtocol *This = PROTOCOL_THIS(iface);
406
407     TRACE("(%p)->(%s %p %p %08x %lx)\n", This, debugstr_w(szUrl), pOIProtSink,
408             pOIBindInfo, grfPI, dwReserved);
409
410     return IInternetProtocol_Start(This->protocol_handler, szUrl, pOIProtSink, pOIBindInfo, grfPI, dwReserved);
411 }
412
413 static HRESULT WINAPI BindProtocol_Continue(IInternetProtocol *iface, PROTOCOLDATA *pProtocolData)
414 {
415     BindProtocol *This = PROTOCOL_THIS(iface);
416
417     TRACE("(%p)->(%p)\n", This, pProtocolData);
418
419     return IInternetProtocol_Continue(This->protocol_handler, pProtocolData);
420 }
421
422 static HRESULT WINAPI BindProtocol_Abort(IInternetProtocol *iface, HRESULT hrReason,
423         DWORD dwOptions)
424 {
425     BindProtocol *This = PROTOCOL_THIS(iface);
426     FIXME("(%p)->(%08x %08x)\n", This, hrReason, dwOptions);
427     return E_NOTIMPL;
428 }
429
430 static HRESULT WINAPI BindProtocol_Terminate(IInternetProtocol *iface, DWORD dwOptions)
431 {
432     BindProtocol *This = PROTOCOL_THIS(iface);
433
434     TRACE("(%p)->(%08x)\n", This, dwOptions);
435
436     return IInternetProtocol_Terminate(This->protocol_handler, dwOptions);
437 }
438
439 static HRESULT WINAPI BindProtocol_Suspend(IInternetProtocol *iface)
440 {
441     BindProtocol *This = PROTOCOL_THIS(iface);
442     FIXME("(%p)\n", This);
443     return E_NOTIMPL;
444 }
445
446 static HRESULT WINAPI BindProtocol_Resume(IInternetProtocol *iface)
447 {
448     BindProtocol *This = PROTOCOL_THIS(iface);
449     FIXME("(%p)\n", This);
450     return E_NOTIMPL;
451 }
452
453 static HRESULT WINAPI BindProtocol_Read(IInternetProtocol *iface, void *pv,
454         ULONG cb, ULONG *pcbRead)
455 {
456     BindProtocol *This = PROTOCOL_THIS(iface);
457
458     TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead);
459
460     if(pcbRead)
461         *pcbRead = 0;
462     return IInternetProtocol_Read(This->protocol_handler, pv, cb, pcbRead);
463 }
464
465 static HRESULT WINAPI BindProtocol_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove,
466         DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
467 {
468     BindProtocol *This = PROTOCOL_THIS(iface);
469     FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
470     return E_NOTIMPL;
471 }
472
473 static HRESULT WINAPI BindProtocol_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
474 {
475     BindProtocol *This = PROTOCOL_THIS(iface);
476
477     TRACE("(%p)->(%08x)\n", This, dwOptions);
478
479     return IInternetProtocol_LockRequest(This->protocol_handler, dwOptions);
480 }
481
482 static HRESULT WINAPI BindProtocol_UnlockRequest(IInternetProtocol *iface)
483 {
484     BindProtocol *This = PROTOCOL_THIS(iface);
485
486     TRACE("(%p)\n", This);
487
488     return IInternetProtocol_UnlockRequest(This->protocol_handler);
489 }
490
491 void set_binding_sink(IInternetProtocol *bind_protocol, IInternetProtocolSink *sink)
492 {
493     BindProtocol *This = PROTOCOL_THIS(bind_protocol);
494     IInternetProtocolSink *prev_sink;
495     IServiceProvider *service_provider = NULL;
496
497     if(sink)
498         IInternetProtocolSink_AddRef(sink);
499     prev_sink = InterlockedExchangePointer((void**)&This->protocol_sink, sink);
500     if(prev_sink)
501         IInternetProtocolSink_Release(prev_sink);
502
503     if(sink)
504         IInternetProtocolSink_QueryInterface(sink, &IID_IServiceProvider, (void**)&service_provider);
505     service_provider = InterlockedExchangePointer((void**)&This->service_provider, service_provider);
506     if(service_provider)
507         IServiceProvider_Release(service_provider);
508 }
509
510 IWinInetInfo *get_wininet_info(IInternetProtocol *bind_protocol)
511 {
512     BindProtocol *This = PROTOCOL_THIS(bind_protocol);
513
514     return This->wininet_info;
515 }
516
517 #undef PROTOCOL_THIS
518
519 static const IInternetProtocolVtbl BindProtocolVtbl = {
520     BindProtocol_QueryInterface,
521     BindProtocol_AddRef,
522     BindProtocol_Release,
523     BindProtocol_Start,
524     BindProtocol_Continue,
525     BindProtocol_Abort,
526     BindProtocol_Terminate,
527     BindProtocol_Suspend,
528     BindProtocol_Resume,
529     BindProtocol_Read,
530     BindProtocol_Seek,
531     BindProtocol_LockRequest,
532     BindProtocol_UnlockRequest
533 };
534
535 #define PROTOCOLHANDLER_THIS(iface) DEFINE_THIS(BindProtocol, IInternetProtocolHandler, iface)
536
537 static HRESULT WINAPI ProtocolHandler_QueryInterface(IInternetProtocol *iface, REFIID riid, void **ppv)
538 {
539     ERR("should not be called\n");
540     return E_NOINTERFACE;
541 }
542
543 static ULONG WINAPI ProtocolHandler_AddRef(IInternetProtocol *iface)
544 {
545     BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
546     return IInternetProtocol_AddRef(PROTOCOL(This));
547 }
548
549 static ULONG WINAPI ProtocolHandler_Release(IInternetProtocol *iface)
550 {
551     BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
552     return IInternetProtocol_Release(PROTOCOL(This));
553 }
554
555 static HRESULT WINAPI ProtocolHandler_Start(IInternetProtocol *iface, LPCWSTR szUrl,
556         IInternetProtocolSink *pOIProtSink, IInternetBindInfo *pOIBindInfo,
557         DWORD grfPI, HANDLE_PTR dwReserved)
558 {
559     BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
560     IInternetProtocol *protocol = NULL;
561     IInternetPriority *priority;
562     IServiceProvider *service_provider;
563     BOOL urlmon_protocol = FALSE;
564     CLSID clsid = IID_NULL;
565     LPOLESTR clsid_str;
566     HRESULT hres;
567
568     TRACE("(%p)->(%s %p %p %08x %lx)\n", This, debugstr_w(szUrl), pOIProtSink,
569             pOIBindInfo, grfPI, dwReserved);
570
571     if(!szUrl || !pOIProtSink || !pOIBindInfo)
572         return E_INVALIDARG;
573
574     This->pi = grfPI;
575     This->url = heap_strdupW(szUrl);
576
577     hres = IInternetProtocolSink_QueryInterface(pOIProtSink, &IID_IServiceProvider,
578                                                 (void**)&service_provider);
579     if(SUCCEEDED(hres)) {
580         /* FIXME: What's protocol CLSID here? */
581         IServiceProvider_QueryService(service_provider, &IID_IInternetProtocol,
582                                       &IID_IInternetProtocol, (void**)&protocol);
583         IServiceProvider_Release(service_provider);
584     }
585
586     if(!protocol) {
587         IClassFactory *cf;
588         IUnknown *unk;
589
590         hres = get_protocol_handler(szUrl, &clsid, &urlmon_protocol, &cf);
591         if(FAILED(hres))
592             return hres;
593
594         if(This->from_urlmon) {
595             hres = IClassFactory_CreateInstance(cf, NULL, &IID_IInternetProtocol, (void**)&protocol);
596             IClassFactory_Release(cf);
597             if(FAILED(hres))
598                 return hres;
599         }else {
600             hres = IClassFactory_CreateInstance(cf, (IUnknown*)BINDINFO(This),
601                     &IID_IUnknown, (void**)&unk);
602             IClassFactory_Release(cf);
603             if(FAILED(hres))
604                 return hres;
605
606             hres = IUnknown_QueryInterface(unk, &IID_IInternetProtocol, (void**)&protocol);
607             IUnknown_Release(unk);
608             if(FAILED(hres))
609                 return hres;
610         }
611     }
612
613     StringFromCLSID(&clsid, &clsid_str);
614     IInternetProtocolSink_ReportProgress(pOIProtSink, BINDSTATUS_PROTOCOLCLASSID, clsid_str);
615     CoTaskMemFree(clsid_str);
616
617     This->protocol = protocol;
618
619     if(urlmon_protocol)
620         IInternetProtocol_QueryInterface(protocol, &IID_IWinInetInfo, (void**)&This->wininet_info);
621
622     IInternetBindInfo_AddRef(pOIBindInfo);
623     This->bind_info = pOIBindInfo;
624
625     set_binding_sink(PROTOCOL(This), pOIProtSink);
626
627     hres = IInternetProtocol_QueryInterface(protocol, &IID_IInternetPriority, (void**)&priority);
628     if(SUCCEEDED(hres)) {
629         IInternetPriority_SetPriority(priority, This->priority);
630         IInternetPriority_Release(priority);
631     }
632
633     return IInternetProtocol_Start(protocol, szUrl, PROTSINK(This), BINDINFO(This), 0, 0);
634 }
635
636 static HRESULT WINAPI ProtocolHandler_Continue(IInternetProtocol *iface, PROTOCOLDATA *pProtocolData)
637 {
638     BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
639     HRESULT hres;
640
641     TRACE("(%p)->(%p)\n", This, pProtocolData);
642
643     hres = IInternetProtocol_Continue(This->protocol, pProtocolData);
644
645     heap_free(pProtocolData);
646     return hres;
647 }
648
649 static HRESULT WINAPI ProtocolHandler_Abort(IInternetProtocol *iface, HRESULT hrReason,
650         DWORD dwOptions)
651 {
652     BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
653     FIXME("(%p)->(%08x %08x)\n", This, hrReason, dwOptions);
654     return E_NOTIMPL;
655 }
656
657 static HRESULT WINAPI ProtocolHandler_Terminate(IInternetProtocol *iface, DWORD dwOptions)
658 {
659     BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
660
661     TRACE("(%p)->(%08x)\n", This, dwOptions);
662
663     if(!This->reported_result)
664         return E_FAIL;
665
666     IInternetProtocol_Terminate(This->protocol, 0);
667
668     if(This->filter_proxy) {
669         IInternetProtocol_Release(PROTOCOL(This->filter_proxy));
670         This->filter_proxy = NULL;
671     }
672
673     set_binding_sink(PROTOCOL(This), NULL);
674
675     if(This->bind_info) {
676         IInternetBindInfo_Release(This->bind_info);
677         This->bind_info = NULL;
678     }
679
680     return S_OK;
681 }
682
683 static HRESULT WINAPI ProtocolHandler_Suspend(IInternetProtocol *iface)
684 {
685     BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
686     FIXME("(%p)\n", This);
687     return E_NOTIMPL;
688 }
689
690 static HRESULT WINAPI ProtocolHandler_Resume(IInternetProtocol *iface)
691 {
692     BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
693     FIXME("(%p)\n", This);
694     return E_NOTIMPL;
695 }
696
697 static HRESULT WINAPI ProtocolHandler_Read(IInternetProtocol *iface, void *pv,
698         ULONG cb, ULONG *pcbRead)
699 {
700     BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
701     ULONG read = 0;
702     HRESULT hres = S_OK;
703
704     TRACE("(%p)->(%p %u %p)\n", This, pv, cb, pcbRead);
705
706     if(This->buf_size) {
707         read = min(cb, This->buf_size);
708         memcpy(pv, This->buf, read);
709
710         if(read == This->buf_size) {
711             heap_free(This->buf);
712             This->buf = NULL;
713         }else {
714             memmove(This->buf, This->buf+cb, This->buf_size-cb);
715         }
716
717         This->buf_size -= read;
718     }
719
720     if(read < cb) {
721         ULONG cread = 0;
722
723         hres = IInternetProtocol_Read(This->protocol, (BYTE*)pv+read, cb-read, &cread);
724         read += cread;
725     }
726
727     *pcbRead = read;
728     return hres;
729 }
730
731 static HRESULT WINAPI ProtocolHandler_Seek(IInternetProtocol *iface, LARGE_INTEGER dlibMove,
732         DWORD dwOrigin, ULARGE_INTEGER *plibNewPosition)
733 {
734     BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
735     FIXME("(%p)->(%d %d %p)\n", This, dlibMove.u.LowPart, dwOrigin, plibNewPosition);
736     return E_NOTIMPL;
737 }
738
739 static HRESULT WINAPI ProtocolHandler_LockRequest(IInternetProtocol *iface, DWORD dwOptions)
740 {
741     BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
742
743     TRACE("(%p)->(%08x)\n", This, dwOptions);
744
745     return IInternetProtocol_LockRequest(This->protocol, dwOptions);
746 }
747
748 static HRESULT WINAPI ProtocolHandler_UnlockRequest(IInternetProtocol *iface)
749 {
750     BindProtocol *This = PROTOCOLHANDLER_THIS(iface);
751
752     TRACE("(%p)\n", This);
753
754     return IInternetProtocol_UnlockRequest(This->protocol);
755 }
756
757 #undef PROTOCOL_THIS
758
759 static const IInternetProtocolVtbl InternetProtocolHandlerVtbl = {
760     ProtocolHandler_QueryInterface,
761     ProtocolHandler_AddRef,
762     ProtocolHandler_Release,
763     ProtocolHandler_Start,
764     ProtocolHandler_Continue,
765     ProtocolHandler_Abort,
766     ProtocolHandler_Terminate,
767     ProtocolHandler_Suspend,
768     ProtocolHandler_Resume,
769     ProtocolHandler_Read,
770     ProtocolHandler_Seek,
771     ProtocolHandler_LockRequest,
772     ProtocolHandler_UnlockRequest
773 };
774
775 #define BINDINFO_THIS(iface) DEFINE_THIS(BindProtocol, InternetBindInfo, iface)
776
777 static HRESULT WINAPI BindInfo_QueryInterface(IInternetBindInfo *iface,
778         REFIID riid, void **ppv)
779 {
780     BindProtocol *This = BINDINFO_THIS(iface);
781     return IInternetProtocol_QueryInterface(PROTOCOL(This), riid, ppv);
782 }
783
784 static ULONG WINAPI BindInfo_AddRef(IInternetBindInfo *iface)
785 {
786     BindProtocol *This = BINDINFO_THIS(iface);
787     return IBinding_AddRef(PROTOCOL(This));
788 }
789
790 static ULONG WINAPI BindInfo_Release(IInternetBindInfo *iface)
791 {
792     BindProtocol *This = BINDINFO_THIS(iface);
793     return IBinding_Release(PROTOCOL(This));
794 }
795
796 static HRESULT WINAPI BindInfo_GetBindInfo(IInternetBindInfo *iface,
797         DWORD *grfBINDF, BINDINFO *pbindinfo)
798 {
799     BindProtocol *This = BINDINFO_THIS(iface);
800     HRESULT hres;
801
802     TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
803
804     hres = IInternetBindInfo_GetBindInfo(This->bind_info, grfBINDF, pbindinfo);
805     if(FAILED(hres)) {
806         WARN("GetBindInfo failed: %08x\n", hres);
807         return hres;
808     }
809
810     *grfBINDF |= BINDF_FROMURLMON;
811     return hres;
812 }
813
814 static HRESULT WINAPI BindInfo_GetBindString(IInternetBindInfo *iface,
815         ULONG ulStringType, LPOLESTR *ppwzStr, ULONG cEl, ULONG *pcElFetched)
816 {
817     BindProtocol *This = BINDINFO_THIS(iface);
818
819     TRACE("(%p)->(%d %p %d %p)\n", This, ulStringType, ppwzStr, cEl, pcElFetched);
820
821     return IInternetBindInfo_GetBindString(This->bind_info, ulStringType, ppwzStr, cEl, pcElFetched);
822 }
823
824 #undef BINDFO_THIS
825
826 static const IInternetBindInfoVtbl InternetBindInfoVtbl = {
827     BindInfo_QueryInterface,
828     BindInfo_AddRef,
829     BindInfo_Release,
830     BindInfo_GetBindInfo,
831     BindInfo_GetBindString
832 };
833
834 #define PRIORITY_THIS(iface) DEFINE_THIS(BindProtocol, InternetPriority, iface)
835
836 static HRESULT WINAPI InternetPriority_QueryInterface(IInternetPriority *iface,
837         REFIID riid, void **ppv)
838 {
839     BindProtocol *This = PRIORITY_THIS(iface);
840     return IInternetProtocol_QueryInterface(PROTOCOL(This), riid, ppv);
841 }
842
843 static ULONG WINAPI InternetPriority_AddRef(IInternetPriority *iface)
844 {
845     BindProtocol *This = PRIORITY_THIS(iface);
846     return IInternetProtocol_AddRef(PROTOCOL(This));
847 }
848
849 static ULONG WINAPI InternetPriority_Release(IInternetPriority *iface)
850 {
851     BindProtocol *This = PRIORITY_THIS(iface);
852     return IInternetProtocol_Release(PROTOCOL(This));
853 }
854
855 static HRESULT WINAPI InternetPriority_SetPriority(IInternetPriority *iface, LONG nPriority)
856 {
857     BindProtocol *This = PRIORITY_THIS(iface);
858
859     TRACE("(%p)->(%d)\n", This, nPriority);
860
861     This->priority = nPriority;
862     return S_OK;
863 }
864
865 static HRESULT WINAPI InternetPriority_GetPriority(IInternetPriority *iface, LONG *pnPriority)
866 {
867     BindProtocol *This = PRIORITY_THIS(iface);
868
869     TRACE("(%p)->(%p)\n", This, pnPriority);
870
871     *pnPriority = This->priority;
872     return S_OK;
873 }
874
875 #undef PRIORITY_THIS
876
877 static const IInternetPriorityVtbl InternetPriorityVtbl = {
878     InternetPriority_QueryInterface,
879     InternetPriority_AddRef,
880     InternetPriority_Release,
881     InternetPriority_SetPriority,
882     InternetPriority_GetPriority
883
884 };
885
886 #define PROTSINK_THIS(iface) DEFINE_THIS(BindProtocol, IInternetProtocolSink, iface)
887
888 static HRESULT WINAPI BPInternetProtocolSink_QueryInterface(IInternetProtocolSink *iface,
889         REFIID riid, void **ppv)
890 {
891     BindProtocol *This = PROTSINK_THIS(iface);
892     return IInternetProtocol_QueryInterface(PROTOCOL(This), riid, ppv);
893 }
894
895 static ULONG WINAPI BPInternetProtocolSink_AddRef(IInternetProtocolSink *iface)
896 {
897     BindProtocol *This = PROTSINK_THIS(iface);
898     return IInternetProtocol_AddRef(PROTOCOL(This));
899 }
900
901 static ULONG WINAPI BPInternetProtocolSink_Release(IInternetProtocolSink *iface)
902 {
903     BindProtocol *This = PROTSINK_THIS(iface);
904     return IInternetProtocol_Release(PROTOCOL(This));
905 }
906
907 typedef struct {
908     task_header_t header;
909     PROTOCOLDATA *data;
910 } switch_task_t;
911
912 static void switch_proc(BindProtocol *bind, task_header_t *t)
913 {
914     switch_task_t *task = (switch_task_t*)t;
915
916     IInternetProtocol_Continue(bind->protocol_handler, task->data);
917
918     heap_free(task);
919 }
920
921 static HRESULT WINAPI BPInternetProtocolSink_Switch(IInternetProtocolSink *iface,
922         PROTOCOLDATA *pProtocolData)
923 {
924     BindProtocol *This = PROTSINK_THIS(iface);
925     PROTOCOLDATA *data;
926
927     TRACE("(%p)->(%p)\n", This, pProtocolData);
928
929     TRACE("flags %x state %x data %p cb %u\n", pProtocolData->grfFlags, pProtocolData->dwState,
930           pProtocolData->pData, pProtocolData->cbData);
931
932     data = heap_alloc(sizeof(PROTOCOLDATA));
933     if(!data)
934         return E_OUTOFMEMORY;
935     memcpy(data, pProtocolData, sizeof(PROTOCOLDATA));
936
937     if(!do_direct_notif(This)) {
938         switch_task_t *task;
939
940         task = heap_alloc(sizeof(switch_task_t));
941         if(!task)
942             return E_OUTOFMEMORY;
943
944         task->data = data;
945
946         push_task(This, &task->header, switch_proc);
947         return S_OK;
948     }
949
950     if(!This->protocol_sink) {
951         IInternetProtocol_Continue(This->protocol_handler, data);
952         return S_OK;
953     }
954
955     return IInternetProtocolSink_Switch(This->protocol_sink, data);
956 }
957
958 static void report_progress(BindProtocol *This, ULONG status_code, LPCWSTR status_text)
959 {
960     switch(status_code) {
961     case BINDSTATUS_FINDINGRESOURCE:
962     case BINDSTATUS_CONNECTING:
963     case BINDSTATUS_REDIRECTING:
964     case BINDSTATUS_BEGINDOWNLOADDATA:
965     case BINDSTATUS_SENDINGREQUEST:
966     case BINDSTATUS_CACHEFILENAMEAVAILABLE:
967     case BINDSTATUS_DIRECTBIND:
968     case BINDSTATUS_ACCEPTRANGES:
969         if(This->protocol_sink)
970             IInternetProtocolSink_ReportProgress(This->protocol_sink, status_code, status_text);
971         break;
972
973     case BINDSTATUS_MIMETYPEAVAILABLE:
974         mime_available(This, status_text, FALSE);
975         break;
976
977     case BINDSTATUS_VERIFIEDMIMETYPEAVAILABLE:
978         mime_available(This, status_text, TRUE);
979         break;
980
981     default:
982         FIXME("unsupported ulStatusCode %u\n", status_code);
983     }
984 }
985
986 typedef struct {
987     task_header_t header;
988
989     ULONG status_code;
990     LPWSTR status_text;
991 } on_progress_task_t;
992
993 static void on_progress_proc(BindProtocol *This, task_header_t *t)
994 {
995     on_progress_task_t *task = (on_progress_task_t*)t;
996
997     report_progress(This, task->status_code, task->status_text);
998
999     heap_free(task->status_text);
1000     heap_free(task);
1001 }
1002
1003 static HRESULT WINAPI BPInternetProtocolSink_ReportProgress(IInternetProtocolSink *iface,
1004         ULONG ulStatusCode, LPCWSTR szStatusText)
1005 {
1006     BindProtocol *This = PROTSINK_THIS(iface);
1007
1008     TRACE("(%p)->(%u %s)\n", This, ulStatusCode, debugstr_w(szStatusText));
1009
1010     if(do_direct_notif(This)) {
1011         report_progress(This, ulStatusCode, szStatusText);
1012     }else {
1013         on_progress_task_t *task;
1014
1015         task = heap_alloc(sizeof(on_progress_task_t));
1016
1017         task->status_code = ulStatusCode;
1018         task->status_text = heap_strdupW(szStatusText);
1019
1020         push_task(This, &task->header, on_progress_proc);
1021     }
1022
1023     return S_OK;
1024 }
1025
1026 static HRESULT report_data(BindProtocol *This, DWORD bscf, ULONG progress, ULONG progress_max)
1027 {
1028     if(!This->protocol_sink)
1029         return S_OK;
1030
1031     if((This->pi & PI_MIMEVERIFICATION) && !This->reported_mime) {
1032         BYTE buf[BUFFER_SIZE];
1033         DWORD read = 0;
1034         LPWSTR mime;
1035         HRESULT hres;
1036
1037         do {
1038             read = 0;
1039             hres = IInternetProtocol_Read(This->protocol, buf,
1040                     sizeof(buf)-This->buf_size, &read);
1041             if(FAILED(hres) && hres != E_PENDING)
1042                 return hres;
1043
1044             if(!This->buf) {
1045                 This->buf = heap_alloc(BUFFER_SIZE);
1046                 if(!This->buf)
1047                     return E_OUTOFMEMORY;
1048             }else if(read + This->buf_size > BUFFER_SIZE) {
1049                 BYTE *tmp;
1050
1051                 tmp = heap_realloc(This->buf, read+This->buf_size);
1052                 if(!tmp)
1053                     return E_OUTOFMEMORY;
1054                 This->buf = tmp;
1055             }
1056
1057             memcpy(This->buf+This->buf_size, buf, read);
1058             This->buf_size += read;
1059         }while(This->buf_size < MIME_TEST_SIZE && hres == S_OK);
1060
1061         if(This->buf_size < MIME_TEST_SIZE && hres != S_FALSE)
1062             return S_OK;
1063
1064         bscf = BSCF_FIRSTDATANOTIFICATION;
1065         if(hres == S_FALSE)
1066             bscf |= BSCF_LASTDATANOTIFICATION|BSCF_DATAFULLYAVAILABLE;
1067
1068         if(!This->reported_mime) {
1069             hres = FindMimeFromData(NULL, This->url, This->buf, min(This->buf_size, MIME_TEST_SIZE),
1070                     This->mime, 0, &mime, 0);
1071             if(FAILED(hres))
1072                 return hres;
1073
1074             mime_available(This, mime, TRUE);
1075             CoTaskMemFree(mime);
1076         }
1077     }
1078
1079     if(!This->protocol_sink)
1080         return S_OK;
1081
1082     return IInternetProtocolSink_ReportData(This->protocol_sink, bscf, progress, progress_max);
1083 }
1084
1085 typedef struct {
1086     task_header_t header;
1087     DWORD bscf;
1088     ULONG progress;
1089     ULONG progress_max;
1090 } report_data_task_t;
1091
1092 static void report_data_proc(BindProtocol *This, task_header_t *t)
1093 {
1094     report_data_task_t *task = (report_data_task_t*)t;
1095
1096     report_data(This, task->bscf, task->progress, task->progress_max);
1097     heap_free(task);
1098 }
1099
1100 static HRESULT WINAPI BPInternetProtocolSink_ReportData(IInternetProtocolSink *iface,
1101         DWORD grfBSCF, ULONG ulProgress, ULONG ulProgressMax)
1102 {
1103     BindProtocol *This = PROTSINK_THIS(iface);
1104
1105     TRACE("(%p)->(%d %u %u)\n", This, grfBSCF, ulProgress, ulProgressMax);
1106
1107     if(!This->protocol_sink)
1108         return S_OK;
1109
1110     if(!do_direct_notif(This)) {
1111         report_data_task_t *task;
1112
1113         task = heap_alloc(sizeof(report_data_task_t));
1114         if(!task)
1115             return E_OUTOFMEMORY;
1116
1117         task->bscf = grfBSCF;
1118         task->progress = ulProgress;
1119         task->progress_max = ulProgressMax;
1120
1121         push_task(This, &task->header, report_data_proc);
1122         return S_OK;
1123     }
1124
1125     return report_data(This, grfBSCF, ulProgress, ulProgressMax);
1126 }
1127
1128 typedef struct {
1129     task_header_t header;
1130
1131     HRESULT hres;
1132     DWORD err;
1133     LPWSTR str;
1134 } report_result_task_t;
1135
1136 static void report_result_proc(BindProtocol *This, task_header_t *t)
1137 {
1138     report_result_task_t *task = (report_result_task_t*)t;
1139
1140     if(This->protocol_sink)
1141         IInternetProtocolSink_ReportResult(This->protocol_sink, task->hres, task->err, task->str);
1142
1143     heap_free(task->str);
1144     heap_free(task);
1145 }
1146
1147 static HRESULT WINAPI BPInternetProtocolSink_ReportResult(IInternetProtocolSink *iface,
1148         HRESULT hrResult, DWORD dwError, LPCWSTR szResult)
1149 {
1150     BindProtocol *This = PROTSINK_THIS(iface);
1151
1152     TRACE("(%p)->(%08x %d %s)\n", This, hrResult, dwError, debugstr_w(szResult));
1153
1154     if(!This->protocol_sink)
1155         return E_FAIL;
1156
1157     This->reported_result = TRUE;
1158
1159     if(!do_direct_notif(This)) {
1160         report_result_task_t *task;
1161
1162         task = heap_alloc(sizeof(report_result_task_t));
1163         if(!task)
1164             return E_OUTOFMEMORY;
1165
1166         task->hres = hrResult;
1167         task->err = dwError;
1168         task->str = heap_strdupW(szResult);
1169
1170         push_task(This, &task->header, report_result_proc);
1171         return S_OK;
1172     }
1173
1174     return IInternetProtocolSink_ReportResult(This->protocol_sink, hrResult, dwError, szResult);
1175 }
1176
1177 #undef PROTSINK_THIS
1178
1179 static const IInternetProtocolSinkVtbl InternetProtocolSinkVtbl = {
1180     BPInternetProtocolSink_QueryInterface,
1181     BPInternetProtocolSink_AddRef,
1182     BPInternetProtocolSink_Release,
1183     BPInternetProtocolSink_Switch,
1184     BPInternetProtocolSink_ReportProgress,
1185     BPInternetProtocolSink_ReportData,
1186     BPInternetProtocolSink_ReportResult
1187 };
1188
1189 #define INETINFO_THIS(iface) DEFINE_THIS(BindProtocol, IWinInetHttpInfo, iface)
1190
1191 static HRESULT WINAPI WinInetHttpInfo_QueryInterface(IWinInetHttpInfo *iface, REFIID riid, void **ppv)
1192 {
1193     BindProtocol *This = INETINFO_THIS(iface);
1194     return IInternetProtocol_QueryInterface(PROTOCOL(This), riid, ppv);
1195 }
1196
1197 static ULONG WINAPI WinInetHttpInfo_AddRef(IWinInetHttpInfo *iface)
1198 {
1199     BindProtocol *This = INETINFO_THIS(iface);
1200     return IInternetProtocol_AddRef(PROTOCOL(This));
1201 }
1202
1203 static ULONG WINAPI WinInetHttpInfo_Release(IWinInetHttpInfo *iface)
1204 {
1205     BindProtocol *This = INETINFO_THIS(iface);
1206     return IInternetProtocol_Release(PROTOCOL(This));
1207 }
1208
1209 static HRESULT WINAPI WinInetHttpInfo_QueryOption(IWinInetHttpInfo *iface, DWORD dwOption,
1210         void *pBuffer, DWORD *pcbBuffer)
1211 {
1212     BindProtocol *This = INETINFO_THIS(iface);
1213     FIXME("(%p)->(%x %p %p)\n", This, dwOption, pBuffer, pcbBuffer);
1214     return E_NOTIMPL;
1215 }
1216
1217 static HRESULT WINAPI WinInetHttpInfo_QueryInfo(IWinInetHttpInfo *iface, DWORD dwOption,
1218         void *pBuffer, DWORD *pcbBuffer, DWORD *pdwFlags, DWORD *pdwReserved)
1219 {
1220     BindProtocol *This = INETINFO_THIS(iface);
1221     FIXME("(%p)->(%x %p %p %p %p)\n", This, dwOption, pBuffer, pcbBuffer, pdwFlags, pdwReserved);
1222     return E_NOTIMPL;
1223 }
1224
1225 #undef INETINFO_THIS
1226
1227 static const IWinInetHttpInfoVtbl WinInetHttpInfoVtbl = {
1228     WinInetHttpInfo_QueryInterface,
1229     WinInetHttpInfo_AddRef,
1230     WinInetHttpInfo_Release,
1231     WinInetHttpInfo_QueryOption,
1232     WinInetHttpInfo_QueryInfo
1233 };
1234
1235 #define SERVPROV_THIS(iface) DEFINE_THIS(BindProtocol, ServiceProvider, iface)
1236
1237 static HRESULT WINAPI BPServiceProvider_QueryInterface(IServiceProvider *iface,
1238         REFIID riid, void **ppv)
1239 {
1240     BindProtocol *This = SERVPROV_THIS(iface);
1241     return IInternetProtocol_QueryInterface(PROTOCOL(This), riid, ppv);
1242 }
1243
1244 static ULONG WINAPI BPServiceProvider_AddRef(IServiceProvider *iface)
1245 {
1246     BindProtocol *This = SERVPROV_THIS(iface);
1247     return IInternetProtocol_AddRef(PROTOCOL(This));
1248 }
1249
1250 static ULONG WINAPI BPServiceProvider_Release(IServiceProvider *iface)
1251 {
1252     BindProtocol *This = SERVPROV_THIS(iface);
1253     return IInternetProtocol_Release(PROTOCOL(This));
1254 }
1255
1256 static HRESULT WINAPI BPServiceProvider_QueryService(IServiceProvider *iface,
1257         REFGUID guidService, REFIID riid, void **ppv)
1258 {
1259     BindProtocol *This = SERVPROV_THIS(iface);
1260
1261     TRACE("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
1262
1263     if(!This->service_provider)
1264         return E_NOINTERFACE;
1265
1266     return IServiceProvider_QueryService(This->service_provider, guidService, riid, ppv);
1267 }
1268
1269 #undef SERVPROV_THIS
1270
1271 static const IServiceProviderVtbl ServiceProviderVtbl = {
1272     BPServiceProvider_QueryInterface,
1273     BPServiceProvider_AddRef,
1274     BPServiceProvider_Release,
1275     BPServiceProvider_QueryService
1276 };
1277
1278 HRESULT create_binding_protocol(LPCWSTR url, BOOL from_urlmon, IInternetProtocol **protocol)
1279 {
1280     BindProtocol *ret = heap_alloc_zero(sizeof(BindProtocol));
1281
1282     ret->lpIInternetProtocolVtbl        = &BindProtocolVtbl;
1283     ret->lpInternetBindInfoVtbl         = &InternetBindInfoVtbl;
1284     ret->lpInternetPriorityVtbl         = &InternetPriorityVtbl;
1285     ret->lpServiceProviderVtbl          = &ServiceProviderVtbl;
1286     ret->lpIInternetProtocolSinkVtbl    = &InternetProtocolSinkVtbl;
1287     ret->lpIInternetProtocolHandlerVtbl = &InternetProtocolHandlerVtbl;
1288     ret->lpIWinInetHttpInfoVtbl         = &WinInetHttpInfoVtbl;
1289
1290     ret->ref = 1;
1291     ret->from_urlmon = from_urlmon;
1292     ret->apartment_thread = GetCurrentThreadId();
1293     ret->notif_hwnd = get_notif_hwnd();
1294     ret->protocol_handler = PROTOCOLHANDLER(ret);
1295     InitializeCriticalSection(&ret->section);
1296
1297     URLMON_LockModule();
1298
1299     *protocol = PROTOCOL(ret);
1300     return S_OK;
1301 }