windows-xp/Source/XPSP1/NT/inetsrv/query/cifrmwrk/indexing/ciframe.cxx

//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1992 - 2000.
//
//  File:       ciframe.cxx
//
//  Contents:
//
//  Classes:
//
//  Functions:
//
//  History:    11-22-96   srikants   Created
//
//----------------------------------------------------------------------------

#include <pch.cxx>
#pragma hdrstop

#include <frmutils.hxx>
#include <lang.hxx>
#include <worker.hxx>

#include "ciframe.hxx"

//+---------------------------------------------------------------------------
//
//  Member:     CCiAdminParams::QueryInterface
//
//  Arguments:  [riid]      -- Interface ID
//              [ppvObject] -- Object returned here
//
//  Returns:    S_OK if [riid] found.
//
//  History:    11-27-96   srikants   Created
//
//----------------------------------------------------------------------------

STDMETHODIMP CCiAdminParams::QueryInterface(
    REFIID riid,
    void **ppvObject)
{
    Win4Assert( 0 != ppvObject );

    *ppvObject = 0;

    if ( IID_ICiAdminParams == riid )
        *ppvObject = (void *)((ICiAdminParams *)this);
    else if ( IID_ICiAdmin == riid )
        *ppvObject = (void *)((ICiAdmin *)this);
    else if ( IID_IUnknown == riid )
        *ppvObject = (void *)((IUnknown *)(ICiAdminParams *)this);
    else
        return E_NOINTERFACE;

    AddRef();
    return S_OK;
} //QueryInterface

//+---------------------------------------------------------------------------
//
//  Member:     CCiCDocName::AddRef
//
//  History:    11-22-96   srikants   Created
//
//----------------------------------------------------------------------------

STDMETHODIMP_(ULONG) CCiAdminParams::AddRef()
{
    return InterlockedIncrement(&_refCount);
} //AddRef

//+---------------------------------------------------------------------------
//
//  Member:     CCiCDocName::Release
//
//  History:    11-22-96   srikants   Created
//
//----------------------------------------------------------------------------

STDMETHODIMP_(ULONG) CCiAdminParams::Release()
{
    Win4Assert( _refCount > 0 );

    LONG refCount = InterlockedDecrement(&_refCount);

    if (  refCount <= 0 )
        delete this;

    return (ULONG) refCount;
}  //Release

//+---------------------------------------------------------------------------
//
//  Member:     CCiAdminParams::GetValue
//
//  Synopsis:   Gets the parameter value, if it is a DWORD type.
//
//  Arguments:  [param]    - [in]  Parameter to retrive
//              [pdwValue] - [out] The value of the parameter.
//
//  Returns:    S_OK if successful
//              E_INVALIDARG if wrong parameters.
//
//  History:    11-27-96   srikants   Created
//
//----------------------------------------------------------------------------


STDMETHODIMP CCiAdminParams::GetValue(
    CI_ADMIN_PARAMS param,
    DWORD * pdwValue )
{
    Win4Assert( 0 != pdwValue );

    if ( param < CI_AP_MAX_DWORD_VAL )
    {
        *pdwValue = (DWORD) _adwParams[ param ];
        return S_OK;
    }
    else
    {
        return E_INVALIDARG;
    }
}

//+---------------------------------------------------------------------------
//
//  Member:     CCiAdminParams::GetValue
//
//  Synopsis:   Gets the parameter value, if it is a DWORD type.
//
//  Arguments:  [param]    - [in]  Parameter to retrive
//              [pdwValue] - [out] The value of the parameter.
//
//  Returns:    S_OK if successful
//              E_INVALIDARG if wrong parameters.
//
//  History:    10-Jun-97   KyleP      Added header, MaxFileSize in KB.
//
//----------------------------------------------------------------------------

STDMETHODIMP CCiAdminParams::GetInt64Value( CI_ADMIN_PARAMS param, __int64 * pValue )
{
    Win4Assert( 0 != pValue );

    if ( !IsValidParam(param) )
        return E_INVALIDARG;

    if ( param < CI_AP_MAX_DWORD_VAL )
    {
        *pValue = _adwParams[param];
    }
    else
    {
        //
        // Currently, there are no non-dword values.
        //

        Win4Assert( param < CI_AP_MAX_DWORD_VAL );
    }

    return S_OK;
}

