git.oblomov.eu Git - wine/blob - dlls/ole32/bindctx.c

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