dlls/dpnet/address.c

   1 /*
   2  * DirectPlay8 Address
   3  *
   4  * Copyright 2004 Raphael Junqueira
   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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  *
  20  */
  21
  22 #include "config.h"
  23
  24 #include <stdarg.h>
  25
  26 #define COBJMACROS
  27 #include "windef.h"
  28 #include "winbase.h"
  29 #include "wingdi.h"
  30 #include "winuser.h"
  31 #include "objbase.h"
  32
  33 #include "wine/unicode.h"
  34 #include "wine/debug.h"
  35
  36 #include "dplay8.h"
  37 #include "dpnet_private.h"
  38
  39 WINE_DEFAULT_DEBUG_CHANNEL(dpnet);
  40
  41
  42 static inline void *heap_alloc(size_t len)
  43 {
  44     return HeapAlloc(GetProcessHeap(), 0, len);
  45 }
  46
  47 static inline void *heap_realloc(void *mem, size_t len)
  48 {
  49     return HeapReAlloc( GetProcessHeap(), 0, mem, len);
  50 }
  51
  52 static inline BOOL heap_free(void *mem)
  53 {
  54     return HeapFree(GetProcessHeap(), 0, mem);
  55 }
  56
  57 static inline LPWSTR heap_strdupW(LPCWSTR str)
  58 {
  59     LPWSTR ret = NULL;
  60
  61     if(str) {
  62         DWORD size;
  63
  64         size = (strlenW(str)+1)*sizeof(WCHAR);
  65         ret = heap_alloc(size);
  66         if(ret)
  67             memcpy(ret, str, size);
  68     }
  69
  70     return ret;
  71 }
  72
  73 static char *heap_strdupA( const char *str )
  74 {
  75     char *ret;
  76
  77     if (!str) return NULL;
  78     if ((ret = HeapAlloc( GetProcessHeap(), 0, strlen(str) + 1 ))) strcpy( ret, str );
  79     return ret;
  80 }
  81
  82 static BOOL add_component(IDirectPlay8AddressImpl *This, struct component *item)
  83 {
  84     if(This->comp_count == This->comp_array_size)
  85     {
  86         struct component **temp;
  87
  88         temp = heap_realloc(This->components, sizeof(*temp) * This->comp_array_size * 2 );
  89         if(!temp)
  90         {
  91             return FALSE;
  92         }
  93
  94         This->comp_array_size *= 2;
  95         This->components = temp;
  96     }
  97
  98     This->components[This->comp_count] = item;
  99     This->comp_count++;
 100
 101     return TRUE;
 102 }
 103
 104 static inline IDirectPlay8AddressImpl *impl_from_IDirectPlay8Address(IDirectPlay8Address *iface)
 105 {
 106     return CONTAINING_RECORD(iface, IDirectPlay8AddressImpl, IDirectPlay8Address_iface);
 107 }
 108
 109 /* IDirectPlay8Address IUnknown parts follow: */
 110 static HRESULT WINAPI IDirectPlay8AddressImpl_QueryInterface(IDirectPlay8Address *iface,
 111         REFIID riid, void **ppv)
 112 {
 113     if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IDirectPlay8Address)) {
 114         IUnknown_AddRef(iface);
 115         *ppv = iface;
 116         return DPN_OK;
 117     }
 118
 119     WARN("(%p)->(%s,%p),not found\n", iface, debugstr_guid(riid), ppv);
 120     return E_NOINTERFACE;
 121 }
 122
 123 static ULONG WINAPI IDirectPlay8AddressImpl_AddRef(IDirectPlay8Address *iface)
 124 {
 125     IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 126     ULONG ref = InterlockedIncrement(&This->ref);
 127
 128     TRACE("(%p) ref=%u\n", This, ref);
 129
 130     return ref;
 131 }
 132
 133 static ULONG WINAPI IDirectPlay8AddressImpl_Release(IDirectPlay8Address *iface)
 134 {
 135     IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 136     ULONG ref = InterlockedDecrement(&This->ref);
 137
 138     TRACE("(%p) ref=%u\n", This, ref);
 139
 140     if (!ref)
 141     {
 142         struct component *entry;
 143         DWORD i;
 144
 145         for(i=0; i < This->comp_count; i++)
 146         {
 147             entry = This->components[i];
 148
 149             switch(entry->type)
 150             {
 151                 case DPNA_DATATYPE_STRING:
 152                     heap_free(entry->data.string);
 153                     break;
 154                 case DPNA_DATATYPE_STRING_ANSI:
 155                     heap_free(entry->data.ansi);
 156                     break;
 157                 case DPNA_DATATYPE_BINARY:
 158                     heap_free(entry->data.binary);
 159                     break;
 160             }
 161
 162             heap_free(entry);
 163         }
 164
 165         heap_free(This->components);
 166         heap_free(This);
 167     }
 168     return ref;
 169 }
 170
 171 /* returns name of given GUID */
 172 static const char *debugstr_SP(const GUID *id) {
 173   static const guid_info guids[] = {
 174     /* CLSIDs */
 175     GE(CLSID_DP8SP_IPX),
 176     GE(CLSID_DP8SP_TCPIP),
 177     GE(CLSID_DP8SP_SERIAL),
 178     GE(CLSID_DP8SP_MODEM)
 179   };
 180   unsigned int i;
 181
 182   if (!id) return "(null)";
 183
 184   for (i = 0; i < sizeof(guids)/sizeof(guids[0]); i++) {
 185     if (IsEqualGUID(id, guids[i].guid))
 186       return guids[i].name;
 187   }
 188   /* if we didn't find it, act like standard debugstr_guid */
 189   return debugstr_guid(id);
 190 }
 191
 192 /* IDirectPlay8Address Interface follow: */
 193
 194 static HRESULT WINAPI IDirectPlay8AddressImpl_BuildFromURLW(IDirectPlay8Address *iface,
 195         WCHAR *pwszSourceURL)
 196 {
 197   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 198   TRACE("(%p, %s): stub\n", This, debugstr_w(pwszSourceURL));
 199   return DPN_OK;
 200 }
 201
 202 static HRESULT WINAPI IDirectPlay8AddressImpl_BuildFromURLA(IDirectPlay8Address *iface,
 203        CHAR *pszSourceURL)
 204 {
 205   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 206   TRACE("(%p, %s): stub\n", This, pszSourceURL);
 207   return DPN_OK;
 208 }
 209
 210 static HRESULT WINAPI IDirectPlay8AddressImpl_Duplicate(IDirectPlay8Address *iface,
 211         IDirectPlay8Address **ppdpaNewAddress)
 212 {
 213     IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 214     IDirectPlay8Address *dup;
 215     HRESULT hr;
 216
 217     TRACE("(%p, %p)\n", This, ppdpaNewAddress);
 218
 219     if(!ppdpaNewAddress)
 220         return E_POINTER;
 221
 222     hr = DPNET_CreateDirectPlay8Address(NULL, NULL, &IID_IDirectPlay8Address, (LPVOID*)&dup);
 223     if(hr == S_OK)
 224     {
 225         IDirectPlay8AddressImpl *DupThis = impl_from_IDirectPlay8Address(dup);
 226         DWORD i;
 227
 228         DupThis->SP_guid = This->SP_guid;
 229         DupThis->init    = This->init;
 230
 231         for(i=0; i < This->comp_count; i++)
 232         {
 233             struct component *entry = This->components[i];
 234
 235             hr = IDirectPlay8Address_AddComponent(dup, entry->name, &entry->data, entry->size, entry->type);
 236             if(hr != S_OK)
 237                 ERR("Failed to copy component: %s - 0x%08x\n", debugstr_w(entry->name), hr);
 238         }
 239
 240         *ppdpaNewAddress = dup;
 241     }
 242
 243     return hr;
 244 }
 245
 246 static HRESULT WINAPI IDirectPlay8AddressImpl_SetEqual(IDirectPlay8Address *iface,
 247         IDirectPlay8Address *pdpaAddress)
 248 {
 249   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 250   TRACE("(%p, %p): stub\n", This, pdpaAddress);
 251   return DPN_OK;
 252 }
 253
 254 static HRESULT WINAPI IDirectPlay8AddressImpl_IsEqual(IDirectPlay8Address *iface,
 255         IDirectPlay8Address *pdpaAddress)
 256 {
 257   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 258   TRACE("(%p, %p): stub\n", This, pdpaAddress);
 259   return DPN_OK;
 260 }
 261
 262 static HRESULT WINAPI IDirectPlay8AddressImpl_Clear(IDirectPlay8Address *iface)
 263 {
 264   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 265   TRACE("(%p): stub\n", This);
 266   return DPN_OK;
 267 }
 268
 269 static HRESULT WINAPI IDirectPlay8AddressImpl_GetURLW(IDirectPlay8Address *iface, WCHAR *pwszURL,
 270         DWORD *pdwNumChars)
 271 {
 272   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 273   TRACE("(%p): stub\n", This);
 274   return DPN_OK;
 275 }
 276
 277 static HRESULT WINAPI IDirectPlay8AddressImpl_GetURLA(IDirectPlay8Address *iface, CHAR *pszURL,
 278         DWORD *pdwNumChars)
 279 {
 280   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 281   TRACE("(%p): stub\n", This);
 282   return DPN_OK;
 283 }
 284
 285 static HRESULT WINAPI IDirectPlay8AddressImpl_GetSP(IDirectPlay8Address *iface, GUID *pguidSP)
 286 {
 287     IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 288
 289     TRACE("(%p, %p)\n", iface, pguidSP);
 290
 291     if(!pguidSP)
 292         return DPNERR_INVALIDPOINTER;
 293
 294     if(!This->init)
 295         return DPNERR_DOESNOTEXIST;
 296
 297     *pguidSP = This->SP_guid;
 298     return DPN_OK;
 299 }
 300
 301 static HRESULT WINAPI IDirectPlay8AddressImpl_GetUserData(IDirectPlay8Address *iface,
 302         void *pvUserData, DWORD *pdwBufferSize)
 303 {
 304   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 305   TRACE("(%p): stub\n", This);
 306   return DPN_OK;
 307 }
 308
 309 static HRESULT WINAPI IDirectPlay8AddressImpl_SetSP(IDirectPlay8Address *iface,
 310         const GUID *const pguidSP)
 311 {
 312     IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 313
 314     TRACE("(%p, %s)\n", iface, debugstr_SP(pguidSP));
 315
 316     if(!pguidSP)
 317         return DPNERR_INVALIDPOINTER;
 318
 319     This->init = TRUE;
 320     This->SP_guid = *pguidSP;
 321
 322     IDirectPlay8Address_AddComponent(iface, DPNA_KEY_PROVIDER, &This->SP_guid, sizeof(GUID), DPNA_DATATYPE_GUID);
 323
 324     return DPN_OK;
 325 }
 326
 327 static HRESULT WINAPI IDirectPlay8AddressImpl_SetUserData(IDirectPlay8Address *iface,
 328         const void *const pvUserData, const DWORD dwDataSize)
 329 {
 330   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 331   TRACE("(%p): stub\n", This);
 332   return DPN_OK;
 333 }
 334
 335 static HRESULT WINAPI IDirectPlay8AddressImpl_GetNumComponents(IDirectPlay8Address *iface,
 336         DWORD *pdwNumComponents)
 337 {
 338     IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 339     TRACE("(%p): stub\n", This);
 340
 341     if(!pdwNumComponents)
 342         return DPNERR_INVALIDPOINTER;
 343
 344     *pdwNumComponents = This->comp_count;
 345
 346     return DPN_OK;
 347 }
 348
 349 static HRESULT WINAPI IDirectPlay8AddressImpl_GetComponentByName(IDirectPlay8Address *iface,
 350         const WCHAR *const pwszName, void *pvBuffer, DWORD *pdwBufferSize, DWORD *pdwDataType)
 351 {
 352     IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 353     struct component *entry;
 354     DWORD i;
 355
 356     TRACE("(%p)->(%p %p %p %p)\n", This, pwszName, pvBuffer, pdwBufferSize, pdwDataType);
 357
 358     if(!pwszName || !pdwBufferSize || !pdwDataType || (!pvBuffer && pdwBufferSize))
 359         return E_POINTER;
 360
 361     for(i=0; i < This->comp_count; i++)
 362     {
 363         entry = This->components[i];
 364
 365         if (lstrcmpW(pwszName, entry->name) == 0)
 366         {
 367             TRACE("Found %s\n", debugstr_w(pwszName));
 368
 369             if(*pdwBufferSize < entry->size)
 370             {
 371                 *pdwBufferSize = entry->size;
 372                 return DPNERR_BUFFERTOOSMALL;
 373             }
 374
 375             *pdwBufferSize = entry->size;
 376             *pdwDataType   = entry->type;
 377
 378             switch (entry->type)
 379             {
 380                 case DPNA_DATATYPE_DWORD:
 381                     memcpy(pvBuffer, &entry->data.value, sizeof(DWORD));
 382                     break;
 383                 case DPNA_DATATYPE_GUID:
 384                     memcpy(pvBuffer, &entry->data.guid, sizeof(GUID));
 385                     break;
 386                 case DPNA_DATATYPE_STRING:
 387                     memcpy(pvBuffer, entry->data.string, entry->size);
 388                     break;
 389                 case DPNA_DATATYPE_STRING_ANSI:
 390                     memcpy(pvBuffer, entry->data.ansi, entry->size);
 391                     break;
 392                 case DPNA_DATATYPE_BINARY:
 393                     memcpy(pvBuffer, entry->data.binary, entry->size);
 394                     break;
 395             }
 396
 397             return S_OK;
 398         }
 399     }
 400
 401     return DPNERR_DOESNOTEXIST;
 402 }
 403
 404 static HRESULT WINAPI IDirectPlay8AddressImpl_GetComponentByIndex(IDirectPlay8Address *iface,
 405         const DWORD dwComponentID, WCHAR *pwszName, DWORD *pdwNameLen, void *pvBuffer,
 406         DWORD *pdwBufferSize, DWORD *pdwDataType)
 407 {
 408   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 409   TRACE("(%p): stub\n", This);
 410   return DPN_OK;
 411 }
 412
 413 static HRESULT WINAPI IDirectPlay8AddressImpl_AddComponent(IDirectPlay8Address *iface,
 414         const WCHAR *const pwszName, const void* const lpvData, const DWORD dwDataSize,
 415         const DWORD dwDataType)
 416 {
 417     IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 418     struct component *entry;
 419     BOOL found = FALSE;
 420     DWORD i;
 421
 422     TRACE("(%p, %s, %p, %u, %x)\n", This, debugstr_w(pwszName), lpvData, dwDataSize, dwDataType);
 423
 424     if (NULL == lpvData)
 425         return DPNERR_INVALIDPOINTER;
 426
 427     switch (dwDataType)
 428     {
 429         case DPNA_DATATYPE_DWORD:
 430             if (sizeof(DWORD) != dwDataSize)
 431             {
 432                 WARN("Invalid DWORD size, returning DPNERR_INVALIDPARAM\n");
 433                 return DPNERR_INVALIDPARAM;
 434             }
 435             break;
 436         case DPNA_DATATYPE_GUID:
 437             if (sizeof(GUID) != dwDataSize)
 438             {
 439                 WARN("Invalid GUID size, returning DPNERR_INVALIDPARAM\n");
 440                 return DPNERR_INVALIDPARAM;
 441             }
 442             break;
 443         case DPNA_DATATYPE_STRING:
 444             if (((strlenW((WCHAR*)lpvData)+1)*sizeof(WCHAR)) != dwDataSize)
 445             {
 446                 WARN("Invalid STRING size, returning DPNERR_INVALIDPARAM\n");
 447                 return DPNERR_INVALIDPARAM;
 448             }
 449             break;
 450         case DPNA_DATATYPE_STRING_ANSI:
 451             if ((strlen((const CHAR*)lpvData)+1) != dwDataSize)
 452             {
 453                 WARN("Invalid ASCII size, returning DPNERR_INVALIDPARAM\n");
 454                 return DPNERR_INVALIDPARAM;
 455             }
 456             break;
 457     }
 458
 459     for(i=0; i < This->comp_count; i++)
 460     {
 461         entry = This->components[i];
 462
 463         if (lstrcmpW(pwszName, entry->name) == 0)
 464         {
 465             TRACE("Found %s\n", debugstr_w(pwszName));
 466             found = TRUE;
 467
 468             if(entry->type == DPNA_DATATYPE_STRING_ANSI)
 469                 heap_free(entry->data.ansi);
 470             else if(entry->type == DPNA_DATATYPE_STRING)
 471                 heap_free(entry->data.string);
 472             else if(entry->type == DPNA_DATATYPE_BINARY)
 473                 heap_free(entry->data.binary);
 474
 475             break;
 476         }
 477     }
 478
 479     if(!found)
 480     {
 481         /* Create a new one */
 482         entry = heap_alloc(sizeof(struct component));
 483         if(!entry)
 484             return E_OUTOFMEMORY;
 485
 486         entry->name = heap_strdupW(pwszName);
 487         if(!entry->name)
 488         {
 489             heap_free(entry);
 490             return E_OUTOFMEMORY;
 491         }
 492
 493         if(!add_component(This, entry))
 494         {
 495            heap_free(entry->name);
 496            heap_free(entry);
 497            return E_OUTOFMEMORY;
 498         }
 499     }
 500
 501     switch (dwDataType)
 502     {
 503         case DPNA_DATATYPE_DWORD:
 504             entry->data.value = *(DWORD*)lpvData;
 505             TRACE("(%p, %u): DWORD Type -> %u\n", lpvData, dwDataSize, *(const DWORD*) lpvData);
 506             break;
 507         case DPNA_DATATYPE_GUID:
 508             entry->data.guid = *(GUID*)lpvData;
 509             TRACE("(%p, %u): GUID Type -> %s\n", lpvData, dwDataSize, debugstr_guid(lpvData));
 510             break;
 511         case DPNA_DATATYPE_STRING:
 512             entry->data.string = heap_strdupW((WCHAR*)lpvData);
 513             TRACE("(%p, %u): STRING Type -> %s\n", lpvData, dwDataSize, debugstr_w((WCHAR*)lpvData));
 514             break;
 515         case DPNA_DATATYPE_STRING_ANSI:
 516             entry->data.ansi = heap_strdupA((CHAR*)lpvData);
 517             TRACE("(%p, %u): ANSI STRING Type -> %s\n", lpvData, dwDataSize, (const CHAR*) lpvData);
 518             break;
 519         case DPNA_DATATYPE_BINARY:
 520             entry->data.binary = heap_alloc(dwDataSize);
 521             memcpy(entry->data.binary, lpvData, dwDataSize);
 522             TRACE("(%p, %u): BINARY Type\n", lpvData, dwDataSize);
 523             break;
 524     }
 525
 526     entry->type = dwDataType;
 527     entry->size = dwDataSize;
 528
 529     return DPN_OK;
 530 }
 531
 532 static HRESULT WINAPI IDirectPlay8AddressImpl_GetDevice(IDirectPlay8Address *iface, GUID *pDevGuid) {
 533   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 534   TRACE("(%p): stub\n", This);
 535   return DPN_OK;
 536 }
 537
 538 static HRESULT WINAPI IDirectPlay8AddressImpl_SetDevice(IDirectPlay8Address *iface,
 539         const GUID *const devGuid)
 540 {
 541   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 542   TRACE("(%p, %s): stub\n", This, debugstr_guid(devGuid));
 543   return DPN_OK;
 544 }
 545
 546 static HRESULT WINAPI IDirectPlay8AddressImpl_BuildFromDirectPlay4Address(IDirectPlay8Address *iface,
 547         void *pvAddress, DWORD dwDataSize)
 548 {
 549   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 550   TRACE("(%p): stub\n", This);
 551   return DPN_OK;
 552 }
 553
 554 static const IDirectPlay8AddressVtbl DirectPlay8Address_Vtbl =
 555 {
 556     IDirectPlay8AddressImpl_QueryInterface,
 557     IDirectPlay8AddressImpl_AddRef,
 558     IDirectPlay8AddressImpl_Release,
 559     IDirectPlay8AddressImpl_BuildFromURLW,
 560     IDirectPlay8AddressImpl_BuildFromURLA,
 561     IDirectPlay8AddressImpl_Duplicate,
 562     IDirectPlay8AddressImpl_SetEqual,
 563     IDirectPlay8AddressImpl_IsEqual,
 564     IDirectPlay8AddressImpl_Clear,
 565     IDirectPlay8AddressImpl_GetURLW,
 566     IDirectPlay8AddressImpl_GetURLA,
 567     IDirectPlay8AddressImpl_GetSP,
 568     IDirectPlay8AddressImpl_GetUserData,
 569     IDirectPlay8AddressImpl_SetSP,
 570     IDirectPlay8AddressImpl_SetUserData,
 571     IDirectPlay8AddressImpl_GetNumComponents,
 572     IDirectPlay8AddressImpl_GetComponentByName,
 573     IDirectPlay8AddressImpl_GetComponentByIndex,
 574     IDirectPlay8AddressImpl_AddComponent,
 575     IDirectPlay8AddressImpl_GetDevice,
 576     IDirectPlay8AddressImpl_SetDevice,
 577     IDirectPlay8AddressImpl_BuildFromDirectPlay4Address
 578 };
 579
 580 HRESULT DPNET_CreateDirectPlay8Address(IClassFactory *iface, IUnknown *pUnkOuter, REFIID riid, LPVOID *ppobj)
 581 {
 582     IDirectPlay8AddressImpl* client;
 583     HRESULT ret;
 584
 585     TRACE("(%p, %s, %p)\n", pUnkOuter, debugstr_guid(riid), ppobj);
 586
 587     *ppobj = NULL;
 588
 589     client = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectPlay8AddressImpl));
 590     if (!client)
 591         return E_OUTOFMEMORY;
 592
 593     client->IDirectPlay8Address_iface.lpVtbl = &DirectPlay8Address_Vtbl;
 594     client->ref = 1;
 595     client->comp_array_size = 4;
 596     client->components = heap_alloc( sizeof(*client->components) * client->comp_array_size );
 597     if(!client->components)
 598     {
 599         heap_free(client);
 600         return E_OUTOFMEMORY;
 601     }
 602
 603     ret = IDirectPlay8AddressImpl_QueryInterface(&client->IDirectPlay8Address_iface, riid, ppobj);
 604     IDirectPlay8AddressImpl_Release(&client->IDirectPlay8Address_iface);
 605
 606     return ret;
 607 }