//+---------------------------------------------------------------------------
//
//  Member:     CCiAdminParams::SetValues
//
//  Synopsis:   calls CCiAdminParams::SetValue() for each of the property
//              variant values.
//
//  Arguments:  [ULONG nParams]         - [in] number of elements in the array.
//              [PROPVARIANT *]         - [in] array of property variants of
//                                        size CI_AP_MAX_VAL containing
//                                        new CI settings.
//              [CI_ADMIN_PARAMS *]     - [in] array of CI_ADMIN_PARAMS values
//                                        used as indices in teh prop variant array.
//
//  Returns:    S_OK if successful
//              E_INVALIDARG if wrong parameters (returned from SetParamValue()).
//
//  History:    1-24-97   mohamedn   Created
//
//----------------------------------------------------------------------------

STDMETHODIMP CCiAdminParams::SetValues(ULONG nParams,
                                       const PROPVARIANT     *  aParamVals,
                                       const CI_ADMIN_PARAMS *  aParamNames)
{
    SCODE sc = S_OK;

    for ( ULONG i = 0; i < nParams; i++)
    {
        switch ( aParamNames[i] )
        {
           case CI_AP_MAX_DWORD_VAL:
           case CI_AP_MAX_VAL:
               continue;    //  values are place holders.

           default:
               Win4Assert( aParamNames[i] < CI_AP_MAX_VAL );

               sc = SetParamValue( aParamNames[i], aParamVals+i );

               if (sc != S_OK)
                   return sc;
        }
    }
    return sc;
}

//+---------------------------------------------------------------------------
//
//  Member:     CCiAdminParams::SetValue
//
//  Synopsis:   Sets the value of the given parameter, if it is a DWORD type.
//
//  Arguments:  [param]   - [in] Parameter
//              [dwValue] - [in] Value to set
//
//  Returns:    S_OK if successful
//              E_INVALIDARG if wrong parameters.
//
//  History:    11-27-96   srikants   Created
//
//----------------------------------------------------------------------------


STDMETHODIMP CCiAdminParams::SetValue(
    CI_ADMIN_PARAMS param,
    DWORD dwValue )
{

    SCODE sc = S_OK;

    // =================================================================
    CLock   lock(_mutex);

    if ( param < CI_AP_MAX_DWORD_VAL )
        _adwParams[param] = _GetValueInRange( param, dwValue );
    else
        sc = E_INVALIDARG;

    // =================================================================

    return sc;
}
//+---------------------------------------------------------------------------
//
//  Member:     CCiAdminParams::SetParamValue
//
//  Synopsis:   Sets the value of a parameter, given a DWORD
//
//  Arguments:  [param]     - [in] Parameter
//              [pvarValue] - [in] Value
//
//  Returns:    S_OK if successful
//              E_INVALIDARG if bad parameter.
//
//  History:    11-27-96   srikants   Created
//
//-----------------------------------------------------------------------


STDMETHODIMP CCiAdminParams::SetParamValue(
    CI_ADMIN_PARAMS param,
    PROPVARIANT const * pvarValue )
{
    Win4Assert( 0 != pvarValue );

    SCODE sc = S_OK;

    // =================================================================

    CLock lock( _mutex );

    CStorageVariant const * pVar = ConvertToStgVariant( pvarValue );

    if ( param < CI_AP_MAX_DWORD_VAL )
    {
        Win4Assert( VT_I4  == pvarValue->vt ||
                    VT_UI4 == pvarValue->vt );

        long lVal = *pVar;
        _adwParams[param] = (DWORD) *pVar;
    }
    else
    {
        //
        // Currently no non-dword values.
        //

        Win4Assert( param < CI_AP_MAX_DWORD_VAL );

        sc = E_INVALIDARG;
    }

    // =================================================================

    return sc;
}
//+---------------------------------------------------------------------------
//
//  Member:     CCiAdminParams::GetParamValue
//
//  Synopsis:   Retrieves the value of a parameter as a variant.
//
//  Arguments:  [param]     -  [in]  Parameter
//              [ppvarValue] - [out] Value on return
//
//  Returns:    S_OK if successful;
//              E_INVALIDARG if bad parameters.
//              E_OUTOFMEMORY if no memory.
//
//  History:    11-27-96   srikants   Created
//
//----------------------------------------------------------------------------


