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