You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
942 lines
30 KiB
942 lines
30 KiB
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 1996.
|
|
//
|
|
// File: utils.cxx
|
|
//
|
|
// Contents: Utility classes/functions for property implementation.
|
|
//
|
|
// Classes: CPropSetName -- wraps buffer and conversion of fmtids
|
|
// CStackBuffer -- utility class that allows a small number
|
|
// of items be on stack, but more be on heap.
|
|
//
|
|
// Functions: PropVariantClear
|
|
// FreePropVariantArray
|
|
// AllocAndCopy
|
|
// PropVariantCopy
|
|
// PropSysAllocString
|
|
// PropSysFreeString
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include "pch.cxx"
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CPropSetName::CPropSetName
|
|
//
|
|
// Synopsis: Initialize internal buffer with converted FMTID
|
|
//
|
|
// Arguments: [rfmtid] -- FMTID to convert
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
CPropSetName::CPropSetName(REFFMTID rfmtid)
|
|
{
|
|
RtlGuidToPropertySetName(&rfmtid, _oszName);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Member: CStackBuffer::Init
|
|
//
|
|
// Synopsis: Determine whether the class derived from this one
|
|
// needs to have additional buffer allocated on the
|
|
// heap and allocate it if neccessary. Otherwise, if
|
|
// there is space, use the internal buffer in the
|
|
// derived class.
|
|
//
|
|
// Arguments: [cElements] -- the number of elements required.
|
|
//
|
|
// Returns: S_OK if buffer available
|
|
// STG_E_INSUFFICIENTMEMORY if stack buffer was not
|
|
// big enough AND heap allocation failed.
|
|
//
|
|
// Notes: To be called directly by client after the derived
|
|
// classes constructor initialized CStackBuffer.
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
HRESULT CStackBuffer::Init(ULONG cElements)
|
|
{
|
|
if (cElements > _cStackElements)
|
|
{
|
|
_pbHeapBuf = new BYTE[cElements * _cbElementSize];
|
|
if (_pbHeapBuf == NULL)
|
|
{
|
|
return(STG_E_INSUFFICIENTMEMORY);
|
|
}
|
|
}
|
|
return(S_OK);
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: PropVariantClear
|
|
//
|
|
// Synopsis: Deallocates the members of the PROPVARIANT that require
|
|
// deallocation.
|
|
//
|
|
// Arguments: [pvarg] - variant to clear
|
|
//
|
|
// Returns: S_OK if successful,
|
|
// STG_E_INVALIDPARAMETER if any part of the variant has
|
|
// an unknown vt type. (In this case, ALL the elements
|
|
// that can be freed, will be freed.)
|
|
//
|
|
// Modifies: [pvarg] - the variant is left with vt = VT_EMPTY
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
STDAPI PropVariantClear(PROPVARIANT *pvarg)
|
|
{
|
|
|
|
ULONG l;
|
|
HRESULT hr = S_OK;
|
|
|
|
if (pvarg == NULL)
|
|
return(hr);
|
|
|
|
switch (pvarg->vt)
|
|
{
|
|
case VT_EMPTY:
|
|
case VT_NULL:
|
|
case VT_ILLEGAL:
|
|
|
|
#ifdef PROPVAR_VT_I1
|
|
case VT_I1:
|
|
#endif
|
|
case VT_UI1:
|
|
case VT_I2:
|
|
case VT_UI2:
|
|
case VT_I4:
|
|
case VT_UI4:
|
|
case VT_I8:
|
|
case VT_UI8:
|
|
case VT_R4:
|
|
case VT_R8:
|
|
case VT_CY:
|
|
case VT_DATE:
|
|
break;
|
|
|
|
case VT_BSTR:
|
|
if (pvarg->bstrVal != NULL)
|
|
PropSysFreeString( pvarg->bstrVal );
|
|
break;
|
|
|
|
case VT_BOOL:
|
|
case VT_ERROR:
|
|
case VT_FILETIME:
|
|
break;
|
|
|
|
case VT_LPSTR:
|
|
case VT_LPWSTR:
|
|
case VT_CLSID:
|
|
PROPASSERT((void**)&pvarg->pszVal == (void**)&pvarg->pwszVal);
|
|
PROPASSERT((void**)&pvarg->pszVal == (void**)&pvarg->puuid);
|
|
CoTaskMemFree(pvarg->pszVal); // ptr at 0
|
|
break;
|
|
|
|
case VT_CF:
|
|
if (pvarg->pclipdata != NULL)
|
|
{
|
|
CoTaskMemFree(pvarg->pclipdata->pClipData); // ptr at 8
|
|
CoTaskMemFree(pvarg->pclipdata);
|
|
}
|
|
break;
|
|
|
|
case VT_BLOB:
|
|
case VT_BLOB_OBJECT:
|
|
CoTaskMemFree(pvarg->blob.pBlobData); //ptr at 4
|
|
break;
|
|
|
|
#ifdef PROPVAR_VT_I1
|
|
case (VT_VECTOR | VT_I1):
|
|
#endif
|
|
case (VT_VECTOR | VT_UI1):
|
|
case (VT_VECTOR | VT_I2):
|
|
case (VT_VECTOR | VT_UI2):
|
|
case (VT_VECTOR | VT_I4):
|
|
case (VT_VECTOR | VT_UI4):
|
|
case (VT_VECTOR | VT_I8):
|
|
case (VT_VECTOR | VT_UI8):
|
|
case (VT_VECTOR | VT_R4):
|
|
case (VT_VECTOR | VT_R8):
|
|
case (VT_VECTOR | VT_CY):
|
|
case (VT_VECTOR | VT_DATE):
|
|
|
|
FreeArray:
|
|
PROPASSERT((void**)&pvarg->caub.pElems == (void**)&pvarg->cai.pElems);
|
|
CoTaskMemFree(pvarg->caub.pElems);
|
|
break;
|
|
|
|
case (VT_VECTOR | VT_BSTR):
|
|
if (pvarg->cabstr.pElems != NULL)
|
|
{
|
|
for (l=0; l< pvarg->cabstr.cElems; l++)
|
|
{
|
|
if (pvarg->cabstr.pElems[l] != NULL)
|
|
{
|
|
PropSysFreeString( pvarg->cabstr.pElems[l] );
|
|
}
|
|
}
|
|
}
|
|
goto FreeArray;
|
|
|
|
case (VT_VECTOR | VT_BOOL):
|
|
case (VT_VECTOR | VT_ERROR):
|
|
goto FreeArray;
|
|
|
|
case (VT_VECTOR | VT_LPSTR):
|
|
case (VT_VECTOR | VT_LPWSTR):
|
|
if (pvarg->calpstr.pElems != NULL)
|
|
for (l=0; l< pvarg->calpstr.cElems; l++)
|
|
{
|
|
CoTaskMemFree(pvarg->calpstr.pElems[l]);
|
|
}
|
|
goto FreeArray;
|
|
|
|
case (VT_VECTOR | VT_FILETIME):
|
|
case (VT_VECTOR | VT_CLSID):
|
|
goto FreeArray;
|
|
|
|
case (VT_VECTOR | VT_CF):
|
|
if (pvarg->caclipdata.pElems != NULL)
|
|
for (l=0; l< pvarg->caclipdata.cElems; l++)
|
|
{
|
|
CoTaskMemFree(pvarg->caclipdata.pElems[l].pClipData);
|
|
}
|
|
goto FreeArray;
|
|
|
|
case (VT_VECTOR | VT_VARIANT):
|
|
if (pvarg->capropvar.pElems != NULL)
|
|
hr = FreePropVariantArray(pvarg->capropvar.cElems, pvarg->capropvar.pElems);
|
|
goto FreeArray;
|
|
|
|
default:
|
|
hr = STG_E_INVALIDPARAMETER;
|
|
break;
|
|
}
|
|
|
|
// We have all of the important information about the variant, so
|
|
// let's clear it out.
|
|
//
|
|
PropVariantInit(pvarg);
|
|
|
|
return (hr);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: FreePropVariantArray, public
|
|
//
|
|
// Synopsis: Frees a value array returned from ReadMultiple
|
|
//
|
|
// Arguments: [cval] - Number of elements
|
|
// [rgvar] - Array
|
|
//
|
|
// Returns: S_OK if all types recognised and all freeable items were freed.
|
|
// STG_E_INVALID_PARAMETER if one or more types were not
|
|
// recognised but all items are freed too.
|
|
//
|
|
// Notes: Even if a vt-type is not understood, all the ones that are
|
|
// understood are freed. The error code will indicate
|
|
// if *any* of the members were illegal types.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI FreePropVariantArray (
|
|
ULONG cVariants,
|
|
PROPVARIANT *rgvars)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (rgvars != NULL)
|
|
for ( ULONG I=0; I < cVariants; I++ )
|
|
if (STG_E_INVALIDPARAMETER == PropVariantClear ( rgvars + I ))
|
|
hr = STG_E_INVALIDPARAMETER;
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Function: AllocAndCopy
|
|
//
|
|
// Synopsis: Allocates enough memory to copy the passed data into and
|
|
// then copies the data into the new buffer.
|
|
//
|
|
// Arguments: [cb] -- number of bytes of data to allocate and copy
|
|
// [pvData] -- the source of the data to copy
|
|
// [phr] -- optional pointer to an HRESULT set to
|
|
// STG_E_INSUFFICIENTMEMORY if memory could
|
|
// not be allocated.
|
|
//
|
|
//
|
|
// Returns: NULL if no memory could be allocated,
|
|
// Otherwise, pointer to allocated and copied data.
|
|
//
|
|
//--------------------------------------------------------------------
|
|
|
|
void * AllocAndCopy(ULONG cb, void * pvData, HRESULT *phr = NULL)
|
|
{
|
|
PROPASSERT(cb!=0);
|
|
void * pvNew = CoTaskMemAlloc(cb);
|
|
if (pvNew != NULL)
|
|
{
|
|
memcpy(pvNew, pvData, cb);
|
|
}
|
|
else
|
|
{
|
|
if (phr != NULL)
|
|
{
|
|
*phr = STG_E_INSUFFICIENTMEMORY;
|
|
}
|
|
}
|
|
return(pvNew);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------
|
|
//
|
|
// Function: SysAllocString
|
|
// SysFreeString
|
|
//
|
|
// Synopsis: Exported BSTR allocation and deallocation routines
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------
|
|
STDAPI_(void) SysFreeString(BSTR bstr)
|
|
{
|
|
if (bstr)
|
|
{
|
|
BYTE* pab = (BYTE*) bstr;
|
|
delete[] (pab - sizeof(DWORD));
|
|
}
|
|
}
|
|
|
|
STDAPI_(BSTR) SysAllocString(LPOLECHAR pwsz)
|
|
{
|
|
if (!pwsz) return NULL;
|
|
|
|
DWORD cch = _tcslen(pwsz);
|
|
|
|
/* a BSTR points to a DWORD length, followed by the string */
|
|
BYTE *pab = new BYTE[sizeof(DWORD) + ((cch+1)*sizeof(OLECHAR))];
|
|
|
|
if (pab)
|
|
{
|
|
*((DWORD*) pab) = cch*sizeof(OLECHAR);
|
|
pab += sizeof(DWORD);
|
|
_tcscpy( (LPOLECHAR)pab, pwsz );
|
|
}
|
|
return ((BSTR) pab);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Table: g_TypeSizes, g_TypeSizesB
|
|
//
|
|
// Synopsis: Tables containing byte sizes and flags for various VT_ types.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#define BIT_VECTNOALLOC 0x80 // the VT_VECTOR with this type does not
|
|
// use heap allocation
|
|
|
|
#define BIT_SIMPNOALLOC 0x40 // the non VT_VECTOR with this type does not
|
|
// use heap allocation
|
|
|
|
#define BIT_INVALID 0x20 // marks an invalid type
|
|
|
|
#define BIT_SIZEMASK 0x1F // mask for size of underlying type
|
|
|
|
const unsigned char g_TypeSizes[] =
|
|
{ BIT_SIMPNOALLOC | BIT_VECTNOALLOC | 0, //VT_EMPTY= 0,
|
|
BIT_SIMPNOALLOC | BIT_VECTNOALLOC | 0, //VT_NULL = 1,
|
|
BIT_SIMPNOALLOC | BIT_VECTNOALLOC | 2, //VT_I2 = 2,
|
|
BIT_SIMPNOALLOC | BIT_VECTNOALLOC | 4, //VT_I4 = 3,
|
|
BIT_SIMPNOALLOC | BIT_VECTNOALLOC | 4, //VT_R4 = 4,
|
|
BIT_SIMPNOALLOC | BIT_VECTNOALLOC | 8, //VT_R8 = 5,
|
|
BIT_SIMPNOALLOC | BIT_VECTNOALLOC | sizeof(CY), //VT_CY = 6,
|
|
BIT_SIMPNOALLOC | BIT_VECTNOALLOC | sizeof(DATE), //VT_DATE = 7,
|
|
sizeof(BSTR), //VT_BSTR = 8,
|
|
BIT_INVALID | 0, //VT_DISPATCH = 9,
|
|
BIT_SIMPNOALLOC | BIT_VECTNOALLOC | sizeof(SCODE), //VT_ERROR = 10,
|
|
BIT_SIMPNOALLOC | BIT_VECTNOALLOC | sizeof(VARIANT_BOOL), //VT_BOOL = 11,
|
|
sizeof(PROPVARIANT), //VT_VARIANT = 12,
|
|
BIT_INVALID | BIT_SIMPNOALLOC | BIT_VECTNOALLOC | 0, //VT_UNKNOWN = 13,
|
|
BIT_INVALID | BIT_SIMPNOALLOC | BIT_VECTNOALLOC | 0, // 14
|
|
BIT_INVALID | BIT_SIMPNOALLOC | BIT_VECTNOALLOC | 0, // 15
|
|
#ifdef PROPVAR_VT_I1
|
|
BIT_SIMPNOALLOC | BIT_VECTNOALLOC | 1, //VT_I1 = 16,
|
|
#else
|
|
BIT_INVALID /*BIT_SIMPNOALLOC | BIT_VECTNOALLOC | 1,*/ | 0, //VT_I1 = 16,
|
|
#endif
|
|
BIT_SIMPNOALLOC | BIT_VECTNOALLOC | 1, //VT_UI1 = 17,
|
|
BIT_SIMPNOALLOC | BIT_VECTNOALLOC | 2, //VT_UI2 = 18,
|
|
BIT_SIMPNOALLOC | BIT_VECTNOALLOC | 4, //VT_UI4 = 19,
|
|
BIT_SIMPNOALLOC | BIT_VECTNOALLOC | 8, //VT_I8 = 20,
|
|
BIT_SIMPNOALLOC | BIT_VECTNOALLOC | 8, //VT_UI8 = 21,
|
|
BIT_INVALID | BIT_SIMPNOALLOC | BIT_VECTNOALLOC | 0, //VT_INT = 22,
|
|
BIT_INVALID | BIT_SIMPNOALLOC | BIT_VECTNOALLOC | 0, //VT_UINT = 23,
|
|
BIT_INVALID | BIT_SIMPNOALLOC | BIT_VECTNOALLOC | 0, //VT_VOID = 24,
|
|
BIT_INVALID | BIT_SIMPNOALLOC | BIT_VECTNOALLOC | 0, //VT_HRESULT = 25,
|
|
BIT_INVALID | 0, //VT_PTR = 26,
|
|
BIT_INVALID | 0, //VT_SAFEARRAY = 27,
|
|
BIT_INVALID | 0, //VT_CARRAY = 28,
|
|
BIT_INVALID | 0, //VT_USERDEFINED = 29,
|
|
sizeof(LPSTR), //VT_LPSTR = 30,
|
|
sizeof(LPWSTR) //VT_LPWSTR = 31,
|
|
};
|
|
|
|
const unsigned char g_TypeSizesB[] =
|
|
{
|
|
// NOTE: vectors of types marked ** are determined dynamically
|
|
BIT_SIMPNOALLOC | BIT_VECTNOALLOC | sizeof(FILETIME), //VT_FILETIME = 64,
|
|
0, //**VT_BLOB = 65,
|
|
0, //**VT_STREAM = 66,
|
|
0, //**VT_STORAGE = 67,
|
|
0, //**VT_STREAMED_OBJECT = 68,
|
|
0, //**VT_STORED_OBJECT = 69,
|
|
0, //**VT_BLOB_OBJECT = 70,
|
|
sizeof(CLIPDATA), //VT_CF = 71,
|
|
BIT_VECTNOALLOC | sizeof(CLSID) //VT_CLSID = 72
|
|
};
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: PropVariantCopy, public
|
|
//
|
|
// Synopsis: Copies a PROPVARIANT
|
|
//
|
|
// Arguments: [pDest] -- the destination PROPVARIANT
|
|
// [pvarg] - the source PROPVARIANT
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
STDAPI PropVariantCopy ( PROPVARIANT * pDest, const PROPVARIANT * pvarg )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
register unsigned char TypeInfo;
|
|
register int iBaseType;
|
|
|
|
// handle the simple types quickly
|
|
iBaseType = pvarg->vt & ~VT_VECTOR;
|
|
|
|
if (iBaseType <= VT_LPWSTR)
|
|
{
|
|
TypeInfo = g_TypeSizes[iBaseType];
|
|
}
|
|
else
|
|
if (VT_FILETIME <= iBaseType && iBaseType <= VT_CLSID)
|
|
{
|
|
TypeInfo = g_TypeSizesB[iBaseType-VT_FILETIME];
|
|
}
|
|
else
|
|
{
|
|
hr = STG_E_INVALIDPARAMETER;
|
|
goto errRet;
|
|
}
|
|
|
|
if ((TypeInfo & BIT_INVALID) != 0)
|
|
{
|
|
hr = STG_E_INVALIDPARAMETER;
|
|
goto errRet;
|
|
}
|
|
|
|
*pDest = *pvarg;
|
|
|
|
if ((pvarg->vt & VT_VECTOR) == 0)
|
|
{
|
|
// handle non-vector types
|
|
|
|
if ((TypeInfo & BIT_SIMPNOALLOC) == 0)
|
|
{
|
|
void * pvAllocated = (void*)-1;
|
|
|
|
switch (pvarg->vt)
|
|
{
|
|
case VT_BSTR:
|
|
pvAllocated = pDest->bstrVal = PropSysAllocString( pvarg->bstrVal );
|
|
break;
|
|
|
|
case VT_LPSTR:
|
|
if (pvarg->pszVal != NULL)
|
|
pvAllocated = pDest->pszVal = (CHAR *)
|
|
AllocAndCopy(strlen(pvarg->pszVal)+1, pvarg->pszVal);
|
|
break;
|
|
case VT_LPWSTR:
|
|
if (pvarg->pwszVal != NULL)
|
|
{
|
|
ULONG cbString = (Prop_wcslen(pvarg->pwszVal)+1) * sizeof(WCHAR);
|
|
pvAllocated = pDest->pwszVal = (WCHAR *)
|
|
AllocAndCopy(cbString, pvarg->pwszVal);
|
|
}
|
|
break;
|
|
case VT_CLSID:
|
|
if (pvarg->puuid != NULL)
|
|
pvAllocated = pDest->puuid = (GUID *)
|
|
AllocAndCopy(sizeof(*(pvarg->puuid)), pvarg->puuid);
|
|
break;
|
|
|
|
case VT_CF:
|
|
// first check if CLIPDATA is present
|
|
if (pvarg->pclipdata != NULL)
|
|
{
|
|
// yes ... copy the clip data structure
|
|
|
|
pvAllocated = pDest->pclipdata = (CLIPDATA*)AllocAndCopy(
|
|
sizeof(*(pvarg->pclipdata)), pvarg->pclipdata);
|
|
|
|
// did we allocate the CLIPDATA ?
|
|
if (pvAllocated != NULL)
|
|
{
|
|
// yes ... initialize the destination.
|
|
pDest->pclipdata->pClipData = NULL;
|
|
|
|
// Is the input valid?
|
|
if (NULL == pvarg->pclipdata->pClipData
|
|
&&
|
|
0 != CBPCLIPDATA(*pvarg->pclipdata))
|
|
{
|
|
// no ... the input is not valid
|
|
hr = STG_E_INVALIDPARAMETER;
|
|
}
|
|
|
|
// Is there is any actual clip data ?
|
|
else if (0 != CBPCLIPDATA(*pvarg->pclipdata))
|
|
{
|
|
// yes ... copy the actual clip data
|
|
pvAllocated = pDest->pclipdata->pClipData =
|
|
(BYTE*)AllocAndCopy(CBPCLIPDATA(*pvarg->pclipdata),
|
|
pvarg->pclipdata->pClipData);
|
|
}
|
|
} // if (pvAllocated != NULL)
|
|
} // if (pvarg->pclipdata != NULL)
|
|
break;
|
|
|
|
case VT_BLOB:
|
|
case VT_BLOB_OBJECT:
|
|
if (pvarg->blob.pBlobData != NULL && pvarg->blob.cbSize != 0)
|
|
{
|
|
pvAllocated = pDest->blob.pBlobData = (BYTE *)
|
|
AllocAndCopy(pvarg->blob.cbSize,
|
|
pvarg->blob.pBlobData);
|
|
}
|
|
else
|
|
{
|
|
// if the cbsize is 0 or pBlobData is NULL, make
|
|
// sure both values are consistent in the destination
|
|
pDest->blob.pBlobData = NULL;
|
|
pDest->blob.cbSize = 0;
|
|
}
|
|
break;
|
|
|
|
case VT_VARIANT:
|
|
// drop through - this merely documents that VT_VARIANT has been thought of.
|
|
|
|
default:
|
|
//PROPASSERT(!"Unexpected non-vector type in PropVariantCopy");
|
|
hr = STG_E_INVALIDPARAMETER;
|
|
goto errRet;
|
|
}
|
|
|
|
if( FAILED(hr) )
|
|
goto errRet;
|
|
|
|
if (pvAllocated == NULL)
|
|
{
|
|
hr = STG_E_INSUFFICIENTMEMORY;
|
|
goto errRet;
|
|
}
|
|
} // if ((TypeInfo & BIT_SIMPNOALLOC) == 0)
|
|
} // if ((pvarg->vt & VT_VECTOR) == 0)
|
|
|
|
else
|
|
{
|
|
ULONG cbType = TypeInfo & BIT_SIZEMASK;
|
|
if (cbType == 0)
|
|
{
|
|
hr = STG_E_INVALIDPARAMETER;
|
|
goto errRet;
|
|
}
|
|
|
|
// handle the vector types
|
|
|
|
// this depends on the pointer and count being in the same place in
|
|
// each of CAUI1 CAI2 etc
|
|
|
|
// allocate the array for pElems
|
|
if (pvarg->caub.pElems == NULL || pvarg->caub.cElems == 0)
|
|
{
|
|
PROPASSERT( hr == S_OK );
|
|
goto errRet; // not really an error
|
|
}
|
|
|
|
void *pvAllocated = pDest->caub.pElems = (BYTE *)
|
|
AllocAndCopy(cbType * pvarg->caub.cElems, pvarg->caub.pElems);
|
|
|
|
if (pvAllocated == NULL)
|
|
{
|
|
hr = STG_E_INSUFFICIENTMEMORY;
|
|
goto errRet;
|
|
}
|
|
|
|
if ((TypeInfo & BIT_VECTNOALLOC) != 0)
|
|
{
|
|
// the vector needs no further allocation
|
|
PROPASSERT( hr == S_OK );
|
|
goto errRet;
|
|
}
|
|
|
|
ULONG l;
|
|
|
|
// vector types that require allocation ...
|
|
// we first zero out the pointers so that we can use PropVariantClear
|
|
// to clean up in the error case
|
|
|
|
switch (pvarg->vt)
|
|
{
|
|
case (VT_VECTOR | VT_BSTR):
|
|
// initialize for error case
|
|
for (l=0; l< pvarg->cabstr.cElems; l++)
|
|
{
|
|
pDest->cabstr.pElems[l] = NULL;
|
|
}
|
|
break;
|
|
|
|
case (VT_VECTOR | VT_LPSTR):
|
|
case (VT_VECTOR | VT_LPWSTR):
|
|
// initialize for error case
|
|
for (l=0; l< pvarg->calpstr.cElems; l++)
|
|
{
|
|
pDest->calpstr.pElems[l] = NULL;
|
|
}
|
|
break;
|
|
|
|
case (VT_VECTOR | VT_CF):
|
|
// initialize for error case
|
|
for (l=0; l< pvarg->caclipdata.cElems; l++)
|
|
{
|
|
pDest->caclipdata.pElems[l].pClipData = NULL;
|
|
}
|
|
break;
|
|
|
|
case (VT_VECTOR | VT_VARIANT):
|
|
// initialize for error case
|
|
for (l=0; l< pvarg->capropvar.cElems; l++)
|
|
{
|
|
pDest->capropvar.pElems[l].vt = VT_ILLEGAL;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
PROPASSERT(!"Internal error: Unexpected type in PropVariantCopy");
|
|
CoTaskMemFree(pvAllocated);
|
|
hr = STG_E_INVALIDPARAMETER;
|
|
goto errRet;
|
|
}
|
|
|
|
// now do the vector copy...
|
|
|
|
switch (pvarg->vt)
|
|
{
|
|
case (VT_VECTOR | VT_BSTR):
|
|
for (l=0; l< pvarg->cabstr.cElems; l++)
|
|
{
|
|
if (pvarg->cabstr.pElems[l] != NULL)
|
|
{
|
|
pDest->cabstr.pElems[l] = PropSysAllocString( pvarg->cabstr.pElems[l]);
|
|
if (pDest->cabstr.pElems[l] == NULL)
|
|
{
|
|
hr = STG_E_INSUFFICIENTMEMORY;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
|
|
case (VT_VECTOR | VT_LPWSTR):
|
|
for (l=0; l< pvarg->calpwstr.cElems; l++)
|
|
{
|
|
if (pvarg->calpwstr.pElems[l] != NULL)
|
|
{
|
|
|
|
pDest->calpwstr.pElems[l] = (LPWSTR)AllocAndCopy(
|
|
sizeof(WCHAR)*(Prop_wcslen(pvarg->calpwstr.pElems[l])+1),
|
|
pvarg->calpwstr.pElems[l],
|
|
&hr);
|
|
|
|
if (hr != S_OK)
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case (VT_VECTOR | VT_LPSTR):
|
|
for (l=0; l< pvarg->calpstr.cElems; l++)
|
|
{
|
|
if (pvarg->calpstr.pElems[l] != NULL)
|
|
{
|
|
pDest->calpstr.pElems[l] = (LPSTR)AllocAndCopy(
|
|
strlen(pvarg->calpstr.pElems[l])+1,
|
|
pvarg->calpstr.pElems[l],
|
|
&hr);
|
|
|
|
if (hr != S_OK)
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case (VT_VECTOR | VT_CF):
|
|
for (l=0; l< pvarg->caclipdata.cElems; l++)
|
|
{
|
|
// Is the input valid?
|
|
if (NULL == pvarg->caclipdata.pElems[l].pClipData
|
|
&&
|
|
0 != CBPCLIPDATA(pvarg->caclipdata.pElems[l] ))
|
|
{
|
|
hr = STG_E_INVALIDPARAMETER;
|
|
break;
|
|
}
|
|
|
|
// Is there data to copy?
|
|
if (0 != CBPCLIPDATA(pvarg->caclipdata.pElems[l]))
|
|
{
|
|
pDest->caclipdata.pElems[l].pClipData = (BYTE*)AllocAndCopy(
|
|
CBPCLIPDATA(pvarg->caclipdata.pElems[l]),
|
|
pvarg->caclipdata.pElems[l].pClipData,
|
|
&hr);
|
|
|
|
if (hr != S_OK)
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case (VT_VECTOR | VT_VARIANT):
|
|
for (l=0; l< pvarg->capropvar.cElems; l++)
|
|
{
|
|
hr = PropVariantCopy(pDest->capropvar.pElems + l,
|
|
pvarg->capropvar.pElems + l);
|
|
if (hr != S_OK)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
|
|
default:
|
|
PROPASSERT(!"Internal error: Unexpected type in PropVariantCopy");
|
|
CoTaskMemFree(pvAllocated);
|
|
hr = STG_E_INVALIDPARAMETER;
|
|
goto errRet;
|
|
}
|
|
|
|
if (hr != S_OK)
|
|
{
|
|
PropVariantClear(pDest);
|
|
goto errRet;
|
|
}
|
|
}
|
|
|
|
errRet:
|
|
|
|
if (hr != S_OK)
|
|
{
|
|
// VT_EMPTY
|
|
PROPASSERT(VT_EMPTY == 0);
|
|
memset(pDest, 0, sizeof(*pDest));
|
|
}
|
|
|
|
return(hr);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: NtStatusToScode, public
|
|
//
|
|
// Synopsis: Attempts to map an NTSTATUS code to an SCODE
|
|
//
|
|
// Arguments: [nts] - NTSTATUS
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 29-Jun-93 DrewB Created
|
|
//
|
|
// Notes: Assumes [nts] is an error code
|
|
// This function is by no means exhaustively complete
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
SCODE NtStatusToScode(NTSTATUS nts)
|
|
{
|
|
SCODE sc;
|
|
|
|
PropDbg((DEB_ITRACE, "In NtStatusToScode(%lX)\n", nts));
|
|
|
|
switch(nts)
|
|
{
|
|
case STATUS_INVALID_PARAMETER:
|
|
case STATUS_INVALID_PARAMETER_MIX:
|
|
case STATUS_INVALID_PARAMETER_1:
|
|
case STATUS_INVALID_PARAMETER_2:
|
|
case STATUS_INVALID_PARAMETER_3:
|
|
case STATUS_INVALID_PARAMETER_4:
|
|
case STATUS_INVALID_PARAMETER_5:
|
|
case STATUS_INVALID_PARAMETER_6:
|
|
case STATUS_INVALID_PARAMETER_7:
|
|
case STATUS_INVALID_PARAMETER_8:
|
|
case STATUS_INVALID_PARAMETER_9:
|
|
case STATUS_INVALID_PARAMETER_10:
|
|
case STATUS_INVALID_PARAMETER_11:
|
|
case STATUS_INVALID_PARAMETER_12:
|
|
sc = STG_E_INVALIDPARAMETER;
|
|
break;
|
|
|
|
case STATUS_DUPLICATE_NAME:
|
|
case STATUS_DUPLICATE_OBJECTID:
|
|
case STATUS_OBJECTID_EXISTS:
|
|
case STATUS_OBJECT_NAME_COLLISION:
|
|
sc = STG_E_FILEALREADYEXISTS;
|
|
break;
|
|
|
|
case STATUS_NO_SUCH_DEVICE:
|
|
case STATUS_NO_SUCH_FILE:
|
|
case STATUS_OBJECT_NAME_NOT_FOUND:
|
|
case STATUS_NOT_A_DIRECTORY:
|
|
case STATUS_FILE_IS_A_DIRECTORY:
|
|
case STATUS_PROPSET_NOT_FOUND:
|
|
case STATUS_NOT_FOUND:
|
|
case STATUS_OBJECT_TYPE_MISMATCH:
|
|
sc = STG_E_FILENOTFOUND;
|
|
break;
|
|
|
|
case STATUS_OBJECT_NAME_INVALID:
|
|
case STATUS_OBJECT_PATH_SYNTAX_BAD:
|
|
case STATUS_OBJECT_PATH_INVALID:
|
|
case STATUS_NAME_TOO_LONG:
|
|
sc = STG_E_INVALIDNAME;
|
|
break;
|
|
|
|
case STATUS_ACCESS_DENIED:
|
|
sc = STG_E_ACCESSDENIED;
|
|
break;
|
|
|
|
case STATUS_NO_MEMORY:
|
|
case STATUS_INSUFFICIENT_RESOURCES:
|
|
sc = STG_E_INSUFFICIENTMEMORY;
|
|
break;
|
|
|
|
case STATUS_INVALID_HANDLE:
|
|
case STATUS_FILE_INVALID:
|
|
case STATUS_FILE_FORCED_CLOSED:
|
|
sc = STG_E_INVALIDHANDLE;
|
|
break;
|
|
|
|
case STATUS_INVALID_DEVICE_REQUEST:
|
|
case STATUS_INVALID_SYSTEM_SERVICE:
|
|
case STATUS_NOT_IMPLEMENTED:
|
|
sc = STG_E_INVALIDFUNCTION;
|
|
break;
|
|
|
|
case STATUS_NO_MEDIA_IN_DEVICE:
|
|
case STATUS_UNRECOGNIZED_MEDIA:
|
|
case STATUS_DISK_CORRUPT_ERROR:
|
|
case STATUS_DATA_ERROR:
|
|
sc = STG_E_WRITEFAULT;
|
|
break;
|
|
|
|
case STATUS_OBJECT_PATH_NOT_FOUND:
|
|
sc = STG_E_PATHNOTFOUND;
|
|
break;
|
|
|
|
case STATUS_SHARING_VIOLATION:
|
|
sc = STG_E_SHAREVIOLATION;
|
|
break;
|
|
|
|
case STATUS_FILE_LOCK_CONFLICT:
|
|
case STATUS_LOCK_NOT_GRANTED:
|
|
sc = STG_E_LOCKVIOLATION;
|
|
break;
|
|
|
|
case STATUS_DISK_FULL:
|
|
sc = STG_E_MEDIUMFULL;
|
|
break;
|
|
|
|
case STATUS_ACCESS_VIOLATION:
|
|
case STATUS_INVALID_USER_BUFFER:
|
|
sc = STG_E_INVALIDPOINTER;
|
|
break;
|
|
|
|
case STATUS_TOO_MANY_OPENED_FILES:
|
|
sc = STG_E_TOOMANYOPENFILES;
|
|
break;
|
|
|
|
case STATUS_DIRECTORY_NOT_EMPTY:
|
|
sc = WIN32_SCODE(ERROR_DIR_NOT_EMPTY);
|
|
break;
|
|
|
|
case STATUS_DELETE_PENDING:
|
|
sc = STG_E_REVERTED;
|
|
break;
|
|
|
|
case STATUS_INTERNAL_DB_CORRUPTION:
|
|
sc = STG_E_INVALIDHEADER;
|
|
break;
|
|
|
|
case STATUS_UNSUCCESSFUL:
|
|
sc = E_FAIL;
|
|
break;
|
|
|
|
case STATUS_UNMAPPABLE_CHARACTER:
|
|
sc = HRESULT_FROM_WIN32( ERROR_NO_UNICODE_TRANSLATION );
|
|
break;
|
|
|
|
default:
|
|
PropDbg((DEB_ERROR, "NtStatusToScode: Unknown status %lX\n", nts));
|
|
|
|
sc = HRESULT_FROM_NT(nts);
|
|
break;
|
|
}
|
|
|
|
PropDbg((DEB_ITRACE, "Out NtStatusToScode => %lX\n", sc));
|
|
return sc;
|
|
}
|
|
|
|
#if DBG!=0
|
|
|
|
ULONG
|
|
DbgPrint(
|
|
PCHAR Format,
|
|
...
|
|
)
|
|
{
|
|
va_list arglist;
|
|
CHAR Buffer[512];
|
|
int cb;
|
|
|
|
//
|
|
// Format the output into a buffer and then print it.
|
|
//
|
|
|
|
va_start(arglist, Format);
|
|
cb = PropVsprintfA(Buffer, Format, arglist);
|
|
if (cb == -1) { // detect buffer overflow
|
|
cb = sizeof(Buffer);
|
|
Buffer[sizeof(Buffer) - 2] = '\n';
|
|
Buffer[sizeof(Buffer) - 1] = '\0';
|
|
}
|
|
|
|
OutputDebugString(Buffer);
|
|
|
|
return 0;
|
|
}
|
|
#endif
|
|
|