EnumAll Sample

The EnumAll.cpp sample application puts all properties in all property sets of a storage file.



//+===================================================================
//
// To Build:   cl /GX enumall.cpp
//
// The following code example dumps all the properties in all property
// sets of a storage file.
//
//+===================================================================


#define UNICODE
#define _UNICODE

#include <stdio.h>
#include <windows.h>

#pragma comment( lib, "ole32.lib" )

//+-------------------------------------------------------------------
//
//  ConvertVarTypeToString
//  
//  Generate a string for a given PROPVARIANT variable type (VT). 
//  For the given vt, write the string to pwszType, which is a buffer
//  of size cchType characters.
//
//+-------------------------------------------------------------------

void
ConvertVarTypeToString( VARTYPE vt, WCHAR *pwszType, ULONG cchType )
{
    const WCHAR *pwszModifier;

    // Ensure that the output string is terminated
    // (wcsncpy does not guarantee termination)

    pwszType[ cchType-1 ] = L'\0';
    --cchType;

    // Create a string using the basic type.

    switch( vt & VT_TYPEMASK )
    {
    case VT_EMPTY:
        wcsncpy_s( pwszType, cchType, L"VT_EMPTY", cchType );
        break;
    case VT_NULL:
        wcsncpy_s( pwszType, cchType, L"VT_NULL", cchType );
        break;
    case VT_I2:
        wcsncpy_s( pwszType, cchType, L"VT_I2", cchType );
        break;
    case VT_I4:
        wcsncpy_s( pwszType, cchType, L"VT_I4", cchType );
        break;
    case VT_I8:
        wcsncpy_s( pwszType, cchType, L"VT_I8", cchType );
        break;
    case VT_UI2:
        wcsncpy_s( pwszType, cchType, L"VT_UI2", cchType );
        break;
    case VT_UI4:
        wcsncpy_s( pwszType, cchType, L"VT_UI4", cchType );
        break;
    case VT_UI8:
        wcsncpy_s( pwszType, cchType, L"VT_UI8", cchType );
        break;
    case VT_R4:
        wcsncpy_s( pwszType, cchType, L"VT_R4", cchType );
        break;
    case VT_R8:
        wcsncpy_s( pwszType, cchType, L"VT_R8", cchType );
        break;
    case VT_CY:
        wcsncpy_s( pwszType, cchType, L"VT_CY", cchType );
        break;
    case VT_DATE:
        wcsncpy_s( pwszType, cchType, L"VT_DATE", cchType );
        break;
    case VT_BSTR:
        wcsncpy_s( pwszType, cchType, L"VT_BSTR", cchType );
        break;
    case VT_ERROR:
        wcsncpy_s( pwszType, cchType, L"VT_ERROR", cchType );
        break;
    case VT_BOOL:
        wcsncpy_s( pwszType, cchType, L"VT_BOOL", cchType );
        break;
    case VT_VARIANT:
        wcsncpy_s( pwszType, cchType, L"VT_VARIANT", cchType );
        break;
    case VT_DECIMAL:
        wcsncpy_s( pwszType, cchType, L"VT_DECIMAL", cchType );
        break;
    case VT_I1:
        wcsncpy_s( pwszType, cchType, L"VT_I1", cchType );
        break;
    case VT_UI1:
        wcsncpy_s( pwszType, cchType, L"VT_UI1", cchType );
        break;
    case VT_INT:
        wcsncpy_s( pwszType, cchType, L"VT_INT", cchType );
        break;
    case VT_UINT:
        wcsncpy_s( pwszType, cchType, L"VT_UINT", cchType );
        break;
    case VT_VOID:
        wcsncpy_s( pwszType, cchType, L"VT_VOID", cchType );
        break;
    case VT_SAFEARRAY:
        wcsncpy_s( pwszType, cchType, L"VT_SAFEARRAY", cchType );
        break;
    case VT_USERDEFINED:
        wcsncpy_s( pwszType, cchType, L"VT_USERDEFINED", cchType );
        break;
    case VT_LPSTR:
        wcsncpy_s( pwszType, cchType, L"VT_LPSTR", cchType );
        break;
    case VT_LPWSTR:
        wcsncpy_s( pwszType, cchType, L"VT_LPWSTR", cchType );
        break;
    case VT_RECORD:
        wcsncpy_s( pwszType, cchType, L"VT_RECORD", cchType );
        break;
    case VT_FILETIME:
        wcsncpy_s( pwszType, cchType, L"VT_FILETIME", cchType );
        break;
    case VT_BLOB:
        wcsncpy_s( pwszType, cchType, L"VT_BLOB", cchType );
        break;
    case VT_STREAM:
        wcsncpy_s( pwszType, cchType, L"VT_STREAM", cchType );
        break;
    case VT_STORAGE:
        wcsncpy_s( pwszType, cchType, L"VT_STORAGE", cchType );
        break;
    case VT_STREAMED_OBJECT:
        wcsncpy_s( pwszType, cchType, L"VT_STREAMED_OBJECT", cchType );
        break;
    case VT_STORED_OBJECT:
        wcsncpy_s( pwszType, cchType, L"VT_BLOB_OBJECT", cchType );
        break;
    case VT_CF:
        wcsncpy_s( pwszType, cchType, L"VT_CF", cchType );
        break;
    case VT_CLSID:
        wcsncpy_s( pwszType, cchType, L"VT_CLSID", cchType );
        break;
    default:
        _snwprintf_s( pwszType, cchType, cchType, L"Unknown (%d)", 
                    vt & VT_TYPEMASK );
        break;
    }

    // Adjust cchType for the added characters.

    cchType -= wcslen(pwszType);

    // Add the type modifiers, if present.

    if( vt & VT_VECTOR )
    {
        pwszModifier = L" | VT_VECTOR";        
        wcsncat_s( pwszType, cchType, pwszModifier, cchType );
        cchType -= wcslen( pwszModifier );
    }

    if( vt & VT_ARRAY )
    {
        pwszModifier = L" | VT_ARRAY";        
        wcsncat_s( pwszType, cchType, pwszModifier, cchType );
        cchType -= wcslen( pwszModifier );
    }

    if( vt & VT_RESERVED )
    {
        pwszModifier = L" | VT_RESERVED";        
        wcsncat_s( pwszType, cchType, pwszModifier, cchType );
        cchType -= wcslen( pwszModifier );
    }

}


