//+-------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1996 - 2000.
//
// File: main.cxx
//
// Contents: Fixes a catalog after propagating from one machine to another.
//
// History: 12 Jan 2000 dlee Created from propdump
//
//--------------------------------------------------------------------------
#include <pch.cxx>
#pragma hdrstop
#include <proprec.hxx>
#include <propdesc.hxx>
#include "mmfile.hxx"
DECLARE_INFOLEVEL(ci)
unsigned const SixtyFourK = 1024 * 64;
//#define LOG
CCoTaskAllocator CoTaskAllocator; // exported data definition
void * CCoTaskAllocator::Allocate(ULONG cbSize)
{
return CoTaskMemAlloc( cbSize );
}
void CCoTaskAllocator::Free(void *pv)
{
CoTaskMemFree(pv);
}
void Usage()
{
printf( "Usage: PropCi directory\n");
printf( " directory specifies the directory where the catalog exists.\n");
printf( "\n" );
printf( "This application converts file indexes in the catalog specified.\n" );
exit( 1 );
}
WCHAR const * wcsistr( WCHAR const * wcsString, WCHAR const * wcsPattern )
{
if ( (wcsPattern == 0) || (*wcsPattern == 0) )
return wcsString;
ULONG cwcPattern = wcslen(wcsPattern);
while ( *wcsString != 0 )
{
while ( (*wcsString != 0) &&
(towupper(*wcsString) != towupper(*wcsPattern)) )
wcsString++;
if ( 0 == *wcsString )
return 0;
if ( _wcsnicmp( wcsString, wcsPattern, cwcPattern) == 0 )
return wcsString;
wcsString++;
}
return 0;
} //wcsistr
void AppendBackslash( WCHAR *p )
{
int x = wcslen( p );
if ( 0 != x && L'\\' != p[x-1] )
{
p[x] = L'\\';
p[x+1] = 0;
}
} //AppendBackslash
void FindFieldRec(
WCHAR const * pwcFile,
PROPID pid,
CPropDesc & prop,
ULONG & cTotal,
ULONG & cFixed,
ULONG & culFixed )
{
cTotal = 0;
cFixed = 0;
culFixed = 0;
HANDLE h = CreateFile( pwcFile,
GENERIC_READ,
FILE_SHARE_READ,
0,
OPEN_EXISTING,
0,
0 );
if ( INVALID_HANDLE_VALUE == h )
{
printf( "Can't open file %ws. Error %u\n", pwcFile, GetLastError() );
exit( 1 );
}
ULONG cbRead;
static BYTE abTemp[SixtyFourK];
if ( ReadFile( h,
abTemp,
sizeof abTemp ,
&cbRead,
0 ) )
{
// Loop through records
BOOL fFound = FALSE;
CPropDesc * pPropDesc = (CPropDesc *)abTemp;
for ( unsigned i = 0;
i < cbRead/(sizeof(CPropDesc) + sizeof(ULONG));
i++, pPropDesc = (CPropDesc *)(((BYTE *)pPropDesc) + sizeof(CPropDesc) + sizeof(ULONG)) )
{
if ( 0 != pPropDesc->Pid() )
{
if ( pPropDesc->Pid() == pid )
{
memcpy( &prop, pPropDesc, sizeof prop );
fFound = TRUE;
}
cTotal++;
if ( pPropDesc->Offset() != -1 )
{
cFixed++;
culFixed += (pPropDesc->Size() / sizeof(DWORD));
}
}
}
if ( !fFound )
{
printf( "can't find pid %#x\n", pid );
exit( 1 );
}
}
else
{
printf( "Can't read file %ws. Error %u\n", pwcFile, GetLastError() );
exit( 1 );
}
#ifdef LOG
printf( "pid %d, total %d, fixed %d\n", pid, cTotal, cFixed );
printf( " pid %d, vt %d, ostart %d, cbmax %d, ordinal %d, mask %d, rec %d, fmodify %d\n",
prop.Pid(),
prop.Type(),
prop.Offset(),
prop.Size(),
prop.Ordinal(),
prop.Mask(),
prop.Record(),
prop.Modifiable() );
#endif
CloseHandle( h );
} //FindFieldRec
NTSTATUS CiNtOpenNoThrow(
HANDLE & h,
WCHAR const * pwcsPath,
ACCESS_MASK DesiredAccess,
ULONG ShareAccess,
ULONG OpenOptions )
{
h = INVALID_HANDLE_VALUE;
UNICODE_STRING uScope;
if ( !RtlDosPathNameToNtPathName_U( pwcsPath,
&uScope,
0,
0 ) )
return STATUS_INSUFFICIENT_RESOURCES;
//
// Open the file
//
OBJECT_ATTRIBUTES ObjectAttr;
InitializeObjectAttributes( &ObjectAttr, // Structure
&uScope, // Name
OBJ_CASE_INSENSITIVE, // Attributes
0, // Root
0 ); // Security
IO_STATUS_BLOCK IoStatus;
NTSTATUS Status = NtOpenFile( &h, // Handle
DesiredAccess, // Access
&ObjectAttr, // Object Attributes
&IoStatus, // I/O Status block
ShareAccess, // Shared access
OpenOptions ); // Flags
RtlFreeHeap( RtlProcessHeap(), 0, uScope.Buffer );
return Status;
} //CiNtOpenNoThrow
FILEID GetFileId( WCHAR * pwcPath )
{
if ( 2 == wcslen( pwcPath ) )
wcscat( pwcPath, L"\\" );
HANDLE h;
NTSTATUS status = CiNtOpenNoThrow( h,
pwcPath,
FILE_READ_ATTRIBUTES | SYNCHRONIZE,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
0 );
if ( FAILED( status ) )
{
printf( "Can't open file %ws to get fileid. Error %#x\n", pwcPath, status );
return 0;
}
FILE_INTERNAL_INFORMATION fii;
IO_STATUS_BLOCK IoStatus;
status = NtQueryInformationFile( h,
&IoStatus,
&fii,
sizeof fii,
FileInternalInformation );
NtClose( h );
if ( NT_SUCCESS( status ) )
status = IoStatus.Status;
if ( NT_SUCCESS( status ) )
return fii.IndexNumber.QuadPart;
return 0;
} //GetFileId
void GetRecordInformation(
WCHAR const * pwcFile,
ULONG & cRecPerBuf,
ULONG & cbRec )
{
cRecPerBuf = 0;
cbRec = 0;
HANDLE h = CreateFile( pwcFile,
GENERIC_READ,
FILE_SHARE_READ,
0,
OPEN_EXISTING,
0,
0 );
if ( INVALID_HANDLE_VALUE == h )
{
printf( "Can't open file %ws. Error %u\n", pwcFile, GetLastError() );
exit( 1 );
}
ULONG cbRead;
static BYTE abTemp[SixtyFourK];
if ( ReadFile( h,
abTemp,
sizeof(abTemp),
&cbRead,
0 ) )
{
//
// Determine record size
//
if ( abTemp[0] != 0 || abTemp[1] != 0 )
{
printf( "Record 0 not blank. File corrupt!\n" );
exit( 1 );
}
// First record should be all empty and only the first
// record should be so. So counting all leading zeros gives us
// the size of the record.
for ( unsigned i = 0; i < cbRead && abTemp[i] == 0; i++ )
continue;
if ( i == cbRead )
{
printf( "First %uK segment all zero!. File corrupt!\n", sizeof(abTemp)/1024 );
exit( 1 );
}
switch ( *(USHORT *)&abTemp[i] )
{
case 0x5555:
case 0xAAAA:
case 0xBBBB:
case 0xCCCC:
case 0xDDDD:
cbRec = i;
if ( cbRec % 4 != 0 )
{
printf( "Record size (%u bytes) not DWORD aligned!\n\n", cbRec );
exit( 1 );
}
cRecPerBuf = sizeof(abTemp) / cbRec;
break;
default:
printf( "First non-zero byte is not a proper signature (%u)!\n", *(SHORT *)&abTemp[i] );
exit( 1 );
}
}
else
{
printf( "can't read from file %ws, error %d\n", pwcFile, GetLastError() );
exit( 1 );
}
#ifdef LOG
printf( "cRecPerBuf %d, cbRec %d\n", cRecPerBuf, cbRec );
#endif
CloseHandle( h );
} //GetRecordInformation
void PatchFileIDs(
WCHAR const * pwcDir,
WCHAR const * pwcPri,
WCHAR const * pwcSec )
{
//
// First, read the property specifications for secondary wid, fileindex,
// lastseen, and path. The first 3 are in the primary and the last in
// the secondary.
//
WCHAR awcPriProp[ MAX_PATH ];
wcscpy( awcPriProp, pwcDir );
wcscat( awcPriProp, L"CIP10000.001" );
ULONG cPriTotal, cPriFixed, culPriFixed;
CPropDesc SecWidPtrFieldRec;
FindFieldRec( awcPriProp,
pidSecondaryStorage,
SecWidPtrFieldRec,
cPriTotal,
cPriFixed,
culPriFixed );
CPropDesc FileIdFieldRec;
FindFieldRec( awcPriProp,
pidFileIndex,
FileIdFieldRec,
cPriTotal,
cPriFixed,
culPriFixed );
CPropDesc LastSeenFieldRec;
FindFieldRec( awcPriProp,
pidLastSeenTime,
LastSeenFieldRec,
cPriTotal,
cPriFixed,
culPriFixed );
WCHAR awcSecProp[ MAX_PATH ];
wcscpy( awcSecProp, pwcDir );
wcscat( awcSecProp, L"CIP20000.001" );
ULONG cSecTotal, cSecFixed, culSecFixed;
CPropDesc PathFieldRec;
FindFieldRec( awcSecProp,
pidPath,
PathFieldRec,
cSecTotal,
cSecFixed,
culSecFixed );
//
// Get information about the number and size of records.
//
ULONG cPriRecPerBuf, cbPriRec;
GetRecordInformation( pwcPri, cPriRecPerBuf, cbPriRec );
ULONG cSecRecPerBuf, cbSecRec;
GetRecordInformation( pwcSec, cSecRecPerBuf, cbSecRec );
//
// Walk the property store, get the secondary wid, read the path from
// the secondary store, lookup the fileid, and write the fileid back
// info the primary store.
//
CMMFile pri( pwcPri, TRUE );
if ( !pri.Ok() )
{
printf( "can't map primary\n" );
exit( 1 );
}
BYTE * pb = (BYTE *) pri.GetMapping();
BYTE * pbBase = pb;
CMMFile sec( pwcSec, TRUE );
if ( !sec.Ok() )
{
printf( "can't map secondary\n" );
exit( 1 );
}
BYTE * pbSecBase = (BYTE *) sec.GetMapping();
FILETIME ftNow;
GetSystemTimeAsFileTime( &ftNow );
#ifdef LOG
printf( "pb %#x, size %d\n", pb, pri.FileSize() );
#endif
ULONG iRec = 0, iRecTotal = 0;
do
{
#ifdef LOG
printf( "record %d\n", iRecTotal );
#endif
// If we're at the end of a 64k page, go on to the next one.
if ( iRec == cPriRecPerBuf )
{
iRec = 0;
pb += 65536;
}
COnDiskPropertyRecord * pRec = new( iRec, pb, cbPriRec/4 ) COnDiskPropertyRecord;
if ( (BYTE *) pRec >= ( pbBase + pri.FileSize() ) )
break;
if ( pRec->IsTopLevel() )
{
PROPVARIANT var;
static BYTE abExtra[MAX_PATH * 5];
unsigned cbExtra = sizeof(abExtra);
pRec->ReadFixed( SecWidPtrFieldRec.Ordinal(),
SecWidPtrFieldRec.Mask(),
SecWidPtrFieldRec.Offset(),
cPriTotal,
SecWidPtrFieldRec.Type(),
var,
abExtra,
&cbExtra,
*((PStorage *)0) );
if ( VT_UI4 != var.vt )
{
printf( "failure: secondary wid wasn't a UI4\n" );
exit( 1 );
}
#ifdef LOG
printf( "secondary wid %d\n", var.ulVal );
#endif
ULONG iTargetSection = var.ulVal/cSecRecPerBuf;
BYTE * pbSec = pbSecBase + ( iTargetSection * SixtyFourK );
// Get the secondary store record
COnDiskPropertyRecord * pRec2 = new( var.ulVal % cSecRecPerBuf, pbSec, cbSecRec/4 ) COnDiskPropertyRecord;
// Read the path
cbExtra = sizeof abExtra;
#ifdef LOG
printf( "pRec2: %#x\n", pRec2 );
#endif
var.vt = VT_EMPTY;
if ( !pRec2->ReadVariable( PathFieldRec.Ordinal(),
PathFieldRec.Mask(),
culSecFixed,
cSecTotal,
cSecFixed,
var,
abExtra,
&cbExtra ) )
{
// It's in an overflow record
BOOL fOk;
do
{
//
// Check for existing overflow block.
//
WORKID widOverflow = pRec2->OverflowBlock();
if ( 0 == widOverflow )
break;
iTargetSection = widOverflow / cSecRecPerBuf;
pbSec = pbSecBase + ( iTargetSection * SixtyFourK );
pRec2 = new( widOverflow % cSecRecPerBuf, pbSec, cbSecRec/4 ) COnDiskPropertyRecord;
#ifdef LOG
printf( "overflow pRec2: %#x\n", pRec2 );
#endif
ULONG Ordinal = PathFieldRec.Ordinal() - cSecFixed;
DWORD Mask = (1 << ((Ordinal % 16) * 2) );
fOk = pRec2->ReadVariable( Ordinal, // Ordinal (assuming 0 fixed)
Mask, // Mask (assuming 0 fixed)
0, // Fixed properties
cSecTotal - cSecFixed,
0, // Count of fixed properties
var,
abExtra,
&cbExtra );
} while ( !fOk );
}
if ( VT_LPWSTR == var.vt )
{
// Get and set the fileindex for this volume
FILEID fid = GetFileId( var.pwszVal );
PROPVARIANT varId;
varId.vt = VT_UI8;
varId.hVal.QuadPart = fid;
pRec->WriteFixed( FileIdFieldRec.Ordinal(),
FileIdFieldRec.Mask(),
FileIdFieldRec.Offset(),
FileIdFieldRec.Type(),
cPriTotal,
varId );
// Set the last seen time so we don't reindex the file
PROPVARIANT varLS;
varLS.vt = VT_FILETIME;
varLS.filetime = ftNow;
pRec->WriteFixed( LastSeenFieldRec.Ordinal(),
LastSeenFieldRec.Mask(),
LastSeenFieldRec.Offset(),
LastSeenFieldRec.Type(),
cPriTotal,
varLS );
#ifdef LOG
printf( "fileid %#I64x, %ws\n", fid, var.pwszVal );
#endif
}
}
if ( pRec->IsValidType() )
{
iRec += pRec->CountRecords();
iRecTotal += pRec->CountRecords();
}
else
{
iRec++;
iRecTotal++;
}
} while ( TRUE );
pri.Flush();
} //PatchFileIDs
void GetNtVolumeInformation(
ULONG ulVolumeId,
ULONGLONG & ullVolumeCreationTime,
ULONG & ulVolumeSerialNumber,
ULONGLONG & ullJournalId )
{
ullVolumeCreationTime = 0;
ulVolumeSerialNumber = 0;
ullJournalId = 0;
WCHAR wszVolumePath[] = L"\\\\.\\a:";
wszVolumePath[4] = (WCHAR) ulVolumeId;
FILE_FS_VOLUME_INFORMATION VolumeInfo;
VolumeInfo.VolumeCreationTime.QuadPart = 0;
VolumeInfo.VolumeSerialNumber = 0;
HANDLE hVolume = CreateFile( wszVolumePath,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
0,
OPEN_EXISTING,
0,
0 );
if ( INVALID_HANDLE_VALUE == hVolume )
{
printf( "failure: can't open volume %ws\n", wszVolumePath );
exit( 1 );
}
IO_STATUS_BLOCK iosb;
RtlZeroMemory( &VolumeInfo, sizeof VolumeInfo );
NtQueryVolumeInformationFile( hVolume,
&iosb,
&VolumeInfo,
sizeof(VolumeInfo),
FileFsVolumeInformation );
//
// This call will only succeed on NTFS NT5 w/ USN Journal enabled.
//
USN_JOURNAL_DATA UsnJournalInfo;
RtlZeroMemory( &UsnJournalInfo, sizeof UsnJournalInfo );
NTSTATUS Status = NtFsControlFile( hVolume,
0,
0,
0,
&iosb,
FSCTL_QUERY_USN_JOURNAL,
0,
0,
&UsnJournalInfo,
sizeof UsnJournalInfo );
if ( NT_SUCCESS(Status) && NT_SUCCESS( iosb.Status ) )
{
// cool, it's a usn volume
}
else if ( ( STATUS_JOURNAL_NOT_ACTIVE == Status ||
STATUS_INVALID_DEVICE_STATE == Status ) )
{
//
// Usn journal not created, create it
//
CREATE_USN_JOURNAL_DATA usnCreateData;
usnCreateData.MaximumSize = 0x800000; // 8 meg
usnCreateData.AllocationDelta = 0x100000; // 1 meg
Status = NtFsControlFile( hVolume,
0,
0,
0,
&iosb,
FSCTL_CREATE_USN_JOURNAL,
&usnCreateData,
sizeof usnCreateData,
0,
0 );
if ( NT_SUCCESS( Status ) && NT_SUCCESS( iosb.Status ) )
{
Status = NtFsControlFile( hVolume,
0,
0,
0,
&iosb,
FSCTL_QUERY_USN_JOURNAL,
0,
0,
&UsnJournalInfo,
sizeof UsnJournalInfo );
if (! ( NT_SUCCESS(Status) && NT_SUCCESS( iosb.Status ) ) )
{
printf( "can't query usn vol info after creating it %#x\n", Status );
exit( 1 );
}
}
else
{
printf( "can't create usn journal %#x\n", Status );
exit( 1 );
}
}
else
{
printf( "can't get USN information, probably FAT: %#x\n", Status );
}
ullVolumeCreationTime = VolumeInfo.VolumeCreationTime.QuadPart;
ulVolumeSerialNumber = VolumeInfo.VolumeSerialNumber;
ullJournalId = UsnJournalInfo.UsnJournalID;
printf( " new volumecreationtime: %#I64x\n", ullVolumeCreationTime );
printf( " new volumeserialnumber: %#x\n", ulVolumeSerialNumber );
printf( " new journalid: %#I64x\n", ullJournalId );
CloseHandle( hVolume );
} //GetNtVolumeInformation
void PatchScopeTable( WCHAR const * pwcDir )
{
// Find out how many scopes are in the scope table
ULONG cScopes = 0;
{
WCHAR awcControl[ MAX_PATH ];
wcscpy( awcControl, pwcDir );
wcscat( awcControl, L"cisp0000.000" );
CMMFile Control( awcControl, FALSE );
if ( 0 == Control.GetMapping() )
{
printf( "can't open file %ws\n", awcControl );
exit( 1 );
}
cScopes = ((ULONG *) Control.GetMapping())[4];
}
WCHAR awcOne[ MAX_PATH ];
wcscpy( awcOne, pwcDir );
wcscat( awcOne, L"cisp0000.001" );
// Loop through the scopes and patch
{
printf( " scope table: %ws has %d scopes\n", awcOne, cScopes );
CMMFile One( awcOne, TRUE );
if ( !One.Ok() )
{
printf( "can't map scope table\n" );
exit( 1 );
}
BYTE * pb = (BYTE *) One.GetMapping();
for ( ULONG i = 0; i < cScopes; i++ )
{
const LONGLONG eSigCiScopeTable = 0x5158515851585158i64;
LONGLONG signature;
memcpy( &signature, pb, sizeof signature );
pb += sizeof signature;
if ( 0 == signature )
break;
printf( " scope record: \n" );
if ( eSigCiScopeTable != signature )
{
printf( "invalid scope signature: %#I64x\n", signature );
exit( 1 );
}
VOLUMEID volumeId;
memcpy( &volumeId, pb, sizeof volumeId );
printf( " volumeId: %x\n", volumeId );
pb += sizeof volumeId;
ULONGLONG ullNewVolumeCreationTime;
ULONG ulNewVolumeSerialNumber;
ULONGLONG ullNewJournalId;
GetNtVolumeInformation( volumeId,
ullNewVolumeCreationTime,
ulNewVolumeSerialNumber,
ullNewJournalId );
ULONGLONG ullVolumeCreationTime;
memcpy( &ullVolumeCreationTime, pb, sizeof ullVolumeCreationTime );
printf( " creation time: %#I64x\n", ullVolumeCreationTime );
memcpy( pb,
&ullNewVolumeCreationTime,
sizeof ullNewVolumeCreationTime );
pb += sizeof ullVolumeCreationTime;
ULONG ulVolumeSerialNumber;
memcpy( &ulVolumeSerialNumber, pb, sizeof ulVolumeSerialNumber );
printf( " serial number: %x\n", ulVolumeSerialNumber );
memcpy( pb,
&ulNewVolumeSerialNumber,
sizeof ulNewVolumeSerialNumber );
pb += sizeof ulVolumeSerialNumber;
if ( CI_VOLID_USN_NOT_ENABLED == volumeId )
{
FILETIME ft;
memcpy( &ft, pb, sizeof ft );
printf( " filetime: %#I64x\n", ft );
pb += sizeof ft;
}
else
{
USN usn;
memcpy( &usn, pb, sizeof usn );
printf( " usn: %#I64x\n", usn );
USN usnNewMax = 0;
memcpy( pb,
&usnNewMax,
sizeof usnNewMax );
pb += sizeof usn;
ULONGLONG JournalId;
memcpy( &JournalId, pb, sizeof JournalId );
printf( " JournalId: %#I64x\n", JournalId );
memcpy( pb,
&ullNewJournalId,
sizeof ullNewJournalId );
pb += sizeof JournalId;
}
ULONG cwcPath;
memcpy( &cwcPath, pb, sizeof cwcPath );
pb += sizeof cwcPath;
WCHAR awcPath[ MAX_PATH ];
memcpy( awcPath, pb, cwcPath * sizeof WCHAR );
printf( " path: %ws\n", awcPath );
pb += ( cwcPath * sizeof WCHAR );
}
One.Flush();
}
WCHAR awcTwo[ MAX_PATH ];
wcscpy( awcTwo, pwcDir );
wcscat( awcTwo, L"cisp0000.002" );
BOOL f = CopyFile( awcOne, awcTwo, FALSE );
if ( !f )
{
printf( "can't copy scope list, error %d\n", GetLastError() );
exit( 1 );
}
} //PatchScopeDir
extern "C" int __cdecl wmain( int argc, WCHAR * argv[] )
{
if ( 2 != argc )
Usage();
//
// The lone argument is the catalog directory, with or without catalog.wci
//
WCHAR awcDir[ MAX_PATH ];
wcscpy( awcDir, argv[1] );
AppendBackslash( awcDir );
if ( 0 == wcsistr( awcDir, L"catalog.wci" ) )
wcscat( awcDir, L"catalog.wci\\" );
// Find and validate the primary and secondary stores exist
WCHAR awcPri[MAX_PATH];
wcscpy( awcPri, awcDir );
wcscat( awcPri, L"*.ps1" );
WIN32_FIND_DATA findData;
HANDLE h = FindFirstFile( awcPri, &findData );
if ( INVALID_HANDLE_VALUE == h )
{
printf( "can't find primary *.ps1 store\n" );
exit( 1 );
}
FindClose( h );
wcscpy( awcPri, awcDir );
wcscat( awcPri, findData.cFileName );
WCHAR awcSec[MAX_PATH];
wcscpy( awcSec, awcDir );
wcscat( awcSec, L"*.ps2" );
h = FindFirstFile( awcSec, &findData );
if ( INVALID_HANDLE_VALUE == h )
{
printf( "can't find secondary *.ps2 store\n" );
exit( 1 );
}
FindClose( h );
wcscpy( awcSec, awcDir );
wcscat( awcSec, findData.cFileName );
//
// Do the core work here -- patch the file IDs in the primary store.
// Also whack the last seen times so the files aren't refiltered in
// case they were copied to the target machine after the catalog was
// snapped.
//
printf( "patching file IDs\n" );
PatchFileIDs( awcDir, awcPri, awcSec );
//
// Patch the scope table so cisvc doesn't think it's a different volume.
//
printf( "patching the scope table\n" );
PatchScopeTable( awcDir );
//
// Delete the old fileid hash table since the fileids are wrong.
// It'll get recreated automatically when the catalog is opened.
//
printf( "deleting the fileid hash map\n" );
WCHAR awcHashMap[ MAX_PATH ];
wcscpy( awcHashMap, awcDir );
wcscat( awcHashMap, L"cicat.fid" );
DeleteFile( awcHashMap );
printf( "catalog successfully converted\n" );
return 0;
} //wmain