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