//+-------------------------------------------------------------------
//
//  ConvertValueToString
//  
//  Generate a string for the value in a given PROPVARIANT structure.
//  The most common types are supported; that is, those that can be
//  displayed with printf.  For other types, only an ellipses (...) 
//  is displayed.
//
//  The property to create a string from is in propvar, the resulting
//  string is placed into pwszValue, which is a buffer with space for
//  cchValue characters (including the string terminator).
//
//+-------------------------------------------------------------------

void
ConvertValueToString( const PROPVARIANT &propvar,
                      WCHAR *pwszValue,
                      ULONG cchValue )
{
    // Ensure that the output string is terminated

    pwszValue[ cchValue - 1 ] = L'\0';
    --cchValue;

    // Based on the type, put the value into pwszValue as a string.

    switch( propvar.vt )
    {
    case VT_EMPTY:
        wcsncpy_s( pwszValue, cchValue, L"", cchValue );
        break;
    case VT_NULL:
        wcsncpy_s( pwszValue, cchValue, L"", cchValue );
        break;
    case VT_I2:
        _snwprintf_s( pwszValue, cchValue, cchValue, L"%i", propvar.iVal );
        break;
    case VT_I4:
    case VT_INT:
        _snwprintf_s( pwszValue, cchValue, cchValue, L"%li", propvar.lVal );
        break;
    case VT_I8:
        _snwprintf_s( pwszValue, cchValue, cchValue, L"%I64i", propvar.hVal );
        break;
    case VT_UI2:
        _snwprintf_s( pwszValue, cchValue, cchValue, L"%u", propvar.uiVal );
        break;
    case VT_UI4:
    case VT_UINT:
        _snwprintf_s( pwszValue, cchValue, cchValue, L"%lu", propvar.ulVal );
        break;
    case VT_UI8:
        _snwprintf_s( pwszValue, cchValue, cchValue, L"%I64u", propvar.uhVal );
        break;
    case VT_R4:
        _snwprintf_s( pwszValue, cchValue, cchValue, L"%f", propvar.fltVal );
        break;
    case VT_R8:
        _snwprintf_s( pwszValue, cchValue, cchValue, L"%lf", propvar.dblVal );
        break;
    case VT_BSTR:
        _snwprintf_s( pwszValue, cchValue, cchValue, L"\"%s\"", 
                     propvar.bstrVal );
        break;
    case VT_ERROR:
        _snwprintf_s( pwszValue, cchValue, cchValue, L"0x%08X", propvar.scode );
        break;
    case VT_BOOL:
        _snwprintf_s( pwszValue, cchValue, cchValue, L"%s",
               VARIANT_TRUE == propvar.boolVal ? L"True" : L"False" );
        break;
    case VT_I1:
        _snwprintf_s( pwszValue, cchValue, cchValue, L"%i", propvar.cVal );
        break;
    case VT_UI1:
        _snwprintf_s( pwszValue, cchValue, cchValue, L"%u", propvar.bVal );
        break;
    case VT_VOID:
        wcsncpy_s( pwszValue, cchValue, L"", cchValue );
        break;
    case VT_LPSTR:
        if( 0 > _snwprintf_s( pwszValue, cchValue, cchValue, 
                             L"\"%hs\"", propvar.pszVal ))
            // String is too large for pwszValue
            wcsncpy_s( pwszValue, cchValue, L"...", cchValue );
        break;
    case VT_LPWSTR:
        if( 0 > _snwprintf_s( pwszValue, cchValue, cchValue, 
                             L"\"%s\"", propvar.pwszVal ))
            // String is too large for pwszValue
            wcsncpy_s( pwszValue, cchValue, L"...", cchValue );
        break;
    case VT_FILETIME:
        _snwprintf_s( pwszValue, cchValue, cchValue, L"%08x:%08x",
                     propvar.filetime.dwHighDateTime,
                     propvar.filetime.dwLowDateTime );
        break;
    case VT_CLSID:
        pwszValue[0] = L'\0';
        StringFromGUID2( *propvar.puuid, pwszValue, cchValue );
        break;
    default:
        wcsncpy_s( pwszValue, cchValue, L"...", cchValue );
        break;
    }

}


