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