windows-server-2003/inetsrv/query/setupqry/catcnfg.cxx

//+-------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1998 - 2000.
//
//  File:       CatCnfg.cxx
//
//  Contents:   Support for adding catalogs during setup.
//
//  History:    13-May-1998   KyleP   Added copyright
//
//--------------------------------------------------------------------------

#include "pch.cxx"
#pragma hdrstop

#include <ciregkey.hxx>
#include "catcnfg.hxx"


//+-------------------------------------------------------------------------
//
//  Member:     CCatalogConfig::CCatalogConfig
//
//  Synopsis:   Constructor
//
//  History:    9-10-97  mohamedn
//
//--------------------------------------------------------------------------

CCatalogConfig::CCatalogConfig(CError & Err) :
    _Err( Err ),
    _cDrive( 0 ),
    _pwszCatalogDrive( 0 ),
    _cIncludedScopes( 0 ), _xaIncludedScopes( 10 ),
    _cExcludedScopes( 0 ), _xaExcludedScopes( 10 )
{
    RtlZeroMemory( _DriveList, sizeof _DriveList );
}

//+-------------------------------------------------------------------------
//
//  Member:     CCatalogConfig::InitDriveList, public
//
//  Synopsis:   Initialize drive list with local drive names, types, and
//              available/free space.
//
//  Arguments:  none
//
//  Returns:    ERROR_SUCCESS upon sucess,
//              none zero upon failure.
//
//  History:    6-27-97     mohamedn  created
//              9/10/97     mohamedn  rewritten catalog configuration
//
//--------------------------------------------------------------------------

BOOL CCatalogConfig::InitDriveList()
{
    // 26 drive letters * 4 characters per drive + terminating NULL.
    const DWORD dwSize = MAX_DRIVES * CHARS_PER_DRIVE + 1;
    WCHAR       wszListOfAllDrives[ dwSize ];
    unsigned    iDriveNumber   = 0;
    DWORD       dwRetVal       = 0;

    RtlZeroMemory( wszListOfAllDrives, sizeof wszListOfAllDrives );

    dwRetVal = GetLogicalDriveStrings(dwSize, wszListOfAllDrives);
    if ( dwRetVal == 0 ||  dwRetVal > dwSize )
    {
        DWORD dwErr = GetLastError();
        isDebugOut(( "GetLogicalDriveStrings Failed: dwRetVal: %d, GetLastError(): %d\n",
                     dwRetVal, dwErr ));

        ISError( IS_MSG_COULD_NOT_CONFIGURE_CATALOGS, _Err, LogSevFatalError, dwErr );

        return FALSE;
    }

    for ( WCHAR *pwszTmp = wszListOfAllDrives;
          *pwszTmp;
          pwszTmp += CHARS_PER_DRIVE )
    {
        switch (GetDriveType(pwszTmp))
        {
        case DRIVE_FIXED:         // The disk cannot be removed from the drive.
            break;

        default:
            isDebugOut(( "InitDriveList: Unexpected drive type %d\n",
                         GetDriveType(pwszTmp) ));

        case 0:                 // The drive type cannot be determined.
        case 1:                 // The root directory does not exist.
        case DRIVE_REMOVABLE:   // The media can be removed from the drive.
        case DRIVE_REMOTE:      // The drive is a remote (network) drive.
        case DRIVE_CDROM:       // drive is a CD-ROM drive.
        case DRIVE_RAMDISK:     // The drive is a RAM disk.
            continue;
        }

        _DriveList[iDriveNumber].SetDriveName(pwszTmp);

        if ( ! _DriveList[iDriveNumber].SetDriveInfo( ) )
        {
            continue;
        }
        else
        {
            iDriveNumber++;
        }
    }

    _cDrive = iDriveNumber;

    ReservePageFileData();

    return ( _cDrive > 0 ? TRUE : FALSE );
}


//+-------------------------------------------------------------------------
//
//  Member:     CCatalogConfig::ReservePageFileData, private
//
//  Synopsis:   Reserve unallocated space for page files.
//
//  Arguments:  none
//
//  Returns:    TRUE upon sucess, FALSE upon failure.
//
//  History:    26 Oct 1998    AlanwW    Created
//
//--------------------------------------------------------------------------

const WCHAR wszPagingFileKey[] =
    L"System\\CurrentControlSet\\Control\\Session Manager\\Memory Management";
