/*++

Copyright (c) 1994  Microsoft Corporation

Module Name:

    apitest.c

Abstract:

    Program to test CSC apis.

Author:

    Shishir Pardikar (shishirp) 4-24-97

Environment:

    User Mode - Win32

Revision History:

--*/
#ifdef CSC_ON_NT
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#else
typedef const char *    LPCSTR;
#endif
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <cscapi.h>
#include "lmcons.h"
#include "lmuse.h"
//#include <timelog.h>

//=================================================================================
#define MAX_COMMAND_ARGS    32
#define DEFAULT_BUFFER_SIZE 1024    // 1k
//=================================================================================

// The order of these must match the order in GlobalCommandInfo[]
typedef enum _COMMAND_CODE {
    CmdCSCPinFile,
    CmdCSCUnPinFile,
    CmdCSCQueryFileStatus,
    CmdCSCEnum,
    CmdCSCDelete,
    CmdCSCFill,
    CmdCSCMerge,
    CmdCSCCopyReplica,
    CmdTimeLog,
    CmdCheckCSC,
    CmdDbCheckCSC,
    CmdCSCEnumForStats,
    CmdCSCDoLocalRename,
    CmdCSCDoEnableDisable,
    CmdShowTime,
    CmdEncryptDecrypt,
    CmdDoRandomWrites,
    CmdHelp,
    CmdQuit,
    UnknownCommand
} COMMAND_CODE, *LPCOMMAND_CODE;

typedef struct _COMMAND_INFO {
    LPSTR CommandName;
    LPSTR CommandParams;
    COMMAND_CODE CommandCode;
} COMMAND_INFO, *LPCOMMAND_INFO;

typedef VOID (*PRINTPROC)(LPSTR);
#ifndef CSC_ON_NT
typedef BOOL (*CHECKCSCEX)(LPSTR, LPCSCPROCA, DWORD, DWORD);
#else
typedef BOOL (*CHECKCSCEX)(LPSTR, LPCSCPROCW, DWORD, DWORD);
#endif
// If Count is not already aligned, then
// round Count up to an even multiple of "Pow2".  "Pow2" must be a power of 2.
//
// DWORD
// ROUND_UP_COUNT(
//     IN DWORD Count,
//     IN DWORD Pow2
//     );

#define ROUND_UP_COUNT(Count,Pow2) \
        ( ((Count)+(Pow2)-1) & (~((Pow2)-1)) )

#define ALIGN_WCHAR             sizeof(WCHAR)

//=================================================================================
FILE *UncList = NULL;
LPSTR g_lpWriteFileBuf = NULL;
FILE *DumpUncList = NULL;
DWORD cCommands = 0;
DWORD cFails = 0;
DWORD g_dwNumIterations = 1;
DWORD g_dwIteration = 0;
DWORD g_dwNumCmdIterations = 1;
DWORD g_dwCmdIteration = 0;
DWORD g_dwFileSize = 0;
DWORD g_dwDiskCache = 0;
BOOL g_bWriteFile = FALSE;
BOOL g_bQuietMode = FALSE;
BOOL g_bPerfMode = FALSE;
BOOL g_bUseFile = FALSE;
char szDefaultTimeLogFile[] = "c:\\debug\\kd.log";
char vszFile[] = "C:\\WINNT\\private\\ntos\\rdr2\\csc\\usermode\\reint\\foo";
WCHAR vwzFileName[] = L"\\\\shishir1\\public\\foo.txt";

COMMAND_INFO GlobalCommandInfo[] = {
    {"pin",         "UNCName",                          CmdCSCPinFile},
    {"unpin",       "UNCName",                          CmdCSCUnPinFile},
    {"query",       "UNCName",                          CmdCSCQueryFileStatus},
    {"Enum",        "UNCName or nothing",               CmdCSCEnum},
    {"Del",         "UNCName",                          CmdCSCDelete},
    {"Fill",        "UNCName",                          CmdCSCFill},
    {"Merge",       "\\\\Server\\Share",                CmdCSCMerge},
    {"Move",        "UNCNAME",                          CmdCSCCopyReplica},
    {"tlog",        "logfile",                          CmdTimeLog},
    {"check",       "\\\\Server\\Share",                CmdCheckCSC},
    {"dbcheck",     "dbdir <0 (verify) or 1 (fix)>",    CmdDbCheckCSC},
    {"stats",       ""              ,                   CmdCSCEnumForStats},
    {"Ren",         "ren src containing_dst_dir [1:-replace files]", CmdCSCDoLocalRename},
    {"EnDis",       "0 (disable) or 1 enable",              CmdCSCDoEnableDisable},
    {"ShowTime",    "HHHHHHHH LLLLLLLL (Hex HighDateTime and LowDateTime)", CmdShowTime},
    {"EncDec",      "U (decrypt) anything else=> encrypt", CmdEncryptDecrypt},
    {"RandW",        "Randw filename",                  CmdDoRandomWrites},
    {"Help",        "",                                 CmdHelp},
    {"Quit",         "",                                CmdQuit}
};

LPSTR   rgszNameArray[] =
{
"EditRecordEx",
"AddFileRecordFR",
"DeleteFileRecFromInode",
"FindFileRecord",
"UpdateFileRecordFR",
"AddPriQRecord",
"DeletePriQRecord",
"FindPriQRecordInternal",
"SetPriorityForInode",
"CreateShadowInternal",
"GetShadow",
"GetShadowInfo",
"SetShadowInfoInternal",
"ChangePriEntryStatusHSHADOW",
"MRxSmbCscCreateShadowFromPath",
"MRxSmbGetFileInfoFromServer",
"EditRecordEx_OpenFileLocal",
"EditRecordEx_Lookup",
"KeAttachProcess_R0Open",
"IoCreateFile_R0Open",
"KeDetachProcess_R0Open",
"KeAttachProcess_R0Read",
"R0ReadWrite",
"KeDetachProcess_R0Read",
"FindQRecordInsertionPoint_Addq",
"LinkQRecord_Addq",
"UnlinkQRecord_Addq",
"FindQRecordInsertionPoint_Addq_dir",
"EditRecordEx_Validate",
"EditRecordEx_dat"
};

typedef struct tagCSCSTATS{
    DWORD   dwTotal;
    DWORD   dwTotalFiles;
    DWORD   dwTotalDirs;
    DWORD   dwSparseFiles;
    DWORD   dwDirtyFiles;
    DWORD   dwPinned;
    DWORD   dwPinnedAndSparse;
    DWORD   dwMismatched;
} CSCSTATS, *LPCSCSTATS;

DWORD WINAPIV Format_String(LPSTR *plpsz, LPSTR lpszFmt, ...);
DWORD WINAPI Format_Error(DWORD dwErr, LPSTR *plpsz);
DWORD WINAPI Format_StringV(LPSTR *plpsz, LPCSTR lpszFmt, va_list *vArgs);
DWORD WINAPI Format_MessageV(DWORD dwFlags, DWORD dwErr, LPSTR *plpsz, LPCSTR lpszFmt, va_list *vArgs);
VOID PrintBuffer(
    LPSTR   lpszBuff
    );


BOOL WINAPI CheckCSC(LPSTR lpszDataBaseLocation, BOOL fFix);
BOOL
DoPinningA(
    LPSTR   lpszName,
    DWORD   dwHintFlags,
    BOOL    fRecurse
    );
BOOL
DoPinningW(
    LPWSTR   lpwzName,
    DWORD   dwHintFlags,
    BOOL    fRecurse
    );

DWORD
ProcessShowTime (
    DWORD argc,
    LPSTR *argv
    );

DWORD
ProcessEncryptDecrypt(
    DWORD   argc,
    LPSTR   *argv
);


//=================================================================================
DWORD
ProcessCommandCode (
    DWORD CommandCode,
    DWORD CommandArgc,
    LPSTR *CommandArgv
    );


DWORD
GetLeafLenFromPath(
    LPSTR   lpszPath
    );

BOOL
GetStreamInformation(
    LPCSTR  lpExistingFileName,
    LPVOID  *lpStreamInformation
    );

//=================================================================================
#if DBG