//+-------------------------------------------------------------------
//
//  DisplayProperty
//
//  Dump the ID, name, type, and value of a property.
//
//+-------------------------------------------------------------------

void
DisplayProperty( const PROPVARIANT &propvar, 
                 const STATPROPSTG &statpropstg )
{
    WCHAR wsz[ MAX_PATH + 1 ];

    ConvertVarTypeToString( statpropstg.vt, wsz, 
                            sizeof(wsz)/sizeof(wsz[0]) );

    wprintf( L"   -------------------------------------------------\n"
             L"   PropID = %-5d VarType = %-23s",
             statpropstg.propid, wsz );

    if( NULL != statpropstg.lpwstrName )
        wprintf( L" Name = %s", statpropstg.lpwstrName );

    ConvertValueToString( propvar, wsz, sizeof(wsz)/sizeof(wsz[0]) );

    wprintf( L"\n   Value = %s\n", wsz ); 

}


//+-------------------------------------------------------------------
//
//  DisplayPropertySet
//
//  Dump all the properties into a given property set.
//
//+-------------------------------------------------------------------

void
DisplayPropertySet( FMTID fmtid,
                    const WCHAR *pwszStorageName,
                    IPropertyStorage *pPropStg )
{
    IEnumSTATPROPSTG *penum = NULL;
    HRESULT hr = S_OK;
    STATPROPSTG statpropstg;
    PROPVARIANT propvar;
    PROPSPEC propspec;
    PROPID propid;
    WCHAR *pwszFriendlyName = NULL;

    // This string will hold a string-formatted FMTID. It must
    // be 38 characters, plus the terminator character.
    // For best practice, create a moderately longer string.
    WCHAR wszFMTID[ 64 ] = { L"" };

    PropVariantInit( &propvar );
    memset( &statpropstg, 0, sizeof(statpropstg) );

    try
    {
        // Display the ID of the property set.

        StringFromGUID2( fmtid,
                         wszFMTID,
                         sizeof(wszFMTID)/sizeof(wszFMTID[0]) );
        wprintf( L"\n Property Set %s\n", wszFMTID );

        // If this is a common property set, display.

        if( FMTID_SummaryInformation == fmtid )
         wprintf( L"   (SummaryInformation property set)\n" );
        else if( FMTID_DocSummaryInformation == fmtid )
         wprintf( L"   (DocumentSummaryInformation property set)\n" );
        else if( FMTID_UserDefinedProperties == fmtid )
            wprintf( L"   (UserDefined property set)\n" );

        // Also display the name of the storage that contains
        // this property set.

        wprintf( L"   in \"%s\":\n", pwszStorageName );

        // If this property set has a friendly name, display it now.
        // (Property names are stored in the special dictionary
        // property - the name of the property set is indicated by
        // naming the dictionary property itself.)

        propid = PID_DICTIONARY;
        pwszFriendlyName = NULL;

        hr = pPropStg->ReadPropertyNames( 1, &propid, 
                                          &pwszFriendlyName );
        if( S_OK == hr )
        {
            wprintf( L"   (Friendly name is \"%s\")\n\n", 
                     pwszFriendlyName );
            CoTaskMemFree( pwszFriendlyName );
            pwszFriendlyName = NULL;
        }
        else
            wprintf( L"\n" );

        // Get a property enumerator.

        hr = pPropStg->Enum( &penum );
        if( FAILED(hr) ) 
            throw L"Failed IPropertyStorage::Enum";

        // Get the first property in the enumeration.

        hr = penum->Next( 1, &statpropstg, NULL );

        // Loop through and display each property.  The 'Next'
        // call above, and at the bottom of the while loop,
        // will return S_OK if it returns another property,
        // S_FALSE if there are no more properties,
        // and anything else is an error.

        while( S_OK == hr )
        {

            // Read the property out of the property set

            PropVariantInit( &propvar );
            propspec.ulKind = PRSPEC_PROPID;
            propspec.propid = statpropstg.propid;

            hr = pPropStg->ReadMultiple( 1, &propspec, &propvar );
            if( FAILED(hr) ) 
                throw L"Failed IPropertyStorage::ReadMultiple";

            // Display the property value, type, and so on.

            DisplayProperty( propvar, statpropstg );

            // Free buffers allocated during the read, and
            // by the enumerator.

            PropVariantClear( &propvar );
            CoTaskMemFree( statpropstg.lpwstrName );
            statpropstg.lpwstrName = NULL;

            // Move to the next property in the enumeration

            hr = penum->Next( 1, &statpropstg, NULL );
        }
        if( FAILED(hr) ) throw L"Failed IEnumSTATPROPSTG::Next";
    }
    catch( LPCWSTR pwszErrorMessage )
    {
        wprintf( L"Error in DumpPropertySet: %s (hr = %08x)\n",
                 pwszErrorMessage, hr );
    }

    if( NULL != penum )
        penum->Release();

    if( NULL != statpropstg.lpwstrName )
        CoTaskMemFree( statpropstg.lpwstrName );

    PropVariantClear( &propvar );
}