const WCHAR wszPagingFileValueName[] = L"PagingFiles";

BOOL CCatalogConfig::ReservePageFileData()
{
    WCHAR awcPagingFiles[2000];
    awcPagingFiles[0] = L'\0';

    //
    //  Get the original page file info from
    //  HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\SessonManager
    //
    CWin32RegAccess reg( HKEY_LOCAL_MACHINE, wszPagingFileKey );

    if ( ! reg.Get( wszPagingFileValueName,
                    awcPagingFiles,
                    sizeof awcPagingFiles/sizeof awcPagingFiles[0] ) )
        return FALSE;

    //
    // Iterate through all paging files, reserve any difference between
    // the max size and currently allocated size.
    //
    WCHAR * pwsz = &awcPagingFiles[0];
    while ( *pwsz )
    {
        WCHAR *pwszPageFile = pwsz;
        pwsz = wcschr(pwsz, L' ');
        if ( ! pwsz )
            break;

        *pwsz++ = L'\0';
        ULONG ulMinAlloc = _wtoi( pwsz );

        WCHAR *pwsz2 = wcschr(pwsz, L' ');

        ULONG ulMaxAlloc = ulMinAlloc + MAXOVERMINFACTOR;
        if ( pwsz2 )
            ulMaxAlloc = _wtoi( pwsz2 );

        while ( *pwsz )
            pwsz++;
        pwsz++;

        CDriveInformation * pDriveInfo = GetDriveInfo( pwszPageFile );
        if ( !pDriveInfo )
            continue;

        //
        //  For some reason, GetFileAttributesEx will get a sharing violation
        //  on an open paging file.  FindFirstFile will work to get the very
        //  same information.
        //
        HANDLE hFind;
        WIN32_FIND_DATA FindData;

        if ( (hFind = FindFirstFile(pwszPageFile, &FindData)) ==
             INVALID_HANDLE_VALUE )
        {
            isDebugOut(( "ReservePageFileData: FindFirstFile %ws failed: %x\n",
                         pwszPageFile,
                         GetLastError() ));
            continue;
        }
        FindClose(hFind);

        ULARGE_INTEGER ullFileSize;
        ullFileSize.LowPart =  FindData.nFileSizeLow;
        ullFileSize.HighPart = FindData.nFileSizeHigh;

        pDriveInfo->ReservePagingData( ulMaxAlloc * ONE_MB,
                                       ullFileSize.QuadPart );
    }
    return TRUE;
}


//+-------------------------------------------------------------------------
//
//  Member:     CDriveInformation::GetDriveInfo, public
//
//  Synopsis:   Returns pointer to drive information structure.
//
//  Arguments:  [pwszPath] - path name to be looked up
//
//  Returns:    CDriveInformation* - pointer to drive information; 0 if not found
//
//  History:    29 Oct 1998     AlanW     Created
//
//--------------------------------------------------------------------------

CDriveInformation * CCatalogConfig::GetDriveInfo(WCHAR const * pwszPath)
{
    WCHAR       wcDriveLetter = (WCHAR)toupper( *pwszPath );

    for (unsigned i = 0; i < _cDrive; i++ )
    {
        if (toupper( _DriveList[i].GetDriveLetter() ) == wcDriveLetter )
            return &_DriveList[i];
    }

    return 0;
}

//+-------------------------------------------------------------------------
//
//  Member:     CDriveInformation::SetDriveInfo, public
//
//  Synopsis:   Obtains drive info
//
//  Arguments:  [none]
//
//  Returns:    TRUE upon success, False upon failure.
//
//  History:    6-27-97        mohamedn  created
//              26 Oct 1998    AlanwW    Enhanced and made a CDriveInfo method.
//
//--------------------------------------------------------------------------

static WCHAR pwszBootFile1[] = L"x:\\NTLDR";                      // x86
static WCHAR pwszBootFile2[] = L"x:\\OS\\WINNT50\\OSLOADER.EXE";  // risc

static WCHAR * apwszBootFiles[] = {
    pwszBootFile1,
    pwszBootFile2,
};


