dlls/propsys/propvar.c

   1 /*
   2  * PropVariant implementation
   3  *
   4  * Copyright 2008 James Hawkins for CodeWeavers
   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 <stdarg.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winerror.h"
  29 #include "winreg.h"
  30 #include "winuser.h"
  31 #include "shlobj.h"
  32 #include "propvarutil.h"
  33 #include "strsafe.h"
  34
  35 #include "wine/debug.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(propsys);
  38
  39 static HRESULT PROPVAR_ConvertFILETIME(const FILETIME *ft, PROPVARIANT *ppropvarDest, VARTYPE vt)
  40 {
  41     SYSTEMTIME time;
  42
  43     FileTimeToSystemTime(ft, &time);
  44
  45     switch (vt)
  46     {
  47         case VT_LPSTR:
  48             ppropvarDest->pszVal = HeapAlloc(GetProcessHeap(), 0, 64);
  49             if (!ppropvarDest->pszVal)
  50                 return E_OUTOFMEMORY;
  51
  52             sprintf( ppropvarDest->pszVal, "%04d/%02d/%02d:%02d:%02d:%02d.%03d",
  53                       time.wYear, time.wMonth, time.wDay,
  54                       time.wHour, time.wMinute, time.wSecond,
  55                       time.wMilliseconds );
  56
  57             return S_OK;
  58
  59         default:
  60             FIXME("Unhandled target type: %d\n", vt);
  61     }
  62
  63     return E_FAIL;
  64 }
  65
  66 static HRESULT PROPVAR_ConvertNumber(REFPROPVARIANT pv, int dest_bits,
  67                                      BOOL dest_signed, LONGLONG *res)
  68 {
  69     BOOL src_signed;
  70
  71     switch (pv->vt)
  72     {
  73     case VT_I1:
  74         src_signed = TRUE;
  75         *res = pv->cVal;
  76         break;
  77     case VT_UI1:
  78         src_signed = FALSE;
  79         *res = pv->bVal;
  80         break;
  81     case VT_I2:
  82         src_signed = TRUE;
  83         *res = pv->iVal;
  84         break;
  85     case VT_UI2:
  86         src_signed = FALSE;
  87         *res = pv->uiVal;
  88         break;
  89     case VT_I4:
  90         src_signed = TRUE;
  91         *res = pv->lVal;
  92         break;
  93     case VT_UI4:
  94         src_signed = FALSE;
  95         *res = pv->ulVal;
  96         break;
  97     case VT_I8:
  98         src_signed = TRUE;
  99         *res = pv->hVal.QuadPart;
 100         break;
 101     case VT_UI8:
 102         src_signed = FALSE;
 103         *res = pv->uhVal.QuadPart;
 104         break;
 105     case VT_EMPTY:
 106         src_signed = FALSE;
 107         *res = 0;
 108         break;
 109     case VT_LPSTR:
 110     {
 111         char *end;
 112         *res = strtoll(pv->pszVal, &end, 0);
 113         if (pv->pszVal == end)
 114             return DISP_E_TYPEMISMATCH;
 115         src_signed = *res < 0;
 116         break;
 117     }
 118     case VT_LPWSTR:
 119     case VT_BSTR:
 120     {
 121         WCHAR *end;
 122         *res = wcstol(pv->pwszVal, &end, 0);
 123         if (pv->pwszVal == end)
 124             return DISP_E_TYPEMISMATCH;
 125         src_signed = *res < 0;
 126         break;
 127     }
 128     case VT_R8:
 129     {
 130         src_signed = TRUE;
 131         *res = pv->dblVal;
 132         break;
 133     }
 134     default:
 135         FIXME("unhandled vt %d\n", pv->vt);
 136         return E_NOTIMPL;
 137     }
 138
 139     if (*res < 0 && src_signed != dest_signed)
 140         return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
 141
 142     if (dest_bits < 64)
 143     {
 144         if (dest_signed)
 145         {
 146             if (*res >= ((LONGLONG)1 << (dest_bits-1)) ||
 147                 *res < ((LONGLONG)-1 << (dest_bits-1)))
 148                 return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
 149         }
 150         else
 151         {
 152             if ((ULONGLONG)(*res) >= ((ULONGLONG)1 << dest_bits))
 153                 return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
 154         }
 155     }
 156
 157     return S_OK;
 158 }
 159
 160 HRESULT WINAPI PropVariantToDouble(REFPROPVARIANT propvarIn, double *ret)
 161 {
 162     LONGLONG res;
 163     HRESULT hr;
 164
 165     TRACE("(%p, %p)\n", propvarIn, ret);
 166
 167     hr = PROPVAR_ConvertNumber(propvarIn, 64, TRUE, &res);
 168     if (SUCCEEDED(hr)) *ret = (double)res;
 169     return hr;
 170 }
 171
 172 HRESULT WINAPI PropVariantToInt16(REFPROPVARIANT propvarIn, SHORT *ret)
 173 {
 174     LONGLONG res;
 175     HRESULT hr;
 176
 177     TRACE("%p,%p\n", propvarIn, ret);
 178
 179     hr = PROPVAR_ConvertNumber(propvarIn, 16, TRUE, &res);
 180     if (SUCCEEDED(hr)) *ret = (SHORT)res;
 181     return hr;
 182 }
 183
 184 HRESULT WINAPI PropVariantToInt32(REFPROPVARIANT propvarIn, LONG *ret)
 185 {
 186     LONGLONG res;
 187     HRESULT hr;
 188
 189     TRACE("%p,%p\n", propvarIn, ret);
 190
 191     hr = PROPVAR_ConvertNumber(propvarIn, 32, TRUE, &res);
 192     if (SUCCEEDED(hr)) *ret = (LONG)res;
 193     return hr;
 194 }
 195
 196 HRESULT WINAPI PropVariantToInt64(REFPROPVARIANT propvarIn, LONGLONG *ret)
 197 {
 198     LONGLONG res;
 199     HRESULT hr;
 200
 201     TRACE("%p,%p\n", propvarIn, ret);
 202
 203     hr = PROPVAR_ConvertNumber(propvarIn, 64, TRUE, &res);
 204     if (SUCCEEDED(hr)) *ret = res;
 205     return hr;
 206 }
 207
 208 HRESULT WINAPI PropVariantToUInt16(REFPROPVARIANT propvarIn, USHORT *ret)
 209 {
 210     LONGLONG res;
 211     HRESULT hr;
 212
 213     TRACE("%p,%p\n", propvarIn, ret);
 214
 215     hr = PROPVAR_ConvertNumber(propvarIn, 16, FALSE, &res);
 216     if (SUCCEEDED(hr)) *ret = (USHORT)res;
 217     return hr;
 218 }
 219
 220 HRESULT WINAPI PropVariantToUInt32(REFPROPVARIANT propvarIn, ULONG *ret)
 221 {
 222     LONGLONG res;
 223     HRESULT hr;
 224
 225     TRACE("%p,%p\n", propvarIn, ret);
 226
 227     hr = PROPVAR_ConvertNumber(propvarIn, 32, FALSE, &res);
 228     if (SUCCEEDED(hr)) *ret = (ULONG)res;
 229     return hr;
 230 }
 231
 232 ULONG WINAPI PropVariantToUInt32WithDefault(REFPROPVARIANT propvarIn, ULONG ulDefault)
 233 {
 234     LONGLONG res;
 235     HRESULT hr;
 236
 237     TRACE("%p,%lu\n", propvarIn, ulDefault);
 238
 239     hr = PROPVAR_ConvertNumber(propvarIn, 32, FALSE, &res);
 240     if (SUCCEEDED(hr))
 241         return (ULONG)res;
 242
 243     return ulDefault;
 244 }
 245
 246 HRESULT WINAPI PropVariantToUInt64(REFPROPVARIANT propvarIn, ULONGLONG *ret)
 247 {
 248     LONGLONG res;
 249     HRESULT hr;
 250
 251     TRACE("%p,%p\n", propvarIn, ret);
 252
 253     hr = PROPVAR_ConvertNumber(propvarIn, 64, FALSE, &res);
 254     if (SUCCEEDED(hr)) *ret = (ULONGLONG)res;
 255     return hr;
 256 }
 257
 258 HRESULT WINAPI PropVariantToBoolean(REFPROPVARIANT propvarIn, BOOL *ret)
 259 {
 260     LONGLONG res;
 261     HRESULT hr;
 262
 263     TRACE("%p,%p\n", propvarIn, ret);
 264
 265     *ret = FALSE;
 266
 267     switch (propvarIn->vt)
 268     {
 269         case VT_BOOL:
 270             *ret = propvarIn->boolVal == VARIANT_TRUE;
 271             return S_OK;
 272
 273         case VT_LPWSTR:
 274         case VT_BSTR:
 275             if (!propvarIn->pwszVal)
 276                 return DISP_E_TYPEMISMATCH;
 277
 278             if (!lstrcmpiW(propvarIn->pwszVal, L"true") || !lstrcmpW(propvarIn->pwszVal, L"#TRUE#"))
 279             {
 280                 *ret = TRUE;
 281                 return S_OK;
 282             }
 283
 284             if (!lstrcmpiW(propvarIn->pwszVal, L"false") || !lstrcmpW(propvarIn->pwszVal, L"#FALSE#"))
 285             {
 286                 *ret = FALSE;
 287                 return S_OK;
 288             }
 289             break;
 290
 291          case VT_LPSTR:
 292             if (!propvarIn->pszVal)
 293                 return DISP_E_TYPEMISMATCH;
 294
 295             if (!lstrcmpiA(propvarIn->pszVal, "true") || !lstrcmpA(propvarIn->pszVal, "#TRUE#"))
 296             {
 297                 *ret = TRUE;
 298                 return S_OK;
 299             }
 300
 301             if (!lstrcmpiA(propvarIn->pszVal, "false") || !lstrcmpA(propvarIn->pszVal, "#FALSE#"))
 302             {
 303                 *ret = FALSE;
 304                 return S_OK;
 305             }
 306             break;
 307     }
 308
 309     hr = PROPVAR_ConvertNumber(propvarIn, 64, TRUE, &res);
 310     *ret = !!res;
 311     return hr;
 312 }
 313
 314 HRESULT WINAPI PropVariantToBuffer(REFPROPVARIANT propvarIn, void *ret, UINT cb)
 315 {
 316     HRESULT hr = S_OK;
 317
 318     TRACE("(%p, %p, %d)\n", propvarIn, ret, cb);
 319
 320     switch(propvarIn->vt)
 321     {
 322         case VT_VECTOR|VT_UI1:
 323             if(cb > propvarIn->caub.cElems)
 324                 return E_FAIL;
 325             memcpy(ret, propvarIn->caub.pElems, cb);
 326             break;
 327         case VT_ARRAY|VT_UI1:
 328             FIXME("Unsupported type: VT_ARRAY|VT_UI1\n");
 329             hr = E_NOTIMPL;
 330             break;
 331         default:
 332             WARN("Unexpected type: %x\n", propvarIn->vt);
 333             hr = E_INVALIDARG;
 334     }
 335
 336     return hr;
 337 }
 338
 339
 340 HRESULT WINAPI PropVariantToString(REFPROPVARIANT propvarIn, PWSTR ret, UINT cch)
 341 {
 342     HRESULT hr;
 343     WCHAR *stringW = NULL;
 344
 345     TRACE("(%p, %p, %d)\n", propvarIn, ret, cch);
 346
 347     ret[0] = '\0';
 348
 349     if(!cch)
 350         return E_INVALIDARG;
 351
 352     hr = PropVariantToStringAlloc(propvarIn, &stringW);
 353     if(SUCCEEDED(hr))
 354     {
 355         if(lstrlenW(stringW) >= cch)
 356             hr = STRSAFE_E_INSUFFICIENT_BUFFER;
 357         lstrcpynW(ret, stringW, cch);
 358         CoTaskMemFree(stringW);
 359     }
 360
 361     return hr;
 362 }
 363
 364 HRESULT WINAPI PropVariantToStringAlloc(REFPROPVARIANT propvarIn, WCHAR **ret)
 365 {
 366     WCHAR *res = NULL;
 367     HRESULT hr = S_OK;
 368
 369     TRACE("%p,%p semi-stub\n", propvarIn, ret);
 370
 371     switch(propvarIn->vt)
 372     {
 373         case VT_EMPTY:
 374         case VT_NULL:
 375             res = CoTaskMemAlloc(1*sizeof(WCHAR));
 376             res[0] = '\0';
 377             break;
 378
 379         case VT_LPSTR:
 380             if(propvarIn->pszVal)
 381             {
 382                 DWORD len;
 383
 384                 len = MultiByteToWideChar(CP_ACP, 0, propvarIn->pszVal, -1, NULL, 0);
 385                 res = CoTaskMemAlloc(len*sizeof(WCHAR));
 386                 if(!res)
 387                     return E_OUTOFMEMORY;
 388
 389                 MultiByteToWideChar(CP_ACP, 0, propvarIn->pszVal, -1, res, len);
 390             }
 391             break;
 392
 393         case VT_LPWSTR:
 394         case VT_BSTR:
 395             if (propvarIn->pwszVal)
 396             {
 397                 DWORD size = (lstrlenW(propvarIn->pwszVal) + 1) * sizeof(WCHAR);
 398                 res = CoTaskMemAlloc(size);
 399                 if(!res) return E_OUTOFMEMORY;
 400                 memcpy(res, propvarIn->pwszVal, size);
 401             }
 402             break;
 403
 404         default:
 405             FIXME("Unsupported conversion (%d)\n", propvarIn->vt);
 406             hr = E_FAIL;
 407             break;
 408     }
 409
 410     *ret = res;
 411
 412     return hr;
 413 }
 414
 415 PCWSTR WINAPI PropVariantToStringWithDefault(REFPROPVARIANT propvarIn, LPCWSTR pszDefault)
 416 {
 417     if (propvarIn->vt == VT_BSTR)
 418     {
 419         if (propvarIn->bstrVal == NULL)
 420             return L"";
 421
 422         return propvarIn->bstrVal;
 423     }
 424
 425     if (propvarIn->vt == VT_LPWSTR && propvarIn->pwszVal != NULL)
 426         return propvarIn->pwszVal;
 427
 428     return pszDefault;
 429 }
 430
 431 /******************************************************************
 432  *  VariantToStringWithDefault   (PROPSYS.@)
 433  */
 434 PCWSTR WINAPI VariantToStringWithDefault(const VARIANT *pvar, const WCHAR *default_value)
 435 {
 436     TRACE("%s, %s.\n", debugstr_variant(pvar), debugstr_w(default_value));
 437
 438     if (V_VT(pvar) == (VT_BYREF | VT_VARIANT)) pvar = V_VARIANTREF(pvar);
 439     if (V_VT(pvar) == (VT_BYREF | VT_BSTR) || V_VT(pvar) == VT_BSTR)
 440     {
 441         BSTR ret = V_ISBYREF(pvar) ? *V_BSTRREF(pvar) : V_BSTR(pvar);
 442         return ret ? ret : L"";
 443     }
 444
 445     return default_value;
 446 }
 447
 448 /******************************************************************
 449  *  VariantToString   (PROPSYS.@)
 450  */
 451 HRESULT WINAPI VariantToString(REFVARIANT var, PWSTR ret, UINT cch)
 452 {
 453     WCHAR buffer[64], *str = buffer;
 454
 455     TRACE("%p, %p, %u.\n", var, ret, cch);
 456
 457     *ret = 0;
 458
 459     if (!cch)
 460         return E_INVALIDARG;
 461
 462     switch (V_VT(var))
 463     {
 464         case VT_BSTR:
 465             str = V_BSTR(var);
 466             break;
 467         case VT_I4:
 468             swprintf(buffer, ARRAY_SIZE(buffer), L"%d", V_I4(var));
 469             break;
 470         default:
 471             FIXME("Unsupported type %d.\n", V_VT(var));
 472             return E_NOTIMPL;
 473     }
 474
 475     if (wcslen(str) > cch - 1)
 476         return STRSAFE_E_INSUFFICIENT_BUFFER;
 477     wcscpy(ret, str);
 478
 479     return S_OK;
 480 }
 481
 482 /******************************************************************
 483  *  PropVariantChangeType   (PROPSYS.@)
 484  */
 485 HRESULT WINAPI PropVariantChangeType(PROPVARIANT *ppropvarDest, REFPROPVARIANT propvarSrc,
 486                                      PROPVAR_CHANGE_FLAGS flags, VARTYPE vt)
 487 {
 488     HRESULT hr;
 489
 490     FIXME("(%p, %p, %d, %d, %d): semi-stub!\n", ppropvarDest, propvarSrc,
 491           propvarSrc->vt, flags, vt);
 492
 493     if (vt == propvarSrc->vt)
 494         return PropVariantCopy(ppropvarDest, propvarSrc);
 495
 496     if (propvarSrc->vt == VT_FILETIME)
 497         return PROPVAR_ConvertFILETIME(&propvarSrc->filetime, ppropvarDest, vt);
 498
 499     switch (vt)
 500     {
 501     case VT_I1:
 502     {
 503         LONGLONG res;
 504
 505         hr = PROPVAR_ConvertNumber(propvarSrc, 8, TRUE, &res);
 506         if (SUCCEEDED(hr))
 507         {
 508             ppropvarDest->vt = VT_I1;
 509             ppropvarDest->cVal = (char)res;
 510         }
 511         return hr;
 512     }
 513
 514     case VT_UI1:
 515     {
 516         LONGLONG res;
 517
 518         hr = PROPVAR_ConvertNumber(propvarSrc, 8, FALSE, &res);
 519         if (SUCCEEDED(hr))
 520         {
 521             ppropvarDest->vt = VT_UI1;
 522             ppropvarDest->bVal = (UCHAR)res;
 523         }
 524         return hr;
 525     }
 526
 527     case VT_I2:
 528     {
 529         SHORT res;
 530         hr = PropVariantToInt16(propvarSrc, &res);
 531         if (SUCCEEDED(hr))
 532         {
 533             ppropvarDest->vt = VT_I2;
 534             ppropvarDest->iVal = res;
 535         }
 536         return hr;
 537     }
 538     case VT_UI2:
 539     {
 540         USHORT res;
 541         hr = PropVariantToUInt16(propvarSrc, &res);
 542         if (SUCCEEDED(hr))
 543         {
 544             ppropvarDest->vt = VT_UI2;
 545             ppropvarDest->uiVal = res;
 546         }
 547         return hr;
 548     }
 549     case VT_I4:
 550     {
 551         LONG res;
 552         hr = PropVariantToInt32(propvarSrc, &res);
 553         if (SUCCEEDED(hr))
 554         {
 555             ppropvarDest->vt = VT_I4;
 556             ppropvarDest->lVal = res;
 557         }
 558         return hr;
 559     }
 560     case VT_UI4:
 561     {
 562         ULONG res;
 563         hr = PropVariantToUInt32(propvarSrc, &res);
 564         if (SUCCEEDED(hr))
 565         {
 566             ppropvarDest->vt = VT_UI4;
 567             ppropvarDest->ulVal = res;
 568         }
 569         return hr;
 570     }
 571     case VT_I8:
 572     {
 573         LONGLONG res;
 574         hr = PropVariantToInt64(propvarSrc, &res);
 575         if (SUCCEEDED(hr))
 576         {
 577             ppropvarDest->vt = VT_I8;
 578             ppropvarDest->hVal.QuadPart = res;
 579         }
 580         return hr;
 581     }
 582     case VT_UI8:
 583     {
 584         ULONGLONG res;
 585         hr = PropVariantToUInt64(propvarSrc, &res);
 586         if (SUCCEEDED(hr))
 587         {
 588             ppropvarDest->vt = VT_UI8;
 589             ppropvarDest->uhVal.QuadPart = res;
 590         }
 591         return hr;
 592     }
 593
 594     case VT_LPWSTR:
 595     case VT_BSTR:
 596     {
 597         WCHAR *res;
 598         hr = PropVariantToStringAlloc(propvarSrc, &res);
 599         if (SUCCEEDED(hr))
 600         {
 601             ppropvarDest->vt = VT_LPWSTR;
 602             ppropvarDest->pwszVal = res;
 603         }
 604         return hr;
 605     }
 606
 607     case VT_LPSTR:
 608     {
 609         WCHAR *resW;
 610         hr = PropVariantToStringAlloc(propvarSrc, &resW);
 611         if (SUCCEEDED(hr))
 612         {
 613             char *res;
 614             DWORD len;
 615
 616             len = WideCharToMultiByte(CP_ACP, 0, resW, -1, NULL, 0, NULL, NULL);
 617             res = CoTaskMemAlloc(len);
 618             if (res)
 619             {
 620                 WideCharToMultiByte(CP_ACP, 0, resW, -1, res, len, NULL, NULL);
 621                 ppropvarDest->vt = VT_LPSTR;
 622                 ppropvarDest->pszVal = res;
 623             }
 624             else
 625                 hr = E_OUTOFMEMORY;
 626
 627             CoTaskMemFree(resW);
 628         }
 629         return hr;
 630     }
 631
 632     default:
 633         FIXME("Unhandled dest type: %d\n", vt);
 634         return E_FAIL;
 635     }
 636 }
 637
 638 static void PROPVAR_GUIDToWSTR(REFGUID guid, WCHAR *str)
 639 {
 640     swprintf(str, 39, L"{%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}", guid->Data1,
 641             guid->Data2, guid->Data3, guid->Data4[0], guid->Data4[1], guid->Data4[2],
 642             guid->Data4[3], guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
 643 }
 644
 645 HRESULT WINAPI InitPropVariantFromGUIDAsString(REFGUID guid, PROPVARIANT *ppropvar)
 646 {
 647     TRACE("(%p %p)\n", guid, ppropvar);
 648
 649     if(!guid)
 650         return E_FAIL;
 651
 652     ppropvar->vt = VT_LPWSTR;
 653     ppropvar->pwszVal = CoTaskMemAlloc(39*sizeof(WCHAR));
 654     if(!ppropvar->pwszVal)
 655         return E_OUTOFMEMORY;
 656
 657     PROPVAR_GUIDToWSTR(guid, ppropvar->pwszVal);
 658     return S_OK;
 659 }
 660
 661 HRESULT WINAPI InitVariantFromGUIDAsString(REFGUID guid, VARIANT *pvar)
 662 {
 663     TRACE("(%p %p)\n", guid, pvar);
 664
 665     if(!guid) {
 666         FIXME("guid == NULL\n");
 667         return E_FAIL;
 668     }
 669
 670     V_VT(pvar) = VT_BSTR;
 671     V_BSTR(pvar) = SysAllocStringLen(NULL, 38);
 672     if(!V_BSTR(pvar))
 673         return E_OUTOFMEMORY;
 674
 675     PROPVAR_GUIDToWSTR(guid, V_BSTR(pvar));
 676     return S_OK;
 677 }
 678
 679 HRESULT WINAPI InitPropVariantFromBuffer(const VOID *pv, UINT cb, PROPVARIANT *ppropvar)
 680 {
 681     TRACE("(%p %u %p)\n", pv, cb, ppropvar);
 682
 683     ppropvar->caub.pElems = CoTaskMemAlloc(cb);
 684     if(!ppropvar->caub.pElems)
 685         return E_OUTOFMEMORY;
 686
 687     ppropvar->vt = VT_VECTOR|VT_UI1;
 688     ppropvar->caub.cElems = cb;
 689     memcpy(ppropvar->caub.pElems, pv, cb);
 690     return S_OK;
 691 }
 692
 693 HRESULT WINAPI InitPropVariantFromCLSID(REFCLSID clsid, PROPVARIANT *ppropvar)
 694 {
 695     TRACE("(%s %p)\n", debugstr_guid(clsid), ppropvar);
 696
 697     ppropvar->puuid = CoTaskMemAlloc(sizeof(*ppropvar->puuid));
 698     if(!ppropvar->puuid)
 699         return E_OUTOFMEMORY;
 700
 701     ppropvar->vt = VT_CLSID;
 702     memcpy(ppropvar->puuid, clsid, sizeof(*ppropvar->puuid));
 703     return S_OK;
 704 }
 705
 706 HRESULT WINAPI InitPropVariantFromStringVector(PCWSTR *strs, ULONG count, PROPVARIANT *ppropvar)
 707 {
 708     unsigned int i;
 709
 710     TRACE("(%p %lu %p)\n", strs, count, ppropvar);
 711
 712     ppropvar->calpwstr.pElems = CoTaskMemAlloc(count * sizeof(*ppropvar->calpwstr.pElems));
 713     if(!ppropvar->calpwstr.pElems)
 714         return E_OUTOFMEMORY;
 715
 716     ppropvar->vt = VT_LPWSTR | VT_VECTOR;
 717     ppropvar->calpwstr.cElems = 0;
 718     if (count)
 719         memset(ppropvar->calpwstr.pElems, 0, count * sizeof(*ppropvar->calpwstr.pElems));
 720
 721     for (i = 0; i < count; ++i)
 722     {
 723         if (strs[i])
 724         {
 725             if (!(ppropvar->calpwstr.pElems[i] = CoTaskMemAlloc((wcslen(strs[i]) + 1)*sizeof(**strs))))
 726             {
 727                 PropVariantClear(ppropvar);
 728                 return E_OUTOFMEMORY;
 729             }
 730         }
 731         wcscpy(ppropvar->calpwstr.pElems[i], strs[i]);
 732         ppropvar->calpwstr.cElems++;
 733     }
 734
 735     return S_OK;
 736 }
 737
 738 HRESULT WINAPI InitVariantFromBuffer(const VOID *pv, UINT cb, VARIANT *pvar)
 739 {
 740     SAFEARRAY *arr;
 741     void *data;
 742     HRESULT hres;
 743
 744     TRACE("(%p %u %p)\n", pv, cb, pvar);
 745
 746     arr = SafeArrayCreateVector(VT_UI1, 0, cb);
 747     if(!arr)
 748         return E_OUTOFMEMORY;
 749
 750     hres = SafeArrayAccessData(arr, &data);
 751     if(FAILED(hres)) {
 752         SafeArrayDestroy(arr);
 753         return hres;
 754     }
 755
 756     memcpy(data, pv, cb);
 757
 758     hres = SafeArrayUnaccessData(arr);
 759     if(FAILED(hres)) {
 760         SafeArrayDestroy(arr);
 761         return hres;
 762     }
 763
 764     V_VT(pvar) = VT_ARRAY|VT_UI1;
 765     V_ARRAY(pvar) = arr;
 766     return S_OK;
 767 }
 768
 769 HRESULT WINAPI InitVariantFromFileTime(const FILETIME *ft, VARIANT *var)
 770 {
 771     SYSTEMTIME st;
 772
 773     TRACE("%p, %p\n", ft, var);
 774
 775     VariantInit(var);
 776     if (!FileTimeToSystemTime(ft, &st))
 777         return E_INVALIDARG;
 778     if (!SystemTimeToVariantTime(&st, &V_DATE(var)))
 779         return E_INVALIDARG;
 780     V_VT(var) = VT_DATE;
 781     return S_OK;
 782 }
 783
 784 static inline DWORD PROPVAR_HexToNum(const WCHAR *hex)
 785 {
 786     DWORD ret;
 787
 788     if(hex[0]>='0' && hex[0]<='9')
 789         ret = hex[0]-'0';
 790     else if(hex[0]>='a' && hex[0]<='f')
 791         ret = hex[0]-'a'+10;
 792     else if(hex[0]>='A' && hex[0]<='F')
 793         ret = hex[0]-'A'+10;
 794     else
 795         return -1;
 796
 797     ret <<= 4;
 798     if(hex[1]>='0' && hex[1]<='9')
 799         return ret + hex[1]-'0';
 800     else if(hex[1]>='a' && hex[1]<='f')
 801         return ret + hex[1]-'a'+10;
 802     else if(hex[1]>='A' && hex[1]<='F')
 803         return ret + hex[1]-'A'+10;
 804     else
 805         return -1;
 806 }
 807
 808 static inline HRESULT PROPVAR_WCHARToGUID(const WCHAR *str, int len, GUID *guid)
 809 {
 810     DWORD i, val=0;
 811     const WCHAR *p;
 812
 813     memset(guid, 0, sizeof(GUID));
 814
 815     if(len!=38 || str[0]!='{' || str[9]!='-' || str[14]!='-'
 816             || str[19]!='-' || str[24]!='-' || str[37]!='}') {
 817         WARN("Error parsing %s\n", debugstr_w(str));
 818         return E_INVALIDARG;
 819     }
 820
 821     p = str+1;
 822     for(i=0; i<4 && val!=-1; i++) {
 823         val = PROPVAR_HexToNum(p);
 824         guid->Data1 = (guid->Data1<<8) + val;
 825         p += 2;
 826     }
 827     p++;
 828     for(i=0; i<2 && val!=-1; i++) {
 829         val = PROPVAR_HexToNum(p);
 830         guid->Data2 = (guid->Data2<<8) + val;
 831         p += 2;
 832     }
 833     p++;
 834     for(i=0; i<2 && val!=-1; i++) {
 835         val = PROPVAR_HexToNum(p);
 836         guid->Data3 = (guid->Data3<<8) + val;
 837         p += 2;
 838     }
 839     p++;
 840     for(i=0; i<8 && val!=-1; i++) {
 841         if(i == 2)
 842             p++;
 843
 844         val = guid->Data4[i] = PROPVAR_HexToNum(p);
 845         p += 2;
 846     }
 847
 848     if(val == -1) {
 849         WARN("Error parsing %s\n", debugstr_w(str));
 850         memset(guid, 0, sizeof(GUID));
 851         return E_INVALIDARG;
 852     }
 853     return S_OK;
 854 }
 855
 856 HRESULT WINAPI PropVariantToGUID(const PROPVARIANT *ppropvar, GUID *guid)
 857 {
 858     TRACE("%p %p)\n", ppropvar, guid);
 859
 860     switch(ppropvar->vt) {
 861     case VT_BSTR:
 862         return PROPVAR_WCHARToGUID(ppropvar->bstrVal, SysStringLen(ppropvar->bstrVal), guid);
 863     case VT_LPWSTR:
 864         return PROPVAR_WCHARToGUID(ppropvar->pwszVal, lstrlenW(ppropvar->pwszVal), guid);
 865     case VT_CLSID:
 866         memcpy(guid, ppropvar->puuid, sizeof(*ppropvar->puuid));
 867         return S_OK;
 868
 869     default:
 870         FIXME("unsupported vt: %d\n", ppropvar->vt);
 871         return E_NOTIMPL;
 872     }
 873 }
 874
 875 HRESULT WINAPI VariantToGUID(const VARIANT *pvar, GUID *guid)
 876 {
 877     TRACE("(%p %p)\n", pvar, guid);
 878
 879     switch(V_VT(pvar)) {
 880     case VT_BSTR: {
 881         HRESULT hres = PROPVAR_WCHARToGUID(V_BSTR(pvar), SysStringLen(V_BSTR(pvar)), guid);
 882         if(hres == E_INVALIDARG)
 883             return E_FAIL;
 884         return hres;
 885     }
 886
 887     default:
 888         FIXME("unsupported vt: %d\n", V_VT(pvar));
 889         return E_NOTIMPL;
 890     }
 891 }
 892
 893 static BOOL isemptyornull(const PROPVARIANT *propvar)
 894 {
 895     if (propvar->vt == VT_EMPTY || propvar->vt == VT_NULL)
 896         return TRUE;
 897     if ((propvar->vt & VT_ARRAY) == VT_ARRAY)
 898     {
 899         int i;
 900         for (i=0; i<propvar->parray->cDims; i++)
 901         {
 902             if (propvar->parray->rgsabound[i].cElements != 0)
 903                 break;
 904         }
 905         return i == propvar->parray->cDims;
 906     }
 907     if (propvar->vt == VT_CLSID)
 908         return !propvar->puuid;
 909
 910     if (propvar->vt & VT_VECTOR)
 911         return !propvar->caub.cElems;
 912
 913     /* FIXME: byrefs, errors? */
 914     return FALSE;
 915 }
 916
 917 INT WINAPI PropVariantCompareEx(REFPROPVARIANT propvar1, REFPROPVARIANT propvar2,
 918     PROPVAR_COMPARE_UNIT unit, PROPVAR_COMPARE_FLAGS flags)
 919 {
 920     const PROPVARIANT *propvar2_converted;
 921     PROPVARIANT propvar2_static;
 922     unsigned int count;
 923     HRESULT hr;
 924     INT res=-1;
 925
 926     TRACE("%p,%p,%x,%x\n", propvar1, propvar2, unit, flags);
 927
 928     if (isemptyornull(propvar1))
 929     {
 930         if (isemptyornull(propvar2))
 931             return 0;
 932         return (flags & PVCF_TREATEMPTYASGREATERTHAN) ? 1 : -1;
 933     }
 934
 935     if (isemptyornull(propvar2))
 936         return (flags & PVCF_TREATEMPTYASGREATERTHAN) ? -1 : 1;
 937
 938     if (propvar1->vt != propvar2->vt)
 939     {
 940         hr = PropVariantChangeType(&propvar2_static, propvar2, 0, propvar1->vt);
 941
 942         if (FAILED(hr))
 943             return -1;
 944
 945         propvar2_converted = &propvar2_static;
 946     }
 947     else
 948         propvar2_converted = propvar2;
 949
 950 #define CMP_NUM_VALUE(var) do { \
 951     if (propvar1->var > propvar2_converted->var) \
 952         res = 1; \
 953     else if (propvar1->var < propvar2_converted->var) \
 954         res = -1; \
 955     else \
 956         res = 0; \
 957     } while (0)
 958
 959     switch (propvar1->vt)
 960     {
 961     case VT_I1:
 962         CMP_NUM_VALUE(cVal);
 963         break;
 964     case VT_UI1:
 965         CMP_NUM_VALUE(bVal);
 966         break;
 967     case VT_I2:
 968         CMP_NUM_VALUE(iVal);
 969         break;
 970     case VT_UI2:
 971         CMP_NUM_VALUE(uiVal);
 972         break;
 973     case VT_I4:
 974         CMP_NUM_VALUE(lVal);
 975         break;
 976     case VT_UI4:
 977         CMP_NUM_VALUE(ulVal);
 978         break;
 979     case VT_I8:
 980         CMP_NUM_VALUE(hVal.QuadPart);
 981         break;
 982     case VT_UI8:
 983         CMP_NUM_VALUE(uhVal.QuadPart);
 984         break;
 985     case VT_R4:
 986         CMP_NUM_VALUE(fltVal);
 987         break;
 988     case VT_R8:
 989         CMP_NUM_VALUE(dblVal);
 990         break;
 991     case VT_BSTR:
 992     case VT_LPWSTR:
 993         /* FIXME: Use other string flags. */
 994         if (flags & (PVCF_USESTRCMPI | PVCF_USESTRCMPIC))
 995             res = lstrcmpiW(propvar1->bstrVal, propvar2_converted->bstrVal);
 996         else
 997             res = lstrcmpW(propvar1->bstrVal, propvar2_converted->bstrVal);
 998         break;
 999     case VT_LPSTR:
1000         /* FIXME: Use other string flags. */
1001         if (flags & (PVCF_USESTRCMPI | PVCF_USESTRCMPIC))
1002             res = lstrcmpiA(propvar1->pszVal, propvar2_converted->pszVal);
1003         else
1004             res = lstrcmpA(propvar1->pszVal, propvar2_converted->pszVal);
1005         break;
1006     case VT_CLSID:
1007         res = memcmp(propvar1->puuid, propvar2->puuid, sizeof(*propvar1->puuid));
1008         if (res) res = res > 0 ? 1 : -1;
1009         break;
1010     case VT_VECTOR | VT_UI1:
1011         count = min(propvar1->caub.cElems, propvar2->caub.cElems);
1012         res = count ? memcmp(propvar1->caub.pElems, propvar2->caub.pElems, sizeof(*propvar1->caub.pElems) * count) : 0;
1013         if (res) res = res > 0 ? 1 : -1;
1014         if (!res && propvar1->caub.cElems != propvar2->caub.cElems)
1015             res = propvar1->caub.cElems > propvar2->caub.cElems ? 1 : -1;
1016         break;
1017     default:
1018         FIXME("vartype %#x not handled\n", propvar1->vt);
1019         res = -1;
1020         break;
1021     }
1022
1023     if (propvar2_converted == &propvar2_static)
1024         PropVariantClear(&propvar2_static);
1025
1026     return res;
1027 }