//+-------------------------------------------------------------------
//
//  DisplayPropertySetsInStorage
//
//  Dump the property sets in the top level of a given storage.
//
//+-------------------------------------------------------------------

void
DisplayPropertySetsInStorage( const WCHAR *pwszStorageName, 
                              IPropertySetStorage *pPropSetStg )
{
    IEnumSTATPROPSETSTG *penum = NULL;
    HRESULT hr = S_OK;
    IPropertyStorage *pPropStg = NULL;
    STATPROPSETSTG statpropsetstg;

    try
    {
        // Get a property-set enumerator, which only enumerates
        // the property sets at this level of the storage, not 
        // its child objects.

        hr = pPropSetStg->Enum( &penum );
        if( FAILED(hr) ) 
            throw L"failed IPropertySetStorage::Enum";

        // Get the first property set in the enumeration.
        // (The field used to open the property set is
        // statpropsetstg.fmtid.

        memset( &statpropsetstg, 0, sizeof(statpropsetstg) );
        hr = penum->Next( 1, &statpropsetstg, NULL );

        // Loop through all the property sets.

        while( S_OK == hr )
        {
            // Open the property set.

            hr = pPropSetStg->Open( statpropsetstg.fmtid,
                                    STGM_READ | STGM_SHARE_EXCLUSIVE,
                                    &pPropStg );
            if( FAILED(hr) ) 
                throw L"failed IPropertySetStorage::Open";

            // Display the properties in the property set.

            DisplayPropertySet( statpropsetstg.fmtid,
                                pwszStorageName,
                                pPropStg );

            pPropStg->Release();
            pPropStg = NULL;

            // Get the FMTID of the next property set in the
            // enumeration.

            hr = penum->Next( 1, &statpropsetstg, NULL );

        }
        if( FAILED(hr) ) throw L"Failed IEnumSTATPROPSETSTG::Next";

        // Special-case handling for the UserDefined property set:
        // This property set actually lives inside the well-known
        // DocumentSummaryInformation property set. It is the only
        // property set which is allowed to live inside another
        // (and exists for legacy compatibility).  It does not get
        // included in a normal enumeration, so verify that it is
        // done explicitly. Look for it when the end of the
        // enumerator is reached.

        hr = pPropSetStg->Open( FMTID_UserDefinedProperties,
                                STGM_READ | STGM_SHARE_EXCLUSIVE,
                                &pPropStg );
        if( SUCCEEDED(hr) )
        {
            DisplayPropertySet( FMTID_UserDefinedProperties,
                                pwszStorageName,
                                pPropStg );
            pPropStg->Release();
                                    pPropStg = NULL;
        }

    }
    catch( LPCWSTR pwszErrorMessage )
    {
        wprintf( L"Error in DumpPropertySetsInStorage: 
                 %s (hr = %08x)\n",
                 pwszErrorMessage, hr );
    }

    if( NULL != pPropStg )
        pPropStg->Release();
    if( NULL != penum )
        penum->Release();
}