BOOL CDriveInformation::SetDriveInfo()
{
    Win4Assert( 0 != GetDriveLetter() );
    _cbFreeSpace = _cbTotalSpace = _cbReservedSpace = 0;

    ULARGE_INTEGER  cbFreeBytesToCaller;
    ULARGE_INTEGER  cbTotalNumberOfBytes;
    ULARGE_INTEGER  cbTotalNumberOfFreeBytes;

    cbFreeBytesToCaller.QuadPart        = 0;
    cbTotalNumberOfBytes.QuadPart       = 0;
    cbTotalNumberOfFreeBytes.QuadPart   = 0;

    //
    // returns 0 upon failure, none-zero upon success.
    //
    BOOL fSuccess = GetDiskFreeSpaceEx( _wszDriveName,
                                        &cbFreeBytesToCaller,
                                        &cbTotalNumberOfBytes,
                                        &cbTotalNumberOfFreeBytes );
    if (!fSuccess)
    {
         isDebugOut(( "SetDriveInfo: GetDiskFreeSapceEx %ws failed: %x\n",
                      _wszDriveName,
                      GetLastError() ));
         return fSuccess;
    }

    _cbFreeSpace= cbTotalNumberOfFreeBytes.QuadPart;
    _cbTotalSpace= cbTotalNumberOfBytes.QuadPart;

    //
    // Determine if the volume supports security (i.e., if it's NTFS)
    //
    fSuccess = GetVolumeInformationW( _wszDriveName,
                                      0, 0,           // volume name
                                      0,              // volume serial number
                                      0,              // max filename length
                                      &_dwFileSystemFlags,
                                      0, 0 );         // file system name

    if (!fSuccess)
    {
         isDebugOut(( "SetDriveInfo: GetFileSystemInfo failed: %x\n",GetLastError() ));
         return fSuccess;
    }

    for (unsigned i=0; i < NUMELEM( apwszBootFiles ); i++)
    {
        if (Exists(apwszBootFiles[i]))
        {
            _fIsBootDrive = TRUE;
            break;
        }
    }

    return fSuccess;
}

//+-------------------------------------------------------------------------
//
//  Member:     CDriveInformation::Exists, public
//
//  Synopsis:   Determines if a file or directory exists
//
//  Arguments:  [pwszPath]   - path name of the file to check
//
//  Notes:      The [pwszPath] must be a full path name starting with a
//              drive letter.  The drive letter is overwritten by this
//              method.
//
//  Returns:    TRUE if the file exists, FALSE upon failure or non-existance.
//
//  History:    26 Oct 1998     AlanW     Created
//
//--------------------------------------------------------------------------

BOOL CDriveInformation::Exists(WCHAR * pwszPath)
{
    *pwszPath = GetDriveLetter();

    DWORD attr = GetFileAttributes( pwszPath );

    // If we couldn't determine file's attributes, don't consider it found
    // unless the error code indirectly indicates that it exists.

    if ( 0xffffffff == attr )
    {
        isDebugOut(( DEB_TRACE, "Exists: GetFileAttributes( %ws ) Failed: %d\n",
                      pwszPath, GetLastError() ));

        if (GetLastError() == ERROR_SHARING_VIOLATION)
            return TRUE;        // It must exist

        return FALSE;
    }

    return TRUE;
}

//+-------------------------------------------------------------------------
//
//  Member:     CCatalogConfig::ConfigureDefaultCatalog
//
//  Synopsis:   Creates a single default catalog if sufficient disk space
//              exists on one drive.
//
//  Arguments:  [wszPrimaryScope] -- Path name of primary indexed directory
//
//  Returns:    TRUE upon success, FALSE upon Failure,
//
//  History:    9-10-97  mohamedn
//
//--------------------------------------------------------------------------

static WCHAR wszUpgradeDir[] = L"x:\\$WIN_NT$.~LS";