STDMETHODIMP CCiAdminParams::GetParamValue(
    CI_ADMIN_PARAMS param,
    PROPVARIANT ** ppvarValue )
{
    Win4Assert( 0 != ppvarValue );

    if ( !IsValidParam(param) )
        return E_INVALIDARG;

    if ( param < CI_AP_MAX_DWORD_VAL )
    {
        CStorageVariant * pVar = new CStorageVariant( (long) _adwParams[param] );
        *ppvarValue = ConvertToPropVariant( pVar );
    }
    else
    {
        //
        // Currently no non-dword parameters.
        //

        Win4Assert( param < CI_AP_MAX_DWORD_VAL );
    }

    if ( *ppvarValue )
        return S_OK;
    else
        return E_OUTOFMEMORY;
}

//+---------------------------------------------------------------------------
//
//  Member:     CCiAdminParams::IsSame
//
//  Synopsis:   Tests if the value for the parameter specified is same as
//              the one given.
//
//  Arguments:  [param]     - [in]  Parameter
//              [pvarValue] - [in]  Value given by the caller
//              [pfSame]    - [out] TRUE if the value contained is same as
//                            the one passed; FALSE o/w
//
//  Returns:    S_OK if successful
//              E_INVALIDARG if bad parameter.
//
//  History:    11-27-96   srikants   Created
//
//----------------------------------------------------------------------------


STDMETHODIMP CCiAdminParams::IsSame(
    CI_ADMIN_PARAMS param,
    const PROPVARIANT * pvarValue,
    BOOL * pfSame )
{
    Win4Assert( pvarValue );
    Win4Assert( pfSame );

    CStorageVariant const * pVar = ConvertToStgVariant( pvarValue );

    if ( param < CI_AP_MAX_DWORD_VAL )
    {
        DWORD dwVal = *pVar;
        *pfSame = ( dwVal == _adwParams[param] );
    }
    else
    {
        //
        // Currently no non-dword parameters.
        //

        Win4Assert( param < CI_AP_MAX_DWORD_VAL );

        return E_INVALIDARG;
    }

    return S_OK;

}

STDMETHODIMP CCiAdminParams::InvalidateLangResources()
{
    if ( 0 != _pLangList )
        _pLangList->InvalidateLangResources();

    return S_OK;
}

//+---------------------------------------------------------------------------
//
//  Member:     CCiAdminParams::CCiAdminParams
//
//  Synopsis:   Constructor of the CI admin parameters. Sets the values to
//              default values.
//
//  History:    12-02-96   srikants   Created
//
//----------------------------------------------------------------------------

