ole/bindctx.c

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