//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1996 - 2000.
//
//  File:       propdump.cxx
//
//  Contents:   Property file dump utility
//
//  History:    29 Oct 1996     KyleP   Created
//
//--------------------------------------------------------------------------

#include <pch.cxx>
#pragma hdrstop

#include <proprec.hxx>
#include <propdesc.hxx>


DECLARE_INFOLEVEL(ci)

unsigned const SixtyFourK = 1024 * 64;
unsigned const cMaxFields = 10;

unsigned fVerbose = 0;

enum eRecType
{
    Virgin,
    Top,
    Overflow,
    Free
};

struct SmallInfo
{
    ULONG Type;
    ULONG Length;
    ULONG ulPrev;
    ULONG ulNext;
    ULONG ulChainLength;
};

void Usage()
{
    printf("Usage: PropDump [-?] [-v] [-m] [-f primary_field] [-s secondary_field] <primary file> [<secondary file>]\n");
    printf("       -? to dump this usage information.\n");
    printf("       -v to be verbose.\n");
    printf("       -m[o] to dump the metadata (o --> only. No integrity check).\n");
    printf("       -f field is used to dump a specific field in the primary store records.\n");
    printf("       -s field is used to dump a specific field in the secondary store records.\n");
    printf("       -c secWidPtrField is used to check for consistency between pri and sec stores. Param is usually 3.\n");
    printf("       -w[ps] <workid> dump only <workid> in primary/secondary store\n");
    printf("       <primary file> is the name of the primary file.\n");
    printf("       <secondary file> is the name of secondary file.\n");
    printf("       Specify primary and secondary for the two-level prop store.\n");
    printf("       If secondary is not specified, the primary will be construed as the name of the single store.\n");
}

char *   pszPrimFile = 0;
char *   pszSecFile = 0;
BOOL     fReadMetadata = 0;
BOOL     fMetadataOnly = 0;

unsigned cField1 = 0;
unsigned cField2 = 0;
int      aiField1[cMaxFields];
int      aiField2[cMaxFields];
BOOL     fTwoLevel = FALSE;
ULONG    cPriRecPerBuf, cbPriRec, cPriTotal, cPriFixed;
ULONG    cSecRecPerBuf, cbSecRec, cSecTotal, cSecFixed;
ULONG    cMaxWidsInSecStore;
int      cWidPtrField = 0;
ULONG    widPrimary = 0xFFFFFFFF;
ULONG    widSecondary = 0xFFFFFFFF;

const DWORD PrimaryStore = 0;
const DWORD SecondaryStore = 1;

void DumpStore(char *pszFile, unsigned cField, int *aiField, DWORD dwLevel, ULONG wid);
void CheckConsistencyBetweenStores(char * pszPrimFile, char *pszSecFile);

CPropDesc aFieldRec[cMaxFields];
CPropDesc SecWidPtrFieldRec;

int __cdecl main( int argc, char * argv[] )
{
    if (argc < 2)
    {
        Usage();
        return 0;
    }

    for ( int i = 1; i < argc; i++ )
    {
        if ( argv[i][0] == '-' )
        {
            switch ( argv[i][1] )
            {

            case '?':
                Usage();
                return 0;

            case 'v':
            case 'V':
                fVerbose = 1;
                break;

            case 'm':
            case 'M':
                fReadMetadata = TRUE;
                if ( argv[i][2] == 'o' || argv[i][2] == 'O' )
                    fMetadataOnly = TRUE;
                break;

            case 'f':
            case 'F':
                i++;

                if ( cField1 < cMaxFields )
                    aiField1[cField1++] = strtol( argv[i], 0, 10 );
                break;


            case 's':
            case 'S':
                i++;

                if ( cField2 < cMaxFields )
                    aiField2[cField2++] = strtol( argv[i], 0, 10 );
                break;

            case 'c':
            case 'C':
                i++;
                cWidPtrField = strtol(argv[i], 0, 10);
                // this works only if fReadMetadata is turned on
                fReadMetadata = TRUE;
                break;

            case 'w':
            case 'W':
                switch ( argv[i][2] )
                {
                case 'p':
                case 'P':
                case '\0':
                    i++;
                    widPrimary = strtol(argv[i], 0, 10);
                    break;

                case 's':
                case 'S':
                    i++;
                    widSecondary = strtol(argv[i], 0, 10);
                    break;
                }
            }
        }
        else
        {
            if (!pszPrimFile)
                pszPrimFile = argv[i];
            else
            {
                pszSecFile = argv[i];
                fTwoLevel = TRUE;
            }
        }
    }

    // If we don't have a primary file or a secondary file, look for them in the current directory.
    if (!pszPrimFile)
    {
        fTwoLevel = TRUE;
        pszPrimFile = "00000002.ps1";
        pszSecFile = "00000002.ps2";
    }

    // Verify that the propstore files are indeed available!
    if (0xFFFFFFFF == GetFileAttributesA(pszPrimFile))
    {
        printf("Can't find primary file %s for reason %d\n", pszPrimFile, GetLastError());
        return 0;
    }

    if (0xFFFFFFFF == GetFileAttributesA(pszSecFile))
    {
        printf("Can't find secondary file. Assuming single level property store\n");
        fTwoLevel = FALSE;
    }
    else
        fTwoLevel = TRUE;

    cPriRecPerBuf = cbPriRec = cSecRecPerBuf = cbSecRec = 0;

    //
    // CheckConsistencyBetweenStores relies on some of the information gathered
    // by calls to DumpStore, so they should be called before consistency check.
    //

    DumpStore(pszPrimFile, cField1, aiField1, PrimaryStore, widPrimary );
    if (fTwoLevel)
    {
        DumpStore(pszSecFile, cField2, aiField2, SecondaryStore, widSecondary);
        if (cWidPtrField > 0)
        {
            CheckConsistencyBetweenStores(pszPrimFile, pszSecFile);
        }
    }

    return 0;
}