CCiAdminParams::CCiAdminParams( CLangList * pLangList )
    : _refCount( 1 ),
      _pLangList( pLangList )
{
    RtlZeroMemory( &_adwParams, sizeof(_adwParams) );

    //
    // Initialize the default values of all parameters.
    //
    for ( unsigned i = 0; i < CI_AP_MAX_DWORD_VAL; i++ )
    {
        _adwParams[i] = _adwRangeParams[i]._dwDefault;
    }

    //
    // Add assertions to verify that the default values are correct.
    //

#if 0
    Win4Assert( _adwRangeParams[CI_AP_XXXX]._dwDefault ==
                CI_XXXX_DEFAULT );

  { CI_XXXX_DEFAULT, CI_XXXX_DEFAULT,
    CI_XXXX_DEFAULT },

#endif  // 0


    Win4Assert( _adwRangeParams[CI_AP_MERGE_INTERVAL]._dwDefault ==
                CI_MAX_MERGE_INTERVAL_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_MAX_UPDATES]._dwDefault ==
                CI_MAX_UPDATES_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_MAX_WORDLISTS]._dwDefault ==
                CI_MAX_WORDLISTS_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_MIN_SIZE_MERGE_WORDLISTS]._dwDefault ==
                CI_MIN_SIZE_MERGE_WORDLISTS_DEFAULT );

    Win4Assert( _adwRangeParams[CI_AP_MAX_WORDLIST_SIZE]._dwDefault ==
                CI_MAX_WORDLIST_SIZE_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_MIN_WORDLIST_MEMORY]._dwDefault ==
                CI_MIN_WORDLIST_MEMORY_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_LOW_RESOURCE_SLEEP]._dwDefault ==
                CI_LOW_RESOURCE_SLEEP_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_MAX_WORDLIST_MEMORY_LOAD]._dwDefault ==
                CI_MAX_WORDLIST_MEMORY_LOAD_DEFAULT );

    Win4Assert( _adwRangeParams[CI_AP_MAX_FRESH_COUNT]._dwDefault ==
                CI_MAX_FRESHCOUNT_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_MAX_SHADOW_INDEX_SIZE]._dwDefault ==
                CI_MAX_SHADOW_INDEX_SIZE_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_MIN_DISK_FREE_FORCE_MERGE]._dwDefault ==
                CI_MIN_DISKFREE_FORCE_MERGE_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_MAX_SHADOW_FREE_FORCE_MERGE]._dwDefault ==
                CI_MAX_SHADOW_FREE_FORCE_MERGE_DEFAULT );

    Win4Assert( _adwRangeParams[CI_AP_MAX_INDEXES]._dwDefault ==
                CI_MAX_INDEXES_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_MAX_IDEAL_INDEXES]._dwDefault ==
                CI_MAX_IDEAL_INDEXES_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_MIN_MERGE_IDLE_TIME]._dwDefault ==
                CI_MIN_MERGE_IDLE_TIME_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_MAX_PENDING_DOCUMENTS]._dwDefault ==
                CI_MAX_PENDING_DOCUMENTS_DEFAULT );

    Win4Assert( _adwRangeParams[CI_AP_MASTER_MERGE_TIME]._dwDefault ==
                CI_MASTER_MERGE_TIME_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_MAX_QUEUE_CHUNKS]._dwDefault ==
                CI_MAX_QUEUE_CHUNKS_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_MASTER_MERGE_CHECKPOINT_INTERVAL]._dwDefault ==
                CI_MASTER_MERGE_CHECKPOINT_INTERVAL_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_FILTER_BUFFER_SIZE]._dwDefault ==
                CI_FILTER_BUFFER_SIZE_DEFAULT );

    Win4Assert( _adwRangeParams[CI_AP_FILTER_RETRIES]._dwDefault ==
                CI_FILTER_RETRIES_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_FILTER_RETRY_INTERVAL]._dwDefault ==
                CI_FILTER_RETRY_INTERVAL_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_MIN_IDLE_QUERY_THREADS]._dwDefault ==
                CI_MIN_IDLE_QUERY_THREADS_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_MAX_ACTIVE_QUERY_THREADS]._dwDefault ==
                CI_MAX_ACTIVE_QUERY_THREADS_DEFAULT );

    Win4Assert( _adwRangeParams[CI_AP_MAX_QUERY_TIMESLICE]._dwDefault ==
                CI_MAX_QUERY_TIMESLICE_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_MAX_QUERY_EXECUTION_TIME]._dwDefault ==
                CI_MAX_QUERY_EXECUTION_TIME_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_MAX_RESTRICTION_NODES]._dwDefault ==
                CI_MAX_RESTRICTION_NODES_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_CLUSTERINGTIME]._dwDefault ==
                CI_CLUSTERINGTIME_DEFAULT );

    Win4Assert( _adwRangeParams[CI_AP_MAX_FILESIZE_MULTIPLIER]._dwDefault ==
                CI_MAX_FILESIZE_MULTIPLIER_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_DAEMON_RESPONSE_TIMEOUT]._dwDefault ==
                CI_DAEMON_RESPONSE_TIMEOUT_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_FILTER_DELAY_INTERVAL]._dwDefault ==
                CI_FILTER_DELAY_INTERVAL_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_FILTER_REMAINING_THRESHOLD]._dwDefault ==
                CI_FILTER_REMAINING_THRESHOLD_DEFAULT );

    Win4Assert( _adwRangeParams[CI_AP_MAX_CHARACTERIZATION]._dwDefault ==
                CI_MAX_CHARACTERIZATION_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_MAX_FILESIZE_FILTERED]._dwDefault ==
                CI_MAX_FILESIZE_FILTERED_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_MAX_WORDLIST_IO]._dwDefault ==
                CI_MAX_WORDLIST_IO_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_WORDLIST_RESOURCE_CHECK_INTERVAL]._dwDefault ==
                CI_WORDLIST_RESOURCE_CHECK_INTERVAL_DEFAULT );

    Win4Assert( _adwRangeParams[CI_AP_STARTUP_DELAY]._dwDefault ==
                CI_STARTUP_DELAY_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_GENERATE_CHARACTERIZATION]._dwDefault ==
                CI_GENERATE_CHARACTERIZATION_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_SECQ_FILTER_RETRIES]._dwDefault ==
                CI_SECQ_FILTER_RETRIES_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_MIN_WORDLIST_BATTERY]._dwDefault ==
                CI_MIN_WORDLIST_BATTERY_DEFAULT );

    Win4Assert( _adwRangeParams[CI_AP_THREAD_PRIORITY_MERGE]._dwDefault ==
                CI_THREAD_PRIORITY_MERGE_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_THREAD_PRIORITY_FILTER]._dwDefault ==
                CI_THREAD_PRIORITY_FILTER_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_THREAD_CLASS_FILTER]._dwDefault ==
                CI_THREAD_CLASS_FILTER_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_EVTLOG_FLAGS]._dwDefault ==
                CI_EVTLOG_FLAGS_DEFAULT );

    Win4Assert( _adwRangeParams[CI_AP_MISC_FLAGS]._dwDefault ==
                CI_MISC_FLAGS_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_GENERATE_RELEVANT_WORDS]._dwDefault ==
                CI_GENERATE_RELEVANT_WORDS_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_FFILTER_FILES_WITH_UNKNOWN_EXTENSIONS]._dwDefault ==
                CI_FFILTER_FILES_WITH_UNKNOWN_EXTENSIONS_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_FILTER_DIRECTORIES]._dwDefault ==
                CI_FILTER_DIRECTORIES_DEFAULT );

    Win4Assert( _adwRangeParams[CI_AP_FILTER_CONTENTS]._dwDefault ==
                CI_FILTER_CONTENTS_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_MAX_DAEMON_VM_USE]._dwDefault ==
                CI_MAX_DAEMON_VM_USE_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_WORDLIST_USER_IDLE]._dwDefault ==
                CI_WORDLIST_USER_IDLE_DEFAULT );
    Win4Assert( _adwRangeParams[CI_AP_IS_ENUM_ALLOWED]._dwDefault ==
                CI_IS_ENUM_ALLOWED_DEFAULT );

    Win4Assert( _adwRangeParams[CI_AP_MIN_DISK_SPACE_TO_LEAVE]._dwDefault ==
                CI_MIN_DISK_SPACE_TO_LEAVE_DEFAULT );
}

