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 #include <stdarg.h>
  22 #include <stdio.h>
  23
  24 #define NONAMELESSUNION
  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
  34 #include "wine/debug.h"
  35 #include "wine/unicode.h"
  36
  37 WINE_DEFAULT_DEBUG_CHANNEL(propsys);
  38
  39 static HRESULT PROPVAR_ConvertFILETIME(PROPVARIANT *ppropvarDest,
  40                                        REFPROPVARIANT propvarSrc, VARTYPE vt)
  41 {
  42     SYSTEMTIME time;
  43
  44     FileTimeToSystemTime(&propvarSrc->u.filetime, &time);
  45
  46     switch (vt)
  47     {
  48         case VT_LPSTR:
  49         {
  50             static const char format[] = "%04d/%02d/%02d:%02d:%02d:%02d.%03d";
  51
  52             ppropvarDest->u.pszVal = HeapAlloc(GetProcessHeap(), 0,
  53                                              sizeof(format));
  54             if (!ppropvarDest->u.pszVal)
  55                 return E_OUTOFMEMORY;
  56
  57             snprintf( ppropvarDest->u.pszVal, sizeof(format),
  58                       format,
  59                       time.wYear, time.wMonth, time.wDay,
  60                       time.wHour, time.wMinute, time.wSecond,
  61                       time.wMilliseconds );
  62
  63             return S_OK;
  64         }
  65
  66         default:
  67             FIXME("Unhandled target type: %d\n", vt);
  68     }
  69
  70     return E_FAIL;
  71 }
  72
  73 static HRESULT PROPVAR_ConvertNumber(REFPROPVARIANT pv, int dest_bits,
  74                                      BOOL dest_signed, LONGLONG *res)
  75 {
  76     BOOL src_signed;
  77
  78     switch (pv->vt)
  79     {
  80     case VT_I1:
  81         src_signed = TRUE;
  82         *res = pv->u.cVal;
  83         break;
  84     case VT_UI1:
  85         src_signed = FALSE;
  86         *res = pv->u.bVal;
  87         break;
  88     case VT_I2:
  89         src_signed = TRUE;
  90         *res = pv->u.iVal;
  91         break;
  92     case VT_UI2:
  93         src_signed = FALSE;
  94         *res = pv->u.uiVal;
  95         break;
  96     case VT_I4:
  97         src_signed = TRUE;
  98         *res = pv->u.lVal;
  99         break;
 100     case VT_UI4:
 101         src_signed = FALSE;
 102         *res = pv->u.ulVal;
 103         break;
 104     case VT_I8:
 105         src_signed = TRUE;
 106         *res = pv->u.hVal.QuadPart;
 107         break;
 108     case VT_UI8:
 109         src_signed = FALSE;
 110         *res = pv->u.uhVal.QuadPart;
 111         break;
 112     case VT_EMPTY:
 113         src_signed = FALSE;
 114         *res = 0;
 115         break;
 116     default:
 117         FIXME("unhandled vt %d\n", pv->vt);
 118         return E_NOTIMPL;
 119     }
 120
 121     if (*res < 0 && src_signed != dest_signed)
 122         return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
 123
 124     if (dest_bits < 64)
 125     {
 126         if (dest_signed)
 127         {
 128             if (*res >= ((LONGLONG)1 << (dest_bits-1)) ||
 129                 *res < ((LONGLONG)-1 << (dest_bits-1)))
 130                 return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
 131         }
 132         else
 133         {
 134             if ((ULONGLONG)(*res) >= ((ULONGLONG)1 << dest_bits))
 135                 return HRESULT_FROM_WIN32(ERROR_ARITHMETIC_OVERFLOW);
 136         }
 137     }
 138
 139     return S_OK;
 140 }
 141
 142 HRESULT WINAPI PropVariantToInt16(REFPROPVARIANT propvarIn, SHORT *ret)
 143 {
 144     LONGLONG res;
 145     HRESULT hr;
 146
 147     TRACE("%p,%p\n", propvarIn, ret);
 148
 149     hr = PROPVAR_ConvertNumber(propvarIn, 16, TRUE, &res);
 150     if (SUCCEEDED(hr)) *ret = (SHORT)res;
 151     return hr;
 152 }
 153
 154 HRESULT WINAPI PropVariantToInt32(REFPROPVARIANT propvarIn, LONG *ret)
 155 {
 156     LONGLONG res;
 157     HRESULT hr;
 158
 159     TRACE("%p,%p\n", propvarIn, ret);
 160
 161     hr = PROPVAR_ConvertNumber(propvarIn, 32, TRUE, &res);
 162     if (SUCCEEDED(hr)) *ret = (LONG)res;
 163     return hr;
 164 }
 165
 166 HRESULT WINAPI PropVariantToInt64(REFPROPVARIANT propvarIn, LONGLONG *ret)
 167 {
 168     LONGLONG res;
 169     HRESULT hr;
 170
 171     TRACE("%p,%p\n", propvarIn, ret);
 172
 173     hr = PROPVAR_ConvertNumber(propvarIn, 64, TRUE, &res);
 174     if (SUCCEEDED(hr)) *ret = (LONGLONG)res;
 175     return hr;
 176 }
 177
 178 HRESULT WINAPI PropVariantToUInt16(REFPROPVARIANT propvarIn, USHORT *ret)
 179 {
 180     LONGLONG res;
 181     HRESULT hr;
 182
 183     TRACE("%p,%p\n", propvarIn, ret);
 184
 185     hr = PROPVAR_ConvertNumber(propvarIn, 16, FALSE, &res);
 186     if (SUCCEEDED(hr)) *ret = (USHORT)res;
 187     return hr;
 188 }
 189
 190 HRESULT WINAPI PropVariantToUInt32(REFPROPVARIANT propvarIn, ULONG *ret)
 191 {
 192     LONGLONG res;
 193     HRESULT hr;
 194
 195     TRACE("%p,%p\n", propvarIn, ret);
 196
 197     hr = PROPVAR_ConvertNumber(propvarIn, 32, FALSE, &res);
 198     if (SUCCEEDED(hr)) *ret = (ULONG)res;
 199     return hr;
 200 }
 201
 202 HRESULT WINAPI PropVariantToUInt64(REFPROPVARIANT propvarIn, ULONGLONG *ret)
 203 {
 204     LONGLONG res;
 205     HRESULT hr;
 206
 207     TRACE("%p,%p\n", propvarIn, ret);
 208
 209     hr = PROPVAR_ConvertNumber(propvarIn, 64, FALSE, &res);
 210     if (SUCCEEDED(hr)) *ret = (ULONGLONG)res;
 211     return hr;
 212 }
 213
 214 HRESULT WINAPI PropVariantToStringAlloc(REFPROPVARIANT propvarIn, WCHAR **ret)
 215 {
 216     WCHAR *res = NULL;
 217     HRESULT hr = S_OK;
 218
 219     TRACE("%p,%p semi-stub\n", propvarIn, ret);
 220
 221     switch(propvarIn->vt)
 222     {
 223         case VT_NULL:
 224             res = CoTaskMemAlloc(1*sizeof(WCHAR));
 225             res[0] = '\0';
 226             break;
 227         case VT_LPSTR:
 228             if(propvarIn->u.pszVal)
 229             {
 230                 DWORD len;
 231
 232                 len = MultiByteToWideChar(CP_ACP, 0, propvarIn->u.pszVal, -1, NULL, 0);
 233                 res = CoTaskMemAlloc(len*sizeof(WCHAR));
 234                 if(!res)
 235                     return E_OUTOFMEMORY;
 236
 237                 MultiByteToWideChar(CP_ACP, 0, propvarIn->u.pszVal, -1, res, len);
 238             }
 239             break;
 240         default:
 241             FIXME("Unsupported conversion (%d)\n", propvarIn->vt);
 242             hr = E_FAIL;
 243             break;
 244     }
 245
 246     *ret = res;
 247
 248     return hr;
 249 }
 250
 251 /******************************************************************
 252  *  PropVariantChangeType   (PROPSYS.@)
 253  */
 254 HRESULT WINAPI PropVariantChangeType(PROPVARIANT *ppropvarDest, REFPROPVARIANT propvarSrc,
 255                                      PROPVAR_CHANGE_FLAGS flags, VARTYPE vt)
 256 {
 257     HRESULT hr;
 258
 259     FIXME("(%p, %p, %d, %d, %d): semi-stub!\n", ppropvarDest, propvarSrc,
 260           propvarSrc->vt, flags, vt);
 261
 262     if(vt == propvarSrc->vt)
 263         return PropVariantCopy(ppropvarDest, propvarSrc);
 264
 265     switch (vt)
 266     {
 267     case VT_I2:
 268     {
 269         SHORT res;
 270         hr = PropVariantToInt16(propvarSrc, &res);
 271         if (SUCCEEDED(hr))
 272         {
 273             ppropvarDest->vt = VT_I2;
 274             ppropvarDest->u.iVal = res;
 275         }
 276         return hr;
 277     }
 278     case VT_UI2:
 279     {
 280         USHORT res;
 281         hr = PropVariantToUInt16(propvarSrc, &res);
 282         if (SUCCEEDED(hr))
 283         {
 284             ppropvarDest->vt = VT_UI2;
 285             ppropvarDest->u.uiVal = res;
 286         }
 287         return hr;
 288     }
 289     case VT_I4:
 290     {
 291         LONG res;
 292         hr = PropVariantToInt32(propvarSrc, &res);
 293         if (SUCCEEDED(hr))
 294         {
 295             ppropvarDest->vt = VT_I4;
 296             ppropvarDest->u.lVal = res;
 297         }
 298         return hr;
 299     }
 300     case VT_UI4:
 301     {
 302         ULONG res;
 303         hr = PropVariantToUInt32(propvarSrc, &res);
 304         if (SUCCEEDED(hr))
 305         {
 306             ppropvarDest->vt = VT_UI4;
 307             ppropvarDest->u.ulVal = res;
 308         }
 309         return hr;
 310     }
 311     case VT_I8:
 312     {
 313         LONGLONG res;
 314         hr = PropVariantToInt64(propvarSrc, &res);
 315         if (SUCCEEDED(hr))
 316         {
 317             ppropvarDest->vt = VT_I8;
 318             ppropvarDest->u.hVal.QuadPart = res;
 319         }
 320         return hr;
 321     }
 322     case VT_UI8:
 323     {
 324         ULONGLONG res;
 325         hr = PropVariantToUInt64(propvarSrc, &res);
 326         if (SUCCEEDED(hr))
 327         {
 328             ppropvarDest->vt = VT_UI8;
 329             ppropvarDest->u.uhVal.QuadPart = res;
 330         }
 331         return hr;
 332     }
 333     case VT_LPWSTR:
 334     {
 335         WCHAR *res;
 336         hr = PropVariantToStringAlloc(propvarSrc, &res);
 337         if (SUCCEEDED(hr))
 338         {
 339             ppropvarDest->vt = VT_LPWSTR;
 340             ppropvarDest->u.pwszVal = res;
 341         }
 342         return hr;
 343     }
 344     }
 345
 346     switch (propvarSrc->vt)
 347     {
 348         case VT_FILETIME:
 349             return PROPVAR_ConvertFILETIME(ppropvarDest, propvarSrc, vt);
 350         default:
 351             FIXME("Unhandled source type: %d\n", propvarSrc->vt);
 352     }
 353
 354     return E_FAIL;
 355 }
 356
 357 static void PROPVAR_GUIDToWSTR(REFGUID guid, WCHAR *str)
 358 {
 359     static const WCHAR format[] = {'{','%','0','8','X','-','%','0','4','X','-','%','0','4','X',
 360         '-','%','0','2','X','%','0','2','X','-','%','0','2','X','%','0','2','X','%','0','2','X',
 361         '%','0','2','X','%','0','2','X','%','0','2','X','}',0};
 362
 363     sprintfW(str, format, guid->Data1, guid->Data2, guid->Data3,
 364             guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3],
 365             guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]);
 366 }
 367
 368 HRESULT WINAPI InitPropVariantFromGUIDAsString(REFGUID guid, PROPVARIANT *ppropvar)
 369 {
 370     TRACE("(%p %p)\n", guid, ppropvar);
 371
 372     if(!guid)
 373         return E_FAIL;
 374
 375     ppropvar->vt = VT_LPWSTR;
 376     ppropvar->u.pwszVal = CoTaskMemAlloc(39*sizeof(WCHAR));
 377     if(!ppropvar->u.pwszVal)
 378         return E_OUTOFMEMORY;
 379
 380     PROPVAR_GUIDToWSTR(guid, ppropvar->u.pwszVal);
 381     return S_OK;
 382 }
 383
 384 HRESULT WINAPI InitVariantFromGUIDAsString(REFGUID guid, VARIANT *pvar)
 385 {
 386     TRACE("(%p %p)\n", guid, pvar);
 387
 388     if(!guid) {
 389         FIXME("guid == NULL\n");
 390         return E_FAIL;
 391     }
 392
 393     V_VT(pvar) = VT_BSTR;
 394     V_BSTR(pvar) = SysAllocStringLen(NULL, 38);
 395     if(!V_BSTR(pvar))
 396         return E_OUTOFMEMORY;
 397
 398     PROPVAR_GUIDToWSTR(guid, V_BSTR(pvar));
 399     return S_OK;
 400 }
 401
 402 HRESULT WINAPI InitPropVariantFromBuffer(const VOID *pv, UINT cb, PROPVARIANT *ppropvar)
 403 {
 404     TRACE("(%p %u %p)\n", pv, cb, ppropvar);
 405
 406     ppropvar->u.caub.pElems = CoTaskMemAlloc(cb);
 407     if(!ppropvar->u.caub.pElems)
 408         return E_OUTOFMEMORY;
 409
 410     ppropvar->vt = VT_VECTOR|VT_UI1;
 411     ppropvar->u.caub.cElems = cb;
 412     memcpy(ppropvar->u.caub.pElems, pv, cb);
 413     return S_OK;
 414 }
 415
 416 HRESULT WINAPI InitVariantFromBuffer(const VOID *pv, UINT cb, VARIANT *pvar)
 417 {
 418     SAFEARRAY *arr;
 419     void *data;
 420     HRESULT hres;
 421
 422     TRACE("(%p %u %p)\n", pv, cb, pvar);
 423
 424     arr = SafeArrayCreateVector(VT_UI1, 0, cb);
 425     if(!arr)
 426         return E_OUTOFMEMORY;
 427
 428     hres = SafeArrayAccessData(arr, &data);
 429     if(FAILED(hres)) {
 430         SafeArrayDestroy(arr);
 431         return hres;
 432     }
 433
 434     memcpy(data, pv, cb);
 435
 436     hres = SafeArrayUnaccessData(arr);
 437     if(FAILED(hres)) {
 438         SafeArrayDestroy(arr);
 439         return hres;
 440     }
 441
 442     V_VT(pvar) = VT_ARRAY|VT_UI1;
 443     V_ARRAY(pvar) = arr;
 444     return S_OK;
 445 }
 446
 447 static inline DWORD PROPVAR_HexToNum(const WCHAR *hex)
 448 {
 449     DWORD ret;
 450
 451     if(hex[0]>='0' && hex[0]<='9')
 452         ret = hex[0]-'0';
 453     else if(hex[0]>='a' && hex[0]<='f')
 454         ret = hex[0]-'a'+10;
 455     else if(hex[0]>='A' && hex[0]<='F')
 456         ret = hex[0]-'A'+10;
 457     else
 458         return -1;
 459
 460     ret <<= 4;
 461     if(hex[1]>='0' && hex[1]<='9')
 462         return ret + hex[1]-'0';
 463     else if(hex[1]>='a' && hex[1]<='f')
 464         return ret + hex[1]-'a'+10;
 465     else if(hex[1]>='A' && hex[1]<='F')
 466         return ret + hex[1]-'A'+10;
 467     else
 468         return -1;
 469 }
 470
 471 static inline HRESULT PROPVAR_WCHARToGUID(const WCHAR *str, int len, GUID *guid)
 472 {
 473     DWORD i, val=0;
 474     const WCHAR *p;
 475
 476     memset(guid, 0, sizeof(GUID));
 477
 478     if(len!=38 || str[0]!='{' || str[9]!='-' || str[14]!='-'
 479             || str[19]!='-' || str[24]!='-' || str[37]!='}') {
 480         WARN("Error parsing %s\n", debugstr_w(str));
 481         return E_INVALIDARG;
 482     }
 483
 484     p = str+1;
 485     for(i=0; i<4 && val!=-1; i++) {
 486         val = PROPVAR_HexToNum(p);
 487         guid->Data1 = (guid->Data1<<8) + val;
 488         p += 2;
 489     }
 490     p++;
 491     for(i=0; i<2 && val!=-1; i++) {
 492         val = PROPVAR_HexToNum(p);
 493         guid->Data2 = (guid->Data2<<8) + val;
 494         p += 2;
 495     }
 496     p++;
 497     for(i=0; i<2 && val!=-1; i++) {
 498         val = PROPVAR_HexToNum(p);
 499         guid->Data3 = (guid->Data3<<8) + val;
 500         p += 2;
 501     }
 502     p++;
 503     for(i=0; i<8 && val!=-1; i++) {
 504         if(i == 2)
 505             p++;
 506
 507         val = guid->Data4[i] = PROPVAR_HexToNum(p);
 508         p += 2;
 509     }
 510
 511     if(val == -1) {
 512         WARN("Error parsing %s\n", debugstr_w(str));
 513         memset(guid, 0, sizeof(GUID));
 514         return E_INVALIDARG;
 515     }
 516     return S_OK;
 517 }
 518
 519 HRESULT WINAPI PropVariantToGUID(const PROPVARIANT *ppropvar, GUID *guid)
 520 {
 521     TRACE("%p %p)\n", ppropvar, guid);
 522
 523     switch(ppropvar->vt) {
 524     case VT_BSTR:
 525         return PROPVAR_WCHARToGUID(ppropvar->u.bstrVal, SysStringLen(ppropvar->u.bstrVal), guid);
 526     case VT_LPWSTR:
 527         return PROPVAR_WCHARToGUID(ppropvar->u.pwszVal, strlenW(ppropvar->u.pwszVal), guid);
 528
 529     default:
 530         FIXME("unsupported vt: %d\n", ppropvar->vt);
 531         return E_NOTIMPL;
 532     }
 533 }
 534
 535 HRESULT WINAPI VariantToGUID(const VARIANT *pvar, GUID *guid)
 536 {
 537     TRACE("(%p %p)\n", pvar, guid);
 538
 539     switch(V_VT(pvar)) {
 540     case VT_BSTR: {
 541         HRESULT hres = PROPVAR_WCHARToGUID(V_BSTR(pvar), SysStringLen(V_BSTR(pvar)), guid);
 542         if(hres == E_INVALIDARG)
 543             return E_FAIL;
 544         return hres;
 545     }
 546
 547     default:
 548         FIXME("unsupported vt: %d\n", V_VT(pvar));
 549         return E_NOTIMPL;
 550     }
 551 }
 552
 553 static BOOL isemptyornull(const PROPVARIANT *propvar)
 554 {
 555     if (propvar->vt == VT_EMPTY || propvar->vt == VT_NULL)
 556         return TRUE;
 557     if ((propvar->vt & VT_ARRAY) == VT_ARRAY)
 558     {
 559         int i;
 560         for (i=0; i<propvar->u.parray->cDims; i++)
 561         {
 562             if (propvar->u.parray->rgsabound[i].cElements != 0)
 563                 break;
 564         }
 565         return i == propvar->u.parray->cDims;
 566     }
 567     /* FIXME: vectors, byrefs, errors? */
 568     return FALSE;
 569 }
 570
 571 INT WINAPI PropVariantCompareEx(REFPROPVARIANT propvar1, REFPROPVARIANT propvar2,
 572     PROPVAR_COMPARE_UNIT unit, PROPVAR_COMPARE_FLAGS flags)
 573 {
 574     const PROPVARIANT *propvar2_converted;
 575     PROPVARIANT propvar2_static;
 576     HRESULT hr;
 577     INT res=-1;
 578
 579     TRACE("%p,%p,%x,%x\n", propvar1, propvar2, unit, flags);
 580
 581     if (isemptyornull(propvar1))
 582     {
 583         if (isemptyornull(propvar2))
 584             return 0;
 585         return (flags & PVCF_TREATEMPTYASGREATERTHAN) ? 1 : -1;
 586     }
 587
 588     if (isemptyornull(propvar2))
 589         return (flags & PVCF_TREATEMPTYASGREATERTHAN) ? -1 : 1;
 590
 591     if (propvar1->vt != propvar2->vt)
 592     {
 593         hr = PropVariantChangeType(&propvar2_static, propvar2, 0, propvar1->vt);
 594
 595         if (FAILED(hr))
 596             return -1;
 597
 598         propvar2_converted = &propvar2_static;
 599     }
 600     else
 601         propvar2_converted = propvar2;
 602
 603 #define CMP_INT_VALUE(var) do { \
 604     if (propvar1->u.var > propvar2_converted->u.var) \
 605         res = 1; \
 606     else if (propvar1->u.var < propvar2_converted->u.var) \
 607         res = -1; \
 608     else \
 609         res = 0; \
 610     } while (0)
 611
 612     switch (propvar1->vt)
 613     {
 614     case VT_I1:
 615         CMP_INT_VALUE(cVal);
 616         break;
 617     case VT_UI1:
 618         CMP_INT_VALUE(bVal);
 619         break;
 620     case VT_I2:
 621         CMP_INT_VALUE(iVal);
 622         break;
 623     case VT_UI2:
 624         CMP_INT_VALUE(uiVal);
 625         break;
 626     case VT_I4:
 627         CMP_INT_VALUE(lVal);
 628         break;
 629     case VT_UI4:
 630         CMP_INT_VALUE(uiVal);
 631         break;
 632     case VT_I8:
 633         CMP_INT_VALUE(hVal.QuadPart);
 634         break;
 635     case VT_UI8:
 636         CMP_INT_VALUE(uhVal.QuadPart);
 637         break;
 638     case VT_BSTR:
 639         /* FIXME: Use string flags. */
 640         res = lstrcmpW(propvar1->u.bstrVal, propvar2->u.bstrVal);
 641         break;
 642     default:
 643         FIXME("vartype %d not handled\n", propvar1->vt);
 644         res = -1;
 645         break;
 646     }
 647
 648     if (propvar2_converted == &propvar2_static)
 649         PropVariantClear(&propvar2_static);
 650
 651     return res;
 652 }