source: trunk/src/ole32/bindctx.c

Last change on this file was 8620, checked in by sandervl, 23 years ago

Resync with latest Wine
File size: 17.9 KB
RevLine 
[5602]1/***************************************************************************************
[6711]2 * BindCtx implementation
[5602]3 *
4 * Copyright 1999 Noomen Hamza
[8441]5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
[5602]19 ***************************************************************************************/
20
21#include <string.h>
22#include <assert.h>
23#include "winerror.h"
24#include "winbase.h"
25#include "wine/unicode.h"
26#include "wine/obj_base.h"
27#include "wine/obj_misc.h"
28#include "wine/obj_storage.h"
29#include "wine/obj_moniker.h"
[8441]30#include "wine/debug.h"
[5602]31
[8441]32WINE_DEFAULT_DEBUG_CHANNEL(ole);
[5602]33
34/* represent the first size table and it's increment block size */
[8620]35#define BLOCK_TAB_SIZE 10
[5602]36#define MAX_TAB_SIZE 0xFFFFFFFF
37
38/* data structure of the BindCtx table elements */
39typedef struct BindCtxObject{
40
41 IUnknown* pObj; /* point on a bound object */
42
43 LPOLESTR pkeyObj; /* key associated to this bound object */
44
45 BYTE regType; /* registration type: 1 if RegisterObjectParam and 0 if RegisterObjectBound */
46
47} BindCtxObject;
48
49/* BindCtx data strucrture */
50typedef struct BindCtxImpl{
51
52 ICOM_VFIELD(IBindCtx); /* VTable relative to the IBindCtx interface.*/
[8620]53
[5602]54 ULONG ref; /* reference counter for this object */
55
56 BindCtxObject* bindCtxTable; /* this is a table in which all bounded objects are stored*/
57 DWORD bindCtxTableLastIndex; /* first free index in the table */
58 DWORD bindCtxTableSize; /* size table */
59
60 BIND_OPTS2 bindOption2; /* a structure which contains the bind options*/
61
62} BindCtxImpl;
63
64/* IBindCtx prototype functions : */
65
66/* IUnknown functions*/
67static HRESULT WINAPI BindCtxImpl_QueryInterface(IBindCtx* iface,REFIID riid,void** ppvObject);
68static ULONG WINAPI BindCtxImpl_AddRef(IBindCtx* iface);
69static ULONG WINAPI BindCtxImpl_Release(IBindCtx* iface);
70/* IBindCtx functions */
71static HRESULT WINAPI BindCtxImpl_RegisterObjectBound(IBindCtx* iface,IUnknown* punk);
72static HRESULT WINAPI BindCtxImpl_RevokeObjectBound(IBindCtx* iface, IUnknown* punk);
73static HRESULT WINAPI BindCtxImpl_ReleaseBoundObjects(IBindCtx* iface);
74static HRESULT WINAPI BindCtxImpl_SetBindOptions(IBindCtx* iface,LPBIND_OPTS2 pbindopts);
75static HRESULT WINAPI BindCtxImpl_GetBindOptions(IBindCtx* iface,LPBIND_OPTS2 pbindopts);
76static HRESULT WINAPI BindCtxImpl_GetRunningObjectTable(IBindCtx* iface,IRunningObjectTable** pprot);
77static HRESULT WINAPI BindCtxImpl_RegisterObjectParam(IBindCtx* iface,LPOLESTR pszkey, IUnknown* punk);
78static HRESULT WINAPI BindCtxImpl_GetObjectParam(IBindCtx* iface,LPOLESTR pszkey, IUnknown** punk);
79static HRESULT WINAPI BindCtxImpl_EnumObjectParam(IBindCtx* iface,IEnumString** ppenum);
80static HRESULT WINAPI BindCtxImpl_RevokeObjectParam(IBindCtx* iface,LPOLESTR pszkey);
81/* Local functions*/
82HRESULT WINAPI BindCtxImpl_Construct(BindCtxImpl* This);
83HRESULT WINAPI BindCtxImpl_Destroy(BindCtxImpl* This);
84HRESULT WINAPI BindCtxImpl_GetObjectIndex(BindCtxImpl* This,IUnknown* punk,LPOLESTR pszkey,DWORD *index);
85
86/* Virtual function table for the BindCtx class. */
87static ICOM_VTABLE(IBindCtx) VT_BindCtxImpl =
88 {
89 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
90 BindCtxImpl_QueryInterface,
91 BindCtxImpl_AddRef,
92 BindCtxImpl_Release,
93 BindCtxImpl_RegisterObjectBound,
94 BindCtxImpl_RevokeObjectBound,
95 BindCtxImpl_ReleaseBoundObjects,
96 BindCtxImpl_SetBindOptions,
97 BindCtxImpl_GetBindOptions,
98 BindCtxImpl_GetRunningObjectTable,
99 BindCtxImpl_RegisterObjectParam,
100 BindCtxImpl_GetObjectParam,
101 BindCtxImpl_EnumObjectParam,
102 BindCtxImpl_RevokeObjectParam
103};
104
105/*******************************************************************************
106 * BindCtx_QueryInterface
107 *******************************************************************************/
108HRESULT WINAPI BindCtxImpl_QueryInterface(IBindCtx* iface,REFIID riid,void** ppvObject)
109{
110 ICOM_THIS(BindCtxImpl,iface);
111
112 TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
113
114 /* Perform a sanity check on the parameters.*/
115 if ( (This==0) || (ppvObject==0) )
116 return E_INVALIDARG;
[8620]117
[5602]118 /* Initialize the return parameter.*/
119 *ppvObject = 0;
120
121 /* Compare the riid with the interface IDs implemented by this object.*/
122 if (IsEqualIID(&IID_IUnknown, riid))
123 *ppvObject = (IBindCtx*)This;
124 else
125 if (IsEqualIID(&IID_IBindCtx, riid))
126 *ppvObject = (IBindCtx*)This;
127
128 /* Check that we obtained an interface.*/
129 if ((*ppvObject)==0)
130 return E_NOINTERFACE;
[8620]131
[5602]132 /* Query Interface always increases the reference count by one when it is successful */
133 BindCtxImpl_AddRef(iface);
134
135 return S_OK;
136}
137
138/******************************************************************************
139 * BindCtx_AddRef
140 ******************************************************************************/
141ULONG WINAPI BindCtxImpl_AddRef(IBindCtx* iface)
142{
143 ICOM_THIS(BindCtxImpl,iface);
144
145 TRACE("(%p)\n",This);
146
147 return ++(This->ref);
148}
149
150/******************************************************************************
151 * BindCtx_Release
152 ******************************************************************************/
153ULONG WINAPI BindCtxImpl_Release(IBindCtx* iface)
154{
155 ICOM_THIS(BindCtxImpl,iface);
156
157 TRACE("(%p)\n",This);
158
159 This->ref--;
160
161 if (This->ref==0){
162
163 /* release all registered objects */
164 BindCtxImpl_ReleaseBoundObjects((IBindCtx*)This);
165
166 BindCtxImpl_Destroy(This);
167
168 return 0;
169 }
[8620]170 return This->ref;
[5602]171}
172
173
174/******************************************************************************
175 * BindCtx_Construct (local function)
176 *******************************************************************************/
177HRESULT WINAPI BindCtxImpl_Construct(BindCtxImpl* This)
178{
179 TRACE("(%p)\n",This);
180
181 /* Initialize the virtual function table.*/
182 ICOM_VTBL(This) = &VT_BindCtxImpl;
183 This->ref = 0;
184
185 /* Initialize the BIND_OPTS2 structure */
186 This->bindOption2.cbStruct = sizeof(BIND_OPTS2);
187 This->bindOption2.grfFlags = 0;
188 This->bindOption2.grfMode = STGM_READWRITE;
189 This->bindOption2.dwTickCountDeadline = 0;
190
191 This->bindOption2.dwTrackFlags = 0;
192 This->bindOption2.dwClassContext = CLSCTX_SERVER;
193 This->bindOption2.locale = 1033;
194 This->bindOption2.pServerInfo = 0;
195
196 /* Initialize the bindctx table */
197 This->bindCtxTableSize=BLOCK_TAB_SIZE;
198 This->bindCtxTableLastIndex=0;
199 This->bindCtxTable= HeapAlloc(GetProcessHeap(), 0,This->bindCtxTableSize*sizeof(BindCtxObject));
200
201 if (This->bindCtxTable==NULL)
202 return E_OUTOFMEMORY;
203
204 return S_OK;
205}
206
207/******************************************************************************
208 * BindCtx_Destroy (local function)
209 *******************************************************************************/
210HRESULT WINAPI BindCtxImpl_Destroy(BindCtxImpl* This)
211{
212 TRACE("(%p)\n",This);
213
214 /* free the table space memory */
215 HeapFree(GetProcessHeap(),0,This->bindCtxTable);
216
217 /* free the bindctx structure */
218 HeapFree(GetProcessHeap(),0,This);
219
220 return S_OK;
221}
222
223
224/******************************************************************************
225 * BindCtx_RegisterObjectBound
226 ******************************************************************************/
227HRESULT WINAPI BindCtxImpl_RegisterObjectBound(IBindCtx* iface,IUnknown* punk)
228{
229
230 ICOM_THIS(BindCtxImpl,iface);
231 DWORD lastIndex=This->bindCtxTableLastIndex;
232 BindCtxObject cell;
233
234 TRACE("(%p,%p)\n",This,punk);
235
236 if (punk==NULL)
237 return E_POINTER;
[8620]238
[5602]239 IUnknown_AddRef(punk);
[8620]240
[5602]241 /* put the object in the first free element in the table */
242 This->bindCtxTable[lastIndex].pObj = punk;
243 This->bindCtxTable[lastIndex].pkeyObj = NULL;
244 This->bindCtxTable[lastIndex].regType = 0;
245 cell=This->bindCtxTable[lastIndex];
246 lastIndex= ++This->bindCtxTableLastIndex;
247
248 if (lastIndex == This->bindCtxTableSize){ /* the table is full so it must be resized */
249
250 if (This->bindCtxTableSize > (MAX_TAB_SIZE-BLOCK_TAB_SIZE)){
251 FIXME("This->bindCtxTableSize: %ld is out of data limite \n",This->bindCtxTableSize);
252 return E_FAIL;
[7926]253 }
[5602]254
255 This->bindCtxTableSize+=BLOCK_TAB_SIZE; /* new table size */
256
257 This->bindCtxTable = HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,This->bindCtxTable,
258 This->bindCtxTableSize * sizeof(BindCtxObject));
259 if (!This->bindCtxTable)
260 return E_OUTOFMEMORY;
261 }
262 return S_OK;
263}
264
265/******************************************************************************
266 * BindCtx_RevokeObjectBound
267 ******************************************************************************/
268HRESULT WINAPI BindCtxImpl_RevokeObjectBound(IBindCtx* iface, IUnknown* punk)
269{
270 DWORD index,j;
271
272 ICOM_THIS(BindCtxImpl,iface);
273
274 TRACE("(%p,%p)\n",This,punk);
275
276 /* check if the object was registred or not */
277 if (BindCtxImpl_GetObjectIndex(This,punk,NULL,&index)==S_FALSE)
[8620]278
[5602]279 return MK_E_NOTBOUND;
280
281 IUnknown_Release(This->bindCtxTable[index].pObj);
[8620]282
[5602]283 /* left-shift all elements in the right side of the current revoked object */
284 for(j=index; j<This->bindCtxTableLastIndex-1; j++)
285 This->bindCtxTable[j]= This->bindCtxTable[j+1];
[8620]286
[5602]287 This->bindCtxTableLastIndex--;
288
289 return S_OK;
290}
291
292/******************************************************************************
293 * BindCtx_ReleaseBoundObjects
294 ******************************************************************************/
295HRESULT WINAPI BindCtxImpl_ReleaseBoundObjects(IBindCtx* iface)
296{
297 DWORD i;
298
299 ICOM_THIS(BindCtxImpl,iface);
300
301 TRACE("(%p)\n",This);
302
303 for(i=0;i<This->bindCtxTableLastIndex;i++)
304 IUnknown_Release(This->bindCtxTable[i].pObj);
305
306 This->bindCtxTableLastIndex = 0;
307
308 return S_OK;
309}
310
311/******************************************************************************
312 * BindCtx_SetBindOptions
313 ******************************************************************************/
314HRESULT WINAPI BindCtxImpl_SetBindOptions(IBindCtx* iface,LPBIND_OPTS2 pbindopts)
315{
316 ICOM_THIS(BindCtxImpl,iface);
317
318 TRACE("(%p,%p)\n",This,pbindopts);
319
320 if (pbindopts==NULL)
321 return E_POINTER;
[8620]322
[5602]323 if (pbindopts->cbStruct > sizeof(BIND_OPTS2))
324 {
[7926]325 WARN("invalid size\n");
[5602]326 return E_INVALIDARG; /* FIXME : not verified */
327 }
328 memcpy(&This->bindOption2, pbindopts, pbindopts->cbStruct);
329 return S_OK;
330}
331
332/******************************************************************************
333 * BindCtx_GetBindOptions
334 ******************************************************************************/
335HRESULT WINAPI BindCtxImpl_GetBindOptions(IBindCtx* iface,LPBIND_OPTS2 pbindopts)
336{
337 ICOM_THIS(BindCtxImpl,iface);
338
339 TRACE("(%p,%p)\n",This,pbindopts);
340
341 if (pbindopts==NULL)
342 return E_POINTER;
343
344 if (pbindopts->cbStruct > sizeof(BIND_OPTS2))
345 {
[7926]346 WARN("invalid size\n");
[5602]347 return E_INVALIDARG; /* FIXME : not verified */
348 }
349 memcpy(pbindopts, &This->bindOption2, pbindopts->cbStruct);
350 return S_OK;
351}
352
353/******************************************************************************
354 * BindCtx_GetRunningObjectTable
355 ******************************************************************************/
356HRESULT WINAPI BindCtxImpl_GetRunningObjectTable(IBindCtx* iface,IRunningObjectTable** pprot)
357{
358 HRESULT res;
359
360 ICOM_THIS(BindCtxImpl,iface);
361
362 TRACE("(%p,%p)\n",This,pprot);
363
364 if (pprot==NULL)
365 return E_POINTER;
[8620]366
[5602]367 res=GetRunningObjectTable(0, pprot);
368
369 return res;
370}
371
372/******************************************************************************
373 * BindCtx_RegisterObjectParam
374 ******************************************************************************/
375HRESULT WINAPI BindCtxImpl_RegisterObjectParam(IBindCtx* iface,LPOLESTR pszkey, IUnknown* punk)
376{
377 ICOM_THIS(BindCtxImpl,iface);
378
379 TRACE("(%p,%p,%p)\n",This,pszkey,punk);
380
381 if (punk==NULL)
382 return E_INVALIDARG;
[8620]383
[5602]384 IUnknown_AddRef(punk);
385
386 This->bindCtxTable[This->bindCtxTableLastIndex].pObj = punk;
387 This->bindCtxTable[This->bindCtxTableLastIndex].regType = 1;
388
389 if (pszkey==NULL)
390
391 This->bindCtxTable[This->bindCtxTableLastIndex].pkeyObj=NULL;
392
393 else{
394
395 This->bindCtxTable[This->bindCtxTableLastIndex].pkeyObj=
396 HeapAlloc(GetProcessHeap(),0,(sizeof(WCHAR)*(1+lstrlenW(pszkey))));
397
398 if (This->bindCtxTable[This->bindCtxTableLastIndex].pkeyObj==NULL)
399 return E_OUTOFMEMORY;
400 strcpyW(This->bindCtxTable[This->bindCtxTableLastIndex].pkeyObj,pszkey);
[7926]401 }
[5602]402
403 This->bindCtxTableLastIndex++;
[8620]404
[5602]405 if (This->bindCtxTableLastIndex == This->bindCtxTableSize){ /* table is full ! must be resized */
406
407 This->bindCtxTableSize+=BLOCK_TAB_SIZE; /* new table size */
408
409 if (This->bindCtxTableSize > (MAX_TAB_SIZE-BLOCK_TAB_SIZE)){
410 FIXME("This->bindCtxTableSize: %ld is out of data limite \n",This->bindCtxTableSize);
411 return E_FAIL;
412 }
413 This->bindCtxTable = HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,This->bindCtxTable,
414 This->bindCtxTableSize * sizeof(BindCtxObject));
415 if (!This->bindCtxTable)
416 return E_OUTOFMEMORY;
417 }
418 return S_OK;
419}
420/******************************************************************************
421 * BindCtx_GetObjectParam
422 ******************************************************************************/
423HRESULT WINAPI BindCtxImpl_GetObjectParam(IBindCtx* iface,LPOLESTR pszkey, IUnknown** punk)
424{
425 DWORD index;
426 ICOM_THIS(BindCtxImpl,iface);
427
428 TRACE("(%p,%p,%p)\n",This,pszkey,punk);
429
430 if (punk==NULL)
431 return E_POINTER;
432
433 *punk=0;
[8620]434
[5602]435 if (BindCtxImpl_GetObjectIndex(This,NULL,pszkey,&index)==S_FALSE)
436 return E_FAIL;
437
438 IUnknown_AddRef(This->bindCtxTable[index].pObj);
[8620]439
[5602]440 *punk = This->bindCtxTable[index].pObj;
441
442 return S_OK;
443}
444
445/******************************************************************************
446 * BindCtx_RevokeObjectParam
447 ******************************************************************************/
448HRESULT WINAPI BindCtxImpl_RevokeObjectParam(IBindCtx* iface,LPOLESTR ppenum)
449{
450 DWORD index,j;
451
452 ICOM_THIS(BindCtxImpl,iface);
453
454 TRACE("(%p,%p)\n",This,ppenum);
455
456 if (BindCtxImpl_GetObjectIndex(This,NULL,ppenum,&index)==S_FALSE)
457 return E_FAIL;
458
459 /* release the object if it's found */
460 IUnknown_Release(This->bindCtxTable[index].pObj);
[8620]461
[5602]462 /* remove the object from the table with a left-shifting of all objects in the right side */
463 for(j=index; j<This->bindCtxTableLastIndex-1; j++)
464 This->bindCtxTable[j]= This->bindCtxTable[j+1];
[8620]465
[5602]466 This->bindCtxTableLastIndex--;
467
468 return S_OK;
469}
470
471/******************************************************************************
472 * BindCtx_EnumObjectParam
473 ******************************************************************************/
474HRESULT WINAPI BindCtxImpl_EnumObjectParam(IBindCtx* iface,IEnumString** pszkey)
475{
476 FIXME("(%p,%p),stub!\n",iface,pszkey);
477 return E_NOTIMPL;
478}
479
480/********************************************************************************
481 * GetObjectIndex (local function)
482 ********************************************************************************/
483HRESULT WINAPI BindCtxImpl_GetObjectIndex(BindCtxImpl* This,
484 IUnknown* punk,
485 LPOLESTR pszkey,
486 DWORD *index)
487{
488
489 DWORD i;
490 BYTE found=0;
[8620]491
[5602]492 TRACE("(%p,%p,%p,%p)\n",This,punk,pszkey,index);
493
494 if (punk==NULL)
495 /* search object identified by a register key */
496 for(i=0; ( (i<This->bindCtxTableLastIndex) && (!found));i++){
497
498 if(This->bindCtxTable[i].regType==1){
499
500 if ( ( (This->bindCtxTable[i].pkeyObj==NULL) && (pszkey==NULL) ) ||
501 ( (This->bindCtxTable[i].pkeyObj!=NULL) &&
502 (pszkey!=NULL) &&
503 (lstrcmpW(This->bindCtxTable[i].pkeyObj,pszkey)==0)
504 )
505 )
506
507 found=1;
508 }
509 }
510 else
511 /* search object identified by a moniker*/
512 for(i=0; ( (i<This->bindCtxTableLastIndex) && (!found));i++)
513 if(This->bindCtxTable[i].pObj==punk)
514 found=1;
515
516 if (index != NULL)
517 *index=i-1;
518
519 if (found)
520 return S_OK;
521 else
522 return S_FALSE;
523}
524
525/******************************************************************************
526 * CreateBindCtx16
527 ******************************************************************************/
528HRESULT WINAPI CreateBindCtx16(DWORD reserved, LPBC * ppbc)
529{
530 FIXME("(%ld,%p),stub!\n",reserved,ppbc);
531 return E_NOTIMPL;
532}
533
534/******************************************************************************
[7926]535 * CreateBindCtx (OLE32.52)
[5602]536 ******************************************************************************/
537HRESULT WINAPI CreateBindCtx(DWORD reserved, LPBC * ppbc)
538{
539 BindCtxImpl* newBindCtx = 0;
540 HRESULT hr;
541 IID riid=IID_IBindCtx;
542
543 TRACE("(%ld,%p)\n",reserved,ppbc);
544
545 newBindCtx = HeapAlloc(GetProcessHeap(), 0, sizeof(BindCtxImpl));
546
547 if (newBindCtx == 0)
548 return E_OUTOFMEMORY;
549
550 hr = BindCtxImpl_Construct(newBindCtx);
551
552 if (FAILED(hr)){
553
554 HeapFree(GetProcessHeap(),0,newBindCtx);
555 return hr;
556 }
557
558 hr = BindCtxImpl_QueryInterface((IBindCtx*)newBindCtx,&riid,(void**)ppbc);
559
560 return hr;
561}
Note: See TracBrowser for help on using the repository browser.