ole32: Remove unneeded address-of operators from array names.
[wine] / dlls / urlmon / bindctx.c
1 /*
2  * Copyright 2007 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 <stdio.h>
20
21 #include "urlmon_main.h"
22 #include "wine/debug.h"
23
24 WINE_DEFAULT_DEBUG_CHANNEL(urlmon);
25
26 static WCHAR BSCBHolder[] = { '_','B','S','C','B','_','H','o','l','d','e','r','_',0 };
27
28 extern IID IID_IBindStatusCallbackHolder;
29
30 typedef struct {
31     IBindStatusCallbackEx IBindStatusCallbackEx_iface;
32     IServiceProvider      IServiceProvider_iface;
33     IHttpNegotiate2       IHttpNegotiate2_iface;
34     IAuthenticate         IAuthenticate_iface;
35
36     LONG ref;
37
38     IBindStatusCallback *callback;
39     IServiceProvider *serv_prov;
40 } BindStatusCallback;
41
42 static void *get_callback_iface(BindStatusCallback *This, REFIID riid)
43 {
44     void *ret;
45     HRESULT hres;
46
47     hres = IBindStatusCallback_QueryInterface(This->callback, riid, (void**)&ret);
48     if(FAILED(hres) && This->serv_prov)
49         hres = IServiceProvider_QueryService(This->serv_prov, riid, riid, &ret);
50
51     return SUCCEEDED(hres) ? ret : NULL;
52 }
53
54 static inline BindStatusCallback *impl_from_IBindStatusCallbackEx(IBindStatusCallbackEx *iface)
55 {
56     return CONTAINING_RECORD(iface, BindStatusCallback, IBindStatusCallbackEx_iface);
57 }
58
59 static HRESULT WINAPI BindStatusCallback_QueryInterface(IBindStatusCallbackEx *iface,
60         REFIID riid, void **ppv)
61 {
62     BindStatusCallback *This = impl_from_IBindStatusCallbackEx(iface);
63
64     *ppv = NULL;
65
66     if(IsEqualGUID(&IID_IUnknown, riid)) {
67         TRACE("(%p)->(IID_IUnknown, %p)\n", This, ppv);
68         *ppv = &This->IBindStatusCallbackEx_iface;
69     }else if(IsEqualGUID(&IID_IBindStatusCallback, riid)) {
70         TRACE("(%p)->(IID_IBindStatusCallback, %p)\n", This, ppv);
71         *ppv = &This->IBindStatusCallbackEx_iface;
72     }else if(IsEqualGUID(&IID_IBindStatusCallbackEx, riid)) {
73         TRACE("(%p)->(IID_IBindStatusCallback, %p)\n", This, ppv);
74         *ppv = &This->IBindStatusCallbackEx_iface;
75     }else if(IsEqualGUID(&IID_IBindStatusCallbackHolder, riid)) {
76         TRACE("(%p)->(IID_IBindStatusCallbackHolder, %p)\n", This, ppv);
77         *ppv = This;
78     }else if(IsEqualGUID(&IID_IServiceProvider, riid)) {
79         TRACE("(%p)->(IID_IServiceProvider, %p)\n", This, ppv);
80         *ppv = &This->IServiceProvider_iface;
81     }else if(IsEqualGUID(&IID_IHttpNegotiate, riid)) {
82         TRACE("(%p)->(IID_IHttpNegotiate, %p)\n", This, ppv);
83         *ppv = &This->IHttpNegotiate2_iface;
84     }else if(IsEqualGUID(&IID_IHttpNegotiate2, riid)) {
85         TRACE("(%p)->(IID_IHttpNegotiate2, %p)\n", This, ppv);
86         *ppv = &This->IHttpNegotiate2_iface;
87     }else if(IsEqualGUID(&IID_IAuthenticate, riid)) {
88         TRACE("(%p)->(IID_IAuthenticate, %p)\n", This, ppv);
89         *ppv = &This->IAuthenticate_iface;
90     }
91
92     if(*ppv) {
93         IBindStatusCallback_AddRef((IUnknown*)*ppv);
94         return S_OK;
95     }
96
97     TRACE("Unsupported riid = %s\n", debugstr_guid(riid));
98     return E_NOINTERFACE;
99 }
100
101 static ULONG WINAPI BindStatusCallback_AddRef(IBindStatusCallbackEx *iface)
102 {
103     BindStatusCallback *This = impl_from_IBindStatusCallbackEx(iface);
104     LONG ref = InterlockedIncrement(&This->ref);
105
106     TRACE("(%p) ref = %d\n", This, ref);
107
108     return ref;
109 }
110
111 static ULONG WINAPI BindStatusCallback_Release(IBindStatusCallbackEx *iface)
112 {
113     BindStatusCallback *This = impl_from_IBindStatusCallbackEx(iface);
114     LONG ref = InterlockedDecrement(&This->ref);
115
116     TRACE("(%p) ref = %d\n", This, ref);
117
118     if(!ref) {
119         if(This->serv_prov)
120             IServiceProvider_Release(This->serv_prov);
121         IBindStatusCallback_Release(This->callback);
122         heap_free(This);
123     }
124
125     return ref;
126 }
127
128 static HRESULT WINAPI BindStatusCallback_OnStartBinding(IBindStatusCallbackEx *iface,
129         DWORD dwReserved, IBinding *pbind)
130 {
131     BindStatusCallback *This = impl_from_IBindStatusCallbackEx(iface);
132
133     TRACE("(%p)->(%d %p)\n", This, dwReserved, pbind);
134
135     return IBindStatusCallback_OnStartBinding(This->callback, 0xff, pbind);
136 }
137
138 static HRESULT WINAPI BindStatusCallback_GetPriority(IBindStatusCallbackEx *iface, LONG *pnPriority)
139 {
140     BindStatusCallback *This = impl_from_IBindStatusCallbackEx(iface);
141
142     TRACE("(%p)->(%p)\n", This, pnPriority);
143
144     return IBindStatusCallback_GetPriority(This->callback, pnPriority);
145 }
146
147 static HRESULT WINAPI BindStatusCallback_OnLowResource(IBindStatusCallbackEx *iface, DWORD reserved)
148 {
149     BindStatusCallback *This = impl_from_IBindStatusCallbackEx(iface);
150
151     TRACE("(%p)->(%d)\n", This, reserved);
152
153     return IBindStatusCallback_OnLowResource(This->callback, reserved);
154 }
155
156 static HRESULT WINAPI BindStatusCallback_OnProgress(IBindStatusCallbackEx *iface, ULONG ulProgress,
157         ULONG ulProgressMax, ULONG ulStatusCode, LPCWSTR szStatusText)
158 {
159     BindStatusCallback *This = impl_from_IBindStatusCallbackEx(iface);
160
161     TRACE("%p)->(%u %u %u %s)\n", This, ulProgress, ulProgressMax, ulStatusCode,
162             debugstr_w(szStatusText));
163
164     return IBindStatusCallback_OnProgress(This->callback, ulProgress,
165             ulProgressMax, ulStatusCode, szStatusText);
166 }
167
168 static HRESULT WINAPI BindStatusCallback_OnStopBinding(IBindStatusCallbackEx *iface,
169         HRESULT hresult, LPCWSTR szError)
170 {
171     BindStatusCallback *This = impl_from_IBindStatusCallbackEx(iface);
172
173     TRACE("(%p)->(%08x %s)\n", This, hresult, debugstr_w(szError));
174
175     return IBindStatusCallback_OnStopBinding(This->callback, hresult, szError);
176 }
177
178 static HRESULT WINAPI BindStatusCallback_GetBindInfo(IBindStatusCallbackEx *iface,
179         DWORD *grfBINDF, BINDINFO *pbindinfo)
180 {
181     BindStatusCallback *This = impl_from_IBindStatusCallbackEx(iface);
182     IBindStatusCallbackEx *bscex;
183     HRESULT hres;
184
185     TRACE("(%p)->(%p %p)\n", This, grfBINDF, pbindinfo);
186
187     hres = IBindStatusCallback_QueryInterface(This->callback, &IID_IBindStatusCallbackEx, (void**)&bscex);
188     if(SUCCEEDED(hres)) {
189         DWORD bindf2 = 0, reserv = 0;
190
191         hres = IBindStatusCallbackEx_GetBindInfoEx(bscex, grfBINDF, pbindinfo, &bindf2, &reserv);
192         IBindStatusCallbackEx_Release(bscex);
193     }else {
194         hres = IBindStatusCallback_GetBindInfo(This->callback, grfBINDF, pbindinfo);
195     }
196
197     return hres;
198 }
199
200 static HRESULT WINAPI BindStatusCallback_OnDataAvailable(IBindStatusCallbackEx *iface,
201         DWORD grfBSCF, DWORD dwSize, FORMATETC *pformatetc, STGMEDIUM *pstgmed)
202 {
203     BindStatusCallback *This = impl_from_IBindStatusCallbackEx(iface);
204
205     TRACE("(%p)->(%08x %d %p %p)\n", This, grfBSCF, dwSize, pformatetc, pstgmed);
206
207     return IBindStatusCallback_OnDataAvailable(This->callback, grfBSCF, dwSize, pformatetc, pstgmed);
208 }
209
210 static HRESULT WINAPI BindStatusCallback_OnObjectAvailable(IBindStatusCallbackEx *iface,
211         REFIID riid, IUnknown *punk)
212 {
213     BindStatusCallback *This = impl_from_IBindStatusCallbackEx(iface);
214
215     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), punk);
216
217     return IBindStatusCallback_OnObjectAvailable(This->callback, riid, punk);
218 }
219
220 static HRESULT WINAPI BindStatusCallback_GetBindInfoEx(IBindStatusCallbackEx *iface, DWORD *grfBINDF,
221         BINDINFO *pbindinfo, DWORD *grfBINDF2, DWORD *pdwReserved)
222 {
223     BindStatusCallback *This = impl_from_IBindStatusCallbackEx(iface);
224     IBindStatusCallbackEx *bscex;
225     HRESULT hres;
226
227     TRACE("(%p)->(%p %p %p %p)\n", This, grfBINDF, pbindinfo, grfBINDF2, pdwReserved);
228
229     hres = IBindStatusCallback_QueryInterface(This->callback, &IID_IBindStatusCallbackEx, (void**)&bscex);
230     if(SUCCEEDED(hres)) {
231         hres = IBindStatusCallbackEx_GetBindInfoEx(bscex, grfBINDF, pbindinfo, grfBINDF2, pdwReserved);
232         IBindStatusCallbackEx_Release(bscex);
233     }else {
234         hres = IBindStatusCallback_GetBindInfo(This->callback, grfBINDF, pbindinfo);
235     }
236
237     return hres;
238 }
239
240 static const IBindStatusCallbackExVtbl BindStatusCallbackExVtbl = {
241     BindStatusCallback_QueryInterface,
242     BindStatusCallback_AddRef,
243     BindStatusCallback_Release,
244     BindStatusCallback_OnStartBinding,
245     BindStatusCallback_GetPriority,
246     BindStatusCallback_OnLowResource,
247     BindStatusCallback_OnProgress,
248     BindStatusCallback_OnStopBinding,
249     BindStatusCallback_GetBindInfo,
250     BindStatusCallback_OnDataAvailable,
251     BindStatusCallback_OnObjectAvailable,
252     BindStatusCallback_GetBindInfoEx
253 };
254
255 static inline BindStatusCallback *impl_from_IServiceProvider(IServiceProvider *iface)
256 {
257     return CONTAINING_RECORD(iface, BindStatusCallback, IServiceProvider_iface);
258 }
259
260 static HRESULT WINAPI BSCServiceProvider_QueryInterface(IServiceProvider *iface,
261         REFIID riid, void **ppv)
262 {
263     BindStatusCallback *This = impl_from_IServiceProvider(iface);
264     return IBindStatusCallback_QueryInterface(&This->IBindStatusCallbackEx_iface, riid, ppv);
265 }
266
267 static ULONG WINAPI BSCServiceProvider_AddRef(IServiceProvider *iface)
268 {
269     BindStatusCallback *This = impl_from_IServiceProvider(iface);
270     return IBindStatusCallback_AddRef(&This->IBindStatusCallbackEx_iface);
271 }
272
273 static ULONG WINAPI BSCServiceProvider_Release(IServiceProvider *iface)
274 {
275     BindStatusCallback *This = impl_from_IServiceProvider(iface);
276     return IBindStatusCallback_Release(&This->IBindStatusCallbackEx_iface);
277 }
278
279 static HRESULT WINAPI BSCServiceProvider_QueryService(IServiceProvider *iface,
280         REFGUID guidService, REFIID riid, void **ppv)
281 {
282     BindStatusCallback *This = impl_from_IServiceProvider(iface);
283     HRESULT hres;
284
285     if(IsEqualGUID(&IID_IHttpNegotiate, guidService)) {
286         TRACE("(%p)->(IID_IHttpNegotiate %s %p)\n", This, debugstr_guid(riid), ppv);
287         return IBindStatusCallback_QueryInterface(&This->IBindStatusCallbackEx_iface, riid, ppv);
288     }
289
290     if(IsEqualGUID(&IID_IHttpNegotiate2, guidService)) {
291         TRACE("(%p)->(IID_IHttpNegotiate2 %s %p)\n", This, debugstr_guid(riid), ppv);
292         return IBindStatusCallback_QueryInterface(&This->IBindStatusCallbackEx_iface, riid, ppv);
293     }
294
295     if(IsEqualGUID(&IID_IAuthenticate, guidService)) {
296         TRACE("(%p)->(IID_IAuthenticate %s %p)\n", This, debugstr_guid(riid), ppv);
297         return IBindStatusCallback_QueryInterface(&This->IBindStatusCallbackEx_iface, riid, ppv);
298     }
299
300     TRACE("(%p)->(%s %s %p)\n", This, debugstr_guid(guidService), debugstr_guid(riid), ppv);
301
302     hres = IBindStatusCallback_QueryInterface(This->callback, riid, ppv);
303     if(SUCCEEDED(hres))
304         return S_OK;
305
306     if(This->serv_prov) {
307         hres = IServiceProvider_QueryService(This->serv_prov, guidService, riid, ppv);
308         if(SUCCEEDED(hres))
309             return S_OK;
310     }
311
312     return E_NOINTERFACE;
313 }
314
315 static const IServiceProviderVtbl BSCServiceProviderVtbl = {
316     BSCServiceProvider_QueryInterface,
317     BSCServiceProvider_AddRef,
318     BSCServiceProvider_Release,
319     BSCServiceProvider_QueryService
320 };
321
322 static inline BindStatusCallback *impl_from_IHttpNegotiate2(IHttpNegotiate2 *iface)
323 {
324     return CONTAINING_RECORD(iface, BindStatusCallback, IHttpNegotiate2_iface);
325 }
326
327 static HRESULT WINAPI BSCHttpNegotiate_QueryInterface(IHttpNegotiate2 *iface,
328         REFIID riid, void **ppv)
329 {
330     BindStatusCallback *This = impl_from_IHttpNegotiate2(iface);
331     return IBindStatusCallback_QueryInterface(&This->IBindStatusCallbackEx_iface, riid, ppv);
332 }
333
334 static ULONG WINAPI BSCHttpNegotiate_AddRef(IHttpNegotiate2 *iface)
335 {
336     BindStatusCallback *This = impl_from_IHttpNegotiate2(iface);
337     return IBindStatusCallback_AddRef(&This->IBindStatusCallbackEx_iface);
338 }
339
340 static ULONG WINAPI BSCHttpNegotiate_Release(IHttpNegotiate2 *iface)
341 {
342     BindStatusCallback *This = impl_from_IHttpNegotiate2(iface);
343     return IBindStatusCallback_Release(&This->IBindStatusCallbackEx_iface);
344 }
345
346 static HRESULT WINAPI BSCHttpNegotiate_BeginningTransaction(IHttpNegotiate2 *iface,
347         LPCWSTR szURL, LPCWSTR szHeaders, DWORD dwReserved, LPWSTR *pszAdditionalHeaders)
348 {
349     BindStatusCallback *This = impl_from_IHttpNegotiate2(iface);
350     IHttpNegotiate *http_negotiate;
351     HRESULT hres = S_OK;
352
353     TRACE("(%p)->(%s %s %d %p)\n", This, debugstr_w(szURL), debugstr_w(szHeaders), dwReserved,
354           pszAdditionalHeaders);
355
356     *pszAdditionalHeaders = NULL;
357
358     http_negotiate = get_callback_iface(This, &IID_IHttpNegotiate);
359     if(http_negotiate) {
360         hres = IHttpNegotiate_BeginningTransaction(http_negotiate, szURL, szHeaders,
361                 dwReserved, pszAdditionalHeaders);
362         IHttpNegotiate_Release(http_negotiate);
363     }
364
365     return hres;
366 }
367
368 static HRESULT WINAPI BSCHttpNegotiate_OnResponse(IHttpNegotiate2 *iface, DWORD dwResponseCode,
369         LPCWSTR szResponseHeaders, LPCWSTR szRequestHeaders,
370         LPWSTR *pszAdditionalRequestHeaders)
371 {
372     BindStatusCallback *This = impl_from_IHttpNegotiate2(iface);
373     LPWSTR additional_headers = NULL;
374     IHttpNegotiate *http_negotiate;
375     HRESULT hres = S_OK;
376
377     TRACE("(%p)->(%d %s %s %p)\n", This, dwResponseCode, debugstr_w(szResponseHeaders),
378           debugstr_w(szRequestHeaders), pszAdditionalRequestHeaders);
379
380     http_negotiate = get_callback_iface(This, &IID_IHttpNegotiate);
381     if(http_negotiate) {
382         hres = IHttpNegotiate_OnResponse(http_negotiate, dwResponseCode, szResponseHeaders,
383                 szRequestHeaders, &additional_headers);
384         IHttpNegotiate_Release(http_negotiate);
385     }
386
387     if(pszAdditionalRequestHeaders)
388         *pszAdditionalRequestHeaders = additional_headers;
389     else if(additional_headers)
390         CoTaskMemFree(additional_headers);
391
392     return hres;
393 }
394
395 static HRESULT WINAPI BSCHttpNegotiate_GetRootSecurityId(IHttpNegotiate2 *iface,
396         BYTE *pbSecurityId, DWORD *pcbSecurityId, DWORD_PTR dwReserved)
397 {
398     BindStatusCallback *This = impl_from_IHttpNegotiate2(iface);
399     IHttpNegotiate2 *http_negotiate2;
400     HRESULT hres = E_FAIL;
401
402     TRACE("(%p)->(%p %p %ld)\n", This, pbSecurityId, pcbSecurityId, dwReserved);
403
404     http_negotiate2 = get_callback_iface(This, &IID_IHttpNegotiate2);
405     if(http_negotiate2) {
406         hres = IHttpNegotiate2_GetRootSecurityId(http_negotiate2, pbSecurityId,
407                 pcbSecurityId, dwReserved);
408         IHttpNegotiate2_Release(http_negotiate2);
409     }
410
411     return hres;
412 }
413
414 static const IHttpNegotiate2Vtbl BSCHttpNegotiateVtbl = {
415     BSCHttpNegotiate_QueryInterface,
416     BSCHttpNegotiate_AddRef,
417     BSCHttpNegotiate_Release,
418     BSCHttpNegotiate_BeginningTransaction,
419     BSCHttpNegotiate_OnResponse,
420     BSCHttpNegotiate_GetRootSecurityId
421 };
422
423 static inline BindStatusCallback *impl_from_IAuthenticate(IAuthenticate *iface)
424 {
425     return CONTAINING_RECORD(iface, BindStatusCallback, IAuthenticate_iface);
426 }
427
428 static HRESULT WINAPI BSCAuthenticate_QueryInterface(IAuthenticate *iface, REFIID riid, void **ppv)
429 {
430     BindStatusCallback *This = impl_from_IAuthenticate(iface);
431     return IBindStatusCallback_QueryInterface(&This->IAuthenticate_iface, riid, ppv);
432 }
433
434 static ULONG WINAPI BSCAuthenticate_AddRef(IAuthenticate *iface)
435 {
436     BindStatusCallback *This = impl_from_IAuthenticate(iface);
437     return IBindStatusCallback_AddRef(&This->IBindStatusCallbackEx_iface);
438 }
439
440 static ULONG WINAPI BSCAuthenticate_Release(IAuthenticate *iface)
441 {
442     BindStatusCallback *This = impl_from_IAuthenticate(iface);
443     return IBindStatusCallback_Release(&This->IBindStatusCallbackEx_iface);
444 }
445
446 static HRESULT WINAPI BSCAuthenticate_Authenticate(IAuthenticate *iface,
447         HWND *phwnd, LPWSTR *pszUsername, LPWSTR *pszPassword)
448 {
449     BindStatusCallback *This = impl_from_IAuthenticate(iface);
450     FIXME("(%p)->(%p %p %p)\n", This, phwnd, pszUsername, pszPassword);
451     return E_NOTIMPL;
452 }
453
454 static const IAuthenticateVtbl BSCAuthenticateVtbl = {
455     BSCAuthenticate_QueryInterface,
456     BSCAuthenticate_AddRef,
457     BSCAuthenticate_Release,
458     BSCAuthenticate_Authenticate
459 };
460
461 static void set_callback(BindStatusCallback *This, IBindStatusCallback *bsc)
462 {
463     IServiceProvider *serv_prov;
464     HRESULT hres;
465
466     if(This->callback)
467         IBindStatusCallback_Release(This->callback);
468     if(This->serv_prov)
469         IServiceProvider_Release(This->serv_prov);
470
471     IBindStatusCallback_AddRef(bsc);
472     This->callback = bsc;
473
474     hres = IBindStatusCallback_QueryInterface(bsc, &IID_IServiceProvider, (void**)&serv_prov);
475     This->serv_prov = hres == S_OK ? serv_prov : NULL;
476 }
477
478 HRESULT wrap_callback(IBindStatusCallback *bsc, IBindStatusCallback **ret_iface)
479 {
480     BindStatusCallback *ret;
481
482     ret = heap_alloc_zero(sizeof(BindStatusCallback));
483     if(!ret)
484         return E_OUTOFMEMORY;
485
486     ret->IBindStatusCallbackEx_iface.lpVtbl = &BindStatusCallbackExVtbl;
487     ret->IServiceProvider_iface.lpVtbl = &BSCServiceProviderVtbl;
488     ret->IHttpNegotiate2_iface.lpVtbl = &BSCHttpNegotiateVtbl;
489     ret->IAuthenticate_iface.lpVtbl = &BSCAuthenticateVtbl;
490
491     ret->ref = 1;
492     set_callback(ret, bsc);
493
494     *ret_iface = (IBindStatusCallback*)&ret->IBindStatusCallbackEx_iface;
495     return S_OK;
496 }
497
498 /***********************************************************************
499  *           RegisterBindStatusCallback (urlmon.@)
500  *
501  * Register a bind status callback.
502  *
503  * PARAMS
504  *  pbc           [I] Binding context
505  *  pbsc          [I] Callback to register
506  *  ppbscPrevious [O] Destination for previous callback
507  *  dwReserved    [I] Reserved, must be 0.
508  *
509  * RETURNS
510  *    Success: S_OK.
511  *    Failure: E_INVALIDARG, if any argument is invalid, or
512  *             E_OUTOFMEMORY if memory allocation fails.
513  */
514 HRESULT WINAPI RegisterBindStatusCallback(IBindCtx *pbc, IBindStatusCallback *pbsc,
515         IBindStatusCallback **ppbscPrevious, DWORD dwReserved)
516 {
517     BindStatusCallback *holder;
518     IBindStatusCallback *bsc, *prev = NULL;
519     IUnknown *unk;
520     HRESULT hres;
521
522     TRACE("(%p %p %p %x)\n", pbc, pbsc, ppbscPrevious, dwReserved);
523
524     if (!pbc || !pbsc)
525         return E_INVALIDARG;
526
527     hres = IBindCtx_GetObjectParam(pbc, BSCBHolder, &unk);
528     if(SUCCEEDED(hres)) {
529         hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&bsc);
530         IUnknown_Release(unk);
531         if(SUCCEEDED(hres)) {
532             hres = IBindStatusCallback_QueryInterface(bsc, &IID_IBindStatusCallbackHolder, (void**)&holder);
533             if(SUCCEEDED(hres)) {
534                 if(ppbscPrevious) {
535                     IBindStatusCallback_AddRef(holder->callback);
536                     *ppbscPrevious = holder->callback;
537                 }
538
539                 set_callback(holder, pbsc);
540
541                 IBindStatusCallback_Release(bsc);
542                 IBindStatusCallback_Release(&holder->IBindStatusCallbackEx_iface);
543                 return S_OK;
544             }else {
545                 prev = bsc;
546             }
547         }
548
549         IBindCtx_RevokeObjectParam(pbc, BSCBHolder);
550     }
551
552     hres = wrap_callback(pbsc, &bsc);
553     if(SUCCEEDED(hres)) {
554         hres = IBindCtx_RegisterObjectParam(pbc, BSCBHolder, (IUnknown*)bsc);
555         IBindStatusCallback_Release(bsc);
556     }
557     if(FAILED(hres)) {
558         if(prev)
559             IBindStatusCallback_Release(prev);
560         return hres;
561     }
562
563     if(ppbscPrevious)
564         *ppbscPrevious = prev;
565     return S_OK;
566 }
567
568 /***********************************************************************
569  *           RevokeBindStatusCallback (URLMON.@)
570  *
571  * Unregister a bind status callback.
572  *
573  *  pbc           [I] Binding context
574  *  pbsc          [I] Callback to unregister
575  *
576  * RETURNS
577  *    Success: S_OK.
578  *    Failure: E_INVALIDARG, if any argument is invalid
579  */
580 HRESULT WINAPI RevokeBindStatusCallback(IBindCtx *pbc, IBindStatusCallback *pbsc)
581 {
582     BindStatusCallback *holder;
583     IBindStatusCallback *callback;
584     IUnknown *unk;
585     BOOL dorevoke = FALSE;
586     HRESULT hres;
587
588     TRACE("(%p %p)\n", pbc, pbsc);
589
590     if (!pbc || !pbsc)
591         return E_INVALIDARG;
592
593     hres = IBindCtx_GetObjectParam(pbc, BSCBHolder, &unk);
594     if(FAILED(hres))
595         return S_OK;
596
597     hres = IUnknown_QueryInterface(unk, &IID_IBindStatusCallback, (void**)&callback);
598     IUnknown_Release(unk);
599     if(FAILED(hres))
600         return S_OK;
601
602     hres = IBindStatusCallback_QueryInterface(callback, &IID_IBindStatusCallbackHolder, (void**)&holder);
603     if(SUCCEEDED(hres)) {
604         if(pbsc == holder->callback)
605             dorevoke = TRUE;
606         IBindStatusCallback_Release(&holder->IBindStatusCallbackEx_iface);
607     }else if(pbsc == callback) {
608         dorevoke = TRUE;
609     }
610     IBindStatusCallback_Release(callback);
611
612     if(dorevoke)
613         IBindCtx_RevokeObjectParam(pbc, BSCBHolder);
614
615     return S_OK;
616 }
617
618 typedef struct {
619     IBindCtx IBindCtx_iface;
620
621     LONG ref;
622
623     IBindCtx *bindctx;
624 } AsyncBindCtx;
625
626 static inline AsyncBindCtx *impl_from_IBindCtx(IBindCtx *iface)
627 {
628     return CONTAINING_RECORD(iface, AsyncBindCtx, IBindCtx_iface);
629 }
630
631 static HRESULT WINAPI AsyncBindCtx_QueryInterface(IBindCtx *iface, REFIID riid, void **ppv)
632 {
633     AsyncBindCtx *This = impl_from_IBindCtx(iface);
634
635     *ppv = NULL;
636
637     if(IsEqualGUID(riid, &IID_IUnknown)) {
638         TRACE("(%p)->(IID_IUnknown %p)\n", This, ppv);
639         *ppv = &This->IBindCtx_iface;
640     }else if(IsEqualGUID(riid, &IID_IBindCtx)) {
641         TRACE("(%p)->(IID_IBindCtx %p)\n", This, ppv);
642         *ppv = &This->IBindCtx_iface;
643     }else if(IsEqualGUID(riid, &IID_IAsyncBindCtx)) {
644         TRACE("(%p)->(IID_IAsyncBindCtx %p)\n", This, ppv);
645         *ppv = &This->IBindCtx_iface;
646     }
647
648     if(*ppv) {
649         IUnknown_AddRef((IUnknown*)*ppv);
650         return S_OK;
651     }
652
653     FIXME("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
654     return E_NOINTERFACE;
655 }
656
657 static ULONG WINAPI AsyncBindCtx_AddRef(IBindCtx *iface)
658 {
659     AsyncBindCtx *This = impl_from_IBindCtx(iface);
660     LONG ref = InterlockedIncrement(&This->ref);
661
662     TRACE("(%p) ref=%d\n", This, ref);
663
664     return ref;
665 }
666
667 static ULONG WINAPI AsyncBindCtx_Release(IBindCtx *iface)
668 {
669     AsyncBindCtx *This = impl_from_IBindCtx(iface);
670     LONG ref = InterlockedDecrement(&This->ref);
671
672     TRACE("(%p) ref=%d\n", This, ref);
673
674     if(!ref) {
675         IBindCtx_Release(This->bindctx);
676         heap_free(This);
677     }
678
679     return ref;
680 }
681
682 static HRESULT WINAPI AsyncBindCtx_RegisterObjectBound(IBindCtx *iface, IUnknown *punk)
683 {
684     AsyncBindCtx *This = impl_from_IBindCtx(iface);
685
686     TRACE("(%p)->(%p)\n", This, punk);
687
688     return IBindCtx_RegisterObjectBound(This->bindctx, punk);
689 }
690
691 static HRESULT WINAPI AsyncBindCtx_RevokeObjectBound(IBindCtx *iface, IUnknown *punk)
692 {
693     AsyncBindCtx *This = impl_from_IBindCtx(iface);
694
695     TRACE("(%p %p)\n", This, punk);
696
697     return IBindCtx_RevokeObjectBound(This->bindctx, punk);
698 }
699
700 static HRESULT WINAPI AsyncBindCtx_ReleaseBoundObjects(IBindCtx *iface)
701 {
702     AsyncBindCtx *This = impl_from_IBindCtx(iface);
703
704     TRACE("(%p)\n", This);
705
706     return IBindCtx_ReleaseBoundObjects(This->bindctx);
707 }
708
709 static HRESULT WINAPI AsyncBindCtx_SetBindOptions(IBindCtx *iface, BIND_OPTS *pbindopts)
710 {
711     AsyncBindCtx *This = impl_from_IBindCtx(iface);
712
713     TRACE("(%p)->(%p)\n", This, pbindopts);
714
715     return IBindCtx_SetBindOptions(This->bindctx, pbindopts);
716 }
717
718 static HRESULT WINAPI AsyncBindCtx_GetBindOptions(IBindCtx *iface, BIND_OPTS *pbindopts)
719 {
720     AsyncBindCtx *This = impl_from_IBindCtx(iface);
721
722     TRACE("(%p)->(%p)\n", This, pbindopts);
723
724     return IBindCtx_GetBindOptions(This->bindctx, pbindopts);
725 }
726
727 static HRESULT WINAPI AsyncBindCtx_GetRunningObjectTable(IBindCtx *iface, IRunningObjectTable **pprot)
728 {
729     AsyncBindCtx *This = impl_from_IBindCtx(iface);
730
731     TRACE("(%p)->(%p)\n", This, pprot);
732
733     return IBindCtx_GetRunningObjectTable(This->bindctx, pprot);
734 }
735
736 static HRESULT WINAPI AsyncBindCtx_RegisterObjectParam(IBindCtx *iface, LPOLESTR pszkey, IUnknown *punk)
737 {
738     AsyncBindCtx *This = impl_from_IBindCtx(iface);
739
740     TRACE("(%p)->(%s %p)\n", This, debugstr_w(pszkey), punk);
741
742     return IBindCtx_RegisterObjectParam(This->bindctx, pszkey, punk);
743 }
744
745 static HRESULT WINAPI AsyncBindCtx_GetObjectParam(IBindCtx* iface, LPOLESTR pszkey, IUnknown **punk)
746 {
747     AsyncBindCtx *This = impl_from_IBindCtx(iface);
748
749     TRACE("(%p)->(%s %p)\n", This, debugstr_w(pszkey), punk);
750
751     return IBindCtx_GetObjectParam(This->bindctx, pszkey, punk);
752 }
753
754 static HRESULT WINAPI AsyncBindCtx_RevokeObjectParam(IBindCtx *iface, LPOLESTR pszkey)
755 {
756     AsyncBindCtx *This = impl_from_IBindCtx(iface);
757
758     TRACE("(%p)->(%s)\n", This, debugstr_w(pszkey));
759
760     return IBindCtx_RevokeObjectParam(This->bindctx, pszkey);
761 }
762
763 static HRESULT WINAPI AsyncBindCtx_EnumObjectParam(IBindCtx *iface, IEnumString **pszkey)
764 {
765     AsyncBindCtx *This = impl_from_IBindCtx(iface);
766
767     TRACE("(%p)->(%p)\n", This, pszkey);
768
769     return IBindCtx_EnumObjectParam(This->bindctx, pszkey);
770 }
771
772 static const IBindCtxVtbl AsyncBindCtxVtbl =
773 {
774     AsyncBindCtx_QueryInterface,
775     AsyncBindCtx_AddRef,
776     AsyncBindCtx_Release,
777     AsyncBindCtx_RegisterObjectBound,
778     AsyncBindCtx_RevokeObjectBound,
779     AsyncBindCtx_ReleaseBoundObjects,
780     AsyncBindCtx_SetBindOptions,
781     AsyncBindCtx_GetBindOptions,
782     AsyncBindCtx_GetRunningObjectTable,
783     AsyncBindCtx_RegisterObjectParam,
784     AsyncBindCtx_GetObjectParam,
785     AsyncBindCtx_EnumObjectParam,
786     AsyncBindCtx_RevokeObjectParam
787 };
788
789 static HRESULT init_bindctx(IBindCtx *bindctx, DWORD options,
790        IBindStatusCallback *callback, IEnumFORMATETC *format)
791 {
792     BIND_OPTS bindopts;
793     HRESULT hres;
794
795     if(options)
796         FIXME("not supported options %08x\n", options);
797     if(format)
798         FIXME("format is not supported\n");
799
800     bindopts.cbStruct = sizeof(BIND_OPTS);
801     bindopts.grfFlags = BIND_MAYBOTHERUSER;
802     bindopts.grfMode = STGM_READWRITE | STGM_SHARE_EXCLUSIVE;
803     bindopts.dwTickCountDeadline = 0;
804
805     hres = IBindCtx_SetBindOptions(bindctx, &bindopts);
806     if(FAILED(hres))
807        return hres;
808
809     if(callback) {
810         hres = RegisterBindStatusCallback(bindctx, callback, NULL, 0);
811         if(FAILED(hres))
812             return hres;
813     }
814
815     return S_OK;
816 }
817
818 /***********************************************************************
819  *           CreateAsyncBindCtx (urlmon.@)
820  */
821 HRESULT WINAPI CreateAsyncBindCtx(DWORD reserved, IBindStatusCallback *callback,
822         IEnumFORMATETC *format, IBindCtx **pbind)
823 {
824     IBindCtx *bindctx;
825     HRESULT hres;
826
827     TRACE("(%08x %p %p %p)\n", reserved, callback, format, pbind);
828
829     if(!pbind || !callback)
830         return E_INVALIDARG;
831
832     hres = CreateBindCtx(0, &bindctx);
833     if(FAILED(hres))
834         return hres;
835
836     hres = init_bindctx(bindctx, 0, callback, format);
837     if(FAILED(hres)) {
838         IBindCtx_Release(bindctx);
839         return hres;
840     }
841
842     *pbind = bindctx;
843     return S_OK;
844 }
845
846 /***********************************************************************
847  *           CreateAsyncBindCtxEx (urlmon.@)
848  *
849  * Create an asynchronous bind context.
850  */
851 HRESULT WINAPI CreateAsyncBindCtxEx(IBindCtx *ibind, DWORD options,
852         IBindStatusCallback *callback, IEnumFORMATETC *format, IBindCtx** pbind,
853         DWORD reserved)
854 {
855     AsyncBindCtx *ret;
856     IBindCtx *bindctx;
857     HRESULT hres;
858
859     TRACE("(%p %08x %p %p %p %d)\n", ibind, options, callback, format, pbind, reserved);
860
861     if(!pbind)
862         return E_INVALIDARG;
863
864     if(reserved)
865         WARN("reserved=%d\n", reserved);
866
867     if(ibind) {
868         IBindCtx_AddRef(ibind);
869         bindctx = ibind;
870     }else {
871         hres = CreateBindCtx(0, &bindctx);
872         if(FAILED(hres))
873             return hres;
874     }
875
876     ret = heap_alloc(sizeof(AsyncBindCtx));
877
878     ret->IBindCtx_iface.lpVtbl = &AsyncBindCtxVtbl;
879     ret->ref = 1;
880     ret->bindctx = bindctx;
881
882     hres = init_bindctx(&ret->IBindCtx_iface, options, callback, format);
883     if(FAILED(hres)) {
884         IBindCtx_Release(&ret->IBindCtx_iface);
885         return hres;
886     }
887
888     *pbind = &ret->IBindCtx_iface;
889     return S_OK;
890 }