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.
1076 lines
34 KiB
1076 lines
34 KiB
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 2000.
|
|
//
|
|
// File: CatArray.cxx
|
|
//
|
|
// Contents: Catalog array, for user mode content index
|
|
//
|
|
// History: 22-Dec-92 KyleP Split from vquery.cxx
|
|
// 11-Oct-96 dlee added catalog name support
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include <pch.cxx>
|
|
#pragma hdrstop
|
|
|
|
#include <catarray.hxx>
|
|
#include <ciregkey.hxx>
|
|
#include <regacc.hxx>
|
|
|
|
#include <docstore.hxx>
|
|
#include <imprsnat.hxx>
|
|
#include <eventlog.hxx>
|
|
#include <cievtmsg.h>
|
|
|
|
#include "cicat.hxx"
|
|
|
|
#include <dbgproxy.hxx>
|
|
#include <query.hxx>
|
|
#include <srequest.hxx>
|
|
#include <removcat.hxx>
|
|
|
|
CCatArray Catalogs;
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: COldCatState::COldCatState, public
|
|
//
|
|
// Synopsis: Constructor
|
|
//
|
|
// Arguments: [dwOldState] -- old state of the catalog
|
|
// [wcsCatName] -- name of the catalog
|
|
// [wcVol] -- volume letter
|
|
//
|
|
// History: 15-Jul-98 KitmanH Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
COldCatState::COldCatState( DWORD dwOldState, WCHAR const * wcsCatName, WCHAR wcVol )
|
|
: _dwOldState(dwOldState),
|
|
_cStopCount(1)
|
|
{
|
|
RtlZeroMemory( _aVol, sizeof _aVol );
|
|
|
|
if ( 0 != wcVol )
|
|
_aVol[toupper(wcVol) - L'A'] = 1;
|
|
|
|
_xCatName.Init( wcslen( wcsCatName ) + 1 );
|
|
RtlCopyMemory( _xCatName.Get(), wcsCatName, _xCatName.SizeOf() );
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatArray::CCatArray, public
|
|
//
|
|
// Synopsis: Constructor for array to handle switching drives for catalogs
|
|
//
|
|
// History: 07-May-92 AmyA Lifted from vquery.cxx
|
|
// 02-Jun-92 KyleP Added UNC support.
|
|
// 12-Jun-92 KyleP Lifted from citest.cxx
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CCatArray::CCatArray()
|
|
: _aDocStores(0),
|
|
_pDrvNotifArray(0),
|
|
_fInit(FALSE),
|
|
_mutex(FALSE)
|
|
{
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatArray::Init, public
|
|
//
|
|
// Synopsis: Initializer for catalogs array
|
|
//
|
|
// History: 20 May 99 AlanW Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CCatArray::Init()
|
|
{
|
|
_mutex.Init();
|
|
_fInit = TRUE;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatArray::~CCatArray, public
|
|
//
|
|
// Synopsis: Destructor for array to handle switching drives for catalogs
|
|
//
|
|
// History: 07-May-92 AmyA Lifted from vquery.cxx
|
|
// 02-Jun-92 KyleP Added UNC support.
|
|
// 12-Jun-92 KyleP Lifted from citest.cxx
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
extern HANDLE gmem_hHeap;
|
|
|
|
CCatArray::~CCatArray()
|
|
{
|
|
//
|
|
// If the global object was initialized (not just constructed) and the
|
|
// global heap is still around (we aren't after the process detach and
|
|
// unwinding global objects from _CRT_INIT on shutdown, clean up.
|
|
//
|
|
|
|
if ( _fInit && ( 0 != gmem_hHeap ) )
|
|
{
|
|
CLock lockx( _mutex );
|
|
_pDrvNotifArray = 0;
|
|
ClearStopArray();
|
|
Flush();
|
|
|
|
_fInit = FALSE;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Zero out the dynarrays so they aren't deleted since the heap
|
|
// is gone by now.
|
|
//
|
|
// Just acquire them and leak the memory on purpose because the
|
|
// process is going away anyway.
|
|
//
|
|
|
|
_aDocStores.AcquireAll();
|
|
_aStoppedCatalogs.Acquire();
|
|
}
|
|
} //~CCatArray
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatArray::Flush, public
|
|
//
|
|
// Synopsis: Close all open catalogs
|
|
//
|
|
// History: 03-Sep-93 KyleP Created
|
|
//
|
|
// Notes: This is a dangerous operation. It should only be called
|
|
// when no-one is accessing any indexes.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
void CCatArray::Flush()
|
|
{
|
|
if (! _fInit)
|
|
return;
|
|
|
|
CLock lock( _mutex );
|
|
|
|
TRY
|
|
{
|
|
// Close all the open docstores
|
|
|
|
for ( unsigned i = 0; i < _aDocStores.Count(); i++ )
|
|
{
|
|
Win4Assert( 0 != _aDocStores[i] );
|
|
_aDocStores[i]->Shutdown();
|
|
}
|
|
|
|
// Delete registry entries for auto-mounted catalogs
|
|
|
|
if ( 0 != _pDrvNotifArray )
|
|
{
|
|
BOOL aDrives[ RTL_MAX_DRIVE_LETTERS ];
|
|
RtlZeroMemory( aDrives, sizeof aDrives );
|
|
|
|
_pDrvNotifArray->GetAutoMountDrives( aDrives );
|
|
|
|
for ( WCHAR x = 0; x < RTL_MAX_DRIVE_LETTERS; x++ )
|
|
{
|
|
if ( aDrives[x] )
|
|
{
|
|
CRemovableCatalog cat( L'A' + x );
|
|
cat.Destroy();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
Win4Assert( !"unexpected exception when shutting down a docstore" );
|
|
}
|
|
END_CATCH
|
|
|
|
_aDocStores.Free();
|
|
} //Flush
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatArray::FlushOne, public
|
|
//
|
|
// Synopsis: Close one catalog
|
|
//
|
|
// Arguments: [pDocStore] -- Pointer to the docstore to be flushed
|
|
//
|
|
// History: 27-Apr-98 KitmanH Created
|
|
//
|
|
// Notes: This is a dangerous operation. It should only be called
|
|
// when no-one is accessing any indexes. If this wasn't
|
|
// downlevel scaffolding we'd have to perform some serious
|
|
// serialization and refcounting here.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
void CCatArray::FlushOne( ICiCDocStore * pDocStore )
|
|
{
|
|
CLock lock( _mutex );
|
|
|
|
for ( unsigned i = 0; i < _aDocStores.Count(); i++ )
|
|
{
|
|
Win4Assert( 0 != _aDocStores[i] );
|
|
|
|
if ( _aDocStores[i] == pDocStore)
|
|
{
|
|
_aDocStores[i]->Shutdown();
|
|
|
|
CClientDocStore * p = _aDocStores.AcquireAndShrink(i);
|
|
p->Release();
|
|
return;
|
|
}
|
|
}
|
|
} //FlushOne
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatArray::GetDocStore, public
|
|
//
|
|
// Synopsis: Returns a PCatalog by either using an existing catalog or
|
|
// creating a new one. Returns 0 if a catalog couldn't be
|
|
// found or created.
|
|
//
|
|
// Arguments: [pwcPathOrName] -- Root of the catalog or friendly name
|
|
//
|
|
// History: 07-May-92 AmyA Lifted from vquery.cxx
|
|
// 22-May-92 AmyA Added TRY/CATCH
|
|
// 02-Jun-92 KyleP Added UNC support.
|
|
// 12-Jun-92 KyleP Lifted from citest.cxx
|
|
// 29-Sep-94 KyleP Added ofs proxy support
|
|
// 1-16-97 srikants Changed to return DocStore.
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CClientDocStore * CCatArray::GetDocStore(
|
|
WCHAR const * pwcPathOrName,
|
|
BOOL fMustExist )
|
|
{
|
|
BOOL fPath = wcschr( pwcPathOrName, L':' ) ||
|
|
wcschr( pwcPathOrName, L'\\' );
|
|
return GetNamedDocStore( pwcPathOrName, fPath ? 0 : pwcPathOrName,
|
|
FALSE, // read-only
|
|
fMustExist );
|
|
} //GetDocStore
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CatalogPathToName
|
|
//
|
|
// Synopsis: Enumerates catalogs looking for a named catalog whose
|
|
// location matches the given path.
|
|
//
|
|
// Arguments: [pwcPath] -- Path to look for
|
|
// [pwcName] -- Returns the catalog name
|
|
//
|
|
// Returns: S_OK if a match was found, S_FALSE otherwise.
|
|
//
|
|
// History: 22-Jun-98 dlee created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
SCODE CatalogPathToName(
|
|
WCHAR const * pwcPath,
|
|
WCHAR * pwcName )
|
|
{
|
|
BOOL fFound = FALSE;
|
|
|
|
HKEY hKey;
|
|
if ( ERROR_SUCCESS == RegOpenKeyEx( HKEY_LOCAL_MACHINE,
|
|
wcsRegCatalogsSubKey,
|
|
0,
|
|
KEY_QUERY_VALUE |
|
|
KEY_ENUMERATE_SUB_KEYS,
|
|
&hKey ) )
|
|
{
|
|
SRegKey xKey( hKey );
|
|
DWORD iSubKey = 0;
|
|
|
|
do
|
|
{
|
|
FILETIME ft;
|
|
WCHAR awcName[MAX_PATH];
|
|
DWORD cwcName = sizeof awcName / sizeof WCHAR;
|
|
LONG err = RegEnumKeyEx( hKey,
|
|
iSubKey,
|
|
awcName,
|
|
&cwcName,
|
|
0, 0, 0, &ft );
|
|
|
|
// either error or end of enumeration
|
|
|
|
if ( ERROR_SUCCESS != err )
|
|
break;
|
|
|
|
iSubKey++;
|
|
|
|
HKEY hCatName;
|
|
if ( ERROR_SUCCESS == RegOpenKeyEx( hKey,
|
|
awcName,
|
|
0,
|
|
KEY_QUERY_VALUE,
|
|
&hCatName ) )
|
|
{
|
|
SRegKey xCatNameKey( hCatName );
|
|
|
|
// Check if the catalog is inactive and can be ignored
|
|
|
|
WCHAR awcKey[MAX_PATH];
|
|
wcscpy( awcKey, wcsRegJustCatalogsSubKey );
|
|
wcscat( awcKey, L"\\" );
|
|
wcscat( awcKey, awcName );
|
|
|
|
CRegAccess reg( RTL_REGISTRY_CONTROL, awcKey );
|
|
BOOL fInactive = reg.Read( wcsCatalogInactive,
|
|
CI_CATALOG_INACTIVE_DEFAULT );
|
|
|
|
if ( !fInactive )
|
|
{
|
|
WCHAR awcPath[MAX_PATH];
|
|
DWORD cbPath = sizeof awcPath;
|
|
if ( ERROR_SUCCESS == RegQueryValueEx( hCatName,
|
|
wcsCatalogLocation,
|
|
0,
|
|
0,
|
|
(BYTE *)awcPath,
|
|
&cbPath ) )
|
|
{
|
|
int cwc = wcslen( awcPath ) - 1;
|
|
if ( ( cwc >= 0 ) && ( L'\\' == awcPath[ cwc ] ) )
|
|
awcPath[ cwc ] = 0;
|
|
|
|
if ( !_wcsicmp( awcPath, pwcPath ) )
|
|
{
|
|
fFound = TRUE;
|
|
wcscpy( pwcName, awcName );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} while ( TRUE );
|
|
}
|
|
|
|
return fFound ? S_OK : S_FALSE;
|
|
} //CatalogPathToName
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatArray::GetNamedDocStore, public
|
|
//
|
|
// Synopsis: Returns a PCatalog by either using an existing catalog or
|
|
// creating a new one. Returns 0 if a catalog couldn't be
|
|
// found or created.
|
|
//
|
|
// Arguments: [pwcPath] -- Root of the catalog
|
|
// [pwcName] -- 0 or name of the catalog (optional param)
|
|
// [fMustExist] -- If TRUE, the catalog must exist unless
|
|
// it is the null catalog. If FALSE, the
|
|
// catalog can be opened.
|
|
//
|
|
// History: 12-Oct-96 dlee created
|
|
// 1-16-97 srikants Changed to return DocStore.
|
|
// 16-Feb-2000 KLam Make sure path is good before using it
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
CClientDocStore * CCatArray::GetNamedDocStore(
|
|
WCHAR const * pwcPath,
|
|
WCHAR const * pwcName,
|
|
BOOL fOpenForReadOnly,
|
|
BOOL fMustExist )
|
|
{
|
|
WCHAR awcPath[ MAX_PATH ];
|
|
|
|
Win4Assert ( 0 != pwcPath );
|
|
|
|
unsigned len = wcslen( pwcPath );
|
|
RtlCopyMemory( awcPath, pwcPath, ( len + 1 ) * sizeof WCHAR );
|
|
|
|
// Get rid of trailing slash.
|
|
|
|
Win4Assert ( len > 0 && len < MAX_PATH );
|
|
if ( len > 0 && awcPath[ len - 1 ] == '\\' )
|
|
awcPath[ len - 1 ] = 0;
|
|
|
|
// make a complete path including \catalog.wci
|
|
|
|
WCHAR awcCompletePath[ MAX_PATH ];
|
|
wcscpy( awcCompletePath, awcPath );
|
|
wcscat( awcCompletePath, CAT_DIR );
|
|
|
|
BOOL fNullCatalog = !wcscmp( pwcPath, CINULLCATALOG );
|
|
|
|
CLock lock( _mutex );
|
|
|
|
// Look for previous use of catalog path or name.
|
|
|
|
for ( unsigned i = 0; i < _aDocStores.Count(); i++ )
|
|
{
|
|
Win4Assert( 0 != _aDocStores[i] );
|
|
|
|
const WCHAR *pwcCatName = _aDocStores[i]->GetName();
|
|
CiCat * pCat = _aDocStores[i]->GetCiCat();
|
|
const WCHAR *pwcCatPath = ( 0 == pCat ) ? 0 : pCat->GetCatDir();
|
|
|
|
ciDebugOut(( DEB_ITRACE, "pwcPath: '%ws'\n", pwcPath ));
|
|
ciDebugOut(( DEB_ITRACE, "pwcName: '%ws'\n", pwcName ));
|
|
ciDebugOut(( DEB_ITRACE, "pwcCatName: '%ws'\n", pwcCatName ));
|
|
ciDebugOut(( DEB_ITRACE, "pwcCatPath: '%ws'\n", pwcCatPath ));
|
|
ciDebugOut(( DEB_ITRACE, "awcPath: '%ws'\n", awcPath ));
|
|
ciDebugOut(( DEB_ITRACE, "awcCompletePath: '%ws'\n", awcCompletePath ));
|
|
|
|
if ( ( fNullCatalog && ( 0 == pwcCatName ) ) ||
|
|
( ( 0 != pwcCatPath ) &&
|
|
( 0 == _wcsicmp( awcCompletePath, pwcCatPath ) ) ) ||
|
|
( ( ( 0 != pwcCatName ) &&
|
|
( 0 != pwcName ) &&
|
|
( 0 == _wcsicmp( pwcName, pwcCatName ) ) ) ) )
|
|
return _aDocStores[i];
|
|
}
|
|
|
|
//
|
|
// We will let the special case of NullCatalog percolate through
|
|
// so we can create it only if the registry entry IsCatalogActive
|
|
// says we should activate it.
|
|
//
|
|
|
|
if ( fMustExist && !fNullCatalog)
|
|
return 0;
|
|
|
|
// Try to fault the catalog in by name or path
|
|
|
|
WCHAR awcName[ MAX_PATH ];
|
|
|
|
if ( !fMustExist )
|
|
{
|
|
// Can we fault-in a named catalog?
|
|
|
|
if ( L':' != awcPath[1] )
|
|
{
|
|
HKEY hCatName;
|
|
WCHAR awcCat[ MAX_PATH ];
|
|
wcscpy( awcCat, wcsRegCatalogsSubKey );
|
|
wcscat( awcCat, L"\\" );
|
|
wcscat( awcCat, pwcName );
|
|
|
|
ciDebugOut(( DEB_ITRACE, "attempting to fault-in %ws\n", awcCat ));
|
|
|
|
if ( ERROR_SUCCESS != RegOpenKeyEx( HKEY_LOCAL_MACHINE,
|
|
awcCat,
|
|
0,
|
|
KEY_QUERY_VALUE,
|
|
&hCatName ) )
|
|
return 0;
|
|
|
|
SRegKey xCatName( hCatName );
|
|
DWORD cbPath = sizeof awcPath;
|
|
if ( ERROR_SUCCESS != RegQueryValueEx( hCatName,
|
|
wcsCatalogLocation,
|
|
0,
|
|
0,
|
|
(BYTE *)awcPath,
|
|
&cbPath ) )
|
|
return 0;
|
|
|
|
// Trim trailing backslash
|
|
|
|
int cwc = wcslen( awcPath ) - 1;
|
|
if ( ( cwc >= 0 ) && ( L'\\' == awcPath[ cwc ] ) )
|
|
awcPath[ cwc ] = 0;
|
|
}
|
|
else if ( ( 0 == pwcName ) || ( L':' == pwcName[1] ) )
|
|
{
|
|
// no name, just a path in both fields -- inverse lookup
|
|
|
|
if ( S_FALSE == CatalogPathToName( awcPath, awcName ) )
|
|
return 0;
|
|
|
|
pwcName = awcName;
|
|
}
|
|
}
|
|
|
|
// Catalog name instead of a path? If so, fail the lookup since
|
|
// catalogs can only be really opened by path.
|
|
|
|
if ( L':' != awcPath[1] )
|
|
return 0;
|
|
|
|
TRY
|
|
{
|
|
BOOL fInactive = FALSE;
|
|
|
|
// We want the null catalog's registry entry to be looked up using
|
|
// friendly name.
|
|
|
|
WCHAR const *pwcCatName = fNullCatalog ? pwcPath : pwcName;
|
|
|
|
// Check if the catalog is marked as inactive. Don't do this
|
|
// in the constructor of CiCat -- it would be after a few
|
|
// threads are created and lots of activity has started.
|
|
|
|
if ( 0 != pwcCatName )
|
|
{
|
|
WCHAR awcKey[MAX_PATH];
|
|
wcscpy( awcKey, wcsRegJustCatalogsSubKey );
|
|
wcscat( awcKey, L"\\" );
|
|
wcscat( awcKey, pwcCatName );
|
|
|
|
CRegAccess reg( RTL_REGISTRY_CONTROL, awcKey );
|
|
fInactive = reg.Read( wcsCatalogInactive,
|
|
CI_CATALOG_INACTIVE_DEFAULT );
|
|
}
|
|
|
|
if ( !fInactive )
|
|
{
|
|
CImpersonateSystem impersonate;
|
|
|
|
// Have we reached the maximum # of docstores?
|
|
|
|
if ( _aDocStores.Count() >= GetMaxCatalogs() )
|
|
{
|
|
ciDebugOut(( DEB_WARN, "can't open %ws, out of catalogs!\n", pwcName ));
|
|
|
|
TRY
|
|
{
|
|
CEventLog eventLog( 0, wcsCiEventSource );
|
|
CEventItem item( EVENTLOG_WARNING_TYPE,
|
|
CI_SERVICE_CATEGORY,
|
|
MSG_CI_TOO_MANY_CATALOGS,
|
|
1 );
|
|
|
|
item.AddArg( awcPath );
|
|
eventLog.ReportEvent( item );
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
// if we can't log the event, ignore
|
|
}
|
|
END_CATCH
|
|
|
|
return 0; //Expensive, but who cares?
|
|
}
|
|
|
|
XPtr<CClientDocStore> xDocStore;
|
|
|
|
if (fNullCatalog)
|
|
xDocStore.Set( new CClientDocStore() );
|
|
else
|
|
xDocStore.Set( new CClientDocStore( awcPath,
|
|
fOpenForReadOnly,
|
|
*_pDrvNotifArray,
|
|
pwcName ) );
|
|
|
|
_aDocStores.Add( xDocStore.GetPointer(), _aDocStores.Count() );
|
|
xDocStore.Acquire();
|
|
}
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
// ignore catalogs that can't be opened
|
|
}
|
|
END_CATCH
|
|
|
|
if ( i < _aDocStores.Count() )
|
|
return _aDocStores[i];
|
|
else
|
|
return 0;
|
|
} //GetNamedDocStore
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatArray::GetOne, public
|
|
//
|
|
// Synopsis: Returns a PCatalog by either using an existing catalog or
|
|
// creating a new one. Returns 0 if a catalog couldn't be
|
|
// found or created.
|
|
//
|
|
// Arguments: [pwcPathOrName] -- Root of the catalog or friendly name
|
|
//
|
|
// History: 07-May-92 AmyA Lifted from vquery.cxx
|
|
// 22-May-92 AmyA Added TRY/CATCH
|
|
// 02-Jun-92 KyleP Added UNC support.
|
|
// 12-Jun-92 KyleP Lifted from citest.cxx
|
|
// 29-Sep-94 KyleP Added ofs proxy support
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
PCatalog * CCatArray::GetOne ( WCHAR const * pwcPathOrName )
|
|
{
|
|
CClientDocStore * pDocStore = GetDocStore( pwcPathOrName );
|
|
return pDocStore ? pDocStore->GetCiCat() : 0;
|
|
} //GetOne
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatArray::GetNamedOne, public
|
|
//
|
|
// Synopsis: Returns a PCatalog by either using an existing catalog or
|
|
// creating a new one. Returns 0 if a catalog couldn't be
|
|
// found or created.
|
|
//
|
|
// Arguments: [pwcPath] -- Root of the catalog
|
|
// [pwcName] -- 0 or name of the catalog (optional param)
|
|
//
|
|
// History: 12-Oct-96 dlee created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
PCatalog * CCatArray::GetNamedOne(
|
|
WCHAR const * pwcPath,
|
|
WCHAR const * pwcName,
|
|
BOOL fOpenForReadOnly,
|
|
BOOL fNoQuery )
|
|
{
|
|
CClientDocStore * pDocStore = GetNamedDocStore( pwcPath, pwcName, fOpenForReadOnly );
|
|
if ( pDocStore )
|
|
{
|
|
if ( fNoQuery )
|
|
pDocStore->SetNoQuery();
|
|
else
|
|
pDocStore->UnSetNoQuery();
|
|
}
|
|
|
|
return pDocStore ? pDocStore->GetCiCat() : 0;
|
|
} //GetNamedOne
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: AddStoppedCat, public
|
|
//
|
|
// Synopsis: Add an item of COldCatState into the _aStopCatalogs array
|
|
//
|
|
// Arguments: [dwOldState] -- Old state of a docstore
|
|
// [wcsCatName] -- Catalog name of the docstore
|
|
// [wcVol] -- Letter of the volume on which the catalog resides
|
|
//
|
|
// History: 07-July-98 KitmanH Created
|
|
// 10-July-98 KitmanH Don't add an item with same CatName
|
|
// more than once
|
|
// 23-July-98 KitmanH Add volume letter on which the catalog
|
|
// resides
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
void CCatArray::AddStoppedCat( DWORD dwOldState,
|
|
WCHAR const * wcsCatName,
|
|
WCHAR wcVol )
|
|
{
|
|
XPtrST<COldCatState> xOldState( new COldCatState( dwOldState,
|
|
wcsCatName,
|
|
wcVol) );
|
|
|
|
CLock lockx( _mutex );
|
|
_aStoppedCatalogs.Add( xOldState.GetPointer(), _aStoppedCatalogs.Count() );
|
|
xOldState.Acquire();
|
|
} //AddStoppedCat
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatArray::LokFindCat, private
|
|
//
|
|
// Synopsis: returns the index of the catalog in the _aStoppedcatalogs
|
|
// Array
|
|
//
|
|
// Arguments: [wcsCatName] -- name of the catalog
|
|
//
|
|
// History: 23-July-98 KitmanH Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
DWORD CCatArray::FindCat( WCHAR const * wcsCatName )
|
|
{
|
|
Win4Assert( _mutex.IsHeld() );
|
|
|
|
for ( unsigned i = 0; i < _aStoppedCatalogs.Count(); i++ )
|
|
{
|
|
COldCatState * pOldState = _aStoppedCatalogs.Get(i);
|
|
|
|
if ( !(_wcsicmp( pOldState->GetCatName(), wcsCatName ) ) )
|
|
return i;
|
|
}
|
|
|
|
return -1;
|
|
} //FindCat
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatArray::GetOldState, public
|
|
//
|
|
// Synopsis: returns the old state of a catalog before the volume was locked
|
|
//
|
|
// Arguments: [wcsCatName] -- catalog name
|
|
//
|
|
// Returns: old state of a catalog
|
|
//
|
|
// History: 07-July-98 KitmanH Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
DWORD CCatArray::GetOldState( WCHAR const * wcsCatName )
|
|
{
|
|
CLock lockx( _mutex );
|
|
DWORD i = FindCat(wcsCatName);
|
|
|
|
if ( -1 != i )
|
|
return (_aStoppedCatalogs.Get(i)->GetOldState() );
|
|
else
|
|
return -1;
|
|
} //GetOldState
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatArray::RmFromStopArray, public
|
|
//
|
|
// Synopsis: remove the catalog from the stop array
|
|
//
|
|
// Arguments: [wcsCatName] -- name of the catalog
|
|
//
|
|
// History: 05-May-98 KitmanH Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
void CCatArray::RmFromStopArray( WCHAR const * wcsCatName )
|
|
{
|
|
CLock lockx( _mutex );
|
|
DWORD i = FindCat( wcsCatName );
|
|
|
|
if ( -1 != i )
|
|
{
|
|
delete _aStoppedCatalogs.Get(i);
|
|
_aStoppedCatalogs.Remove(i);
|
|
ciDebugOut(( DEB_ITRACE, "Catalog %ws is deleted from Array\n",
|
|
wcsCatName ));
|
|
}
|
|
} //RmFromStopArray
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatArray::IsCatStopped, public
|
|
//
|
|
// Synopsis: check if the catalog has been stopped
|
|
//
|
|
// Arguments: [wcsCatName] -- name of the catalog
|
|
//
|
|
// History: 05-May-98 KitmanH Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
BOOL CCatArray::IsCatStopped( WCHAR const * wcsCatName )
|
|
{
|
|
CLock lockx( _mutex );
|
|
DWORD i = FindCat( wcsCatName );
|
|
|
|
if ( -1 != i )
|
|
{
|
|
ciDebugOut(( DEB_ITRACE, "Catalog %ws is Stopped\n", wcsCatName ));
|
|
return TRUE;
|
|
}
|
|
else
|
|
return FALSE;
|
|
} //IsCatStopped
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: ClearStopArray, public
|
|
//
|
|
// Synopsis: clear the contents in the _aStoppedCatalogs array
|
|
//
|
|
// History: 05-May-98 KitmanH Created
|
|
// 08-July-98 KitmanH ReWrited
|
|
//
|
|
// Note: _aStoppedCatalogs now stores the old state with the cat name
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
void CCatArray::ClearStopArray()
|
|
{
|
|
CLock lockx( _mutex );
|
|
|
|
for ( unsigned i = 0; i < _aStoppedCatalogs.Count(); i++ )
|
|
{
|
|
ciDebugOut(( DEB_ITRACE, "ClearStopArray: i is %d\n", i ));
|
|
COldCatState * pOldState = _aStoppedCatalogs.Get(i);
|
|
delete pOldState;
|
|
}
|
|
|
|
_aStoppedCatalogs.Clear();
|
|
} //ClearStopArray
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatArray::IncStopCount, public
|
|
//
|
|
// Synopsis: Increment the _cStopCount and set the appropriate element
|
|
// in the volume array
|
|
//
|
|
// Arguments: [wcsCatName] -- name of the catalog
|
|
// [wcVol] -- volume letter
|
|
//
|
|
// History: 24-Aug-98 KitmanH Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
BOOL CCatArray::IncStopCount( WCHAR const * wcsCatName, WCHAR wcVol )
|
|
{
|
|
ciDebugOut(( DEB_ITRACE, "IncStopCount %wc\n", wcVol ));
|
|
CLock lockx( _mutex );
|
|
|
|
DWORD i = FindCat( wcsCatName );
|
|
|
|
if ( -1 != i )
|
|
{
|
|
COldCatState * pOldState = _aStoppedCatalogs.Get(i);
|
|
pOldState->IncStopCountAndSetVol( wcVol );
|
|
return TRUE;
|
|
}
|
|
else
|
|
return FALSE;
|
|
} //IncStop
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Funtion: DriveHasCatalog
|
|
//
|
|
// Synopsis: Checks if there is a catalog.wci directory on the root
|
|
// of the volume.
|
|
//
|
|
// Arguments: [wc] -- the volume to check
|
|
//
|
|
// History: 16-Apr-99 dlee Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
BOOL DriveHasCatalog( WCHAR wc )
|
|
{
|
|
BOOL fCat = FALSE;
|
|
|
|
WCHAR wszVolumePath[] = L"\\\\.\\a:";
|
|
wszVolumePath[4] = wc;
|
|
|
|
HANDLE hVolume = CreateFile( wszVolumePath,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
0,
|
|
NULL );
|
|
|
|
if ( hVolume != INVALID_HANDLE_VALUE )
|
|
{
|
|
SWin32Handle xHandleVolume( hVolume );
|
|
|
|
//
|
|
// Is there media in the drive? This check avoids possible hard-error
|
|
// popups prompting for media.
|
|
//
|
|
|
|
ULONG ulSequence;
|
|
DWORD cb = sizeof(ULONG);
|
|
|
|
BOOL fOk = DeviceIoControl( hVolume,
|
|
IOCTL_STORAGE_CHECK_VERIFY,
|
|
0,
|
|
0,
|
|
&ulSequence,
|
|
sizeof(ulSequence),
|
|
&cb,
|
|
0 );
|
|
|
|
if ( fOk )
|
|
{
|
|
WCHAR awcCatDir[ MAX_PATH ];
|
|
wcscpy( awcCatDir, L"c:\\" );
|
|
wcscat( awcCatDir, CAT_DIR ); // catalog.wci
|
|
awcCatDir[0] = wc;
|
|
|
|
WIN32_FILE_ATTRIBUTE_DATA fData;
|
|
if ( GetFileAttributesEx( awcCatDir, GetFileExInfoStandard, &fData ) )
|
|
{
|
|
// Is the catalog path a file or a directory?
|
|
|
|
fCat = ( 0 != ( fData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) );
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
ciDebugOut(( DEB_ITRACE, "catalog on drive %wc? %s\n", wc, fCat ? "yes" : "no" ));
|
|
|
|
return fCat;
|
|
} //DriveHasCatalog
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatArray::TryToStartCatalogOnRemovableVol
|
|
//
|
|
// Synopsis: Attempts to open a catalog on the root of the volume.
|
|
//
|
|
// Arguments: [wcVol] -- Volume letter
|
|
// [pRequestQ] -- Pointer to the RequestQueue
|
|
//
|
|
// History: 16-Apr-99 dlee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CCatArray::TryToStartCatalogOnRemovableVol(
|
|
WCHAR wcVol,
|
|
CRequestQueue * pRequestQ )
|
|
{
|
|
Win4Assert( IsRemovableDrive( wcVol ) );
|
|
|
|
if ( DriveHasCatalog( wcVol ) )
|
|
{
|
|
ciDebugOut(( DEB_ITRACE, "opening temporary catalog\n" ));
|
|
|
|
// Make the registry entries
|
|
|
|
CRemovableCatalog cat( wcVol );
|
|
cat.Create();
|
|
|
|
WCHAR awcName[MAX_PATH];
|
|
cat.MakeCatalogName( awcName );
|
|
CClientDocStore *p = GetDocStore( awcName, FALSE );
|
|
}
|
|
} //TryToStartCatalogOnRemovableVol
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCatArray::StartCatalogsOnVol
|
|
//
|
|
// Synopsis: Restore all catalogs on the volume specified to its previous
|
|
// state before the volume was locked.
|
|
//
|
|
// Arguments: [wcVol] -- Volume letter
|
|
// [pRequestQ] -- Pointer to the RequestQueue
|
|
//
|
|
// History: 09-03-98 kitmanh Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void CCatArray::StartCatalogsOnVol( WCHAR wcVol, CRequestQueue * pRequestQ )
|
|
{
|
|
ciDebugOut(( DEB_ITRACE, "StartCatalogsOnVol %wc\n", wcVol ));
|
|
CLock lock( _mutex );
|
|
|
|
SCWorkItem newItem;
|
|
RtlZeroMemory( &newItem, sizeof newItem );
|
|
|
|
BOOL fOpenedCatalogs = FALSE;
|
|
|
|
for ( unsigned i = 0 ; i < _aStoppedCatalogs.Count(); i++ )
|
|
{
|
|
COldCatState * pOldCatState = _aStoppedCatalogs.Get(i);
|
|
|
|
if ( pOldCatState->IsVolSet( wcVol ) )
|
|
{
|
|
if ( 1 == pOldCatState->GetStopCount() )
|
|
{
|
|
ciDebugOut(( DEB_ITRACE, "Catalog %ws : pOldCatState->GetStopCount() is == 1\n",
|
|
pOldCatState->GetCatName() ));
|
|
|
|
WCHAR const * awcName = pOldCatState->GetCatName();
|
|
|
|
DWORD dwOldState = pOldCatState->GetOldState();
|
|
|
|
if ( -1 != dwOldState )
|
|
{
|
|
ciDebugOut(( DEB_ITRACE, "dwOldState for %ws is %d\n", awcName, dwOldState ));
|
|
fOpenedCatalogs = TRUE;
|
|
|
|
if ( !( (CICAT_READONLY & dwOldState) ||
|
|
(CICAT_STOPPED & dwOldState) ) )
|
|
{
|
|
if ( 0 != (CICAT_NO_QUERY & dwOldState) )
|
|
{
|
|
newItem.type = eNoQuery;
|
|
newItem.fNoQueryRW = TRUE;
|
|
}
|
|
else if ( 0 != (CICAT_WRITABLE & dwOldState) )
|
|
{
|
|
newItem.type = eCatW;
|
|
}
|
|
else
|
|
{
|
|
Win4Assert( !"Undefined CICAT state" );
|
|
}
|
|
|
|
newItem.pDocStore = 0;
|
|
pRequestQ->AddSCItem( &newItem, awcName );
|
|
}
|
|
else if ( 0 != (CICAT_READONLY & dwOldState) ) //readonly
|
|
{
|
|
newItem.type = eCatRO;
|
|
newItem.pDocStore = 0;
|
|
pRequestQ->AddSCItem( &newItem, awcName );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ciDebugOut(( DEB_ITRACE, "Catalog %ws: pOldCatState->GetStopCount() is %d\n",
|
|
pOldCatState->GetCatName(), pOldCatState->GetStopCount() ));
|
|
|
|
Win4Assert( 1 < pOldCatState->GetStopCount() );
|
|
// Decreament stopcount
|
|
pOldCatState->UnSetVol( wcVol );
|
|
pOldCatState->DecStopCount();
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// If we didn't open any catalogs on the volume and it's a removable
|
|
// volume with a catalog.wci directory in the root, make a temporary
|
|
// entry in the registry and open the catalog read-only. Close the
|
|
// catalog and remove the registry entries when the volume is ejected.
|
|
//
|
|
|
|
if ( !fOpenedCatalogs )
|
|
{
|
|
if ( IsRemovableDrive( wcVol ) && DriveHasCatalog( wcVol ) )
|
|
{
|
|
ciDebugOut(( DEB_ITRACE, "trying to opening temporary catalog\n" ));
|
|
|
|
// Make the registry entries
|
|
|
|
CRemovableCatalog cat( wcVol );
|
|
cat.Create();
|
|
|
|
// Tell the request queue to open the catalog
|
|
|
|
newItem.type = eCatRO;
|
|
newItem.pDocStore = 0;
|
|
newItem.fNoQueryRW = FALSE;
|
|
WCHAR awcName[MAX_PATH];
|
|
cat.MakeCatalogName( awcName );
|
|
newItem.StoppedCat = awcName;
|
|
pRequestQ->AddSCItem( &newItem, awcName );
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// File a null work item so the request queue won't close
|
|
// connections to all query clients.
|
|
//
|
|
|
|
newItem.type = eNoCatWork;
|
|
pRequestQ->AddSCItem( &newItem, L"" );
|
|
}
|
|
}
|
|
} //StartCatalogsOnVol
|
|
|