BOOL CCatalogConfig::ConfigureDefaultCatalog(
    WCHAR const * pwszPrimaryScope )
{
    {
        //
        // Reserve space for a net upgrade of the OS if we're not currently
        // doing one (in which case the space for it will already be in use).
        // Because we will preferably use an NTFS drive for the catalog, try
        // using a FAT drive for the upgrade files.
        //
        int       iUpgradeFiles = -1;
        int       iBestFitForUpgrade = -1;
        ULONGLONG cbBestFitForUpgrade = 0;
        BOOL      fBestFitOnNtfs = FALSE;

        for ( unsigned i = 0 ; i < _cDrive; i++ )
        {
            if ( iUpgradeFiles == -1 && _DriveList[i].Exists( wszUpgradeDir ) )
            {
                iUpgradeFiles = i;
                break;
            }

            ULONGLONG cbAvail = _DriveList[i].GetAvailableSpace();
            if ( cbAvail < MIN_UPGRADE_SPACE )
                continue;

            if ( iBestFitForUpgrade == -1 ||
                 ( cbAvail < cbBestFitForUpgrade && fBestFitOnNtfs ) ||
                 ( ! _DriveList[i].IsNtfs() && fBestFitOnNtfs ) )
            {
                cbBestFitForUpgrade = cbAvail;
                iBestFitForUpgrade = i;
                fBestFitOnNtfs = _DriveList[i].IsNtfs();
            }
        }
        if ( iUpgradeFiles == -1 && iBestFitForUpgrade != -1 )
            _DriveList[iBestFitForUpgrade].AddReservedSpace( MIN_UPGRADE_SPACE );
        else  if ( iUpgradeFiles == -1 )
        {
            isDebugOut(( DEB_TRACE, "Not enough room for net upgrade!\n" ));
            return FALSE;
        }
    }

    //
    //  Determine which drive to put the catalog on.
    //
    int          iBiggestFreeNTFS = -1;
    int          iBiggestFreeFAT  = -1;
    ULONGLONG    cbMaxFreeSpaceOnNTFS = 0;
    ULONGLONG    cbMaxFreeSpaceOnFAT  = 0;

    for ( unsigned i = 0 ; i < _cDrive; i++ )
    {
        if ( _DriveList[i].IsSmallBootPartition() )
            continue;

        int *       piBiggestFree = &iBiggestFreeFAT;
        ULONGLONG * pcbMaxFree = &cbMaxFreeSpaceOnFAT;
        if ( _DriveList[i].IsNtfs() )
        {
            piBiggestFree = &iBiggestFreeNTFS;
            pcbMaxFree = &cbMaxFreeSpaceOnNTFS;
        }

        if ( *pcbMaxFree < _DriveList[i].GetAvailableSpace() )
        {
            *pcbMaxFree = _DriveList[i].GetAvailableSpace();
            *piBiggestFree = i;
        }
    }


    BOOL fAddNtfsDrives = FALSE;
    CDriveInformation * pCatalogDrive = 0;
    double dblCatalogSizeRatio;

    if ( iBiggestFreeNTFS != -1 )
    {
        //
        // There is an NTFS drive on the system; need to put the catalog
        // there.
        //

        pCatalogDrive = &_DriveList[iBiggestFreeNTFS];
        dblCatalogSizeRatio = CATALOG_SIZE_RATIO_NTFS;
        fAddNtfsDrives = TRUE;
    }
    else if ( iBiggestFreeFAT != -1 )
    {
        pCatalogDrive = &_DriveList[iBiggestFreeFAT];
        dblCatalogSizeRatio = CATALOG_SIZE_RATIO_FAT;
        fAddNtfsDrives = FALSE;
    }

    if ( 0 == pCatalogDrive ||
         pCatalogDrive->GetAvailableSpace() < MIN_CATALOG_SPACE )
    {
        isDebugOut(( DEB_TRACE, "Not enough room for minimal catalog!\n" ));
        return FALSE;
    }

    _pwszCatalogDrive = pCatalogDrive->GetDriveName();
    pCatalogDrive->AddReservedSpace( MIN_CATALOG_SPACE );

    //  Add the primary scope directory for the catalog.
    if ( pwszPrimaryScope && *pwszPrimaryScope )
        AddIncludedDir( pwszPrimaryScope );

    //
    // Iterate through the list of drives once or twice, depending on
    // whether all drives are FAT.
    //
    unsigned maxLoop = _cDrive * ( (fAddNtfsDrives == TRUE) + 1);
    for ( i = 0 ; i < maxLoop; i++ )
    {
        // If end of NTFS enumeration, go back around the loop for FAT drives.
        if (i == _cDrive)
            fAddNtfsDrives = FALSE;

        CDriveInformation & DriveToCheck = _DriveList[i % _cDrive];

        if ( DriveToCheck.IsSmallBootPartition() )
            continue;

        if ( DriveToCheck.IsNtfs() != fAddNtfsDrives )
            continue;

        ULONGLONG cbUsed = DriveToCheck.GetUsedSpace();

        cbUsed = (ULONGLONG) ((LONGLONG)cbUsed * dblCatalogSizeRatio);
        if ( cbUsed < pCatalogDrive->GetAvailableSpace() )
        {
            AddIncludedDir( DriveToCheck.GetDriveName() );
            pCatalogDrive->AddReservedSpace( cbUsed );
        }
    }

    return TRUE;
}