void DumpStore(char *pszFile, unsigned cField, int *aiField, DWORD dwLevel, ULONG wid )
{
    BYTE abTemp[SixtyFourK];

    //
    // First, read out the metadata
    //

    unsigned cFixed = 0;
    unsigned cTotal = 0;
    unsigned culFixed = 0;

    if ( fReadMetadata || cField != 0 )
    {
        //
        // Build path.
        //

        char szPath[MAX_PATH];
        strcpy( szPath, pszFile );
        char * pLastSlash = strrchr( szPath, '\\' );
        if (pLastSlash)
            pLastSlash++;
        else
            pLastSlash = szPath;
        if (fTwoLevel)
        {
            if (PrimaryStore == dwLevel)
                strcpy( pLastSlash, "CIP10000.001" );
            else
                strcpy( pLastSlash, "CIP20000.001" );
        }
        else
            strcpy( pLastSlash, "CIPS0000.001" );

        HANDLE h = CreateFileA( szPath,
                                GENERIC_READ,
                                FILE_SHARE_READ,
                                0,
                                OPEN_EXISTING,
                                0,
                                0 );

        if ( INVALID_HANDLE_VALUE == h )
        {
            printf( "Can't open file %s. Error %u\n", szPath, GetLastError() );
            return;
        }

        ULONG cbRead;

        if ( ReadFile( h,
                       abTemp,
                       sizeof(abTemp),
                       &cbRead,
                       0 ) )
        {
            //
            // Loop through records
            //

            CPropDesc * pPropDesc = (CPropDesc *)abTemp;

            if ( fReadMetadata )
                printf( "Record\t%-25s  Type\t\tOffset\tSize\tOrdinal\tMask\n",
                        "   Pid" );

            for ( unsigned i = 0;
                  i < cbRead/(sizeof(CPropDesc) + sizeof(ULONG));
                  i++, pPropDesc = (CPropDesc *)(((BYTE *)pPropDesc) + sizeof(CPropDesc) + sizeof(ULONG)) )
            {
                if ( pPropDesc->Pid() != 0 )
                {
                    if ( fReadMetadata )
                    {
                        char * pszPidName = 0;
                        char * pszMarker = "";
                        switch (pPropDesc->Pid())
                        {
                        case pidSecurity:
                            pszPidName = "pidSecurity"; break;
                        case pidDirectory:
                            pszPidName = "pidDirectory";        break;
                        case pidClassId:
                            pszPidName = "pidClassId";  break;
                        case pidStorageType:
                            pszPidName = "pidStorageType";      break;
                        case pidFileIndex:
                            pszPidName = "pidFileIndex";        break;
                        case pidVolumeId:
                            pszPidName = "pidVolumeId"; break;
                        case pidParentWorkId:
                            pszPidName = "pidParentWorkId";     break;
                        case pidLastChangeUsn:
                            pszPidName = "pidLastChangeUsn";    break;
                        case pidName:
                            pszPidName = "pidName";     break;
                        case pidSize:
                            pszPidName = "pidSize";     break;
                        case pidAttrib:
                            pszPidName = "pidAttrib";   break;
                        case pidWriteTime:
                            pszPidName = "pidWriteTime";        break;
                        case pidCreateTime:
                            pszPidName = "pidCreateTime";       break;
                        case pidAccessTime:
                            pszPidName = "pidAccessTime";       break;
                        case pidShortName:
                            pszPidName = "pidShortName";        break;
                        case pidWorkId:
                            pszPidName = "pidWorkId";   break;
                        case pidUnfiltered:
                            pszPidName = "pidUnfiltered";       break;
                        case pidRevName:
                            pszPidName = "pidRevName";  break;
                        case pidVirtualPath:
                            pszPidName = "pidVirtualPath";      break;
                        case pidLastSeenTime:
                            pszPidName = "pidLastSeenTime";     break;
                        case pidPath:
                            pszPidName = "pidPath";
                            pszMarker = "**";
                            break;
                        case pidSecondaryStorage:
                            pszPidName = "pidSecondaryStorage";
                            pszMarker = "*";
                            break;
                        }

                        static char achBuf[20];

                        if ( 0 == pszPidName )
                        {
                            sprintf( achBuf, "   %d(0x%x)",
                                     pPropDesc->Pid(), pPropDesc->Pid() );
                        }
                        else
                        {
                            sprintf( achBuf, "%-3s%d(%s)",
                                     pszMarker, pPropDesc->Pid(), pszPidName );
                        }
                        printf( "%u:\t%-25s  %u (0x%x)\t%d\t%u\t%u\t0x%x\n",
                                pPropDesc->Record(),
                                achBuf,
                                pPropDesc->Type(), pPropDesc->Type(),
                                pPropDesc->Offset(),
                                pPropDesc->Size(),
                                pPropDesc->Ordinal(),
                                pPropDesc->Mask() );
                    }

                    cTotal++;

                    if ( pPropDesc->Offset() != -1 )
                    {
                        cFixed++;
                        culFixed += (pPropDesc->Size() / sizeof(DWORD));
                    }

                    // copy the description of the sec top-level wid ptr for later use
                    if ( PrimaryStore == dwLevel && cWidPtrField && cWidPtrField == (int)pPropDesc->Record() )
                    {
                        memcpy( &SecWidPtrFieldRec, pPropDesc, sizeof(aFieldRec[0]) );
                    }

                    for ( unsigned j = 0; j < cField; j++ )
                    {
                        if ( aiField[j] == (int)pPropDesc->Record() )
                            memcpy( &aFieldRec[j], pPropDesc, sizeof(aFieldRec[0]) );

                        if (cWidPtrField && cWidPtrField == (int)j )
                        {
                            // verify that we are capturing the right property
                            // description for the sec top-level wid ptr
                            for (int k = 0; k < sizeof(aFieldRec[0]); k++)
                            {
                                Win4Assert(RtlEqualMemory(&aFieldRec[j], &SecWidPtrFieldRec, sizeof(SecWidPtrFieldRec)));
                            }
                        }
                    }
                }
            }

            printf( "\n%u Properties, %u Fixed totaling %u bytes  (* = Secondary link, ** = Path)\n\n",
                    cTotal, cFixed, culFixed * sizeof(DWORD) );
        }
        else
        {
            printf( "Can't read file %s.  Error %u\n", szPath, GetLastError() );
            return;
        }

        CloseHandle(h);

        if ( fMetadataOnly )
            return;
    }


    HANDLE h = CreateFileA( pszFile,
                            GENERIC_READ,
                            FILE_SHARE_READ,
                            0,
                            OPEN_EXISTING,
                            0,
                            0 );

    if ( INVALID_HANDLE_VALUE == h &&
         ERROR_SHARING_VIOLATION == GetLastError() )
    {
        h = CreateFileA( pszFile,
                         GENERIC_READ,
                         FILE_SHARE_READ | FILE_SHARE_WRITE,
                         0,
                         OPEN_EXISTING,
                         0,
                         0 );
    }

    if ( INVALID_HANDLE_VALUE == h )
    {
        printf( "Can't open file %s. Error %u\n", pszFile, GetLastError() );
        return;
    }

    BY_HANDLE_FILE_INFORMATION fi;

    if ( !GetFileInformationByHandle( h, &fi ) )
    {
        printf( "Error %u getting size from handle\n", GetLastError() );
        return;
    }

    ULONG oFile = 0;
    ULONG cbRec = 0;
    ULONG cRecPerBuf;
    ULONG cRecTotal;
    ULONG cTotalSections = 0;

    HANDLE hSmallInfo;
    SmallInfo * aSmallInfo = 0;

    ULONG iSection = 0;

    BOOL fFirst = TRUE;

    ULONG iCurrentPct = 0;

    ULONG cTopLevel = 0;
    ULONG cOverflow = 0;
    ULONG cFree = 0;
    ULONG cVirgin = 0;

    for (;;)
    {
        ULONG cbRead;

        if ( ReadFile( h,
                       abTemp,
                       sizeof(abTemp),
                       &cbRead,
                       0 ) )
        {
            if (fVerbose)
                printf( "READ: 0x%x bytes, offset 0x%x\n", cbRead, oFile );

            if ( 0 == cbRead )
                break;

            if ( fFirst )
            {
                //
                // Determine record size
                //

                if ( abTemp[0] != 0 || abTemp[1] != 0 )
                {
                    printf( "Record 0 not blank.  File corrupt!\n" );
                    break;
                }

                // First record should be all empty and only the first
                // record should be so. So counting all leading zeros gives us
                // the size of the record.
                for ( unsigned i = 0; i < cbRead && abTemp[i] == 0; i++ )
                    continue;

                if ( i == cbRead )
                {
                    printf( "First %uK segment all zero!.  File corrupt!\n", sizeof(abTemp)/1024 );
                    break;
                }

                switch ( *(USHORT *)&abTemp[i] )
                {
                case 0x5555:
                case 0xAAAA:
                case 0xBBBB:
                case 0xCCCC:
                case 0xDDDD:
                    cbRec = i;

                    if ( cbRec % 4 != 0 )
                    {
                        printf( "Record size (%u bytes) not DWORD aligned!\n\n", cbRec );
                        return;
                    }

                    cRecPerBuf = sizeof(abTemp) / cbRec;
                    printf( "Record size: %u bytes (%u / %uK)\n", i, cRecPerBuf, sizeof(abTemp)/1024 );
                    cTotalSections = (fi.nFileSizeLow + sizeof(abTemp) - 1)/ sizeof abTemp;

                    hSmallInfo = LocalAlloc( LMEM_MOVEABLE,
                                             ((fi.nFileSizeLow / sizeof(abTemp)) + 1) * cRecPerBuf * sizeof(SmallInfo) );
                    aSmallInfo = (SmallInfo *)LocalLock( hSmallInfo );

                    break;

                default:
                    printf( "First non-zero byte is not a proper signature (%u)!\n", *(SHORT *)&abTemp[i] );
                    return;
                }

                if (PrimaryStore == dwLevel)
                {
                    cPriRecPerBuf = cRecPerBuf;
                    cbPriRec = cbRec;
                    cPriTotal = cTotal;
                    cPriFixed = cFixed;
                }
                else
                {
                    cSecRecPerBuf = cRecPerBuf;
                    cbSecRec = cbRec;
                    cSecTotal = cTotal;
                    cSecFixed = cFixed;
                }

                fFirst = FALSE;
            }

            ULONG iRec = 0;

            while ( iRec < cRecPerBuf )
            {
                COnDiskPropertyRecord * pRec = new( iRec, abTemp, cbRec/4 ) COnDiskPropertyRecord;

                if ( !pRec->IsValidType() )
                {
                    printf( "Record 0x%x (%u:%u) (file offset 0x%x) is corrupt!\n",
                            iSection * cRecPerBuf + iRec,
                            iSection, iRec,
                            iSection * sizeof(abTemp) + iRec * cbRec );
                }

                if (fVerbose )
                    printf( "%u:%u, %s, length = %u record(s)",
                        iSection, iRec,
                        pRec->IsNormalTopLevel() ? "Top Level Normal" :
                            pRec->IsOverflow() ? "Overflow" :
                                pRec->IsFreeRecord() ? "Free Normal" :
                                    pRec->IsTopLevel() ? "Top Level Lean":
                                        pRec->IsLeanFreeRecord() ? "Free Lean":
                                    "Virgin",
                        pRec->CountRecords() );

                aSmallInfo[iSection*cRecPerBuf + iRec].ulChainLength = 0;

                BOOL fPrint = (0xFFFFFFFF == wid || iSection*cRecPerBuf + iRec == wid);

                if ( pRec->IsOverflow() )
                {
                    aSmallInfo[iSection*cRecPerBuf + iRec].Type = Overflow;
                    cOverflow++;

                    for ( unsigned j = 0; j < cField; j++ )
                    {
                        PROPVARIANT var;
                        BYTE abExtra[MAX_PATH * 5];
                        unsigned cbExtra = sizeof(abExtra);

                        if ( 0 == j && fPrint )
                            printf( "%6u: ", iSection*cRecPerBuf + iRec );

                        if ( aFieldRec[j].IsFixedSize() )
                            continue;

                        ULONG Ordinal = aFieldRec[j].Ordinal() - cFixed;
                        DWORD Mask = (1 << ((Ordinal % 16) * 2) );

                        BOOL fOk = pRec->ReadVariable( Ordinal,
                                                       Mask,
                                                       0,
                                                       cTotal - cFixed,
                                                       0,
                                                       var,
                                                       abExtra,
                                                       &cbExtra );

                        if ( fOk && fPrint )
                        {
                            switch ( var.vt )
                            {
                            case VT_LPSTR:
                                printf( "%s ", var.pszVal );
                                break;

                            case VT_LPWSTR:
                                printf( "%ws ", var.pwszVal );
                                break;
                            }
                        }
                    }

                    if ( 0 != cField && fPrint )
                        printf( "\n" );
                }
                else if ( pRec->IsNormalTopLevel() )
                {
                    aSmallInfo[iSection*cRecPerBuf + iRec].Type = Top;
                    aSmallInfo[iSection*cRecPerBuf + iRec].ulChainLength = pRec->GetOverflowChainLength();
                    cTopLevel++;

                    for ( unsigned j = 0; j < cField; j++ )
                    {
                        PROPVARIANT var;
                        BYTE abExtra[MAX_PATH * 5];
                        unsigned cbExtra = sizeof(abExtra);

                        if ( 0 == j && fPrint )
                            printf( "%6u: ", iSection*cRecPerBuf + iRec );

                        if ( aFieldRec[j].IsFixedSize() )
                        {
                            pRec->ReadFixed( aFieldRec[j].Ordinal(),
                                             aFieldRec[j].Mask(),
                                             aFieldRec[j].Offset(),
                                             cTotal,
                                             aFieldRec[j].Type(),
                                             var,
                                             abExtra,
                                             &cbExtra,
                                             *((PStorage *)0) );

                            if ( fPrint )
                            {
                                switch ( var.vt )
                                {
                                case VT_EMPTY:
                                    printf( "n/a " );
                                    break;

                                case VT_I4:
                                    printf( "%8d ", var.lVal );
                                    break;

                                case VT_UI4:
                                    printf( "%8u ", var.ulVal );
                                    break;

                                case VT_FILETIME:
                                    {
                                        SYSTEMTIME stTime;

                                        FileTimeToSystemTime( &var.filetime, &stTime );

                                        WCHAR awcBuffer[100] = L"???";

                                        GetDateFormat( LOCALE_USER_DEFAULT,   // locale
                                                       0,                     // flags
                                                       &stTime,               // time
                                                       L"MM/dd/yy  ",         // format
                                                       awcBuffer,             // output
                                                       sizeof(awcBuffer)/sizeof(awcBuffer[0]) );

                                        GetTimeFormat( LOCALE_USER_DEFAULT,   // locale
                                                       0,                     // flags
                                                       &stTime,               // time
                                                       L"hh:mmt",             // format
                                                       awcBuffer + 10,        // output
                                                       sizeof(awcBuffer)/sizeof(awcBuffer[0]) - 10 );

                                        awcBuffer[15] += 0x20;  // lowercase

                                        printf( "%ws ", awcBuffer );
                                    }
                                    break;

                                case VT_I8:
                                    printf( "%12hu ", var.hVal );
                                    break;

                                case VT_UI8:
                                    printf( "0x%08lx%08lx ", (ULONG) (var.uhVal.QuadPart>>32), (ULONG) var.uhVal.QuadPart );
                                    break;
                                }
                            }
                        }
                        else
                        {
                            BOOL fOk = pRec->ReadVariable( aFieldRec[j].Ordinal(),
                                                           aFieldRec[j].Mask(),
                                                           culFixed,
                                                           cTotal,
                                                           cFixed,
                                                           var,
                                                           abExtra,
                                                           &cbExtra );

                            if ( fOk && fPrint )
                            {
                                switch ( var.vt )
                                {
                                case VT_LPSTR:
                                    printf( "%s ", var.pszVal );
                                    break;

                                case VT_LPWSTR:
                                    printf( "%ws ", var.pwszVal );
                                    break;
                                }
                            }
                        }
                    }

                    if ( 0 != cField && fPrint )
                        printf( "\n" );
                }
                else if ( pRec->IsTopLevel() )
                {
                    // This is a lean top level record
                    aSmallInfo[iSection*cRecPerBuf + iRec].Type = Top;
                    aSmallInfo[iSection*cRecPerBuf + iRec].ulChainLength = 0;
                    cTopLevel++;

                    for ( unsigned j = 0; j < cField; j++ )
                    {
                        PROPVARIANT var;
                        BYTE abExtra[MAX_PATH * 5];
                        unsigned cbExtra = sizeof(abExtra);

                        if ( 0 == j && fPrint )
                            printf( "%6u: ", iSection*cRecPerBuf + iRec );

                        Win4Assert(aFieldRec[j].IsFixedSize());

                        {
                            pRec->ReadFixed( aFieldRec[j].Ordinal(),
                                             aFieldRec[j].Mask(),
                                             aFieldRec[j].Offset(),
                                             cTotal,
                                             aFieldRec[j].Type(),
                                             var,
                                             abExtra,
                                             &cbExtra,
                                             *((PStorage *)0) );

                            if ( fPrint )
                            {
                                switch ( var.vt )
                                {
                                case VT_EMPTY:
                                    printf( "n/a " );
                                    break;

                                case VT_I4:
                                    printf( "%8d ", var.lVal );
                                    break;

                                case VT_UI4:
                                    printf( "%8u ", var.ulVal );
                                    break;

                                case VT_FILETIME:
                                    {
                                        SYSTEMTIME stTime;

                                        FileTimeToSystemTime( &var.filetime, &stTime );

                                        WCHAR awcBuffer[100] = L"???";

                                        GetDateFormat( LOCALE_USER_DEFAULT,   // locale
                                                       0,                     // flags
                                                       &stTime,               // time
                                                       L"MM/dd/yy  ",         // format
                                                       awcBuffer,             // output
                                                       sizeof(awcBuffer)/sizeof(awcBuffer[0]) );

                                        GetTimeFormat( LOCALE_USER_DEFAULT,   // locale
                                                       0,                     // flags
                                                       &stTime,               // time
                                                       L"hh:mmt",             // format
                                                       awcBuffer + 10,        // output
                                                       sizeof(awcBuffer)/sizeof(awcBuffer[0]) - 10 );

                                        awcBuffer[15] += 0x20;  // lowercase

                                        printf( "%ws ", awcBuffer );

                                    }
                                    break;

                                case VT_I8:
                                    printf( "%12hu ", var.hVal );
                                    break;

                                case VT_UI8:
                                    printf( "0x%08lx%08lx ", (ULONG) (var.uhVal.QuadPart>>32), (ULONG) var.uhVal.QuadPart );
                                    break;
                                }
                            }
                        }
                    }

                    if ( 0 != cField && fPrint )
                        printf( "\n" );
                }
                else if ( pRec->IsFreeRecord() )
                {
                    aSmallInfo[iSection*cRecPerBuf + iRec].Type = Free;
                    cFree++;
                }
                else
                {
                    aSmallInfo[iSection*cRecPerBuf + iRec].Type = Virgin;
                    cVirgin++;
                }

                if (pRec->IsNormalTopLevel() || pRec->IsOverflow())
                {
                    aSmallInfo[iSection*cRecPerBuf + iRec].ulPrev = pRec->ToplevelBlock();
                    aSmallInfo[iSection*cRecPerBuf + iRec].ulNext = pRec->OverflowBlock();

                    if ( pRec->OverflowBlock() != 0 )
                    {
                        /* printf( ", Overflow = %u:%u (file offset 0x%x)",
                                pRec->OverflowBlock() / cRecPerBuf,
                                pRec->OverflowBlock() % cRecPerBuf,
                                (pRec->OverflowBlock() / cRecPerBuf) * sizeof(abTemp) +
                                    (pRec->OverflowBlock() % cRecPerBuf) * cbRec ); */
                    }
                }
                else if (pRec->IsTopLevel())
                {
                    aSmallInfo[iSection*cRecPerBuf + iRec].ulPrev = 0;
                    aSmallInfo[iSection*cRecPerBuf + iRec].ulNext = 0;
                }
                else if (pRec->IsFreeRecord())
                {
                    aSmallInfo[iSection*cRecPerBuf + iRec].ulPrev = pRec->GetPreviousFreeRecord();
                    aSmallInfo[iSection*cRecPerBuf + iRec].ulNext = pRec->GetNextFreeRecord();
                }
                aSmallInfo[iSection*cRecPerBuf + iRec].Length = pRec->CountRecords();

                if ( pRec->CountRecords() == 0 )
                {
                    printf( "Record %u (file offset 0x%x) is zero length!\n",
                            iSection * cRecPerBuf + iRec,
                            iSection * sizeof(abTemp) + iRec * cbRec );
                }

                if (fVerbose)
                    printf( "\n" );

                if ( pRec->IsValidType() )
                    iRec += pRec->CountRecords();
                else
                    iRec++;

                ULONG iPct = (iSection * (100/5) / cTotalSections) * 5;
                if (iPct != iCurrentPct)
                {
                    iCurrentPct = iPct;
                    if (0 == wid)
                        printf( "Read %u%%\n", iCurrentPct );
                }

            }

            iSection++;
            oFile += cbRead;
        }
        else
        {
            ULONG Status = GetLastError();

            if ( Status == ERROR_HANDLE_EOF )
                break;
            else
            {
                printf( "Error %u reading file.\n", Status );
            }
        }
    }

    if (SecondaryStore == dwLevel)
        cMaxWidsInSecStore = iSection * cRecPerBuf;

    if (wid == 0 || wid == 0xFFFFFFFF)
    {
        printf( "Read 100%%\n" );
        printf( "%6u Top-Level records\n"
                "%6u Overflow records\n"
                "%6u Free records\n"
                "%6u Virgin records\n", cTopLevel, cOverflow, cFree, cVirgin );
    }

    CloseHandle( h );

    //
    // Now check inter-record state
    //

    unsigned iRec = 0;
    unsigned iCurrentSection = 0;
    iCurrentPct = 0;

    while ( iRec < iSection * cRecPerBuf )
    {
        if ( aSmallInfo[iRec].Type == Top )
        {
            unsigned iOverflowRec = aSmallInfo[iRec].ulNext;
            unsigned cOverflowRec = 0;

            while ( 0 != iOverflowRec )
            {
                if ( aSmallInfo[iOverflowRec].Type != Overflow )
                {
                    printf( "Record 0x%x (%u:%u) (file offset 0x%x) should be overflow and is not!\n   Top level = 0x%x (%u:%u) (file offset 0x%x)\n",
                            iOverflowRec,
                            iOverflowRec / cRecPerBuf,
                            iOverflowRec % cRecPerBuf,
                            (iOverflowRec / cRecPerBuf) * sizeof(abTemp) +
                                (iOverflowRec % cRecPerBuf) * cbRec,
                            iRec,
                            iRec / cRecPerBuf,
                            iRec % cRecPerBuf,
                            (iRec / cRecPerBuf) * sizeof(abTemp) +
                                (iRec % cRecPerBuf) * cbRec );

                    break;
                }

                iOverflowRec = aSmallInfo[iOverflowRec].ulNext;
                cOverflowRec++;
                if ( cOverflowRec > aSmallInfo[iRec].ulChainLength )
                    break;
            }

            if ( aSmallInfo[iRec].ulChainLength != cOverflowRec )
            {
                printf( "Record 0x%x (%u:%u) (file offset 0x%x) chain length mismatch %d,%d!\n",
                        iRec,
                        iRec / cRecPerBuf,
                        iRec % cRecPerBuf,
                        (iRec / cRecPerBuf) * sizeof(abTemp) +
                                (iRec % cRecPerBuf) * cbRec,
                        aSmallInfo[iRec].ulChainLength, cOverflowRec );
            }
        }

        if (aSmallInfo[iRec].Length == 0)
        {
            printf( "%u:%u (file offset 0x%x) zero length record!\n",
                    iRec / cRecPerBuf,
                    iRec % cRecPerBuf,
                    (iRec / cRecPerBuf) * sizeof(abTemp) +
                        (iRec % cRecPerBuf) * cbRec );

            iRec++;
        } else {
            iRec += aSmallInfo[iRec].Length;
        }

        if ( (iRec / cRecPerBuf) != iCurrentSection )
        {
            if (fVerbose)
                printf( "Checked section %u\n", iCurrentSection );

            ULONG iPct = (iCurrentSection * (100/5) / iSection) * 5;
            if (iPct != iCurrentPct)
            {
                iCurrentPct = iPct;
                if (wid == 0 || wid == 0xFFFFFFFF)
                    printf( "Checked %u%%\n", iCurrentPct );
            }

            iCurrentSection = (iRec / cRecPerBuf);
        }
    }

    if (wid == 0 || wid == 0xFFFFFFFF)
        printf( "Checked 100%%\n" );

    LocalUnlock( hSmallInfo );
    LocalFree( hSmallInfo );
}