// ---------------------------------------------------------------------------
// Array of the min, max, default values for the DWORD parameters.
// Organize the array as sets of 4 for readability.
// ---------------------------------------------------------------------------

const CI_ADMIN_PARAMS_RANGE CCiAdminParams::_adwRangeParams[CI_AP_MAX_DWORD_VAL] =
{

  { CI_MAX_MERGE_INTERVAL_MIN, CI_MAX_MERGE_INTERVAL_MAX,
    CI_MAX_MERGE_INTERVAL_DEFAULT },
  { CI_MAX_UPDATES_MIN, CI_MAX_UPDATES_MAX,
    CI_MAX_UPDATES_DEFAULT },
  { CI_MAX_WORDLISTS_MIN, CI_MAX_WORDLISTS_MAX,
    CI_MAX_WORDLISTS_DEFAULT },
  { CI_MIN_SIZE_MERGE_WORDLISTS_MIN, CI_MIN_SIZE_MERGE_WORDLISTS_MAX,
    CI_MIN_SIZE_MERGE_WORDLISTS_DEFAULT },

  { CI_MAX_WORDLIST_SIZE_MIN, CI_MAX_WORDLIST_SIZE_MAX,
    CI_MAX_WORDLIST_SIZE_DEFAULT },
  { CI_MIN_WORDLIST_MEMORY_MIN, CI_MIN_WORDLIST_MEMORY_MAX,
    CI_MIN_WORDLIST_MEMORY_DEFAULT },
  { CI_LOW_RESOURCE_SLEEP_MIN, CI_LOW_RESOURCE_SLEEP_MAX,
    CI_LOW_RESOURCE_SLEEP_DEFAULT },
  { CI_MAX_WORDLIST_MEMORY_LOAD_MIN, CI_MAX_WORDLIST_MEMORY_LOAD_MAX,
    CI_MAX_WORDLIST_MEMORY_LOAD_DEFAULT },

  { CI_MAX_FRESHCOUNT_MIN, CI_MAX_FRESHCOUNT_MAX,
    CI_MAX_FRESHCOUNT_DEFAULT },
  { CI_MAX_SHADOW_INDEX_SIZE_MIN, CI_MAX_SHADOW_INDEX_SIZE_MAX,
    CI_MAX_SHADOW_INDEX_SIZE_DEFAULT },
  { CI_MIN_DISKFREE_FORCE_MERGE_MIN, CI_MIN_DISKFREE_FORCE_MERGE_MAX,
    CI_MIN_DISKFREE_FORCE_MERGE_DEFAULT },
  { CI_MAX_SHADOW_FREE_FORCE_MERGE_MIN, CI_MAX_SHADOW_FREE_FORCE_MERGE_MAX,
    CI_MAX_SHADOW_FREE_FORCE_MERGE_DEFAULT },

  { CI_MAX_INDEXES_MIN, CI_MAX_INDEXES_MAX,
    CI_MAX_INDEXES_DEFAULT },
  { CI_MAX_IDEAL_INDEXES_MIN, CI_MAX_IDEAL_INDEXES_MAX,
    CI_MAX_IDEAL_INDEXES_DEFAULT },
  { CI_MIN_MERGE_IDLE_TIME_MIN, CI_MIN_MERGE_IDLE_TIME_MAX,
    CI_MIN_MERGE_IDLE_TIME_DEFAULT },
  { CI_MAX_PENDING_DOCUMENTS_MIN, CI_MAX_PENDING_DOCUMENTS_MAX,
    CI_MAX_PENDING_DOCUMENTS_DEFAULT },

  { CI_MASTER_MERGE_TIME_MIN, CI_MASTER_MERGE_TIME_MAX,
    CI_MASTER_MERGE_TIME_DEFAULT },
  { CI_MAX_QUEUE_CHUNKS_MIN, CI_MAX_QUEUE_CHUNKS_MAX,
    CI_MAX_QUEUE_CHUNKS_DEFAULT },
  { CI_MASTER_MERGE_CHECKPOINT_INTERVAL_MIN,
    CI_MASTER_MERGE_CHECKPOINT_INTERVAL_MAX,
    CI_MASTER_MERGE_CHECKPOINT_INTERVAL_DEFAULT },
  { CI_FILTER_BUFFER_SIZE_MIN, CI_FILTER_BUFFER_SIZE_MAX,
    CI_FILTER_BUFFER_SIZE_DEFAULT },


  { CI_FILTER_RETRIES_MIN, CI_FILTER_RETRIES_MAX,
    CI_FILTER_RETRIES_DEFAULT },
  { CI_FILTER_RETRY_INTERVAL_MIN, CI_FILTER_RETRY_INTERVAL_MAX,
    CI_FILTER_RETRY_INTERVAL_DEFAULT },
  { CI_MIN_IDLE_QUERY_THREADS_MIN, CI_MIN_IDLE_QUERY_THREADS_MAX,
    CI_MIN_IDLE_QUERY_THREADS_DEFAULT },
  { CI_MAX_ACTIVE_QUERY_THREADS_MIN, CI_MAX_ACTIVE_QUERY_THREADS_MAX,
    CI_MAX_ACTIVE_QUERY_THREADS_DEFAULT },


  { CI_MAX_QUERY_TIMESLICE_MIN, CI_MAX_QUERY_TIMESLICE_MAX,
    CI_MAX_QUERY_TIMESLICE_DEFAULT },
  { CI_MAX_QUERY_EXECUTION_TIME_MIN, CI_MAX_QUERY_EXECUTION_TIME_MAX,
    CI_MAX_QUERY_EXECUTION_TIME_DEFAULT },
  { CI_MAX_RESTRICTION_NODES_MIN, CI_MAX_RESTRICTION_NODES_MAX,
    CI_MAX_RESTRICTION_NODES_DEFAULT },
  { CI_CLUSTERINGTIME_MIN, CI_CLUSTERINGTIME_MAX,
    CI_CLUSTERINGTIME_DEFAULT },

  { CI_MAX_FILESIZE_MULTIPLIER_MIN, CI_MAX_FILESIZE_MULTIPLIER_MAX,
    CI_MAX_FILESIZE_MULTIPLIER_DEFAULT },
  { CI_DAEMON_RESPONSE_TIMEOUT_MIN, CI_DAEMON_RESPONSE_TIMEOUT_MAX,
    CI_DAEMON_RESPONSE_TIMEOUT_DEFAULT },
  { CI_FILTER_DELAY_INTERVAL_MIN, CI_FILTER_DELAY_INTERVAL_MAX,
    CI_FILTER_DELAY_INTERVAL_DEFAULT },
  { CI_FILTER_REMAINING_THRESHOLD_MIN, CI_FILTER_REMAINING_THRESHOLD_MAX,
    CI_FILTER_REMAINING_THRESHOLD_DEFAULT },

  { CI_MAX_CHARACTERIZATION_MIN, CI_MAX_CHARACTERIZATION_MAX,
    CI_MAX_CHARACTERIZATION_DEFAULT },
  { CI_MAX_FRESH_DELETES_MIN, CI_MAX_FRESH_DELETES_MAX,
    CI_MAX_FRESH_DELETES_DEFAULT },
  { CI_MAX_WORDLIST_IO_MIN, CI_MAX_WORDLIST_IO_MAX,
    CI_MAX_WORDLIST_IO_DEFAULT },
  { CI_WORDLIST_RESOURCE_CHECK_INTERVAL_MIN, CI_WORDLIST_RESOURCE_CHECK_INTERVAL_MAX,
    CI_WORDLIST_RESOURCE_CHECK_INTERVAL_DEFAULT },

  { CI_STARTUP_DELAY_MIN, CI_STARTUP_DELAY_MAX,
    CI_STARTUP_DELAY_DEFAULT },
  { CI_GENERATE_CHARACTERIZATION_MIN, CI_GENERATE_CHARACTERIZATION_MAX,
    CI_GENERATE_CHARACTERIZATION_DEFAULT },
  { CI_MIN_WORDLIST_BATTERY_MIN, CI_MIN_WORDLIST_BATTERY_MAX,
    CI_MIN_WORDLIST_BATTERY_DEFAULT },
  { 0,0xFFFFFFFF,
    (DWORD) CI_THREAD_PRIORITY_MERGE_DEFAULT },

  { 0, 0,
    (DWORD) CI_THREAD_PRIORITY_FILTER_DEFAULT },
  { 0,0xFFFFFFFF,
    CI_THREAD_CLASS_FILTER_DEFAULT },
  { 0,0xFFFFFFFF,
    CI_EVTLOG_FLAGS_DEFAULT },
  { 0,0xFFFFFFFF,
    CI_MISC_FLAGS_DEFAULT },

  { 0,0xFFFFFFFF,
    CI_GENERATE_RELEVANT_WORDS_DEFAULT },
  { 0,0xFFFFFFFF,
    CI_FFILTER_FILES_WITH_UNKNOWN_EXTENSIONS_DEFAULT },
  { 0,0xFFFFFFFF,
    CI_FILTER_DIRECTORIES_DEFAULT },
  { 0,0xFFFFFFFF,
    CI_FILTER_CONTENTS_DEFAULT },

  { 0, 0xFFFFFFFF,
    CI_MAX_FILESIZE_FILTERED_DEFAULT },
  { 0, 0xFFFFFFFF,
    CI_MIN_CLIENT_IDLE_TIME },
  { CI_MAX_DAEMON_VM_USE_MIN, CI_MAX_DAEMON_VM_USE_MAX,
    CI_MAX_DAEMON_VM_USE_DEFAULT },
  { CI_SECQ_FILTER_RETRIES_MIN, CI_SECQ_FILTER_RETRIES_MAX,
    CI_SECQ_FILTER_RETRIES_DEFAULT },

  { CI_WORDLIST_USER_IDLE_MIN, CI_WORDLIST_USER_IDLE_MAX,
    CI_WORDLIST_USER_IDLE_DEFAULT },
  { 0, 0xFFFFFFFF,
    CI_IS_ENUM_ALLOWED_DEFAULT },
  { CI_MIN_DISK_SPACE_TO_LEAVE_MIN, CI_MIN_DISK_SPACE_TO_LEAVE_MAX,
    CI_MIN_DISK_SPACE_TO_LEAVE_DEFAULT },

// End of DWORD values
};

