You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2321 lines
57 KiB
2321 lines
57 KiB
/*++
|
|
|
|
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);
|
|
}
|
|
|