void CheckConsistencyBetweenStores(char * pszPriFile, char *pszSecFile)
{
    BYTE abTemp[SixtyFourK];
    BYTE abTemp2[SixtyFourK];
    ULONG iSection2 = 0, iTargetSection = 0, oFile = 0, iSection = 0;
    ULONG cInconsistencies = 0;
    ULONG cPriTotalSections = 0;
    ULONG cSecTotalSections = 0;
    ULONG iCurrentPct = 0;

    HANDLE hPri = CreateFileA( pszPriFile,
                            GENERIC_READ,
                            FILE_SHARE_READ,
                            0,
                            OPEN_EXISTING,
                            0,
                            0 );

    if ( INVALID_HANDLE_VALUE == hPri )
    {
        printf( "Can't open file %s. Error %u\n", pszPriFile, GetLastError() );
        return;
    }

    HANDLE hSec = CreateFileA( pszSecFile,
                            GENERIC_READ,
                            FILE_SHARE_READ,
                            0,
                            OPEN_EXISTING,
                            0,
                            0 );

    if ( INVALID_HANDLE_VALUE == hSec )
    {
        printf( "Can't open file %s. Error %u\n", pszSecFile, GetLastError() );
        return;
    }

    BY_HANDLE_FILE_INFORMATION fi;

    if ( GetFileInformationByHandle( hPri, &fi ) )
    {
        cPriTotalSections = (fi.nFileSizeLow + sizeof(abTemp) - 1)/ sizeof abTemp;
    }
    else
    {
        printf( "Error %u getting size from primary's handle\n", GetLastError() );
        return;
    }

    if ( GetFileInformationByHandle( hSec, &fi ) )
    {
        cSecTotalSections = (fi.nFileSizeLow + sizeof(abTemp) - 1)/ sizeof abTemp;
    }
    else
    {
        printf( "Error %u getting size from secondary's handle\n", GetLastError() );
        return;
    }

    ULONG ulSecWidPtr = widInvalid;

    // read the first large page of the secondary store into memory.
    DWORD cbRead2;
    ReadFile( hSec, abTemp2, sizeof(abTemp2), &cbRead2, 0 );

    for (;;)
    {
        ULONG cbRead;

        if ( ReadFile( hPri, abTemp, sizeof(abTemp), &cbRead, 0 ) )
        {
            if ( 0 == cbRead )
                break;

            ULONG iRec = 0;

            while ( iRec < cPriRecPerBuf )
            {
                COnDiskPropertyRecord * pRec = new( iRec, abTemp, cbPriRec/4 ) COnDiskPropertyRecord;

                if ( pRec->IsTopLevel() )
                {
                    Win4Assert(!pRec->IsNormalTopLevel());

                    PROPVARIANT var;
                    BYTE abExtra[MAX_PATH * 5];
                    unsigned cbExtra = sizeof(abExtra);

                    Win4Assert(SecWidPtrFieldRec.IsFixedSize());

                    {
                        pRec->ReadFixed( SecWidPtrFieldRec.Ordinal(),
                                         SecWidPtrFieldRec.Mask(),
                                         SecWidPtrFieldRec.Offset(),
                                         cPriTotal,
                                         SecWidPtrFieldRec.Type(),
                                         var,
                                         abExtra,
                                         &cbExtra,
                                         *((PStorage *)0) );

                        switch ( var.vt )
                        {
                        case VT_EMPTY:
                            Win4Assert(!"Reading VT_EMPTY. Expect to read VT_UI4");
                            break;

                        case VT_I4:
                            Win4Assert(!"Reading VT_I4. Expect to read VT_UI4");
                            break;

                        case VT_UI4:
                        {
                            // Do we need to read a new large page?
                            iTargetSection = var.ulVal/cSecRecPerBuf;
                            if (var.ulVal > cMaxWidsInSecStore)  // ensure that it is a valid wid in secondary store.
                            {
                                printf("Wid %u (0x%x) is pointing to a non-existent wid %u (0x%x) in Secondary store.\n",
                                       iSection*cPriRecPerBuf + iRec, iSection*cPriRecPerBuf + iRec,
                                       var.ulVal, var.ulVal);
                                continue;
                            }

                            if (iSection2 != iTargetSection)
                            {
                                // seek to the target section and read the large page into buffer.
                                //SetFilePointer(hSec, (iTargetSection - iSection2)*SixtyFourK, 0, FILE_CURRENT);
                                SetFilePointer(hSec, iTargetSection*SixtyFourK, 0, FILE_BEGIN);
                                ReadFile( hSec, abTemp2, sizeof(abTemp2), &cbRead2, 0 );
                                iSection2 = iTargetSection;
                            }

                            // Get the record in question.
                            COnDiskPropertyRecord * pRec2 = new( var.ulVal % cSecRecPerBuf, abTemp2, cbSecRec/4 ) COnDiskPropertyRecord;

                            // Now grill it!
                            if (!pRec2->IsNormalTopLevel())
                            {
                                cInconsistencies++;
                                // Invalid record type
                                printf("Error: Wid %u (0x%x), (%u:%u) is pointing to a non-toplevel  wid %u (0x%x), ",
                                       iSection*cPriRecPerBuf + iRec,
                                       iSection*cPriRecPerBuf + iRec,
                                       iSection, iRec,
                                       var.ulVal, var.ulVal);

                                 printf("(%u:%u), %s, length = %u record(s)\n",
                                    iSection2, var.ulVal % cSecRecPerBuf,
                                    pRec2->IsNormalTopLevel() ? "Top Level Normal" :
                                        pRec2->IsOverflow() ? "Overflow" :
                                            pRec2->IsFreeRecord() ? "Free Normal" :
                                                pRec2->IsTopLevel() ? "Top Level Lean":
                                                    pRec2->IsLeanFreeRecord() ? "Free Lean":
                                                "Virgin",
                                    pRec2->CountRecords() );
                            }
                            break;
                        }

                        case VT_FILETIME:
                            Win4Assert(!"Reading VT_FILETIME. Expect to read VT_UI4");
                            break;

                        case VT_I8:
                            Win4Assert(!"Reading VT_I8. Expect to read VT_UI4");
                            break;

                        case VT_UI8:
                            Win4Assert(!"Reading VT_UI8. Expect to read VT_UI4");
                            break;
                        }
                    }
                }
                else if ( pRec->IsFreeRecord() )
                {

                }
                else
                {

                }

                if ( pRec->CountRecords() == 0 )
                {
                    printf( "Record %u (file offset 0x%x) is zero length!\n",
                            iSection * cPriRecPerBuf + iRec,
                            iSection * sizeof(abTemp) + iRec * cbPriRec );
                }

                if ( pRec->IsValidType() )
                    iRec += pRec->CountRecords();
                else
                    iRec++;

                ULONG iPct = (iSection * (100/5) / cPriTotalSections) * 5;
                if (iPct != iCurrentPct)
                {
                    iCurrentPct = iPct;
                    printf( "Read %u%%\n", iCurrentPct );
                }
            }

            iSection++;
            oFile += cbRead;
        }
        else
        {
            ULONG Status = GetLastError();

            if ( Status == ERROR_HANDLE_EOF )
                break;
            else
            {
                printf( "Error %u reading file.\n", Status );
            }
        }
    }

    CloseHandle( hPri );
    CloseHandle( hSec );

    if (cInconsistencies)
    {
        printf("%d inconsistencies were detected between the two stores.\n", cInconsistencies);
    }
    else
        printf("No inconsistencies were detected between the two stores.\n");
}