819 lines
21 KiB
C++
819 lines
21 KiB
C++
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1998 - 2000.
|
|
//
|
|
// File: FunyPath.hxx
|
|
//
|
|
// Contents: Implementation of ``Funny'' Path for long pathnames
|
|
//
|
|
// Classes: CFunnyPath
|
|
// CLowerFunnyPath
|
|
// CLowerFunnyStack
|
|
//
|
|
// Notes: This class takes in a fully qualified path. The path can be in
|
|
// two forms - C:\dir\... or \\machine\share\...
|
|
// EXCEPTION: To accomodate for scope restrictions, this class
|
|
// will also allow paths of \dir... format
|
|
// This path is converted to the "funny" form. The normal path
|
|
// takes the form of \\?\C:\dir\... and remote path takes the form
|
|
// of \\?\UNC\machine\share\... These funny paths can used by in
|
|
// functions like CreateFile to open paths > MAX_PATH
|
|
//
|
|
// History: 08-May-98 vikasman Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#pragma once
|
|
|
|
#include "lcase.hxx"
|
|
|
|
const WCHAR _FUNNY_PATH[] = L"\\\\?\\";
|
|
const WCHAR _UNC_FUNNY_PATH[] = L"\\\\?\\UN";
|
|
|
|
const _FUNNY_PATH_LENGTH = ( ( sizeof( _FUNNY_PATH ) / sizeof( WCHAR ) ) - 1 );
|
|
const _UNC_FUNNY_PATH_LENGTH = ( ( sizeof( _UNC_FUNNY_PATH ) / sizeof( WCHAR ) ) - 1 );
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Class: CFunnyPath
|
|
//
|
|
// Purpose: A path name preceeded by "\\?\" to allow file operations
|
|
// when the length of the path is > MAX_PATH.
|
|
//
|
|
// History: 08-May-98 vikasman Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
class CFunnyPath
|
|
{
|
|
public:
|
|
|
|
// used by SetState function to set the state to funny/actual
|
|
enum PathState
|
|
{
|
|
FUNNY_PATH_STATE,
|
|
ACTUAL_PATH_STATE
|
|
};
|
|
|
|
//
|
|
// Constructors, Destructors, Operators...
|
|
//
|
|
|
|
CFunnyPath( BOOL fRemote = FALSE ) :
|
|
_fRemote( fRemote ),
|
|
_ccActualBuf( 0 )
|
|
{
|
|
if ( _fRemote )
|
|
{
|
|
_xBuf.SetSize( _UNC_FUNNY_PATH_LENGTH + 1 );
|
|
_xBuf[_UNC_FUNNY_PATH_LENGTH] = 0;
|
|
}
|
|
else
|
|
{
|
|
_xBuf.SetSize( _FUNNY_PATH_LENGTH + 1 );
|
|
_xBuf[_FUNNY_PATH_LENGTH] = 0;
|
|
}
|
|
}
|
|
|
|
CFunnyPath( const WCHAR * wcsPath, unsigned cc = 0 ) :
|
|
_fRemote( FALSE ),
|
|
_ccActualBuf( 0 )
|
|
{
|
|
SetPath( wcsPath, cc );
|
|
}
|
|
|
|
CFunnyPath( CFunnyPath const & src )
|
|
{
|
|
*this = src;
|
|
}
|
|
|
|
CFunnyPath & operator =( CFunnyPath const & src )
|
|
{
|
|
_xBuf = src._xBuf;
|
|
_fRemote = src._fRemote;
|
|
_ccActualBuf = src._ccActualBuf;
|
|
|
|
return *this;
|
|
}
|
|
|
|
//
|
|
// Sets the path "wcsPath"
|
|
//
|
|
virtual void SetPath( const WCHAR * wcsPath, unsigned cc = 0 )
|
|
{
|
|
Win4Assert( wcsPath );
|
|
|
|
_ccActualBuf = ( 0 == cc ? wcslen( wcsPath ) : cc ) ;
|
|
|
|
if ( 0 == _ccActualBuf )
|
|
{
|
|
InitBlank();
|
|
return;
|
|
}
|
|
|
|
Win4Assert( _ccActualBuf > 1 ); // at least 2 characters
|
|
|
|
WCHAR * pwcActualPath;
|
|
BOOL fInvalidPath = FALSE;
|
|
|
|
if ( L'\\' != wcsPath[0] && L':' != wcsPath[1] )
|
|
// Looks like we don't have a valid path, but still
|
|
// we will continue. It's not CFunnyPath's problem
|
|
// We will treat it as a normal path
|
|
{
|
|
|
|
ciDebugOut(( DEB_ITRACE, "CFunnyPath::SetPath - The path (%ws) is not valid.\n", wcsPath ));
|
|
fInvalidPath = TRUE;
|
|
}
|
|
|
|
if ( L':' == wcsPath[1] || fInvalidPath )
|
|
{
|
|
// normal or invalid path
|
|
_fRemote = FALSE;
|
|
_xBuf.SetSize( _ccActualBuf + _FUNNY_PATH_LENGTH + 1 );
|
|
_xBuf.SetBuf( _FUNNY_PATH, _FUNNY_PATH_LENGTH );
|
|
pwcActualPath = &_xBuf[_FUNNY_PATH_LENGTH];
|
|
}
|
|
else
|
|
{
|
|
// remote path
|
|
_fRemote = TRUE;
|
|
_xBuf.SetSize( _ccActualBuf + _UNC_FUNNY_PATH_LENGTH + 1 );
|
|
_xBuf.SetBuf( _UNC_FUNNY_PATH, _UNC_FUNNY_PATH_LENGTH );
|
|
pwcActualPath = &_xBuf[_UNC_FUNNY_PATH_LENGTH];
|
|
}
|
|
RtlCopyMemory( pwcActualPath, wcsPath, _ccActualBuf * sizeof( WCHAR ) );
|
|
pwcActualPath[_ccActualBuf] = 0;
|
|
}
|
|
|
|
//
|
|
// Appends the path "wcsPath"
|
|
//
|
|
virtual void AppendPath( const WCHAR * wcsPath, unsigned cc = 0 )
|
|
{
|
|
AssertValid();
|
|
Win4Assert( wcsPath );
|
|
|
|
if ( 0 == cc )
|
|
{
|
|
cc = wcslen( wcsPath );
|
|
}
|
|
|
|
unsigned ccTotalSizeNeeded = cc + _ccActualBuf + 1;
|
|
WCHAR * pwcAppendAt;
|
|
|
|
if ( _fRemote )
|
|
{
|
|
_xBuf.SetSize( ccTotalSizeNeeded + _UNC_FUNNY_PATH_LENGTH );
|
|
pwcAppendAt = &_xBuf[_UNC_FUNNY_PATH_LENGTH + _ccActualBuf];
|
|
}
|
|
else
|
|
{
|
|
_xBuf.SetSize( ccTotalSizeNeeded + _FUNNY_PATH_LENGTH );
|
|
pwcAppendAt = &_xBuf[_FUNNY_PATH_LENGTH + _ccActualBuf];
|
|
}
|
|
RtlCopyMemory( pwcAppendAt, wcsPath, cc * sizeof( WCHAR ) );
|
|
pwcAppendAt[cc] = 0;
|
|
_ccActualBuf += cc;
|
|
}
|
|
|
|
//
|
|
// Returns the path either as funny or unc_funny which can be used in
|
|
// functions like CreateFile. Do not keep and use the pointer from
|
|
// GetPath after calling GetActualPath.
|
|
// Reason: Both these functions(even though they are const) may
|
|
// modify the internal buffer before returning data
|
|
//
|
|
const WCHAR * GetPath() const
|
|
{
|
|
AssertValid();
|
|
if ( _fRemote )
|
|
{
|
|
// need to replace \ with C
|
|
((CFunnyPath*)this)->_xBuf[_UNC_FUNNY_PATH_LENGTH] = L'C';
|
|
}
|
|
return _xBuf.Get();
|
|
}
|
|
|
|
//
|
|
// Returns the "actual path". Do not keep and use the pointer from
|
|
// GetActualPath after calling GetPath. Reason: Both these functions
|
|
// (even though they are const) may modify the internal buffer before
|
|
// returning data
|
|
//
|
|
const WCHAR * GetActualPath() const
|
|
{
|
|
return _GetActualPath();
|
|
}
|
|
|
|
//
|
|
// Sets the state of the path to actual/funny
|
|
//
|
|
void SetState( const PathState state )
|
|
{
|
|
if ( _fRemote )
|
|
{
|
|
_xBuf[_UNC_FUNNY_PATH_LENGTH] =
|
|
( FUNNY_PATH_STATE == state ? L'C' : L'\\' );
|
|
}
|
|
}
|
|
|
|
//
|
|
// Returns the actual length of characters
|
|
//
|
|
unsigned GetActualLength() const
|
|
{
|
|
return _ccActualBuf;
|
|
}
|
|
|
|
//
|
|
// Returns the total length
|
|
//
|
|
unsigned GetLength() const
|
|
{
|
|
return ( _ccActualBuf +
|
|
(_fRemote ? _UNC_FUNNY_PATH_LENGTH : _FUNNY_PATH_LENGTH) );
|
|
}
|
|
|
|
//
|
|
// Appends back slash
|
|
//
|
|
BOOL AppendBackSlash()
|
|
{
|
|
WCHAR * pwcsActualPath = _GetActualPath();
|
|
|
|
if ( 0 == _ccActualBuf || L'\\' == pwcsActualPath[_ccActualBuf - 1] )
|
|
{
|
|
return FALSE;
|
|
}
|
|
AppendPath( L"\\", 1 );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Removes back slash
|
|
//
|
|
BOOL RemoveBackSlash()
|
|
{
|
|
WCHAR * pwcsActualPath = _GetActualPath();
|
|
|
|
if ( 0 == _ccActualBuf || L'\\' != pwcsActualPath[_ccActualBuf - 1] )
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
pwcsActualPath[--_ccActualBuf] = 0;
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Truncates the buf to ccNewLength (this is the "actual char.", excluding
|
|
// funny path prefix, length)
|
|
//
|
|
void Truncate( unsigned ccNewLength )
|
|
{
|
|
if ( ccNewLength < _ccActualBuf )
|
|
{
|
|
WCHAR * pwcActualPath = _GetActualPath();
|
|
pwcActualPath[ _ccActualBuf = ccNewLength ] = 0;
|
|
}
|
|
}
|
|
|
|
BOOL IsRemote () const
|
|
{
|
|
return _fRemote;
|
|
}
|
|
|
|
//
|
|
// returns TRUE if any component in the path looks like the short version
|
|
// of a long file name.
|
|
//
|
|
BOOL IsShortPath () const;
|
|
static BOOL IsShortName( WCHAR const * const pwszName );
|
|
|
|
//
|
|
// Returns the count of all the characters in xBuf
|
|
//
|
|
unsigned Count() const
|
|
{
|
|
return _xBuf.Count();
|
|
}
|
|
|
|
//
|
|
// Set the size of _xBuf
|
|
//
|
|
void SetSize( unsigned cc )
|
|
{
|
|
_xBuf.SetSize( cc );
|
|
}
|
|
|
|
//
|
|
// Get the internal buffer
|
|
//
|
|
const WCHAR * GetBuffer() const
|
|
{
|
|
return _xBuf.Get();
|
|
}
|
|
|
|
//
|
|
// This is a dangerous function as it exposes the internal buffer
|
|
//
|
|
WCHAR * GetBuffer()
|
|
{
|
|
return _xBuf.Get();
|
|
}
|
|
|
|
// This path initializes the internal buffer with empty actual path
|
|
void InitBlank( BOOL fRemote = FALSE )
|
|
{
|
|
_fRemote = fRemote;
|
|
if ( _fRemote )
|
|
{
|
|
_xBuf.SetBuf( _UNC_FUNNY_PATH, _UNC_FUNNY_PATH_LENGTH + 1 );
|
|
}
|
|
else
|
|
{
|
|
_xBuf.SetBuf( _FUNNY_PATH, _FUNNY_PATH_LENGTH + 1 );
|
|
}
|
|
_ccActualBuf = 0;
|
|
}
|
|
|
|
#if CIDBG==1
|
|
//
|
|
// Asserts that we are in good state
|
|
//
|
|
void AssertValid() const
|
|
{
|
|
const WCHAR * pwcsFunny = _xBuf.Get();
|
|
Win4Assert( pwcsFunny &&
|
|
L'\\' == pwcsFunny[0] && L'\\' == pwcsFunny[1] &&
|
|
L'?' == pwcsFunny[2] && L'\\' == pwcsFunny[3] );
|
|
|
|
Win4Assert( L':' == pwcsFunny[5] || L'N' == pwcsFunny[5] ||
|
|
L'n' == pwcsFunny[5] );
|
|
|
|
}
|
|
#else
|
|
|
|
void AssertValid() const {}
|
|
|
|
#endif
|
|
|
|
//
|
|
// Some static utility functions
|
|
//
|
|
enum FunnyUNC
|
|
{
|
|
NOT_FUNNY, // not funny
|
|
FUNNY_ONLY, // of type \\?\c:\dir\...
|
|
FUNNY_UNC // of type \\?\unc\...
|
|
};
|
|
|
|
static inline BOOL IsFunnyPath( WCHAR const * pwcsPath )
|
|
{
|
|
return ( pwcsPath &&
|
|
L'\\' == pwcsPath[0] &&
|
|
L'\\' == pwcsPath[1] &&
|
|
L'?' == pwcsPath[2] &&
|
|
L'\\' == pwcsPath[3] );
|
|
}
|
|
|
|
static inline FunnyUNC IsFunnyUNCPath( WCHAR const * pwcsPath )
|
|
{
|
|
// The 6th char here can also be as '\\' (instead of being c/C) as
|
|
// this class modifies that charatcter to be a '\\'.
|
|
return ( FALSE == IsFunnyPath( pwcsPath ) ?
|
|
NOT_FUNNY :
|
|
( ( (L'U' == pwcsPath[4] || L'u' == pwcsPath[4]) &&
|
|
(L'N' == pwcsPath[5] || L'n' == pwcsPath[5]) &&
|
|
(L'C' == pwcsPath[6] || L'c' == pwcsPath[6] || L'\\' == pwcsPath[6]) &&
|
|
(L'\\' == pwcsPath[7] ) ) ?
|
|
FUNNY_UNC :
|
|
FUNNY_ONLY ) );
|
|
}
|
|
|
|
protected:
|
|
|
|
WCHAR * _GetActualPath() const
|
|
{
|
|
WCHAR * pwcsActualPath;
|
|
|
|
if ( _fRemote )
|
|
{
|
|
pwcsActualPath = &(((CFunnyPath*)this)->_xBuf[_UNC_FUNNY_PATH_LENGTH]);
|
|
|
|
// need to replace C with "\"
|
|
*pwcsActualPath = L'\\';
|
|
}
|
|
else
|
|
{
|
|
pwcsActualPath = &(((CFunnyPath*)this)->_xBuf[_FUNNY_PATH_LENGTH]);
|
|
}
|
|
return pwcsActualPath;
|
|
}
|
|
|
|
BOOL _fRemote; // Is the path remote ?
|
|
unsigned _ccActualBuf; // number of actual characters in _xBuf
|
|
// (excluding _FUNNY_PATH/_UNC_FUNNY_PATH)
|
|
XGrowable<WCHAR> _xBuf;
|
|
};
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CFunnyPath::IsShortName, static public
|
|
//
|
|
// Arguments: [pwszName] -- name to be checked (only a single path component
|
|
// is checked at a time)
|
|
//
|
|
// Returns: TRUE if file is potentially a short (8.3) name for
|
|
// a file with a long name.
|
|
//
|
|
// History: 01-Sep-1998 AlanW Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline BOOL CFunnyPath::IsShortName( WCHAR const * const pwszName )
|
|
{
|
|
//
|
|
// First, see if this is possibly a short name (has ~ in file name part).
|
|
//
|
|
|
|
BOOL fTwiddle = FALSE;
|
|
unsigned cDot = 0;
|
|
|
|
for ( unsigned cchFN = 0; cchFN < 13; cchFN++ )
|
|
{
|
|
if ( pwszName[cchFN] == L'~' && cchFN >= 1 )
|
|
fTwiddle = TRUE;
|
|
else if ( pwszName[cchFN] == L'.' )
|
|
{
|
|
if (cchFN == 0 || cchFN > 8)
|
|
return FALSE; // short names can't have '.' at beginning
|
|
cDot++;
|
|
}
|
|
else if ( pwszName[cchFN] == L'\0' || pwszName[cchFN] == L'\\' )
|
|
break;
|
|
|
|
cchFN++;
|
|
}
|
|
|
|
if (fTwiddle)
|
|
{
|
|
// short names can't have more than 1 '.'
|
|
// max filename size if no extension is 8
|
|
if (cDot >= 2 || cDot == 0 && cchFN > 8)
|
|
return FALSE;
|
|
|
|
// check for min (e.g., EXT~1 for .ext) and max lengths
|
|
if (cchFN >= 5 && cchFN <= 12)
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Method: CFunnyPath::IsShortPath, public
|
|
//
|
|
// Arguments: - none -
|
|
//
|
|
// Returns: TRUE if the path name potentially contains a short (8.3) name
|
|
// for a file with a long name.
|
|
//
|
|
// History: 15-Sep-1998 AlanW Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline BOOL CFunnyPath::IsShortPath() const
|
|
{
|
|
//
|
|
// Check to see if the input path name contains an 8.3 short name
|
|
//
|
|
WCHAR * pwszTilde = wcschr( GetActualPath(), L'~' );
|
|
|
|
if (pwszTilde)
|
|
{
|
|
WCHAR * pwszComponent;
|
|
for ( pwszComponent = wcschr( GetActualPath(), L'\\' );
|
|
pwszComponent;
|
|
pwszComponent = wcschr( pwszComponent, L'\\' ) )
|
|
{
|
|
pwszComponent++;
|
|
pwszTilde = wcschr( pwszComponent, L'~' );
|
|
if ( 0 == pwszTilde || pwszTilde - pwszComponent > 13)
|
|
continue;
|
|
if (IsShortName( pwszComponent ))
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Class: CFunnyPath
|
|
//
|
|
// Purpose: A path name preceeded by "\\?\" to allow file operations when
|
|
// the length of the path is > MAX_PATH. Keeps the FunnyPath in
|
|
// lower case.
|
|
//
|
|
// History: 08-May-98 vikasman Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
class CLowerFunnyPath : public CFunnyPath
|
|
{
|
|
public:
|
|
|
|
CLowerFunnyPath( BOOL fRemote = FALSE ) :
|
|
CFunnyPath( fRemote )
|
|
{
|
|
}
|
|
|
|
CLowerFunnyPath( const CLowerFunnyPath & src )
|
|
{
|
|
*this = src;
|
|
}
|
|
|
|
CLowerFunnyPath( const WCHAR * wcsPath,
|
|
unsigned cc = 0,
|
|
BOOL fNoConvert = FALSE ) :
|
|
CFunnyPath()
|
|
{
|
|
SetPath( wcsPath, cc, fNoConvert );
|
|
}
|
|
|
|
CLowerFunnyPath & operator =( CLowerFunnyPath const & src )
|
|
{
|
|
CFunnyPath::operator=( (CFunnyPath&)src );
|
|
return *this;
|
|
}
|
|
|
|
virtual void SetPath( const WCHAR * wcsPath,
|
|
unsigned cc = 0,
|
|
BOOL fNoConvert = FALSE );
|
|
|
|
virtual void AppendPath( const WCHAR * wcsPath,
|
|
unsigned cc = 0,
|
|
BOOL fNoConvert = FALSE );
|
|
|
|
BOOL ConvertToLongName();
|
|
|
|
private:
|
|
|
|
//
|
|
// Converts to wcsPath of length cc to lower case and puts it in
|
|
// _xBuf starting from ccStart index (actual)
|
|
//
|
|
void ToLower( const WCHAR * wcsPath, unsigned cc, unsigned ccStart = 0 );
|
|
|
|
};
|
|
|
|
inline void CLowerFunnyPath::SetPath(
|
|
const WCHAR * wcsPath,
|
|
unsigned cc,
|
|
BOOL fNoConvert )
|
|
{
|
|
if ( fNoConvert )
|
|
{
|
|
// already lower case
|
|
CFunnyPath::SetPath( wcsPath, cc );
|
|
AssertLowerCase( GetActualPath(), GetActualLength() );
|
|
return;
|
|
}
|
|
|
|
Win4Assert( wcsPath );
|
|
|
|
cc = ( 0 == cc ? wcslen( wcsPath ) : cc ) ;
|
|
|
|
if ( 0 == cc )
|
|
{
|
|
InitBlank();
|
|
return;
|
|
}
|
|
|
|
BOOL fInvalidPath = FALSE;
|
|
if ( L'\\' != wcsPath[0] && L':' != wcsPath[1] )
|
|
{
|
|
// Looks like we don't have a valid path, but still
|
|
// we will continue. It's not CFunnyPath's problem
|
|
// We will treat it as a normal path
|
|
|
|
ciDebugOut(( DEB_ITRACE,
|
|
"CLowerFunnyPath::SetPath - path (%ws) is not valid.\n",
|
|
wcsPath ));
|
|
fInvalidPath = TRUE;
|
|
}
|
|
|
|
if ( L':' == wcsPath[1] || fInvalidPath )
|
|
{
|
|
// normal or invalid path
|
|
_fRemote = FALSE;
|
|
_xBuf.SetBuf( _FUNNY_PATH, _FUNNY_PATH_LENGTH + 1 );
|
|
}
|
|
else
|
|
{
|
|
// remote path
|
|
_fRemote = TRUE;
|
|
_xBuf.SetBuf( _UNC_FUNNY_PATH, _UNC_FUNNY_PATH_LENGTH + 1 );
|
|
}
|
|
ToLower( wcsPath, cc );
|
|
}
|
|
|
|
inline void CLowerFunnyPath::AppendPath(
|
|
const WCHAR * wcsPath,
|
|
unsigned cc,
|
|
BOOL fNoConvert )
|
|
{
|
|
if ( fNoConvert )
|
|
{
|
|
// already lower case
|
|
CFunnyPath::AppendPath( wcsPath, cc );
|
|
AssertLowerCase( GetActualPath(), GetActualLength() );
|
|
return;
|
|
}
|
|
|
|
AssertValid();
|
|
Win4Assert( wcsPath );
|
|
|
|
if ( 0 == cc )
|
|
{
|
|
cc = wcslen( wcsPath );
|
|
}
|
|
|
|
ToLower( wcsPath, cc, _ccActualBuf );
|
|
}
|
|
|
|
inline void CLowerFunnyPath::ToLower(
|
|
const WCHAR * wcsPath,
|
|
unsigned cc,
|
|
unsigned ccStart )
|
|
{
|
|
WCHAR * pwcDestActualPath;
|
|
unsigned ccDestActualCount;
|
|
|
|
Win4Assert( wcsPath );
|
|
if ( !cc )
|
|
{
|
|
return;
|
|
}
|
|
|
|
#if CIDBG == 1
|
|
// Variable to try lowercasing again due to some random
|
|
// failures with LCMapStringW
|
|
BOOL fTryAgain = TRUE;
|
|
#endif
|
|
while ( TRUE )
|
|
{
|
|
if ( _fRemote )
|
|
{
|
|
pwcDestActualPath = &_xBuf[_UNC_FUNNY_PATH_LENGTH] + ccStart;
|
|
ccDestActualCount = _xBuf.Count() - (_UNC_FUNNY_PATH_LENGTH + ccStart);
|
|
}
|
|
else
|
|
{
|
|
pwcDestActualPath = &_xBuf[_FUNNY_PATH_LENGTH] + ccStart;
|
|
ccDestActualCount = _xBuf.Count() - (_FUNNY_PATH_LENGTH + ccStart);
|
|
}
|
|
|
|
if ( ccDestActualCount < 2 )
|
|
{
|
|
// Need to allocate more memory
|
|
_xBuf.SetSize( _xBuf.Count() * 2 );
|
|
continue;
|
|
}
|
|
|
|
unsigned cchLen = LCMapStringW ( LOCALE_NEUTRAL,
|
|
LCMAP_LOWERCASE,
|
|
wcsPath,
|
|
cc,
|
|
pwcDestActualPath,
|
|
ccDestActualCount - 1 );
|
|
|
|
if ( 0 == cchLen )
|
|
{
|
|
if ( GetLastError() == ERROR_INSUFFICIENT_BUFFER )
|
|
{
|
|
_xBuf.SetSize( _xBuf.Count() * 2 );
|
|
}
|
|
else
|
|
{
|
|
ciDebugOut(( DEB_ERROR, "Error 0x%x lowercasing path\n", GetLastError() ));
|
|
#if CIDBG == 1
|
|
if ( fTryAgain )
|
|
{
|
|
fTryAgain = FALSE;
|
|
Win4Assert(( !"neutral lowercase failed. Trying again..." ));
|
|
continue;
|
|
}
|
|
#endif
|
|
Win4Assert(( !"neutral lowercase failed" ));
|
|
THROW( CException() );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Win4Assert( cchLen < ccDestActualCount );
|
|
pwcDestActualPath[ cchLen ] = 0;
|
|
_ccActualBuf = ccStart + cchLen;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CLowerFunnyPath::ConvertToLongName, public
|
|
//
|
|
// Synopsis: Converts file path name components to long names.
|
|
//
|
|
// Returns: TRUE if conversion was successful.
|
|
//
|
|
// Notes: GetLongPathNameW will fail with remote funny paths because
|
|
// it will try to call FindFirstFileW on the machine name and
|
|
// share name.
|
|
//
|
|
// History: 06-Jan-98 KyleP Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
inline BOOL CLowerFunnyPath::ConvertToLongName()
|
|
{
|
|
XGrowable<WCHAR> wcsTemp;
|
|
|
|
WCHAR * pwcsShortName;
|
|
unsigned ccFunnyChars;
|
|
|
|
if (IsRemote())
|
|
{
|
|
pwcsShortName = _GetActualPath();
|
|
ccFunnyChars = 0;
|
|
}
|
|
else
|
|
{
|
|
pwcsShortName = (WCHAR *)GetPath();
|
|
ccFunnyChars = _FUNNY_PATH_LENGTH;
|
|
}
|
|
|
|
DWORD ccOut = GetLongPathNameW( pwcsShortName, // Short name
|
|
wcsTemp.Get(), // Long name
|
|
wcsTemp.Count() - 1 );
|
|
|
|
if ( ccOut > wcsTemp.Count() - 1 )
|
|
{
|
|
// Need to grow the buffer
|
|
wcsTemp.SetSize( ccOut + 1 );
|
|
ccOut = GetLongPathNameW( pwcsShortName, // Short name
|
|
wcsTemp.Get(), // Long name
|
|
wcsTemp.Count() - 1 );
|
|
Win4Assert( ccOut <= wcsTemp.Count() - 1 );
|
|
}
|
|
|
|
if ( 0 == ccOut )
|
|
{
|
|
ciDebugOut(( DEB_WARN, "GetLongPathName( %ws ) returned %d\n",
|
|
pwcsShortName, GetLastError() ));
|
|
return FALSE;
|
|
}
|
|
|
|
SetPath( wcsTemp.Get() + ccFunnyChars, ccOut - ccFunnyChars );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Stack class for FunnyPath
|
|
//
|
|
|
|
DECL_DYNSTACK( _CLowerFunnyStack, CLowerFunnyPath )
|
|
|
|
class CLowerFunnyStack : protected _CLowerFunnyStack
|
|
{
|
|
public:
|
|
|
|
BOOL Pop( XPtr<CLowerFunnyPath> & xLowerFunnyPath )
|
|
{
|
|
if (Count() == 0)
|
|
{
|
|
return FALSE;
|
|
}
|
|
xLowerFunnyPath.Set( _CLowerFunnyStack::Pop() );
|
|
return TRUE;
|
|
}
|
|
|
|
void Push( const CLowerFunnyPath & funnyElem )
|
|
{
|
|
XPtr<CLowerFunnyPath> xLowerFunnyPath( new CLowerFunnyPath(funnyElem) );
|
|
_CLowerFunnyStack::Push( xLowerFunnyPath.GetPointer() );
|
|
xLowerFunnyPath.Acquire();
|
|
}
|
|
|
|
};
|
|
|