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             switch (entry->type)
 236             {
 237                 case DPNA_DATATYPE_DWORD:
 238                     hr = IDirectPlay8Address_AddComponent(dup, entry->name, &entry->data.value, entry->size, entry->type);
 239                     break;
 240                 case DPNA_DATATYPE_GUID:
 241                     hr = IDirectPlay8Address_AddComponent(dup, entry->name, &entry->data.guid, entry->size, entry->type);
 242                     break;
 243                 case DPNA_DATATYPE_STRING:
 244                     hr = IDirectPlay8Address_AddComponent(dup, entry->name, entry->data.string, entry->size, entry->type);
 245                     break;
 246                 case DPNA_DATATYPE_STRING_ANSI:
 247                     hr = IDirectPlay8Address_AddComponent(dup, entry->name, entry->data.ansi, entry->size, entry->type);
 248                     break;
 249                 case DPNA_DATATYPE_BINARY:
 250                     hr = IDirectPlay8Address_AddComponent(dup, entry->name, entry->data.binary, entry->size, entry->type);
 251                     break;
 252             }
 253
 254             if(hr != S_OK)
 255             {
 256                 IDirectPlay8Address_Release(dup);
 257                 dup = NULL;
 258                 ERR("Failed to copy component: %s - 0x%08x\n", debugstr_w(entry->name), hr);
 259                 break;
 260             }
 261         }
 262
 263         *ppdpaNewAddress = dup;
 264     }
 265
 266     return hr;
 267 }
 268
 269 static HRESULT WINAPI IDirectPlay8AddressImpl_SetEqual(IDirectPlay8Address *iface,
 270         IDirectPlay8Address *pdpaAddress)
 271 {
 272   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 273   TRACE("(%p, %p): stub\n", This, pdpaAddress);
 274   return DPN_OK;
 275 }
 276
 277 static HRESULT WINAPI IDirectPlay8AddressImpl_IsEqual(IDirectPlay8Address *iface,
 278         IDirectPlay8Address *pdpaAddress)
 279 {
 280   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 281   TRACE("(%p, %p): stub\n", This, pdpaAddress);
 282   return DPN_OK;
 283 }
 284
 285 static HRESULT WINAPI IDirectPlay8AddressImpl_Clear(IDirectPlay8Address *iface)
 286 {
 287   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 288   TRACE("(%p): stub\n", This);
 289   return DPN_OK;
 290 }
 291
 292 static HRESULT WINAPI IDirectPlay8AddressImpl_GetURLW(IDirectPlay8Address *iface, WCHAR *pwszURL,
 293         DWORD *pdwNumChars)
 294 {
 295   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 296   TRACE("(%p): stub\n", This);
 297   return DPN_OK;
 298 }
 299
 300 static HRESULT WINAPI IDirectPlay8AddressImpl_GetURLA(IDirectPlay8Address *iface, CHAR *pszURL,
 301         DWORD *pdwNumChars)
 302 {
 303   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 304   TRACE("(%p): stub\n", This);
 305   return DPN_OK;
 306 }
 307
 308 static HRESULT WINAPI IDirectPlay8AddressImpl_GetSP(IDirectPlay8Address *iface, GUID *pguidSP)
 309 {
 310     IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 311
 312     TRACE("(%p, %p)\n", iface, pguidSP);
 313
 314     if(!pguidSP)
 315         return DPNERR_INVALIDPOINTER;
 316
 317     if(!This->init)
 318         return DPNERR_DOESNOTEXIST;
 319
 320     *pguidSP = This->SP_guid;
 321     return DPN_OK;
 322 }
 323
 324 static HRESULT WINAPI IDirectPlay8AddressImpl_GetUserData(IDirectPlay8Address *iface,
 325         void *pvUserData, DWORD *pdwBufferSize)
 326 {
 327   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 328   TRACE("(%p): stub\n", This);
 329   return DPN_OK;
 330 }
 331
 332 static HRESULT WINAPI IDirectPlay8AddressImpl_SetSP(IDirectPlay8Address *iface,
 333         const GUID *const pguidSP)
 334 {
 335     IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 336
 337     TRACE("(%p, %s)\n", iface, debugstr_SP(pguidSP));
 338
 339     if(!pguidSP)
 340         return DPNERR_INVALIDPOINTER;
 341
 342     This->init = TRUE;
 343     This->SP_guid = *pguidSP;
 344
 345     IDirectPlay8Address_AddComponent(iface, DPNA_KEY_PROVIDER, &This->SP_guid, sizeof(GUID), DPNA_DATATYPE_GUID);
 346
 347     return DPN_OK;
 348 }
 349
 350 static HRESULT WINAPI IDirectPlay8AddressImpl_SetUserData(IDirectPlay8Address *iface,
 351         const void *const pvUserData, const DWORD dwDataSize)
 352 {
 353   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 354   TRACE("(%p): stub\n", This);
 355   return DPN_OK;
 356 }
 357
 358 static HRESULT WINAPI IDirectPlay8AddressImpl_GetNumComponents(IDirectPlay8Address *iface,
 359         DWORD *pdwNumComponents)
 360 {
 361     IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 362     TRACE("(%p): stub\n", This);
 363
 364     if(!pdwNumComponents)
 365         return DPNERR_INVALIDPOINTER;
 366
 367     *pdwNumComponents = This->comp_count;
 368
 369     return DPN_OK;
 370 }
 371
 372 static HRESULT WINAPI IDirectPlay8AddressImpl_GetComponentByName(IDirectPlay8Address *iface,
 373         const WCHAR *const pwszName, void *pvBuffer, DWORD *pdwBufferSize, DWORD *pdwDataType)
 374 {
 375     IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 376     struct component *entry;
 377     DWORD i;
 378
 379     TRACE("(%p)->(%p %p %p %p)\n", This, pwszName, pvBuffer, pdwBufferSize, pdwDataType);
 380
 381     if(!pwszName || !pdwBufferSize || !pdwDataType || (!pvBuffer && pdwBufferSize))
 382         return E_POINTER;
 383
 384     for(i=0; i < This->comp_count; i++)
 385     {
 386         entry = This->components[i];
 387
 388         if (lstrcmpW(pwszName, entry->name) == 0)
 389         {
 390             TRACE("Found %s\n", debugstr_w(pwszName));
 391
 392             if(*pdwBufferSize < entry->size)
 393             {
 394                 *pdwBufferSize = entry->size;
 395                 return DPNERR_BUFFERTOOSMALL;
 396             }
 397
 398             *pdwBufferSize = entry->size;
 399             *pdwDataType   = entry->type;
 400
 401             switch (entry->type)
 402             {
 403                 case DPNA_DATATYPE_DWORD:
 404                     memcpy(pvBuffer, &entry->data.value, sizeof(DWORD));
 405                     break;
 406                 case DPNA_DATATYPE_GUID:
 407                     memcpy(pvBuffer, &entry->data.guid, sizeof(GUID));
 408                     break;
 409                 case DPNA_DATATYPE_STRING:
 410                     memcpy(pvBuffer, entry->data.string, entry->size);
 411                     break;
 412                 case DPNA_DATATYPE_STRING_ANSI:
 413                     memcpy(pvBuffer, entry->data.ansi, entry->size);
 414                     break;
 415                 case DPNA_DATATYPE_BINARY:
 416                     memcpy(pvBuffer, entry->data.binary, entry->size);
 417                     break;
 418             }
 419
 420             return S_OK;
 421         }
 422     }
 423
 424     return DPNERR_DOESNOTEXIST;
 425 }
 426
 427 static HRESULT WINAPI IDirectPlay8AddressImpl_GetComponentByIndex(IDirectPlay8Address *iface,
 428         const DWORD dwComponentID, WCHAR *pwszName, DWORD *pdwNameLen, void *pvBuffer,
 429         DWORD *pdwBufferSize, DWORD *pdwDataType)
 430 {
 431     IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 432     struct component *entry;
 433     int namesize;
 434
 435     TRACE("(%p)->(%u %p %p %p %p %p)\n", This, dwComponentID, pwszName, pdwNameLen, pvBuffer, pdwBufferSize, pdwDataType);
 436
 437     if(!pdwNameLen || !pdwBufferSize || !pdwDataType)
 438     {
 439         WARN("Invalid buffer (%p, %p, %p)\n", pdwNameLen, pdwBufferSize, pdwDataType);
 440         return DPNERR_INVALIDPOINTER;
 441     }
 442
 443     if(dwComponentID > This->comp_count)
 444     {
 445         WARN("dwComponentID out of range\n");
 446         return DPNERR_DOESNOTEXIST;
 447     }
 448
 449     entry = This->components[dwComponentID];
 450
 451     namesize = strlenW(entry->name);
 452     if(*pdwBufferSize < entry->size || *pdwNameLen < namesize)
 453     {
 454         WARN("Buffer too small\n");
 455
 456         *pdwNameLen = namesize + 1;
 457         *pdwBufferSize = entry->size;
 458         *pdwDataType   = entry->type;
 459         return DPNERR_BUFFERTOOSMALL;
 460     }
 461
 462     if(!pwszName || !pvBuffer)
 463     {
 464         WARN("Invalid buffer (%p, %p)\n", pwszName, pvBuffer);
 465         return DPNERR_INVALIDPOINTER;
 466     }
 467
 468     lstrcpyW(pwszName, entry->name);
 469
 470     *pdwNameLen = namesize + 1;
 471     *pdwBufferSize = entry->size;
 472     *pdwDataType   = entry->type;
 473
 474     switch (entry->type)
 475     {
 476         case DPNA_DATATYPE_DWORD:
 477             *(DWORD*)pvBuffer = entry->data.value;
 478             break;
 479         case DPNA_DATATYPE_GUID:
 480              *(GUID*)pvBuffer = entry->data.guid;
 481             break;
 482         case DPNA_DATATYPE_STRING:
 483             memcpy(pvBuffer, entry->data.string, entry->size);
 484             break;
 485         case DPNA_DATATYPE_STRING_ANSI:
 486             memcpy(pvBuffer, entry->data.ansi, entry->size);
 487             break;
 488         case DPNA_DATATYPE_BINARY:
 489             memcpy(pvBuffer, entry->data.binary, entry->size);
 490             break;
 491     }
 492
 493     return S_OK;
 494 }
 495
 496 static HRESULT WINAPI IDirectPlay8AddressImpl_AddComponent(IDirectPlay8Address *iface,
 497         const WCHAR *const pwszName, const void* const lpvData, const DWORD dwDataSize,
 498         const DWORD dwDataType)
 499 {
 500     IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 501     struct component *entry;
 502     BOOL found = FALSE;
 503     DWORD i;
 504
 505     TRACE("(%p, %s, %p, %u, %x)\n", This, debugstr_w(pwszName), lpvData, dwDataSize, dwDataType);
 506
 507     if (NULL == lpvData)
 508         return DPNERR_INVALIDPOINTER;
 509
 510     switch (dwDataType)
 511     {
 512         case DPNA_DATATYPE_DWORD:
 513             if (sizeof(DWORD) != dwDataSize)
 514             {
 515                 WARN("Invalid DWORD size, returning DPNERR_INVALIDPARAM\n");
 516                 return DPNERR_INVALIDPARAM;
 517             }
 518             break;
 519         case DPNA_DATATYPE_GUID:
 520             if (sizeof(GUID) != dwDataSize)
 521             {
 522                 WARN("Invalid GUID size, returning DPNERR_INVALIDPARAM\n");
 523                 return DPNERR_INVALIDPARAM;
 524             }
 525             break;
 526         case DPNA_DATATYPE_STRING:
 527             if (((strlenW((WCHAR*)lpvData)+1)*sizeof(WCHAR)) != dwDataSize)
 528             {
 529                 WARN("Invalid STRING size, returning DPNERR_INVALIDPARAM\n");
 530                 return DPNERR_INVALIDPARAM;
 531             }
 532             break;
 533         case DPNA_DATATYPE_STRING_ANSI:
 534             if ((strlen((const CHAR*)lpvData)+1) != dwDataSize)
 535             {
 536                 WARN("Invalid ASCII size, returning DPNERR_INVALIDPARAM\n");
 537                 return DPNERR_INVALIDPARAM;
 538             }
 539             break;
 540     }
 541
 542     for(i=0; i < This->comp_count; i++)
 543     {
 544         entry = This->components[i];
 545
 546         if (lstrcmpW(pwszName, entry->name) == 0)
 547         {
 548             TRACE("Found %s\n", debugstr_w(pwszName));
 549             found = TRUE;
 550
 551             if(entry->type == DPNA_DATATYPE_STRING_ANSI)
 552                 heap_free(entry->data.ansi);
 553             else if(entry->type == DPNA_DATATYPE_STRING)
 554                 heap_free(entry->data.string);
 555             else if(entry->type == DPNA_DATATYPE_BINARY)
 556                 heap_free(entry->data.binary);
 557
 558             break;
 559         }
 560     }
 561
 562     if(!found)
 563     {
 564         /* Create a new one */
 565         entry = heap_alloc(sizeof(struct component));
 566         if(!entry)
 567             return E_OUTOFMEMORY;
 568
 569         entry->name = heap_strdupW(pwszName);
 570         if(!entry->name)
 571         {
 572             heap_free(entry);
 573             return E_OUTOFMEMORY;
 574         }
 575
 576         if(!add_component(This, entry))
 577         {
 578            heap_free(entry->name);
 579            heap_free(entry);
 580            return E_OUTOFMEMORY;
 581         }
 582     }
 583
 584     switch (dwDataType)
 585     {
 586         case DPNA_DATATYPE_DWORD:
 587             entry->data.value = *(DWORD*)lpvData;
 588             TRACE("(%p, %u): DWORD Type -> %u\n", lpvData, dwDataSize, *(const DWORD*) lpvData);
 589             break;
 590         case DPNA_DATATYPE_GUID:
 591             entry->data.guid = *(GUID*)lpvData;
 592             TRACE("(%p, %u): GUID Type -> %s\n", lpvData, dwDataSize, debugstr_guid(lpvData));
 593             break;
 594         case DPNA_DATATYPE_STRING:
 595             entry->data.string = heap_strdupW((WCHAR*)lpvData);
 596             TRACE("(%p, %u): STRING Type -> %s\n", lpvData, dwDataSize, debugstr_w((WCHAR*)lpvData));
 597             break;
 598         case DPNA_DATATYPE_STRING_ANSI:
 599             entry->data.ansi = heap_strdupA((CHAR*)lpvData);
 600             TRACE("(%p, %u): ANSI STRING Type -> %s\n", lpvData, dwDataSize, (const CHAR*) lpvData);
 601             break;
 602         case DPNA_DATATYPE_BINARY:
 603             entry->data.binary = heap_alloc(dwDataSize);
 604             memcpy(entry->data.binary, lpvData, dwDataSize);
 605             TRACE("(%p, %u): BINARY Type\n", lpvData, dwDataSize);
 606             break;
 607     }
 608
 609     entry->type = dwDataType;
 610     entry->size = dwDataSize;
 611
 612     return DPN_OK;
 613 }
 614
 615 static HRESULT WINAPI IDirectPlay8AddressImpl_GetDevice(IDirectPlay8Address *iface, GUID *pDevGuid) {
 616   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 617   TRACE("(%p): stub\n", This);
 618   return DPN_OK;
 619 }
 620
 621 static HRESULT WINAPI IDirectPlay8AddressImpl_SetDevice(IDirectPlay8Address *iface,
 622         const GUID *const devGuid)
 623 {
 624   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 625   TRACE("(%p, %s): stub\n", This, debugstr_guid(devGuid));
 626   return DPN_OK;
 627 }
 628
 629 static HRESULT WINAPI IDirectPlay8AddressImpl_BuildFromDirectPlay4Address(IDirectPlay8Address *iface,
 630         void *pvAddress, DWORD dwDataSize)
 631 {
 632   IDirectPlay8AddressImpl *This = impl_from_IDirectPlay8Address(iface);
 633   TRACE("(%p): stub\n", This);
 634   return DPN_OK;
 635 }
 636
 637 static const IDirectPlay8AddressVtbl DirectPlay8Address_Vtbl =
 638 {
 639     IDirectPlay8AddressImpl_QueryInterface,
 640     IDirectPlay8AddressImpl_AddRef,
 641     IDirectPlay8AddressImpl_Release,
 642     IDirectPlay8AddressImpl_BuildFromURLW,
 643     IDirectPlay8AddressImpl_BuildFromURLA,
 644     IDirectPlay8AddressImpl_Duplicate,
 645     IDirectPlay8AddressImpl_SetEqual,
 646     IDirectPlay8AddressImpl_IsEqual,
 647     IDirectPlay8AddressImpl_Clear,
 648     IDirectPlay8AddressImpl_GetURLW,
 649     IDirectPlay8AddressImpl_GetURLA,
 650     IDirectPlay8AddressImpl_GetSP,
 651     IDirectPlay8AddressImpl_GetUserData,
 652     IDirectPlay8AddressImpl_SetSP,
 653     IDirectPlay8AddressImpl_SetUserData,
 654     IDirectPlay8AddressImpl_GetNumComponents,
 655     IDirectPlay8AddressImpl_GetComponentByName,
 656     IDirectPlay8AddressImpl_GetComponentByIndex,
 657     IDirectPlay8AddressImpl_AddComponent,
 658     IDirectPlay8AddressImpl_GetDevice,
 659     IDirectPlay8AddressImpl_SetDevice,
 660     IDirectPlay8AddressImpl_BuildFromDirectPlay4Address
 661 };
 662
 663 HRESULT DPNET_CreateDirectPlay8Address(IClassFactory *iface, IUnknown *pUnkOuter, REFIID riid, LPVOID *ppobj)
 664 {
 665     IDirectPlay8AddressImpl* client;
 666     HRESULT ret;
 667
 668     TRACE("(%p, %s, %p)\n", pUnkOuter, debugstr_guid(riid), ppobj);
 669
 670     *ppobj = NULL;
 671
 672     client = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectPlay8AddressImpl));
 673     if (!client)
 674         return E_OUTOFMEMORY;
 675
 676     client->IDirectPlay8Address_iface.lpVtbl = &DirectPlay8Address_Vtbl;
 677     client->ref = 1;
 678     client->comp_array_size = 4;
 679     client->components = heap_alloc( sizeof(*client->components) * client->comp_array_size );
 680     if(!client->components)
 681     {
 682         heap_free(client);
 683         return E_OUTOFMEMORY;
 684     }
 685
 686     ret = IDirectPlay8AddressImpl_QueryInterface(&client->IDirectPlay8Address_iface, riid, ppobj);
 687     IDirectPlay8AddressImpl_Release(&client->IDirectPlay8Address_iface);
 688
 689     return ret;
 690 }