//+-------------------------------------------------------------------
//
//  DisplayStorageTree
//
//  Dump all the property sets in the given storage and recursively in
//  all its child objects.
//
//+-------------------------------------------------------------------

void
DisplayStorageTree( const WCHAR *pwszStorageName, IStorage *pStg )
{
    IPropertySetStorage *pPropSetStg = NULL;
    IStorage *pStgChild = NULL;
    WCHAR *pwszChildStorageName = NULL;
    IEnumSTATSTG *penum = NULL;
    HRESULT hr = S_OK;
    STATSTG statstg;

    memset( &statstg, 0, sizeof(statstg) );

    try
    {
        // Dump the property sets at this storage level

        hr = pStg->QueryInterface( IID_IPropertySetStorage,
                             reinterpret_cast<void**>(&pPropSetStg) );
        if( FAILED(hr) )
          throw 
          L"Failed IStorage::QueryInterface(IID_IPropertySetStorage)";

        DisplayPropertySetsInStorage( pwszStorageName, pPropSetStg );

        // Get an enumerator for this storage.

        hr = pStg->EnumElements( NULL, NULL, NULL, &penum );
        if( FAILED(hr) ) throw L"failed IStorage::Enum";

        // Get the name of the first element (stream/storage)
        // in the enumeration.  As usual, 'Next' will return
        // S_OK if it returns an element of the enumerator,
        // S_FALSE if there are no more elements, and an
        // error otherwise.

        hr = penum->Next( 1, &statstg, 0 );

        // Loop through all the child objects of this storage.

        while( S_OK == hr )
        {
            // Verify that this is a storage that is not a property
            // set, because the property sets are displayed above).
            // If the first character of its name is the '\005'
            // reserved character, it is a stream /storage property
            // set.

            if( STGTY_STORAGE == statstg.type
                &&
                L'\005' != statstg.pwcsName[0] )
            {
                // Indicates normal storage, not a propset.
                // Open the storage.

                ULONG cchChildStorageName;

                hr = pStg->OpenStorage( statstg.pwcsName,
                                     NULL,
                                     STGM_READ | STGM_SHARE_EXCLUSIVE,
                                     NULL, 0,
                                     &pStgChild );
                if( FAILED(hr) ) 
                    throw L"failed IStorage::OpenStorage";

                // Compose a name of the form 
                // "Storage\ChildStorage\..." for display purposes.
                // First, allocate it.

                cchChildStorageName = wcslen(pwszStorageName)
                                        + wcslen(statstg.pwcsName)
                                        + 2  // For two "\" chars
                                        + 1; // For string terminator

                pwszChildStorageName = 
                                  new WCHAR[ cchChildStorageName ];
                if( NULL == pwszChildStorageName )
                {
                    hr = HRESULT_FROM_WIN32(ERROR_NOT_ENOUGH_MEMORY);
                    throw L"couldn't allocate memory";
                }

                // Terminate the name.

                pwszChildStorageName[ cchChildStorageName-1 ] = L'\0';
                --cchChildStorageName;

                // Build the name.

                wcsncpy_s( pwszChildStorageName, cchChildStorageName,
                         pwszStorageName, cchChildStorageName );
                cchChildStorageName -= wcslen(pwszStorageName);

                wcsncat_s( pwszChildStorageName, cchChildStorageName,
                         L"\\", cchChildStorageName );
                cchChildStorageName -= 2;

                wcsncat_s( pwszChildStorageName, cchChildStorageName,
                         statstg.pwcsName, cchChildStorageName );

                // Dump all property sets under this child storage.

                DisplayStorageTree( pwszChildStorageName, pStgChild );

                pStgChild->Release();
                pStgChild = NULL;

                delete[] pwszChildStorageName;
                pwszChildStorageName = NULL;
            }

            // Move to the next element in the enumeration of 
            // this storage.

            CoTaskMemFree( statstg.pwcsName );
            statstg.pwcsName = NULL;

            hr = penum->Next( 1, &statstg, 0 );
        }
        if( FAILED(hr) ) throw L"failed IEnumSTATSTG::Next";
    }
    catch( LPCWSTR pwszErrorMessage )
    {
        wprintf( L"Error in DumpStorageTree: %s (hr = %08x)\n",
                 pwszErrorMessage, hr );
    }

    // Cleanup before returning.

    if( NULL != statstg.pwcsName )
        CoTaskMemFree( statstg.pwcsName );
    if( NULL != pStgChild )
        pStgChild->Release();
    if( NULL != pStg )
        pStg->Release();
    if( NULL != penum )
        penum->Release();
    if( NULL != pwszChildStorageName )
        delete[] pwszChildStorageName;
    
}