//+-------------------------------------------------------------------------
//
//  Member:     CCatalogConfig::SaveState
//
//  Synopsis:   Saves the state of the catalog configuration in the registry.
//
//  Arguments:  - NONE -
//
//  Returns:    TRUE upon success, FALSE upon Failure,
//
//  History:    19 Nov 1998   AlanW   Created
//
//--------------------------------------------------------------------------

BOOL CCatalogConfig::SaveState( )
{
    Win4Assert( 0 != GetName() && 0 != GetLocation() );

    CCatReg  catReg(_Err);

    if ( !catReg.Init( GetName(), GetLocation() ) )
        return FALSE;

    //
    // Add all the included scopes
    //
    WCHAR const * pwszScope;
    for (unsigned i = 0;  pwszScope = GetIncludedScope( i ); i++)
    {
        if ( !catReg.AddScope( pwszScope, L",,5" ) )
        {
            return FALSE;
        }
    }

    //
    // Now add the excluded scopes
    //
    for (i = 0;  pwszScope = GetExcludedScope( i ); i++)
    {
        if ( !catReg.AddScope( pwszScope, L",,4" ) )
        {
            return FALSE;
        }
    }
    return TRUE;
}


//+-------------------------------------------------------------------------
//
//  Member:     CCatalogConfig::AddStringToArray, private static
//
//  Synopsis:   Adds a string to an XArray
//
//  Arguments:  [c]    - current count of strings in array
//              [xa]   - the XArray of strings
//              [pwsz] - string to be added
//
//  Returns:    BOOL - FALSE if any problems, TRUE otherwise
//
//  Notes:      Can throw on allocation failures.
//
//  History:    04 Nov 1998   AlanW   Created
//
//--------------------------------------------------------------------------

BOOL CCatalogConfig::AddStringToArray(
    ULONG & c,
    XArray<WCHAR const *> & xa,
    WCHAR const * pwsz )
{
    XPtrST<WCHAR> xpwsz;
    if (pwsz)
    {
        WCHAR * pwszCopy = new WCHAR[ wcslen(pwsz) + 1 ];
        xpwsz.Set(pwszCopy);
        wcscpy( pwszCopy, pwsz );
        pwsz = pwszCopy;
    }

    if ( c >= xa.Count() )
        xa.ReSize( c*2 );

    xa[c] = pwsz;
    c++;
    xpwsz.Acquire();
    return TRUE;
}


//+-------------------------------------------------------------------------
//
//  Member:     CCatReg::Init
//
//  Synopsis:   Initializes catalog registry key configurator
//
//  Arguments:  [ pwszCatName ] -   catalog name
//              [ pwszLocation] -   catalog location
//
//  Returns:    none - throws upon fatal errors.
//
//  History:    9-10-97  mohamedn
//
//--------------------------------------------------------------------------