#define TestDbgAssert(Predicate) \
    { \
        if (!(Predicate)) \
            TestDbgAssertFailed( #Predicate, __FILE__, __LINE__, NULL ); \
    }

VOID
TestDbgAssertFailed(
    LPSTR FailedAssertion,
    LPSTR FileName,
    DWORD LineNumber,
    LPSTR Message
    )
/*++

Routine Description:

    Assertion failed.

Arguments:

    FailedAssertion :

    FileName :

    LineNumber :

    Message :

Return Value:

    none.

--*/
{

    printf("Assert @ %s \n", FailedAssertion );
    printf("Assert Filename, %s \n", FileName );
    printf("Line Num. = %ld.\n", LineNumber );
    printf("Message is %s\n", Message );

    DebugBreak();
}
#else

#define TestDbgAssert(_x_)

#endif // DBG

//=================================================================================
VOID
ParseArguments(
    LPSTR InBuffer,
    LPSTR *CArgv,
    LPDWORD CArgc
    )
{
    LPSTR CurrentPtr = InBuffer;
    DWORD i = 0;
    DWORD Cnt = 0;

    for ( ;; ) {

        //
        // skip blanks.
        //

        while( *CurrentPtr == ' ' ) {
            CurrentPtr++;
        }

        if( *CurrentPtr == '\0' ) {
            break;
        }

        CArgv[i++] = CurrentPtr;

        //
        // go to next space.
        //

        while(  (*CurrentPtr != '\0') &&
                (*CurrentPtr != '\n') ) {
            if( *CurrentPtr == '"' ) {      // Deal with simple quoted args
                if( Cnt == 0 )
                    CArgv[i-1] = ++CurrentPtr;  // Set arg to after quote
                else
                    *CurrentPtr = '\0';     // Remove end quote
                Cnt = !Cnt;
            }
            if( (Cnt == 0) && (*CurrentPtr == ' ') ||   // If we hit a space and no quotes yet we are done with this arg
                (*CurrentPtr == '\0') )
                break;
            CurrentPtr++;
        }

        if( *CurrentPtr == '\0' ) {
            break;
        }

        *CurrentPtr++ = '\0';
    }

    *CArgc = i;
    return;
}

#ifdef MAYBE
//=================================================================================
LPSTR
GetUncFromFile ()
{
    if (!UncList)
    {
        UncList = fopen ("Unclist", "r");
        if (UncList == NULL)
            return NULL;
    }
    if (fgets( UncBuffer, DEFAULT_BUFFER_SIZE, UncList))
    {
        UncBuffer[strlen(UncBuffer) -1] = '\0';  //kill line feed for no param cmds
        return UncBuffer;
    }
    else
    {
        fclose (UncList);
        UncList = NULL;
        return GetUncFromFile();
    }
}

#endif
//=================================================================================
COMMAND_CODE
DecodeCommand(
    LPSTR CommandName
    )
{
    DWORD i;
    DWORD NumCommands;

    NumCommands = sizeof(GlobalCommandInfo) / sizeof(COMMAND_INFO);
    TestDbgAssert( NumCommands <= UnknownCommand );
    for( i = 0; i < NumCommands; i++) {
        if(( lstrcmpi( CommandName, GlobalCommandInfo[i].CommandName ) == 0 )){
            return( GlobalCommandInfo[i].CommandCode );
        }
    }
    return( UnknownCommand );
}

//=================================================================================
VOID
PrintCommands(
    VOID
    )
{
    DWORD i;
    DWORD NumCommands;

    NumCommands = sizeof(GlobalCommandInfo) / sizeof(COMMAND_INFO);
    TestDbgAssert( NumCommands <= UnknownCommand );
    for( i = 0; i < NumCommands; i++) {
        fprintf(stderr, "    %s (%s)\n",
            GlobalCommandInfo[i].CommandName,
            GlobalCommandInfo[i].CommandParams );
    }
}

//=================================================================================
VOID
DisplayUsage(
    VOID
    )
{
    fprintf(stderr, "Usage: command <command parameters>\n" );

    fprintf(stderr, "Commands : \n");
    PrintCommands();

    return;
}

//=================================================================================
FILETIME
GetGmtTime(
    VOID
    )
{
    SYSTEMTIME SystemTime;
    FILETIME Time;

    GetSystemTime( &SystemTime );
    SystemTimeToFileTime( &SystemTime, &Time );

    return( Time );
}

//=================================================================================
LPSTR
ConvertGmtTimeToString(
    FILETIME Time,
    LPSTR OutputBuffer
    )
{
    SYSTEMTIME SystemTime;
    FILETIME LocalTime;

    static FILETIME ftNone = {0, 0};

    if (!memcmp (&Time, &ftNone, sizeof(FILETIME)))
        sprintf (OutputBuffer, "<none>");
    else
    {
        FileTimeToLocalFileTime( &Time , &LocalTime );
        FileTimeToSystemTime( &LocalTime, &SystemTime );

        sprintf( OutputBuffer,
                    "%02u/%02u/%04u %02u:%02u:%02u ",
                    SystemTime.wMonth,
                    SystemTime.wDay,
                    SystemTime.wYear,
                    SystemTime.wHour,
                    SystemTime.wMinute,
                    SystemTime.wSecond );
    }

    return( OutputBuffer );
}


void
PrintCSCEntryInfo(
    WIN32_FIND_DATA *lpFind32,
    DWORD           dwStatus,
    DWORD           dwPinCount,
    DWORD           dwHintFlags,
    FILETIME        *lpftOrgTime
)
{
    char buff[128];
    fprintf(stderr, "\n");


    if (lpFind32)
    {
        fprintf(stderr, "LFN: %s\n", lpFind32->cFileName);
        fprintf(stderr, "SFN: %s\n", lpFind32->cAlternateFileName);
        fprintf(stderr, "Attr: %x\n", lpFind32->dwFileAttributes);
        fprintf(stderr, "Size: %d %d\n", lpFind32->nFileSizeHigh, lpFind32->nFileSizeLow);

        ConvertGmtTimeToString(lpFind32->ftLastWriteTime, buff);
        fprintf(stderr, "LastWriteTime: %s\n", buff);
    }

    if (lpftOrgTime)
    {
        ConvertGmtTimeToString(*lpftOrgTime, buff);
        fprintf(stderr, "ORGTime: %s\n", buff);
    }

    fprintf(stderr, "Status: %x\n", dwStatus);

    fprintf(stderr, "PinCount: %x\n", dwPinCount);

    fprintf(stderr, "PinFlags: %x\n", dwHintFlags);

    fprintf(stderr, "\n");

}

void
PrintCSCEntryInfoW(
    WIN32_FIND_DATAW *lpFind32,
    DWORD           dwStatus,
    DWORD           dwPinCount,
    DWORD           dwHintFlags,
    FILETIME        *lpftOrgTime
)
{

    WIN32_FIND_DATA *lpFind32P = NULL;

    fprintf(stderr, "\n");
    if (lpFind32)
    {
        WIN32_FIND_DATA sFind32;

        lpFind32P = &sFind32;
        memset(&sFind32, 0, sizeof(WIN32_FIND_DATAA));
        memcpy(&sFind32, lpFind32, sizeof(WIN32_FIND_DATAA)-sizeof(sFind32.cFileName)-sizeof(sFind32.cAlternateFileName));

        WideCharToMultiByte(CP_ACP, 0, lpFind32->cFileName, wcslen(lpFind32->cFileName), sFind32.cFileName, sizeof(sFind32.cFileName), NULL, NULL);
        WideCharToMultiByte(CP_OEMCP, 0, lpFind32->cAlternateFileName, wcslen(lpFind32->cAlternateFileName), sFind32.cAlternateFileName, sizeof(sFind32.cAlternateFileName), NULL, NULL);
    }

    PrintCSCEntryInfo(  lpFind32P,
                        dwStatus,
                        dwPinCount,
                        dwHintFlags,
                        lpftOrgTime
                    );
}

DWORD
MyCSCProc(
    const char          *lpszFullPath,
    DWORD               dwStatus,
    DWORD               dwHintFlags,
    DWORD               dwPinCount,
    WIN32_FIND_DATAA    *lpFind32,
    DWORD               dwReason,
    DWORD               dwParam1,
    DWORD               dwParam2,
    DWORD               dwContext
    )
{
    if (dwReason==CSCPROC_REASON_BEGIN)
    {
        printf("CSCPROC:Name=%s Status=0x%x HintFlags=0x%x PinCount=%d Reason=%d Param1=%d Param2=%d\r\n",
                    (lpszFullPath)?lpszFullPath:"None",
                    dwStatus,
                    dwHintFlags,
                    dwPinCount,
                    dwReason,
                    dwParam1,
                    dwParam2
        );
    }
    else if (dwReason==CSCPROC_REASON_MORE_DATA)
    {
        printf(".");
    }
    else
    {
        printf("\r\n");
        if (dwParam2==ERROR_SUCCESS)
        {
            printf("Succeeded\r\n");
        }
        else
        {
            printf("Error=%d \r\n", dwParam2);
        }
    }
    return (CSCPROC_RETURN_CONTINUE);
}

DWORD
MyCSCProcW(
    const unsigned short  *lpszFullPath,
    DWORD           dwStatus,
    DWORD           dwHintFlags,
    DWORD           dwPinCount,
    WIN32_FIND_DATAW *lpFind32,
    DWORD           dwReason,
    DWORD           dwParam1,
    DWORD           dwParam2,
    DWORD           dwContext
    )
{
    if (dwReason==CSCPROC_REASON_BEGIN)
    {
        printf("CSCPROC:Name=%ls Status=0x%x HintFlags=0x%x PinCount=%d Reason=%d Param1=%d Param2=%d\r\n",
                    (lpszFullPath)?lpszFullPath:L"None",
                    dwStatus,
                    dwHintFlags,
                    dwPinCount,
                    dwReason,
                    dwParam1,
                    dwParam2
        );
    }
    else if (dwReason==CSCPROC_REASON_MORE_DATA)
    {
        printf(".");
    }
    else
    {
        printf("\r\n");
        if (dwParam2==ERROR_SUCCESS)
        {
            printf("Succeeded\r\n");
        }
        else
        {
            printf("Error=%d \r\n", dwParam2);
        }
    }
    return (CSCPROC_RETURN_CONTINUE);
}

DWORD
MyCSCEnumForStatsProc(
    const char          *lpszFullPath,
    DWORD               dwStatus,
    DWORD               dwHintFlags,
    DWORD               dwPinCount,
    WIN32_FIND_DATAA    *lpFind32,
    DWORD               dwReason,
    DWORD               dwParam1,
    DWORD               dwParam2,
    DWORD               dwContext
    )
{
    LPCSCSTATS lpStats = (LPCSCSTATS)dwContext;

    lpStats->dwTotal++;
    if(dwParam1)
    {
        lpStats->dwTotalFiles++;
        if (dwStatus & FLAG_CSC_COPY_STATUS_SPARSE)
        {
            lpStats->dwSparseFiles++;
        }
        if (dwStatus & FLAG_CSC_COPY_STATUS_DATA_LOCALLY_MODIFIED)
        {
            lpStats->dwDirtyFiles++;
        }
        if ((dwHintFlags & (FLAG_CSC_HINT_PIN_USER|FLAG_CSC_HINT_PIN_SYSTEM))||dwPinCount)
        {
            lpStats->dwPinned++;
            if (dwStatus & FLAG_CSC_COPY_STATUS_SPARSE)
            {
                lpStats->dwPinnedAndSparse++;
            }

        }
    }
    else
    {
        lpStats->dwTotalDirs++;
    }

    return (CSCPROC_RETURN_CONTINUE);
}

DWORD
MyCSCEnumForStatsProcW(
    const unsigned short  *lpszFullPath,
    DWORD           dwStatus,
    DWORD           dwHintFlags,
    DWORD           dwPinCount,
    WIN32_FIND_DATAW *lpFind32,
    DWORD           dwReason,
    DWORD           dwParam1,
    DWORD           dwParam2,
    DWORD           dwContext
    )
{
    LPCSCSTATS lpStats = (LPCSCSTATS)dwContext;

    lpStats->dwTotal++;
    if(dwParam1)
    {
        lpStats->dwTotalFiles++;
        if (dwStatus & FLAG_CSC_COPY_STATUS_SPARSE)
        {
            lpStats->dwSparseFiles++;
        }
        if (dwStatus & FLAG_CSC_COPY_STATUS_DATA_LOCALLY_MODIFIED)
        {
            lpStats->dwDirtyFiles++;
        }
        if ((dwHintFlags & (FLAG_CSC_HINT_PIN_USER|FLAG_CSC_HINT_PIN_SYSTEM))||dwPinCount)
        {
            lpStats->dwPinned++;
            if (dwStatus & FLAG_CSC_COPY_STATUS_SPARSE)
            {
                lpStats->dwPinnedAndSparse++;
            }
        }
    }
    else
    {
        lpStats->dwTotalDirs++;
    }

    return (CSCPROC_RETURN_CONTINUE);
}

DWORD
MyCSCCheckExProc(
    const char          *lpszFullPath,
    DWORD               dwStatus,
    DWORD               dwHintFlags,
    DWORD               dwPinCount,
    WIN32_FIND_DATAA    *lpFind32,
    DWORD               dwReason,
    DWORD               dwParam1,
    DWORD               dwParam2,
    DWORD               dwContext
    )
{
    LPCSCSTATS lpStats = (LPCSCSTATS)dwContext;

    if (dwReason == CSCPROC_REASON_BEGIN)
    {
        if (lpFind32)
        {
            printf("%s size=%d\r\n", lpszFullPath, lpFind32->nFileSizeLow);
            lpStats->dwTotal++;
            lpStats->dwTotalFiles++;
        }
        else
        {
            printf("%s\r\n", lpszFullPath);
        }

    }
    else if (dwReason == CSCPROC_REASON_END)
    {
        if (dwParam2 != NO_ERROR)
        {
            if (dwParam2 == ERROR_INVALID_DATA)
            {
                printf("Mismatched, press any key to continue...\r\n", dwParam2);
            }
            else
            {
                printf("Error in comparing Errcode=%d, press any key to continue...\r\n", dwParam2);
            }
            getchar();
            lpStats->dwMismatched++;
        }
    }

    return (CSCPROC_RETURN_CONTINUE);
}

DWORD
MyCSCCheckExProcW(
    const unsigned short  *lpszFullPath,
    DWORD           dwStatus,
    DWORD           dwHintFlags,
    DWORD           dwPinCount,
    WIN32_FIND_DATAW *lpFind32,
    DWORD           dwReason,
    DWORD           dwParam1,
    DWORD           dwParam2,
    DWORD           dwContext
    )
{
    LPCSCSTATS lpStats = (LPCSCSTATS)dwContext;

    if (dwReason == CSCPROC_REASON_BEGIN)
    {
        if (lpFind32)
        {
            printf("%ls size=%d\r\n", lpszFullPath, lpFind32->nFileSizeLow);
            lpStats->dwTotal++;
            lpStats->dwTotalFiles++;
        }
        else
        {
            printf("%s\r\n", lpszFullPath);
        }
    }
    else if (dwReason == CSCPROC_REASON_END)
    {
        if (dwParam2 != NO_ERROR)
        {
            if (dwParam2 == ERROR_INVALID_DATA)
            {
                printf("Mismatched, press any key to continue...\r\n", dwParam2);
            }
            else
            {
                printf("Error in comparing Errcode=%d, press any key to continue...\r\n", dwParam2);
            }
            getchar();
            lpStats->dwMismatched++;
        }
    }
    return (CSCPROC_RETURN_CONTINUE);
}

DWORD
ProcessCSCPinFile(
    DWORD   argc,
    LPSTR   *argv
)
{
    DWORD   dwError=ERROR_SUCCESS, dwHintFlags=0;
    BOOL    fRecurse = FALSE, fRet=FALSE;
#ifdef CSC_ON_NT
    unsigned short uBuff[MAX_PATH];
#endif
    if (argc < 1)
    {
        printf("CSCPinFile: must provide a UNC path \r\n");
    }
    else
    {
        if (argc > 1)
        {
            if ((*argv[1] == 'u')||(*argv[1] == 'U'))
            {
                dwHintFlags |= FLAG_CSC_HINT_PIN_USER;
            }
            else if ((*argv[1] == 's')||(*argv[1] == 'S'))
            {
                dwHintFlags |= FLAG_CSC_HINT_PIN_SYSTEM;
            }
            else if (*argv[1] == 'i')
            {
                dwHintFlags |= FLAG_CSC_HINT_PIN_INHERIT_USER;
            }
            else if (*argv[1] == 'I')
            {
                dwHintFlags |= FLAG_CSC_HINT_PIN_INHERIT_SYSTEM;
            }
            else if (*argv[1] == 'T')
            {
                fRecurse = TRUE;
            }

        }
#ifndef CSC_ON_NT
        fRet = DoPinningA(argv[0], dwHintFlags, fRecurse);
#else
        memset(uBuff, 0, sizeof(uBuff));
        MultiByteToWideChar(CP_ACP, 0, argv[0], strlen(argv[0]), uBuff, MAX_PATH*sizeof(unsigned short));
        fRet = DoPinningW(uBuff, dwHintFlags, fRecurse);
#endif

    }

    if (!fRet)
    {
        dwError = GetLastError();
    }

    return (dwError);
}

DWORD
ProcessCSCUnPinFile(
    DWORD   argc,
    LPSTR   *argv
)
{

    DWORD dwStatus, dwError=ERROR_SUCCESS, dwPinCount, dwHintFlags=0;
#ifdef CSC_ON_NT
    unsigned short uBuff[MAX_PATH];
#endif

    if (argc < 1)
    {
        printf("CSCUnPinFile: must provide a UNC path \r\n");
    }
    else
    {
        if (argc > 1)
        {
            if ((*argv[1] == 'u')||(*argv[1] == 'U'))
            {
                dwHintFlags |= FLAG_CSC_HINT_PIN_USER;
            }
            else if ((*argv[1] == 's')||(*argv[1] == 'S'))
            {
                dwHintFlags |= FLAG_CSC_HINT_PIN_SYSTEM;
            }
            else if (*argv[1] == 'i')
            {
                dwHintFlags |= FLAG_CSC_HINT_PIN_INHERIT_USER;
            }
            else if (*argv[1] == 'I')
            {
                dwHintFlags |= FLAG_CSC_HINT_PIN_INHERIT_SYSTEM;
            }
        }

#ifndef CSC_ON_NT
        if (!CSCUnpinFileA(argv[0], dwHintFlags, &dwStatus, &dwPinCount, &dwHintFlags))
        {
            dwError = GetLastError();   
        }
        else
        {
            PrintCSCEntryInfo(NULL, dwStatus, dwPinCount, dwHintFlags, NULL);

        }
#else
        memset(uBuff, 0, sizeof(uBuff));
        MultiByteToWideChar(CP_ACP, 0, argv[0], strlen(argv[0]), uBuff, MAX_PATH*sizeof(unsigned short));

        if (!CSCUnpinFileW(uBuff, dwHintFlags, &dwStatus, &dwPinCount, &dwHintFlags))
        {
            dwError = GetLastError();   
        }
        else
        {
            PrintCSCEntryInfo(NULL, dwStatus, dwPinCount, dwHintFlags, NULL);

        }
#endif
    }
    return (dwError);
}

DWORD
ProcessCSCQueryFileStatus(
    DWORD   argc,
    LPSTR   *argv
)
{

    DWORD dwStatus, dwError=ERROR_SUCCESS, dwPinCount, dwHintFlags;
#ifdef CSC_ON_NT
    unsigned short uBuff[MAX_PATH];
#endif

    if (argc < 1)
    {
        printf("CSCQueryFileStatusA: must provide a UNC path \r\n");
    }
    else
    {
#ifndef CSC_ON_NT
        if (!CSCQueryFileStatusA(argv[0], &dwStatus, &dwPinCount, &dwHintFlags))
        {
            dwError = GetLastError();   
        }
        else
        {
            PrintCSCEntryInfo(NULL, dwStatus, dwPinCount, dwHintFlags, NULL);

        }
#else

        memset(uBuff, 0, sizeof(uBuff));
        MultiByteToWideChar(CP_ACP, 0, argv[0], strlen(argv[0]), uBuff, MAX_PATH*sizeof(unsigned short));
        if (!CSCQueryFileStatusW(uBuff, &dwStatus, &dwPinCount, &dwHintFlags))
        {
            dwError = GetLastError();   
        }
        else
        {
            PrintCSCEntryInfo(NULL, dwStatus, dwPinCount, dwHintFlags, NULL);

        }

#endif
    }
    return (dwError);
}

DWORD
ProcessCSCEnum(
    DWORD   argc,
    LPSTR   *argv
)
{
    HANDLE hFind;
    DWORD dwError = ERROR_SUCCESS, dwStatus, dwPinCount, dwHintFlags;
    FILETIME ftOrgTime;
#ifndef CSC_ON_NT
    WIN32_FIND_DATAA    sFind32;
#else
    WIN32_FIND_DATAW    sFind32;
    unsigned short uBuff[MAX_PATH];
#endif

#ifndef CSC_ON_NT
    hFind = CSCFindFirstFileA((argc<1)?NULL:argv[0], &sFind32, &dwStatus, &dwPinCount, &dwHintFlags, &ftOrgTime);

    if (hFind != INVALID_HANDLE_VALUE)
    {
        PrintCSCEntryInfo(&sFind32, dwStatus, dwPinCount, dwHintFlags, &ftOrgTime);

        while (CSCFindNextFileA(hFind, &sFind32, &dwStatus, &dwPinCount, &dwHintFlags, &ftOrgTime))
        {
            PrintCSCEntryInfo(&sFind32, dwStatus, dwPinCount, dwHintFlags, &ftOrgTime);
        }

        CSCFindClose(hFind);
    }
    else
    {
        dwError = GetLastError();
    }
#else
    memset(uBuff, 0, sizeof(uBuff));
    MultiByteToWideChar(CP_ACP, 0, argv[0], strlen(argv[0]), uBuff, MAX_PATH*sizeof(unsigned short));
    hFind = CSCFindFirstFileW(uBuff, &sFind32, &dwStatus, &dwPinCount, &dwHintFlags, &ftOrgTime);

    if (hFind != INVALID_HANDLE_VALUE)
    {
        PrintCSCEntryInfoW(&sFind32, dwStatus, dwPinCount, dwHintFlags, &ftOrgTime);

        while (CSCFindNextFileW(hFind, &sFind32, &dwStatus, &dwPinCount, &dwHintFlags, &ftOrgTime))
        {
            PrintCSCEntryInfoW(&sFind32, dwStatus, dwPinCount, dwHintFlags, &ftOrgTime);
        }

        CSCFindClose(hFind);
    }
    else
    {
        dwError = GetLastError();
    }
#endif
    return (dwError);
}

DWORD
ProcessCSCDelete(
    DWORD   argc,
    LPSTR   *argv
)
{

    DWORD dwError=ERROR_SUCCESS;
#ifdef CSC_ON_NT
    unsigned short uBuff[MAX_PATH];
#endif
    if (argc < 1)
    {
        printf("CSCQueryFileStatusA: must provide a UNC path \r\n");
    }
    else
    {
#ifndef CSC_ON_NT
        if (!CSCDeleteA(argv[0]))
        {
            dwError = GetLastError();   
        }
#else
        memset(uBuff, 0, sizeof(uBuff));
        MultiByteToWideChar(CP_ACP, 0, argv[0], strlen(argv[0]), uBuff, MAX_PATH*sizeof(unsigned short));
        if (!CSCDeleteW(uBuff))
        {
            dwError = GetLastError();   
        }
#endif
    }
    return (dwError);
}

DWORD
ProcessTimeLog(
    DWORD   argc,
    LPSTR   *argv
)
{
    DWORD dwError=ERROR_SUCCESS;
    LPSTR   lpszLogFile;
    FILE *fp= (FILE *)NULL;
    char buff[256];
    int indx = 0;
    LONGLONG llTime = 0;
    DWORD   dwMin, dwSec, dwMSec;
    if (argc < 1)
    {
        printf("No file specified assuming %s\r\n", szDefaultTimeLogFile);
        lpszLogFile = szDefaultTimeLogFile;
    }
    else
    {
        lpszLogFile = argv[0];
    }

    if (fp = fopen(lpszLogFile, "rb")){
        printf("Total time spent by routine \r\n");

         while(fgets(buff, sizeof(buff), fp) != NULL)
         {

            if (sscanf(buff, "%x %x", (DWORD *)&llTime, (DWORD *)(((BYTE *)&llTime)+sizeof(DWORD)))==2)
            {
                dwMin = (DWORD)((llTime/10000000)/60);
                dwSec = (DWORD)((llTime/10000000)%60);

                if (!dwMin && !dwSec)
                {
                    dwMSec = (DWORD)(llTime/10000);
                    printf("%d msecs:   %s\r\n", dwMSec, rgszNameArray[indx]);
                }
                else
                {
                    printf("%d min %d sec:   %s \r\n",
                        dwMin,
                        dwSec,
                        rgszNameArray[indx]);

                }
            }

            ++indx;
         }

         fclose(fp);
    }

    return (dwError);

}

DWORD
ProcessCheckCSC(
    DWORD   argc,
    LPSTR   *argv
    )
{
    CHECKCSCEX  lpCheckCscEx;
    HANDLE  hLib;
    CSCSTATS    sCscStats;
    DWORD dwError=ERROR_SUCCESS;
    BOOL fRet = TRUE;

    if (hLib = LoadLibraryA("cscdll.dll"))
    {
        if (lpCheckCscEx = (CHECKCSCEX)GetProcAddress(hLib, "CheckCSCEx"))
        {
            memset(&sCscStats, 0, sizeof(sCscStats));
#ifndef CSC_ON_NT
            fRet = lpCheckCscEx(argv[0], MyCSCCheckExProc, (DWORD)&sCscStats, 0);    // verify
#else
            fRet = lpCheckCscEx(argv[0], MyCSCCheckExProcW, (DWORD)&sCscStats, 0);    // verify
#endif
        }
        else
        {
            printf("Older version of cscdll \r\n");
            fRet = FALSE;

        }

        FreeLibrary(hLib);
    }

    if (!fRet)
    {
        dwError = GetLastError();
    }
    return dwError;
}

DWORD
ProcessDbCheckCSC(
    DWORD   argc,
    LPSTR   *argv
)
{
    DWORD dwError=ERROR_SUCCESS;
    DWORD   dwLevel=0;
    BOOL fRet = TRUE;
    PRINTPROC lpfnPrintProc = NULL;
#if 0
    PFILE_STREAM_INFORMATION pStream = NULL, pstreamT;
    char buff[1024];

    if (GetStreamInformation((LPCSTR)vszFile, (LPVOID *)&pStream))
    {
        pstreamT = pStream;

        do
        {
            memset(buff, 0, sizeof(buff));

            wcstombs(buff, pstreamT->StreamName, pstreamT->StreamNameLength);

            printf("%s\r\n", buff);

            if (!pstreamT->NextEntryOffset)
            {
                break;
            }

            pstreamT = (PFILE_STREAM_INFORMATION)((LPBYTE)pstreamT + pstreamT->NextEntryOffset);
        }
        while (TRUE);

        LocalFree(pStream);
    }

#endif

    if (argc < 1)
    {
        printf("Usage: check cscdir level{0 for verify, 1 for rebuild}\r\n");
        return (ERROR_INVALID_PARAMETER);
    }
    else if (argc>1)
    {
        dwLevel = *argv[1] - '0';
    }

    if (dwLevel > 1)
    {
        printf("Usage: check cscdir level{0 for verify, 1 for rebuild}\r\n");
        return (ERROR_INVALID_PARAMETER);
    }

    printf("Calling CheckCSC with cscdir=%s level=%d \r\n", argv[0], dwLevel);

    switch (dwLevel)
    {
        case 0:
            fRet = CheckCSC(argv[0], FALSE); // don't fix
            break;
        case 1:
            fRet = CheckCSC(argv[0], TRUE);  // fix
            break;
        default:
            break;
    }
    if (!fRet)
    {
        dwError = GetLastError();
    }
    return dwError;
}

DWORD
ProcessCSCFill(
    DWORD   argc,
    LPSTR   *argv
)
{

    DWORD dwError=ERROR_FILE_NOT_FOUND;
#ifdef CSC_ON_NT
    unsigned short uBuff[MAX_PATH];
#endif

    if (argc>=1)
    {
#ifndef CSC_ON_NT
        if (!CSCFillSparseFilesA((const char *)argv[0], FALSE, MyCSCProc, 0))
        {
            dwError = GetLastError();
        }
        else
        {
            dwError = ERROR_SUCCESS;
        }
#else
        memset(uBuff, 0, sizeof(uBuff));
        MultiByteToWideChar(CP_ACP, 0, argv[0], strlen(argv[0]), uBuff, MAX_PATH*sizeof(unsigned short));

        if (!CSCFillSparseFilesW((const unsigned short *)uBuff, FALSE, MyCSCProcW, 0))
        {
            dwError = GetLastError();
        }
        else
        {
            dwError = ERROR_SUCCESS;
        }
#endif
    }
    return dwError;
}

DWORD
ProcessCSCMerge(
    DWORD   argc,
    LPSTR   *argv
)
{

    DWORD dwError=ERROR_FILE_NOT_FOUND;
#ifdef CSC_ON_NT
    unsigned short uBuff[MAX_PATH];
#endif

    if (argc>=1)
    {
#ifndef CSC_ON_NT
        if (!CSCMergeShareA((const char *)(argv[0]), MyCSCProc, 0))
        {
            dwError = GetLastError();
        }
        else
        {
            dwError = ERROR_SUCCESS;
        }
#else
        memset(uBuff, 0, sizeof(uBuff));
        MultiByteToWideChar(CP_ACP, 0, argv[0], strlen(argv[0]), uBuff, MAX_PATH*sizeof(unsigned short));
        if (!CSCMergeShareW((const unsigned short *)uBuff, MyCSCProcW, 0))
        {
            dwError = GetLastError();
        }
        else
        {
            dwError = ERROR_SUCCESS;
        }
        CSCTransitionServerOnlineW((const unsigned short *)uBuff);
#endif

    }
    return dwError;
}

DWORD
ProcessCSCCopyReplica(
    DWORD   argc,
    LPSTR   *argv
)
{

    DWORD dwError=ERROR_FILE_NOT_FOUND;
#ifdef CSC_ON_NT
    LPWSTR  lpszTempName = NULL;
    unsigned short uBuff[MAX_PATH];
#else
    LPSTR  lpszTempName = NULL;
#endif

    if (argc>=1)
    {
#ifndef CSC_ON_NT
        if (!CSCCopyReplicaA((const char *)argv[0], &lpszTempName))
        {
            dwError = GetLastError();
        }
        else
        {
            dwError = ERROR_SUCCESS;
        }
#else
        memset(uBuff, 0, sizeof(uBuff));
        MultiByteToWideChar(CP_ACP, 0, argv[0], strlen(argv[0]), uBuff, MAX_PATH*sizeof(unsigned short));

        if (!CSCCopyReplicaW((const unsigned short *)uBuff, &lpszTempName))
        {
            dwError = GetLastError();
        }
        else
        {
            dwError = ERROR_SUCCESS;
        }
#endif
    }

    if (dwError == ERROR_SUCCESS)
    {

#ifdef CSC_ON_NT
        OutputDebugStringW(lpszTempName);
        OutputDebugStringW(L"\r\n");
#else
        OutputDebugStringA(lpszTempName);
        OutputDebugStringA("\r\n");
#endif
    }

    return dwError;
}



DWORD
ProcessCSCEnumForStats(
    DWORD   argc,
    LPSTR   *argv
)
{

    DWORD dwError=ERROR_FILE_NOT_FOUND;
    CSCSTATS   sStats;
#ifdef CSC_ON_NT
    unsigned short uBuff[MAX_PATH];
#endif

    memset(&sStats, 0, sizeof(sStats));
#ifndef CSC_ON_NT
        if (!CSCEnumForStatsA((argc >=1)?(const char *)(argv[0]):NULL, MyCSCEnumForStatsProc, (DWORD)&sStats))
        {
            dwError = GetLastError();
        }
        else
        {
            dwError = ERROR_SUCCESS;
        }
#else
        if (argc >= 1)
        {
            memset(uBuff, 0, sizeof(uBuff));
            MultiByteToWideChar(CP_ACP, 0, argv[0], strlen(argv[0]), uBuff, MAX_PATH*sizeof(unsigned short));
        }
        if (!CSCEnumForStatsW((argc>=1)?(const unsigned short *)uBuff:NULL, MyCSCEnumForStatsProcW, (DWORD)&sStats))
        {
            dwError = GetLastError();
        }
        else
        {
            dwError = ERROR_SUCCESS;
        }
#if 0
        if (argc < 1)
        {
            DWORD   dwMaxSpaceHigh, dwMaxSpaceLow, dwCurrentSpaceHigh, dwCurrentSpaceLow, cntTotalFiles, cntTotalDirs;

            if(CSCGetSpaceUsageW(uBuff, sizeof(uBuff),
                                &dwMaxSpaceHigh, &dwMaxSpaceLow,
                                &dwCurrentSpaceHigh, &dwCurrentSpaceLow,
                                &cntTotalFiles, &cntTotalDirs))
            {
                printf("\r\n Space Stats \r\n");
                printf("CSC directory location: %ls \r\n", uBuff);
                printf("MaxSpace=%d, CurrentSpaceUsed=%d, Fnles=%d Dirs=%d \r\n", dwMaxSpaceLow, dwCurrentSpaceLow, cntTotalFiles, cntTotalDirs);
            }
            else
            {
                printf("Error=%d in CSCGetSpaceUsage\r\n", GetLastError());
            }
        }
#endif
#endif
    if (dwError == ERROR_SUCCESS)
    {
        printf("Stats\n");
        printf("Total = %d, files=%d dirs=%d sparse=%d dirty=%d pinned=%d pinnedAndSparse=%d\r\n",
            sStats.dwTotal,
            sStats.dwTotalFiles,
            sStats.dwTotalDirs,
            sStats.dwSparseFiles,
            sStats.dwDirtyFiles,
            sStats.dwPinned,
            sStats.dwPinnedAndSparse

        );
    }
    return dwError;
}


DWORD
ProcessCSCDoLocalRename(
    DWORD   argc,
    LPSTR   *argv
)
{

    DWORD dwError=ERROR_FILE_NOT_FOUND;
#ifdef CSC_ON_NT
    unsigned short uBuffSrc[MAX_PATH], uBuffDst[MAX_PATH];
#endif


    if (argc<2)
    {
        printf("Usage: ren source_name dest_dir [optional character to indicate replace]\r\n");
        return ERROR_INVALID_PARAMETER;
    }

#ifndef CSC_ON_NT
    dwError = ERROR_CALL_NOT_IMPLEMENTED;
#else
    memset(uBuffSrc, 0, sizeof(uBuffSrc));
    MultiByteToWideChar(CP_ACP, 0, argv[0], strlen(argv[0]), uBuffSrc, MAX_PATH*sizeof(unsigned short));

    memset(uBuffDst, 0, sizeof(uBuffDst));
    MultiByteToWideChar(CP_ACP, 0, argv[1], strlen(argv[1]), uBuffDst, MAX_PATH*sizeof(unsigned short));

    if (!CSCDoLocalRenameW(uBuffSrc, uBuffDst, (argc > 2)))
    {
        dwError = GetLastError();
    }
    else
    {
        dwError = ERROR_SUCCESS;
    }
#endif
    return dwError;
}

DWORD
ProcessCSCDoEnableDisable(
    DWORD   argc,
    LPSTR   *argv
)
{

    DWORD dwError=ERROR_FILE_NOT_FOUND;

    if (argc<1)
    {
        printf("Usage: endis fEnable\r\n");
        return ERROR_INVALID_PARAMETER;
    }

#ifndef CSC_ON_NT
    dwError = ERROR_CALL_NOT_IMPLEMENTED;
#else

    if (!CSCDoEnableDisable(*argv[0]!='0'))
    {
        dwError = GetLastError();
    }
    else
    {
        dwError = ERROR_SUCCESS;
    }
#endif
    return dwError;
}


DWORD
ProcessDoRandomWrites(
    DWORD   argc,
    LPSTR   *argv
)
{

    DWORD dwError=ERROR_SUCCESS, dwFileSize, dwOffset, dwOffsetHigh;
    unsigned short uBuff[MAX_PATH];
    unsigned char   uchData;
    
    HANDLE  hFile = INVALID_HANDLE_VALUE;
    int i, count;
        
    if (argc>=1)
    {
        memset(uBuff, 0, sizeof(uBuff));
        MultiByteToWideChar(CP_ACP, 0, argv[0], strlen(argv[0]), uBuff, MAX_PATH*sizeof(unsigned short));
        hFile = CreateFileW(
                        uBuff,                              // name
                        GENERIC_READ|GENERIC_WRITE,         // access mode
                        FILE_SHARE_READ|FILE_SHARE_WRITE,   // share mode
                        NULL,                               // security descriptor
                        OPEN_EXISTING,                      // create disposition
                        0,                                  // file statributes if created
                        NULL);                              // template handle
#if LARGE_FILE
        hFile = CreateFileW(
                        uBuff,                              // name
                        GENERIC_READ|GENERIC_WRITE,         // access mode
                        FILE_SHARE_READ|FILE_SHARE_WRITE,   // share mode
                        NULL,                               // security descriptor
                        OPEN_ALWAYS,                      // create disposition
                        0,                                  // file statributes if created
                        NULL);                              // template handle
#endif

        if (hFile != INVALID_HANDLE_VALUE)
        {
            dwFileSize = GetFileSize(hFile, NULL);
            if (dwFileSize == -1)
            {
                dwError = GetLastError();
                goto bailout;
            }
            if (dwFileSize == 0)
            {
                printf("0 sized file \n");
                goto bailout;
            }
            
            srand( (unsigned)time( NULL ) );
            
//            count = rand() % 100;
            count = 2;

            printf("writing %d times \n", count);
                        
            for (i=0; i< count; ++i)
            {
                DWORD   dwReturn;
                
                dwOffset = rand() % dwFileSize;
                uchData = (unsigned char)rand();

                if (SetFilePointer(hFile, dwOffset, NULL, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
                {
                    dwError = GetLastError();
                    printf("Failed SetFilePointer %d \n", dwError);
                    goto bailout;
                }

                printf("writing %c at %d \n", uchData, dwOffset);
                
                if (!WriteFile(hFile, &uchData, 1, &dwReturn, NULL))
                {
                    dwError = GetLastError();
                    printf("Failed write with error %d \n", dwError);
                    goto bailout;
                }
            }
        }
#if LARGE_FILE
                dwOffsetHigh = 1;
                if (SetFilePointer(hFile, 0x400000, &dwOffsetHigh, FILE_BEGIN) == INVALID_SET_FILE_POINTER)
                {
                    dwError = GetLastError();
                    printf("Failed SetFilePointer %d \n", dwError);
                    goto bailout;
                }
                
                if (!SetEndOfFile(hFile))
                {
                    dwError = GetLastError();
                    printf("Failed SetEof %d \n", dwError);
                    goto bailout;
                }
#endif
    }
    
bailout:
    if (hFile != INVALID_HANDLE_VALUE)
    {
        CloseHandle(hFile);
    }
    return dwError;
}




VOID
PrintBuffer(
    LPSTR   lpszBuff
    )
{
    printf(lpszBuff);
}

//=================================================================================
DWORD
ProcessCommandCode (
    DWORD CommandCode,
    DWORD CommandArgc,
    LPSTR *CommandArgv
    )
{
    DWORD Error = ERROR_SUCCESS;

        switch( CommandCode ) {
            case CmdCSCPinFile:
                Error = ProcessCSCPinFile(CommandArgc, CommandArgv);
            break;

            case CmdCSCUnPinFile:
                Error = ProcessCSCUnPinFile(CommandArgc, CommandArgv);
            break;
            case CmdCSCQueryFileStatus:
                Error = ProcessCSCQueryFileStatus(CommandArgc, CommandArgv);
            break;
            case CmdCSCEnum:
                Error = ProcessCSCEnum(CommandArgc, CommandArgv);
            break;
            case CmdCSCDelete:
                Error = ProcessCSCDelete(CommandArgc, CommandArgv);
            break;
            case CmdHelp:
                DisplayUsage();
            break;
            case CmdTimeLog:
                Error = ProcessTimeLog(CommandArgc, CommandArgv);
            break;
            case CmdCheckCSC:
                Error = ProcessCheckCSC(CommandArgc, CommandArgv);
            break;
            case CmdDbCheckCSC:
                Error = ProcessDbCheckCSC(CommandArgc, CommandArgv);
            break;
            case CmdCSCFill:
                Error = ProcessCSCFill(CommandArgc, CommandArgv);
            break;
            case CmdCSCMerge:
                Error = ProcessCSCMerge(CommandArgc, CommandArgv);
            break;
            case CmdCSCCopyReplica:
                Error = ProcessCSCCopyReplica(CommandArgc, CommandArgv);
            break;
            case CmdCSCEnumForStats:
                Error = ProcessCSCEnumForStats(CommandArgc, CommandArgv);
            break;
            case CmdCSCDoLocalRename:
                Error = ProcessCSCDoLocalRename(CommandArgc, CommandArgv);
                break;
            case CmdCSCDoEnableDisable:
                Error = ProcessCSCDoEnableDisable(CommandArgc, CommandArgv);
                break;
            case CmdShowTime:
                Error = ProcessShowTime( CommandArgc, CommandArgv );
                break;
            case CmdEncryptDecrypt:
                Error = ProcessEncryptDecrypt(CommandArgc, CommandArgv );
                break;
            case CmdDoRandomWrites:
                Error = ProcessDoRandomWrites(CommandArgc, CommandArgv );
                break;
            case CmdQuit :
                exit (0);

        default:
            TestDbgAssert( FALSE );
            fprintf(stderr, "Unknown Command Specified.\n");
            DisplayUsage();
            break;
        }
        cCommands++;

        if( Error != ERROR_SUCCESS ) {
            LPSTR lpstr;

            cFails++;
            Format_Error(Error, &lpstr);
            printf("FAILED (%s), %ld-%s.\n",
                GlobalCommandInfo[CommandCode].CommandName, Error, lpstr );
            LocalFree(lpstr);
        }
        else {
            if(!g_bQuietMode)
                printf("Command (%s) successfully completed.\n", GlobalCommandInfo[CommandCode].CommandName );
        }
        return Error;
}


//=================================================================================
VOID
__cdecl
main(
    int argc,
    char *argv[]
    )
{

    DWORD Error;
    COMMAND_CODE CommandCode;
    CHAR InBuffer[DEFAULT_BUFFER_SIZE];
    DWORD CArgc;
    LPSTR CArgv[MAX_COMMAND_ARGS];
    unsigned u1 = 1, u2 = 0xffffffff;

    DWORD CommandArgc;
    LPSTR *CommandArgv;

    printf("u1=0x%x u2=0x%x, (int)(u1-u2)=%d, (u1-u2)=0x%x \r\n", u1, u2, (int)(u1-u2), (u1-u2));

    /* must check for batch mode.  if there are command line parms, assume batch mode */
    if (argc > 1)
    {
        //this means that the arguments translate directly into CommandArgc....
        CommandCode = DecodeCommand( argv[1] );
        if( CommandCode == UnknownCommand ) {
            printf("Unknown Command Specified.\n");
            return;
        }

        CommandArgc = argc - 2;
        CommandArgv = &argv[2];

        Error = ProcessCommandCode (CommandCode,CommandArgc,CommandArgv);

        if (DumpUncList)
            fclose(DumpUncList);
        if (UncList)
            fclose(UncList);

        return;
    }

    DisplayUsage();

    for(;;) {

        fprintf(stderr,  "Command : " );

        gets( InBuffer );

        CArgc = 0;
        ParseArguments( InBuffer, CArgv, &CArgc );

        if( CArgc < 1 ) {
            continue;
        }

        //
        // decode command.
        //

        CommandCode = DecodeCommand( CArgv[0] );
        if( CommandCode == UnknownCommand ) {
            fprintf(stderr, "Unknown Command Specified.\n");
            continue;
        }

        CommandArgc = CArgc - 1;
        CommandArgv = &CArgv[1];

        Error = ProcessCommandCode (CommandCode,CommandArgc,CommandArgv);

    }

    return;
}

//=================================================================================
DWORD
GetLeafLenFromPath(
    LPSTR   lpszPath
    )
{
    DWORD len;
    LPSTR   lpT;

    if(!lpszPath)
        return(0);

    len = lstrlen(lpszPath);

    if (len == 0) {

        return (len);

    }

    lpT = lpszPath+len-1;
    if (*lpT =='\\') {
        --lpT;
    }
    for (; lpT >= lpszPath; --lpT) {
        if (*lpT == '\\') {
            break;
        }
    }
    return (lstrlen(lpT));
}

//=================================================================================
DWORD WINAPIV Format_String(LPSTR *plpsz, LPSTR lpszFmt, ...)
{
    const char c_Func_Name[] = "[Format_String] ";
    DWORD dwRet;
    va_list vArgs;

    va_start (vArgs, lpszFmt);
    dwRet = Format_StringV(plpsz, lpszFmt, &vArgs);
    va_end (vArgs);

    return(dwRet);
}

//=================================================================================
DWORD WINAPI Format_Error(DWORD dwErr, LPSTR *plpsz)
{
    DWORD dwRet;

    if(dwErr != ERROR_SUCCESS)
    {
        dwRet = Format_MessageV(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
            dwErr, plpsz, NULL, NULL);
    }
    else
    {
        const char szMsg[] = "No Error";
        Format_String(plpsz, (LPSTR)szMsg);
        dwRet = lstrlen(szMsg);
    }

    return(dwRet);
}

//=================================================================================
DWORD WINAPI Format_StringV(LPSTR *plpsz, LPCSTR lpszFmt, va_list *vArgs)
{
    return(Format_MessageV(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING,
        0, plpsz, lpszFmt, vArgs));
}

// ***************************************************************************
DWORD WINAPI Format_MessageV(DWORD dwFlags, DWORD dwErr, LPSTR *plpsz, LPCSTR lpszFmt, va_list *vArgs)
{
    const char c_Func_Name[] = "[Format_MessageV]";

    DWORD dwRet;
    DWORD dwGLE;

    *plpsz = NULL;
    dwRet = FormatMessage(dwFlags, lpszFmt, dwErr, 0, (LPSTR) plpsz, 0, vArgs);

    if (!dwRet || !*plpsz)
    {
        dwGLE = GetLastError();
        printf("%s FormatMessage Failed: %s. dwRet: %#lx!. *plpsz:%#lx! GLE:%d\r\n", c_Func_Name, lpszFmt, dwRet, *plpsz, dwGLE);

        if (*plpsz)
            LocalFree ((HLOCAL) *plpsz);
        *plpsz = NULL;
        return 0;
    }

    return(dwRet);
}

#if 0
BOOL
GetStreamInformation(
    LPCSTR  lpExistingFileName,
    LPVOID  *lpStreamInformation
    )
{
    HANDLE SourceFile = INVALID_HANDLE_VALUE;
    PFILE_STREAM_INFORMATION StreamInfoBase = NULL;
    ULONG StreamInfoSize;
    IO_STATUS_BLOCK IoStatus;
    BOOL    fRet = FALSE;
    DWORD   Status;

    *lpStreamInformation = NULL;
    SourceFile = CreateFile(
                    lpExistingFileName,
                    GENERIC_READ,
                    FILE_SHARE_READ | FILE_SHARE_WRITE,
                    NULL,
                    OPEN_EXISTING,
                    FILE_FLAG_SEQUENTIAL_SCAN,
                    NULL
                    );
    if (SourceFile == INVALID_HANDLE_VALUE)
    {
        return FALSE;
    }
    //
    //  Obtain the full set of streams we have to copy.  Since the Io subsystem does
    //  not provide us a way to find out how much space this information will take,
    //  we must iterate the call, doubling the buffer size upon each failure.
    //
    //  If the underlying file system does not support stream enumeration, we end up
    //  with a NULL buffer.  This is acceptable since we have at least a default
    //  data stream,
    //

    StreamInfoSize = 4096;
    do {
        StreamInfoBase = LocalAlloc(LPTR, StreamInfoSize );

        if ( !StreamInfoBase ) {
            SetLastError( STATUS_NO_MEMORY );
            goto bailout;
        }

        Status = NtQueryInformationFile(
                    SourceFile,
                    &IoStatus,
                    (PVOID) StreamInfoBase,
                    StreamInfoSize,
                    FileStreamInformation
                    );

        if (Status != STATUS_SUCCESS) {
            //
            //  We failed the call.  Free up the previous buffer and set up
            //  for another pass with a buffer twice as large
            //

            LocalFree(StreamInfoBase);
            StreamInfoBase = NULL;
            StreamInfoSize *= 2;
        }

    } while ( Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL );

    if (Status == STATUS_SUCCESS)
    {
        fRet = TRUE;
    }

bailout:

    if (SourceFile != INVALID_HANDLE_VALUE)
    {
        CloseHandle(SourceFile);
    }

    *lpStreamInformation = StreamInfoBase;

    return fRet;
}
#endif


#ifdef CSC_ON_NT
BOOL
DoPinningW(
    LPWSTR   lpwzName,
    DWORD   dwHintFlags,
    BOOL    fRecurse
    )
{
    unsigned short uBuff[MAX_PATH];
    WIN32_FIND_DATAW sFind32W;
    HANDLE  hFind = NULL;
    BOOL    fRet = TRUE;
    DWORD   lenName, dwStatus, dwPinCount, dwError;

    lenName = lstrlenW(lpwzName);

    if (lenName < 5)
    {
        return FALSE;
    }

    lstrcpyW(uBuff, lpwzName);

    if (uBuff[lenName-1] == (USHORT)'\\')
    {
        uBuff[lenName-1] = 0;

        --lenName;

        if (lenName < 5)
        {
            return FALSE;
        }
    }

    hFind = FindFirstFileW(uBuff, &sFind32W);
    if (hFind==INVALID_HANDLE_VALUE)
    {
        lstrcatW(uBuff, L"\\*");

        hFind = FindFirstFileW(uBuff, &sFind32W);

        uBuff[lenName] = 0;

        if (hFind==INVALID_HANDLE_VALUE)
        {
            return FALSE;
        }

    }
    else if (sFind32W.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
    {
        FindClose(hFind);

        lstrcatW(uBuff, L"\\*");
        hFind = FindFirstFileW(uBuff, &sFind32W);
        uBuff[lenName] = 0;

        if (hFind==INVALID_HANDLE_VALUE)
        {
            return FALSE;
        }
    }

    do
    {
        if (!CSCPinFileW(uBuff, dwHintFlags, &dwStatus, &dwPinCount, &dwHintFlags))
        {
            dwError = GetLastError();   
        }
        else
        {
            PrintCSCEntryInfo(NULL, dwStatus, dwPinCount, dwHintFlags, NULL);
        }

        if (fRecurse)
        {
            do
            {
                if(!FindNextFileW(hFind, &sFind32W))
                {
                    goto bailout;
                }

                if ((!lstrcmpW(sFind32W.cFileName, L"."))||(!lstrcmpW(sFind32W.cFileName, L"..")))
                {
                    continue;
                }

                uBuff[lenName] = (USHORT)'\\';
                uBuff[lenName+1] = 0;
                lstrcatW(uBuff, sFind32W.cFileName);

                if (sFind32W.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
                {
                    DoPinningW(uBuff, dwHintFlags, fRecurse);
                }

                break;
            }
            while (TRUE);
        }
        else
        {
            break;
        }
    }
    while (TRUE);

bailout:
    if (hFind)
    {
        FindClose(hFind);
    }
    return fRet;
}

#else

BOOL
DoPinningA(
    LPSTR   lpszName,
    DWORD   dwHintFlags,
    BOOL    fRecurse
    )
{
    char chBuff[MAX_PATH];
    WIN32_FIND_DATAA sFind32A;
    HANDLE  hFind = NULL;
    BOOL    fRet = TRUE;
    DWORD   lenName, dwStatus, dwPinCount, dwError;


    lenName = lstrlen(lpszName);

    if (lenName < 5)
    {
        return FALSE;
    }

    lstrcpy(chBuff, lpszName);

    if (chBuff[lenName-1] == (USHORT)'\\')
    {
        chBuff[lenName-1] = 0;
        --lenName;
        if (lenName < 5)
        {
            return FALSE;
        }
    }

    hFind = FindFirstFileA(chBuff, &sFind32A);

    if (hFind==INVALID_HANDLE_VALUE)
    {
        lstrcatA(chBuff, "\\*");
        hFind = FindFirstFileA(chBuff, &sFind32A);
        if (hFind==INVALID_HANDLE_VALUE)
        {
            return FALSE;
        }
        chBuff[lenName] = 0;
    }

    if (sFind32A.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
    {
        FindClose(hFind);

        lstrcatA(chBuff, "\\*");
        hFind = FindFirstFileA(chBuff, &sFind32A);

        if (hFind==INVALID_HANDLE_VALUE)
        {
            return FALSE;
        }
        chBuff[lenName] = 0;
    }

    do
    {
        if (!CSCPinFileA(chBuff, dwHintFlags, &dwStatus, &dwPinCount, &dwHintFlags))
        {
            dwError = GetLastError();   
        }
        else
        {
            PrintCSCEntryInfo(NULL, dwStatus, dwPinCount, dwHintFlags, NULL);
        }

        if (fRecurse)
        {
            if(!FindNextFile(hFind, &sFind32A))
            {
                goto bailout;
            }

            chBuff[lenName] = '\\';
            lstrcat(chBuff, sFind32A.cFileName);

            if (sFind32A.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
            {
                DoPinningA(chBuff, dwHintFlags, fRecurse);
            }
        }
        else
        {
            break;
        }
    }
    while (TRUE);

bailout:
    if (hFind)
    {
        FindClose(hFind);
    }
    return fRet;
}

#endif


//=================================================================================
DWORD
ProcessShowTime (
    DWORD argc,
    LPSTR *argv
    )
{
    DWORD Error, dwSize;
    FILETIME ftTemp;
    SYSTEMTIME SystemTime;

    if(argc != 2)
        return 0xffffffff;

    sscanf(argv[0], "%x", &(ftTemp.dwHighDateTime));
    sscanf(argv[1], "%x", &(ftTemp.dwLowDateTime));

    if(FileTimeToSystemTime( &ftTemp, &SystemTime )) {
        printf("%02u/%02u/%04u %02u:%02u:%02u\n ",
                    SystemTime.wMonth,
                    SystemTime.wDay,
                    SystemTime.wYear,
                    SystemTime.wHour,
                    SystemTime.wMinute,
                    SystemTime.wSecond );

    }
    else {
        printf("Wrong Times \n");
    }

    return ERROR_SUCCESS;
}

DWORD
ProcessEncryptDecrypt(
    DWORD   argc,
    LPSTR   *argv
)
{

    DWORD dwStatus, dwError=ERROR_SUCCESS;
    BOOL    fEncrypt = FALSE;
#ifdef CSC_ON_NT
    unsigned short uBuff[MAX_PATH];
#endif

    if (argc != 1)
    {
        printf("CSCUnPinFile: must provide a UNC path \r\n");
    }
    else
    {
        fEncrypt = !((*argv[0] == 'u')||(*argv[0] == 'U'));            
        if (argc == 1)
        {
            if(!CSCEncryptDecryptDatabase(fEncrypt, NULL, 0))
            {
                dwError = GetLastError();   
            }
        }
        else
        {
#if 0
            memset(uBuff, 0, sizeof(uBuff));
            MultiByteToWideChar(CP_ACP, 0, argv[1], strlen(argv[1]), uBuff, MAX_PATH*sizeof(unsigned short));

            if (!CSCEncryptDecryptFileW(uBuff, fEncrypt))
            {
                dwError = GetLastError();   
            }
#endif
        }
    }
    return (dwError);
}