/*++
Copyright (C) 1995-2001 Microsoft Corporation
Module Name:
CVARIANT.CPP
Abstract:
Defines the CVarinat class which is a purpose object to
wrap VARIANT structures.
History:
a-davj 4-27-95 Created.
--*/
#include "precomp.h"
#include "impdyn.h"
#include "cvariant.h"
//#include <afxpriv.h>
BSTR SysAllocBstrFromTCHAR(TCHAR * pFrom)
{
#ifdef UNICODE
return SysAllocString(pFrom);
#else
WCHAR * pTemp = new WCHAR[lstrlen(pFrom)+1];
if(pTemp == NULL)
return NULL;
mbstowcs(pTemp, pFrom, lstrlen(pFrom)+1);
BSTR bRet = SysAllocString(pTemp);
delete pTemp;
return bRet;
#endif
}
//***************************************************************************
//
// int CVariant::CalcNumStrings
//
// DESCRIPTION:
//
// Calculates the number of strings
//
// PARAMETERS:
//
// pTest points to string to test
//
// RETURN VALUE:
// Return - the number of strings in a multistring block.
//
//***************************************************************************
int CVariant::CalcNumStrings(
IN TCHAR *pTest)
{
int iRet = 0;
if(pTest == NULL)
return 0;
while(*pTest)
{
iRet++;
pTest += lstrlen(pTest)+1;
}
return iRet;
}
//***************************************************************************
//
// CVariant::ChangeType
//
// DESCRIPTION:
//
// Changes the CVariant data into a new type.
//
// PARAMETERS:
//
// vtNew Type to convert to
//
// RETURN VALUE:
//
// S_OK if alright, otherwise an error set by OMSVariantChangeType
//
//***************************************************************************
SCODE CVariant::ChangeType(
IN VARTYPE vtNew)
{
SCODE sc;
// if type doesnt need changing, then already done!
if(vtNew == var.vt)
return S_OK;
// Create and initialize a temp VARIANT
VARIANTARG vTemp;
VariantInit(&vTemp);
// Change to the desired type. Then delete the current value
// and copy the temp copy
sc = OMSVariantChangeType(&vTemp,&var,0,vtNew);
OMSVariantClear(&var);
var = vTemp; // structure copy
return sc;
}
//***************************************************************************
//
// CVariant::Clear
//
// DESCRIPTION:
//
// Clears out the VARIANT.
//
//***************************************************************************
void CVariant::Clear(void)
{
OMSVariantClear(&var);
}
//***************************************************************************
//
// CVariant::
// CVariant::~CVariant
//
// DESCRIPTION:
//
// Constructor and destructor.
//
//***************************************************************************
CVariant::CVariant()
{
VariantInit(&var);
memset((void *)&var.lVal,0,8);
}
CVariant::CVariant(LPWSTR pwcStr)
{
VariantInit(&var);
if(pwcStr)
{
var.bstrVal = SysAllocString(pwcStr);
if(var.bstrVal)
var.vt = VT_BSTR;
}
}
CVariant::~CVariant()
{
OMSVariantClear(&var);
}
//***************************************************************************
//
// SCODE CVariant::DoPut
//
// DESCRIPTION:
//
// "Puts" the data out to the WBEM server (if pClassInt isnt NULL), or just
// copies the data to the variant.
//
// PARAMETERS:
//
// lFlags flags to pass along to wbem server
// pClassInt pointer to class/instance object
// PropName property name
// pVar variant value
//
// RETURN VALUE:
//
// S_OK if no error other wise see wbemsvc error codes when, pClass isnt
// null, or see the OMSVariantChangeType function.
//
//***************************************************************************
SCODE CVariant::DoPut(
IN long lFlags,
IN IWbemClassObject FAR * pClassInt,
IN BSTR PropName,
IN CVariant * pVar)
{
SCODE sc;
if(pClassInt)
{
sc = pClassInt->Put(PropName,lFlags,&var,0);
}
else if(pVar)
{
pVar->Clear();
sc = OMSVariantChangeType(&pVar->var,&var,0,var.vt);
}
else sc = WBEM_E_FAILED;
return sc;
}
//***************************************************************************
//
// SCODE CVariant::GetArrayData
//
// DESCRIPTION:
//
// Converts array data into a single data block. This is used by the
// registry provider when it writes out array data.
//
// PARAMETERS:
//
// ppData pointer to the return data. Note it is the job of the
// caller to free this when the return code is S_OK
// pdwSize Size of returned data
//
// RETURN VALUE:
//
// S_OK if all is well
// WBEM_E_OUT_OF_MEMORY when we memory allocation fails
// WBEM_E_FAILED when variant has bogus type.
// ??? when failure is in SafeArrayGetElement
//
//***************************************************************************
SCODE CVariant::GetArrayData(
OUT void ** ppData,
OUT DWORD * pdwSize)
{
SCODE sc;
DWORD dwSoFar = 0;
SAFEARRAY * psa;
long ix[2] = {0,0};
BYTE * pb;
TCHAR * ptc;
BOOL bString = ((var.vt & ~VT_ARRAY) == CHARTYPE ||(var.vt & ~VT_ARRAY) == VT_BSTR );
int iNumElements = GetNumElements();
int iSizeOfType = iTypeSize(var.vt);
if(iSizeOfType < 1)
return WBEM_E_FAILED;
// Calculate necessary size;
psa = var.parray;
if(bString) {
*pdwSize = CHARSIZE; // 1 for the final double null!
for(ix[0] = 0; ix[0] < iNumElements; ix[0]++) {
BSTR bstr;
sc = SafeArrayGetElement(psa,ix,&bstr);
if(FAILED(sc))
return sc;
#ifdef UNICODE
*pdwSize += 2 * (wcslen(bstr) +1);
#else
int iWCSLen = wcslen(bstr) + 1;
*pdwSize += wcstombs(NULL,bstr,iWCSLen) + 1;
#endif
SysFreeString(bstr);
}
}
else {
*pdwSize = iNumElements * iSizeOfType;
}
// Allocate the memory to be filled
*ppData = CoTaskMemAlloc(*pdwSize);
if(*ppData == NULL)
return WBEM_E_OUT_OF_MEMORY;
pb = (BYTE *)*ppData;
ptc = (TCHAR *)*ppData;
// loop for each array element
sc = S_OK;
for(ix[0] = 0; ix[0] < iNumElements && sc == S_OK; ix[0]++) {
if (bString) {
BSTR bstr;
sc = SafeArrayGetElement(psa,ix,&bstr);
if(sc != S_OK)
break;
DWORD dwBytesLeft = *pdwSize-dwSoFar;
#ifdef UNICODE
lstrcpyn(ptc,bstr,dwBytesLeft/2);
#else
wcstombs(ptc,bstr,dwBytesLeft);
#endif
dwSoFar += CHARSIZE * (lstrlen(ptc) + 1);
ptc += lstrlen(ptc) + 1;
SysFreeString(bstr);
*ptc = 0; // double null
}
else {
sc = SafeArrayGetElement(psa,ix,pb);
pb += iSizeOfType;
}
}
if(sc != S_OK)
CoTaskMemFree(*ppData);
return S_OK;
}
//***************************************************************************
//
// SCODE CVariant::GetData
//
// DESCRIPTION:
//
// Used by the registry provider to take the data from VARIANT arg format
// into a raw block for output. Note that the data allocated and stuck into
// *ppData should be freed using CoTaskMemFree!
//
// PARAMETERS:
//
// ppData Pointer to output data.
// dwRegType Type to convert to
// pdwSize Pointer to size of returned data
//
// RETURN VALUE:
//
// S_OK if all is well, otherwise a error code which is set by either
// OMSVariantChangeType, or GetArrayData.
//
//***************************************************************************
SCODE CVariant::GetData(
OUT void ** ppData,
IN DWORD dwRegType,
OUT DWORD * pdwSize)
{
SCODE sc = S_OK;
// Determine the type it may need to be converted to. Note that binary
// data is not converted intentionally.
switch(dwRegType) {
case REG_DWORD:
sc = ChangeType(VT_I4);
break;
case REG_SZ:
sc = ChangeType(VT_BSTR);
break;
case REG_MULTI_SZ:
sc = ChangeType(VT_BSTR | VT_ARRAY);
break;
default:
break;
}
if(sc != S_OK)
return sc;
// Special case for arrays
if(dwRegType == REG_BINARY || dwRegType == REG_MULTI_SZ)
return GetArrayData(ppData, pdwSize);
// Allocate some memory and move the data into it.
if(dwRegType == REG_SZ) {
#ifdef UNICODE
*pdwSize = 2 * (wcslen(var.bstrVal)+1);
*ppData = CoTaskMemAlloc(*pdwSize);
if(*ppData == NULL)
return WBEM_E_OUT_OF_MEMORY;
lstrcpyW((WCHAR *)*ppData,var.bstrVal);
#else
*ppData = WideToNarrow(var.bstrVal);
if(*ppData == NULL)
return WBEM_E_OUT_OF_MEMORY;
*pdwSize = lstrlenA((char *)*ppData)+1;
#endif
}
else {
*pdwSize = iTypeSize(var.vt);
*ppData = CoTaskMemAlloc(*pdwSize);
if(*ppData == NULL)
return WBEM_E_OUT_OF_MEMORY;
memcpy(*ppData,(void *)&var.lVal,*pdwSize);
}
return S_OK;
}
//***************************************************************************
//
// CVariant::GetNumElements
//
// DESCRIPTION:
//
// Gets the number of elements in an array.
//
// RETURN VALUE:
//
// number of elements. Scalers return a 1.
//
//***************************************************************************
DWORD CVariant::GetNumElements(void)
{
SCODE sc;
if(!IsArray())
return 1;
SAFEARRAY * psa = var.parray;
long uLower, uUpper;
sc = SafeArrayGetLBound(psa,1,&uLower);
sc |= SafeArrayGetUBound(psa,1,&uUpper);
if(sc != S_OK)
return 0;
else
return uUpper - uLower +1;
}
//***************************************************************************
//
// SCODE CVariant::SetArrayData
//
// DESCRIPTION:
//
// Sets the CVariant value using raw data. Used by the reg provider.
//
// PARAMETERS:
//
// pData pointer to data to set
// vtSimple Type to set the data to
// iSize size of data pointed to by pData
//
// RETURN VALUE:
//
// S_OK if OK.
// WBEM_E_INVALID_PARAMETER if the arguments are bad
// WBEM_E_OUT_OF_MEMORY if out of memory
// other wise error from SafeArrayPutElement
//
//***************************************************************************
SCODE CVariant::SetArrayData(
IN void * pData,
IN VARTYPE vtSimple,
IN int iSize)
{
SCODE sc;
int iNumElements;
BYTE * pNext;
long ix[2] = {0,0};
DWORD dwLeftOver = 0;
int iSizeOfType = iTypeSize(vtSimple);
if(pData == NULL || iSizeOfType < 1 || iSize < 1)
return WBEM_E_INVALID_PARAMETER;
// Calculate the number of elements and make sure it is a type that
// is supported
if(vtSimple == VT_BSTR) {
iNumElements = CalcNumStrings((TCHAR *)pData);
}
else {
iNumElements = iSize / iSizeOfType;
dwLeftOver = iSize % iSizeOfType;
}
// Allocate array
int iNumCreate = (dwLeftOver) ? iNumElements + 1 : iNumElements;
SAFEARRAY * psa = OMSSafeArrayCreate(vtSimple,iNumCreate);
if(psa == NULL)
return WBEM_E_FAILED;
// Set each element of the array
for(ix[0] = 0, pNext = (BYTE *)pData; ix[0] < iNumElements; ix[0]++) {
if(vtSimple == VT_BSTR) {
BSTR bstr;
bstr = SysAllocBstrFromTCHAR((LPTSTR)pNext);
if(bstr == NULL) { // todo, free previously allocated strings!
SafeArrayDestroy(psa);
return WBEM_E_OUT_OF_MEMORY;
}
sc = SafeArrayPutElement(psa,ix,(void*)bstr);
pNext += sizeof(TCHAR)*(lstrlen((TCHAR *)pNext) + 1);
SysFreeString(bstr);
}
else {
sc = SafeArrayPutElement(psa,ix,pNext);
pNext += iSizeOfType;
}
if(sc) { // todo, cleanup???
SafeArrayDestroy(psa);
return sc;
}
}
// it is possible that the number of bytes being set doesnt evenly factor
// into the type size. For instance, there may be 10 bytes of registry
// data being put into a DWORD array. In this case, the last two bytes
// are left overs
if(dwLeftOver) {
__int64 iTemp = 0;
memcpy((void *)&iTemp,(void *)pNext,dwLeftOver);
sc = SafeArrayPutElement(psa,ix,&iTemp);
}
var.vt = vtSimple | VT_ARRAY;
var.parray = psa;
return S_OK;
}
//***************************************************************************
//
// CVariant::SetData
//
// Sets the CVariant value using raw data. Used by the reg provider.
//
// DESCRIPTION:
//
// PARAMETERS:
//
// pData Data to be set
// vtChangeTo Type to change the data to
// iSize size of data pointed to by pData
//
// RETURN VALUE:
//
// S_OK if OK.
// WBEM_E_INVALID_PARAMETER if the arguments are bad
// WBEM_E_OUT_OF_MEMORY if out of memory
// other wise error from SafeArrayPutElement
//
//***************************************************************************
SCODE CVariant::SetData(
IN void * pData,
IN VARTYPE vtChangeTo,
IN int iSize)
{
int iToSize = iTypeSize(vtChangeTo);
// check arguments and clear the variant
if(pData == NULL || iToSize < 1)
return WBEM_E_INVALID_PARAMETER;
OMSVariantClear(&var);
if(iSize < 1)
iSize = iToSize;
// Special case for arrays!
if(vtChangeTo & VT_ARRAY)
return SetArrayData(pData,vtChangeTo & ~VT_ARRAY,iSize);
if(vtChangeTo == CIM_SINT64 || vtChangeTo == CIM_UINT64)
{
// int64 and uint64 need to be converted to strings
WCHAR wcTemp[50];
__int64 iLong;
memcpy((void *)&iLong, pData, 8);
if(vtChangeTo == CIM_SINT64)
swprintf(wcTemp,L"%I64d", iLong);
else
swprintf(wcTemp,L"%I64u", iLong);
var.bstrVal = SysAllocString(wcTemp);
if(var.bstrVal == NULL)
return WBEM_E_OUT_OF_MEMORY;
var.vt = VT_BSTR;
}
else if(vtChangeTo == VT_BSTR)
{
// All strings are stored as BSTRS
var.bstrVal = SysAllocBstrFromTCHAR((LPTSTR)pData);
if(var.bstrVal == NULL)
return WBEM_E_OUT_OF_MEMORY;
var.vt = VT_BSTR;
}
else
{
memcpy((void *)&var.lVal,pData,iToSize);
var.vt = vtChangeTo;
}
return S_OK;
}