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