//+-------------------------------------------------------------------
//
//  wmain
//
//  Dump all the property sets in a file which is a storage.
//
//+-------------------------------------------------------------------

extern "C" void wmain( int cArgs, WCHAR *rgwszArgs[] )
{
    HRESULT hr = S_OK;
    IStorage *pStg = NULL;

    // Display usage information if necessary.

    if( 1 == cArgs
        ||
        0 == wcscmp( L"-?", rgwszArgs[1] )
        ||
        0 == wcscmp( L"/?", rgwszArgs[1] ))
    {
        printf( "\n"
                "Purpose:  Enumerate all properties in all\n"
                "          property sets for a storage file\n"
                "Usage:    PropDump <filename>\n"
                "E.g.:     PropDump word.doc\n"
                "\n" );
        exit(0);
    }

    // Open the root storage.

    hr = StgOpenStorageEx( rgwszArgs[1],
                           STGM_READ | STGM_SHARE_DENY_WRITE,
                           STGFMT_ANY,
                           0,
                           NULL,
                           NULL,
                           IID_IStorage,
                           reinterpret_cast<void**>(&pStg) );

    // Dump all the properties in all the property sets within this
    // storage.

    if( FAILED(hr) )
    {
        wprintf( L"Error: couldn't open storage \"%s\" 
                 (hr = %08x)\n",
                 rgwszArgs[1], hr );
    }
    else
    {
        printf( "\nDisplaying all property sets ...\n" );
        DisplayStorageTree( rgwszArgs[1], pStg );
        pStg->Release();
    }


}


 

 

Community Additions

ADD
Show: