//+------------------------------------------------------------------------- // // 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