dlls/oleaut32/connpt.c

   1 /*
   2  * Implementation of a generic ConnectionPoint object.
   3  *
   4  * Copyright 2000 Huw D M Davies for CodeWeavers
   5  *
   6  * See one exported function here is CreateConnectionPoint, see
   7  * comments just above that function for information.
   8  */
   9
  10 #include <assert.h>
  11 #include "winerror.h"
  12 #include "olectl.h"
  13 #include "wine/obj_base.h"
  14 #include "wine/obj_connection.h"
  15 #include "connpt.h"
  16
  17 #include "debugtools.h"
  18
  19 DEFAULT_DEBUG_CHANNEL(ole)
  20
  21 #define MAXSINKS 10
  22
  23 /************************************************************************
  24  * Implementation of IConnectionPoint
  25  */
  26 typedef struct ConnectionPointImpl {
  27
  28   ICOM_VTABLE(IConnectionPoint)       *lpvtbl;
  29
  30   /* IUnknown of our main object*/
  31   IUnknown *Obj;
  32
  33   /* Reference count */
  34   DWORD ref;
  35
  36   /* IID of sink interface */
  37   IID iid;
  38
  39   /* Array of sink IUnknowns */
  40   IUnknown **sinks;
  41   DWORD maxSinks;
  42
  43   DWORD nSinks;
  44 } ConnectionPointImpl;
  45
  46 static ICOM_VTABLE(IConnectionPoint) ConnectionPointImpl_VTable;
  47
  48
  49 /************************************************************************
  50  * Implementation of IEnumConnections
  51  */
  52 typedef struct EnumConnectionsImpl {
  53
  54   ICOM_VTABLE(IEnumConnections)       *lpvtbl;
  55
  56   DWORD ref;
  57
  58   /* IUnknown of ConnectionPoint, used for ref counting */
  59   IUnknown *pUnk;
  60
  61   /* Connection Data */
  62   CONNECTDATA *pCD;
  63   DWORD nConns;
  64
  65   /* Next connection to enumerate from */
  66   DWORD nCur;
  67
  68 } EnumConnectionsImpl;
  69
  70 static EnumConnectionsImpl *EnumConnectionsImpl_Construct(IUnknown *pUnk,
  71                                                           DWORD nSinks,
  72                                                           CONNECTDATA *pCD);
  73
  74
  75 /************************************************************************
  76  * ConnectionPointImpl_Construct
  77  */
  78 static ConnectionPointImpl *ConnectionPointImpl_Construct(IUnknown *pUnk,
  79                                                           REFIID riid)
  80 {
  81   ConnectionPointImpl *Obj;
  82
  83   Obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*Obj));
  84   Obj->lpvtbl = &ConnectionPointImpl_VTable;
  85   Obj->Obj = pUnk;
  86   Obj->ref = 1;
  87   Obj->iid =  *riid;
  88   Obj->maxSinks = MAXSINKS;
  89   Obj->sinks = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
  90                          sizeof(IUnknown*) * MAXSINKS);
  91   Obj->nSinks = 0;
  92   return Obj;
  93 }
  94
  95 /************************************************************************
  96  * ConnectionPointImpl_Destroy
  97  */
  98 static void ConnectionPointImpl_Destroy(ConnectionPointImpl *Obj)
  99 {
 100   DWORD i;
 101   for(i = 0; i < Obj->maxSinks; i++) {
 102     if(Obj->sinks[i]) {
 103       IUnknown_Release(Obj->sinks[i]);
 104       Obj->sinks[i] = NULL;
 105     }
 106   }
 107   HeapFree(GetProcessHeap(), 0, Obj->sinks);
 108   HeapFree(GetProcessHeap(), 0, Obj);
 109   return;
 110 }
 111
 112 static ULONG WINAPI ConnectionPointImpl_AddRef(IConnectionPoint* iface);
 113 /************************************************************************
 114  * ConnectionPointImpl_QueryInterface (IUnknown)
 115  *
 116  * See Windows documentation for more details on IUnknown methods.
 117  */
 118 static HRESULT WINAPI ConnectionPointImpl_QueryInterface(
 119   IConnectionPoint*  iface,
 120   REFIID  riid,
 121   void**  ppvObject)
 122 {
 123   ICOM_THIS(ConnectionPointImpl, iface);
 124   TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObject);
 125
 126   /*
 127    * Perform a sanity check on the parameters.
 128    */
 129   if ( (This==0) || (ppvObject==0) )
 130     return E_INVALIDARG;
 131
 132   /*
 133    * Initialize the return parameter.
 134    */
 135   *ppvObject = 0;
 136
 137   /*
 138    * Compare the riid with the interface IDs implemented by this object.
 139    */
 140   if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
 141   {
 142     *ppvObject = (IConnectionPoint*)This;
 143   }
 144   else if (memcmp(&IID_IConnectionPoint, riid, sizeof(IID_IConnectionPoint)) == 0)
 145   {
 146     *ppvObject = (IConnectionPoint*)This;
 147   }
 148
 149   /*
 150    * Check that we obtained an interface.
 151    */
 152   if ((*ppvObject)==0)
 153   {
 154     FIXME("() : asking for un supported interface %s\n",debugstr_guid(riid));
 155     return E_NOINTERFACE;
 156   }
 157
 158   /*
 159    * Query Interface always increases the reference count by one when it is
 160    * successful
 161    */
 162   ConnectionPointImpl_AddRef((IConnectionPoint*)This);
 163
 164   return S_OK;;
 165 }
 166
 167
 168 /************************************************************************
 169  * ConnectionPointImpl_AddRef (IUnknown)
 170  *
 171  * See Windows documentation for more details on IUnknown methods.
 172  */
 173 static ULONG WINAPI ConnectionPointImpl_AddRef(IConnectionPoint* iface)
 174 {
 175   ICOM_THIS(ConnectionPointImpl, iface);
 176   TRACE("(%p)->(ref=%ld)\n", This, This->ref);
 177   This->ref++;
 178
 179   return This->ref;
 180 }
 181
 182 /************************************************************************
 183  * ConnectionPointImpl_Release (IUnknown)
 184  *
 185  * See Windows documentation for more details on IUnknown methods.
 186  */
 187 static ULONG WINAPI ConnectionPointImpl_Release(
 188       IConnectionPoint* iface)
 189 {
 190   ICOM_THIS(ConnectionPointImpl, iface);
 191   TRACE("(%p)->(ref=%ld)\n", This, This->ref);
 192
 193   /*
 194    * Decrease the reference count on this object.
 195    */
 196   This->ref--;
 197
 198   /*
 199    * If the reference count goes down to 0, perform suicide.
 200    */
 201   if (This->ref==0)
 202   {
 203     ConnectionPointImpl_Destroy(This);
 204
 205     return 0;
 206   }
 207
 208   return This->ref;
 209 }
 210
 211 /************************************************************************
 212  * ConnectionPointImpl_GetConnectionInterface (IConnectionPoint)
 213  *
 214  */
 215 static HRESULT WINAPI ConnectionPointImpl_GetConnectionInterface(
 216                                                IConnectionPoint *iface,
 217                                                IID              *piid)
 218 {
 219   ICOM_THIS(ConnectionPointImpl, iface);
 220   TRACE("(%p)->(%p) returning %s\n", This, piid, debugstr_guid(&(This->iid)));
 221   *piid = This->iid;
 222   return S_OK;
 223 }
 224
 225 /************************************************************************
 226  * ConnectionPointImpl_GetConnectionPointContainer (IConnectionPoint)
 227  *
 228  */
 229 static HRESULT WINAPI ConnectionPointImpl_GetConnectionPointContainer(
 230                                       IConnectionPoint           *iface,
 231                                       IConnectionPointContainer  **ppCPC)
 232 {
 233   ICOM_THIS(ConnectionPointImpl, iface);
 234   TRACE("(%p)->(%p)\n", This, ppCPC);
 235
 236   return IUnknown_QueryInterface(This->Obj,
 237                                  &IID_IConnectionPointContainer,
 238                                  (LPVOID)ppCPC);
 239 }
 240
 241 /************************************************************************
 242  * ConnectionPointImpl_Advise (IConnectionPoint)
 243  *
 244  */
 245 static HRESULT WINAPI ConnectionPointImpl_Advise(IConnectionPoint *iface,
 246                                                  IUnknown *lpUnk,
 247                                                  DWORD *pdwCookie)
 248 {
 249   DWORD i;
 250   ICOM_THIS(ConnectionPointImpl, iface);
 251   IUnknown *lpSink;
 252   TRACE("(%p)->(%p, %p)\n", This, lpUnk, pdwCookie);
 253
 254   *pdwCookie = 0;
 255   if(FAILED(IUnknown_QueryInterface(lpUnk, &This->iid, (LPVOID)&lpSink)))
 256     return CONNECT_E_CANNOTCONNECT;
 257
 258   for(i = 0; i < This->maxSinks; i++) {
 259     if(This->sinks[i] == NULL)
 260       break;
 261   }
 262   if(i == This->maxSinks) {
 263     This->maxSinks += MAXSINKS;
 264     This->sinks = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, This->sinks,
 265                               This->maxSinks * sizeof(IUnknown *));
 266   }
 267   This->sinks[i] = lpSink;
 268   This->nSinks++;
 269   *pdwCookie = i + 1;
 270   return S_OK;
 271 }
 272
 273
 274 /************************************************************************
 275  * ConnectionPointImpl_Unadvise (IConnectionPoint)
 276  *
 277  */
 278 static HRESULT WINAPI ConnectionPointImpl_Unadvise(IConnectionPoint *iface,
 279                                                    DWORD dwCookie)
 280 {
 281   ICOM_THIS(ConnectionPointImpl, iface);
 282   TRACE("(%p)->(%ld)\n", This, dwCookie);
 283
 284   if(dwCookie == 0 || dwCookie > This->maxSinks) return E_INVALIDARG;
 285
 286   if(This->sinks[dwCookie-1] == NULL) return CONNECT_E_NOCONNECTION;
 287
 288   IUnknown_Release(This->sinks[dwCookie-1]);
 289   This->sinks[dwCookie-1] = NULL;
 290   This->nSinks--;
 291   return S_OK;
 292 }
 293
 294 /************************************************************************
 295  * ConnectionPointImpl_EnumConnections (IConnectionPoint)
 296  *
 297  */
 298 static HRESULT WINAPI ConnectionPointImpl_EnumConnections(
 299                                                     IConnectionPoint *iface,
 300                                                     LPENUMCONNECTIONS *ppEnum)
 301 {
 302   ICOM_THIS(ConnectionPointImpl, iface);
 303   CONNECTDATA *pCD;
 304   DWORD i, nextslot;
 305   EnumConnectionsImpl *EnumObj;
 306   HRESULT hr;
 307
 308   TRACE("(%p)->(%p)\n", This, ppEnum);
 309
 310   *ppEnum = NULL;
 311
 312   if(This->nSinks == 0) return OLE_E_NOCONNECTION;
 313
 314   pCD = HeapAlloc(GetProcessHeap(), 0, sizeof(CONNECTDATA) * This->nSinks);
 315
 316   for(i = 0, nextslot = 0; i < This->maxSinks; i++) {
 317     if(This->sinks[i] != NULL) {
 318       pCD[nextslot].pUnk = This->sinks[i];
 319       pCD[nextslot].dwCookie = i + 1;
 320       nextslot++;
 321     }
 322   }
 323   assert(nextslot == This->nSinks);
 324
 325   /* Bump the ref count of this object up by one.  It gets Released in
 326      IEnumConnections_Release */
 327   IUnknown_AddRef((IUnknown*)This);
 328
 329   EnumObj = EnumConnectionsImpl_Construct((IUnknown*)This, This->nSinks, pCD);
 330   hr = IEnumConnections_QueryInterface((IEnumConnections*)EnumObj,
 331                                   &IID_IEnumConnections, (LPVOID)ppEnum);
 332   IEnumConnections_Release((IEnumConnections*)EnumObj);
 333
 334   HeapFree(GetProcessHeap(), 0, pCD);
 335   return hr;
 336 }
 337
 338 static ICOM_VTABLE(IConnectionPoint) ConnectionPointImpl_VTable =
 339 {
 340   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 341   ConnectionPointImpl_QueryInterface,
 342   ConnectionPointImpl_AddRef,
 343   ConnectionPointImpl_Release,
 344   ConnectionPointImpl_GetConnectionInterface,
 345   ConnectionPointImpl_GetConnectionPointContainer,
 346   ConnectionPointImpl_Advise,
 347   ConnectionPointImpl_Unadvise,
 348   ConnectionPointImpl_EnumConnections
 349 };
 350
 351
 352 static ICOM_VTABLE(IEnumConnections) EnumConnectionsImpl_VTable;
 353 static ULONG WINAPI EnumConnectionsImpl_AddRef(IEnumConnections* iface);
 354
 355 /************************************************************************
 356  * EnumConnectionsImpl_Construct
 357  */
 358 static EnumConnectionsImpl *EnumConnectionsImpl_Construct(IUnknown *pUnk,
 359                                                           DWORD nSinks,
 360                                                           CONNECTDATA *pCD)
 361 {
 362   EnumConnectionsImpl *Obj = HeapAlloc(GetProcessHeap(), 0, sizeof(*Obj));
 363   DWORD i;
 364
 365   Obj->lpvtbl = &EnumConnectionsImpl_VTable;
 366   Obj->ref = 1;
 367   Obj->pUnk = pUnk;
 368   Obj->pCD = HeapAlloc(GetProcessHeap(), 0, nSinks * sizeof(CONNECTDATA));
 369   Obj->nConns = nSinks;
 370   Obj->nCur = 0;
 371
 372   for(i = 0; i < nSinks; i++) {
 373     Obj->pCD[i] = pCD[i];
 374     IUnknown_AddRef(Obj->pCD[i].pUnk);
 375   }
 376   return Obj;
 377 }
 378
 379 /************************************************************************
 380  * EnumConnectionsImpl_Destroy
 381  */
 382 static void EnumConnectionsImpl_Destroy(EnumConnectionsImpl *Obj)
 383 {
 384   DWORD i;
 385
 386   for(i = 0; i < Obj->nConns; i++)
 387     IUnknown_Release(Obj->pCD[i].pUnk);
 388
 389   HeapFree(GetProcessHeap(), 0, Obj->pCD);
 390   HeapFree(GetProcessHeap(), 0, Obj);
 391   return;
 392 }
 393
 394 /************************************************************************
 395  * EnumConnectionsImpl_QueryInterface (IUnknown)
 396  *
 397  * See Windows documentation for more details on IUnknown methods.
 398  */
 399 static HRESULT WINAPI EnumConnectionsImpl_QueryInterface(
 400   IEnumConnections*  iface,
 401   REFIID  riid,
 402   void**  ppvObject)
 403 {
 404   ICOM_THIS(ConnectionPointImpl, iface);
 405   TRACE("(%p)->(%s, %p)\n", This, debugstr_guid(riid), ppvObject);
 406
 407   /*
 408    * Perform a sanity check on the parameters.
 409    */
 410   if ( (This==0) || (ppvObject==0) )
 411     return E_INVALIDARG;
 412
 413   /*
 414    * Initialize the return parameter.
 415    */
 416   *ppvObject = 0;
 417
 418   /*
 419    * Compare the riid with the interface IDs implemented by this object.
 420    */
 421   if (memcmp(&IID_IUnknown, riid, sizeof(IID_IUnknown)) == 0)
 422   {
 423     *ppvObject = (IEnumConnections*)This;
 424   }
 425   else if (memcmp(&IID_IEnumConnections, riid, sizeof(IID_IEnumConnections)) == 0)
 426   {
 427     *ppvObject = (IEnumConnections*)This;
 428   }
 429
 430   /*
 431    * Check that we obtained an interface.
 432    */
 433   if ((*ppvObject)==0)
 434   {
 435     FIXME("() : asking for un supported interface %s\n",debugstr_guid(riid));
 436     return E_NOINTERFACE;
 437   }
 438
 439   /*
 440    * Query Interface always increases the reference count by one when it is
 441    * successful
 442    */
 443   EnumConnectionsImpl_AddRef((IEnumConnections*)This);
 444
 445   return S_OK;;
 446 }
 447
 448
 449 /************************************************************************
 450  * EnumConnectionsImpl_AddRef (IUnknown)
 451  *
 452  * See Windows documentation for more details on IUnknown methods.
 453  */
 454 static ULONG WINAPI EnumConnectionsImpl_AddRef(IEnumConnections* iface)
 455 {
 456   ICOM_THIS(EnumConnectionsImpl, iface);
 457   TRACE("(%p)->(ref=%ld)\n", This, This->ref);
 458   This->ref++;
 459   IUnknown_AddRef(This->pUnk);
 460   return This->ref;
 461 }
 462
 463 /************************************************************************
 464  * EnumConnectionsImpl_Release (IUnknown)
 465  *
 466  * See Windows documentation for more details on IUnknown methods.
 467  */
 468 static ULONG WINAPI EnumConnectionsImpl_Release(IEnumConnections* iface)
 469 {
 470   ICOM_THIS(EnumConnectionsImpl, iface);
 471   TRACE("(%p)->(ref=%ld)\n", This, This->ref);
 472
 473   IUnknown_Release(This->pUnk);
 474
 475   /*
 476    * Decrease the reference count on this object.
 477    */
 478   This->ref--;
 479
 480   /*
 481    * If the reference count goes down to 0, perform suicide.
 482    */
 483   if (This->ref==0)
 484   {
 485     EnumConnectionsImpl_Destroy(This);
 486
 487     return 0;
 488   }
 489
 490   return This->ref;
 491 }
 492
 493 /************************************************************************
 494  * EnumConnectionsImpl_Next (IEnumConnections)
 495  *
 496  */
 497 static HRESULT WINAPI EnumConnectionsImpl_Next(IEnumConnections* iface,
 498                                                ULONG cConn, LPCONNECTDATA pCD,
 499                                                ULONG *pEnum)
 500 {
 501   ICOM_THIS(EnumConnectionsImpl, iface);
 502   DWORD nRet = 0;
 503   TRACE("(%p)->(%ld, %p, %p)\n", This, cConn, pCD, pEnum);
 504
 505   if(pEnum == NULL) {
 506     if(cConn != 1)
 507       return E_POINTER;
 508   } else
 509     *pEnum = 0;
 510
 511   if(This->nCur >= This->nConns)
 512     return S_FALSE;
 513
 514   while(This->nCur < This->nConns && cConn) {
 515     *pCD++ = This->pCD[This->nCur];
 516     IUnknown_AddRef(This->pCD[This->nCur].pUnk);
 517     This->nCur++;
 518     cConn--;
 519     nRet++;
 520   }
 521
 522   if(pEnum)
 523     *pEnum = nRet;
 524
 525   return S_OK;
 526 }
 527
 528
 529 /************************************************************************
 530  * EnumConnectionsImpl_Skip (IEnumConnections)
 531  *
 532  */
 533 static HRESULT WINAPI EnumConnectionsImpl_Skip(IEnumConnections* iface,
 534                                                ULONG cSkip)
 535 {
 536   ICOM_THIS(EnumConnectionsImpl, iface);
 537   TRACE("(%p)->(%ld)\n", This, cSkip);
 538
 539   if(This->nCur + cSkip >= This->nConns)
 540     return S_FALSE;
 541
 542   This->nCur += cSkip;
 543
 544   return S_OK;
 545 }
 546
 547
 548 /************************************************************************
 549  * EnumConnectionsImpl_Reset (IEnumConnections)
 550  *
 551  */
 552 static HRESULT WINAPI EnumConnectionsImpl_Reset(IEnumConnections* iface)
 553 {
 554   ICOM_THIS(EnumConnectionsImpl, iface);
 555   TRACE("(%p)\n", This);
 556
 557   This->nCur = 0;
 558
 559   return S_OK;
 560 }
 561
 562
 563 /************************************************************************
 564  * EnumConnectionsImpl_Clone (IEnumConnections)
 565  *
 566  */
 567 static HRESULT WINAPI EnumConnectionsImpl_Clone(IEnumConnections* iface,
 568                                                 LPENUMCONNECTIONS *ppEnum)
 569 {
 570   ICOM_THIS(EnumConnectionsImpl, iface);
 571   EnumConnectionsImpl *newObj;
 572   TRACE("(%p)->(%p)\n", This, ppEnum);
 573
 574   newObj = EnumConnectionsImpl_Construct(This->pUnk, This->nConns, This->pCD);
 575   newObj->nCur = This->nCur;
 576   *ppEnum = (LPENUMCONNECTIONS)newObj;
 577   IUnknown_AddRef(This->pUnk);
 578   return S_OK;
 579 }
 580
 581 static ICOM_VTABLE(IEnumConnections) EnumConnectionsImpl_VTable =
 582 {
 583   ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 584   EnumConnectionsImpl_QueryInterface,
 585   EnumConnectionsImpl_AddRef,
 586   EnumConnectionsImpl_Release,
 587   EnumConnectionsImpl_Next,
 588   EnumConnectionsImpl_Skip,
 589   EnumConnectionsImpl_Reset,
 590   EnumConnectionsImpl_Clone
 591 };
 592
 593 /************************************************************************
 594  *
 595  *  The exported function to create the connection point.
 596  *  NB not a windows API
 597  *
 598  * PARAMS
 599  * pUnk [in] IUnknown of object to which the ConnectionPoint is associated.
 600  *           Needed to access IConnectionPointContainer.
 601  *
 602  * riid [in] IID of sink interface that this ConnectionPoint manages
 603  *
 604  * pCP [out] returns IConnectionPoint
 605  *
 606  */
 607 HRESULT CreateConnectionPoint(IUnknown *pUnk, REFIID riid,
 608                               IConnectionPoint **pCP)
 609 {
 610   ConnectionPointImpl *Obj;
 611   HRESULT hr;
 612
 613   Obj = ConnectionPointImpl_Construct(pUnk, riid);
 614   if(!Obj) return E_OUTOFMEMORY;
 615
 616   hr = IConnectionPoint_QueryInterface((IConnectionPoint *)Obj,
 617                                        &IID_IConnectionPoint, (LPVOID)pCP);
 618   IConnectionPoint_Release((IConnectionPoint *)Obj);
 619   return hr;
 620 }