| /* |
| * PropVariant implementation |
| * |
| * Copyright 2008 James Hawkins for CodeWeavers |
| * |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Lesser General Public |
| * License as published by the Free Software Foundation; either |
| * version 2.1 of the License, or (at your option) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Lesser General Public License for more details. |
| * |
| * You should have received a copy of the GNU Lesser General Public |
| * License along with this library; if not, write to the Free Software |
| * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA |
| */ |
| |
| #include <stdarg.h> |
| #include <stdio.h> |
| |
| #define NONAMELESSUNION |
| |
| #include "windef.h" |
| #include "winbase.h" |
| #include "winerror.h" |
| #include "winreg.h" |
| #include "winuser.h" |
| #include "shlobj.h" |
| #include "propvarutil.h" |
| |
| #include "wine/debug.h" |
| #include "wine/unicode.h" |
| |
| WINE_DEFAULT_DEBUG_CHANNEL(propsys); |
| |
| static HRESULT PROPVAR_ConvertFILETIME(PROPVARIANT *ppropvarDest, |
| REFPROPVARIANT propvarSrc, VARTYPE vt) |
| { |
| SYSTEMTIME time; |
| |
| FileTimeToSystemTime(&propvarSrc->u.filetime, &time); |
| |
| switch (vt) |
| { |
| case VT_LPSTR: |
| { |
| static const char format[] = "%04d/%02d/%02d:%02d:%02d:%02d.%03d"; |
| |
| ppropvarDest->u.pszVal = HeapAlloc(GetProcessHeap(), 0, |
| lstrlenA(format) + 1); |
| if (!ppropvarDest->u.pszVal) |
| return E_OUTOFMEMORY; |
| |
| sprintf(ppropvarDest->u.pszVal, format, time.wYear, time.wMonth, |
| time.wDay, time.wHour, time.wMinute, |
| time.wSecond, time.wMilliseconds); |
| |
| return S_OK; |
| } |
| |
| default: |
| FIXME("Unhandled target type: %d\n", vt); |
| } |
| |
| return E_FAIL; |
| } |
| |
| /****************************************************************** |
| * PropVariantChangeType (PROPSYS.@) |
| */ |
| HRESULT WINAPI PropVariantChangeType(PROPVARIANT *ppropvarDest, REFPROPVARIANT propvarSrc, |
| PROPVAR_CHANGE_FLAGS flags, VARTYPE vt) |
| { |
| FIXME("(%p, %p, %d, %d, %d): semi-stub!\n", ppropvarDest, propvarSrc, |
| propvarSrc->vt, flags, vt); |
| |
| switch (propvarSrc->vt) |
| { |
| case VT_FILETIME: |
| return PROPVAR_ConvertFILETIME(ppropvarDest, propvarSrc, vt); |
| default: |
| FIXME("Unhandled source type: %d\n", propvarSrc->vt); |
| } |
| |
| return E_FAIL; |
| } |
| |
| static void PROPVAR_GUIDToWSTR(REFGUID guid, WCHAR *str) |
| { |
| static const WCHAR format[] = {'{','%','0','8','X','-','%','0','4','X','-','%','0','4','X', |
| '-','%','0','2','X','%','0','2','X','-','%','0','2','X','%','0','2','X','%','0','2','X', |
| '%','0','2','X','%','0','2','X','%','0','2','X','}',0}; |
| |
| sprintfW(str, format, guid->Data1, guid->Data2, guid->Data3, |
| guid->Data4[0], guid->Data4[1], guid->Data4[2], guid->Data4[3], |
| guid->Data4[4], guid->Data4[5], guid->Data4[6], guid->Data4[7]); |
| } |
| |
| HRESULT WINAPI InitPropVariantFromGUIDAsString(REFGUID guid, PROPVARIANT *ppropvar) |
| { |
| TRACE("(%p %p)\n", guid, ppropvar); |
| |
| if(!guid) |
| return E_FAIL; |
| |
| ppropvar->vt = VT_LPWSTR; |
| ppropvar->u.pwszVal = CoTaskMemAlloc(39*sizeof(WCHAR)); |
| if(!ppropvar->u.pwszVal) |
| return E_OUTOFMEMORY; |
| |
| PROPVAR_GUIDToWSTR(guid, ppropvar->u.pwszVal); |
| return S_OK; |
| } |
| |
| HRESULT WINAPI InitVariantFromGUIDAsString(REFGUID guid, VARIANT *pvar) |
| { |
| TRACE("(%p %p)\n", guid, pvar); |
| |
| if(!guid) { |
| FIXME("guid == NULL\n"); |
| return E_FAIL; |
| } |
| |
| V_VT(pvar) = VT_BSTR; |
| V_BSTR(pvar) = SysAllocStringLen(NULL, 38); |
| if(!V_BSTR(pvar)) |
| return E_OUTOFMEMORY; |
| |
| PROPVAR_GUIDToWSTR(guid, V_BSTR(pvar)); |
| return S_OK; |
| } |
| |
| HRESULT WINAPI InitPropVariantFromBuffer(const VOID *pv, UINT cb, PROPVARIANT *ppropvar) |
| { |
| TRACE("(%p %u %p)\n", pv, cb, ppropvar); |
| |
| ppropvar->u.caub.pElems = CoTaskMemAlloc(cb); |
| if(!ppropvar->u.caub.pElems) |
| return E_OUTOFMEMORY; |
| |
| ppropvar->vt = VT_VECTOR|VT_UI1; |
| ppropvar->u.caub.cElems = cb; |
| memcpy(ppropvar->u.caub.pElems, pv, cb); |
| return S_OK; |
| } |
| |
| HRESULT WINAPI InitVariantFromBuffer(const VOID *pv, UINT cb, VARIANT *pvar) |
| { |
| SAFEARRAY *arr; |
| void *data; |
| HRESULT hres; |
| |
| TRACE("(%p %u %p)\n", pv, cb, pvar); |
| |
| arr = SafeArrayCreateVector(VT_UI1, 0, cb); |
| if(!arr) |
| return E_OUTOFMEMORY; |
| |
| hres = SafeArrayAccessData(arr, &data); |
| if(FAILED(hres)) { |
| SafeArrayDestroy(arr); |
| return hres; |
| } |
| |
| memcpy(data, pv, cb); |
| |
| hres = SafeArrayUnaccessData(arr); |
| if(FAILED(hres)) { |
| SafeArrayDestroy(arr); |
| return hres; |
| } |
| |
| V_VT(pvar) = VT_ARRAY|VT_UI1; |
| V_ARRAY(pvar) = arr; |
| return S_OK; |
| } |
| |
| static inline DWORD PROPVAR_HexToNum(const WCHAR *hex) |
| { |
| DWORD ret; |
| |
| if(hex[0]>='0' && hex[0]<='9') |
| ret = hex[0]-'0'; |
| else if(hex[0]>='a' && hex[0]<='f') |
| ret = hex[0]-'a'+10; |
| else if(hex[0]>='A' && hex[0]<='F') |
| ret = hex[0]-'A'+10; |
| else |
| return -1; |
| |
| ret <<= 4; |
| if(hex[1]>='0' && hex[1]<='9') |
| return ret + hex[1]-'0'; |
| else if(hex[1]>='a' && hex[1]<='f') |
| return ret + hex[1]-'a'+10; |
| else if(hex[1]>='A' && hex[1]<='F') |
| return ret + hex[1]-'A'+10; |
| else |
| return -1; |
| } |
| |
| static inline HRESULT PROPVAR_WCHARToGUID(const WCHAR *str, int len, GUID *guid) |
| { |
| DWORD i, val=0; |
| const WCHAR *p; |
| |
| memset(guid, 0, sizeof(GUID)); |
| |
| if(len!=38 || str[0]!='{' || str[9]!='-' || str[14]!='-' |
| || str[19]!='-' || str[24]!='-' || str[37]!='}') { |
| WARN("Error parsing %s\n", debugstr_w(str)); |
| return E_INVALIDARG; |
| } |
| |
| p = str+1; |
| for(i=0; i<4 && val!=-1; i++) { |
| val = PROPVAR_HexToNum(p); |
| guid->Data1 = (guid->Data1<<8) + val; |
| p += 2; |
| } |
| p++; |
| for(i=0; i<2 && val!=-1; i++) { |
| val = PROPVAR_HexToNum(p); |
| guid->Data2 = (guid->Data2<<8) + val; |
| p += 2; |
| } |
| p++; |
| for(i=0; i<2 && val!=-1; i++) { |
| val = PROPVAR_HexToNum(p); |
| guid->Data3 = (guid->Data3<<8) + val; |
| p += 2; |
| } |
| p++; |
| for(i=0; i<8 && val!=-1; i++) { |
| if(i == 2) |
| p++; |
| |
| val = guid->Data4[i] = PROPVAR_HexToNum(p); |
| p += 2; |
| } |
| |
| if(val == -1) { |
| WARN("Error parsing %s\n", debugstr_w(str)); |
| memset(guid, 0, sizeof(GUID)); |
| return E_INVALIDARG; |
| } |
| return S_OK; |
| } |
| |
| HRESULT WINAPI PropVariantToGUID(const PROPVARIANT *ppropvar, GUID *guid) |
| { |
| TRACE("%p %p)\n", ppropvar, guid); |
| |
| switch(ppropvar->vt) { |
| case VT_BSTR: |
| return PROPVAR_WCHARToGUID(ppropvar->u.bstrVal, SysStringLen(ppropvar->u.bstrVal), guid); |
| case VT_LPWSTR: |
| return PROPVAR_WCHARToGUID(ppropvar->u.pwszVal, strlenW(ppropvar->u.pwszVal), guid); |
| |
| default: |
| FIXME("unsupported vt: %d\n", ppropvar->vt); |
| return E_NOTIMPL; |
| } |
| } |
| |
| HRESULT WINAPI VariantToGUID(const VARIANT *pvar, GUID *guid) |
| { |
| TRACE("(%p %p)\n", pvar, guid); |
| |
| switch(V_VT(pvar)) { |
| case VT_BSTR: { |
| HRESULT hres = PROPVAR_WCHARToGUID(V_BSTR(pvar), SysStringLen(V_BSTR(pvar)), guid); |
| if(hres == E_INVALIDARG) |
| return E_FAIL; |
| return hres; |
| } |
| |
| default: |
| FIXME("unsupported vt: %d\n", V_VT(pvar)); |
| return E_NOTIMPL; |
| } |
| } |
