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.
1331 lines
41 KiB
1331 lines
41 KiB
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1992 - 2000.
|
|
//
|
|
// File: ciprop.cxx
|
|
//
|
|
// Contents: Content index property retriever
|
|
//
|
|
// History: 12-Dec-96 SitaramR Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include <pch.cxx>
|
|
#pragma hdrstop
|
|
|
|
#include <ciprop.hxx>
|
|
#include <catalog.hxx>
|
|
#include <smatch.hxx>
|
|
#include <prcstob.hxx>
|
|
#include <notifmgr.hxx>
|
|
#include <scopetbl.hxx>
|
|
|
|
#define SET_UNICODE_STR( str, buffer, size, maxSize ) \
|
|
str.Buffer = buffer; \
|
|
str.Length = (USHORT)size; \
|
|
str.MaximumLength = (USHORT)maxSize;
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCiPropRetriever::CCiPropRetriever, public
|
|
//
|
|
// Synopsis: Constructor
|
|
// Adds info for *all* scopes to the hashtable. Hereafter, only
|
|
// hashtable is checked to see if a file is in scope.
|
|
//
|
|
// Requires: All directories in a catalog must have a wid.
|
|
// Hashtable must be allowed to grow to hold all specified scopes.
|
|
//
|
|
// Arguments: [cat] -- Catalog
|
|
// [pQueryPropMapper] -- Pid Remapper associated with the query
|
|
// [secCache] -- Cache of AccessCheck() results
|
|
// [fUsePathAlias] -- TRUE if client is going through rdr/svr
|
|
// [scope] -- Root scope.
|
|
//
|
|
// History: 19-Aug-93 KyleP Created
|
|
// 25-Aug-97 EmilyB Add wids for all scopes to the hashtable.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
CCiPropRetriever::CCiPropRetriever( PCatalog & cat,
|
|
ICiQueryPropertyMapper *pQueryPropMapper,
|
|
CSecurityCache & secCache,
|
|
BOOL fUsePathAlias,
|
|
CRestriction * pScope )
|
|
: CGenericPropRetriever( cat, pQueryPropMapper, secCache, fUsePathAlias ? pScope : 0 ),
|
|
_fFindLoaded( FALSE ),
|
|
_fFastFindLoaded( FALSE ),
|
|
_fFastStatLoaded( 0 ),
|
|
_fFastStatNeverLoad( 0 ),
|
|
_pScope( pScope ),
|
|
_hTable(MAX_HASHED_DIRECTORIES),
|
|
_fAllScopesShallow(TRUE),
|
|
_fAllInScope(FALSE),
|
|
_fNoneInScope(FALSE)
|
|
|
|
{
|
|
if ( !ValidateScopeRestriction( _pScope ) )
|
|
THROW( CException( STATUS_NO_MEMORY ) );
|
|
|
|
//
|
|
// add scopes to hash table
|
|
//
|
|
|
|
if ( RTScope == _pScope->Type() )
|
|
{
|
|
const CScopeRestriction & scp = * (CScopeRestriction *) _pScope;
|
|
Win4Assert( scp.IsValid() );
|
|
|
|
if (scp.IsVirtual())
|
|
AddVirtualScopeRestriction(scp);
|
|
else
|
|
AddScopeRestriction(scp.GetFunnyPath(), scp.IsDeep() );
|
|
|
|
}
|
|
else if ( RTOr == _pScope->Type() )
|
|
{
|
|
CNodeRestriction const & node = * _pScope->CastToNode();
|
|
|
|
for ( ULONG x = 0; x < node.Count() && !_fAllInScope; x++ )
|
|
{
|
|
Win4Assert( RTScope == node.GetChild( x )->Type() );
|
|
|
|
const CScopeRestriction & scp = * (CScopeRestriction *)
|
|
node.GetChild( x );
|
|
Win4Assert( scp.IsValid() );
|
|
|
|
if (scp.IsVirtual())
|
|
AddVirtualScopeRestriction(scp);
|
|
else
|
|
AddScopeRestriction(scp.GetFunnyPath(), scp.IsDeep() );
|
|
}
|
|
}
|
|
|
|
|
|
if (!_fAllInScope && 0 == _hTable.Count())
|
|
_fNoneInScope = TRUE;
|
|
|
|
SET_UNICODE_STR( _Path, _xwcPath.Get(), flagNoValueYet, _xwcPath.SizeOf() );
|
|
|
|
SET_UNICODE_STR( _VPath, _xwcVPath.Get(), flagNoValueYet, _xwcVPath.SizeOf() );
|
|
|
|
_Name.Length = flagNoValueYet;
|
|
} //CCiPropRetriever
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCiPropRetriever::AddVirtualScopeRestriction, public
|
|
//
|
|
// Synopsis: Adds info to hashtable for all virtual directories which fall
|
|
// within the virtual scope specified. Hashtable entries for
|
|
// exclude directories have fInScope = FALSE.
|
|
//
|
|
// Requires: All directories in a catalog must have a wid.
|
|
// Hashtable must be allowed to grow to hold all specified scopes.
|
|
//
|
|
// Arguments: [scp] - specified scope
|
|
//
|
|
// History: 25-Aug-97 EmilyB Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
void CCiPropRetriever::AddVirtualScopeRestriction(
|
|
CScopeRestriction const & scp)
|
|
{
|
|
unsigned iBmk = 0;
|
|
ULONG ulType = 0;
|
|
|
|
XGrowable<WCHAR> xwcVPath;
|
|
CLowerFunnyPath lcaseFunnyPPath;
|
|
|
|
unsigned ccVPath = 0;
|
|
unsigned ccPPath = 0;
|
|
|
|
//
|
|
// enumerate through all virtual roots (both include and exclude) falling
|
|
// under specified virtual scope
|
|
//
|
|
while ( _cat.VirtualToAllPhysicalRoots( scp.GetPath(), // Virtual scope (prefix)
|
|
scp.PathLength(), // + length
|
|
xwcVPath, // Full virtual root
|
|
ccVPath, // + return length
|
|
lcaseFunnyPPath, // Full physical root
|
|
ccPPath, // + return length
|
|
ulType, // root type
|
|
iBmk ) ) // Bookmark
|
|
{
|
|
//
|
|
// Special-case shallow queries at '/', so we don't end up with hits
|
|
// in the roots of all virtual roots
|
|
//
|
|
|
|
if ( ( 0 != (lcaseFunnyPPath.GetActualPath())[0] ) &&
|
|
( ( scp.IsDeep() ) ||
|
|
( 0 != scp.PathLength() ) ||
|
|
( 1 == ccVPath ) ) )
|
|
|
|
{
|
|
// if virtual scope was invalid, VirtualToPhysicalRoot will return
|
|
// path to general root + \invalid scope name, which will not have
|
|
// a wid. So this is where we catch invalid virtual scopes.
|
|
WORKID wid = _cat.PathToWorkId( lcaseFunnyPPath, FALSE );
|
|
|
|
if (widInvalid != wid )
|
|
{
|
|
//
|
|
// add info for vroot to hashtable
|
|
//
|
|
CDirWidHashEntry DirInfo(wid,
|
|
scp.IsDeep(),
|
|
(ulType & PCatalog::UsedRoot) ? TRUE : FALSE ); // include or exclude scope?
|
|
_hTable.AddEntry(DirInfo);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// This can happen. We may have hit an exclude scope that
|
|
// is not below an include scope.
|
|
//
|
|
|
|
continue;
|
|
}
|
|
}
|
|
|
|
ccVPath = ccPPath = 0;
|
|
}
|
|
|
|
if ( scp.IsDeep() )
|
|
_fAllScopesShallow = FALSE;
|
|
} //AddVirtualScopeRestriction
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCiPropRetriever::AddScopeRestriction, public
|
|
//
|
|
// Synopsis: Adds info to hashtable for all physical scope specified.
|
|
// Exclude physical scopes are not indexed, so no need to
|
|
// check for exclude scopes. If physical scope is
|
|
// above all physical roots, then adds those roots which fall
|
|
// under scope to the hashtable.
|
|
// Sets _fAllInScope to TRUE if physical scope was '\' or
|
|
// if it was a directory above all physical roots. There is no
|
|
// other way _fAllInScope can be TRUE.
|
|
//
|
|
// Requires: All directories in a catalog must have a wid.
|
|
// Hashtable must be allowed to grow to hold all specified scopes.
|
|
//
|
|
// Arguments: [lcaseFunnyPhysPath] - specified physical scope
|
|
// [fIsDeep] - is scope deep?
|
|
//
|
|
// History: 25-Aug-97 EmilyB Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
void CCiPropRetriever::AddScopeRestriction(
|
|
const CLowerFunnyPath & lcaseFunnyPhysPath,
|
|
BOOL fIsDeep )
|
|
{
|
|
WORKID wid;
|
|
|
|
if (fIsDeep)
|
|
_fAllScopesShallow = FALSE;
|
|
|
|
if ( 0 == lcaseFunnyPhysPath.GetActualLength() )
|
|
{
|
|
//
|
|
// A physical scope of '\' that is shallow makes no sense.
|
|
//
|
|
|
|
if ( fIsDeep )
|
|
_fAllInScope = TRUE;
|
|
|
|
return;
|
|
}
|
|
|
|
CLowerFunnyPath lcaseFunnyFixedPath = lcaseFunnyPhysPath;
|
|
BOOL fImpersonated = FALSE;
|
|
|
|
//
|
|
// if scope is unc, use fixed up version
|
|
//
|
|
|
|
if ( lcaseFunnyFixedPath.IsRemote() )
|
|
{
|
|
// unc -- try to unfixup the scope. if there is no unfixup,
|
|
// it'll just use the original path.
|
|
|
|
_cat.InverseFixupPath( lcaseFunnyFixedPath );
|
|
|
|
// need to impersonate for remote access here?
|
|
|
|
if ( lcaseFunnyFixedPath.IsRemote() &&
|
|
! _remoteAccess.IsImpersonated() )
|
|
{
|
|
// ignore any error return
|
|
if ( _remoteAccess.ImpersonateIfNoThrow(
|
|
lcaseFunnyFixedPath.GetActualPath(),
|
|
0 ) )
|
|
fImpersonated = TRUE;
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// Check to see if the input path name contains an 8.3 short name
|
|
//
|
|
if ( lcaseFunnyFixedPath.IsShortPath() )
|
|
{
|
|
vqDebugOut(( DEB_WARN,
|
|
"CCiPropRetriever::AddScopeRestriction: possible shortname path\n\t%ws ==>\n",
|
|
lcaseFunnyFixedPath.GetActualPath() ));
|
|
|
|
if ( lcaseFunnyFixedPath.ConvertToLongName() )
|
|
{
|
|
vqDebugOut(( DEB_WARN|DEB_NOCOMPNAME,
|
|
"\t%ws\n",
|
|
lcaseFunnyFixedPath.GetActualPath() ));
|
|
}
|
|
else
|
|
{
|
|
vqDebugOut(( DEB_ERROR, "longname path conversion failed!\n" ));
|
|
}
|
|
}
|
|
|
|
if ( fImpersonated )
|
|
{
|
|
_remoteAccess.Release();
|
|
}
|
|
|
|
wid = _cat.PathToWorkId( lcaseFunnyFixedPath, FALSE );
|
|
if (widInvalid != wid )
|
|
{
|
|
// straightforward case - scope has a wid - which we add to _hTable
|
|
|
|
CDirWidHashEntry DirInfo(wid, fIsDeep, TRUE);
|
|
_hTable.AddEntry(DirInfo);
|
|
return;
|
|
}
|
|
|
|
// got here because scope was not global and it didn't have a wid.
|
|
// Might be physical directory (not cataloged) above one that is
|
|
// in catalog. If scope is shallow, then nothing is in it.
|
|
// If scope is deep, enumerate through scopes and see if any
|
|
// are subdirectories of scope specified
|
|
|
|
if (fIsDeep)
|
|
{
|
|
CScopeMatch Match( lcaseFunnyFixedPath.GetActualPath(),
|
|
lcaseFunnyFixedPath.GetActualLength() );
|
|
|
|
_fAllInScope = TRUE;
|
|
|
|
CCiScopeTable *pScopes = _cat.GetScopeTable();
|
|
if ( 0 != pScopes )
|
|
{
|
|
unsigned iBmk = 0;
|
|
WCHAR awc[MAX_PATH];
|
|
while ( pScopes->Enumerate( awc,
|
|
(sizeof awc / sizeof WCHAR),
|
|
iBmk ) )
|
|
{
|
|
unsigned ccawc = wcslen(awc);
|
|
if ( Match.IsInScope( awc, ccawc ) )
|
|
{
|
|
CLowerFunnyPath lcaseFunnyAwc( awc, ccawc );
|
|
wid = _cat.PathToWorkId( lcaseFunnyAwc, FALSE );
|
|
|
|
// wid may be widInvalid if it's a scope that hasn't been
|
|
// scanned yet.
|
|
|
|
if (widInvalid != wid )
|
|
{
|
|
CDirWidHashEntry DirInfo( wid,
|
|
fIsDeep,
|
|
TRUE );
|
|
_hTable.AddEntry(DirInfo);
|
|
}
|
|
}
|
|
else // found a root not included in scope
|
|
_fAllInScope = FALSE;
|
|
}
|
|
}
|
|
}
|
|
} //AddScopeRestriction
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCiPropRetriever::GetPath, public
|
|
//
|
|
// Synopsis: Returns the path for the file
|
|
//
|
|
// Returns: A path to file
|
|
//
|
|
// History: 07-Feb-96 KyleP Added header
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
UNICODE_STRING const * CCiPropRetriever::GetPath()
|
|
{
|
|
if ( _Path.Length == flagNoValueYet )
|
|
{
|
|
unsigned cwc = _xwcPath.Count();
|
|
FetchPath( _Path.Buffer, cwc );
|
|
|
|
if ( cwc > _xwcPath.Count() )
|
|
{
|
|
// Need more space
|
|
_xwcPath.SetSize( cwc );
|
|
SET_UNICODE_STR( _Path, _xwcPath.Get(), _Path.Length, _xwcPath.SizeOf() );
|
|
|
|
FetchPath( _Path.Buffer, cwc );
|
|
|
|
// Can't go on asking for more space forever !
|
|
Win4Assert( cwc <= _xwcPath.Count() );
|
|
}
|
|
|
|
if ( 0 == cwc )
|
|
_Path.Length = 0;
|
|
|
|
_Name.Length = 0;
|
|
|
|
if ( _Path.Length == 0 )
|
|
return 0;
|
|
else
|
|
{
|
|
_Path.Length = (USHORT)(cwc * sizeof( WCHAR ));
|
|
_Name.Buffer = _Path.Buffer + _Path.Length/(sizeof WCHAR) - 1;
|
|
|
|
// _Path can be path of root (e.g. c:) if indexing directories and
|
|
// root is a match. Watch that we don't walk off end.
|
|
|
|
while ( *_Name.Buffer != L'\\' && _Name.Buffer != _Path.Buffer)
|
|
{
|
|
Win4Assert( _Name.Length < _Path.Length );
|
|
|
|
_Name.Length += sizeof(WCHAR);
|
|
_Name.Buffer--;
|
|
}
|
|
if (_Name.Buffer == _Path.Buffer)
|
|
{
|
|
_Name.Buffer = _Path.Buffer + _Path.Length/(sizeof WCHAR); // point it to /0
|
|
_Name.Length=0;
|
|
}
|
|
else
|
|
{
|
|
_Name.Buffer++;
|
|
_Path.Length -= _Name.Length + sizeof WCHAR;
|
|
}
|
|
}
|
|
}
|
|
|
|
return &_Path;
|
|
} //GetPath
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCiPropRetriever::FetchVPathInVScope, private
|
|
//
|
|
// Synopsis: Returns a virtual path for the file that is in the given
|
|
// virtual scope
|
|
//
|
|
// Arguments: [xwcVPath] -- The resulting virtual path
|
|
// [pwcVScope] -- The virtual scope
|
|
// [cwcVScope] -- # of characters in pwcVScope
|
|
// [fVScopeDeep] -- TRUE if the scope is deep
|
|
//
|
|
// Returns: Length of vpath, if a vpath was found and the vpath is in the vscope
|
|
// 0 if no vpath exists in the vscope
|
|
//
|
|
// History: 02-Feb-98 dlee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
unsigned CCiPropRetriever::FetchVPathInVScope( XGrowable<WCHAR> & xwcVPath,
|
|
WCHAR const * pwcVScope,
|
|
const unsigned cwcVScope,
|
|
const BOOL fVScopeDeep )
|
|
{
|
|
vqDebugOut(( DEB_ITRACE, "FetchVPathInVScope, vscope '%ws', cwc %d\n",
|
|
pwcVScope, cwcVScope ));
|
|
|
|
CScopeMatch Match( pwcVScope, cwcVScope );
|
|
unsigned cSkip = 0;
|
|
unsigned cwcVPath = 0;
|
|
|
|
while ( TRUE )
|
|
{
|
|
cwcVPath = _cat.WorkIdToVirtualPath( GetPropertyRecord(),
|
|
cSkip,
|
|
xwcVPath );
|
|
|
|
if ( 0 == cwcVPath )
|
|
return 0;
|
|
|
|
//
|
|
// In scope?
|
|
//
|
|
|
|
vqDebugOut(( DEB_ITRACE, " comparing to cwc %d, '%ws'\n",
|
|
cwcVPath, xwcVPath.Get() ));
|
|
|
|
if ( !Match.IsInScope( xwcVPath.Get(), cwcVPath ) )
|
|
{
|
|
cSkip++;
|
|
continue;
|
|
}
|
|
|
|
Win4Assert( 0 == xwcVPath[cwcVPath] );
|
|
|
|
//
|
|
// If the scope is shallow, check that it's still in scope
|
|
//
|
|
|
|
if ( !fVScopeDeep )
|
|
{
|
|
unsigned cwcName = 0;
|
|
WCHAR * pwcName = xwcVPath.Get() + cwcVPath - 1;
|
|
|
|
while ( L'\\' != *pwcName )
|
|
{
|
|
Win4Assert( cwcName < cwcVPath );
|
|
cwcName++;
|
|
pwcName--;
|
|
}
|
|
|
|
unsigned cwcJustPath = cwcVPath - cwcName;
|
|
vqDebugOut(( DEB_ITRACE, "cwcJustPath: %d\n", cwcJustPath ));
|
|
|
|
BOOL fTooDeep = cwcJustPath > ( cwcVScope + 1 );
|
|
|
|
if ( fTooDeep )
|
|
{
|
|
cSkip++;
|
|
continue;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
vqDebugOut(( DEB_ITRACE," InVScope: match!\n" ));
|
|
return cwcVPath;
|
|
} //FetchVPathInVScope
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCiPropRetriever::FetchVirtualPath, private
|
|
//
|
|
// Synopsis: Returns the virtual path for the file
|
|
//
|
|
// Arguments: [xwcVPath] -- The resulting virtual path
|
|
//
|
|
// Returns: If found, length of vpath ELSE 0
|
|
//
|
|
// History: 02-Feb-98 dlee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
unsigned CCiPropRetriever::FetchVirtualPath( XGrowable<WCHAR> & xwcVPath )
|
|
{
|
|
BOOL fUseAnyVPath = FALSE;
|
|
unsigned cwc = 0;
|
|
|
|
if ( RTScope == _pScope->Type() )
|
|
{
|
|
CScopeRestriction const & scp = * (CScopeRestriction *) _pScope;
|
|
|
|
if ( scp.IsVirtual() )
|
|
{
|
|
cwc = FetchVPathInVScope( xwcVPath,
|
|
scp.GetPath(),
|
|
scp.PathLength(),
|
|
scp.IsDeep() );
|
|
}
|
|
else
|
|
fUseAnyVPath = TRUE;
|
|
}
|
|
else if ( RTOr == _pScope->Type() )
|
|
{
|
|
CNodeRestriction const & node = * _pScope->CastToNode();
|
|
|
|
fUseAnyVPath = TRUE;
|
|
|
|
for ( ULONG x = 0; x < node.Count(); x++ )
|
|
{
|
|
Win4Assert( RTScope == node.GetChild( x )->Type() );
|
|
|
|
CScopeRestriction const & scp = * (CScopeRestriction *)
|
|
node.GetChild( x );
|
|
|
|
if ( scp.IsVirtual() )
|
|
{
|
|
cwc = FetchVPathInVScope( xwcVPath,
|
|
scp.GetPath(),
|
|
scp.PathLength(),
|
|
scp.IsDeep() );
|
|
if ( cwc > 0 )
|
|
{
|
|
fUseAnyVPath = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// If no virtual scope works for the file, grab any virtual path
|
|
//
|
|
|
|
if ( fUseAnyVPath )
|
|
cwc = _cat.WorkIdToVirtualPath( GetPropertyRecord(),
|
|
0,
|
|
xwcVPath );
|
|
return cwc;
|
|
} //FetchVirtualPath
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCiPropRetriever::GetVirtualPath, public
|
|
//
|
|
// Synopsis: Returns the virtual path for the file
|
|
//
|
|
// Returns: A virtual path to file, or 0 if none exists.
|
|
//
|
|
// History: 07-Feb-96 KyleP Added header
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
UNICODE_STRING const * CCiPropRetriever::GetVirtualPath()
|
|
{
|
|
if ( flagNoValueYet == _VPath.Length )
|
|
{
|
|
unsigned cwc = FetchVirtualPath( _xwcVPath );
|
|
|
|
if ( 0 == cwc )
|
|
{
|
|
SET_UNICODE_STR( _VPath, _xwcVPath.Get(), flagNoValue, _xwcVPath.SizeOf() );
|
|
}
|
|
else
|
|
{
|
|
Win4Assert( 0 == _xwcVPath[cwc] );
|
|
SET_UNICODE_STR( _VPath, _xwcVPath.Get(), cwc * sizeof WCHAR, _xwcVPath.SizeOf() );
|
|
|
|
_Name.Length = 0;
|
|
_Name.Buffer = _VPath.Buffer + cwc - 1;
|
|
|
|
while ( L'\\' != *_Name.Buffer )
|
|
{
|
|
Win4Assert( _Name.Length < _VPath.Length );
|
|
|
|
_Name.Length += sizeof WCHAR;
|
|
_Name.Buffer--;
|
|
}
|
|
|
|
Win4Assert ( L'\\' == *_Name.Buffer );
|
|
|
|
_Name.Buffer++;
|
|
_VPath.Length -= _Name.Length + sizeof WCHAR;
|
|
}
|
|
}
|
|
|
|
if ( flagNoValue == _VPath.Length )
|
|
return 0;
|
|
else
|
|
return &_VPath;
|
|
} //GetVirtualPath
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCiPropRetriever::GetShortName, public
|
|
//
|
|
// Returns: A short name to file
|
|
//
|
|
// History: 17-Apr-96 KyleP Added header
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
UNICODE_STRING const * CCiPropRetriever::GetShortName()
|
|
{
|
|
if ( !_fFindLoaded )
|
|
Refresh( FALSE );
|
|
|
|
_ShortName.Length = wcslen( _finddata.cAlternateFileName ) * sizeof(WCHAR);
|
|
|
|
//
|
|
// If we don'th have a short name and it's not just because we were unable
|
|
// to load it, return the real file name.
|
|
//
|
|
|
|
if ( ( 0 == _ShortName.Length ) && ( 0xffffffff != _finddata.dwReserved0 ) )
|
|
return &_Name;
|
|
|
|
_ShortName.MaximumLength = _ShortName.Length;
|
|
_ShortName.Buffer = &_finddata.cAlternateFileName[0];
|
|
|
|
return &_ShortName;
|
|
} //GetShortName
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCiPropRetriever::CreateTime, public
|
|
//
|
|
// Returns: Create time for file, or 0xFFFFFFFFFFFFFFFF if unknown
|
|
//
|
|
// History: 17-Apr-96 KyleP Added header
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
LONGLONG CCiPropRetriever::CreateTime()
|
|
{
|
|
//
|
|
// First, should we try a fast path?
|
|
//
|
|
|
|
if ( 0 == (_fFastStatLoaded & fsCreate) )
|
|
FetchI8StatProp( fsCreate, pidCreateTime, (LONGLONG *)&_finddata.ftCreationTime );
|
|
|
|
LARGE_INTEGER li;
|
|
li.LowPart = _finddata.ftCreationTime.dwLowDateTime;
|
|
li.HighPart = _finddata.ftCreationTime.dwHighDateTime;
|
|
|
|
return li.QuadPart;
|
|
} //CreateTime
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCiPropRetriever::ModifyTime, public
|
|
//
|
|
// Returns: Last write time for file, or 0xFFFFFFFFFFFFFFFF if unknown
|
|
//
|
|
// History: 17-Apr-96 KyleP Added header
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
LONGLONG CCiPropRetriever::ModifyTime()
|
|
{
|
|
//
|
|
// First, should we try a fast path?
|
|
//
|
|
|
|
if ( 0 == (_fFastStatLoaded & fsModify) )
|
|
FetchI8StatProp( fsModify, pidWriteTime, (LONGLONG *)&_finddata.ftLastWriteTime );
|
|
|
|
LARGE_INTEGER li;
|
|
li.LowPart = _finddata.ftLastWriteTime.dwLowDateTime;
|
|
li.HighPart = _finddata.ftLastWriteTime.dwHighDateTime;
|
|
|
|
return li.QuadPart;
|
|
} //ModifyTime
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCiPropRetriever::AccessTime, public
|
|
//
|
|
// Returns: Last access time for file, or 0xFFFFFFFFFFFFFFFF if unknown
|
|
//
|
|
// History: 17-Apr-96 KyleP Added header
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
LONGLONG CCiPropRetriever::AccessTime()
|
|
{
|
|
//
|
|
// First, should we try a fast path?
|
|
//
|
|
|
|
if ( 0 == (_fFastStatLoaded & fsAccess) )
|
|
FetchI8StatProp( fsAccess, pidAccessTime, (LONGLONG *)&_finddata.ftLastAccessTime );
|
|
|
|
LARGE_INTEGER li;
|
|
li.LowPart = _finddata.ftLastAccessTime.dwLowDateTime;
|
|
li.HighPart = _finddata.ftLastAccessTime.dwHighDateTime;
|
|
|
|
return li.QuadPart;
|
|
} //AccessTime
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCiPropRetriever::ObjectSize public
|
|
//
|
|
// Returns: Size of file, or 0xFFFFFFFFFFFFFFFF if unknown
|
|
//
|
|
// History: 17-Apr-96 KyleP Added header
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
LONGLONG CCiPropRetriever::ObjectSize()
|
|
{
|
|
//
|
|
// First, should we try a fast path?
|
|
//
|
|
|
|
LARGE_INTEGER li;
|
|
if ( 0 == (_fFastStatLoaded & fsSize) )
|
|
{
|
|
//
|
|
// If this fails, the FindData will have been initialized.
|
|
//
|
|
|
|
if ( FetchI8StatProp( fsSize, pidSize, (LONGLONG *)&li ) )
|
|
{
|
|
_finddata.nFileSizeLow = li.LowPart;
|
|
_finddata.nFileSizeHigh = li.HighPart;
|
|
}
|
|
}
|
|
|
|
li.LowPart = _finddata.nFileSizeLow;
|
|
li.HighPart = _finddata.nFileSizeHigh;
|
|
|
|
return li.QuadPart;
|
|
} //ObjectSize
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CCiPropRetriever::Attributes, public
|
|
//
|
|
// Returns: Attributes for file, or 0xFFFFFFFF if unknown
|
|
//
|
|
// History: 17-Apr-96 KyleP Added header
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
ULONG CCiPropRetriever::Attributes()
|
|
{
|
|
//
|
|
// First, should we try a fast path?
|
|
//
|
|
|
|
if ( 0 == (_fFastStatLoaded & fsAttrib) )
|
|
{
|
|
//
|
|
// Try property store?
|
|
//
|
|
|
|
if ( 0 == (_fFastStatNeverLoad & fsAttrib) )
|
|
{
|
|
PROPVARIANT var;
|
|
unsigned cb = sizeof(var);
|
|
|
|
if ( FetchValue( pidAttrib, &var, &cb ) )
|
|
{
|
|
if ( var.vt == VT_EMPTY )
|
|
Refresh( TRUE );
|
|
else
|
|
{
|
|
Win4Assert( var.vt == VT_UI4 );
|
|
_finddata.dwFileAttributes = var.ulVal;
|
|
_fFastStatLoaded |= fsAttrib;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_fFastStatNeverLoad |= fsAttrib;
|
|
Refresh( TRUE );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Win4Assert( !_fFastFindLoaded );
|
|
Refresh( TRUE );
|
|
}
|
|
}
|
|
|
|
return _finddata.dwFileAttributes;
|
|
} //Attributes
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCiPropRetriever::IsInScope
|
|
//
|
|
// Synopsis: Test if workid in scope.
|
|
//
|
|
// History: 19-Aug-93 KyleP Created
|
|
// 30-Oct-96 dlee Added loop, moved guts to isInScope
|
|
// 26-Jun-96 emilyb optimized scope checking. No longer
|
|
// loads stat properties.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
SCODE STDMETHODCALLTYPE CCiPropRetriever::IsInScope( BOOL *pfInScope )
|
|
{
|
|
if ( widInvalid == _widPrimedForPropRetrieval )
|
|
return CI_E_WORKID_NOTVALID;
|
|
|
|
SCODE sc = S_OK;
|
|
|
|
CTranslateSystemExceptions translate;
|
|
TRY
|
|
{
|
|
*pfInScope = IsInScope( _widPrimedForPropRetrieval );
|
|
}
|
|
CATCH( CException, e )
|
|
{
|
|
sc = e.GetErrorCode();
|
|
|
|
vqDebugOut(( DEB_ERROR,
|
|
"CCiPropRetriever::IsInScope - Exception caught 0x%x\n",
|
|
sc ));
|
|
}
|
|
END_CATCH;
|
|
|
|
return sc;
|
|
} //IsInScope
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCiPropRetriever::IsInScope, private
|
|
//
|
|
// Synopsis: Test if workid is in scope.
|
|
//
|
|
// Algorithm: looks for an ancestor of the current file (wid parameter) in
|
|
// the hashtable. If it finds one, it uses it to determine if
|
|
// current file is in scope. If it doesn't, the current file\
|
|
// is not in scope. It also adds an
|
|
// entry for the topmost unmatched ancestor to the hashtable.
|
|
//
|
|
// Requires: All scopes must be in hashtable. For virtual scopes, this
|
|
// requirement includes both exclude and include roots
|
|
// within the scope.
|
|
//
|
|
// Returns: TRUE if object is in scope.
|
|
//
|
|
// History: 27-Jun-97 emilyb created
|
|
//
|
|
// Notes: The only time widInvalid is valid as a parent is if the
|
|
// parent is the root of a drive.
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
BOOL CCiPropRetriever::IsInScope( WORKID wid )
|
|
{
|
|
Win4Assert( wid == _widPrimedForPropRetrieval );
|
|
|
|
if (_fAllInScope)
|
|
{
|
|
//
|
|
// Still need to check matching attributes.
|
|
//
|
|
|
|
return ( 0 == _ulAttribFilter ) ||
|
|
( (Attributes() & _ulAttribFilter) == 0 );
|
|
}
|
|
|
|
if (_fNoneInScope)
|
|
return FALSE;
|
|
|
|
//
|
|
// is wid an inscope directory?
|
|
//
|
|
//
|
|
CDirWidHashEntry DirInfo(wid, 0); // entry to find in hash table
|
|
if (_hTable.LookUpWorkId (DirInfo) )
|
|
{
|
|
if (DirInfo.fInScope())
|
|
{
|
|
return ( 0 == _ulAttribFilter ) ||
|
|
( (Attributes() & _ulAttribFilter) == 0 );
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// find wid of parent
|
|
//
|
|
|
|
WORKID widParent = widInvalid; // parent of wid
|
|
WORKID widAncestor = widInvalid; // used to walk up ancestor chain
|
|
|
|
PROPVARIANT var;
|
|
BOOL fFound;
|
|
unsigned cb = sizeof(var);
|
|
fFound = FetchValue(pidParentWorkId, &var, &cb);
|
|
Win4Assert( !fFound || VT_UI4 == var.vt || VT_EMPTY == var.vt );
|
|
|
|
if ( !fFound || VT_EMPTY == var.vt )
|
|
{
|
|
// file could have been deleted - not in scope
|
|
return FALSE;
|
|
}
|
|
|
|
widParent = var.ulVal;
|
|
if (widParent == widInvalid)
|
|
return FALSE;
|
|
|
|
//
|
|
// look for parent in hash table
|
|
//
|
|
DirInfo.SetWorkId(widParent); // entry to find in hash table
|
|
if (_hTable.LookUpWorkId (DirInfo) )
|
|
{
|
|
if (DirInfo.fInScope())
|
|
{
|
|
return ( 0 == _ulAttribFilter ) ||
|
|
( (Attributes() & _ulAttribFilter) == 0 );
|
|
}
|
|
else
|
|
return FALSE;
|
|
}
|
|
if (_fAllScopesShallow) // should have found it above if it was in scope
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// we've looked for parent without success -- now look for ancestors
|
|
//
|
|
cb = sizeof(var);
|
|
|
|
Quiesce(); // Can only read 1 property record at a time.
|
|
fFound = _cat.FetchValue(widParent, pidParentWorkId, &var, &cb);
|
|
Win4Assert( !fFound || VT_UI4 == var.vt || VT_EMPTY == var.vt );
|
|
widAncestor = var.ulVal;
|
|
DirInfo.SetWorkId(widAncestor);
|
|
|
|
while ( fFound && VT_UI4 == var.vt &&
|
|
widAncestor != widInvalid && // not root
|
|
( !_hTable.LookUpWorkId ( DirInfo) || // not in table already
|
|
!DirInfo.fDeep() ) ) // shallow - so it doesn't apply to grandchild
|
|
{
|
|
// save topmost valid ancestor
|
|
widParent = widAncestor;
|
|
|
|
// get the previous ancestor
|
|
Quiesce(); // Can only read 1 property record at a time.
|
|
|
|
cb = sizeof(var);
|
|
fFound = _cat.FetchValue(widAncestor, pidParentWorkId, &var, &cb);
|
|
Win4Assert( !fFound || VT_UI4 == var.vt || VT_EMPTY == var.vt );
|
|
widAncestor = var.ulVal;
|
|
DirInfo.SetWorkId(widAncestor);
|
|
}
|
|
|
|
if ( !fFound || VT_UI4 != var.vt )
|
|
{
|
|
// file could have been deleted -- not in scope
|
|
return FALSE;
|
|
}
|
|
|
|
BOOL fInScope = FALSE; // not in scope unless match found
|
|
BOOL fDeep = TRUE; // must be deep, or else wouldn't apply to grandchild
|
|
|
|
if (widInvalid != widAncestor) // found match
|
|
{
|
|
Win4Assert( DirInfo.fDeep() );
|
|
fInScope = DirInfo.fInScope();
|
|
}
|
|
|
|
Win4Assert( widInvalid != widParent );
|
|
|
|
// add top ancestor to hashtable
|
|
//
|
|
// Once hash table reaches max size, stop adding entries to it.
|
|
// Because it was seeded with scopes, the data is there to answer
|
|
// if something is in scope.
|
|
if(_hTable.Count() < MAX_HASHED_DIRECTORIES)
|
|
{
|
|
CDirWidHashEntry DirAnc( widParent, fDeep, fInScope );
|
|
if (!_hTable.LookUpWorkId (DirAnc) ) // be careful not to replace ancestral shallow scopes
|
|
{
|
|
_hTable.AddEntry(DirAnc);
|
|
#if CIDBG == 1
|
|
// how often do we max out the hash table
|
|
if(_hTable.Count() == MAX_HASHED_DIRECTORIES)
|
|
vqDebugOut(( DEB_WARN,
|
|
"IsInScope maxed out wid hash table with %d entries\n",
|
|
_hTable.Count()) );
|
|
#endif
|
|
}
|
|
}
|
|
|
|
//
|
|
// Still need to check matching attributes.
|
|
//
|
|
|
|
return fInScope && (( 0 == _ulAttribFilter ) ||
|
|
( (Attributes() & _ulAttribFilter) == 0 ));
|
|
} //IsInScope
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCiPropRetriever::Refresh, private
|
|
//
|
|
// Synopsis: Load stat properties for current object
|
|
//
|
|
// Arguments: [fFast] -- If TRUE, make fast call and don't load alternate
|
|
// file name.
|
|
//
|
|
// Returns: TRUE if load successful
|
|
//
|
|
// History: 19-Aug-93 KyleP Created
|
|
// 29-Feb-96 KyleP Added GetFileAttributesEx support
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
BOOL CCiPropRetriever::Refresh( BOOL fFast )
|
|
{
|
|
//
|
|
// Physical path may not be loaded.
|
|
//
|
|
|
|
if ( _Path.Length == flagNoValueYet )
|
|
{
|
|
if ( 0 == GetPath() )
|
|
{
|
|
RtlFillMemory( &_finddata, sizeof(WIN32_FILE_ATTRIBUTE_DATA), 0xFF );
|
|
_finddata.cAlternateFileName[0] = 0;
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
if ( _Path.Length == 0 )
|
|
{
|
|
//
|
|
// Previously failed to load path, so no way to get attributes
|
|
//
|
|
|
|
RtlFillMemory( &_finddata, sizeof(WIN32_FILE_ATTRIBUTE_DATA), 0xFF );
|
|
_finddata.cAlternateFileName[0] = 0;
|
|
return FALSE;
|
|
}
|
|
|
|
if ( CImpersonateRemoteAccess::IsNetPath(_Path.Buffer) )
|
|
{
|
|
WCHAR const * pwszVPath = (_VPath.Length == flagNoValueYet) ? 0 : _VPath.Buffer;
|
|
|
|
//
|
|
// Just blow off the file if this fails.
|
|
//
|
|
|
|
if ( !_remoteAccess.ImpersonateIfNoThrow( _Path.Buffer,
|
|
pwszVPath ) )
|
|
{
|
|
RtlFillMemory( &_finddata, sizeof WIN32_FILE_ATTRIBUTE_DATA, 0xFF );
|
|
_finddata.cAlternateFileName[0] = 0;
|
|
_Path.Length = 0;
|
|
return FALSE;
|
|
}
|
|
}
|
|
else if ( _remoteAccess.IsImpersonated() )
|
|
{
|
|
_remoteAccess.Release();
|
|
}
|
|
|
|
if ( fFast )
|
|
{
|
|
BOOL fResult;
|
|
unsigned ccPath = (_Path.Length + _Name.Length) / sizeof(WCHAR);
|
|
|
|
// handle long paths here
|
|
// we do this here instead of keeping a funnypath object all thru,
|
|
// because we get the path from the property store(in GetPath), which
|
|
// does not recognize funny paths, so we would have to do an extra
|
|
// copy operation. This we do here, but only for paths > MAX_PATH
|
|
if ( ccPath >= MAX_PATH )
|
|
{
|
|
CFunnyPath funnyPath( _Path.Buffer, ccPath );
|
|
fResult = GetFileAttributesEx( funnyPath.GetPath(), GetFileExInfoStandard, &_finddata );
|
|
}
|
|
else
|
|
{
|
|
fResult = GetFileAttributesEx( _Path.Buffer, GetFileExInfoStandard, &_finddata );
|
|
}
|
|
|
|
if ( !fResult )
|
|
{
|
|
vqDebugOut(( DEB_ERROR, "Can't retrieve fast findfirst data for %ws. Error = %d\n",
|
|
_Path.Buffer, GetLastError() ));
|
|
RtlFillMemory( &_finddata, sizeof(WIN32_FILE_ATTRIBUTE_DATA), 0xFF );
|
|
_finddata.cAlternateFileName[0] = 0;
|
|
return FALSE;
|
|
}
|
|
|
|
_fFastFindLoaded = TRUE;
|
|
_fFastStatLoaded = fsCreate | fsModify | fsAccess | fsSize | fsAttrib;
|
|
|
|
}
|
|
else
|
|
{
|
|
unsigned ccPath = (_Path.Length + _Name.Length) / sizeof(WCHAR);
|
|
HANDLE h;
|
|
|
|
//
|
|
// handle long paths here
|
|
// we do this here instead of keeping a funnypath object all thru,
|
|
// because we get the path from the property store(in GetPath), which
|
|
// does not recognize funny paths, so we would have to do an extra
|
|
// copy operation. This we do here, but only for paths > MAX_PATH
|
|
//
|
|
|
|
if ( ccPath >= MAX_PATH )
|
|
{
|
|
CFunnyPath funnyPath( _Path.Buffer, ccPath );
|
|
h = FindFirstFile( funnyPath.GetPath(), &_finddata );
|
|
}
|
|
else
|
|
{
|
|
h = FindFirstFile( _Path.Buffer, &_finddata );
|
|
}
|
|
|
|
if ( INVALID_HANDLE_VALUE == h )
|
|
{
|
|
vqDebugOut(( DEB_ERROR, "Can't retrieve findfirst data for %ws\n",
|
|
_Path.Buffer ));
|
|
RtlFillMemory( &_finddata, sizeof(WIN32_FILE_ATTRIBUTE_DATA), 0xFF );
|
|
_finddata.cAlternateFileName[0] = 0;
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
FindClose( h );
|
|
_fFindLoaded = TRUE;
|
|
_fFastFindLoaded = TRUE;
|
|
_fFastStatLoaded = fsCreate | fsModify | fsAccess | fsSize | fsAttrib;
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
} //Refresh
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCiPropRetriever::FetchI8StatProp, private
|
|
//
|
|
// Synopsis: Load stat property. Try property store before hitting file.
|
|
//
|
|
// Arguments: [fsProp] -- Fast stat bit to check.
|
|
// [pid] -- Pid of property
|
|
// [pDestination] -- resulting LONGLONG stored here.
|
|
//
|
|
// Returns: TRUE if property fetch successful *and* value in
|
|
// pDestination is valid.
|
|
//
|
|
// History: 17-Apr-96 KyleP Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
BOOL CCiPropRetriever::FetchI8StatProp( CCiPropRetriever::FastStat fsProp,
|
|
PROPID pid,
|
|
LONGLONG * pDestination )
|
|
{
|
|
Win4Assert( 0 == (_fFastStatLoaded & fsProp) );
|
|
|
|
//
|
|
// Try property store?
|
|
//
|
|
|
|
if ( 0 == (_fFastStatNeverLoad & fsProp) )
|
|
{
|
|
PROPVARIANT var;
|
|
unsigned cb = sizeof(var);
|
|
|
|
if ( FetchValue( pid, &var, &cb ) )
|
|
{
|
|
if ( var.vt == VT_EMPTY )
|
|
Refresh( TRUE );
|
|
else
|
|
{
|
|
Win4Assert( var.vt == VT_I8 || var.vt == VT_UI8 || var.vt == VT_FILETIME );
|
|
*(UNALIGNED LONGLONG *)pDestination = var.hVal.QuadPart;
|
|
return TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
_fFastStatNeverLoad |= fsProp;
|
|
Refresh( TRUE );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Win4Assert( !_fFastFindLoaded );
|
|
Refresh( TRUE );
|
|
}
|
|
|
|
return FALSE;
|
|
} //FetchI8StatProp
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCiPropRetriever::BeginPropertyRetrieval
|
|
//
|
|
// Synopsis: Prime wid for property retrieval
|
|
//
|
|
// Arguments: [wid] -- Wid to prime
|
|
//
|
|
// History: 12-Dec-96 SitaramR Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
SCODE STDMETHODCALLTYPE CCiPropRetriever::BeginPropertyRetrieval( WORKID wid )
|
|
{
|
|
//
|
|
// Check that we are not in the midst of a property retrieval
|
|
//
|
|
|
|
Win4Assert( _fFindLoaded == FALSE );
|
|
Win4Assert( _fFastFindLoaded == FALSE );
|
|
Win4Assert( _fFastStatLoaded == 0 );
|
|
Win4Assert( _fFastStatNeverLoad == 0 );
|
|
Win4Assert( _Path.Length == flagNoValueYet );
|
|
Win4Assert( _VPath.Length == flagNoValueYet );
|
|
Win4Assert( _Name.Length == flagNoValueYet );
|
|
Win4Assert( !_remoteAccess.IsImpersonated() );
|
|
Win4Assert( _widPrimedForPropRetrieval == widInvalid );
|
|
|
|
//
|
|
// wid should be valid
|
|
//
|
|
Win4Assert( wid != widInvalid );
|
|
|
|
_widPrimedForPropRetrieval = wid;
|
|
|
|
return S_OK;
|
|
} //BeginPropertyRetrieval
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCiPropRetriever::EndPropertyRetrieval
|
|
//
|
|
// Synopsis: Reset wid for property retrieval
|
|
//
|
|
// History: 12-Dec-96 SitaramR Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
SCODE STDMETHODCALLTYPE CCiPropRetriever::EndPropertyRetrieval( )
|
|
{
|
|
PurgeCachedInfo();
|
|
|
|
return CGenericPropRetriever::EndPropertyRetrieval();
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Member: CCiPropRetriever::GetName
|
|
//
|
|
// Synopsis: Return file name
|
|
//
|
|
// History: 12-Dec-96 SitaramR Created
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
UNICODE_STRING const * CCiPropRetriever::GetName()
|
|
{
|
|
//
|
|
// Retrieving Path or VPath will retrieve Name
|
|
//
|
|
|
|
if ( _Name.Length == flagNoValueYet )
|
|
GetPath();
|
|
|
|
return &_Name;
|
|
} //GetName
|
|
|
|
|
|
|
|
|
|
|