//+================================================================= // // File: // PropTest.cxx // // Description: // This file contains the main() and most supporting functions // for the PropTest command-line DRT. Run "PropTest /?" for // usage information. // //+================================================================= // tests to do: // IEnumSTATPROPSTG // Create some properties, named and id'd // Enumerate them and check // (check vt, lpwstrName, propid) // (check when asking for more than there is: S_FALSE, S_OK) // Delete one // Reset the enumerator // Enumerate them and check // Delete one // // Reset the enumeratorA // Read one from enumeratorA // Clone enumerator -> enumeratorB // Loop comparing rest of enumerator contents // // Reset the enumerator // Skip all // Check none left // // Reset the enumerator // Skip all but one // Check one left // // Check refcounting and IUnknown // // IPropertyStorage tests // // Multiple readers/writers access tests // //+---------------------------------------------------------------------------- // // I n c l u d e s // //+---------------------------------------------------------------------------- #include "pch.cxx" // Brings in most other includes/defines/etc. #include "propstm.hxx" #include "propstg.hxx" //#include // //+---------------------------------------------------------------------------- // // G l o b a l s // //+---------------------------------------------------------------------------- OLECHAR g_aocMap[CCH_MAP + 1] = OLESTR("abcdefghijklmnopqrstuvwxyz012345"); // Special-case property set names const OLECHAR oszSummaryInformation[] = OLESTR("\005SummaryInformation"); ULONG cboszSummaryInformation = sizeof(oszSummaryInformation); const OLECHAR oszDocSummaryInformation[] = OLESTR("\005DocumentSummaryInformation"); ULONG cboszDocSummaryInformation = sizeof(oszDocSummaryInformation); const OLECHAR oszGlobalInfo[] = OLESTR("\005Global Info"); ULONG cboszGlobalInfo = sizeof(oszGlobalInfo); const OLECHAR oszImageContents[] = OLESTR("\005Image Contents"); ULONG cboszImageContents = sizeof(oszImageContents); const OLECHAR oszImageInfo[] = OLESTR("\005Image Info"); ULONG cboszImageInfo = sizeof(oszImageInfo); // Enumeration indicating how to get an IPropertySetStorage EnumImplementation g_enumImplementation = PROPIMP_UNKNOWN; DWORD g_Restrictions; BOOL g_fRegisterLocalServer = TRUE; BOOL g_fUseNt5PropsDll = FALSE; // Property Set APIs (which may be in OLE32.dll or IProp.dll) HINSTANCE g_hinstDLL = NULL; FNSTGCREATEPROPSTG *g_pfnStgCreatePropStg = NULL; FNSTGOPENPROPSTG *g_pfnStgOpenPropStg = NULL; FNSTGCREATEPROPSETSTG *g_pfnStgCreatePropSetStg = NULL; FNFMTIDTOPROPSTGNAME *g_pfnFmtIdToPropStgName = NULL; FNPROPSTGNAMETOFMTID *g_pfnPropStgNameToFmtId = NULL; FNPROPVARIANTCLEAR *g_pfnPropVariantClear = NULL; FNPROPVARIANTCOPY *g_pfnPropVariantCopy = NULL; FNFREEPROPVARIANTARRAY *g_pfnFreePropVariantArray = NULL; FNSTGCREATESTORAGEEX *g_pfnStgCreateStorageEx = NULL; FNSTGOPENSTORAGEEX *g_pfnStgOpenStorageEx = NULL; FNSTGOPENSTORAGEONHANDLE *g_pfnStgOpenStorageOnHandle = NULL; FNSTGCREATESTORAGEONHANDLE *g_pfnStgCreateStorageOnHandle = NULL; FNSTGPROPERTYLENGTHASVARIANT *g_pfnStgPropertyLengthAsVariant = NULL; FNSTGCONVERTVARIANTTOPROPERTY *g_pfnStgConvertVariantToProperty = NULL; FNSTGCONVERTPROPERTYTOVARIANT *g_pfnStgConvertPropertyToVariant = NULL; // PictureIt! Format IDs const FMTID fmtidGlobalInfo = { 0x56616F00, 0xC154, 0x11ce, { 0x85, 0x53, 0x00, 0xAA, 0x00, 0xA1, 0xF9, 0x5B } }; const FMTID fmtidImageContents = { 0x56616400, 0xC154, 0x11ce, { 0x85, 0x53, 0x00, 0xAA, 0x00, 0xA1, 0xF9, 0x5B } }; const FMTID fmtidImageInfo = { 0x56616500, 0xC154, 0x11ce, { 0x85, 0x53, 0x00, 0xAA, 0x00, 0xA1, 0xF9, 0x5B } }; BOOL g_fOFS; LARGE_INTEGER g_li0; CPropVariant g_rgcpropvarAll[ CPROPERTIES_ALL ]; CPropSpec g_rgcpropspecAll[ CPROPERTIES_ALL ]; const OLECHAR* g_rgoszpropnameAll[ CPROPERTIES_ALL ]; char g_szPropHeader[] = " propid/name propid cb type value\n"; char g_szEmpty[] = ""; BOOL g_fVerbose = FALSE; BOOL g_stgmDumpFlags = 0; // This flag indicates whether or not the run-time system supports // IPropertySetStorage on the DocFile IStorage object. BOOL g_fQIPropertySetStorage = FALSE; // g_curUuid is used by UuidCreate(). Everycall to that function // returns the current value of g_curUuid, and increments the DWORD // field. GUID g_curUuid = { /* e4ecf7f0-e587-11cf-b10d-00aa005749e9 */ 0xe4ecf7f0, 0xe587, 0x11cf, {0xb1, 0x0d, 0x00, 0xaa, 0x00, 0x57, 0x49, 0xe9} }; // Instantiate an object for the Marshaling tests #ifndef _MAC_NODOC CPropStgMarshalTest g_cpsmt; #endif // On the Mac, instantiate a CDisplay object, which is used // by these tests to write to the screen (see #define PRINTF). #ifdef _MAC CDisplay *g_pcDisplay; #endif // System information SYSTEMINFO g_SystemInfo; int g_nIndent = 0; void Status( char* szMessage ) { for( int i = 0; i < g_nIndent; i++ ) PRINTF( " " ); if( g_fVerbose ) PRINTF( szMessage ); else PRINTF( "." ); } // STATUS() //+---------------------------------------------------------------------------- // // Function: IsOriginalPropVariantType // // Determines if a VARTYPE was one of the ones in the original PropVariant // definition (as defined in the OLE2 spec and shipped with NT4/DCOM95). // //+---------------------------------------------------------------------------- // *** Duped from props\utils.cxx *** BOOL IsOriginalPropVariantType( VARTYPE vt ) { if( vt & ~VT_TYPEMASK & ~VT_VECTOR ) return( FALSE ); switch( vt ) { case VT_EMPTY: case VT_NULL: case VT_UI1: case VT_I2: case VT_UI2: case VT_BOOL: case VT_I4: case VT_UI4: case VT_R4: case VT_ERROR: case VT_I8: case VT_UI8: case VT_R8: case VT_CY: case VT_DATE: case VT_FILETIME: case VT_CLSID: case VT_BLOB: case VT_BLOB_OBJECT: case VT_CF: case VT_STREAM: case VT_STREAMED_OBJECT: case VT_STORAGE: case VT_STORED_OBJECT: case VT_BSTR: case VT_LPSTR: case VT_LPWSTR: case VT_UI1|VT_VECTOR: case VT_I2|VT_VECTOR: case VT_UI2|VT_VECTOR: case VT_BOOL|VT_VECTOR: case VT_I4|VT_VECTOR: case VT_UI4|VT_VECTOR: case VT_R4|VT_VECTOR: case VT_ERROR|VT_VECTOR: case VT_I8|VT_VECTOR: case VT_UI8|VT_VECTOR: case VT_R8|VT_VECTOR: case VT_CY|VT_VECTOR: case VT_DATE|VT_VECTOR: case VT_FILETIME|VT_VECTOR: case VT_CLSID|VT_VECTOR: case VT_CF|VT_VECTOR: case VT_BSTR|VT_VECTOR: case VT_BSTR_BLOB|VT_VECTOR: case VT_LPSTR|VT_VECTOR: case VT_LPWSTR|VT_VECTOR: case VT_VARIANT|VT_VECTOR: return( TRUE ); } return( FALSE ); } //+================================================================= // // Function: _Check // // Synopsis: Verify that the actual HR is the expected // value. If not, report an error and exit. // // Inputs: [HRESULT] hrExpected // What we expected // [HRESULT] hrActual // The actual HR of the previous operation. // [int] line // The line number of the operation. // // Outputs: None. // //+================================================================= void _Check(HRESULT hrExpected, HRESULT hrActual, LPCSTR szFile, int line) { if (hrExpected != hrActual) { PRINTF("\nFailed with hr=%08x at line %d\n" "in \"%s\"\n" "(expected hr=%08x, GetLastError=%lu)\n", hrActual, line, szFile, hrExpected, GetLastError() ); // On NT, we simply exit here. On the Mac, where PropTest is a function rather // than a main(), we throw an exception so that the test may terminate somewhat // cleanly. #ifdef _MAC throw CHRESULT( hrActual, OLESTR("Fatal Error") ); #else if( IsDebuggerPresent() ) DebugBreak(); exit(1); #endif } } OLECHAR * GetNextTest() { static int nTest; static OLECHAR ocsBuf[10]; soprintf(ocsBuf, OLESTR("%d"), nTest++); return(ocsBuf); } VOID CalcSafeArrayIndices( LONG iLinear, LONG rgIndices[], const SAFEARRAYBOUND rgsaBounds[], ULONG cDims ) { for( long i = 0; i < static_cast(cDims) - 1; i++ ) { LONG lProduct = rgsaBounds[cDims-1].cElements; for( int j = cDims-2; j > i; j-- ) lProduct *= rgsaBounds[j].cElements; rgIndices[ i ] = rgsaBounds[i].lLbound + (iLinear / lProduct); iLinear %= lProduct; } rgIndices[ cDims-1 ] = rgsaBounds[cDims-1].lLbound + (iLinear % rgsaBounds[cDims-1].cElements); } ULONG CalcSafeArrayElementCount( const SAFEARRAY *psa ) { ULONG cElems = 1; ULONG cDims = SafeArrayGetDim( const_cast(psa) ); for( ULONG i = 1; i <= cDims; i++ ) { LONG lUpperBound = 0, lLowerBound = 0; Check( S_OK, SafeArrayGetLBound( const_cast(psa), i, &lLowerBound )); Check( S_OK, SafeArrayGetUBound( const_cast(psa), i, &lUpperBound )); cElems *= lUpperBound - lLowerBound + 1; } return( cElems ); } VOID CompareSafeArrays( SAFEARRAY *psa1, SAFEARRAY *psa2 ) { VARTYPE vt1, vt2; UINT cDims1, cDims2; UINT i; UINT cElems = 0; SAFEARRAYBOUND *rgsaBounds = NULL; LONG *rgIndices = NULL; Check( S_OK, SafeArrayGetVartype( psa1, &vt1 )); Check( S_OK, SafeArrayGetVartype( psa2, &vt2 )); Check( vt1, vt2 ); cDims1 = SafeArrayGetDim( psa1 ); cDims2 = SafeArrayGetDim( psa2 ); Check( cDims1, cDims2 ); Check( 0, memcmp( psa1->rgsabound, psa2->rgsabound, cDims1 * sizeof(SAFEARRAYBOUND) )); Check( psa1->fFeatures, psa2->fFeatures ); Check( psa1->cbElements, psa2->cbElements ); cElems = CalcSafeArrayElementCount( psa1 ); switch( vt1 ) { case VT_I1: case VT_UI1: case VT_I2: case VT_UI2: case VT_I4: case VT_UI4: case VT_INT: case VT_UINT: case VT_ERROR: case VT_BOOL: case VT_R4: case VT_R8: case VT_I8: case VT_UI8: Check( 0, memcmp( psa1->pvData, psa2->pvData, cDims1 * psa1->cbElements )); break; case VT_BSTR: rgsaBounds = new SAFEARRAYBOUND[ cDims1 ]; Check( FALSE, NULL == rgsaBounds ); rgIndices = new LONG[ cDims1 ]; Check( FALSE, NULL == rgIndices ); // The Bounds are stored in the safearray in reversed order. Correct them so // that we can use CalcSafeArrayIndices for( i = 0; i < cDims1; i++ ) rgsaBounds[i] = psa1->rgsabound[ cDims1-1-i ]; for( i = 0; i < cElems; i++ ) { BSTR *pbstr1 = NULL, *pbstr2 = NULL; CalcSafeArrayIndices( i, rgIndices, rgsaBounds, cDims1 ); Check( S_OK, SafeArrayPtrOfIndex( psa1, rgIndices, reinterpret_cast(&pbstr1) )); Check( S_OK, SafeArrayPtrOfIndex( psa2, rgIndices, reinterpret_cast(&pbstr2) )); Check( *(reinterpret_cast(*pbstr1)-1), *(reinterpret_cast(*pbstr2)-1) ); Check( 0, ocscmp( *pbstr1, *pbstr2 )); } break; case VT_VARIANT: rgsaBounds = new SAFEARRAYBOUND[ cDims1 ]; Check( FALSE, NULL == rgsaBounds ); rgIndices = new LONG[ cDims1 ]; Check( FALSE, NULL == rgIndices ); // The Bounds are stored in the safearray in reversed order. Correct them so // that we can use CalcSafeArrayIndices for( i = 0; i < cDims1; i++ ) rgsaBounds[i] = psa1->rgsabound[ cDims1-1-i ]; for( i = 0; i < cElems; i++ ) { CPropVariant *pcpropvar1 = NULL, *pcpropvar2 = NULL; CalcSafeArrayIndices( i, rgIndices, rgsaBounds, cDims1 ); Check( S_OK, SafeArrayPtrOfIndex( psa1, rgIndices, reinterpret_cast(&pcpropvar1) )); Check( S_OK, SafeArrayPtrOfIndex( psa2, rgIndices, reinterpret_cast(&pcpropvar2) )); Check( TRUE, *pcpropvar1 == *pcpropvar2 ); } break; default: Check( FALSE, TRUE ); } // switch( vt1 ) delete[] rgIndices; delete[] rgsaBounds; } #ifndef _MAC // SYSTEMTIME isn't supported on the Mac. void Now(FILETIME *pftNow) { SYSTEMTIME stStart; GetSystemTime(&stStart); SystemTimeToFileTime(&stStart, pftNow); } #endif IStorage *_pstgTemp = NULL; IStorage *_pstgTempCopyTo = NULL; // _pstgTemp is copied to _pstgTempCopyTo unsigned int CTempStorage::_iName; PROPVARIANT * CGenProps::GetNext(int HowMany, int *pActual, BOOL fWrapOk, BOOL fNoNonSimple) { PROPVARIANT *pVar = new PROPVARIANT[HowMany]; if (pVar == NULL) return(NULL); for (int l=0; lcbSize = 10; Var.pclipdata->pClipData = new BYTE[ 10 ]; Var.pclipdata->ulClipFmt = 0; break; case VT_VERSIONED_STREAM: Var.pVersionedStream = new VERSIONEDSTREAM; UuidCreate( &Var.pVersionedStream->guidVersion ); Var.pVersionedStream->pStream = NULL; break; } } while ( (fNoNonSimple && (Var.vt == VT_STREAM || Var.vt == VT_STREAMED_OBJECT || Var.vt == VT_STORAGE || Var.vt == VT_STORED_OBJECT || Var.vt == VT_VERSIONED_STREAM) ) || !IsOriginalPropVariantType(Var.vt) ); g_pfnPropVariantCopy(pVar, &Var); g_pfnPropVariantClear(&Var); return(TRUE); } VOID CleanStat(ULONG celt, STATPROPSTG *psps) { while (celt--) { delete [] psps->lpwstrName; psps++; } } //+---------------------------------------------------------------------------- // // Function: PopulateRGPropVar // // Synopsis: This function fills an input array of PROPVARIANTs // with an assortment of properties. // // Note: For compatibility with the marshaling test, all // non-simple properties must be at the end of the array. // //+---------------------------------------------------------------------------- HRESULT PopulateRGPropVar( CPropVariant rgcpropvar[], CPropSpec rgcpropspec[], const OLECHAR *rgoszpropname[], IStorage *pstg ) { HRESULT hr = (HRESULT) E_FAIL; int i; ULONG ulPropIndex = 0; CLIPDATA clipdataNull = {0, 0, NULL}, clipdataNonNull = {0, 0, NULL}; CClipData cclipdataEmpty; cclipdataEmpty.Set( (ULONG) -1, "", 0 ); // Initialize the PropVariants for( i = 0; i < CPROPERTIES_ALL; i++ ) { rgcpropvar[i].Clear(); } /* // Create a I1 property rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR( "I1 Property" ); rgcpropvar[ulPropIndex] = (CHAR) 38; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_I1 ); ulPropIndex++; // Create a vector of I1s rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR( "Vector|I1 Property" ); rgcpropvar[ulPropIndex][1] = (CHAR) 22; rgcpropvar[ulPropIndex][0] = (CHAR) 23; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == (VT_VECTOR|VT_I1) ); ulPropIndex++; */ // Create a UI1 property rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR( "UI1 Property" ); rgcpropvar[ulPropIndex] = (UCHAR) 39; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_UI1 ); ulPropIndex++; // Create an I2 property rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR( "I2 Property" ); rgcpropvar[ulPropIndex] = (short) -502; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_I2 ); ulPropIndex++; // Create a UI2 property rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR( "UI2 Property" ); rgcpropvar[ulPropIndex] = (USHORT) 502; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_UI2 ); ulPropIndex++; // Create a BOOL property rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR( "Bool Property" ); rgcpropvar[ulPropIndex].SetBOOL( VARIANT_TRUE ); Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_BOOL ); ulPropIndex++; // Create a I4 property rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR( "I4 Property" ); rgcpropvar[ulPropIndex] = (long) -523; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_I4 ); ulPropIndex++; // Create a UI4 property rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR( "UI4 Property" ); rgcpropvar[ulPropIndex] = (ULONG) 530; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_UI4 ); ulPropIndex++; // Create a R4 property rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR( "R4 Property" ); rgcpropvar[ulPropIndex] = (float) 5.37; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_R4 ); ulPropIndex++; // Create an ERROR property rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR( "ERROR Property" ); rgcpropvar[ulPropIndex].SetERROR( STG_E_FILENOTFOUND ); Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_ERROR ); ulPropIndex++; // Create an I8 property LARGE_INTEGER large_integer; large_integer.LowPart = 551; large_integer.HighPart = 30; rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR( "I8 Property" ); rgcpropvar[ulPropIndex] = large_integer; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_I8 ); ulPropIndex++; // Create a UI8 property ULARGE_INTEGER ularge_integer; ularge_integer.LowPart = 561; ularge_integer.HighPart = 30; rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR( "UI8 Property" ); rgcpropvar[ulPropIndex] = ularge_integer; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_UI8 ); ulPropIndex++; // Create an R8 property rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR( "R8 Property" ); rgcpropvar[ulPropIndex] = (double) 571.36; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_R8 ); ulPropIndex++; // Create a CY property CY cy; cy.Hi = 123; cy.Lo = 456; rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR( "Cy Property" ); rgcpropvar[ulPropIndex] = cy; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_CY ); ulPropIndex++; // Create a DATE property rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR( "DATE Property" ); rgcpropvar[ulPropIndex].SetDATE( 587 ); Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_DATE ); ulPropIndex++; // Create a FILETIME property FILETIME filetime; filetime.dwLowDateTime = 0x767c0570; filetime.dwHighDateTime = 0x1bb7ecf; rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR( "FILETIME Property" ); rgcpropvar[ulPropIndex] = filetime; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_FILETIME ); ulPropIndex++; // Create a CLSID property rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR( "CLSID Property" ); rgcpropvar[ulPropIndex] = FMTID_SummaryInformation; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_CLSID ); ulPropIndex++; // Create a vector of CLSIDs rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR( "CLSID Vector Property" ); rgcpropvar[ulPropIndex][0] = FMTID_SummaryInformation; rgcpropvar[ulPropIndex][1] = FMTID_DocSummaryInformation; rgcpropvar[ulPropIndex][2] = FMTID_UserDefinedProperties; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == (VT_CLSID | VT_VECTOR) ); ulPropIndex++; // Create a BSTR property rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR("BSTR"); rgcpropvar[ulPropIndex].SetBSTR( OLESTR("BSTR Value") ); Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_BSTR ); ulPropIndex++; // Create a BSTR Vector property rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR("BSTR Vector"); for( i = 0; i < 3; i++ ) { OLECHAR olestrElement[] = OLESTR("# - BSTR Vector Element"); olestrElement[0] = (OLECHAR) i%10 + OLESTR('0'); rgcpropvar[ulPropIndex].SetBSTR( olestrElement, i ); } Check(TRUE, rgcpropvar[ulPropIndex].VarType() == (VT_BSTR | VT_VECTOR) ); ulPropIndex++; // Create a variant vector BSTR property. rgcpropspec[ulPropIndex ] = rgoszpropname[ulPropIndex] = OLESTR("BSTR Variant Vector"); for( i = 0; i < 3; i++ ) { if( i == 0 ) { rgcpropvar[ulPropIndex][0] = (PROPVARIANT) CPropVariant((long) 0x1234); } else { CPropVariant cpropvarBSTR; cpropvarBSTR.SetBSTR( OLESTR("# - Vector Variant BSTR") ); (cpropvarBSTR.GetBSTR())[0] = (OLECHAR) i%10 + OLESTR('0'); rgcpropvar[ulPropIndex][i] = (PROPVARIANT) cpropvarBSTR; } } Check(TRUE, rgcpropvar[ulPropIndex].VarType() == (VT_VARIANT | VT_VECTOR) ); ulPropIndex++; // Create an LPSTR property rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR("LPSTR Property"); rgcpropvar[ulPropIndex] = "LPSTR Value"; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_LPSTR ); ulPropIndex++; // Create some ClipFormat properties rgcpropspec[ ulPropIndex ] = rgoszpropname[ulPropIndex] = OLESTR("ClipFormat property"); rgcpropvar[ ulPropIndex ] = CClipData( L"Clipboard Data" ); Check(TRUE, rgcpropvar[ ulPropIndex ].VarType() == VT_CF ); ulPropIndex++; rgcpropspec[ ulPropIndex ] = rgoszpropname[ulPropIndex] = OLESTR("Empty ClipFormat property (NULL pointer)"); clipdataNull.cbSize = 4; clipdataNull.ulClipFmt = (ULONG) -1; clipdataNull.pClipData = NULL; rgcpropvar[ ulPropIndex ] = clipdataNull; Check(TRUE, rgcpropvar[ ulPropIndex ].VarType() == VT_CF ); ulPropIndex++; rgcpropspec[ ulPropIndex ] = rgoszpropname[ulPropIndex] = OLESTR("Empty ClipFormat property (non-NULL pointer)"); clipdataNonNull.cbSize = 4; clipdataNonNull.ulClipFmt = (ULONG) -1; clipdataNonNull.pClipData = new BYTE[ 0 ]; rgcpropvar[ ulPropIndex ] = clipdataNonNull; Check(TRUE, rgcpropvar[ ulPropIndex ].VarType() == VT_CF ); ulPropIndex++; // Create a vector of ClipFormat properties rgcpropspec[ ulPropIndex ] = rgoszpropname[ulPropIndex] = OLESTR("ClipFormat Array Property"); rgcpropvar[ ulPropIndex ][0] = CClipData( L"Clipboard Date element 1" ); rgcpropvar[ ulPropIndex ][1] = cclipdataEmpty; rgcpropvar[ ulPropIndex ][2] = clipdataNull; rgcpropvar[ ulPropIndex ][3] = clipdataNonNull; rgcpropvar[ ulPropIndex ][4] = CClipData( L"Clipboard Date element 2" ); Check(TRUE, rgcpropvar[ulPropIndex].VarType() == (VT_CF | VT_VECTOR) ); Check(TRUE, rgcpropvar[ulPropIndex].Count() == 5 ); ulPropIndex++; // Create an LPSTR|Vector property (e.g., the DocSumInfo // Document Parts array). rgcpropspec[ ulPropIndex ] = rgoszpropname[ulPropIndex] = OLESTR("LPSTR|Vector property"); rgcpropvar[ ulPropIndex ][0] = "LPSTR Element 0"; rgcpropvar[ ulPropIndex ][1] = "LPSTR Element 1"; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == (VT_LPSTR | VT_VECTOR) ); ulPropIndex++; // Create an LPWSTR|Vector property rgcpropspec[ ulPropIndex ] = rgoszpropname[ulPropIndex] = OLESTR("LPWSTR|Vector property"); rgcpropvar[ ulPropIndex ][0] = L"LPWSTR Element 0"; rgcpropvar[ ulPropIndex ][1] = L"LPWSTR Element 1"; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == (VT_LPWSTR | VT_VECTOR) ); ulPropIndex++; // Create a DocSumInfo HeadingPairs array. rgcpropspec[ ulPropIndex ] = rgoszpropname[ulPropIndex] = OLESTR("HeadingPair array"); rgcpropvar[ ulPropIndex ][0] = (PROPVARIANT) CPropVariant( "Heading 0" ); rgcpropvar[ ulPropIndex ][1] = (PROPVARIANT) CPropVariant( (long) 1 ); rgcpropvar[ ulPropIndex ][2] = (PROPVARIANT) CPropVariant( "Heading 1" ); rgcpropvar[ ulPropIndex ][3] = (PROPVARIANT) CPropVariant( (long) 1 ); Check(TRUE, rgcpropvar[ulPropIndex].VarType() == (VT_VARIANT | VT_VECTOR) ); ulPropIndex++; // Create some NULL (but extant) properties rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR("Empty LPSTR"); rgcpropvar[ulPropIndex] = ""; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_LPSTR ); ulPropIndex++; rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR("Empty LPWSTR"); rgcpropvar[ulPropIndex] = L""; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_LPWSTR ); ulPropIndex++; rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR("Empty BLOB"); rgcpropvar[ulPropIndex] = CBlob(0); Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_BLOB ); ulPropIndex++; rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR("Empty BSTR"); rgcpropvar[ulPropIndex].SetBSTR( OLESTR("") ); Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_BSTR ); ulPropIndex++; // Create some NULL (and non-extant) properties rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR("NULL BSTR"); ((PROPVARIANT*)&rgcpropvar[ulPropIndex])->vt = VT_BSTR; ((PROPVARIANT*)&rgcpropvar[ulPropIndex])->bstrVal = NULL; ulPropIndex++; // *** rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR("NULL LPSTR"); ((PROPVARIANT*)&rgcpropvar[ulPropIndex])->vt = VT_LPSTR; ((PROPVARIANT*)&rgcpropvar[ulPropIndex])->pszVal = NULL; ulPropIndex++; rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR("NULL LPWSTR"); ((PROPVARIANT*)&rgcpropvar[ulPropIndex])->vt = VT_LPWSTR; ((PROPVARIANT*)&rgcpropvar[ulPropIndex])->pwszVal = NULL; ulPropIndex++; // *** rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR("BSTR Vector with NULL element"); rgcpropvar[ulPropIndex].SetBSTR( NULL, 0 ); Check(TRUE, rgcpropvar[ulPropIndex].VarType() == (VT_VECTOR | VT_BSTR) ); ulPropIndex++; /* rgcpropspec[ulPropIndex] = rgoszpropname[ulPropIndex] = OLESTR("LPSTR Vector with NULL element"); rgcpropvar[ulPropIndex].SetLPSTR( NULL, 0 ); Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_VECTOR | VT_LPSTR ); ulPropIndex++; */ if( !(g_Restrictions & RESTRICT_SIMPLE_ONLY) ) { // Create an IStream property IStream *pstmProperty = NULL; CheckLockCount( pstg, 0 ); Check(S_OK, pstg->CreateStream( OLESTR("Stream Property"), STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0L, 0L, &pstmProperty )); CheckLockCount( pstg, 0 ); Check(S_OK, pstmProperty->Write("Hi There", 9, NULL )); Check(S_OK, pstmProperty->Seek( CLargeInteger(0), STREAM_SEEK_SET, NULL )); CheckLockCount( pstmProperty, 0 ); rgcpropspec[ ulPropIndex ] = rgoszpropname[ulPropIndex] = OLESTR("Stream Property"); rgcpropvar[ ulPropIndex ] = pstmProperty; pstmProperty->Release(); pstmProperty = NULL; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_STREAM ); ulPropIndex++; // Create a VersionedStream property VERSIONEDSTREAM VersionedStreamProperty; UuidCreate( &VersionedStreamProperty.guidVersion ); Check(S_OK, pstg->CreateStream( OLESTR("Versioned Stream Property"), STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0L, 0L, &VersionedStreamProperty.pStream )); Check(S_OK, VersionedStreamProperty.pStream->Write("Hi There, version", 9, NULL )); Check(S_OK, VersionedStreamProperty.pStream->Seek( CLargeInteger(0), STREAM_SEEK_SET, NULL )); rgcpropspec[ ulPropIndex ] = rgoszpropname[ ulPropIndex ] = OLESTR("Versioned Stream Property"); rgcpropvar[ ulPropIndex ] = VersionedStreamProperty; RELEASE_INTERFACE( VersionedStreamProperty.pStream ); Check( TRUE, rgcpropvar[ulPropIndex].VarType() == VT_VERSIONED_STREAM ); ulPropIndex++; // Create an IStorage property IStorage *pstgProperty = NULL; Check(S_OK, StgCreateDocfile(NULL, STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE|STGM_DELETEONRELEASE, 0, &pstgProperty )); rgcpropspec[ ulPropIndex ] = rgoszpropname[ulPropIndex] = OLESTR("Storage Property"); rgcpropvar[ ulPropIndex ] = pstgProperty; pstgProperty->Release(); pstgProperty = NULL; Check(TRUE, rgcpropvar[ulPropIndex].VarType() == VT_STORAGE ); ulPropIndex++; } // ---- // Exit // ---- delete [] clipdataNonNull.pClipData; memset( &clipdataNonNull, 0, sizeof(clipdataNonNull) ); Check(TRUE, CPROPERTIES_ALL >= ulPropIndex ); hr = S_OK; return(hr); } HRESULT ResetRGPropVar( CPropVariant rgcpropvar[] ) { HRESULT hr = S_OK; for( int i = 0; i < CPROPERTIES_ALL; i++ ) { IStream *pstm = NULL; if( VT_STREAM == rgcpropvar[i].VarType() || VT_STREAMED_OBJECT == rgcpropvar[i].VarType() ) { pstm = rgcpropvar[i].GetSTREAM(); } else if( VT_VERSIONED_STREAM == rgcpropvar[i].VarType() ) { pstm = rgcpropvar[i].GetVERSIONEDSTREAM().pStream; } if( NULL != pstm ) { hr = pstm->Seek( CLargeInteger(0), STREAM_SEEK_SET, NULL ); if( FAILED(hr) ) goto Exit; } } Exit: return( hr) ; } void CheckFormatVersion( IPropertyStorage *ppropstg, WORD wExpected ) { HRESULT hr = S_OK; NTSTATUS status; WORD wActual; IStorageTest *ptest = NULL; hr = ppropstg->QueryInterface( IID_IStorageTest, reinterpret_cast(&ptest) ); if( SUCCEEDED(hr) ) { Check( S_OK, ptest->GetFormatVersion(&wActual) ); Check( wExpected, wActual ); RELEASE_INTERFACE(ptest); } return; } void CheckLockCount( IUnknown *punk, LONG lExpected ) { IStorageTest *ptest = NULL; HRESULT hr = S_OK; hr = punk->QueryInterface( IID_IStorageTest, reinterpret_cast(&ptest) ); if( SUCCEEDED(hr) ) Check( lExpected, ptest->GetLockCount() ); RELEASE_INTERFACE(ptest); return; } FILETIME operator - ( const FILETIME &ft1, const FILETIME &ft2 ) { FILETIME ftDiff; if( ft1 < ft2 ) { ftDiff.dwLowDateTime = 0; ftDiff.dwHighDateTime = 0; } else if( ft1.dwLowDateTime >= ft2.dwLowDateTime ) { ftDiff.dwLowDateTime = ft1.dwLowDateTime - ft2.dwLowDateTime; ftDiff.dwHighDateTime = ft1.dwHighDateTime - ft2.dwHighDateTime; } else { ftDiff.dwLowDateTime = ft1.dwLowDateTime - ft2.dwLowDateTime; ftDiff.dwLowDateTime = (DWORD) -1 - ftDiff.dwLowDateTime; ftDiff.dwHighDateTime = ft1.dwHighDateTime - ft2.dwHighDateTime - 1; } return( ftDiff ); } FILETIME operator -= ( FILETIME &ft1, const FILETIME &ft2 ) { ft1 = ft1 - ft2; return( ft1 ); } void CheckTime(const FILETIME &ftStart, const FILETIME &ftPropSet) { FILETIME ftNow; CoFileTimeNow(&ftNow); if (ftPropSet.dwLowDateTime == 0 && ftPropSet.dwHighDateTime == 0) { return; } // if ftPropSet < ftStart || ftNow < ftPropSet, error Check(TRUE, ftStart <= ftPropSet && ftPropSet <= ftNow ); } void CheckStat( IPropertyStorage *pPropSet, REFFMTID fmtid, REFCLSID clsid, ULONG PropSetFlag, const FILETIME & ftStart, DWORD dwOSVersion ) { STATPROPSETSTG StatPropSetStg; Check(S_OK, pPropSet->Stat(&StatPropSetStg)); Check(TRUE, StatPropSetStg.fmtid == fmtid); Check(TRUE, StatPropSetStg.clsid == clsid); Check(TRUE, StatPropSetStg.grfFlags == PropSetFlag); Check(TRUE, StatPropSetStg.dwOSVersion == dwOSVersion); CheckTime(ftStart, StatPropSetStg.mtime); CheckTime(ftStart, StatPropSetStg.ctime); CheckTime(ftStart, StatPropSetStg.atime); } BOOL IsEqualSTATPROPSTG(const STATPROPSTG *p1, const STATPROPSTG *p2) { BOOL f1 = p1->propid == p2->propid; BOOL f2 = p1->vt == p2->vt; BOOL f3 = (p1->lpwstrName == NULL && p2->lpwstrName == NULL) || ((p1->lpwstrName != NULL && p2->lpwstrName != NULL) && ocscmp(p1->lpwstrName, p2->lpwstrName) == 0); return(f1 && f2 && f3); } void CreateCodePageTestFile( LPOLESTR poszFileName, IStorage **ppStg ) { Check(TRUE, poszFileName != NULL ); // -------------- // Initialization // -------------- TSafeStorage< IPropertySetStorage > pPSStg; TSafeStorage< IPropertyStorage > pPStg; PROPSPEC propspec; CPropVariant cpropvar; *ppStg = NULL; // Create the Docfile. Check(S_OK, g_pfnStgCreateStorageEx( poszFileName, STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, DetermineStgFmt( g_enumImplementation ), 0, NULL, NULL, DetermineStgIID( g_enumImplementation ), reinterpret_cast(ppStg) )); // Get an IPropertySetStorage Check(S_OK, StgToPropSetStg( *ppStg, &pPSStg )); // Create an IPropertyStorage Check(S_OK, pPSStg->Create( FMTID_NULL, NULL, PROPSETFLAG_ANSI, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, &pPStg )); // ---------------------- // Write a named property // ---------------------- // Write a named I4 property propspec.ulKind = PRSPEC_LPWSTR; propspec.lpwstr = CODEPAGE_TEST_NAMED_PROPERTY; cpropvar = (LONG) 0x12345678; Check(S_OK, pPStg->WriteMultiple( 1, &propspec, &cpropvar, PID_FIRST_USABLE )); // -------------------------- // Write singleton properties // -------------------------- // Write an un-named BSTR. propspec.ulKind = PRSPEC_PROPID; propspec.propid = CODEPAGE_TEST_UNNAMED_BSTR_PROPID; cpropvar.SetBSTR( OLESTR("BSTR Property") ); Check(S_OK, pPStg->WriteMultiple( 1, &propspec, &cpropvar, PID_FIRST_USABLE )); // Write an un-named I4 propspec.ulKind = PRSPEC_PROPID; propspec.propid = CODEPAGE_TEST_UNNAMED_I4_PROPID; cpropvar = (LONG) 0x76543210; Check(S_OK, pPStg->WriteMultiple( 1, &propspec, &cpropvar, PID_FIRST_USABLE )); // ----------------------- // Write vector properties // ----------------------- // Write a vector of BSTRs. propspec.ulKind = PRSPEC_PROPID; propspec.propid = CODEPAGE_TEST_VBSTR_PROPID; cpropvar.SetBSTR( OLESTR("BSTR Element 1"), 1 ); cpropvar.SetBSTR( OLESTR("BSTR Element 0"), 0 ); Check(TRUE, (VT_VECTOR | VT_BSTR) == cpropvar.VarType() ); Check(S_OK, pPStg->WriteMultiple( 1, &propspec, &cpropvar, PID_FIRST_USABLE )); // ------------------------------- // Write Variant Vector Properties // ------------------------------- // Write a variant vector that has a BSTR propspec.ulKind = PRSPEC_PROPID; propspec.propid = CODEPAGE_TEST_VPROPVAR_BSTR_PROPID; CPropVariant cpropvarT; cpropvarT.SetBSTR( OLESTR("PropVar Vector BSTR") ); cpropvar[1] = (PROPVARIANT) cpropvarT; cpropvar[0] = (PROPVARIANT) CPropVariant((long) 44); Check(TRUE, (VT_VARIANT | VT_VECTOR) == cpropvar.VarType() ); Check(S_OK, pPStg->WriteMultiple( 1, &propspec, &cpropvar, PID_FIRST_USABLE )); } // CreateCodePageTestFile() void ModifyPropSetCodePage( IStorage *pStg, const FMTID &fmtid, USHORT usCodePage ) { Check(TRUE, pStg != NULL ); // -------------- // Initialization // -------------- OLECHAR aocPropSetName[ 32 ]; DWORD dwVT; ULONG cbWritten = 0; TSafeStorage< IStream > pStm; CPropVariant cpropvar; // Open the Stream RtlGuidToPropertySetName( &fmtid, aocPropSetName ); Check(S_OK, pStg->OpenStream( aocPropSetName, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, &pStm )); // Seek to the codepage property SeekToProperty( pStm, PID_CODEPAGE ); // Move past the VT Check(S_OK, pStm->Read( &dwVT, sizeof(DWORD), NULL )); // Write the new code page. PropByteSwap( &usCodePage ); Check(S_OK, pStm->Write( &usCodePage, sizeof(usCodePage), &cbWritten )); Check(TRUE, cbWritten == sizeof(usCodePage) ); } // ModifyPropSetCodePage() void ModifyPropertyType( IStorage *pStg, const FMTID &fmtid, PROPID propid, VARTYPE vt ) { Check(TRUE, pStg != NULL ); // -------------- // Initialization // -------------- OLECHAR aocPropSetName[ 32 ]; DWORD dwVT; ULONG cbWritten = 0; TSafeStorage< IStream > pStm; CPropVariant cpropvar; // Open the Stream RtlGuidToPropertySetName( &fmtid, aocPropSetName ); Check(S_OK, pStg->OpenStream( aocPropSetName, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, &pStm )); // Seek to the property SeekToProperty( pStm, propid ); // Write the new VT PropByteSwap( &vt ); Check(S_OK, pStm->Write( &vt, sizeof(DWORD), &cbWritten )); Check(TRUE, cbWritten == sizeof(DWORD) ); } // ModifyPropertyType() void SeekToProperty( IStream *pStm, PROPID propidSearch ) { // -------------- // Initialization // -------------- OLECHAR aocPropSetName[ 32 ]; DWORD dwOffset = 0; DWORD dwcbSection = 0; DWORD dwcProperties = 0; ULONG ulcbWritten = 0; LARGE_INTEGER liSectionOffset, liCodePageOffset; CPropVariant cpropvar; // Seek past the propset header and the format ID. liSectionOffset.HighPart = 0; liSectionOffset.LowPart = sizeof(PROPERTYSETHEADER) + sizeof(FMTID); Check(S_OK, pStm->Seek(liSectionOffset, STREAM_SEEK_SET, NULL )); // Move to the beginning of the property set. liSectionOffset.HighPart = 0; Check(S_OK, pStm->Read( &liSectionOffset.LowPart, sizeof(DWORD), NULL )); PropByteSwap(&liSectionOffset.LowPart); Check(S_OK, pStm->Seek( liSectionOffset, STREAM_SEEK_SET, NULL )); // Get the section size & property count. Check(S_OK, pStm->Read( &dwcbSection, sizeof(DWORD), NULL )); PropByteSwap( &dwcbSection ); Check(S_OK, pStm->Read( &dwcProperties, sizeof(DWORD), NULL )); PropByteSwap( &dwcProperties ); // Scan for the property. for( ULONG ulIndex = 0; ulIndex < dwcProperties; ulIndex++ ) { PROPID propid; // Read in the PROPID Check(S_OK, pStm->Read( &propid, sizeof(PROPID), NULL )); // Read in this PROPIDs offset (we may not need it, but we want // to seek past it. Check(S_OK, pStm->Read( &dwOffset, sizeof(dwOffset), NULL )); PropByteSwap(dwOffset); // Is it the one we're looking for? if( PropByteSwap(propid) == propidSearch ) break; } // Verify that the above for loop terminated because we found // the codepage. Check( TRUE, ulIndex < dwcProperties ); // Move to the property. liSectionOffset.LowPart += dwOffset; Check(S_OK, pStm->Seek( liSectionOffset, STREAM_SEEK_SET, NULL )); return; } // SeekToProperty() void ModifyOSVersion( IStorage* pStg, DWORD dwOSVersion ) { Check(TRUE, pStg != NULL ); // -------------- // Initialization // -------------- OLECHAR aocPropSetName[ 32 ]; ULONG ulcbWritten = 0; LARGE_INTEGER liOffset; TSafeStorage< IStream > pStm; // Open the Stream RtlGuidToPropertySetName( &FMTID_NULL, aocPropSetName ); Check(S_OK, pStg->OpenStream( aocPropSetName, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, &pStm )); // Seek to the OS Version field in the header. liOffset.HighPart = 0; liOffset.LowPart = sizeof(WORD) /*(byte-order)*/ + sizeof(WORD) /*(format)*/ ; Check(S_OK, pStm->Seek( liOffset, STREAM_SEEK_SET, NULL )); // Set the new OS Version PropByteSwap( &dwOSVersion ); Check(S_OK, pStm->Write( &dwOSVersion, sizeof(dwOSVersion), &ulcbWritten )); Check(TRUE, ulcbWritten == sizeof(dwOSVersion) ); } // ModifyOSVersion() //+--------------------------------------------------------- // // Function: MungePropertyStorage // // Synopsis: This routine munges the properties in a // Property Storage. The values of the properties // remain the same, but the underlying serialization // is new (the properties are read, the property // storage is deleted, and the properties are // re-written). // // Inputs: [IPropertySetStorage*] ppropsetgstg (in) // The Property Storage container. // [FMTID] fmtid // The Property Storage to munge. // // Returns: None. // // Note: Property names in the dictionary for which // there is no property are not munged. // //+--------------------------------------------------------- #define MUNGE_PROPVARIANT_STEP 10 void MungePropertyStorage( IPropertySetStorage *ppropsetstg, FMTID fmtid ) { // ------ // Locals // ------ HRESULT hr; ULONG celt, ulIndex; TSafeStorage< IPropertyStorage > ppropstg; IEnumSTATPROPSTG *penumstatpropstg; PROPVARIANT *rgpropvar = NULL; STATPROPSTG *rgstatpropstg = NULL; ULONG cProperties = 0; // Allocate an array of PropVariants. We may grow this later. rgpropvar = new PROPVARIANT[ MUNGE_PROPVARIANT_STEP ]; Check( FALSE, NULL == rgpropvar ); // Allocate an array of STATPROPSTGs. We may grow this also. rgstatpropstg = new STATPROPSTG[ MUNGE_PROPVARIANT_STEP ]; Check( FALSE, NULL == rgstatpropstg ); // ----------------- // Get an Enumerator // ----------------- // Open the Property Storage. We may get an error if we're attempting // the UserDefined propset. If it's file-not-found, then simply return, // it's not an error, and there's nothing to do. hr = ppropsetstg->Open( fmtid, STGM_DIRECT | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, &ppropstg ); if( FMTID_UserDefinedProperties == fmtid && (HRESULT) STG_E_FILENOTFOUND == hr ) { goto Exit; } Check( S_OK, hr ); // Get an Enumerator Check(S_OK, ppropstg->Enum( &penumstatpropstg )); // -------------------------------------------- // Read & delete in all of the properties/names // -------------------------------------------- // Get the first property from the enumerator hr = penumstatpropstg->Next( 1, &rgstatpropstg[cProperties], &celt ); Check( TRUE, (HRESULT) S_OK == hr || (HRESULT) S_FALSE == hr ); // Iterate through the properties. while( celt > 0 ) { PROPSPEC propspec; propspec.ulKind = PRSPEC_PROPID; propspec.propid = rgstatpropstg[cProperties].propid; // Read and delete the property Check(S_OK, ppropstg->ReadMultiple( 1, &propspec, &rgpropvar[cProperties] )); Check(S_OK, ppropstg->DeleteMultiple( 1, &propspec )); // If there is a property name, delete it also. if( NULL != rgstatpropstg[cProperties].lpwstrName ) { // We have a name. Check(S_OK, ppropstg->DeletePropertyNames( 1, &rgstatpropstg[cProperties].propid )); } // Increment the property count. cProperties++; // Do we need to grow the arrays? if( 0 != cProperties && (cProperties % MUNGE_PROPVARIANT_STEP) == 0 ) { // Yes - they must be reallocated. rgpropvar = (PROPVARIANT*) CoTaskMemRealloc( rgpropvar, ( (cProperties + MUNGE_PROPVARIANT_STEP) * sizeof(*rgpropvar) )); Check( FALSE, NULL == rgpropvar ); rgstatpropstg = (STATPROPSTG*) CoTaskMemRealloc( rgstatpropstg, ( (cProperties + MUNGE_PROPVARIANT_STEP) * sizeof(*rgstatpropstg) )); Check( FALSE, NULL == rgstatpropstg ); } // Move on to the next property. hr = penumstatpropstg->Next( 1, &rgstatpropstg[cProperties], &celt ); Check( TRUE, (HRESULT) S_OK == hr || (HRESULT) S_FALSE == hr ); } // while( celt > 0 ) // ------------------------------------- // Write the properties & names back out // ------------------------------------- for( ulIndex = 0; ulIndex < cProperties; ulIndex++ ) { // Write the property. PROPSPEC propspec; propspec.ulKind = PRSPEC_PROPID; propspec.propid = rgstatpropstg[ ulIndex ].propid; Check(S_OK, ppropstg->WriteMultiple(1, &propspec, &rgpropvar[ulIndex], PID_FIRST_USABLE )); // If this property has a name, write it too. if( rgstatpropstg[ ulIndex ].lpwstrName != NULL ) { Check(S_OK, ppropstg->WritePropertyNames( 1, &rgstatpropstg[ulIndex].propid, &rgstatpropstg[ulIndex].lpwstrName )); } } // for( ulIndex = 0; ulIndex < cProperties; ulIndex++ ) // ---- // Exit // ---- Exit: if( penumstatpropstg ) { penumstatpropstg->Release(); penumstatpropstg = NULL; } // Free the PropVariants if( rgpropvar ) { g_pfnFreePropVariantArray( cProperties, rgpropvar ); delete [] rgpropvar; } // Free the property names if( rgstatpropstg ) { for( ulIndex = 0; ulIndex < cProperties; ulIndex++ ) { if( NULL != rgstatpropstg[ ulIndex ].lpwstrName ) { delete [] rgstatpropstg[ ulIndex ].lpwstrName; } } // for( ulIndex = 0; ulIndex < cProperties; ulIndex++ ) delete [] rgstatpropstg; } } // MungePropertyStorage //+--------------------------------------------------------- // // Function: MungeStorage // // Synopsis: This routine munges the property sets in a // Storage. The properties themselves are not // modified, but the serialized bytes are. // For each property set, all the properties are // read, the property set is deleted, and // the properties are re-written. // // Inputs: [IStorage*] pstg (in) // The Storage to munge. // // Returns: None. // // Note: This routine only munges simple property // sets. // //+--------------------------------------------------------- void MungeStorage( IStorage *pstg ) { // ------ // Locals // ------ HRESULT hr; ULONG celt; STATPROPSETSTG statpropsetstg; STATSTG statstg; TSafeStorage< IPropertySetStorage > ppropsetstg; TSafeStorage< IPropertyStorage > ppropstg; IEnumSTATPROPSETSTG *penumstatpropsetstg; IEnumSTATSTG *penumstatstg; // ----------------------------------------------- // Munge each of the property sets in this Storage // ----------------------------------------------- // Get the IPropertySetStorage interface Check(S_OK, StgToPropSetStg( pstg, &ppropsetstg )); // Get a property storage enumerator Check(S_OK, ppropsetstg->Enum( &penumstatpropsetstg )); // Get the first STATPROPSETSTG hr = penumstatpropsetstg->Next( 1, &statpropsetstg, &celt ); Check( TRUE, (HRESULT) S_OK == hr || (HRESULT) S_FALSE == hr ); // Loop through the STATPROPSETSTGs. while( celt > 0 ) { // Is this a simple property storage (we don't // handle non-simple sets)? if( !(statpropsetstg.grfFlags & PROPSETFLAG_NONSIMPLE) ) { // Munge the Property Storage. MungePropertyStorage( ppropsetstg, statpropsetstg.fmtid ); } // Get the next STATPROPSETSTG // If we just did the first section of the DocSumInfo // property set, then attempt the second section. if( FMTID_DocSummaryInformation == statpropsetstg.fmtid ) { statpropsetstg.fmtid = FMTID_UserDefinedProperties; } else { hr = penumstatpropsetstg->Next( 1, &statpropsetstg, &celt ); Check( TRUE, (HRESULT) S_OK == hr || (HRESULT) S_FALSE == hr ); } } // We're done with the Property Storage enumerator. penumstatpropsetstg->Release(); penumstatpropsetstg = NULL; // ------------------------------------------ // Recursively munge each of the sub-storages // ------------------------------------------ // Get the IEnumSTATSTG enumerator Check(S_OK, pstg->EnumElements( 0L, NULL, 0L, &penumstatstg )); // Get the first STATSTG structure. hr = penumstatstg->Next( 1, &statstg, &celt ); Check( TRUE, (HRESULT) S_OK == hr || (HRESULT) S_FALSE == hr ); // Loop through the elements of this Storage. while( celt > 0 ) { // Is this a sub-Storage which must be // munged? if( STGTY_STORAGE & statstg.type // This is a Storage && 0x20 <= *statstg.pwcsName ) // But not a system Storage. { // We'll munge it. IStorage *psubstg; // Open the sub-storage. Check(S_OK, pstg->OpenStorage( statstg.pwcsName, NULL, STGM_DIRECT | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, NULL, 0L, &psubstg )); // Munge the sub-storage. MungeStorage( psubstg ); psubstg->Release(); psubstg = NULL; } delete [] statstg.pwcsName; statstg.pwcsName = NULL; // Move on to the next Storage element. hr = penumstatstg->Next( 1, &statstg, &celt ); Check( TRUE, (HRESULT) S_OK == hr || (HRESULT) S_FALSE == hr ); } penumstatstg->Release(); penumstatstg = NULL; } // MungeStorage //+---------------------------------------------------------------------------- //+---------------------------------------------------------------------------- CLSID CObjectWithPersistStorage::_clsid = { /* 01c0652e-c97c-11d1-b2a8-00c04fb9386d */ 0x01c0652e, 0xc97c, 0x11d1, {0xb2, 0xa8, 0x00, 0xc0, 0x4f, 0xb9, 0x38, 0x6d} }; CObjectWithPersistStorage::CObjectWithPersistStorage() { _poszData = NULL; _cRefs = 1; _fDirty = FALSE; } CObjectWithPersistStorage::CObjectWithPersistStorage( const OLECHAR *posz ) { new(this) CObjectWithPersistStorage; _poszData = new OLECHAR[ ocslen(posz) + 1 ]; Check( TRUE, NULL != _poszData ); ocscpy( _poszData, posz ); _fDirty = TRUE; } CObjectWithPersistStorage::~CObjectWithPersistStorage() { delete[] _poszData; } ULONG CObjectWithPersistStorage::AddRef() { ULONG cRefs = InterlockedIncrement( &_cRefs ); return( cRefs ); } ULONG CObjectWithPersistStorage::Release() { ULONG cRefs = InterlockedDecrement( &_cRefs ); if( 0 == cRefs ) delete this; return( cRefs ); } HRESULT CObjectWithPersistStorage::QueryInterface( REFIID iid, void **ppvObject ) { if( IID_IPersistStorage == iid || IID_IUnknown == iid ) { *ppvObject = static_cast(this); AddRef(); return( S_OK ); } else return( E_NOINTERFACE ); } HRESULT CObjectWithPersistStorage::GetClassID( CLSID *pclsid ) { *pclsid = GetClassID(); return( S_OK ); } HRESULT CObjectWithPersistStorage::IsDirty( void) { return( _fDirty ); } HRESULT CObjectWithPersistStorage::InitNew( /* [unique][in] */ IStorage __RPC_FAR *pStg) { return( E_NOTIMPL ); } HRESULT CObjectWithPersistStorage::Load( /* [unique][in] */ IStorage __RPC_FAR *pStg) { IStream *pStm = NULL; ULONG cbRead; Check( S_OK, pStg->OpenStream( OLESTR("CObjectWithPersistStorage"), NULL, STGM_READWRITE|STGM_SHARE_EXCLUSIVE, 0, &pStm )); _poszData = new OLECHAR[ MAX_PATH ]; Check( TRUE, NULL != _poszData ); Check( S_OK, pStm->Read( _poszData, sizeof(OLECHAR)*MAX_PATH, &cbRead )); _poszData[ MAX_PATH-1 ] = OLESTR('\0'); Check( 0, RELEASE_INTERFACE( pStm )); return( S_OK ); } HRESULT CObjectWithPersistStorage::Save( /* [unique][in] */ IStorage __RPC_FAR *pStgSave, /* [in] */ BOOL fSameAsLoad) { IStream *pStm = NULL; ULONG cbData, cbWritten; Check( S_OK, pStgSave->CreateStream( OLESTR("CObjectWithPersistStorage"), STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, 0, 0, &pStm )); cbData = sizeof(OLECHAR)*( 1 + ocslen(_poszData) ); Check( S_OK, pStm->Write( _poszData, cbData, &cbWritten )); Check( TRUE, cbData == cbWritten ); Check( 0, RELEASE_INTERFACE(pStm) ); return( S_OK ); } HRESULT CObjectWithPersistStorage::SaveCompleted( /* [unique][in] */ IStorage __RPC_FAR *pStgNew) { return( S_OK ); } HRESULT CObjectWithPersistStorage::HandsOffStorage( void) { return( E_NOTIMPL ); } BOOL CObjectWithPersistStorage::operator ==( const CObjectWithPersistStorage &Other ) { return( Other._poszData == _poszData || 0 == ocscmp( Other._poszData, _poszData )); } CLSID CObjectWithPersistStream::_clsid= { /* b447cba0-c991-11d1-b2a8-00c04fb9386d */ 0xb447cba0, 0xc991, 0x11d1, {0xb2, 0xa8, 0x00, 0xc0, 0x4f, 0xb9, 0x38, 0x6d} }; CObjectWithPersistStream::CObjectWithPersistStream() { _poszData = NULL; _cRefs = 1; _fDirty = FALSE; } CObjectWithPersistStream::CObjectWithPersistStream( const OLECHAR *posz ) { new(this) CObjectWithPersistStream; _poszData = new OLECHAR[ ocslen(posz) + 1 ]; Check( TRUE, NULL != _poszData ); ocscpy( _poszData, posz ); _fDirty = TRUE; } CObjectWithPersistStream::~CObjectWithPersistStream() { delete[] _poszData; } ULONG CObjectWithPersistStream::AddRef() { ULONG cRefs = InterlockedIncrement( &_cRefs ); return( cRefs ); } ULONG CObjectWithPersistStream::Release() { ULONG cRefs = InterlockedDecrement( &_cRefs ); if( 0 == cRefs ) delete this; return( cRefs ); } HRESULT CObjectWithPersistStream::QueryInterface( REFIID iid, void **ppvObject ) { if( IID_IPersistStream == iid || IID_IUnknown == iid ) { *ppvObject = static_cast(this); AddRef(); return( S_OK ); } else return( E_NOINTERFACE ); } HRESULT CObjectWithPersistStream::GetClassID( CLSID *pclsid ) { *pclsid = GetClassID(); return( S_OK ); } HRESULT CObjectWithPersistStream::IsDirty( void) { return( _fDirty ); } HRESULT CObjectWithPersistStream::Load( /* [unique][in] */ IStream __RPC_FAR *pStm) { ULONG cbRead; _poszData = new OLECHAR[ MAX_PATH ]; Check( TRUE, NULL != _poszData ); Check( S_OK, pStm->Read( _poszData, sizeof(OLECHAR)*MAX_PATH, &cbRead )); _poszData[ MAX_PATH-1 ] = OLESTR('\0'); return( S_OK ); } HRESULT CObjectWithPersistStream::Save( /* [unique][in] */ IStream __RPC_FAR *pStm, /* [in] */ BOOL fClearDirty) { ULONG cbData, cbWritten; cbData = sizeof(OLECHAR)*( 1 + ocslen(_poszData) ); Check( S_OK, pStm->Write( _poszData, cbData, &cbWritten )); Check( TRUE, cbData == cbWritten ); return( S_OK ); } HRESULT CObjectWithPersistStream::GetSizeMax( /* [out] */ ULARGE_INTEGER __RPC_FAR *pcbSize) { return( E_NOTIMPL ); } BOOL CObjectWithPersistStream::operator ==( const CObjectWithPersistStream &Other ) { return( Other._poszData == _poszData || 0 == ocscmp( Other._poszData, _poszData )); } //+---------------------------------------------------------------------------- //+---------------------------------------------------------------------------- void DeleteBagExProperties( IPropertyBagEx *pbag, const OLECHAR *poszPrefix ) { HRESULT hr = S_OK; IEnumSTATPROPBAG *penum = NULL; STATPROPBAG statpropbag; // Get an enumerator of the properties to be deleted. Check( S_OK, pbag->Enum( poszPrefix, 0, &penum )); // Loop through and delete the properties hr = penum->Next(1, &statpropbag, NULL ); Check( TRUE, SUCCEEDED(hr) ); while( S_OK == hr ) { Check( S_OK, pbag->DeleteMultiple(1, &statpropbag.lpwstrName, 0 )); delete [] statpropbag.lpwstrName; statpropbag.lpwstrName = NULL; hr = penum->Next(1, &statpropbag, NULL ); Check( TRUE, SUCCEEDED(hr) ); } // while( S_OK == hr ) RELEASE_INTERFACE(penum); return; } // EmptyPropertyBagEx //+---------------------------------------------------------------------------- // // Function: DetermineSystemInfo // // Synopsis: Fill in the g_SystemInfo structure. // // Inputs: None. // // Returns: None. // //+---------------------------------------------------------------------------- void DetermineSystemInfo() { // Initilize g_SystemInfo. g_SystemInfo.osenum = osenumUnknown; g_SystemInfo.fIPropMarshaling = FALSE; #ifdef _MAC // Set the OS type. g_SystemInfo.osenum = osenumMac; #else DWORD dwVersion; // Get the OS Version dwVersion = GetVersion(); // Is this an NT system? if( (dwVersion & 0x80000000) == 0 ) { // Is this at least NT4? if( LOBYTE(LOWORD( dwVersion )) >= 4 ) g_SystemInfo.osenum = osenumNT4; // Or, is this pre-NT4? else if( LOBYTE(LOWORD( dwVersion )) == 3 ) { g_SystemInfo.osenum = osenumNT3; } } // Otherwise, this is some kind of Win95 machine. else { HINSTANCE hinst; FARPROC farproc; // Load OLE32, and see if CoIntializeEx exists. If it does, // then DCOM95 is installed. Otherwise, this is just the base // Win95. hinst = LoadLibraryA( "ole32.dll" ); Check( TRUE, hinst != NULL ); farproc = GetProcAddress( hinst, "CoInitializeEx" ); if( NULL != farproc ) { g_SystemInfo.osenum = osenumDCOM95; } else if( ERROR_PROC_NOT_FOUND == GetLastError() ) { g_SystemInfo.osenum = osenumWin95; } } // if( (dwVersion & 0x80000000) == 0 ) Check( TRUE, g_SystemInfo.osenum != osenumUnknown ); #endif // #ifdef _MAC ... #else if( osenumWin95 == g_SystemInfo.osenum || osenumNT3 == g_SystemInfo.osenum ) { g_SystemInfo.fIPropMarshaling = TRUE; } } void DisplayUsage( LPSTR pszCommand ) { #ifndef _MAC printf("\n"); printf(" Usage: %s [options]\n", pszCommand); printf(" Options:\n"); printf(" /s run Standard tests\n" ); printf(" /w run the Word 6 test\n"); printf(" /m run the Marshaling test\n"); printf(" /c run the CoFileTimeNow\n"); printf(" /p run the Performance test\n"); printf(" /a run All tests\n" ); printf(" /k run the simple leaK test\n" ); printf(" /n use nt5props.dll rather than ole32.dll where possible\n"); printf(" (mostly for STGFMT_FILE)\n" ); printf("\n"); printf(" /i# Implementation to use:\n"); printf(" 0 => Use DocFile and QI for IPropSetStg (default)\n"); printf(" 1 => Use DocFile and use Stg*Prop*Stg\n"); printf(" 3 => Use NSS\n"); printf(" 4 => Use NTFS native property sets\n"); printf(" /l Don't register the local server\n"); printf(" /v Verbose output\n" ); printf("\n"); printf(" File & Directory Options:\n" ); printf(" /t specifies temporary directory\n" ); printf(" (used during standard & optional tests - if not specified,\n" ); printf(" a default will be used)\n" ); printf(" /g specifies a file to be munGed\n" ); printf(" (propsets are read, deleted, & re-written)\n" ); printf(" /d specifies a file to be Dumped\n" ); printf(" (propsets are dumped to stdout\n" ); printf("\n"); printf(" For Example:\n" ); printf(" %s -smw /i1 -t d:\\test\n", pszCommand ); printf(" %s -d word6.doc\n", pszCommand ); printf(" %s -g word6.doc\n", pszCommand ); printf("\n"); #endif return; } ULONG ProcessCommandLine( int cArg, const LPSTR rgszArg[], LPSTR *ppszFileToDump, LPSTR *ppszFileToMunge, LPSTR *ppszTemporaryDirectory ) { ULONG ulTestOptions = 0; ULONG ulTestOptionsT = 0; int nArgIndex; if( 2 > cArg ) { goto Exit; } for( nArgIndex = 1; nArgIndex < cArg; nArgIndex++ ) { if( rgszArg[nArgIndex][0] == '/' || rgszArg[nArgIndex][0] == '-' ) { BOOL fNextArgument = FALSE; for( int nOptionSubIndex = 1; rgszArg[nArgIndex][nOptionSubIndex] != '\0' && !fNextArgument; nOptionSubIndex++ ) { switch( rgszArg[nArgIndex][nOptionSubIndex] ) { case 's': case 'S': ulTestOptionsT |= TEST_STANDARD; break; case 'a': case 'A': ulTestOptionsT |= TEST_WORD6 | TEST_MARSHALING | TEST_COFILETIMENOW | TEST_PERFORMANCE; break; case 'g': case 'G': if( NULL != *ppszFileToMunge ) printf( "Error: Only one file may be munged\n" ); else { nArgIndex++; *ppszFileToMunge = &rgszArg[nArgIndex][0]; fNextArgument = TRUE; if(**ppszFileToMunge == '-' || **ppszFileToMunge == '/') { printf( "Error: Missing filename for munge option\n" ); goto Exit; } } break; case 'w': case 'W': ulTestOptionsT |= TEST_WORD6; break; case 'm': case 'M': ulTestOptionsT |= TEST_MARSHALING; break; case 'k': case 'K': ulTestOptionsT |= TEST_SIMPLE_LEAKS; break; case 'c': case 'C': ulTestOptionsT |= TEST_COFILETIMENOW; break; case 'p': case 'P': ulTestOptionsT |= TEST_PERFORMANCE; break; case 'i': case 'I': { int nSubOption = rgszArg[nArgIndex][++nOptionSubIndex]; if( PROPIMP_UNKNOWN != g_enumImplementation ) { printf( "Error in \"/i\" option (too many occurrences)\n" ); goto Exit; } switch( nSubOption ) { case '0': // default, if unspecified g_enumImplementation = PROPIMP_DOCFILE_QI; break; case '1': g_enumImplementation = PROPIMP_DOCFILE_OLE32; break; case '3': g_enumImplementation = PROPIMP_STORAGE; break; case '4': g_enumImplementation = PROPIMP_NTFS; break; default: printf( "Error in \"/i\" option\n" ); goto Exit; } break; } case 't': case 'T': if( NULL != *ppszTemporaryDirectory ) { printf( "Error: Only one temporary directory may be specified\n" ); } else { nArgIndex++; *ppszTemporaryDirectory = &rgszArg[nArgIndex][0]; fNextArgument = TRUE; if(**ppszTemporaryDirectory == '-' || **ppszTemporaryDirectory == '/' ) { printf( "Error: Missing name for temporary directory option\n" ); goto Exit; } } break; case 'l': case 'L': g_fRegisterLocalServer = FALSE; break; case 'n': case 'N': g_fUseNt5PropsDll = TRUE; break; case '?': return( FALSE ); break; case 'd': case 'D': if( NULL != *ppszFileToDump ) { printf( "Error: Only one file may be dumped\n" ); goto Exit; } else { nOptionSubIndex++; switch (rgszArg[nArgIndex][nOptionSubIndex]) { case 's': g_stgmDumpFlags = STGM_SIMPLE; break; case '\0': break; default: printf( "Error: Invalid Flag used with dump option\n" ); return( FALSE ); break; } nArgIndex++; *ppszFileToDump = &rgszArg[nArgIndex][0]; fNextArgument = TRUE; if(**ppszFileToDump == '-' || **ppszFileToDump == '/') { printf( "Error: Missing filename for dump option\n" ); goto Exit; } } break; case 'v': case 'V': g_fVerbose = TRUE; break; default: printf( "Option '%c' ignored\n", rgszArg[nArgIndex][nOptionSubIndex] ); break; } // switch( argv[nArgIndex][1] ) } // for( int nOptionSubIndex = 1; ... } // if( argv[nArgIndex][0] == '/' else { break; } } // for( ULONG nArgIndex = 2; nArgIndex < argc; nArgIndex++ ) ulTestOptions = ulTestOptionsT; // ---- // Exit // ---- Exit: return( ulTestOptions ); } // ProcessCommandLine #define Out wprintf NTSTATUS GetProcessInfo( PSYSTEM_PROCESS_INFORMATION pspi ) { NUMBERFMT NumberFmt; LCID lcid = GetUserDefaultLCID(); typedef NTSTATUS (__stdcall*PFNNtQuerySystemInformation)(ULONG,BYTE*,ULONG,VOID*); static BYTE ab[81920]; static HINSTANCE hinstNTDLL = NULL; static PFNNtQuerySystemInformation pfnNtQuerySystemInformation = NULL; WCHAR *pwcImage = L"proptest.exe"; if( NULL == pfnNtQuerySystemInformation ) { if( NULL == hinstNTDLL ) { hinstNTDLL = LoadLibrary( TEXT("ntdll.dll") ); Check( FALSE, NULL == hinstNTDLL ); } pfnNtQuerySystemInformation = (PFNNtQuerySystemInformation) GetProcAddress( hinstNTDLL, "NtQuerySystemInformation" ); Check( FALSE, NULL == pfnNtQuerySystemInformation ); } NTSTATUS status = pfnNtQuerySystemInformation( SystemProcessInformation, ab, sizeof ab, NULL ); if ( NT_SUCCESS( status ) ) { status = STATUS_OBJECT_NAME_NOT_FOUND; DWORD cbOffset = 0; PSYSTEM_PROCESS_INFORMATION p = 0; do { p = (PSYSTEM_PROCESS_INFORMATION)&(ab[cbOffset]); if ( ( L'*' == *pwcImage ) || ( 0 == *pwcImage ) || ( p->ImageName.Buffer && !_wcsicmp( pwcImage, p->ImageName.Buffer ) ) ) { status = STATUS_SUCCESS; *pspi = *p; break; } cbOffset += p->NextEntryOffset; } while ( 0 != p->NextEntryOffset ); } return( status ); } //GetProcessInfo #ifdef _MAC int __cdecl PropTestMain(int argc, char **argv, CDisplay *pcDisplay ) #else int __cdecl main(int cArg, char *rgszArg[]) #endif { ULONG ulTestOptions = 0L; CHAR* pszFileToMunge = NULL; CHAR* pszTemporaryDirectory = NULL; CHAR* pszFileToDump = NULL; #ifdef _MAC g_pcDisplay = pcDisplay; Check( S_OK, InitOleManager( OLEMGR_BIND_NORMAL )); #if DBG FnAssertOn( TRUE ); #endif #endif // Print an appropriate header message #ifdef WINNT #ifdef _CAIRO_ PRINTF("\nCairo Property Set Tests\n"); #else PRINTF("\nSUR Property Set Tests\n"); #endif #elif defined(_MAC) PRINTF("\nMacintosh Property Set Tests\n" ); #else PRINTF("\nChicago Property Set Tests\n"); #endif // Process the command-line ulTestOptions = ProcessCommandLine( cArg, rgszArg, &pszFileToDump, &pszFileToMunge, &pszTemporaryDirectory ); if(( 0 == ulTestOptions ) && (NULL == pszFileToDump)) { DisplayUsage( rgszArg[0] ); exit(0); } // Ensure that that one of the "-i" options is specified. if( PROPIMP_UNKNOWN == g_enumImplementation ) { g_enumImplementation = PROPIMP_DOCFILE_QI; // The default } if( PROPIMP_NTFS == g_enumImplementation ) g_Restrictions = RESTRICT_DIRECT_ONLY | RESTRICT_NON_HIERARCHICAL; else g_Restrictions = RESTRICT_NONE; // This 'try' wraps the remainder of the routine. try { OLECHAR ocsDir[MAX_PATH+1], ocsTest[MAX_PATH+1], ocsTest2[MAX_PATH+1], ocsMarshalingTest[MAX_PATH+1], ocsTestOffice[MAX_PATH+1]; CHAR szDir[ MAX_PATH+1 ]; CHAR pszGeneratedTempDir[ MAX_PATH + 1 ]; HRESULT hr; DWORD dwFileAttributes; UNREFERENCED_PARAMETER( dwFileAttributes ); UNREFERENCED_PARAMETER( pszGeneratedTempDir ); CoInitialize(NULL); ocscpy( ocsDir, OLESTR("") ); // ---------------------------------------------------- // Get the pointers to the necessary exported functions // ---------------------------------------------------- // We use explicit linking so that we can use either the OLE32.dll // or nt5props.dll exports. if( g_fUseNt5PropsDll ) { // We're to use the propset APIs from nt5props.dll g_hinstDLL = LoadLibraryA( "nt5props.dll" ); Check( TRUE, NULL != g_hinstDLL ); } else { // We're to use the propset APIs from OLE32 g_hinstDLL = LoadLibraryA( "ole32.dll" ); Check( TRUE, NULL != g_hinstDLL ); } g_pfnPropVariantCopy = (FNPROPVARIANTCOPY*) GetProcAddress( g_hinstDLL, "PropVariantCopy" ); Check( FALSE, NULL == g_pfnPropVariantCopy ); g_pfnPropVariantClear = (FNPROPVARIANTCLEAR*) GetProcAddress( g_hinstDLL, "PropVariantClear" ); Check( FALSE, NULL == g_pfnPropVariantClear ); g_pfnFreePropVariantArray = (FNFREEPROPVARIANTARRAY*) GetProcAddress( g_hinstDLL, "FreePropVariantArray" ); Check( FALSE, NULL == g_pfnFreePropVariantArray ); g_pfnStgCreatePropSetStg = (FNSTGCREATEPROPSETSTG*) GetProcAddress( g_hinstDLL, "StgCreatePropSetStg" ); Check( FALSE, NULL == g_pfnStgCreatePropSetStg ); g_pfnStgCreatePropStg = (FNSTGCREATEPROPSTG*) GetProcAddress( g_hinstDLL, "StgCreatePropStg" ); Check( FALSE, NULL == g_pfnStgCreatePropStg ); g_pfnStgOpenPropStg = (FNSTGOPENPROPSTG*) GetProcAddress( g_hinstDLL, "StgOpenPropStg" ); Check( FALSE, NULL == g_pfnStgOpenPropStg ); g_pfnFmtIdToPropStgName = (FNFMTIDTOPROPSTGNAME*) GetProcAddress( g_hinstDLL, "FmtIdToPropStgName" ); Check( FALSE, NULL == g_pfnFmtIdToPropStgName ); g_pfnPropStgNameToFmtId = (FNPROPSTGNAMETOFMTID*) GetProcAddress( g_hinstDLL, "PropStgNameToFmtId" ); Check( FALSE, NULL == g_pfnPropStgNameToFmtId ); g_pfnStgCreateStorageEx = (FNSTGCREATESTORAGEEX*) GetProcAddress( g_hinstDLL, "StgCreateStorageEx" ); Check( FALSE, NULL == g_pfnStgCreateStorageEx ); g_pfnStgOpenStorageEx = (FNSTGOPENSTORAGEEX*) GetProcAddress( g_hinstDLL, "StgOpenStorageEx" ); Check( FALSE, NULL == g_pfnStgOpenStorageEx ); g_pfnStgOpenStorageOnHandle = (FNSTGOPENSTORAGEONHANDLE*) GetProcAddress( g_hinstDLL, "StgOpenStorageOnHandle" ); Check( FALSE, NULL == g_pfnStgOpenStorageOnHandle ); /* g_pfnStgCreateStorageOnHandle = (FNSTGCREATESTORAGEONHANDLE*) GetProcAddress( g_hinstDLL, "StgCreateStorageOnHandle" ); Check( FALSE, NULL == g_pfnStgCreateStorageOnHandle ); */ g_pfnStgPropertyLengthAsVariant = (FNSTGPROPERTYLENGTHASVARIANT*) GetProcAddress( g_hinstDLL, "StgPropertyLengthAsVariant" ); Check( FALSE, NULL == g_pfnStgPropertyLengthAsVariant ); g_pfnStgConvertVariantToProperty = (FNSTGCONVERTVARIANTTOPROPERTY*) GetProcAddress( g_hinstDLL, "StgConvertVariantToProperty" ); Check( FALSE, NULL == g_pfnStgConvertVariantToProperty ); g_pfnStgConvertPropertyToVariant = (FNSTGCONVERTPROPERTYTOVARIANT*) GetProcAddress( g_hinstDLL, "StgConvertPropertyToVariant" ); Check( FALSE, NULL == g_pfnStgConvertPropertyToVariant ); // ------------------------ // Is there a file to dump? // ------------------------ if( NULL != pszFileToDump ) { IStorage *pstg; IPropertySetStorage *pPropSetStg = NULL; IPropertyStorage *pPropStg = NULL; PROPSPEC psTest = {1, 2 }; // { 0, (ULONG) L"cimax" }; PROPVARIANT propvar; #if 0 GUID const guidTest = { 0xCF2EAF90, 0x9311, 0x11CF, 0xBF, 0x8C, 0x00, 0x20, 0xAF, 0xE5, 0x05, 0x08 }; GetProcessInfo( L"proptest.exe" ); #endif PropTest_mbstoocs( ocsDir, sizeof(ocsDir), pszFileToDump ); for( int i = 0; i < 1; i++ ) { HRESULT hr; if ( 0 == ( i % 100 ) ) printf("."); // // Attempt to open as docfile or NSS. If that fails, // then attempt to open as a FLAT_FILE. // hr = StgOpenStorageEx( ocsDir, g_stgmDumpFlags | STGM_DIRECT | STGM_READ | STGM_SHARE_EXCLUSIVE, STGFMT_ANY, 0L, NULL, NULL, IID_IStorage, (PVOID*)&pstg ); if (FAILED(hr)) { hr = StgOpenStorageEx( ocsDir, g_stgmDumpFlags | STGM_DIRECT | STGM_READ | STGM_SHARE_EXCLUSIVE, STGFMT_ANY, 0L, NULL, NULL, IID_IPropertySetStorage, (PVOID*)&pPropSetStg ); } Check(S_OK,hr); DumpOleStorage( pstg, pPropSetStg, ocsDir ); #if 0 Check(S_OK, StgToPropSetStg( pstg, &pPropSetStg )); Check(S_OK, pPropSetStg->Open( guidTest, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, &pPropStg )); Check(S_OK, pPropStg->ReadMultiple( 1, &psTest, &propvar )); Check( TRUE, propvar.vt == VT_I4 ); pPropStg->Release(); pPropSetStg->Release(); #endif if (pstg) { pstg->Release(); } } // GetProcessInfo( L"proptest.exe" ); printf( "Press enter key to exit ..." ); getchar(); return(0); } // ------------------------- // Is there a file to munge? // ------------------------- if( NULL != pszFileToMunge ) { IStorage *pstg; PropTest_mbstoocs( ocsDir, sizeof(ocsDir), pszFileToMunge ); Check(S_OK, StgOpenStorage( ocsDir, NULL, STGM_DIRECT | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0L, &pstg )); MungeStorage( pstg ); OPRINTF( OLESTR("\"%s\" successfully munged\n"), ocsDir ); pstg->Release(); return(0); } // ---------------------------- // Create a temporary directory // ---------------------------- // If no temporary directory was specified, generate one. #ifndef _MAC if( NULL == pszTemporaryDirectory ) { GetTempPathA(sizeof(pszGeneratedTempDir)/sizeof(pszGeneratedTempDir[0]), pszGeneratedTempDir); pszTemporaryDirectory = pszGeneratedTempDir; } // If necessary, add a path separator to the end of the // temp directory name. { CHAR chLast = pszTemporaryDirectory[ strlen(pszTemporaryDirectory) - 1]; if( (CHAR) '\\' != chLast && (CHAR) ':' != chLast ) { strcat( pszTemporaryDirectory, "\\" ); } } #endif // #ifndef _MAC int i=0; #ifndef _MAC // Verify that the user-provided directory path // exists dwFileAttributes = GetFileAttributesA( pszTemporaryDirectory ); if( (DWORD) -1 == dwFileAttributes ) { printf( "Error: couldn't open temporary directory: \"%s\"\n", pszTemporaryDirectory ); exit(1); } else if( !(dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) ) { printf( "Error: \"%s\" is not a directory\n", pszTemporaryDirectory ); exit(1); } // Find a new directory name to use for temporary // files ("PrpTstX", where "X" is a number). do { // Post-pend a subdirectory name and counter // to the temporary directory name. strcpy( szDir, pszTemporaryDirectory ); strcat( szDir, "PrpTst" ); sprintf( strchr(szDir,0), "%d", i++ ); } while (!PropTest_CreateDirectory(szDir, NULL)); printf( "Generated files will be put in \"%s\"\n", szDir ); strcat( szDir, "\\" ); // Convert to an OLESTR. PropTest_mbstoocs( ocsDir, sizeof(ocsDir), szDir ); #endif // #ifndef _MAC // -------------------------------- // Create necessary temporary files // -------------------------------- // If any of the standard or extended tests will be run, // create "testdoc" and "testdoc2". if( ulTestOptions ) { IPropertySetStorage *pPropSetStg; // Create "testdoc" ocscpy(ocsTest, ocsDir); ocscat(ocsTest, OLESTR("testdoc")); hr = g_pfnStgCreateStorageEx ( ocsTest, STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, DetermineStgFmt( g_enumImplementation ), 0, NULL, NULL, DetermineStgIID( g_enumImplementation ), (void**) &_pstgTemp ); if (hr != S_OK) { OPRINTF( OLESTR("Can't create %s\n"), ocsTest); exit(1); } // Create "testdoc2" ocscpy(ocsTest2, ocsDir); ocscat(ocsTest2, OLESTR("testdoc2")); hr = StgCreateDocfile(ocsTest2, STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &_pstgTempCopyTo); if (hr != S_OK) { OPRINTF(OLESTR("Can't create %s\n"), ocsTest2); exit(1); } } // if( ulTestOptions ) // --------------------- // Finish initialization // --------------------- // Indicate what type of marshaling is being used: OLE32 or IPROP. DetermineSystemInfo(); if( g_SystemInfo.fIPropMarshaling ) PRINTF( "Using IPROP.DLL for marshaling\n" ); else PRINTF( "Using OLE32.DLL for marshaling\n" ); // Populate an array of propvars for use in tests. Check(S_OK, PopulateRGPropVar( g_rgcpropvarAll, g_rgcpropspecAll, g_rgoszpropnameAll, _pstgTemp )); // -------------- // Standard Tests // -------------- // These are the standard tests that should run in // any environment. if( ulTestOptions & TEST_STANDARD ) { PRINTF( "\nStandard Tests: " ); g_nIndent++; if( g_fVerbose ) PRINTF( "\n---------------\n" ); // Run the quick tests. test_WriteReadAllProperties( ocsDir ); // The codepage & lcid should be settable iff the property set is ~empty test_SettingLocalization( _pstgTemp ); // Test the StgOpenStorageOnHandle API test_StgOnHandle( ocsDir ); // Test invalid VTs test_UnsupportedProperties( _pstgTemp ); // Test support for the new (to NT5) VTs (VTs from the Variant) test_ExtendedTypes( _pstgTemp ); // Test the calculation of external memory requirements. test_PropertyLengthAsVariant( ); // Test VT_ARRAY test_SafeArray( _pstgTemp ); // Test each of the interfaces test_PropertyInterfaces(_pstgTemp); // Test StgCreate/OpenPropStg on CreateStreamOnHGlobal test_PropsetOnHGlobal(); // Test the read-only range of reserved PROPIDs test_ReadOnlyReservedProperties( _pstgTemp ); // Writing PID_ILLEGAL should be silently ignored. test_PidIllegal( _pstgTemp ); // Test the Standalone APIs test_StandaloneAPIs( ocsDir ); // Test for robustness (NTFS only) //test_Robustness( ocsDir ); // Test read-only open of file with no property sets (NTFS only) test_PropsetOnEmptyFile( ocsDir ); // Test having two read-only readers. test_MultipleReader( ocsDir ); // Test PROPSETFLAG_CASE_SENSITIVE & long names test_VersionOneNames( _pstgTemp ); // Test the low-memory support in IMappedStream test_LowMemory( _pstgTemp ); // Test VT_BYREF test_ByRef( _pstgTemp ); // Run the property bag tests Status( "Bag Tests\n" ); g_nIndent++; { test_IPropertyBag( _pstgTemp ); test_BagVtUnknown( _pstgTemp ); test_BagDelete( _pstgTemp ); test_EmptyBag( ocsDir ); test_BagEnum( _pstgTemp ); test_BagCoercion( _pstgTemp ); test_BagOpenMethod( _pstgTemp ); } --g_nIndent; // Test that code pages are handled properly. test_CodePages( ocsDir ); // Test the PROPSETFLAG_UNBUFFERED flag in Stg*PropStg APIs test_PROPSETFLAG_UNBUFFERED( _pstgTemp ); // Test FMTID<->Name conversions test_PropStgNameConversion( _pstgTemp ); // Test the FMTID<->Name conversion APIs test_PropStgNameConversion2( ); // Test StgOpenStorageEx for NTFS flat file support. test_ex_api(ocsDir); // Test Simple Mode DocFile test_SimpleDocFile(ocsDir); // Test the IStorage::CopyTo operation, using all combinations of // direct and transacted mode for the base and PropSet storages. // We don't run this test on the Mac because it doesn't have IStorages // which support IPropertySetStorages. #ifndef _MAC_NODOC if( PROPIMP_STORAGE == g_enumImplementation || PROPIMP_DOCFILE_QI == g_enumImplementation ) { for( int iteration = 0; iteration < 4; iteration++ ) { OLECHAR aocStorageName[] = OLESTR( "#0 Test CopyTo" ); aocStorageName[1] = (OLECHAR) iteration + OLESTR('0'); test_CopyTo( _pstgTemp, _pstgTempCopyTo, iteration & 2 ? STGM_TRANSACTED : STGM_DIRECT, // For the base Storage iteration & 1 ? STGM_TRANSACTED : STGM_DIRECT, // For the PropSet Storages aocStorageName ); } } #endif // #ifndef _MAC_NODOC // Generate the stock ticker property set example // from the OLE programmer's reference spec. test_OLESpecTickerExample( _pstgTemp ); // Test Office Property Sets ocscpy(ocsTestOffice, ocsDir); ocscat(ocsTestOffice, OLESTR("Office")); test_Office( ocsTestOffice ); test_Office2( _pstgTemp ); // Verify parameter validation test_ParameterValidation( _pstgTemp ); // Test PropVariantCopy test_PropVariantCopy(); if( PROPIMP_NTFS != g_enumImplementation ) { // Verify PropVariant validation test_PropVariantValidation( _pstgTemp ); } if( !g_fVerbose ) printf( "\n" ); --g_nIndent; PRINTF( "Standard tests PASSED\n" ); } // if( ulTestOptions & TEST_STANDARD ) // -------------- // Extended Tests // -------------- if( ulTestOptions & ~TEST_STANDARD ) { PRINTF( "\nExtended Tests: " ); g_nIndent++; if( g_fVerbose ) PRINTF( "\n---------------\n" ); // Check the CoFileTimeNow fix. if( ulTestOptions & TEST_COFILETIMENOW ) test_CoFileTimeNow(); // Test for compatibility with Word 6.0 files. if( ulTestOptions & TEST_WORD6 ) test_Word6(_pstgTemp, szDir); if( ulTestOptions & TEST_SIMPLE_LEAKS ) test_SimpleLeaks( ocsDir ); // Get some performance numbers. if ( ulTestOptions & TEST_PERFORMANCE ) test_Performance( _pstgTemp ); // Test marshaling. #ifndef _MAC // No property marshaling support on the Mac. if( ulTestOptions & TEST_MARSHALING ) { PRINTF( " Marshaling Test\n" ); ocscpy(ocsMarshalingTest, ocsDir); ocscat(ocsMarshalingTest, OLESTR("Marshal")); Check(S_OK, g_cpsmt.Init( ocsMarshalingTest, (PROPVARIANT*) g_rgcpropvarAll, (PROPSPEC*) g_rgcpropspecAll, CPROPERTIES_ALL, CPROPERTIES_ALL_SIMPLE )); Check(S_OK, g_cpsmt.Run()); } #endif if( !g_fVerbose ) PRINTF( "\n" ); --g_nIndent; PRINTF( "Extended tests PASSED\n" ); } // if( ulTestOptions ) } // try catch( CHResult chr ) { } //Exit: // Clean up and exit. if( _pstgTemp != NULL ) _pstgTemp->Release(); if( _pstgTempCopyTo != NULL ) _pstgTempCopyTo->Release(); g_pfnFreePropVariantArray( CPROPERTIES_ALL, g_rgcpropvarAll ); // Free the propspec array too. It will free itself in its // destructor anyway, but by then it will be too late to // call CoTaskMemFree (since CoUninit will have been called // by then). { for( int i = 0; i < CPROPERTIES_ALL; i++ ) g_rgcpropspecAll[i].FreeResources(); } CoUninitialize(); #ifdef _MAC UninitOleManager(); #if DBG FnAssertOn( FALSE ); #endif #endif if( g_hinstDLL ) FreeLibrary( g_hinstDLL ); CoFreeUnusedLibraries(); return 0; }