// global c++ objects are evil, sick, and wrong.

CWorkQueue TheWorkQueue( 2, CWorkQueue::workQueueQuery );
CLocateDocStore g_DocStoreLocator;
CLocateDocStore g_svcDocStoreLocator;

void InitializeDocStore(void)
{
    TheWorkQueue.Init();
    g_DocStoreLocator.Init();
    g_svcDocStoreLocator.Init();
}


//+---------------------------------------------------------------------------
//
//  Member:     CLocateDocStore::Get
//
//  Synopsis:   Gets the docstore locator with the given clsid.
//
//  History:    1-17-97   srikants   Created
//
//----------------------------------------------------------------------------

ICiCDocStoreLocator * CLocateDocStore::Get( GUID const & guidDocStoreLocator )
{
    if ( !_fShutdown )
    {
        CLock lock( _mutex );

        if ( 0 == _pDocStoreLocator )
        {
            SCODE sc = CoCreateInstance( guidDocStoreLocator,
                                         NULL,
                                         CLSCTX_INPROC_SERVER,
                                         IID_ICiCDocStoreLocator,
                                         (void **) &_pDocStoreLocator );

            if ( FAILED(sc) )
            {
                ciDebugOut(( DEB_ERROR,
                             "Failed to create ICiCDocStoreLocator (0x%X) \n",
                             sc ));
                THROW( CException( sc ) );
            }
        }

        _pDocStoreLocator->AddRef();
    }

    return _pDocStoreLocator;
}

//+---------------------------------------------------------------------------
//
//  Member:     CLocateDocStore::Shutdown
//
//  Synopsis:   Shutsdown the Content Index Framework side of the things.
//              This shuts down the whole Content Index. If there are
//              multiple instances of CI in the same process, this affects
//              all the instances.
//
//  History:    3-20-97   srikants   Created
//
//----------------------------------------------------------------------------

void CLocateDocStore::Shutdown()
{
    CLock lock( _mutex );

    if ( _pDocStoreLocator )
    {
       //
       // Shutdown on the docstore locator  must be called only once.
       //
        if ( !_fShutdown )
            _pDocStoreLocator->Shutdown();

        _pDocStoreLocator->Release();
        _pDocStoreLocator = 0;
    }

    _fShutdown = TRUE;
}