/********************************************************************** * DEVENUM_IPropertyBag_AddRef (also IUnknown) */ static ULONG WINAPI DEVENUM_IPropertyBag_AddRef(LPPROPERTYBAG iface) { RegPropBagImpl *This = impl_from_IPropertyBag(iface); TRACE("(%p)->() AddRef from %d\n", iface, This->ref); return InterlockedIncrement(&This->ref); }
static HRESULT WINAPI DEVENUM_IPropertyBag_Write( LPPROPERTYBAG iface, LPCOLESTR pszPropName, VARIANT* pVar) { RegPropBagImpl *This = impl_from_IPropertyBag(iface); LPVOID lpData = NULL; DWORD cbData = 0; DWORD dwType = 0; HRESULT res = S_OK; TRACE("(%p)->(%s, %p)\n", This, debugstr_w(pszPropName), pVar); switch (V_VT(pVar)) { case VT_BSTR: case VT_LPWSTR: TRACE("writing %s\n", debugstr_w(V_UNION(pVar, bstrVal))); lpData = V_UNION(pVar, bstrVal); dwType = REG_SZ; cbData = (lstrlenW(V_UNION(pVar, bstrVal)) + 1) * sizeof(WCHAR); break; case VT_I4: case VT_UI4: TRACE("writing %u\n", V_UNION(pVar, ulVal)); lpData = &V_UNION(pVar, ulVal); dwType = REG_DWORD; cbData = sizeof(DWORD); break; case VT_ARRAY | VT_UI1: { LONG lUbound = 0; LONG lLbound = 0; dwType = REG_BINARY; res = SafeArrayGetLBound(V_UNION(pVar, parray), 1, &lLbound); res = SafeArrayGetUBound(V_UNION(pVar, parray), 1, &lUbound); cbData = (lUbound - lLbound + 1) /* * sizeof(BYTE)*/; TRACE("cbData: %d\n", cbData); res = SafeArrayAccessData(V_UNION(pVar, parray), &lpData); break; } default: FIXME("Variant type %d not handled\n", V_VT(pVar)); return E_FAIL; } if (RegSetValueExW(This->hkey, pszPropName, 0, dwType, lpData, cbData) != ERROR_SUCCESS) res = E_FAIL; if (V_VT(pVar) & VT_ARRAY) res = SafeArrayUnaccessData(V_UNION(pVar, parray)); return res; }
static ULONG WINAPI RegistryPropertyBag_IPropertyBag_AddRef(IPropertyBag *iface) { RegistryPropertyBag *This = impl_from_IPropertyBag(iface); ULONG cRef; TRACE("(iface=%p)\n", iface); cRef = InterlockedIncrement(&This->m_cRef); if (cRef == 1) SHDOCVW_LockModule(); return cRef; }
/********************************************************************** * DEVENUM_IPropertyBag_Release (also IUnknown) */ static ULONG WINAPI DEVENUM_IPropertyBag_Release(LPPROPERTYBAG iface) { RegPropBagImpl *This = impl_from_IPropertyBag(iface); ULONG ref; TRACE("(%p)->() ReleaseThis->ref from %d\n", iface, This->ref); ref = InterlockedDecrement(&This->ref); if (ref == 0) { RegCloseKey(This->hkey); CoTaskMemFree(This); DEVENUM_UnlockModule(); } return ref; }
static HRESULT WINAPI PB_Read(IPropertyBag *iface, LPCOLESTR name, VARIANT *var, IErrorLog *log) { static const WCHAR dsguid[] = { 'D','S','G','u','i','d', 0 }; IPropertyBagImpl *This = impl_from_IPropertyBag(iface); TRACE("Trying to read %s, type %u\n", debugstr_w(name), var->n1.n2.vt); if (!lstrcmpW(name, dsguid)) { WCHAR guidstr[39]; StringFromGUID2(&This->devguid, guidstr,sizeof(guidstr)/sizeof(*guidstr)); var->n1.n2.vt = VT_BSTR; var->n1.n2.n3.bstrVal = SysAllocString(guidstr); return S_OK; } ERR("Unknown property '%s' queried\n", debugstr_w(name)); return E_FAIL; }
static ULONG WINAPI RegistryPropertyBag_IPropertyBag_Release(IPropertyBag *iface) { RegistryPropertyBag *This = impl_from_IPropertyBag(iface); ULONG cRef; TRACE("(iface=%p)\n", iface); cRef = InterlockedDecrement(&This->m_cRef); if (cRef == 0) { TRACE("Destroying This=%p)\n", This); RegCloseKey(This->m_hInitPropertyBagKey); heap_free(This); SHDOCVW_UnlockModule(); } return cRef; }
static HRESULT WINAPI RegistryPropertyBag_IPropertyBag_QueryInterface(IPropertyBag *iface, REFIID riid, void **ppv) { RegistryPropertyBag *This = impl_from_IPropertyBag(iface); TRACE("(iface=%p, riid=%s, ppv=%p)\n", iface, debugstr_guid(riid), ppv); if (!ppv) return E_INVALIDARG; if (IsEqualIID(&IID_IUnknown, riid) || IsEqualIID(&IID_IPropertyBag, riid)) { *ppv = &This->IPropertyBag_iface; } else { *ppv = NULL; return E_NOINTERFACE; } IUnknown_AddRef((IUnknown*)*ppv); return S_OK; }
static HRESULT WINAPI RegistryPropertyBag_IPropertyBag_Read(IPropertyBag *iface, LPCOLESTR pwszPropName, VARIANT *pVar, IErrorLog *pErrorLog) { RegistryPropertyBag *This = impl_from_IPropertyBag(iface); WCHAR *pwszValue; DWORD dwType, cbData; LONG res; VARTYPE vtDst = V_VT(pVar); HRESULT hr = S_OK; TRACE("(iface=%p, pwszPropName=%s, pVar=%p, pErrorLog=%p)\n", iface, debugstr_w(pwszPropName), pVar, pErrorLog); res = RegQueryValueExW(This->m_hInitPropertyBagKey, pwszPropName, NULL, &dwType, NULL, &cbData); if (res != ERROR_SUCCESS) return E_INVALIDARG; pwszValue = heap_alloc(cbData); if (!pwszValue) return E_OUTOFMEMORY; res = RegQueryValueExW(This->m_hInitPropertyBagKey, pwszPropName, NULL, &dwType, (LPBYTE)pwszValue, &cbData); if (res != ERROR_SUCCESS) { heap_free(pwszValue); return E_INVALIDARG; } V_VT(pVar) = VT_BSTR; V_BSTR(pVar) = SysAllocString(pwszValue); heap_free(pwszValue); if (vtDst != VT_BSTR) { hr = VariantChangeTypeEx(pVar, pVar, LOCALE_SYSTEM_DEFAULT, 0, vtDst); if (FAILED(hr)) SysFreeString(V_BSTR(pVar)); } return hr; }
static HRESULT WINAPI DEVENUM_IPropertyBag_QueryInterface( LPPROPERTYBAG iface, REFIID riid, LPVOID *ppvObj) { RegPropBagImpl *This = impl_from_IPropertyBag(iface); TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppvObj); if (This == NULL || ppvObj == NULL) return E_POINTER; if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IPropertyBag)) { *ppvObj = iface; IPropertyBag_AddRef(iface); return S_OK; } FIXME("- no interface IID: %s\n", debugstr_guid(riid)); return E_NOINTERFACE; }
static HRESULT WINAPI DEVENUM_IPropertyBag_Read( LPPROPERTYBAG iface, LPCOLESTR pszPropName, VARIANT* pVar, IErrorLog* pErrorLog) { LPVOID pData = NULL; DWORD received; DWORD type = 0; RegPropBagImpl *This = impl_from_IPropertyBag(iface); HRESULT res = S_OK; LONG reswin32; TRACE("(%p)->(%s, %p, %p)\n", This, debugstr_w(pszPropName), pVar, pErrorLog); if (!pszPropName || !pVar) return E_POINTER; reswin32 = RegQueryValueExW(This->hkey, pszPropName, NULL, NULL, NULL, &received); res = HRESULT_FROM_WIN32(reswin32); if (SUCCEEDED(res)) { pData = HeapAlloc(GetProcessHeap(), 0, received); /* work around a GCC bug that occurs here unless we use the reswin32 variable as well */ reswin32 = RegQueryValueExW(This->hkey, pszPropName, NULL, &type, pData, &received); res = HRESULT_FROM_WIN32(reswin32); } if (SUCCEEDED(res)) { res = E_INVALIDARG; /* assume we cannot coerce into right type */ TRACE("Read %d bytes (%s)\n", received, type == REG_SZ ? debugstr_w(pData) : "binary data"); switch (type) { case REG_SZ: switch (V_VT(pVar)) { case VT_LPWSTR: V_UNION(pVar, bstrVal) = CoTaskMemAlloc(received); memcpy(V_UNION(pVar, bstrVal), pData, received); res = S_OK; break; case VT_EMPTY: V_VT(pVar) = VT_BSTR; /* fall through */ case VT_BSTR: V_UNION(pVar, bstrVal) = SysAllocStringLen(pData, received/sizeof(WCHAR) - 1); res = S_OK; break; } break; case REG_DWORD: TRACE("REG_DWORD: %x\n", *(DWORD *)pData); switch (V_VT(pVar)) { case VT_EMPTY: V_VT(pVar) = VT_I4; /* fall through */ case VT_I4: case VT_UI4: V_UNION(pVar, ulVal) = *(DWORD *)pData; res = S_OK; break; } break; case REG_BINARY: { SAFEARRAYBOUND bound; void * pArrayElements; bound.lLbound = 0; bound.cElements = received; TRACE("REG_BINARY: len = %d\n", received); switch (V_VT(pVar)) { case VT_EMPTY: V_VT(pVar) = VT_ARRAY | VT_UI1; /* fall through */ case VT_ARRAY | VT_UI1: if (!(V_UNION(pVar, parray) = SafeArrayCreate(VT_UI1, 1, &bound))) res = E_OUTOFMEMORY; else res = S_OK; break; } if (res == E_INVALIDARG) break; res = SafeArrayAccessData(V_UNION(pVar, parray), &pArrayElements); if (FAILED(res)) break; CopyMemory(pArrayElements, pData, received); res = SafeArrayUnaccessData(V_UNION(pVar, parray)); break; } } if (res == E_INVALIDARG) FIXME("Variant type %x not supported for regtype %x\n", V_VT(pVar), type); } HeapFree(GetProcessHeap(), 0, pData); TRACE("<- %x\n", res); return res; }