BOOL CCatReg::Init( WCHAR const *pwszCatName, WCHAR const *pwszLocation)
{

    ISAssert( pwszCatName );

    // create a catalog for the drive
    BOOL fExisted = FALSE;
    CWin32RegAccess reg( HKEY_LOCAL_MACHINE, wcsRegCatalogsSubKey );

    if ( !reg.CreateKey( pwszCatName, fExisted ) )
    {
        DWORD dwErr = GetLastError();
        isDebugOut(( "created catalogs\\%ws subkey Failed: %d\n",
                      pwszCatName, dwErr ));

        ISError( IS_MSG_COULD_NOT_CONFIGURE_CATALOGS, _Err, LogSevFatalError, dwErr );

        return FALSE;
    }

    isDebugOut(( DEB_TRACE, "created catalogs\\%ws subkey\n", pwszCatName ));

    wcscpy( _wszCatRegSubKey, wcsRegCatalogsSubKey );
    wcscat( _wszCatRegSubKey, L"\\" );
    wcscat( _wszCatRegSubKey, pwszCatName );

    CWin32RegAccess regSystem( reg.GetHKey(), pwszCatName );
    if ( !regSystem.Set( L"Location", pwszLocation ) )
    {
        DWORD dw = GetLastError();

        isDebugOut(( "Failed to set Cat Location valued:%ws,  %d\n",
                      pwszLocation, dw ));

        ISError( IS_MSG_COULD_NOT_CONFIGURE_CATALOGS, _Err, LogSevFatalError, dw );

        return FALSE;
    }

    if ( !regSystem.Set( wcsIsIndexingW3Roots,        (DWORD) 0 )  ||
         !regSystem.Set( wcsIsIndexingNNTPRoots,      (DWORD) 0 )
       )
    {
        DWORD dw = GetLastError();

        isDebugOut(( "Failed to set Cat values: %d\n", dw ));

        ISError( IS_MSG_COULD_NOT_CONFIGURE_CATALOGS, _Err, LogSevFatalError, dw );

        return FALSE;
    }

    // Create a "Scopes" key so a watch can be established in cicat
    // It needs no entries.

    if ( !regSystem.CreateKey( wcsCatalogScopes, fExisted ) )
    {
        DWORD dw = GetLastError();
        isDebugOut(( "created scopes subkey Failed: %d\n", dw ));

        ISError( IS_MSG_COULD_NOT_CONFIGURE_CATALOGS, _Err, LogSevFatalError, dw );

        return FALSE;
    }

    //
    // initialize the reg scopes subkey name
    //
    wcscpy( _wszCatScopeRegSubKey, _wszCatRegSubKey );
    wcscat( _wszCatScopeRegSubKey, L"\\" );
    wcscat( _wszCatScopeRegSubKey, wcsCatalogScopes );

    return TRUE;
}

//+-------------------------------------------------------------------------
//
//  Member:     CCatReg::AddScope
//
//  Synopsis:   Adds a scope for the current catalog
//
//  Arguments:  [ pwszScopeName ]   -  scope name
//              [ pwszScopeAttrib]  -  scope attributes
//
//  Returns:    none - throws upon fatal errors.
//
//  History:    9-10-97  mohamedn
//
//--------------------------------------------------------------------------

BOOL CCatReg::AddScope( WCHAR const * pwszScopeName,
                        WCHAR const * pwszScopeAttrib )
{
    CWin32RegAccess regScopes( HKEY_LOCAL_MACHINE, _wszCatScopeRegSubKey );

    if ( !regScopes.Set( pwszScopeName, pwszScopeAttrib ) )
    {
        DWORD dwRetVal = GetLastError();

        isDebugOut(( "Failed to set scope value:\\%ws,  %d\n",
                          pwszScopeName, dwRetVal ));

        ISError( IS_MSG_COULD_NOT_CONFIGURE_CATALOGS, _Err, LogSevFatalError, dwRetVal );

        return FALSE;
    }
    else
    {
        return TRUE;
    }
}

//+-------------------------------------------------------------------------
//
//  Member:     CCatReg::TrackW3Svc, public
//
//  Synopsis:   Configures catalog to be a 'web' catalog.
//
//  Arguments:  [dwInstance] -- WWW Virtual Server instance number
//
//  Returns:    TRUE if setup succeeded.
//
//  History:    13-May-1998   KyleP   Created
//
//--------------------------------------------------------------------------

BOOL CCatReg::TrackW3Svc( DWORD dwInstance )
{
    CWin32RegAccess regSystem( HKEY_LOCAL_MACHINE, _wszCatRegSubKey );

    // Fix for 249655. For a web catalog, wcsGenerateCharacterization and 
    // wcsFilterFilesWithUnknownExtensions should be set as follows.

    if ( !regSystem.Set( wcsIsIndexingW3Roots, 1 ) ||
         !regSystem.Set( wcsW3SvcInstance, dwInstance ) ||
         !regSystem.Set( wcsGenerateCharacterization, 1 ) ||
         !regSystem.Set( wcsFilterFilesWithUnknownExtensions, (DWORD)0 ) ||
         !regSystem.Set( wcsMaxCharacterization, 320 ) )
    {
        DWORD dw = GetLastError();

        isDebugOut(( "Failed to set Cat values: %d\n", dw ));

        ISError( IS_MSG_COULD_NOT_CONFIGURE_CATALOGS, _Err, LogSevFatalError, dw );

        return FALSE;
    }

    return TRUE;
}