static LONG get_var_int(const VARIANT *var)
{
switch(V_VT(var))
{
case VT_I1:
case VT_UI1:
return V_UI1(var);
case VT_I2:
case VT_UI2:
return V_UI2(var);
case VT_I4:
case VT_UI4:
return V_UI4(var);
case VT_I8:
case VT_UI8:
return V_UI8(var);
case VT_INT:
case VT_UINT:
return V_UINT(var);
default:
FIXME("unsupported variant type %d\n", V_VT(var));
return 0;
}
}
JNIEXPORT void JNICALL Java_com_tangram_Variant_putVariantByte(JNIEnv *env, jobject _this, jbyte b)
{
VARIANT *v = extractVariant(env, _this);
if (v) {
VariantClear(v); // whatever was there before
V_VT(v) = VT_UI1;
V_UI1(v) = b;
}
else ThrowComFail(env, "putVariantByte failed", -1);
}
/**
* Returns the value of this Variant as a Byte if it is of that type.
* Otherwise it will return null (no conversion done)
*/
JNIEXPORT jbyte JNICALL Java_com_tangram_Variant_getVariantByte(JNIEnv *env, jobject _this)
{
VARIANT *v = extractVariant(env, _this);
if (v) {
if (V_VT(v) != (VT_UI1)) {
return NULL;
}
return (jbyte)V_UI1(v);
}
return NULL;
}
DWORD COcsWmi::dwCimValue(VARIANT &pVal, CIMTYPE &pType)
{
if ((pVal.vt == VT_NULL) || (pVal.vt == VT_EMPTY))
return 0;
else
switch (pType)
{
case CIM_SINT8:
return V_I1(&pVal);
case CIM_UINT8:
return V_UI1(&pVal);
case CIM_SINT16:
return V_I2(&pVal);
case CIM_UINT16:
return V_UI2(&pVal);
case CIM_SINT32:
return V_I4(&pVal);
case CIM_UINT32:
return V_UI4(&pVal);
case CIM_BOOLEAN:
return (V_BOOL(&pVal) ? 1 : 0);
default:
return 0;
}
}
HRESULT CXMLHttpRequest::InitializeVarFromByte(VARIANT &varOut, const PBYTE pByte, long lSize)
{
::VariantInit(&varOut);
V_VT(&varOut) = VT_NULL;
HRESULT hr = S_OK;
SAFEARRAYBOUND rgsabound[1];
rgsabound[0].cElements = lSize;
rgsabound[0].lLbound = 0;
SAFEARRAY *psa = ::SafeArrayCreate( VT_VARIANT, 1, rgsabound);
if (psa == NULL)
return E_FAIL;
if (pByte != NULL) {
long ix[1];
for (ULONG i = 0; i < rgsabound[0].cElements; ++i) {
ix[0] = i;
VARIANT var;
::VariantInit(&var);
V_VT(&var) = VT_UI1;
V_UI1(&var) = pByte[i];
hr = ::SafeArrayPutElement(psa, ix, &var);
if (S_OK != hr) {
::SafeArrayDestroy(psa);
break;
}
}
}
if (S_OK == hr) {
V_VT(&varOut) = VT_ARRAY | VT_VARIANT;
V_ARRAY(&varOut) = psa;
}
return hr;
}
void EventProxy::convertJavaVariant(VARIANT *java, VARIANT *com) {
switch (com->vt)
{
case VT_DISPATCH:
{
switch (java->vt)
{
case VT_DISPATCH:
{
V_DISPATCH(com) = V_DISPATCH(java);
break;
}
case VT_DISPATCH | VT_BYREF:
{
V_DISPATCH(com) = *V_DISPATCHREF(java);
break;
}
}
break;
}
case VT_DISPATCH | VT_BYREF:
{
switch (java->vt)
{
case VT_DISPATCH:
{
*V_DISPATCHREF(com) = V_DISPATCH(java);
break;
}
case VT_DISPATCH | VT_BYREF:
{
*V_DISPATCHREF(com) = *V_DISPATCHREF(java);
break;
}
}
break;
}
case VT_BOOL:
{
switch (java->vt)
{
case VT_BOOL:
{
V_BOOL(com) = V_BOOL(java);
break;
}
case VT_BOOL | VT_BYREF:
{
V_BOOL(com) = *V_BOOLREF(java);
break;
}
}
break;
}
case VT_BOOL | VT_BYREF:
{
switch (java->vt)
{
case VT_BOOL:
{
*V_BOOLREF(com) = V_BOOL(java);
break;
}
case VT_BOOL | VT_BYREF:
{
*V_BOOLREF(com) = *V_BOOLREF(java);
break;
}
}
break;
}
case VT_UI1:
{
switch (java->vt)
{
case VT_UI1:
{
V_UI1(com) = V_UI1(java);
break;
}
case VT_UI1 | VT_BYREF:
{
V_UI1(com) = *V_UI1REF(java);
break;
}
}
break;
}
case VT_UI1 | VT_BYREF:
{
switch (java->vt)
{
case VT_UI1:
{
*V_UI1REF(com) = V_UI1(java);
break;
}
case VT_UI1 | VT_BYREF:
{
*V_UI1REF(com) = *V_UI1REF(java);
break;
}
}
break;
}
case VT_I2:
{
switch (java->vt)
{
case VT_I2:
{
V_I2(com) = V_I2(java);
break;
}
case VT_I2 | VT_BYREF:
{
V_I2(com) = *V_I2REF(java);
break;
}
}
break;
}
case VT_I2 | VT_BYREF:
{
switch (java->vt)
{
case VT_I2:
{
*V_I2REF(com) = V_I2(java);
break;
}
case VT_I2 | VT_BYREF:
{
*V_I2REF(com) = *V_I2REF(java);
break;
}
}
break;
}
case VT_I4:
{
switch (java->vt)
{
case VT_I4:
{
V_I4(com) = V_I4(java);
break;
}
case VT_I4 | VT_BYREF:
{
V_I4(com) = *V_I4REF(java);
break;
}
}
break;
}
case VT_I4 | VT_BYREF:
{
switch (java->vt)
{
case VT_I4:
{
*V_I4REF(com) = V_I4(java);
break;
}
case VT_I4 | VT_BYREF:
{
*V_I4REF(com) = *V_I4REF(java);
break;
}
}
break;
}
case VT_R4:
{
switch (java->vt)
{
case VT_R4:
{
V_R4(com) = V_R4(java);
break;
}
case VT_R4 | VT_BYREF:
{
V_R4(com) = *V_R4REF(java);
break;
}
}
break;
}
case VT_R4 | VT_BYREF:
{
switch (java->vt)
{
case VT_R4:
{
*V_R4REF(com) = V_R4(java);
break;
}
case VT_R4 | VT_BYREF:
{
*V_R4REF(com) = *V_R4REF(java);
break;
}
}
break;
}
case VT_R8:
{
switch (java->vt)
{
case VT_R8:
{
V_R8(com) = V_R8(java);
break;
}
case VT_R8 | VT_BYREF:
{
V_R8(com) = *V_R8REF(java);
break;
}
}
break;
}
case VT_R8 | VT_BYREF:
{
switch (java->vt)
{
case VT_R8:
{
*V_R8REF(com) = V_R8(java);
break;
}
case VT_R8 | VT_BYREF:
{
*V_R8REF(com) = *V_R8REF(java);
break;
}
}
break;
}
case VT_I1:
{
switch (java->vt)
{
case VT_I1:
{
V_I1(com) = V_I1(java);
break;
}
case VT_I1 | VT_BYREF:
{
V_I1(com) = *V_I1REF(java);
break;
}
}
break;
}
case VT_I1 | VT_BYREF:
{
switch (java->vt)
{
case VT_I1:
{
*V_I1REF(com) = V_I1(java);
break;
}
case VT_I1 | VT_BYREF:
{
*V_I1REF(com) = *V_I1REF(java);
break;
}
}
break;
}
case VT_UI2:
{
switch (java->vt)
{
case VT_UI2:
{
V_UI2(com) = V_UI2(java);
break;
}
case VT_UI2 | VT_BYREF:
{
V_UI2(com) = *V_UI2REF(java);
break;
}
}
break;
}
case VT_UI2 | VT_BYREF:
{
switch (java->vt)
{
case VT_UI2:
{
*V_UI2REF(com) = V_UI2(java);
break;
}
case VT_UI2 | VT_BYREF:
{
*V_UI2REF(com) = *V_UI2REF(java);
break;
}
}
break;
}
case VT_UI4:
{
switch (java->vt)
{
case VT_UI4:
{
V_UI4(com) = V_UI4(java);
break;
}
case VT_UI4 | VT_BYREF:
{
V_UI4(com) = *V_UI4REF(java);
break;
}
}
break;
}
case VT_UI4 | VT_BYREF:
{
switch (java->vt)
{
case VT_UI4:
{
*V_UI4REF(com) = V_UI4(java);
break;
}
case VT_UI4 | VT_BYREF:
{
*V_UI4REF(com) = *V_UI4REF(java);
break;
}
}
break;
}
case VT_INT:
{
switch (java->vt)
{
case VT_INT:
{
V_INT(com) = V_INT(java);
break;
}
case VT_INT | VT_BYREF:
{
V_INT(com) = *V_INTREF(java);
break;
}
}
break;
}
case VT_INT | VT_BYREF:
{
switch (java->vt)
{
case VT_INT:
{
*V_INTREF(com) = V_INT(java);
break;
}
case VT_INT | VT_BYREF:
{
*V_INTREF(com) = *V_INTREF(java);
break;
}
}
break;
}
case VT_UINT:
{
switch (java->vt)
{
case VT_UINT:
{
V_UINT(com) = V_UINT(java);
break;
}
case VT_UINT | VT_BYREF:
{
V_UINT(com) = *V_UINTREF(java);
break;
}
}
break;
}
case VT_UINT | VT_BYREF:
{
switch (java->vt)
{
case VT_UINT:
{
*V_UINTREF(com) = V_UINT(java);
break;
}
case VT_UINT | VT_BYREF:
{
*V_UINTREF(com) = *V_UINTREF(java);
break;
}
}
break;
}
case VT_CY:
{
switch (java->vt)
{
case VT_CY:
{
V_CY(com) = V_CY(java);
break;
}
case VT_CY | VT_BYREF:
{
V_CY(com) = *V_CYREF(java);
break;
}
}
break;
}
case VT_CY | VT_BYREF:
{
switch (java->vt)
{
case VT_CY:
{
*V_CYREF(com) = V_CY(java);
break;
}
case VT_CY | VT_BYREF:
{
*V_CYREF(com) = *V_CYREF(java);
break;
}
}
break;
}
case VT_DATE:
{
switch (java->vt)
{
case VT_DATE:
{
V_DATE(com) = V_DATE(java);
break;
}
case VT_DATE | VT_BYREF:
{
V_DATE(com) = *V_DATEREF(java);
break;
}
}
break;
}
case VT_DATE | VT_BYREF:
{
switch (java->vt)
{
case VT_DATE:
{
*V_DATEREF(com) = V_DATE(java);
break;
}
case VT_DATE | VT_BYREF:
{
*V_DATEREF(com) = *V_DATEREF(java);
break;
}
}
break;
}
case VT_BSTR:
{
switch (java->vt)
{
case VT_BSTR:
{
V_BSTR(com) = V_BSTR(java);
break;
}
case VT_BSTR | VT_BYREF:
{
V_BSTR(com) = *V_BSTRREF(java);
break;
}
}
break;
}
case VT_BSTR | VT_BYREF:
{
switch (java->vt)
{
case VT_BSTR:
{
*V_BSTRREF(com) = V_BSTR(java);
break;
}
case VT_BSTR | VT_BYREF:
{
*V_BSTRREF(com) = *V_BSTRREF(java);
break;
}
}
break;
}
case VT_DECIMAL:
{
switch (java->vt)
{
case VT_DECIMAL:
{
V_DECIMAL(com) = V_DECIMAL(java);
break;
}
case VT_DECIMAL | VT_BYREF:
{
V_DECIMAL(com) = *V_DECIMALREF(java);
break;
}
}
break;
}
case VT_DECIMAL | VT_BYREF:
{
switch (java->vt)
{
case VT_DECIMAL:
{
*V_DECIMALREF(com) = V_DECIMAL(java);
break;
}
case VT_DECIMAL | VT_BYREF:
{
*V_DECIMALREF(com) = *V_DECIMALREF(java);
break;
}
}
break;
}
}
}
STDMETHODIMP CXMLHttpRequest::send(VARIANT varBody)
{
ATLTRACE(_T("CXMLHttpRequest::send\n"));
if (V_VT(&varBody) != VT_BSTR &&
V_VT(&varBody) != VT_DISPATCH &&
V_VT(&varBody) != (VT_ARRAY | VT_VARIANT) &&
V_VT(&varBody) != (VT_ARRAY | VT_UI1) &&
V_VT(&varBody) != VT_UNKNOWN)
return E_INVALIDARG;
// do not start another thread if there is another active
if (NULL != m_hThread) {
DWORD exitCode = 0;
BOOL rc = ::GetExitCodeThread(m_hThread, &exitCode);
if (!rc || STILL_ACTIVE == exitCode)
return E_PENDING;
::CloseHandle(m_hThread);
m_hThread = NULL;
}
HRESULT hr = S_OK;
m_bSuccess = true;
m_bAbort = false;
delete [] m_pBody;
m_pBody = NULL;
m_lBodyLength = 0;
delete [] m_pResponseBody;
m_pResponseBody = NULL;
m_lResponseBodyLength = 0;
m_dwStatus = 0;
m_StatusText = _T("");
m_ResponseHeaders = _T("");
if (V_VT(&varBody) == VT_BSTR) {
_bstr_t body = V_BSTR(&varBody);
m_lBodyLength = body.length() + 1;
m_pBody = new BYTE[m_lBodyLength];
memset(m_pBody,0,m_lBodyLength);
memcpy(m_pBody,static_cast<char*> (body),body.length());
}
else
if (V_VT(&varBody) == VT_UNKNOWN) {
CComQIPtr<IStream,&IID_IStream> pS(V_UNKNOWN(&varBody));
if (!pS)
return E_INVALIDARG;
CComBSTR b;
hr = b.ReadFromStream(pS);
if (S_OK != hr)
return hr;
_bstr_t body = b;
m_lBodyLength = body.length() + 1;
m_pBody = new BYTE[m_lBodyLength];
memset(m_pBody,0,m_lBodyLength);
memcpy(m_pBody,static_cast<char*> (body),body.length());
}
else
if (V_VT(&varBody) == VT_DISPATCH) {
CComQIPtr<IXMLDOMDocument,&IID_IXMLDOMDocument> pDoc(V_DISPATCH(&varBody));
if (!pDoc)
return E_INVALIDARG;
BSTR b = NULL;
hr = pDoc->get_xml(&b);
if (S_OK != hr)
return hr;
_bstr_t body = b;
::SysFreeString(b);
m_lBodyLength = body.length() + 1;
m_pBody = new BYTE[m_lBodyLength];
memset(m_pBody,0,m_lBodyLength);
memcpy(m_pBody,static_cast<char*> (body),body.length());
}
else
if (V_VT(&varBody) == (VT_ARRAY | VT_VARIANT)) {
SAFEARRAY *pArray = reinterpret_cast<SAFEARRAY *> (varBody.byref);
if (NULL == pArray)
return E_INVALIDARG;
long lLBoundVar = 0;
long lUBoundVar = 0;
UINT dims = ::SafeArrayGetDim(pArray);
if (dims == 0)
return E_INVALIDARG;
hr = ::SafeArrayGetLBound(pArray, dims, &lLBoundVar);
if (S_OK != hr)
return hr;
hr = ::SafeArrayGetUBound(pArray, dims, &lUBoundVar);
if (S_OK != hr)
return hr;
if (lUBoundVar >= lLBoundVar) {
VARIANT *pIndex = NULL;
hr = ::SafeArrayAccessData(pArray, reinterpret_cast<void **> (&pIndex));
if (S_OK != hr)
return hr;
m_lBodyLength = lUBoundVar-lLBoundVar+1;
m_pBody = new BYTE[m_lBodyLength];
for (long i = 0; i <= lUBoundVar-lLBoundVar; ++i) {
VARIANT var = pIndex[i];
if (V_VT(&var) != VT_UI1) {
hr = E_INVALIDARG;
break;
}
m_pBody[i] = V_UI1(&var);
}
::SafeArrayUnaccessData(pArray);
if (S_OK != hr) {
delete [] m_pBody;
m_pBody = NULL;
m_lBodyLength = 0;
return hr;
}
}
}
else
if (V_VT(&varBody) == (VT_ARRAY | VT_UI1)) {
SAFEARRAY *pArray = reinterpret_cast<SAFEARRAY *> (varBody.byref);
if (NULL == pArray)
return E_INVALIDARG;
long lLBoundVar = 0;
long lUBoundVar = 0;
UINT dims = ::SafeArrayGetDim(pArray);
if (dims == 0)
return E_INVALIDARG;
hr = ::SafeArrayGetLBound(pArray, dims, &lLBoundVar);
if (S_OK != hr)
return hr;
hr = ::SafeArrayGetUBound(pArray, dims, &lUBoundVar);
if (S_OK != hr)
return hr;
if (lUBoundVar >= lLBoundVar) {
BYTE *pIndex = NULL;
hr = ::SafeArrayAccessData(pArray, reinterpret_cast<void **> (&pIndex));
if (S_OK != hr)
return hr;
m_lBodyLength = lUBoundVar-lLBoundVar+1;
m_pBody = new BYTE[m_lBodyLength];
for (long i = 0; i <= lUBoundVar-lLBoundVar; ++i)
m_pBody[i] = pIndex[i];
::SafeArrayUnaccessData(pArray);
}
}
m_HwndParent = GetParentWindow();
UINT nthreadID = 0;
m_hThread = reinterpret_cast<HANDLE> (_beginthreadex(NULL,
0,
CXMLHttpRequest::SendThread,
(void *) this,
0,
&nthreadID));
if (NULL == m_hThread)
return E_FAIL;
if (m_bAsync)
return S_OK;
bool bWait = true;
while (bWait) {
DWORD dwEvt = MsgWaitForMultipleObjects(1,&m_hThread,FALSE,INFINITE,QS_ALLINPUT);
switch(dwEvt) {
case WAIT_OBJECT_0:
bWait = false;
break;
case WAIT_OBJECT_0 + 1:
{
MSG msg;
while(::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
if (WM_CLOSE == msg.message || WM_QUIT == msg.message) {
bWait = false;
m_bAbort = true;
break;
}
else {
PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
break;
}
default:
m_bAbort = true;
bWait = false;
break;
}
}
return S_OK;
}
static void test_registry(void)
{
static const WCHAR keypathW[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','\\',
'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\','T','e','s','t','\\',0};
static const WCHAR regsz2W[] = {'r','e','g','s','z','2',0};
static const WCHAR regszW[] = {'r','e','g','s','z',0};
static const WCHAR regdwordW[] = {'r','e','g','d','w','o','r','d',0};
static const WCHAR regbinaryW[] = {'r','e','g','b','i','n','a','r','y',0};
static const WCHAR regmultiszW[] = {'r','e','g','m','u','l','t','i','s','z',0};
static const WCHAR regsz1W[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','\\',
'S','o','f','t','w','a','r','e','\\','W','i','n','e','\\','T','e','s','t','\\','r','e','g','s','z','1',0};
static const WCHAR foobarW[] = {'f','o','o','b','a','r',0};
static const WCHAR fooW[] = {'f','o','o',0};
static const WCHAR brokenW[] = {'H','K','E','Y','_','b','r','o','k','e','n','_','k','e','y',0};
static const WCHAR broken2W[] = {'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R','a',0};
WCHAR pathW[MAX_PATH];
DWORD dwvalue, type;
VARIANT value, v;
IWshShell3 *sh3;
VARTYPE vartype;
LONG bound;
HRESULT hr;
BSTR name;
HKEY root;
LONG ret;
UINT dim;
hr = CoCreateInstance(&CLSID_WshShell, NULL, CLSCTX_INPROC_SERVER|CLSCTX_INPROC_HANDLER,
&IID_IWshShell3, (void**)&sh3);
ok(hr == S_OK, "got 0x%08x\n", hr);
/* RegRead() */
V_VT(&value) = VT_I2;
hr = IWshShell3_RegRead(sh3, NULL, &value);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value));
name = SysAllocString(brokenW);
hr = IWshShell3_RegRead(sh3, name, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
V_VT(&value) = VT_I2;
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value));
SysFreeString(name);
name = SysAllocString(broken2W);
V_VT(&value) = VT_I2;
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value));
SysFreeString(name);
ret = RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Test", &root);
ok(ret == 0, "got %d\n", ret);
ret = RegSetValueExA(root, "regsz", 0, REG_SZ, (const BYTE*)"foobar", 7);
ok(ret == 0, "got %d\n", ret);
ret = RegSetValueExA(root, "regsz2", 0, REG_SZ, (const BYTE*)"foobar\0f", 9);
ok(ret == 0, "got %d\n", ret);
ret = RegSetValueExA(root, "regmultisz", 0, REG_MULTI_SZ, (const BYTE*)"foo\0bar\0", 9);
ok(ret == 0, "got %d\n", ret);
dwvalue = 10;
ret = RegSetValueExA(root, "regdword", 0, REG_DWORD, (const BYTE*)&dwvalue, sizeof(dwvalue));
ok(ret == 0, "got %d\n", ret);
dwvalue = 11;
ret = RegSetValueExA(root, "regbinary", 0, REG_BINARY, (const BYTE*)&dwvalue, sizeof(dwvalue));
ok(ret == 0, "got %d\n", ret);
/* REG_SZ */
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regszW);
name = SysAllocString(pathW);
VariantInit(&value);
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
ok(!lstrcmpW(V_BSTR(&value), foobarW), "got %s\n", wine_dbgstr_w(V_BSTR(&value)));
VariantClear(&value);
SysFreeString(name);
/* REG_SZ with embedded NULL */
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regsz2W);
name = SysAllocString(pathW);
VariantInit(&value);
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_BSTR, "got %d\n", V_VT(&value));
ok(SysStringLen(V_BSTR(&value)) == 6, "len %d\n", SysStringLen(V_BSTR(&value)));
VariantClear(&value);
SysFreeString(name);
/* REG_DWORD */
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regdwordW);
name = SysAllocString(pathW);
VariantInit(&value);
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_I4, "got %d\n", V_VT(&value));
ok(V_I4(&value) == 10, "got %d\n", V_I4(&value));
SysFreeString(name);
/* REG_BINARY */
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regbinaryW);
name = SysAllocString(pathW);
VariantInit(&value);
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&value) == (VT_ARRAY|VT_VARIANT), "got 0x%x\n", V_VT(&value));
dim = SafeArrayGetDim(V_ARRAY(&value));
ok(dim == 1, "got %u\n", dim);
hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &bound);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(bound == 0, "got %u\n", bound);
hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &bound);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(bound == 3, "got %u\n", bound);
hr = SafeArrayGetVartype(V_ARRAY(&value), &vartype);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(vartype == VT_VARIANT, "got %d\n", vartype);
bound = 0;
hr = SafeArrayGetElement(V_ARRAY(&value), &bound, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&v) == VT_UI1, "got %d\n", V_VT(&v));
ok(V_UI1(&v) == 11, "got %u\n", V_UI1(&v));
VariantClear(&v);
VariantClear(&value);
SysFreeString(name);
/* REG_MULTI_SZ */
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regmultiszW);
name = SysAllocString(pathW);
VariantInit(&value);
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&value) == (VT_ARRAY|VT_VARIANT), "got 0x%x\n", V_VT(&value));
SysFreeString(name);
dim = SafeArrayGetDim(V_ARRAY(&value));
ok(dim == 1, "got %u\n", dim);
hr = SafeArrayGetLBound(V_ARRAY(&value), 1, &bound);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(bound == 0, "got %u\n", bound);
hr = SafeArrayGetUBound(V_ARRAY(&value), 1, &bound);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(bound == 1, "got %u\n", bound);
hr = SafeArrayGetVartype(V_ARRAY(&value), &vartype);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(vartype == VT_VARIANT, "got %d\n", vartype);
bound = 0;
hr = SafeArrayGetElement(V_ARRAY(&value), &bound, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
ok(V_VT(&v) == VT_BSTR, "got %d\n", V_VT(&v));
ok(!lstrcmpW(V_BSTR(&v), fooW), "got %s\n", wine_dbgstr_w(V_BSTR(&v)));
VariantClear(&v);
VariantClear(&value);
name = SysAllocString(regsz1W);
V_VT(&value) = VT_I2;
hr = IWshShell3_RegRead(sh3, name, &value);
ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr);
ok(V_VT(&value) == VT_I2, "got %d\n", V_VT(&value));
VariantClear(&value);
SysFreeString(name);
delete_key(root);
/* RegWrite() */
ret = RegCreateKeyA(HKEY_CURRENT_USER, "Software\\Wine\\Test", &root);
ok(ret == 0, "got %d\n", ret);
hr = IWshShell3_RegWrite(sh3, NULL, NULL, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
lstrcpyW(pathW, keypathW);
lstrcatW(pathW, regszW);
name = SysAllocString(pathW);
hr = IWshShell3_RegWrite(sh3, name, NULL, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
VariantInit(&value);
hr = IWshShell3_RegWrite(sh3, name, &value, NULL);
ok(hr == E_POINTER, "got 0x%08x\n", hr);
hr = IWshShell3_RegWrite(sh3, name, &value, &value);
ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
/* type is optional */
V_VT(&v) = VT_ERROR;
V_ERROR(&v) = DISP_E_PARAMNOTFOUND;
hr = IWshShell3_RegWrite(sh3, name, &value, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
/* default type is REG_SZ */
V_VT(&value) = VT_I4;
V_I4(&value) = 12;
hr = IWshShell3_RegWrite(sh3, name, &value, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
type = REG_NONE;
ret = RegGetValueA(root, NULL, "regsz", RRF_RT_ANY, &type, NULL, NULL);
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
ok(type == REG_SZ, "got %d\n", type);
ret = RegDeleteValueA(root, "regsz");
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
V_VT(&value) = VT_BSTR;
V_BSTR(&value) = SysAllocString(regszW);
hr = IWshShell3_RegWrite(sh3, name, &value, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
VariantClear(&value);
type = REG_NONE;
ret = RegGetValueA(root, NULL, "regsz", RRF_RT_ANY, &type, NULL, NULL);
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
ok(type == REG_SZ, "got %d\n", type);
ret = RegDeleteValueA(root, "regsz");
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
V_VT(&value) = VT_R4;
V_R4(&value) = 1.2;
hr = IWshShell3_RegWrite(sh3, name, &value, &v);
ok(hr == S_OK, "got 0x%08x\n", hr);
VariantClear(&value);
type = REG_NONE;
ret = RegGetValueA(root, NULL, "regsz", RRF_RT_ANY, &type, NULL, NULL);
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
ok(type == REG_SZ, "got %d\n", type);
ret = RegDeleteValueA(root, "regsz");
ok(ret == ERROR_SUCCESS, "got %d\n", ret);
V_VT(&value) = VT_R4;
V_R4(&value) = 1.2;
V_VT(&v) = VT_I2;
V_I2(&v) = 1;
hr = IWshShell3_RegWrite(sh3, name, &value, &v);
ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
VariantClear(&value);
SysFreeString(name);
delete_key(root);
IWshShell3_Release(sh3);
}
STDAPI
VariantChangeType(
VARIANTARG FAR* pvargDest,
VARIANTARG FAR* pvargSrc,
unsigned short wFlags,
VARTYPE vt)
{
VARIANT varTmp;
HRESULT hresult;
VARTYPE vtSrc;
if (pvargDest == NULL || pvargSrc == NULL)
return(E_INVALIDARG);
vtSrc = V_VT(pvargSrc); // get src vartype
hresult = NOERROR; // assume success
// NOTE: all code after this point must go to LError0 upon Error.
// should have validated the destination type at this point (to ensure
// that the below optimized switch statement will work properly).
switch ( VTSW(vtSrc, vt) )
{
case VTSW(VT_BOOL, VT_BOOL):
case VTSW(VT_I2, VT_I2):
case VTSW(VT_I4, VT_I4):
case VTSW(VT_INT, VT_INT):
case VTSW(VT_I8, VT_I8):
case VTSW(VT_R4, VT_R4):
case VTSW(VT_R8, VT_R8):
case VTSW(VT_CY, VT_CY):
case VTSW(VT_DECIMAL, VT_DECIMAL):
case VTSW(VT_I1, VT_I1):
case VTSW(VT_UI1, VT_UI1):
case VTSW(VT_UI2, VT_UI2):
case VTSW(VT_UI4, VT_UI4):
case VTSW(VT_UINT, VT_UINT):
case VTSW(VT_UI8, VT_UI8):
varTmp = *pvargSrc;
break;
case VTSW(VT_EMPTY, VT_BSTR):
hresult = ErrSysAllocString(OASTR(""), &V_BSTR(&varTmp));
break;
case VTSW(VT_BOOL, VT_BSTR):
//fall through to return "0" or "-1"
case VTSW(VT_I2, VT_BSTR):
hresult = VarBstrFromI2(V_I2(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_I4, VT_BSTR):
case VTSW(VT_INT, VT_BSTR):
hresult = VarBstrFromI4(V_I4(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_I8, VT_BSTR):
hresult = VarBstrFromI8(V_I8(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_R4, VT_BSTR):
hresult = VarBstrFromR4(V_R4(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_R8, VT_BSTR):
hresult = VarBstrFromR8(V_R8(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_CY, VT_BSTR):
hresult = VarBstrFromCy(V_CY(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_DECIMAL, VT_BSTR):
hresult = VarBstrFromDec(&pvargSrc->n1.decVal, LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_I1, VT_BSTR):
hresult = VarBstrFromI1(V_I1(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_UI1, VT_BSTR):
hresult = VarBstrFromUI1(V_UI1(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_UI2, VT_BSTR):
hresult = VarBstrFromUI2(V_UI2(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_UI4, VT_BSTR):
case VTSW(VT_UINT, VT_BSTR):
hresult = VarBstrFromUI4(V_UI4(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_UI8, VT_BSTR):
hresult = VarBstrFromUI8(V_UI8(pvargSrc), LOCALE_USER_DEFAULT, 0, &V_BSTR(&varTmp));
break;
case VTSW(VT_BSTR, VT_BSTR):
hresult = ErrSysAllocString(V_BSTR(pvargSrc), &V_BSTR(&varTmp));
break;
case VTSW(VT_DATE, VT_BSTR):
_ASSERTE(false);
hresult = RESULT(DISP_E_TYPEMISMATCH);
break;
default:
if (vtSrc >= VT_VARIANT) {
IfFailGo(IsLegalVartype(vtSrc), LError0);
}
// everybody else gets a type mis-match error
_ASSERTE(false);
hresult = RESULT(DISP_E_TYPEMISMATCH);
break;
}
if (FAILED(hresult))
{
goto LError0;
}
// now set the tag in temp variant. Errors after this point have to
// goto LError1 to potentially clear this variant.
V_VT(&varTmp) = vt;
// now that we have succeeded, we can go ahead and destroy our
// destination variant.
if (V_VT(pvargDest) >= VT_BSTR) {
IfFailGo(VariantClear(pvargDest), LError1);
}
// copy in the variant we just created
memcpy(pvargDest, &varTmp, sizeof(VARIANT));
return NOERROR;
LError1:;
VariantClear(&varTmp);
// fall through
LError0:;
return hresult;
}
CString CCrack::strVARIANT(const COleVariant& var)
{
CString strRet;
strRet = _T("Fish");
switch(var.vt){
case VT_EMPTY:
case VT_NULL:
strRet = _T("NULL");
break;
case VT_I2:
strRet.Format(_T("%hd"),V_I2(&var));
break;
case VT_I4:
strRet.Format(_T("%d"),V_I4(&var));
break;
case VT_R4:
strRet.Format(_T("%g"),(double)V_R4(&var));
break;
case VT_R8:
strRet.Format(_T("%g"),V_R8(&var));
break;
case VT_CY:
strRet = COleCurrency(var).Format();
break;
case VT_DATE:
strRet = COleDateTime(var).Format(_T("%m %d %y"));
break;
case VT_BSTR:
strRet = V_BSTRT(&var);
break;
case VT_DISPATCH:
strRet = _T("VT_DISPATCH");
break;
case VT_ERROR:
strRet = _T("VT_ERROR");
break;
case VT_BOOL:
return strBOOL(V_BOOL(&var));
case VT_VARIANT:
strRet = _T("VT_VARIANT");
break;
case VT_UNKNOWN:
strRet = _T("VT_UNKNOWN");
break;
case VT_I1:
strRet = _T("VT_I1");
break;
case VT_UI1:
strRet.Format(_T("0x%02hX"),(unsigned short)V_UI1(&var));
break;
case VT_UI2:
strRet = _T("VT_UI2");
break;
case VT_UI4:
strRet = _T("VT_UI4");
break;
case VT_I8:
strRet = _T("VT_I8");
break;
case VT_UI8:
strRet = _T("VT_UI8");
break;
case VT_INT:
strRet = _T("VT_INT");
break;
case VT_UINT:
strRet = _T("VT_UINT");
break;
case VT_VOID:
strRet = _T("VT_VOID");
break;
case VT_HRESULT:
strRet = _T("VT_HRESULT");
break;
case VT_PTR:
strRet = _T("VT_PTR");
break;
case VT_SAFEARRAY:
strRet = _T("VT_SAFEARRAY");
break;
case VT_CARRAY:
strRet = _T("VT_CARRAY");
break;
case VT_USERDEFINED:
strRet = _T("VT_USERDEFINED");
break;
case VT_LPSTR:
strRet = _T("VT_LPSTR");
break;
case VT_LPWSTR:
strRet = _T("VT_LPWSTR");
break;
case VT_FILETIME:
strRet = _T("VT_FILETIME");
break;
case VT_BLOB:
strRet = _T("VT_BLOB");
break;
case VT_STREAM:
strRet = _T("VT_STREAM");
break;
case VT_STORAGE:
strRet = _T("VT_STORAGE");
break;
case VT_STREAMED_OBJECT:
strRet = _T("VT_STREAMED_OBJECT");
break;
case VT_STORED_OBJECT:
strRet = _T("VT_STORED_OBJECT");
break;
case VT_BLOB_OBJECT:
strRet = _T("VT_BLOB_OBJECT");
break;
case VT_CF:
strRet = _T("VT_CF");
break;
case VT_CLSID:
strRet = _T("VT_CLSID");
break;
}
WORD vt = var.vt;
if(vt & VT_ARRAY){
vt = vt & ~VT_ARRAY;
strRet = _T("Array of ");
}
if(vt & VT_BYREF){
vt = vt & ~VT_BYREF;
strRet += _T("Pointer to ");
}
if(vt != var.vt){
switch(vt){
case VT_EMPTY:
strRet += _T("VT_EMPTY");
break;
case VT_NULL:
strRet += _T("VT_NULL");
break;
case VT_I2:
strRet += _T("VT_I2");
break;
case VT_I4:
strRet += _T("VT_I4");
break;
case VT_R4:
strRet += _T("VT_R4");
break;
case VT_R8:
strRet += _T("VT_R8");
break;
case VT_CY:
strRet += _T("VT_CY");
break;
case VT_DATE:
strRet += _T("VT_DATE");
break;
case VT_BSTR:
strRet += _T("VT_BSTR");
break;
case VT_DISPATCH:
strRet += _T("VT_DISPATCH");
break;
case VT_ERROR:
strRet += _T("VT_ERROR");
break;
case VT_BOOL:
strRet += _T("VT_BOOL");
break;
case VT_VARIANT:
strRet += _T("VT_VARIANT");
break;
case VT_UNKNOWN:
strRet += _T("VT_UNKNOWN");
break;
case VT_I1:
strRet += _T("VT_I1");
break;
case VT_UI1:
strRet += _T("VT_UI1");
break;
case VT_UI2:
strRet += _T("VT_UI2");
break;
case VT_UI4:
strRet += _T("VT_UI4");
break;
case VT_I8:
strRet += _T("VT_I8");
break;
case VT_UI8:
strRet += _T("VT_UI8");
break;
case VT_INT:
strRet += _T("VT_INT");
break;
case VT_UINT:
strRet += _T("VT_UINT");
break;
case VT_VOID:
strRet += _T("VT_VOID");
break;
case VT_HRESULT:
strRet += _T("VT_HRESULT");
break;
case VT_PTR:
strRet += _T("VT_PTR");
break;
case VT_SAFEARRAY:
strRet += _T("VT_SAFEARRAY");
break;
case VT_CARRAY:
strRet += _T("VT_CARRAY");
break;
case VT_USERDEFINED:
strRet += _T("VT_USERDEFINED");
break;
case VT_LPSTR:
strRet += _T("VT_LPSTR");
break;
case VT_LPWSTR:
strRet += _T("VT_LPWSTR");
break;
case VT_FILETIME:
strRet += _T("VT_FILETIME");
break;
case VT_BLOB:
strRet += _T("VT_BLOB");
break;
case VT_STREAM:
strRet += _T("VT_STREAM");
break;
case VT_STORAGE:
strRet += _T("VT_STORAGE");
break;
case VT_STREAMED_OBJECT:
strRet += _T("VT_STREAMED_OBJECT");
break;
case VT_STORED_OBJECT:
strRet += _T("VT_STORED_OBJECT");
break;
case VT_BLOB_OBJECT:
strRet += _T("VT_BLOB_OBJECT");
break;
case VT_CF:
strRet += _T("VT_CF");
break;
case VT_CLSID:
strRet += _T("VT_CLSID");
break;
}
}
return strRet;
}
PHP_COM_DOTNET_API int php_com_zval_from_variant(zval *z, VARIANT *v, int codepage TSRMLS_DC)
{
OLECHAR *olestring = NULL;
int ret = SUCCESS;
switch (V_VT(v)) {
case VT_EMPTY:
case VT_NULL:
case VT_VOID:
ZVAL_NULL(z);
break;
case VT_UI1:
ZVAL_LONG(z, (long)V_UI1(v));
break;
case VT_I1:
ZVAL_LONG(z, (long)V_I1(v));
break;
case VT_UI2:
ZVAL_LONG(z, (long)V_UI2(v));
break;
case VT_I2:
ZVAL_LONG(z, (long)V_I2(v));
break;
case VT_UI4: /* TODO: promote to double if large? */
ZVAL_LONG(z, (long)V_UI4(v));
break;
case VT_I4:
ZVAL_LONG(z, (long)V_I4(v));
break;
case VT_INT:
ZVAL_LONG(z, V_INT(v));
break;
case VT_UINT: /* TODO: promote to double if large? */
ZVAL_LONG(z, (long)V_UINT(v));
break;
case VT_R4:
ZVAL_DOUBLE(z, (double)V_R4(v));
break;
case VT_R8:
ZVAL_DOUBLE(z, V_R8(v));
break;
case VT_BOOL:
ZVAL_BOOL(z, V_BOOL(v) ? 1 : 0);
break;
case VT_BSTR:
olestring = V_BSTR(v);
if (olestring) {
Z_TYPE_P(z) = IS_STRING;
Z_STRVAL_P(z) = php_com_olestring_to_string(olestring,
&Z_STRLEN_P(z), codepage TSRMLS_CC);
olestring = NULL;
}
break;
case VT_UNKNOWN:
if (V_UNKNOWN(v) != NULL) {
IDispatch *disp;
if (SUCCEEDED(IUnknown_QueryInterface(V_UNKNOWN(v), &IID_IDispatch, &disp))) {
php_com_wrap_dispatch(z, disp, codepage TSRMLS_CC);
IDispatch_Release(disp);
} else {
ret = FAILURE;
}
}
break;
case VT_DISPATCH:
if (V_DISPATCH(v) != NULL) {
php_com_wrap_dispatch(z, V_DISPATCH(v), codepage TSRMLS_CC);
}
break;
case VT_VARIANT:
/* points to another variant */
return php_com_zval_from_variant(z, V_VARIANTREF(v), codepage TSRMLS_CC);
default:
php_com_wrap_variant(z, v, codepage TSRMLS_CC);
}
if (olestring) {
efree(olestring);
}
if (ret == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "variant->zval: conversion from 0x%x ret=%d", V_VT(v), ret);
}
return ret;
}
static void
ole_set_byref(VARIANT *realvar, VARIANT *var, VARTYPE vt)
{
V_VT(var) = vt;
if (vt == (VT_VARIANT|VT_BYREF)) {
V_VARIANTREF(var) = realvar;
} else {
if (V_VT(realvar) != (vt & ~VT_BYREF)) {
rb_raise(eWIN32OLERuntimeError, "variant type mismatch");
}
switch(vt & ~VT_BYREF) {
case VT_I1:
V_I1REF(var) = &V_I1(realvar);
break;
case VT_UI1:
V_UI1REF(var) = &V_UI1(realvar);
break;
case VT_I2:
V_I2REF(var) = &V_I2(realvar);
break;
case VT_UI2:
V_UI2REF(var) = &V_UI2(realvar);
break;
case VT_I4:
V_I4REF(var) = &V_I4(realvar);
break;
case VT_UI4:
V_UI4REF(var) = &V_UI4(realvar);
break;
case VT_R4:
V_R4REF(var) = &V_R4(realvar);
break;
case VT_R8:
V_R8REF(var) = &V_R8(realvar);
break;
#if (_MSC_VER >= 1300) || defined(__CYGWIN__) || defined(__MINGW32__)
#ifdef V_I8REF
case VT_I8:
V_I8REF(var) = &V_I8(realvar);
break;
#endif
#ifdef V_UI8REF
case VT_UI8:
V_UI8REF(var) = &V_UI8(realvar);
break;
#endif
#endif
case VT_INT:
V_INTREF(var) = &V_INT(realvar);
break;
case VT_UINT:
V_UINTREF(var) = &V_UINT(realvar);
break;
case VT_CY:
V_CYREF(var) = &V_CY(realvar);
break;
case VT_DATE:
V_DATEREF(var) = &V_DATE(realvar);
break;
case VT_BSTR:
V_BSTRREF(var) = &V_BSTR(realvar);
break;
case VT_DISPATCH:
V_DISPATCHREF(var) = &V_DISPATCH(realvar);
break;
case VT_ERROR:
V_ERRORREF(var) = &V_ERROR(realvar);
break;
case VT_BOOL:
V_BOOLREF(var) = &V_BOOL(realvar);
break;
case VT_UNKNOWN:
V_UNKNOWNREF(var) = &V_UNKNOWN(realvar);
break;
case VT_ARRAY:
V_ARRAYREF(var) = &V_ARRAY(realvar);
break;
default:
rb_raise(eWIN32OLERuntimeError, "unknown type specified(setting BYREF):%d", vt);
break;
}
}
}
bool
variant_as_string( DEBUGHELPER *pH, const VARIANT &var, std::string *ret )
{
if (var.vt & VT_VECTOR) return false;
if (var.vt & VT_RESERVED) return false;
if (var.vt & VT_ARRAY)
return safearray_as_string( pH, reinterpret_cast<DWORDLONG>(var.parray), ret);
if (var.vt & VT_BYREF)
{
// Construct a fake variant with the byref-value in it.
VARTYPE vt = var.vt & ~VT_BYREF;
long size = vartype_len(vt);
VARIANT var2;
var2.vt = vt;
long source=reinterpret_cast<long>(var.byref);
void *dest;
if( vt == VT_VARIANT)
dest = &var2;
else
{
var2.vt=vt;
dest = &(var2.bVal);
}
if(!ReadMem(pH,source, size, dest)) return false;
std::string retval;
if( ! variant_as_string( pH, var2, &retval)) return false;
retval += "]";
*ret = "[" + retval;
return true;
}
std::ostringstream os;
switch (var.vt & VT_TYPEMASK )
{
case VT_I2: os << V_I2(&var); break;
case VT_I4: os << V_I4(&var); break;
//case VT_I8: os << V_I8(&var); break;
case VT_R4: os << V_R4(&var); break;
case VT_R8: os << V_R8(&var); break;
case VT_UNKNOWN:
case VT_DISPATCH: os << "0x" << std::hex << (long )V_DISPATCH(&var); break;
case VT_BOOL: os << (V_BOOL(&var)==VARIANT_FALSE?"False":"True"); break;
case VT_I1: os << "'" << V_I1(&var) << "'" ; break;
case VT_UI1: os << "'" << V_UI1(&var) << "'" ; break;
case VT_UI2: os << V_UI2(&var); break;
case VT_UI4: os << V_UI4(&var); break;
case VT_INT: os << V_INT(&var); break;
case VT_UINT: os << V_UINT(&var); break;
case VT_ERROR: os << "error"; break;
case VT_CY: os << (((double)(V_CY(&var).int64))/10000.); break;
case VT_DATE: return date_as_string(V_DATE(&var), ret); break;
case VT_BSTR:
{
long pBSTR = reinterpret_cast<long>( V_BSTR(&var) );
// if (!ReadMem(pH, reinterpret_cast<DWORDLONG>( V_BSTR(&var) ), &pBSTR)) return false;
std::string ret;
if (!bstr_as_string( pH, pBSTR , &ret )) return false;
os << ret;
}break;
case VT_EMPTY: os << '@'; break;
case VT_NULL: os << "null"; break;
break;
default:
return false;
}
*ret = os.str();
return true;
}
LPCTSTR COcsWmi::strCimValue(VARIANT &pVal, CIMTYPE &pType)
{
COleDateTime pOleDate;
static CString csResult;
if ((pVal.vt == VT_NULL) || (pVal.vt == VT_EMPTY))
csResult.Empty();
else
switch (pType)
{
case CIM_ILLEGAL:
csResult = _T( "CIM_ILLEGAL");
break;
case CIM_EMPTY:
csResult = _T( "");
break;
case CIM_SINT8:
csResult.Format(_T( "%hd"),V_I1(&pVal));
break;
case CIM_UINT8:
csResult.Format(_T( "%hu"),V_UI1(&pVal));
break;
case CIM_SINT16:
csResult.Format(_T( "%d"),V_I2(&pVal));
break;
case CIM_UINT16:
csResult.Format(_T( "%u"),V_UI2(&pVal));
break;
case CIM_SINT32:
csResult.Format(_T( "%ld"),V_I4(&pVal));
break;
case CIM_UINT32:
csResult.Format(_T( "%lu"),V_UI4(&pVal));
break;
case CIM_SINT64:
csResult = V_BSTR(&pVal);
break;
case CIM_UINT64:
csResult = V_BSTR(&pVal);
break;
case CIM_REAL32:
csResult.Format(_T( "%e"),V_R4(&pVal));
break;
case CIM_REAL64:
csResult.Format(_T( "%le"),V_R8(&pVal));
break;
case CIM_BOOLEAN:
csResult = (V_BOOL(&pVal) ? _T("TRUE") : _T("FALSE"));
break;
case CIM_STRING:
csResult = V_BSTR(&pVal);
break;
case CIM_DATETIME:
pOleDate = COleDateTime( pVal);
if (pOleDate.GetStatus() == COleDateTime::valid)
csResult = pOleDate.Format( VAR_DATEVALUEONLY);
else
csResult = V_BSTR( &pVal);
break;
case CIM_REFERENCE:
csResult = V_BSTR( &pVal);
break;
case CIM_CHAR16:
csResult = V_BSTR(&pVal);
break;
case CIM_OBJECT:
csResult = _T( "CIM_OBJECT");
break;
default:
csResult = strVariantArray( pVal);
break;
}
return csResult;
}
int ipmi_cmdraw_ms(uchar cmd, uchar netfn, uchar lun, uchar sa,
uchar bus, uchar *pdata, int sdata, uchar *presp, int *sresp,
uchar *pcc, char fdebugcmd)
{
int bRet;
HRESULT hres;
IWbemClassObject* pInParams = NULL; /*class definition*/
IWbemClassObject* pInReq = NULL; /*instance*/
IWbemClassObject* pOutResp = NULL;
VARIANT varCmd, varNetfn, varLun, varSa, varSize, varData;
SAFEARRAY* psa = NULL;
long i;
uchar *p;
fdebugms = fdebugcmd;
if (!fmsopen) {
bRet = ipmi_open_ms(fdebugcmd);
if (bRet != 0) return(bRet);
}
bRet = -1;
hres = pClass->GetMethod(L"RequestResponse",0,&pInParams,NULL);
if (FAILED(hres)) {
if (fdebugcmd)
printf("ipmi_cmdraw_ms: Cannot get RequestResponse method\n");
return (bRet);
}
#ifdef WDM_FIXED
/* see http://support.microsoft.com/kb/951242 for WDM bug info */
hres = pInParams->SpawnInstance(0,&pInReq);
if (FAILED(hres)) {
if (fdebugcmd)
printf("ipmi_cmdraw_ms: Cannot get RequestResponse instance\n");
return (bRet);
}
// also substitute pInReq for pInParams below if this gets fixed.
#endif
VariantInit(&varCmd);
varCmd.vt = VT_UI1;
varCmd.bVal = cmd;
hres = pInParams->Put(_bstr_t(L"Command"), 0, &varCmd, 0);
// VariantClear(&varCmd);
if (FAILED(hres)) goto MSRET;
VariantInit(&varNetfn);
varNetfn.vt = VT_UI1;
varNetfn.bVal = netfn;
hres = pInParams->Put(_bstr_t(L"NetworkFunction"), 0, &varNetfn, 0);
// VariantClear(&varNetfn);
if (FAILED(hres)) goto MSRET;
VariantInit(&varLun);
varLun.vt = VT_UI1;
varLun.bVal = lun;
hres = pInParams->Put(_bstr_t(L"Lun"), 0, &varLun, 0);
// VariantClear(&varLun);
if (FAILED(hres)) goto MSRET;
VariantInit(&varSa);
varSa.vt = VT_UI1;
varSa.bVal = sa;
hres = pInParams->Put(_bstr_t(L"ResponderAddress"), 0, &varSa, 0);
// VariantClear(&varSa);
if (FAILED(hres)) goto MSRET;
VariantInit(&varSize);
varSize.vt = VT_I4;
varSize.lVal = sdata;
hres = pInParams->Put(_bstr_t(L"RequestDataSize"), 0, &varSize, 0);
// VariantClear(&varSize);
if (FAILED(hres)) goto MSRET;
SAFEARRAYBOUND rgsabound[1];
rgsabound[0].cElements = sdata;
rgsabound[0].lLbound = 0;
psa = SafeArrayCreate(VT_UI1,1,rgsabound);
if(!psa) {
printf("ipmi_cmdraw_ms: SafeArrayCreate failed\n");
goto MSRET;
}
#ifdef SHOULD_WORK_BUT_NO
/* The SafeArrayPutElement does not put the data in the right
* place, so skip this and copy the raw data below. */
VARIANT tvar;
if (fdebugcmd && sdata > 0)
{ printf("psa1(%p):",psa); dumpbuf((uchar *)psa,42,1); }
for(i =0; i< sdata; i++)
{
VariantInit(&tvar);
tvar.vt = VT_UI1;
tvar.bVal = pdata[i];
hres = SafeArrayPutElement(psa, &i, &tvar);
// VariantClear(&tvar);
if (FAILED(hres)) {
printf("ipmi_cmdraw_ms: SafeArrayPutElement(%d) failed\n",i);
goto MSRET;
}
} /*end for*/
if (fdebugcmd && sdata > 0)
{ printf("psa2(%p):",psa); dumpbuf((uchar *)psa,42,1); }
#endif
/* Copy the real RequestData into psa */
memcpy(psa->pvData,pdata,sdata);
VariantInit(&varData);
varData.vt = VT_ARRAY | VT_UI1;
varData.parray = psa;
hres = pInParams->Put(_bstr_t(L"RequestData"), 0, &varData, 0);
// VariantClear(&varData);
if (FAILED(hres)) {
printf("Put(RequestData) error %x\n",hres);
goto MSRET;
}
#ifdef TEST_METHODS
IWbemClassObject* pOutSms = NULL;
if (fdebugcmd) printf("ipmi_cmdraw_ms: calling SMS_Attention(%ls)\n",
V_BSTR(&varPath));
hres = pSvc->ExecMethod( V_BSTR(&varPath), _bstr_t(L"SMS_Attention"),
0, NULL, NULL, &pOutSms, NULL);
if (FAILED(hres)) {
printf("ipmi_cmdraw_ms: SMS_Attention method error %x\n",hres);
goto MSRET;
}
if (fdebugcmd) printf("ipmi_cmdraw_ms: SMS_Attention method ok\n");
/* This does work, without input parameters */
pOutSms->Release();
#endif
hres = pSvc->ExecMethod( V_BSTR(&varPath), _bstr_t(L"RequestResponse"),
0, NULL, pInParams, &pOutResp, NULL);
if (fdebugcmd) {
printf("ipmi_cmdraw_ms(cmd=%x,netfn=%x,lun=%x,sa=%x,sdata=%d)"
" RequestResponse ret=%x\n", cmd,netfn,lun,sa,sdata,hres);
if (sdata > 0) {
printf("ipmi_cmdraw_ms: req data(%d):",sdata);
dumpbuf(pdata,sdata,0);
}
}
if (FAILED(hres)) {
printf("ipmi_cmdraw_ms: RequestResponse error %x %s\n",
hres,res_str(hres));
#ifdef EXTRA_DESC
/* This does not usually add any meaning for IPMI. */
BSTR desc;
IErrorInfo *pIErrorInfo;
GetErrorInfo(0,&pIErrorInfo);
pIErrorInfo->GetDescription(&desc);
printf("ipmi_cmdraw_ms: ErrorInfoDescr: %ls\n",desc);
SysFreeString(desc);
#endif
bRet = -1;
/*fall through for cleanup and return*/
}
else { /*successful, get ccode and response data */
VARIANT varByte, varRSz, varRData;
VariantInit(&varByte);
VariantInit(&varRSz);
VariantInit(&varRData);
long rlen;
hres = pOutResp->Get(_bstr_t(L"CompletionCode"),0, &varByte, NULL, 0);
if (FAILED(hres)) goto MSRET;
if (fdebugcmd) printf("ipmi_cmdraw_ms: CompletionCode %x returned\n",
V_UI1(&varByte) );
*pcc = V_UI1(&varByte);
hres = pOutResp->Get(_bstr_t(L"ResponseDataSize"),0, &varRSz, NULL, 0);
if (FAILED(hres)) goto MSRET;
rlen = V_I4(&varRSz);
if (rlen > 1) rlen--; /*skip cc*/
if (rlen > *sresp) {
if (fdebugcmd) printf("ResponseData truncated from %d to %d\n",
rlen,*sresp);
rlen = *sresp; /*truncate*/
}
*sresp = (int)rlen;
hres = pOutResp->Get(_bstr_t(L"ResponseData"),0, &varRData, NULL,0);
if (FAILED(hres)) { /*ignore failure */
if (fdebugcmd) printf("Get ResponseData error %x\n",hres);
} else { /* success */
#ifdef SHOULD_WORK_BUT_NO
uchar *pa;
p = (uchar*)varRData.parray->pvData;
pa = (uchar*)varRData.parray;
printf("pa=%p, pa+12=%p p=%p\n",pa,(pa+12),p);
if (fdebugcmd) {
printf("Data.vt = %04x, Data.parray(%p):",
varRData.vt, varRData.parray);
// 0x2011 means VT_ARRAY | VT_UI1
dumpbuf((uchar *)varRData.parray,40,1);
}
/* The SafeArrayGetElement does not get the data from the right
* place, so skip this and copy the raw data below. */
VARIANT rgvar[NVAR];
if (rlen > NVAR) *pcc = 0xEE;
for (i = 0; i <= rlen; i++)
VariantInit(&rgvar[i]);
/* copy the response data from varRData to presp */
for( i = 0; i <= rlen; i++)
{
hres = SafeArrayGetElement(varRData.parray, &i, &rgvar[i]);
if (FAILED(hres)) {
if (fdebugcmd)
printf("ipmi_cmdraw_ms: SafeArrayGetElement(%d) failed\n",i);
break;
}
if (fdebugcmd) {
printf("Data[%d] vt=%02x val=%02x, rgvar(%p):",i,
rgvar[i].vt, V_UI1(&rgvar[i]),&rgvar[i]);
dumpbuf((uchar *)&rgvar[i],12,0);
}
/* skip the completion code */
// if (i > 0) presp[i-1] = V_UI1(&rgvar[i]);
} /*end for*/
#endif
/*
* parray from a GetDeviceId response:
* 0015CEE0: 01 00 80 00 01 00 00 00 00 00 00 00 00 cf 15 00
* 0015CEF0: 10 00 00 00 00 00 00 00 03 00 06 00 95 01 08 00
* ^- datalen=0x10
* 0015CF00: 00 20 01 00 19 02 9f 57 01 ...
* ^- start of data (cc=00, ...)
*/
/* Copy the real ResponseData into presp. */
p = (uchar*)varRData.parray->pvData;
for( i = 0; i <= rlen; i++) {
/* skip the completion code */
if (i > 0) presp[i-1] = p[i];
}
if (fdebugcmd) {
printf("ipmi_cmdraw_ms: resp data(%d):",rlen+1);
dumpbuf(p,rlen+1,0);
}
}
bRet = 0;
}
MSRET:
#define CLEAN_OK 1
#ifdef CLEAN_OK
/* VariantClear(&var*) should be done by pInParams->Release() */
if (psa != NULL) SafeArrayDestroy(psa);
if (pInParams != NULL) pInParams->Release();
if (pOutResp != NULL) pOutResp->Release();
#endif
return(bRet);
}
////////////////////////////////////////////////////////
// CompareVariant
//
////////////////////////////////////////////////////////
LONG CompareVariant
(
VARIANT *pVar1, //@parm [in]: Pointer to the variant in the consumer's buffer.
VARIANT *pVar2, //@parm [in]: Pointer to the variant at the backend.
BOOL fCaseSensitive
)
{
//Handle NULL cases...
if(pVar1==NULL || pVar2==NULL)
{
if(pVar1 == pVar2)
return TRUE;
return FALSE;
}
// The variant has to be the same type
if (V_VT(pVar1) != V_VT(pVar2))
return FALSE;
// Return FALSE if vt is ORed with VT_RESERVED
if (V_VT(pVar1) & VT_RESERVED)
return FALSE;
// Return TRUE is the vt is VT_EMPTY or VT_NULL
if (V_VT(pVar1)==VT_EMPTY || V_VT(pVar1)==VT_NULL)
return TRUE;
switch(V_VT(pVar1))
{
case VT_UI1:
return V_UI1(pVar1) == V_UI1(pVar2);
case VT_I2:
return V_I2(pVar1) == V_I2(pVar2);
case VT_I4:
return V_I4(pVar1) == V_I4(pVar2);
case VT_R4:
return V_R4(pVar1) == V_R4(pVar2);
case VT_R8:
return V_R8(pVar1) == V_R8(pVar2);
case VT_BOOL:
return V_BOOL(pVar1) == V_BOOL(pVar2);
case VT_ERROR:
return V_ERROR(pVar1) == V_ERROR(pVar2);
case VT_CY:
return memcmp(&V_CY(pVar1), &V_CY(pVar2),8)==0;
case VT_DATE:
return V_DATE(pVar1) == V_DATE(pVar2);
case VT_BSTR:
if(fCaseSensitive)
return wcscmp(V_BSTR(pVar1), V_BSTR(pVar2));
else
return _wcsicmp(V_BSTR(pVar1), V_BSTR(pVar2));
// As we are not testing OLE object, return FALSE for VT_UNKNOWN
case VT_UNKNOWN:
return FALSE;
// As we are not testing OLE object, return FALSE for VT_DISPATCH
case VT_DISPATCH:
return FALSE;
case VT_I2 | VT_BYREF:
return *V_I2REF(pVar1) == *V_I2REF(pVar2);
case VT_I4 | VT_BYREF:
return *V_I4REF(pVar1) == *V_I4REF(pVar2);
case VT_R4 | VT_BYREF:
return *V_R4REF(pVar1) == *V_R4REF(pVar2);
case VT_R8 | VT_BYREF:
return *V_R8REF(pVar1) == *V_R8REF(pVar2);
case VT_BOOL | VT_BYREF:
return *V_BOOLREF(pVar1) == *V_BOOLREF(pVar2);
case VT_ERROR | VT_BYREF:
return *V_ERRORREF(pVar1) == *V_ERRORREF(pVar2);
case VT_CY | VT_BYREF:
return memcmp(V_CYREF(pVar1), V_CYREF(pVar2),8)==0;
case VT_DATE | VT_BYREF:
return *V_DATEREF(pVar1) == *V_DATEREF(pVar2);
case VT_BSTR | VT_BYREF:
if(fCaseSensitive)
return wcscmp(*V_BSTRREF(pVar1), *V_BSTRREF(pVar2));
else
return _wcsicmp(*V_BSTRREF(pVar1), *V_BSTRREF(pVar2));
// As we are not testing OLE object, return FALSE for VT_UNKNOWN
case VT_UNKNOWN | VT_BYREF:
return FALSE;
// As we are not testing OLE object, return FALSE for VT_DISPATCH
case VT_DISPATCH | VT_BYREF:
return FALSE;
}
return FALSE;
}
PHP_COM_DOTNET_API int php_com_copy_variant(VARIANT *dstvar, VARIANT *srcvar)
{
int ret = SUCCESS;
switch (V_VT(dstvar) & ~VT_BYREF) {
case VT_EMPTY:
case VT_NULL:
case VT_VOID:
/* should not be possible */
break;
case VT_UI1:
if (V_VT(dstvar) & VT_BYREF) {
*V_UI1REF(dstvar) = V_UI1(srcvar);
} else {
V_UI1(dstvar) = V_UI1(srcvar);
}
break;
case VT_I1:
if (V_VT(dstvar) & VT_BYREF) {
*V_I1REF(dstvar) = V_I1(srcvar);
} else {
V_I1(dstvar) = V_I1(srcvar);
}
break;
case VT_UI2:
if (V_VT(dstvar) & VT_BYREF) {
*V_UI2REF(dstvar) = V_UI2(srcvar);
} else {
V_UI2(dstvar) = V_UI2(srcvar);
}
break;
case VT_I2:
if (V_VT(dstvar) & VT_BYREF) {
*V_I2REF(dstvar) = V_I2(srcvar);
} else {
V_I2(dstvar) = V_I2(srcvar);
}
break;
case VT_UI4:
if (V_VT(dstvar) & VT_BYREF) {
*V_UI4REF(dstvar) = V_UI4(srcvar);
} else {
V_UI4(dstvar) = V_UI4(srcvar);
}
break;
case VT_I4:
if (V_VT(dstvar) & VT_BYREF) {
*V_I4REF(dstvar) = V_I4(srcvar);
} else {
V_I4(dstvar) = V_I4(srcvar);
}
break;
#if SIZEOF_ZEND_LONG == 8
case VT_UI8:
if (V_VT(dstvar) & VT_BYREF) {
*V_UI8REF(dstvar) = V_UI8(srcvar);
} else {
V_UI8(dstvar) = V_UI8(srcvar);
}
break;
case VT_I8:
if (V_VT(dstvar) & VT_BYREF) {
*V_I8REF(dstvar) = V_I8(srcvar);
} else {
V_I8(dstvar) = V_I8(srcvar);
}
break;
#endif
case VT_INT:
if (V_VT(dstvar) & VT_BYREF) {
*V_INTREF(dstvar) = V_INT(srcvar);
} else {
V_INT(dstvar) = V_INT(srcvar);
}
break;
case VT_UINT:
if (V_VT(dstvar) & VT_BYREF) {
*V_UINTREF(dstvar) = V_UINT(srcvar);
} else {
V_UINT(dstvar) = V_UINT(srcvar);
}
break;
case VT_R4:
if (V_VT(dstvar) & VT_BYREF) {
*V_R4REF(dstvar) = V_R4(srcvar);
} else {
V_R4(dstvar) = V_R4(srcvar);
}
break;
case VT_R8:
if (V_VT(dstvar) & VT_BYREF) {
*V_R8REF(dstvar) = V_R8(srcvar);
} else {
V_R8(dstvar) = V_R8(srcvar);
}
break;
case VT_BOOL:
if (V_VT(dstvar) & VT_BYREF) {
*V_BOOLREF(dstvar) = V_BOOL(srcvar);
} else {
V_BOOL(dstvar) = V_BOOL(srcvar);
}
break;
case VT_BSTR:
if (V_VT(dstvar) & VT_BYREF) {
*V_BSTRREF(dstvar) = V_BSTR(srcvar);
} else {
V_BSTR(dstvar) = V_BSTR(srcvar);
}
break;
case VT_UNKNOWN:
if (V_VT(dstvar) & VT_BYREF) {
*V_UNKNOWNREF(dstvar) = V_UNKNOWN(srcvar);
} else {
V_UNKNOWN(dstvar) = V_UNKNOWN(srcvar);
}
break;
case VT_DISPATCH:
if (V_VT(dstvar) & VT_BYREF) {
*V_DISPATCHREF(dstvar) = V_DISPATCH(srcvar);
} else {
V_DISPATCH(dstvar) = V_DISPATCH(srcvar);
}
break;
case VT_VARIANT:
return php_com_copy_variant(V_VARIANTREF(dstvar), srcvar);
default:
php_error_docref(NULL, E_WARNING, "variant->variant: failed to copy from 0x%x to 0x%x", V_VT(dstvar), V_VT(srcvar));
ret = FAILURE;
}
return ret;
}
PHP_COM_DOTNET_API int php_com_zval_from_variant(zval *z, VARIANT *v, int codepage)
{
OLECHAR *olestring = NULL;
int ret = SUCCESS;
switch (V_VT(v)) {
case VT_EMPTY:
case VT_NULL:
case VT_VOID:
ZVAL_NULL(z);
break;
case VT_UI1:
ZVAL_LONG(z, (zend_long)V_UI1(v));
break;
case VT_I1:
ZVAL_LONG(z, (zend_long)V_I1(v));
break;
case VT_UI2:
ZVAL_LONG(z, (zend_long)V_UI2(v));
break;
case VT_I2:
ZVAL_LONG(z, (zend_long)V_I2(v));
break;
case VT_UI4: /* TODO: promote to double if large? */
ZVAL_LONG(z, (long)V_UI4(v));
break;
case VT_I4:
ZVAL_LONG(z, (long)V_I4(v));
break;
#if SIZEOF_ZEND_LONG == 8
case VT_UI8:
ZVAL_LONG(z, (zend_long)V_UI8(v));
break;
case VT_I8:
ZVAL_LONG(z, (zend_long)V_I8(v));
break;
#endif
case VT_INT:
ZVAL_LONG(z, V_INT(v));
break;
case VT_UINT: /* TODO: promote to double if large? */
ZVAL_LONG(z, (zend_long)V_UINT(v));
break;
case VT_R4:
ZVAL_DOUBLE(z, (double)V_R4(v));
break;
case VT_R8:
ZVAL_DOUBLE(z, V_R8(v));
break;
case VT_BOOL:
ZVAL_BOOL(z, V_BOOL(v) ? 1 : 0);
break;
case VT_BSTR:
olestring = V_BSTR(v);
if (olestring) {
size_t len;
char *str = php_com_olestring_to_string(olestring,
&len, codepage);
ZVAL_STRINGL(z, str, len);
// TODO: avoid reallocation???
efree(str);
olestring = NULL;
}
break;
case VT_UNKNOWN:
if (V_UNKNOWN(v) != NULL) {
IDispatch *disp;
if (SUCCEEDED(IUnknown_QueryInterface(V_UNKNOWN(v), &IID_IDispatch, &disp))) {
php_com_wrap_dispatch(z, disp, codepage);
IDispatch_Release(disp);
} else {
ret = FAILURE;
}
}
break;
case VT_DISPATCH:
if (V_DISPATCH(v) != NULL) {
php_com_wrap_dispatch(z, V_DISPATCH(v), codepage);
}
break;
case VT_VARIANT:
/* points to another variant */
return php_com_zval_from_variant(z, V_VARIANTREF(v), codepage);
default:
php_com_wrap_variant(z, v, codepage);
}
if (olestring) {
efree(olestring);
}
if (ret == FAILURE) {
php_error_docref(NULL, E_WARNING, "variant->zval: conversion from 0x%x ret=%d", V_VT(v), ret);
}
return ret;
}
unsigned __int64 COcsWmi::u64CimValue(VARIANT &pVal, CIMTYPE &pType)
{
CString csResult;
if ((pVal.vt == VT_NULL) || (pVal.vt == VT_EMPTY))
return 0;
else
switch (pType)
{
case CIM_SINT8:
return V_I1(&pVal);
case CIM_UINT8:
return V_UI1(&pVal);
case CIM_SINT16:
return V_I2(&pVal);
case CIM_UINT16:
return V_UI2(&pVal);
case CIM_SINT32:
return V_I4(&pVal);
case CIM_UINT32:
return V_UI4(&pVal);
case CIM_SINT64:
csResult = V_BSTR(&pVal);
return _ttoi64( csResult);
case CIM_UINT64:
csResult = V_BSTR(&pVal);
return _ttoi64( csResult);
case CIM_BOOLEAN:
return (V_BOOL(&pVal) ? 1 : 0);
default:
return 0;
}
}
LPCTSTR COcsWmi::strVariant( VARIANT pVal)
{
static CString strRet;
strRet = _T( "N/A");
switch(pVal.vt){
case VT_EMPTY:
case VT_NULL:
strRet = _T( "");
break;
case VT_I1:
strRet.Format(_T( "%hd"),V_I2(&pVal));
break;
case VT_I2:
strRet.Format(_T( "%d"),V_I2(&pVal));
break;
case VT_I4:
strRet.Format(_T( "%ld"),V_I4(&pVal));
break;
case VT_I8:
strRet.Format(_T( "%I64d"), V_I8(&pVal));
break;
case VT_UI1:
strRet.Format(_T( "%hu"),V_UI1(&pVal));
break;
case VT_UI2:
strRet.Format(_T( "%u"),V_UI2(&pVal));
break;
case VT_UI4:
strRet.Format(_T( "%lu"),V_UI4(&pVal));
break;
case VT_UI8:
strRet.Format(_T( "%I64u"),V_UI8(&pVal));
break;
case VT_INT:
strRet.Format(_T( "%d"),V_INT(&pVal));
break;
case VT_UINT:
strRet.Format(_T( "%u"),V_UINT(&pVal));
break;
case VT_R4:
strRet.Format(_T( "%e"),V_R4(&pVal));
break;
case VT_R8:
strRet.Format(_T( "%le"),V_R8(&pVal));
break;
case VT_CY:
strRet = COleCurrency(pVal).Format();
break;
case VT_DATE:
strRet = COleDateTime(pVal).Format( VAR_DATEVALUEONLY);
break;
case VT_BSTR:
strRet = V_BSTRT(&pVal);
break;
case VT_DISPATCH:
strRet = _T( "VT_DISPATCH");
break;
case VT_ERROR:
strRet = _T( "VT_ERROR");
break;
case VT_BOOL:
return (V_BOOL(&pVal) ? _T("TRUE") : _T("FALSE"));
case VT_VARIANT:
strRet = _T( "VT_VARIANT");
break;
case VT_UNKNOWN:
strRet = _T( "VT_UNKNOWN");
break;
case VT_VOID:
strRet = _T( "VT_VOID");
break;
case VT_HRESULT:
strRet = _T( "VT_HRESULT");
break;
case VT_PTR:
strRet = _T( "VT_PTR");
break;
case VT_SAFEARRAY:
strRet = _T( "VT_SAFEARRAY");
break;
case VT_CARRAY:
strRet = _T( "VT_CARRAY");
break;
case VT_USERDEFINED:
strRet = _T( "VT_USERDEFINED");
break;
case VT_LPSTR:
strRet = _T( "VT_LPSTR");
break;
case VT_LPWSTR:
strRet = _T( "VT_LPWSTR");
break;
case VT_FILETIME:
strRet = _T( "VT_FILETIME");
break;
case VT_BLOB:
strRet = _T( "VT_BLOB");
break;
case VT_STREAM:
strRet = _T( "VT_STREAM");
break;
case VT_STORAGE:
strRet = _T( "VT_STORAGE");
break;
case VT_STREAMED_OBJECT:
strRet = _T( "VT_STREAMED_OBJECT");
break;
case VT_STORED_OBJECT:
strRet = _T( "VT_STORED_OBJECT");
break;
case VT_BLOB_OBJECT:
strRet = _T( "VT_BLOB_OBJECT");
break;
case VT_CF:
strRet = _T( "VT_CF");
break;
case VT_CLSID:
strRet = _T( "VT_CLSID");
break;
}
return strRet;
}
STDMETHODIMP CXMLDOMDocument::load(VARIANT xmlSource, VARIANT_BOOL *isSuccessful)
{
ATLTRACE(_T("CXMLDOMDocument::load\n"));
if (NULL == isSuccessful)
return E_POINTER;
*isSuccessful = VARIANT_FALSE;
if (V_VT(&xmlSource) != VT_BSTR &&
V_VT(&xmlSource) != VT_DISPATCH &&
V_VT(&xmlSource) != (VT_ARRAY | VT_VARIANT) &&
V_VT(&xmlSource) != (VT_ARRAY | VT_UI1) &&
V_VT(&xmlSource) != VT_UNKNOWN)
return E_INVALIDARG;
// do not start another thread if there is another active
if (NULL != m_hParseThread) {
DWORD exitCode = 0;
BOOL rc = ::GetExitCodeThread(m_hParseThread, &exitCode);
if (!rc || STILL_ACTIVE == exitCode)
return S_OK;
::CloseHandle(m_hParseThread);
m_hParseThread = NULL;
}
HRESULT hr = S_OK;
m_bAbort = false;
m_FileName = _T("");
m_xml = _T("");
m_TmpDocument = 0;
m_bThreadValidate = m_bValidate;
if (V_VT(&xmlSource) == VT_BSTR) {
m_FileName = V_BSTR(&xmlSource);
if (0 == m_FileName.length())
return E_INVALIDARG;
// see if the file is relative path
if (!PathIsURL(m_FileName) && PathIsRelative(m_FileName)) {
// try appending baseurl if exists
_bstr_t baseURL;
if (S_OK == GetBaseURL(baseURL)) {
TCHAR szCurFile[MAX_PATH];
_tcscpy(szCurFile, m_FileName);
// change any backslashes to slashes
LPTSTR loc = _tcschr(szCurFile,_T('\\'));
while (loc != NULL) {
*loc = _T('/');
loc = _tcschr(szCurFile,_T('\\'));
}
m_FileName = baseURL + _T("/") + szCurFile;
}
else {
TCHAR szCurDir[MAX_PATH];
GetCurrentDirectory(MAX_PATH,szCurDir);
m_FileName=_bstr_t(szCurDir) + _T("\\") + m_FileName;
}
}
}
else
if (V_VT(&xmlSource) == VT_UNKNOWN) {
CComQIPtr<IStream,&IID_IStream> pS(V_UNKNOWN(&xmlSource));
if (!pS)
return E_INVALIDARG;
CComBSTR b;
hr = b.ReadFromStream(pS);
if (S_OK != hr)
return hr;
m_xml = b;
if (0 == m_xml.length())
return E_INVALIDARG;
}
else
if (V_VT(&xmlSource) == VT_DISPATCH) {
CComQIPtr<IXMLDOMDocument,&IID_IXMLDOMDocument> pDoc(V_DISPATCH(&xmlSource));
if (!pDoc)
return E_INVALIDARG;
BSTR b = NULL;
hr = pDoc->get_xml(&b);
if (S_OK != hr)
return hr;
m_xml = b;
::SysFreeString(b);
if (0 == m_xml.length())
return E_INVALIDARG;
}
else
if (V_VT(&xmlSource) == (VT_ARRAY | VT_VARIANT)) {
SAFEARRAY *pArray = reinterpret_cast<SAFEARRAY *> (xmlSource.byref);
if (NULL == pArray)
return E_INVALIDARG;
long lLBoundVar = 0;
long lUBoundVar = 0;
UINT dims = ::SafeArrayGetDim(pArray);
if (dims == 0)
return E_INVALIDARG;
hr = ::SafeArrayGetLBound(pArray, dims, &lLBoundVar);
if (S_OK != hr)
return hr;
hr = ::SafeArrayGetUBound(pArray, dims, &lUBoundVar);
if (S_OK != hr)
return hr;
if (lUBoundVar >= lLBoundVar) {
VARIANT *pIndex = NULL;
hr = ::SafeArrayAccessData(pArray, reinterpret_cast<void **> (&pIndex));
if (S_OK != hr)
return hr;
int length = lUBoundVar-lLBoundVar+2;
BYTE *body = new BYTE[length];
for (long i = 0; i <= lUBoundVar-lLBoundVar; ++i) {
VARIANT var = pIndex[i];
if (V_VT(&var) != VT_UI1) {
hr = E_INVALIDARG;
break;
}
body[i] = V_UI1(&var);
}
body[length-1] = 0;
::SafeArrayUnaccessData(pArray);
if (S_OK != hr) {
delete [] body;
return hr;
}
m_xml = reinterpret_cast<char*> (body);
delete [] body;
if (0 == m_xml.length())
return E_INVALIDARG;
}
}
else
if (V_VT(&xmlSource) == (VT_ARRAY | VT_UI1)) {
SAFEARRAY *pArray = reinterpret_cast<SAFEARRAY *> (xmlSource.byref);
if (NULL == pArray)
return E_INVALIDARG;
long lLBoundVar = 0;
long lUBoundVar = 0;
UINT dims = ::SafeArrayGetDim(pArray);
if (dims == 0)
return E_INVALIDARG;
hr = ::SafeArrayGetLBound(pArray, dims, &lLBoundVar);
if (S_OK != hr)
return hr;
hr = ::SafeArrayGetUBound(pArray, dims, &lUBoundVar);
if (S_OK != hr)
return hr;
if (lUBoundVar >= lLBoundVar) {
BYTE *pIndex = NULL;
hr = ::SafeArrayAccessData(pArray, reinterpret_cast<void **> (&pIndex));
if (S_OK != hr)
return hr;
int length = lUBoundVar-lLBoundVar+2;
BYTE *body = new BYTE[length];
for (long i = 0; i <= lUBoundVar-lLBoundVar; ++i)
body[i] = pIndex[i];
body[length-1] = 0;
::SafeArrayUnaccessData(pArray);
m_xml = reinterpret_cast<char*> (body);
delete [] body;
if (0 == m_xml.length())
return E_INVALIDARG;
}
}
UINT nthreadID = 0;
m_hParseThread = reinterpret_cast<HANDLE> (_beginthreadex(NULL,
0,
CXMLDOMDocument::ParseThread,
(void *) this,
0,
&nthreadID));
if (NULL == m_hParseThread)
return S_OK;
if (m_bAsync) {
*isSuccessful = VARIANT_TRUE;
return S_OK;
}
bool bWait = true;
while (bWait) {
DWORD dwEvt = MsgWaitForMultipleObjects(1,&m_hParseThread,FALSE,INFINITE,QS_ALLINPUT);
switch(dwEvt) {
case WAIT_OBJECT_0:
bWait = false;
break;
case WAIT_OBJECT_0 + 1:
{
MSG msg;
while(::PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
if (WM_CLOSE == msg.message || WM_QUIT == msg.message) {
bWait = false;
m_bAbort = true;
break;
}
else {
PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
break;
}
default:
m_bAbort = true;
bWait = false;
break;
}
}
if (m_bAbort)
return S_OK;
if (m_bParseError)
return hr;
if(m_Document)
delete m_Document;
m_Document = m_TmpDocument;
m_TmpDocument = 0;
m_url = m_FileName;
*isSuccessful = VARIANT_TRUE;
return hr;
}
HRESULT CTCPropBagOnRegKey::_WriteSafeArray(CRegKey& key,
const _bstr_t& strPropName, VARIANT* pVar)
{
ASSERT(V_ISARRAY(pVar));
ASSERT(lstrlen(strPropName));
// Get the SAFEARRAY pointer from the variant
SAFEARRAY* psa = V_ARRAY(pVar);
if (IsBadReadPtr(psa))
return E_POINTER;
// Only support 1-dimensional arrays (currently)
if (1 != SafeArrayGetDim(psa))
return E_INVALIDARG;
// Get the element size of the safe array
UINT cbElement = SafeArrayGetElemsize(psa);
// Get the safe array type from the variant
VARTYPE vt = V_VT(pVar) & ~VT_ARRAY;
// Check for supported types and validate the element size
switch (vt)
{
case VT_BOOL:
if (sizeof(V_BOOL(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_I1:
if (sizeof(V_I1(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_I2:
if (sizeof(V_I2(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_I4:
if (sizeof(V_I4(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_UI1:
if (sizeof(V_UI1(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_UI2:
if (sizeof(V_UI2(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_UI4:
if (sizeof(V_UI4(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_ERROR:
if (sizeof(V_ERROR(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_R4:
if (sizeof(V_R4(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_R8:
if (sizeof(V_R8(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_DECIMAL:
if (sizeof(V_DECIMAL(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_CY:
if (sizeof(V_CY(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_DATE:
if (sizeof(V_DATE(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_BSTR:
if (sizeof(V_BSTR(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_UNKNOWN:
if (sizeof(V_UNKNOWN(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_DISPATCH:
if (sizeof(V_DISPATCH(pVar)) != cbElement)
return E_UNEXPECTED;
break;
case VT_VARIANT:
if (sizeof(V_VARIANTREF(pVar)) != cbElement)
return E_UNEXPECTED;
break;
default:
return E_UNEXPECTED;
}
// Get the upper and lower bounds of the safe array
HRESULT hr;
LONG lUBound = 0, lLBound = 0;
if (FAILED(hr = SafeArrayGetUBound(psa, 1, &lUBound)))
return hr;
if (FAILED(hr = SafeArrayGetLBound(psa, 1, &lLBound)))
return hr;
UINT nElements = lUBound - lLBound + 1;
// Create a subkey with the specified name
key.DeleteValue(strPropName);
key.RecurseDeleteKey(strPropName);
CRegKey subkey;
if (!subkey.Open(key, strPropName))
return HRESULT_FROM_WIN32(GetLastError());
// Get access to the safe array data
BYTE* pElement = NULL;
if (FAILED(hr = SafeArrayAccessData(psa, (void**)&pElement)))
return hr;
// Write the variant type value
subkey.WriteDWord(m_szVariantType, DWORD(V_VT(pVar)));
// Write the element count value
subkey.WriteDWord(m_szElementCount, DWORD(nElements));
// Write the lower bound value, if not 0
if (lLBound)
subkey.WriteDWord(m_szLowerBound, DWORD(lLBound));
// Special handling for arrays of variants
_bstr_t strText;
if (VT_VARIANT == vt)
{
// Write each variant array element to the registry
for (UINT i = 0; i < nElements; i++, pElement += cbElement)
{
// Format the value name
strText.Format(m_szElementFmt, i);
// Write the variant array element to the registry subkey
if (FAILED(hr = WriteVariant(subkey, strText, (VARIANT*)pElement)))
{
TRACE1("CTCPropBagOnRegKey::_WriteSafeArray(\"%s\", pVar): ",
strPropName);
TRACE2("WriteVariant(subkey, \"%s\", &var) returned 0x%08X\n",
strText, hr);
}
}
}
else
{
// Write each array element to the registry
VARIANT var;
V_VT(&var) = vt;
for (UINT i = 0; i < nElements; i++, pElement += cbElement)
{
// Copy the array element to the data portion of the VARIANT
memcpy(&V_NONE(&var), pElement, cbElement);
// Format the value name
strText.Format(m_szElementFmt, i);
// Write the variant to the registry subkey
if (FAILED(hr = WriteVariant(subkey, strText, &var)))
{
TRACE1("CTCPropBagOnRegKey::_WriteSafeArray(\"%s\", pVar): ",
strPropName);
TRACE2("WriteVariant(subkey, \"%s\", &var) returned 0x%08X\n",
strText, hr);
}
}
}
// Release access to the safe array data
VERIFY(SUCCEEDED(SafeArrayUnaccessData(psa)));
// Indicate success
return S_OK;
}
