3764 lines
120 KiB
C++
3764 lines
120 KiB
C++
|
//*************************************************************
|
||
|
|
//
|
||
|
|
// Copyright (c) Microsoft Corporation 1998
|
||
|
|
// All rights reserved
|
||
|
|
//
|
||
|
|
// util.cxx
|
||
|
|
//
|
||
|
|
//*************************************************************
|
||
|
|
|
||
|
|
#include "fdeploy.hxx"
|
||
|
|
|
||
|
|
WCHAR* NTPrivs[] = {
|
||
|
|
/*SE_CREATE_TOKEN_NAME,
|
||
|
|
SE_ASSIGNPRIMARYTOKEN_NAME,
|
||
|
|
SE_LOCK_MEMORY_NAME,
|
||
|
|
SE_INCREASE_QUOTA_NAME,
|
||
|
|
SE_UNSOLICITED_INPUT_NAME,
|
||
|
|
SE_MACHINE_ACCOUNT_NAME,
|
||
|
|
SE_TCB_NAME,
|
||
|
|
SE_SECURITY_NAME,*/
|
||
|
|
SE_TAKE_OWNERSHIP_NAME, //we only need take ownership privileges
|
||
|
|
/*SE_LOAD_DRIVER_NAME,
|
||
|
|
SE_SYSTEM_PROFILE_NAME,
|
||
|
|
SE_SYSTEMTIME_NAME,
|
||
|
|
SE_PROF_SINGLE_PROCESS_NAME,
|
||
|
|
SE_INC_BASE_PRIORITY_NAME,
|
||
|
|
SE_CREATE_PAGEFILE_NAME,
|
||
|
|
SE_CREATE_PERMANENT_NAME,
|
||
|
|
SE_BACKUP_NAME,*/
|
||
|
|
SE_RESTORE_NAME, //we only need to be able to assign owners
|
||
|
|
/*SE_SHUTDOWN_NAME,
|
||
|
|
SE_DEBUG_NAME,
|
||
|
|
SE_AUDIT_NAME,
|
||
|
|
SE_SYSTEM_ENVIRONMENT_NAME,
|
||
|
|
SE_CHANGE_NOTIFY_NAME,
|
||
|
|
SE_REMOTE_SHUTDOWN_NAME,*/
|
||
|
|
L"\0"
|
||
|
|
};
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Member: CCopyFailData::CCopyFailData
|
||
|
|
//
|
||
|
|
// Synopsis: constructor for the object that contains data about
|
||
|
|
// copy failures.
|
||
|
|
//
|
||
|
|
// Arguments: none.
|
||
|
|
//
|
||
|
|
// Returns: nothing.
|
||
|
|
//
|
||
|
|
// History: 1/25/2000 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
CCopyFailData::CCopyFailData () : m_bCopyFailed (FALSE), m_dwSourceBufLen (0),
|
||
|
|
m_pwszSourceName (NULL), m_dwDestBufLen (0),
|
||
|
|
m_pwszDestName (NULL)
|
||
|
|
{
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Member: CCopyFailData::~CCopyFailData
|
||
|
|
//
|
||
|
|
// Synopsis: destructor for the object that contains data about the last
|
||
|
|
// copy failure
|
||
|
|
//
|
||
|
|
// Arguments: none.
|
||
|
|
//
|
||
|
|
// Returns: nothing.
|
||
|
|
//
|
||
|
|
// History: 1/25/2000 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
CCopyFailData::~CCopyFailData ()
|
||
|
|
{
|
||
|
|
if (m_dwSourceBufLen)
|
||
|
|
delete [] m_pwszSourceName;
|
||
|
|
|
||
|
|
if (m_dwDestBufLen)
|
||
|
|
delete [] m_pwszDestName;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Member: CCopyFailData::RegisterFailure
|
||
|
|
//
|
||
|
|
// Synopsis: registers information about a failed copy.
|
||
|
|
//
|
||
|
|
// Arguments: [in] pwszSource : the source file for the copy.
|
||
|
|
// [in] pwszDest : the destination file for the copy.
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS : on succesful registration.
|
||
|
|
// an error code otherwise.
|
||
|
|
//
|
||
|
|
// History: 1/25/2000 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: if another failure has already been registered in this
|
||
|
|
// object, it is not overwritten with the new info. We only
|
||
|
|
// keep track of the first failure. Since folder redirection
|
||
|
|
// anyway bails out on the first copy failure, we don't really
|
||
|
|
// expect this function to be called more than once.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD CCopyFailData::RegisterFailure (LPCTSTR pwszSource, LPCTSTR pwszDest)
|
||
|
|
{
|
||
|
|
DWORD dwStatus = ERROR_SUCCESS;
|
||
|
|
DWORD dwFromLen = 0;
|
||
|
|
DWORD dwToLen = 0;
|
||
|
|
|
||
|
|
//bail out if another copy failure has already been registered.
|
||
|
|
if (m_bCopyFailed)
|
||
|
|
return dwStatus;
|
||
|
|
|
||
|
|
//first copy the source info.
|
||
|
|
dwFromLen = wcslen (pwszSource);
|
||
|
|
if (dwFromLen >= m_dwSourceBufLen)
|
||
|
|
{
|
||
|
|
//we need a bigger buffer.
|
||
|
|
delete [] m_pwszSourceName;
|
||
|
|
m_dwSourceBufLen = 0;
|
||
|
|
m_pwszSourceName = new WCHAR [dwFromLen + 1];
|
||
|
|
if (m_pwszSourceName)
|
||
|
|
m_dwSourceBufLen = dwFromLen + 1;
|
||
|
|
else
|
||
|
|
dwStatus = ERROR_OUTOFMEMORY;
|
||
|
|
}
|
||
|
|
if (ERROR_SUCCESS == dwStatus)
|
||
|
|
wcscpy (m_pwszSourceName, pwszSource);
|
||
|
|
|
||
|
|
//now copy the destination info.
|
||
|
|
if (ERROR_SUCCESS == dwStatus)
|
||
|
|
{
|
||
|
|
dwToLen = wcslen (pwszDest);
|
||
|
|
if (dwToLen >= m_dwDestBufLen)
|
||
|
|
{
|
||
|
|
//we need a bigger buffer
|
||
|
|
delete [] m_pwszDestName;
|
||
|
|
m_dwDestBufLen = 0;
|
||
|
|
m_pwszDestName = new WCHAR [dwToLen + 1];
|
||
|
|
if (m_pwszDestName)
|
||
|
|
m_dwDestBufLen = dwToLen + 1;
|
||
|
|
else
|
||
|
|
dwStatus = ERROR_OUTOFMEMORY;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ERROR_SUCCESS == dwStatus)
|
||
|
|
wcscpy (m_pwszDestName, pwszDest);
|
||
|
|
|
||
|
|
//register the fact that the copy fail data has been
|
||
|
|
//successfully incorporated into the object
|
||
|
|
if (ERROR_SUCCESS == dwStatus)
|
||
|
|
m_bCopyFailed = TRUE;
|
||
|
|
|
||
|
|
return dwStatus;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Member: CCopyFailData::IsCopyFailure
|
||
|
|
//
|
||
|
|
// Synopsis: indicates if copy failure data exists within the object.
|
||
|
|
//
|
||
|
|
// Arguments: none.
|
||
|
|
//
|
||
|
|
// Returns: TRUE / FALSE : self-explanatory
|
||
|
|
//
|
||
|
|
// History: 1/25/2000 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
BOOL CCopyFailData::IsCopyFailure (void)
|
||
|
|
{
|
||
|
|
return m_bCopyFailed;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Member: CCopyFailData::GetSourceName
|
||
|
|
//
|
||
|
|
// Synopsis: gets the name of the source file of the failed copy.
|
||
|
|
//
|
||
|
|
// Arguments: none.
|
||
|
|
//
|
||
|
|
// Returns: name of the source file of the failed copy.
|
||
|
|
//
|
||
|
|
// History: 1/25/2000 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: returns NULL if the data does not exist or if a
|
||
|
|
// copy failure has not been incorporated into the object
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
LPCTSTR CCopyFailData::GetSourceName (void)
|
||
|
|
{
|
||
|
|
if (! m_bCopyFailed)
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
if (! m_dwSourceBufLen)
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
return m_pwszSourceName;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Member: CCopyFailData::GetDestName
|
||
|
|
//
|
||
|
|
// Synopsis: gets the name of the destination file of the failed copy.
|
||
|
|
//
|
||
|
|
// Arguments: none.
|
||
|
|
//
|
||
|
|
// Returns: name of the destination file of the failed copy.
|
||
|
|
//
|
||
|
|
// History: 1/25/2000 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: returns NULL if the data does not exist or if a copy failure
|
||
|
|
// has not been incorporated into the object.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
LPCTSTR CCopyFailData::GetDestName (void)
|
||
|
|
{
|
||
|
|
if (! m_bCopyFailed)
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
if (! m_dwDestBufLen)
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
return m_pwszDestName;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: IsOnNTFS
|
||
|
|
//
|
||
|
|
// Synopsis: this function determines whether a given file/folder lies
|
||
|
|
// on an NTFS volume or not.
|
||
|
|
//
|
||
|
|
// Arguments: [in] pwszPath : the full pathname of the file.
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS : if it is on NTFS
|
||
|
|
// ERROR_NO_SECURITY_ON_OBJECT : if it is on FAT
|
||
|
|
// other error codes if something goes wrong
|
||
|
|
//
|
||
|
|
// History: 9/4/1998 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
// 1. the full pathname is required in order to determine
|
||
|
|
// if the file/folder is on an NTFS volume
|
||
|
|
// 2. If the file/folder lies on a network share, then the
|
||
|
|
// share must be online when this function is executed.
|
||
|
|
// if it is offline and CSC is turned on, then even NTFS
|
||
|
|
// volumes will show up as FAT volumes.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD IsOnNTFS (const WCHAR* pwszPath)
|
||
|
|
{
|
||
|
|
WCHAR* szName = 0;
|
||
|
|
DWORD Status;
|
||
|
|
size_t len;
|
||
|
|
BOOL bAddSlash = FALSE;
|
||
|
|
BOOL bStatus;
|
||
|
|
DWORD dwFlags;
|
||
|
|
WCHAR* szLastSlash;
|
||
|
|
WCHAR* pwszSuccess = NULL;
|
||
|
|
|
||
|
|
// Basic sanity checks
|
||
|
|
if (NULL == pwszPath || L'\0' == *pwszPath)
|
||
|
|
{
|
||
|
|
return ERROR_BAD_PATHNAME;
|
||
|
|
}
|
||
|
|
|
||
|
|
//GetVolumeInformation requires its 1st argument to be terminated by a slash
|
||
|
|
//so we first make sure that this is the case.
|
||
|
|
len = wcslen (pwszPath);
|
||
|
|
if ('\\' != pwszPath[len-1])
|
||
|
|
{
|
||
|
|
len++;
|
||
|
|
bAddSlash = TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
szName = (WCHAR*) alloca ((len + 1)*sizeof(WCHAR));
|
||
|
|
if (0 == szName)
|
||
|
|
return ERROR_OUTOFMEMORY;
|
||
|
|
|
||
|
|
//obtain the absolute path
|
||
|
|
pwszSuccess = _wfullpath (szName, pwszPath, len + 1);
|
||
|
|
|
||
|
|
if (!pwszSuccess)
|
||
|
|
{
|
||
|
|
return ERROR_BAD_PATHNAME; //_wfullpath will very rarely fail, but
|
||
|
|
//never hurts to take precautions
|
||
|
|
}
|
||
|
|
|
||
|
|
if (bAddSlash)
|
||
|
|
{
|
||
|
|
szName[len] = '\0';
|
||
|
|
szName[len-1] = '\\';
|
||
|
|
}
|
||
|
|
//now our path name is terminated by a slash, and we have the absolute path
|
||
|
|
//too, so we don't have to worry about errors generating from weird paths
|
||
|
|
//like \\server\share\hello\..\.\ etc...
|
||
|
|
|
||
|
|
for (szLastSlash = szName + len - 1;;)
|
||
|
|
{
|
||
|
|
bStatus = GetVolumeInformation (szName, 0, 0, 0, 0, &dwFlags, 0, 0);
|
||
|
|
if (!bStatus)
|
||
|
|
{
|
||
|
|
Status = GetLastError();
|
||
|
|
if (ERROR_DIR_NOT_ROOT != Status)
|
||
|
|
{
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//GetVolumeInformation requires that the path provided to it be
|
||
|
|
//the root of the volume. So if we are here, it means that the
|
||
|
|
//function returned ERROR_DIR_NOT_ROOT. So we remove the last
|
||
|
|
//component from the path and try with the smaller path. We repeat
|
||
|
|
//this until we either succeed or end up with no path in which
|
||
|
|
//case we return ERROR_INVALID_NAME
|
||
|
|
*szLastSlash = '\0';
|
||
|
|
szLastSlash = wcsrchr (szName, '\\');
|
||
|
|
if (NULL == szLastSlash)
|
||
|
|
return ERROR_INVALID_NAME; //we have run out of components
|
||
|
|
else
|
||
|
|
szLastSlash[1] = '\0'; //get rid of the last component.
|
||
|
|
}
|
||
|
|
else
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (dwFlags & FS_PERSISTENT_ACLS)
|
||
|
|
return ERROR_SUCCESS; //NTFS supports persistent ACLs
|
||
|
|
|
||
|
|
//if we are here, then GetVolumeInformation succeeded, but the volume
|
||
|
|
//does not support persistent ACLs. So it must be a FAT volume.
|
||
|
|
return ERROR_NO_SECURITY_ON_OBJECT;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: ModifyAccessAllowedAceCounts
|
||
|
|
//
|
||
|
|
// Synopsis: given an ace, this function determines if the rights of this
|
||
|
|
// ace apply to the object itself, propogates to its container
|
||
|
|
// descendants and propogates to its non-container (or object)
|
||
|
|
// descendants. It increments one or more of the provided counts
|
||
|
|
// based on this.
|
||
|
|
//
|
||
|
|
// Arguments: [in] pAceHeader : pointer to the ACE header structure
|
||
|
|
// [in,out] pCount : pointer to count which is incremented if the
|
||
|
|
// ACE applies to the object on whose ACL it is
|
||
|
|
// found
|
||
|
|
// [in,out] pContainerCount : pointer to count which is incremented
|
||
|
|
// if the ACE propagates to all
|
||
|
|
// container descendants
|
||
|
|
// [in,out] pObjectCount : pointer to count which is incremented if
|
||
|
|
// the ACE propagates to all non-container
|
||
|
|
// descendants
|
||
|
|
//
|
||
|
|
// Returns: nothing
|
||
|
|
//
|
||
|
|
// History: 9/4/1998 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: inheritance of the ace is not counted if the
|
||
|
|
// NO_PROPAGATE_INHERIT_ACE flag is present.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
void
|
||
|
|
ModifyAccessAllowedAceCounts (
|
||
|
|
PACE_HEADER pAceHeader, LONG* pCount,
|
||
|
|
LONG* pContainerCount, LONG* pObjectCount
|
||
|
|
)
|
||
|
|
{
|
||
|
|
if (! (INHERIT_ONLY_ACE & pAceHeader->AceFlags))
|
||
|
|
(*pCount)++;
|
||
|
|
|
||
|
|
if (NO_PROPAGATE_INHERIT_ACE & pAceHeader->AceFlags)
|
||
|
|
return; //the rights of this Ace will not be propagated all the way
|
||
|
|
|
||
|
|
if (CONTAINER_INHERIT_ACE & pAceHeader->AceFlags)
|
||
|
|
(*pContainerCount)++;
|
||
|
|
|
||
|
|
if (OBJECT_INHERIT_ACE & pAceHeader->AceFlags)
|
||
|
|
(*pObjectCount)++;
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: RestrictMyDocsRedirection
|
||
|
|
//
|
||
|
|
// Synopsis: Disables/Enables the ability of users to redirect the
|
||
|
|
// "My Documents" folder
|
||
|
|
//
|
||
|
|
// Arguments: [in] fRestrict : Disable if TRUE, Enable if FALSE
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS : on success
|
||
|
|
// *OR* other Win32 error codes based on the error that occurred
|
||
|
|
//
|
||
|
|
// History: 8/25/1998 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD RestrictMyDocsRedirection (
|
||
|
|
HANDLE hToken,
|
||
|
|
HKEY hKeyRoot,
|
||
|
|
BOOL fRestrict
|
||
|
|
)
|
||
|
|
{
|
||
|
|
HKEY hkRoot;
|
||
|
|
HANDLE hUserToken;
|
||
|
|
HKEY hkPolicies;
|
||
|
|
HKEY hkExplorer;
|
||
|
|
DWORD Status;
|
||
|
|
|
||
|
|
hkRoot = hKeyRoot;
|
||
|
|
hUserToken = hToken;
|
||
|
|
|
||
|
|
//
|
||
|
|
// This policies key is secured, so we must do this as LocalSystem.
|
||
|
|
//
|
||
|
|
RevertToSelf();
|
||
|
|
|
||
|
|
Status = RegCreateKeyEx(
|
||
|
|
hkRoot,
|
||
|
|
L"Software\\Microsoft\\Windows\\CurrentVersion\\Policies",
|
||
|
|
0,
|
||
|
|
NULL,
|
||
|
|
REG_OPTION_NON_VOLATILE,
|
||
|
|
KEY_READ | KEY_WRITE,
|
||
|
|
NULL,
|
||
|
|
&hkPolicies,
|
||
|
|
NULL );
|
||
|
|
|
||
|
|
if ( ERROR_SUCCESS == Status )
|
||
|
|
{
|
||
|
|
Status = RegCreateKeyEx(
|
||
|
|
hkPolicies,
|
||
|
|
L"Explorer",
|
||
|
|
0,
|
||
|
|
NULL,
|
||
|
|
REG_OPTION_NON_VOLATILE,
|
||
|
|
KEY_READ | KEY_WRITE,
|
||
|
|
NULL,
|
||
|
|
&hkExplorer,
|
||
|
|
NULL );
|
||
|
|
|
||
|
|
RegCloseKey( hkPolicies );
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( ERROR_SUCCESS == Status )
|
||
|
|
{
|
||
|
|
if ( fRestrict )
|
||
|
|
{
|
||
|
|
Status = RegSetValueEx(
|
||
|
|
hkExplorer,
|
||
|
|
L"DisablePersonalDirChange",
|
||
|
|
0,
|
||
|
|
REG_DWORD,
|
||
|
|
(PBYTE) &fRestrict,
|
||
|
|
sizeof(fRestrict) );
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
RegDeleteValue( hkExplorer, L"DisablePersonalDirChange" );
|
||
|
|
}
|
||
|
|
|
||
|
|
RegCloseKey( hkExplorer );
|
||
|
|
}
|
||
|
|
|
||
|
|
//now that the keys have been modified, return to impersonation.
|
||
|
|
if (!ImpersonateLoggedOnUser( hUserToken ))
|
||
|
|
Status = GetLastError();
|
||
|
|
|
||
|
|
if ( ERROR_SUCCESS == Status )
|
||
|
|
{
|
||
|
|
if ( fRestrict )
|
||
|
|
{
|
||
|
|
DebugMsg((DM_VERBOSE, IDS_MYDOCSRESTRICT_ON));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
DebugMsg((DM_VERBOSE, IDS_MYDOCSRESTRICT_OFF));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: GroupInList
|
||
|
|
//
|
||
|
|
// Synopsis: given a group sid in string format, and a list of group sids
|
||
|
|
// in PTOKEN_GROUPS format, this function figures out if the
|
||
|
|
// give sid belongs to that list
|
||
|
|
//
|
||
|
|
// Arguments: [in] pwszSid : the given sid in string format
|
||
|
|
// [in] PTOKEN_GROUPS : a list of group sids
|
||
|
|
//
|
||
|
|
// Returns: TRUE : if the group is found in the list
|
||
|
|
// FALSE : otherwise. FALSE is also returned if an error occurs
|
||
|
|
//
|
||
|
|
// History: 10/6/1998 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
BOOL GroupInList (WCHAR * pwszSid, PTOKEN_GROUPS pGroups)
|
||
|
|
{
|
||
|
|
ASSERT (pwszSid);
|
||
|
|
|
||
|
|
PSID pSid = 0;
|
||
|
|
DWORD Status;
|
||
|
|
BOOL bStatus = FALSE;
|
||
|
|
DWORD i;
|
||
|
|
|
||
|
|
//optimization for the basic case
|
||
|
|
if (0 == lstrcmpi (pwszSid, L"s-1-1-0")) //if the user is an earthling
|
||
|
|
{
|
||
|
|
bStatus = TRUE;
|
||
|
|
goto GroupInListEnd;
|
||
|
|
}
|
||
|
|
|
||
|
|
Status = AllocateAndInitSidFromString (pwszSid, &pSid);
|
||
|
|
|
||
|
|
if (ERROR_SUCCESS != Status)
|
||
|
|
goto GroupInListEnd;
|
||
|
|
|
||
|
|
for (i = 0, bStatus = FALSE;
|
||
|
|
i < pGroups->GroupCount && !bStatus;
|
||
|
|
i++
|
||
|
|
)
|
||
|
|
{
|
||
|
|
bStatus = RtlEqualSid (pSid, pGroups->Groups[i].Sid);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
GroupInListEnd:
|
||
|
|
if (pSid)
|
||
|
|
RtlFreeSid (pSid);
|
||
|
|
return bStatus;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: AllocateAndInitSidFromString
|
||
|
|
//
|
||
|
|
// Synopsis: given the string representation of a SID, this function
|
||
|
|
// allocate and initializes a SID which the string represents
|
||
|
|
// For more information on the string representation of SIDs
|
||
|
|
// refer to ntseapi.h & ntrtl.h
|
||
|
|
//
|
||
|
|
// Arguments: [in] lpszSidStr : the string representation of the SID
|
||
|
|
// [out] pSID : the actual SID structure created from the string
|
||
|
|
//
|
||
|
|
// Returns: STATUS_SUCCESS : if the sid structure was successfully created
|
||
|
|
// or an error code based on errors that might occur
|
||
|
|
//
|
||
|
|
// History: 10/6/1998 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
NTSTATUS AllocateAndInitSidFromString (const WCHAR* lpszSidStr, PSID* ppSid)
|
||
|
|
{
|
||
|
|
WCHAR * pSidStr = 0;
|
||
|
|
WCHAR* pString = 0;
|
||
|
|
NTSTATUS Status;
|
||
|
|
WCHAR* pEnd = 0;
|
||
|
|
int count;
|
||
|
|
BYTE SubAuthCount;
|
||
|
|
DWORD SubAuths[8] = {0, 0, 0, 0, 0, 0, 0, 0};
|
||
|
|
ULONG n;
|
||
|
|
SID_IDENTIFIER_AUTHORITY Auth;
|
||
|
|
|
||
|
|
pSidStr = new WCHAR [lstrlen (lpszSidStr) + 1];
|
||
|
|
if (!pSidStr)
|
||
|
|
{
|
||
|
|
Status = STATUS_NO_MEMORY;
|
||
|
|
goto AllocAndInitSidFromStr_End;
|
||
|
|
}
|
||
|
|
|
||
|
|
lstrcpy (pSidStr, lpszSidStr);
|
||
|
|
pString = pSidStr;
|
||
|
|
*ppSid = NULL;
|
||
|
|
|
||
|
|
count = 0;
|
||
|
|
do
|
||
|
|
{
|
||
|
|
pString = wcschr (pString, '-');
|
||
|
|
if (NULL == pString)
|
||
|
|
break;
|
||
|
|
count++;
|
||
|
|
pString++;
|
||
|
|
} while (1);
|
||
|
|
|
||
|
|
SubAuthCount = (BYTE)(count - 2);
|
||
|
|
if (0 > SubAuthCount || 8 < SubAuthCount)
|
||
|
|
{
|
||
|
|
Status = ERROR_INVALID_SID;
|
||
|
|
goto AllocAndInitSidFromStr_End;
|
||
|
|
}
|
||
|
|
|
||
|
|
pString = wcschr (pSidStr, L'-');
|
||
|
|
pString++;
|
||
|
|
pString = wcschr (pString, L'-'); //ignore the revision #
|
||
|
|
pString++;
|
||
|
|
pEnd = wcschr (pString, L'-'); //go to the beginning of subauths.
|
||
|
|
if (NULL != pEnd) *pEnd = L'\0';
|
||
|
|
|
||
|
|
Status = LoadSidAuthFromString (pString, &Auth);
|
||
|
|
|
||
|
|
if (STATUS_SUCCESS != Status)
|
||
|
|
goto AllocAndInitSidFromStr_End;
|
||
|
|
|
||
|
|
for (count = 0; count < SubAuthCount; count++)
|
||
|
|
{
|
||
|
|
pString = pEnd + 1;
|
||
|
|
pEnd = wcschr (pString, L'-');
|
||
|
|
if (pEnd)
|
||
|
|
*pEnd = L'\0';
|
||
|
|
Status = GetIntFromUnicodeString (pString, 10, &n);
|
||
|
|
if (STATUS_SUCCESS != Status)
|
||
|
|
goto AllocAndInitSidFromStr_End;
|
||
|
|
SubAuths[count] = n;
|
||
|
|
}
|
||
|
|
|
||
|
|
Status = RtlAllocateAndInitializeSid (&Auth, SubAuthCount,
|
||
|
|
SubAuths[0], SubAuths[1], SubAuths[2],
|
||
|
|
SubAuths[3], SubAuths[4], SubAuths[5],
|
||
|
|
SubAuths[6], SubAuths[7], ppSid);
|
||
|
|
|
||
|
|
AllocAndInitSidFromStr_End:
|
||
|
|
if (pSidStr)
|
||
|
|
delete [] pSidStr;
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: LoadSidAuthFromString
|
||
|
|
//
|
||
|
|
// Synopsis: given a string representing the SID authority (as it is
|
||
|
|
// normally represented in string format, fill the SID_AUTH..
|
||
|
|
// structure. For more details on the format of the string
|
||
|
|
// representation of the sid authority, refer to ntseapi.h and
|
||
|
|
// ntrtl.h
|
||
|
|
//
|
||
|
|
// Arguments: [in] pString : pointer to the unicode string
|
||
|
|
// [out] pSidAuth : pointer to the SID_IDENTIFIER_AUTH.. that is
|
||
|
|
// desired
|
||
|
|
//
|
||
|
|
// Returns: STATUS_SUCCESS if it succeeds
|
||
|
|
// or an error code
|
||
|
|
//
|
||
|
|
// History: 9/29/1998 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
NTSTATUS LoadSidAuthFromString (const WCHAR* pString,
|
||
|
|
PSID_IDENTIFIER_AUTHORITY pSidAuth)
|
||
|
|
{
|
||
|
|
size_t len;
|
||
|
|
int i;
|
||
|
|
NTSTATUS Status;
|
||
|
|
const ULONG LowByteMask = 0xFF;
|
||
|
|
ULONG n;
|
||
|
|
|
||
|
|
len = wcslen (pString);
|
||
|
|
|
||
|
|
if (len > 2 && 'x' == pString[1])
|
||
|
|
{
|
||
|
|
//this is in hex.
|
||
|
|
//so we must have exactly 14 characters
|
||
|
|
//(2 each for each of the 6 bytes) + 2 for the leading 0x
|
||
|
|
if (14 != len)
|
||
|
|
{
|
||
|
|
Status = ERROR_INVALID_SID;
|
||
|
|
goto LoadAuthEnd;
|
||
|
|
}
|
||
|
|
|
||
|
|
for (i=0; i < 6; i++)
|
||
|
|
{
|
||
|
|
pString += 2; //we need to skip the leading 0x
|
||
|
|
pSidAuth->Value[i] = (UCHAR)(((pString[0] - L'0') << 4) +
|
||
|
|
(pString[1] - L'0'));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
//this is in decimal
|
||
|
|
Status = GetIntFromUnicodeString (pString, 10, &n);
|
||
|
|
if (Status != STATUS_SUCCESS)
|
||
|
|
goto LoadAuthEnd;
|
||
|
|
|
||
|
|
pSidAuth->Value[0] = pSidAuth->Value[1] = 0;
|
||
|
|
for (i = 5; i >=2; i--, n>>=8)
|
||
|
|
pSidAuth->Value[i] = (UCHAR)(n & LowByteMask);
|
||
|
|
}
|
||
|
|
|
||
|
|
Status = STATUS_SUCCESS;
|
||
|
|
|
||
|
|
LoadAuthEnd:
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: GetIntfromUnicodeString
|
||
|
|
//
|
||
|
|
// Synopsis: converts a unicode string into an integer
|
||
|
|
//
|
||
|
|
// Arguments: [in] szNum : the number represented as a unicode string
|
||
|
|
// [in] Base : the base in which the resultant int is desired
|
||
|
|
// [out] pValue : pointer to the integer representation of the
|
||
|
|
// number
|
||
|
|
//
|
||
|
|
// Returns: STATUS_SUCCESS if successful.
|
||
|
|
// or some other error code
|
||
|
|
//
|
||
|
|
// History: 9/29/1998 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
NTSTATUS GetIntFromUnicodeString (const WCHAR* szNum, ULONG Base, PULONG pValue)
|
||
|
|
{
|
||
|
|
WCHAR * pwszNumStr = 0;
|
||
|
|
UNICODE_STRING StringW;
|
||
|
|
size_t len;
|
||
|
|
NTSTATUS Status;
|
||
|
|
|
||
|
|
len = lstrlen (szNum);
|
||
|
|
pwszNumStr = new WCHAR [len + 1];
|
||
|
|
|
||
|
|
if (!pwszNumStr)
|
||
|
|
{
|
||
|
|
Status = STATUS_NO_MEMORY;
|
||
|
|
goto GetNumEnd;
|
||
|
|
}
|
||
|
|
|
||
|
|
lstrcpy (pwszNumStr, szNum);
|
||
|
|
StringW.Length = len * sizeof(WCHAR);
|
||
|
|
StringW.MaximumLength = StringW.Length + sizeof (WCHAR);
|
||
|
|
StringW.Buffer = pwszNumStr;
|
||
|
|
|
||
|
|
Status = RtlUnicodeStringToInteger (&StringW, Base, pValue);
|
||
|
|
|
||
|
|
GetNumEnd:
|
||
|
|
if (pwszNumStr)
|
||
|
|
delete [] pwszNumStr;
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: CopyProgressRoutine
|
||
|
|
//
|
||
|
|
// Synopsis: this is a callback function for PrivCopyFileExW. It is used
|
||
|
|
// to track errors that are considered fatal by the folder
|
||
|
|
// redirection client. In many cases, PrivCopyFileExW will succeed
|
||
|
|
// even if a certain operation like encryption fails. The only
|
||
|
|
// way a calling prgram can find out about this is through this
|
||
|
|
// callback function by looking at the reason for the callback.
|
||
|
|
// currently, the only 3 reasons that are considered fatal for
|
||
|
|
// redirection are PRIVCALLBACK_ENCRYPTION_FAILED and
|
||
|
|
// PRIVCALLBACK_DACL_ACCESS_DENIED and
|
||
|
|
// PRIVCALLBACK_OWNER_GROUP_ACCESS_DENIED. All other reasons will
|
||
|
|
// either not occur, or can be safely ignored.
|
||
|
|
//
|
||
|
|
// The data passed via lpData is actually a pointer to a DWORD
|
||
|
|
// that this callback function uses to store an error code if one
|
||
|
|
// occurs.
|
||
|
|
//
|
||
|
|
// Arguments: see sdk help on CopyProgressRoutine
|
||
|
|
//
|
||
|
|
// Returns: see sdk help on CopyProgressRoutine
|
||
|
|
//
|
||
|
|
// History: 10/21/1998 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD CALLBACK CopyProgressRoutine (
|
||
|
|
LARGE_INTEGER TotalFileSize,
|
||
|
|
LARGE_INTEGER TotalBytesTransferred,
|
||
|
|
LARGE_INTEGER StreamSize,
|
||
|
|
LARGE_INTEGER StreamBytesTransferred,
|
||
|
|
DWORD dwStreamNumber,
|
||
|
|
DWORD dwCallbackReason,
|
||
|
|
HANDLE hSourceFile,
|
||
|
|
HANDLE hDestinationFile,
|
||
|
|
LPVOID lpData
|
||
|
|
)
|
||
|
|
{
|
||
|
|
LPDWORD lpStatus = (LPDWORD) lpData;
|
||
|
|
|
||
|
|
//an error condition has already been registered. No need to invoke
|
||
|
|
//this callback again
|
||
|
|
if (ERROR_SUCCESS != *lpStatus)
|
||
|
|
return PROGRESS_QUIET;
|
||
|
|
|
||
|
|
switch (dwCallbackReason)
|
||
|
|
{
|
||
|
|
case PRIVCALLBACK_ENCRYPTION_FAILED:
|
||
|
|
*lpStatus = ERROR_ENCRYPTION_FAILED;
|
||
|
|
return PROGRESS_CANCEL; //no point continuing. we have already failed
|
||
|
|
case PRIVCALLBACK_DACL_ACCESS_DENIED:
|
||
|
|
*lpStatus = ERROR_INVALID_SECURITY_DESCR;
|
||
|
|
return PROGRESS_CANCEL; //same as above
|
||
|
|
case PRIVCALLBACK_OWNER_GROUP_ACCESS_DENIED:
|
||
|
|
*lpStatus = ERROR_INVALID_OWNER;
|
||
|
|
return PROGRESS_CANCEL;
|
||
|
|
default:
|
||
|
|
return PROGRESS_CONTINUE; //all other conditions can be safely ignored
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: FullFileCopyW
|
||
|
|
//
|
||
|
|
// Synopsis: this function makes use of the internal API PrivCopyFileExW
|
||
|
|
// to copy not only the contents of a file but also metadata
|
||
|
|
// like encryption, compression and DACL
|
||
|
|
//
|
||
|
|
// This function also imposes limits on the lengths of the files
|
||
|
|
// that can be copied. Anything longer than MAX_PATH is disallowed
|
||
|
|
// because the shell cannot gracefully handle such paths and we
|
||
|
|
// don't want to create problems for the user by redirecting their
|
||
|
|
// files to paths that explorer cannot get to.
|
||
|
|
//
|
||
|
|
// Arguments: [in] wszSource : the path of the source file.
|
||
|
|
// [in] wszDest : the path of the destination file.
|
||
|
|
// [in] bFailIfExists : whether the function should fail if
|
||
|
|
// the destination exists
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS : if successful
|
||
|
|
// ERROR_ENCRYPTION_FAILED : if the source is encrypted and
|
||
|
|
// the destination cannot be encrypted
|
||
|
|
// ERROR_INVALID_SECURITY_DESCR: if the DACL of the source cannot
|
||
|
|
// be copied over to the destination
|
||
|
|
// ERROR_FILE_EXISTS / ERROR_ALREADY_EXISTS : if the destination
|
||
|
|
// exists and bFailIfExists is TRUE
|
||
|
|
// ERROR_INVALID_OWNER : if the owner info. cannot be copied
|
||
|
|
// or other error codes.
|
||
|
|
//
|
||
|
|
// ERROR_FILENAME_EXCED_RANGE : if the filename is longer than MAX_PATH.
|
||
|
|
//
|
||
|
|
// History: 10/22/1998 RahulTh created
|
||
|
|
// 12/13/2000 RahulTh added length limitations
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD FullFileCopyW (
|
||
|
|
const WCHAR* wszSource,
|
||
|
|
const WCHAR* wszDest,
|
||
|
|
BOOL bFailIfExists
|
||
|
|
)
|
||
|
|
{
|
||
|
|
DWORD Status = ERROR_SUCCESS;
|
||
|
|
DWORD dwFlags = PRIVCOPY_FILE_METADATA | PRIVCOPY_FILE_OWNER_GROUP;
|
||
|
|
BOOL bCancel = FALSE;
|
||
|
|
BOOL bStatus;
|
||
|
|
int lenSource = 0;
|
||
|
|
int lenDest = 0;
|
||
|
|
|
||
|
|
if (bFailIfExists)
|
||
|
|
dwFlags |= COPY_FILE_FAIL_IF_EXISTS;
|
||
|
|
|
||
|
|
if (! wszSource)
|
||
|
|
lenSource = wcslen (wszSource);
|
||
|
|
|
||
|
|
if (! wszDest)
|
||
|
|
lenDest = wcslen (wszDest);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Prevent copying of files longer than MAX_PATH characters. This limitation
|
||
|
|
// needs to be added because the shell cannot handle paths longer than
|
||
|
|
// MAX_PATH gracefully and we don't want to land the users into trouble by
|
||
|
|
// creating files / folder that they cannot get to via explorer.
|
||
|
|
//
|
||
|
|
if (lenDest >= MAX_PATH || lenSource >= MAX_PATH)
|
||
|
|
return ERROR_FILENAME_EXCED_RANGE;
|
||
|
|
|
||
|
|
bStatus = PrivCopyFileExW (wszSource, wszDest,
|
||
|
|
(LPPROGRESS_ROUTINE) CopyProgressRoutine,
|
||
|
|
(LPVOID) &Status,
|
||
|
|
&bCancel,
|
||
|
|
dwFlags
|
||
|
|
);
|
||
|
|
|
||
|
|
//get the last error if PrivCopyFileExW failed
|
||
|
|
//and the callback function has not already registered a fatal error
|
||
|
|
if ((ERROR_SUCCESS == Status) && (!bStatus))
|
||
|
|
Status = GetLastError();
|
||
|
|
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: FullDirCopyW
|
||
|
|
//
|
||
|
|
// Synopsis: creates a directory using the new PrivCopyFileExW so that
|
||
|
|
// all the file metadata and ownership information is retained
|
||
|
|
//
|
||
|
|
// This function also imposes limits on the lengths of the folders
|
||
|
|
// that can be copied. Anything longer than MAX_PATH is disallowed
|
||
|
|
// because the shell cannot gracefully handle such paths and we
|
||
|
|
// don't want to create problems for the user by redirecting their
|
||
|
|
// files to paths that explorer cannot get to.
|
||
|
|
//
|
||
|
|
// Arguments: [in] pwszSource : the full path of the source directory
|
||
|
|
// [in] pwszDest : the full path of the destination directory
|
||
|
|
// [in] bSkipDacl : Skip DACL copying.
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS : if the copy was successful
|
||
|
|
// ERROR_INVALID_SECURITY_DESCR : if the DACL could not be applied
|
||
|
|
// ERROR_INVALID_OWNER : if the owner information could not be copied
|
||
|
|
// ERROR_ENCRYPTION_FAILED : if the encryption info. could not be copied
|
||
|
|
// or other error codes if some other error occurs
|
||
|
|
// ERROR_FILENAME_EXCED_RANGE : if the filename is longer than MAX_PATH.
|
||
|
|
//
|
||
|
|
// History: 11/5/1998 RahulTh created
|
||
|
|
// 12/13/2000 RahulTh added length limitations
|
||
|
|
// 5/2/2002 RahulTh added the skip DACL flag
|
||
|
|
//
|
||
|
|
// Notes: Essentially the same as FullFileCopyW, but we have an extra
|
||
|
|
// attribute to indicate that we are trying to copy a directory
|
||
|
|
// Also, the FAIL_IF_EXSTS flag doesn't have any significance
|
||
|
|
// when we are trying to copy directories, so that is something
|
||
|
|
// we do not need here.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD FullDirCopyW (const WCHAR* pwszSource, const WCHAR* pwszDest, BOOL bSkipDacl)
|
||
|
|
{
|
||
|
|
DWORD Status = ERROR_SUCCESS;
|
||
|
|
DWORD dwFlags = PRIVCOPY_FILE_METADATA |
|
||
|
|
PRIVCOPY_FILE_OWNER_GROUP | PRIVCOPY_FILE_DIRECTORY;
|
||
|
|
BOOL bCancel = FALSE;
|
||
|
|
BOOL bStatus = TRUE;
|
||
|
|
int lenSource = 0;
|
||
|
|
int lenDest = 0;
|
||
|
|
|
||
|
|
if (! pwszSource)
|
||
|
|
lenSource = wcslen (pwszSource);
|
||
|
|
|
||
|
|
if (! pwszDest)
|
||
|
|
lenDest = wcslen (pwszDest);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Prevent copying of files longer than MAX_PATH characters. This limitation
|
||
|
|
// needs to be added because the shell cannot handle paths longer than
|
||
|
|
// MAX_PATH gracefully and we don't want to land the users into trouble by
|
||
|
|
// creating files / folder that they cannot get to via explorer.
|
||
|
|
//
|
||
|
|
if (lenDest >= MAX_PATH || lenSource >= MAX_PATH)
|
||
|
|
return ERROR_FILENAME_EXCED_RANGE;
|
||
|
|
|
||
|
|
if (bSkipDacl)
|
||
|
|
dwFlags |= PRIVCOPY_FILE_SKIP_DACL;
|
||
|
|
|
||
|
|
bStatus = PrivCopyFileExW (pwszSource, pwszDest,
|
||
|
|
(LPPROGRESS_ROUTINE) CopyProgressRoutine,
|
||
|
|
(LPVOID) &Status,
|
||
|
|
&bCancel,
|
||
|
|
dwFlags
|
||
|
|
);
|
||
|
|
|
||
|
|
//get the last error if PrivCopyFileExW failed
|
||
|
|
//and the callback function has not already registered a fatal error
|
||
|
|
if ((ERROR_SUCCESS == Status) && (!bStatus))
|
||
|
|
Status = GetLastError();
|
||
|
|
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: FileInDir
|
||
|
|
//
|
||
|
|
// Synopsis: given a file and a directory, this function determines if
|
||
|
|
// a file with the same name exists in the given directory.
|
||
|
|
//
|
||
|
|
// Arguments: [in] pwszFile : the name of the file : it can be the full path
|
||
|
|
// [in] pwszDir : the directory for which the check needs to be
|
||
|
|
// performed
|
||
|
|
// [out] pExists : if the function succeeds, this will contain
|
||
|
|
// the result. TRUE if the file is present in the
|
||
|
|
// directory. FALSE otherwise.
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS : if it is successful
|
||
|
|
// ERROR_OUTOFMEMORY : if it runs out of memory
|
||
|
|
// ERROR_BAD_NETPATH : if the network path for the given directory
|
||
|
|
// cannot be found
|
||
|
|
//
|
||
|
|
// History: 10/28/1998 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: pwszDir MUST BE \ terminated
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD FileInDir (LPCWSTR pwszFile, LPCWSTR pwszDir, BOOL* pExists)
|
||
|
|
{
|
||
|
|
const WCHAR* pwszFileName = NULL;
|
||
|
|
WCHAR* pwszDestName = NULL;
|
||
|
|
int len;
|
||
|
|
|
||
|
|
//first get the display name of the source file
|
||
|
|
pwszFileName = wcsrchr (pwszFile, L'\\');
|
||
|
|
if (!pwszFileName)
|
||
|
|
pwszFileName = pwszFile;
|
||
|
|
else
|
||
|
|
pwszFileName++; //go past the slash
|
||
|
|
|
||
|
|
//the dir should be \ terminated
|
||
|
|
len = wcslen (pwszFile) + wcslen (pwszDir) + 1;
|
||
|
|
pwszDestName = (WCHAR*) alloca (sizeof (WCHAR) * len);
|
||
|
|
if (!pwszDestName)
|
||
|
|
return ERROR_OUTOFMEMORY;
|
||
|
|
|
||
|
|
wcscpy (pwszDestName, pwszDir);
|
||
|
|
wcscat (pwszDestName, pwszFileName);
|
||
|
|
|
||
|
|
if (0xFFFFFFFF == GetFileAttributes(pwszDestName))
|
||
|
|
{
|
||
|
|
//return an error if it is a bad network name. Saves us the trouble
|
||
|
|
//of trying to redirect to a non-existent location later
|
||
|
|
if (ERROR_BAD_NETPATH == GetLastError())
|
||
|
|
return ERROR_BAD_NETPATH;
|
||
|
|
else
|
||
|
|
*pExists = FALSE;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
*pExists = TRUE;
|
||
|
|
|
||
|
|
return ERROR_SUCCESS;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: ComparePaths
|
||
|
|
//
|
||
|
|
// Synopsis: given 2 paths, this function compares them to check if
|
||
|
|
// they are identical or if one is a descendant of the other
|
||
|
|
// or if no such relationship can be deduced
|
||
|
|
//
|
||
|
|
// Arguments: [in] pwszSource : the first path
|
||
|
|
// [in] pwszDest : the second path
|
||
|
|
// [out] pResult : the result of the comparison if the function
|
||
|
|
// succeeds in comparing the paths.
|
||
|
|
// value of pResult may contain the following values upon
|
||
|
|
// successful completion.
|
||
|
|
// 0 : if the 2 paths are identical
|
||
|
|
// -1 : if the second path is a descendant of the first
|
||
|
|
// 1 : if no such relationship can be deduced
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS : if the function succeeds in comparing the paths
|
||
|
|
// other error codes depending on the failure
|
||
|
|
//
|
||
|
|
// History: 10/28/1998 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: the result of the comparison is unreliable if the paths are
|
||
|
|
// expressed in different formats, e.g. TCP/IP, UNC, NetBios etc.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD ComparePaths (LPCWSTR pwszSource, LPCWSTR pwszDest, int* pResult)
|
||
|
|
{
|
||
|
|
DWORD Status = ERROR_SUCCESS;
|
||
|
|
BOOL bStatus;
|
||
|
|
WCHAR* pwszAbsSource = NULL;
|
||
|
|
WCHAR* pwszAbsDest = NULL;
|
||
|
|
int lSource, lDest;
|
||
|
|
WCHAR* pwszSuccess = NULL;
|
||
|
|
|
||
|
|
ASSERT (pResult);
|
||
|
|
//first allocate memory for the absolute paths.
|
||
|
|
//since the arguments to this function are full pathnames
|
||
|
|
//the lengths of the absolute paths cannot exceed the length of
|
||
|
|
//the parameters
|
||
|
|
//add an extra character because we will add a \ to the end of the abs. path
|
||
|
|
lSource = wcslen (pwszSource) + 2;
|
||
|
|
pwszAbsSource = (WCHAR*) alloca (sizeof(WCHAR) * lSource);
|
||
|
|
if (!pwszAbsSource)
|
||
|
|
{
|
||
|
|
Status = ERROR_OUTOFMEMORY;
|
||
|
|
goto ComparePathsEnd;
|
||
|
|
}
|
||
|
|
//add an extra character because we will add a \ to the end of the abs. path
|
||
|
|
lDest = wcslen (pwszDest) + 2;
|
||
|
|
pwszAbsDest = (WCHAR*) alloca (sizeof(WCHAR) * lDest);
|
||
|
|
if (!pwszAbsDest)
|
||
|
|
{
|
||
|
|
Status = ERROR_OUTOFMEMORY;
|
||
|
|
goto ComparePathsEnd;
|
||
|
|
}
|
||
|
|
|
||
|
|
//first get the absolute paths. after that we will just work with the
|
||
|
|
//absolute paths.
|
||
|
|
//note: we need the absolute paths so that we can can check if one path
|
||
|
|
//is a descendant of the other path by just using wcsncmp. without absolute
|
||
|
|
//paths, wcsncmp cannot be used because we can have 2 paths like
|
||
|
|
//\\server\share\hello\there and \\server\share\hello\..\hello\there\hi
|
||
|
|
//in this case the second path is actually a descendant of the first, but
|
||
|
|
//wcsncmp cannot detect that. getting the absolute paths will eliminate
|
||
|
|
//the .., . etc.
|
||
|
|
//also we must terminate the absolute paths with \, so that wcsncmp does
|
||
|
|
//not mistakenly think that \\server\share\hellofubar is a descendant
|
||
|
|
//of \\server\share\hello
|
||
|
|
pwszSuccess = _wfullpath (pwszAbsSource, pwszSource, lSource);
|
||
|
|
if (!pwszSuccess)
|
||
|
|
{
|
||
|
|
Status = ERROR_BAD_PATHNAME;
|
||
|
|
goto ComparePathsEnd;
|
||
|
|
}
|
||
|
|
pwszSuccess = _wfullpath (pwszAbsDest, pwszDest, lDest);
|
||
|
|
if (!pwszSuccess)
|
||
|
|
{
|
||
|
|
Status = ERROR_BAD_PATHNAME;
|
||
|
|
goto ComparePathsEnd;
|
||
|
|
}
|
||
|
|
|
||
|
|
//update the lengths with the actual lengths of the absolute paths
|
||
|
|
//not including the terminating null character
|
||
|
|
lSource = wcslen (pwszAbsSource);
|
||
|
|
lDest = wcslen (pwszAbsDest);
|
||
|
|
|
||
|
|
//terminate the absolute paths with '\' if necessary. also make
|
||
|
|
//the appropriate changes to the lengths
|
||
|
|
if (L'\\' != pwszAbsSource[lSource - 1])
|
||
|
|
{
|
||
|
|
wcscat (pwszAbsSource, L"\\"); //we won't run out of space here
|
||
|
|
//because of the extra character allocation
|
||
|
|
lSource++;
|
||
|
|
}
|
||
|
|
if (L'\\' != pwszAbsDest[lDest - 1])
|
||
|
|
{
|
||
|
|
wcscat (pwszAbsDest, L"\\"); //won't run out of space here because
|
||
|
|
//of the extra allocation above
|
||
|
|
lDest++;
|
||
|
|
}
|
||
|
|
|
||
|
|
//now we are all set (finally!) to perform the comparisons
|
||
|
|
|
||
|
|
//first do a simple check of whether the paths are identical
|
||
|
|
if ((lSource == lDest) && (0 == _wcsicmp (pwszAbsSource, pwszAbsDest)))
|
||
|
|
{
|
||
|
|
*pResult = 0;
|
||
|
|
goto ComparePathsSuccess;
|
||
|
|
}
|
||
|
|
|
||
|
|
//check for recursion
|
||
|
|
if ((lDest > lSource) && (0 == _wcsnicmp (pwszAbsSource, pwszAbsDest, lSource)))
|
||
|
|
{
|
||
|
|
*pResult = -1;
|
||
|
|
goto ComparePathsSuccess;
|
||
|
|
}
|
||
|
|
|
||
|
|
//if we are here, these paths are not identical...
|
||
|
|
*pResult = 1;
|
||
|
|
|
||
|
|
|
||
|
|
ComparePathsSuccess:
|
||
|
|
Status = ERROR_SUCCESS;
|
||
|
|
goto ComparePathsEnd;
|
||
|
|
|
||
|
|
ComparePathsEnd:
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: CheckIdenticalSpecial
|
||
|
|
//
|
||
|
|
// Synopsis: given 2 paths, this function determines if they are actually
|
||
|
|
// the same path expressed in 2 different formats
|
||
|
|
//
|
||
|
|
// Arguments: [in] pwszSource : path #1
|
||
|
|
// [in] pwszDest : path #2
|
||
|
|
// [out] pResult : result of the comparison
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS if the function could perform the comparison
|
||
|
|
// in this case *pResult will contain the result of comparison
|
||
|
|
// Other win32 errors, in which case *pResult should not be used
|
||
|
|
// by the calling function
|
||
|
|
//
|
||
|
|
// History: 12/1/1998 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: this function expects both pwszSource and pwszDest to exist and
|
||
|
|
// be online when it is called.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD CheckIdenticalSpecial (LPCWSTR pwszSource, LPCWSTR pwszDest, int* pResult)
|
||
|
|
{
|
||
|
|
ASSERT (pResult);
|
||
|
|
|
||
|
|
BOOL bStatus;
|
||
|
|
DWORD Status;
|
||
|
|
BOOL bTempFileCreated = FALSE;
|
||
|
|
WCHAR * pwszTempPath;
|
||
|
|
UINT lUnique = 0;
|
||
|
|
BOOL bFileExists;
|
||
|
|
WCHAR * pwszSlashTerminatedDest;
|
||
|
|
int lDest;
|
||
|
|
|
||
|
|
//first append a \ to pwszDest if it is not already \ terminated
|
||
|
|
//allocate an extra characted just in case we need it
|
||
|
|
pwszSlashTerminatedDest = (WCHAR *) alloca (sizeof (WCHAR) * ((lDest = wcslen(pwszDest)) + 2));
|
||
|
|
|
||
|
|
if (!pwszSlashTerminatedDest)
|
||
|
|
{
|
||
|
|
Status = ERROR_OUTOFMEMORY;
|
||
|
|
goto CheckIdenticalEnd;
|
||
|
|
}
|
||
|
|
|
||
|
|
wcscpy (pwszSlashTerminatedDest, pwszDest);
|
||
|
|
if (L'\\' != pwszSlashTerminatedDest[lDest - 1])
|
||
|
|
{
|
||
|
|
wcscat (pwszSlashTerminatedDest, L"\\");
|
||
|
|
lDest++;
|
||
|
|
}
|
||
|
|
|
||
|
|
pwszTempPath = (WCHAR*) alloca (sizeof (WCHAR) * (MAX_PATH + wcslen(pwszSource) + 2));
|
||
|
|
if (!pwszTempPath)
|
||
|
|
{
|
||
|
|
Status = ERROR_OUTOFMEMORY;
|
||
|
|
goto CheckIdenticalEnd;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (0 == (lUnique = GetTempFileName(pwszSource, L"fde", 0, pwszTempPath)))
|
||
|
|
{
|
||
|
|
//a failure to create the temporary file would mean that the source
|
||
|
|
//and destination paths are different...
|
||
|
|
*pResult = 1;
|
||
|
|
goto CheckIdenticalSuccess;
|
||
|
|
}
|
||
|
|
|
||
|
|
//now we have created a temporary file,
|
||
|
|
bTempFileCreated = TRUE;
|
||
|
|
|
||
|
|
//check if it exists on the destination
|
||
|
|
//note: FileInDir requires that the path in the second parameter is
|
||
|
|
// slash terminated.
|
||
|
|
Status = FileInDir (pwszTempPath, pwszSlashTerminatedDest, &bFileExists);
|
||
|
|
|
||
|
|
if (Status != ERROR_SUCCESS)
|
||
|
|
goto CheckIdenticalEnd;
|
||
|
|
|
||
|
|
//if the file does not exist at the destination, we know that these 2 paths
|
||
|
|
//are different. However, if the file does exist at the destination, we
|
||
|
|
//need to watch out for the rare case that the file existed even before we
|
||
|
|
//we created the temp file at the source. To do this, we must delete the
|
||
|
|
//temp file from the source and make sure that it has indeed disappeared
|
||
|
|
//from the destination
|
||
|
|
if (!bFileExists)
|
||
|
|
{
|
||
|
|
*pResult = 1;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (!DeleteFile(pwszTempPath))
|
||
|
|
goto CheckIdenticalErr;
|
||
|
|
|
||
|
|
//the file has been deleted
|
||
|
|
bTempFileCreated = FALSE;
|
||
|
|
//make sure that it has disappeared from the destination
|
||
|
|
Status = FileInDir (pwszTempPath, pwszSlashTerminatedDest, &bFileExists);
|
||
|
|
|
||
|
|
if (Status != ERROR_SUCCESS)
|
||
|
|
goto CheckIdenticalEnd;
|
||
|
|
|
||
|
|
if (bFileExists)
|
||
|
|
{
|
||
|
|
*pResult = 1; //by some quirk of fate, a file by the same name as
|
||
|
|
//the tempfile preexisted on the destination, so
|
||
|
|
//in reality they are not the same share.
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
//the file has disappeared from the dest. this means that it was
|
||
|
|
//indeed the same share
|
||
|
|
*pResult = 0;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
CheckIdenticalSuccess:
|
||
|
|
Status = ERROR_SUCCESS;
|
||
|
|
goto CheckIdenticalEnd;
|
||
|
|
|
||
|
|
CheckIdenticalErr:
|
||
|
|
Status = GetLastError();
|
||
|
|
|
||
|
|
CheckIdenticalEnd:
|
||
|
|
if (bTempFileCreated)
|
||
|
|
DeleteFile (pwszTempPath); //ignore any errors here.
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//*************************************************************
|
||
|
|
//
|
||
|
|
// CheckSlash()
|
||
|
|
//
|
||
|
|
// Purpose: Checks for an ending slash and adds one if
|
||
|
|
// it is missing.
|
||
|
|
//
|
||
|
|
// Parameters: lpDir - directory
|
||
|
|
//
|
||
|
|
// Return: Pointer to the end of the string
|
||
|
|
//
|
||
|
|
// Comments:
|
||
|
|
//
|
||
|
|
// History: Date Author Comment
|
||
|
|
// 6/19/95 ericflo Created
|
||
|
|
//
|
||
|
|
//*************************************************************
|
||
|
|
LPTSTR CheckSlash (LPTSTR lpDir)
|
||
|
|
{
|
||
|
|
LPTSTR lpEnd;
|
||
|
|
|
||
|
|
lpEnd = lpDir + lstrlen(lpDir);
|
||
|
|
|
||
|
|
if (*(lpEnd - 1) != TEXT('\\')) {
|
||
|
|
*lpEnd = TEXT('\\');
|
||
|
|
lpEnd++;
|
||
|
|
*lpEnd = TEXT('\0');
|
||
|
|
}
|
||
|
|
|
||
|
|
return lpEnd;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//*************************************************************
|
||
|
|
//
|
||
|
|
// RegDelnodeRecurse()
|
||
|
|
//
|
||
|
|
// Purpose: Deletes a registry key and all it's subkeys / values.
|
||
|
|
// Called by RegDelnode
|
||
|
|
//
|
||
|
|
// Parameters: hKeyRoot - Root key
|
||
|
|
// lpSubKey - SubKey to delete
|
||
|
|
//
|
||
|
|
// Return: TRUE if successful
|
||
|
|
// FALSE if an error occurs
|
||
|
|
//
|
||
|
|
// Comments:
|
||
|
|
//
|
||
|
|
// History: Date Author Comment
|
||
|
|
// 10/3/95 EricFlo Created
|
||
|
|
// 11/5/98 RahulTh Copied from EricFlo's code
|
||
|
|
//
|
||
|
|
//*************************************************************
|
||
|
|
|
||
|
|
BOOL RegDelnodeRecurse (HKEY hKeyRoot, LPTSTR lpSubKey)
|
||
|
|
{
|
||
|
|
LPTSTR lpEnd;
|
||
|
|
LONG lResult;
|
||
|
|
DWORD dwSize;
|
||
|
|
TCHAR szName[MAX_PATH];
|
||
|
|
HKEY hKey;
|
||
|
|
FILETIME ftWrite;
|
||
|
|
|
||
|
|
//
|
||
|
|
// First, see if we can delete the key without having
|
||
|
|
// to recurse.
|
||
|
|
//
|
||
|
|
|
||
|
|
|
||
|
|
lResult = RegDeleteKey(hKeyRoot, lpSubKey);
|
||
|
|
|
||
|
|
if (lResult == ERROR_SUCCESS) {
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
lResult = RegOpenKeyEx (hKeyRoot, lpSubKey, 0, KEY_READ, &hKey);
|
||
|
|
|
||
|
|
if (lResult != ERROR_SUCCESS) {
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
lpEnd = CheckSlash(lpSubKey);
|
||
|
|
|
||
|
|
//
|
||
|
|
// Enumerate the keys
|
||
|
|
//
|
||
|
|
|
||
|
|
dwSize = MAX_PATH;
|
||
|
|
lResult = RegEnumKeyEx(hKey, 0, szName, &dwSize, NULL,
|
||
|
|
NULL, NULL, &ftWrite);
|
||
|
|
|
||
|
|
if (lResult == ERROR_SUCCESS) {
|
||
|
|
|
||
|
|
do {
|
||
|
|
|
||
|
|
lstrcpy (lpEnd, szName);
|
||
|
|
|
||
|
|
if (!RegDelnodeRecurse(hKeyRoot, lpSubKey)) {
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Enumerate again
|
||
|
|
//
|
||
|
|
|
||
|
|
dwSize = MAX_PATH;
|
||
|
|
|
||
|
|
lResult = RegEnumKeyEx(hKey, 0, szName, &dwSize, NULL,
|
||
|
|
NULL, NULL, &ftWrite);
|
||
|
|
|
||
|
|
|
||
|
|
} while (lResult == ERROR_SUCCESS);
|
||
|
|
}
|
||
|
|
|
||
|
|
lpEnd--;
|
||
|
|
*lpEnd = TEXT('\0');
|
||
|
|
|
||
|
|
|
||
|
|
RegCloseKey (hKey);
|
||
|
|
|
||
|
|
|
||
|
|
//
|
||
|
|
// Try again to delete the key
|
||
|
|
//
|
||
|
|
|
||
|
|
lResult = RegDeleteKey(hKeyRoot, lpSubKey);
|
||
|
|
|
||
|
|
if (lResult == ERROR_SUCCESS) {
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//*************************************************************
|
||
|
|
//
|
||
|
|
// RegDelnode()
|
||
|
|
//
|
||
|
|
// Purpose: Deletes a registry key and all it's subkeys / values
|
||
|
|
//
|
||
|
|
// Parameters: hKeyRoot - Root key
|
||
|
|
// lpSubKey - SubKey to delete
|
||
|
|
//
|
||
|
|
// Return: TRUE if successful
|
||
|
|
// FALSE if an error occurs
|
||
|
|
//
|
||
|
|
// Comments:
|
||
|
|
//
|
||
|
|
// History: Date Author Comment
|
||
|
|
// 10/3/95 ericflo Created
|
||
|
|
// 11/8/98 RahulTh Copied from EricFlo's code
|
||
|
|
//
|
||
|
|
//*************************************************************
|
||
|
|
|
||
|
|
BOOL RegDelnode (HKEY hKeyRoot, LPTSTR lpSubKey)
|
||
|
|
{
|
||
|
|
TCHAR szDelKey[2 * MAX_PATH];
|
||
|
|
|
||
|
|
|
||
|
|
lstrcpy (szDelKey, lpSubKey);
|
||
|
|
|
||
|
|
return RegDelnodeRecurse(hKeyRoot, szDelKey);
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: GetSetOwnerPrivileges
|
||
|
|
//
|
||
|
|
// Synopsis: tries to get privileges to set ownership
|
||
|
|
//
|
||
|
|
// Arguments: [in] hToken : handle to the token for which we are trying to
|
||
|
|
// obtain the privileges
|
||
|
|
//
|
||
|
|
// Returns: nothing
|
||
|
|
//
|
||
|
|
// History: 11/6/1998 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: this function never fails. It just tries its best to get all
|
||
|
|
// NT privileges. It is not guaranteed that it will get all of
|
||
|
|
// them, as it depends on the user's rights
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
void GetSetOwnerPrivileges (HANDLE hToken)
|
||
|
|
{
|
||
|
|
BOOL bStatus;
|
||
|
|
DWORD Status;
|
||
|
|
DWORD Size = 0;
|
||
|
|
DWORD i;
|
||
|
|
DWORD privCount;
|
||
|
|
PTOKEN_PRIVILEGES pPrivs = NULL;
|
||
|
|
|
||
|
|
//try to get all the windows NT privileges.
|
||
|
|
for (i=0, privCount=0; *NTPrivs[i]; i++)
|
||
|
|
privCount++;
|
||
|
|
|
||
|
|
Size = sizeof (LUID_AND_ATTRIBUTES) * (privCount - 1) +
|
||
|
|
sizeof (TOKEN_PRIVILEGES);
|
||
|
|
|
||
|
|
pPrivs = (PTOKEN_PRIVILEGES) alloca (Size);
|
||
|
|
|
||
|
|
if (NULL == pPrivs)
|
||
|
|
goto GetAllPrivsEnd;
|
||
|
|
|
||
|
|
for (i=0, privCount = 0; *NTPrivs[i]; i++)
|
||
|
|
{
|
||
|
|
bStatus = LookupPrivilegeValue (NULL, NTPrivs[i],
|
||
|
|
&(pPrivs->Privileges[privCount].Luid));
|
||
|
|
if (!bStatus)
|
||
|
|
continue;
|
||
|
|
|
||
|
|
pPrivs->Privileges[privCount++].Attributes = SE_PRIVILEGE_ENABLED;
|
||
|
|
}
|
||
|
|
pPrivs->PrivilegeCount = privCount;
|
||
|
|
|
||
|
|
AdjustTokenPrivileges (hToken,
|
||
|
|
FALSE,
|
||
|
|
pPrivs,
|
||
|
|
NULL, NULL, NULL
|
||
|
|
);
|
||
|
|
|
||
|
|
GetAllPrivsEnd:
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: SafeGetPrivateProfileStringW
|
||
|
|
//
|
||
|
|
// Synopsis: a wrapper for GetPrivateProfileString which takes care of
|
||
|
|
// all the error checks etc. so that functions that call
|
||
|
|
// this routine won't have to do it.
|
||
|
|
//
|
||
|
|
// Arguments: very similar to GetPrivateProfileStringW
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS if successful. An error code otherwise
|
||
|
|
// Also, upon successful return *pSize contains the size of
|
||
|
|
// the data copied -- not including the terminating NULL
|
||
|
|
// probably the only Error code this will ever return is
|
||
|
|
// ERROR_OUTOFMEMORY
|
||
|
|
//
|
||
|
|
// History: 11/19/1998 RahulTh created
|
||
|
|
// 12/13/2000 RahulTh made prefix happy by initializing vars.
|
||
|
|
// which anyway get set by GetPrivateProfileString
|
||
|
|
//
|
||
|
|
// Notes: if *ppwszReturnedString has been allocated memory, it might
|
||
|
|
// get freed by this function
|
||
|
|
// this function also allocates memory for the data
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD SafeGetPrivateProfileStringW (
|
||
|
|
const WCHAR * pwszSection,
|
||
|
|
const WCHAR * pwszKey,
|
||
|
|
const WCHAR * pwszDefault,
|
||
|
|
WCHAR ** ppwszReturnedString,
|
||
|
|
DWORD * pSize,
|
||
|
|
const WCHAR * pwszIniFile
|
||
|
|
)
|
||
|
|
{
|
||
|
|
DWORD Status = ERROR_SUCCESS;
|
||
|
|
DWORD retVal;
|
||
|
|
|
||
|
|
*pSize = MAX_PATH;
|
||
|
|
do
|
||
|
|
{
|
||
|
|
if (*ppwszReturnedString)
|
||
|
|
delete [] *ppwszReturnedString;
|
||
|
|
|
||
|
|
*ppwszReturnedString = new WCHAR [*pSize];
|
||
|
|
|
||
|
|
if (!(*ppwszReturnedString))
|
||
|
|
{
|
||
|
|
Status = ERROR_OUTOFMEMORY;
|
||
|
|
*pSize = 0;
|
||
|
|
goto SafeGetEnd;
|
||
|
|
}
|
||
|
|
|
||
|
|
(*ppwszReturnedString)[0] = L'*';
|
||
|
|
(*ppwszReturnedString)[1] = L'\0';
|
||
|
|
|
||
|
|
|
||
|
|
retVal = GetPrivateProfileString (
|
||
|
|
pwszSection,
|
||
|
|
pwszKey,
|
||
|
|
pwszDefault,
|
||
|
|
*ppwszReturnedString,
|
||
|
|
*pSize,
|
||
|
|
pwszIniFile
|
||
|
|
);
|
||
|
|
|
||
|
|
if (*pSize - 1 != retVal)
|
||
|
|
{
|
||
|
|
*pSize = retVal;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
//if we are here, we need more memory
|
||
|
|
//try with twice of what we had
|
||
|
|
*pSize = (*pSize) * 2;
|
||
|
|
|
||
|
|
} while ( TRUE );
|
||
|
|
|
||
|
|
SafeGetEnd:
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: MySidCopy
|
||
|
|
//
|
||
|
|
// Synopsis: copies sids and also allocates memory for the destination Sid
|
||
|
|
//
|
||
|
|
// Arguments: [out] ppDestSid : pointer the destination Sid;
|
||
|
|
// [in] pSourceSid : the source Sid
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS if successful. an error code otherwise
|
||
|
|
//
|
||
|
|
// History: 11/20/1998 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD MySidCopy (PSID * ppDestSid, PSID pSourceSid)
|
||
|
|
{
|
||
|
|
DWORD Status;
|
||
|
|
ULONG Size = 0;
|
||
|
|
|
||
|
|
*ppDestSid = 0;
|
||
|
|
|
||
|
|
if (!pSourceSid)
|
||
|
|
return ERROR_SUCCESS;
|
||
|
|
|
||
|
|
Size = RtlLengthSid (pSourceSid);
|
||
|
|
|
||
|
|
if (!Size)
|
||
|
|
return ERROR_SUCCESS;
|
||
|
|
|
||
|
|
*ppDestSid = (PSID) new BYTE [Size];
|
||
|
|
|
||
|
|
if (! (*ppDestSid))
|
||
|
|
return ERROR_OUTOFMEMORY;
|
||
|
|
|
||
|
|
return RtlCopySid (Size, *ppDestSid, pSourceSid);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: GetShareStatus
|
||
|
|
//
|
||
|
|
// Synopsis: this function is a wrapper for CSCQueryFileStatus.
|
||
|
|
// basically CSCQueryFileStatus can fail if there was never a net
|
||
|
|
// use to a share. So this function tries to create a net use to
|
||
|
|
// the share if CSCQueryFileStatus fails and then re-queries the
|
||
|
|
// file status
|
||
|
|
//
|
||
|
|
// Arguments: [in] pwszShare : the share name
|
||
|
|
// [out] pdwStatus : the share Status
|
||
|
|
// [out] pdwPinCount : the pin count
|
||
|
|
// [out] pdwHints : the hints
|
||
|
|
//
|
||
|
|
// Returns: TRUE : if everything was successful.
|
||
|
|
// FALSE : if there was an error. In this case, it GetLastError()
|
||
|
|
// will contain the specific error code.
|
||
|
|
//
|
||
|
|
// History: 5/11/1999 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: it is very important that this function be passed a share name
|
||
|
|
// it does not do any parameter validation. So under no
|
||
|
|
// circumstance should this function be passed a filename.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
BOOL GetShareStatus (const WCHAR * pwszShare, DWORD * pdwStatus,
|
||
|
|
DWORD * pdwPinCount, DWORD * pdwHints)
|
||
|
|
{
|
||
|
|
NETRESOURCE nr;
|
||
|
|
DWORD dwResult;
|
||
|
|
DWORD dwErr = NO_ERROR;
|
||
|
|
BOOL bStatus;
|
||
|
|
|
||
|
|
bStatus = CSCQueryFileStatus(pwszShare, pdwStatus, pdwPinCount, pdwHints);
|
||
|
|
|
||
|
|
if (!bStatus)
|
||
|
|
{
|
||
|
|
//try to connect to the share
|
||
|
|
ZeroMemory ((PVOID) (&nr), sizeof (NETRESOURCE));
|
||
|
|
nr.dwType = RESOURCETYPE_DISK;
|
||
|
|
nr.lpLocalName = NULL;
|
||
|
|
nr.lpRemoteName = (LPTSTR) pwszShare;
|
||
|
|
nr.lpProvider = NULL;
|
||
|
|
|
||
|
|
dwErr = WNetUseConnection(NULL, &nr, NULL, NULL, 0,
|
||
|
|
NULL, NULL, &dwResult);
|
||
|
|
|
||
|
|
if (NO_ERROR == dwErr)
|
||
|
|
{
|
||
|
|
bStatus = CSCQueryFileStatus (pwszShare, pdwStatus, pdwPinCount, pdwHints);
|
||
|
|
if (!bStatus)
|
||
|
|
dwErr = GetLastError();
|
||
|
|
else
|
||
|
|
dwErr = NO_ERROR;
|
||
|
|
|
||
|
|
WNetCancelConnection2 (pwszShare, 0, FALSE);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
bStatus = FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
SetLastError(dwErr);
|
||
|
|
return bStatus;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: GetCSCStatus
|
||
|
|
//
|
||
|
|
// Synopsis: given a path, finds out if it is local and if it is not
|
||
|
|
// whether it is online or offline.
|
||
|
|
//
|
||
|
|
// Arguments: [in] pwszPath : the path to the file
|
||
|
|
//
|
||
|
|
// Returns: Local/Online/Offline
|
||
|
|
//
|
||
|
|
// History: 11/20/1998 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: it is important that the path passed to this function is a
|
||
|
|
// a full path and not a relative path
|
||
|
|
//
|
||
|
|
// this function will return offline if the share is not live or
|
||
|
|
// if the share is live but CSC thinks that it is offline
|
||
|
|
//
|
||
|
|
// it will return PathLocal if the path is local or if the path
|
||
|
|
// is a network path that cannot be handled by CSC e.g. a network
|
||
|
|
// share with a pathname longer than what csc can handle or if it
|
||
|
|
// is a netware share. in this case it makes sense to return
|
||
|
|
// PathLocal because CSC won't maintain a database for these shares
|
||
|
|
// -- same as for a local path. so as far as CSC is concerned, this
|
||
|
|
// is as good as a local path.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
SHARESTATUS GetCSCStatus (const WCHAR * pwszPath)
|
||
|
|
{
|
||
|
|
WCHAR * pwszAbsPath = NULL;
|
||
|
|
WCHAR * pwszCurr = NULL;
|
||
|
|
int len;
|
||
|
|
BOOL bRetVal;
|
||
|
|
DWORD Status;
|
||
|
|
DWORD dwPinCount;
|
||
|
|
DWORD dwHints;
|
||
|
|
|
||
|
|
if (!pwszPath)
|
||
|
|
return ShareOffline; //a path must be provided
|
||
|
|
|
||
|
|
len = wcslen (pwszPath);
|
||
|
|
|
||
|
|
pwszAbsPath = (WCHAR *) alloca (sizeof (WCHAR) * (len + 1));
|
||
|
|
|
||
|
|
if (!pwszAbsPath)
|
||
|
|
{
|
||
|
|
//we are out of memory, so it is safest to return ShareOffline
|
||
|
|
//so that we can bail out of redirection.
|
||
|
|
return ShareOffline;
|
||
|
|
}
|
||
|
|
|
||
|
|
//get the absolute path
|
||
|
|
pwszCurr = _wfullpath (pwszAbsPath, pwszPath, len + 1);
|
||
|
|
|
||
|
|
if (!pwszCurr)
|
||
|
|
{
|
||
|
|
//in order for _wfullpath to fail, something really bad has to happen
|
||
|
|
//so it is best to return ShareOffline so that we can bail out of
|
||
|
|
//redirection
|
||
|
|
return ShareOffline;
|
||
|
|
}
|
||
|
|
|
||
|
|
len = wcslen (pwszAbsPath);
|
||
|
|
|
||
|
|
if (! (
|
||
|
|
(2 <= len) &&
|
||
|
|
(L'\\' == pwszAbsPath[0]) &&
|
||
|
|
(L'\\' == pwszAbsPath[1])
|
||
|
|
)
|
||
|
|
)
|
||
|
|
{
|
||
|
|
//it is a local path if it does not begin with 2 backslashes
|
||
|
|
return PathLocal;
|
||
|
|
}
|
||
|
|
|
||
|
|
//this is a UNC path; so extract the \\server\share part
|
||
|
|
pwszCurr = wcschr ( & (pwszAbsPath[2]), L'\\');
|
||
|
|
|
||
|
|
//first make sure that it is at least of the form \\server\share
|
||
|
|
//watch out for the \\server\ case
|
||
|
|
if (!pwszCurr || !pwszCurr[1])
|
||
|
|
return ShareOffline; //it is an invalid path (no share name)
|
||
|
|
|
||
|
|
//the path is of the form \\server\share
|
||
|
|
//note: the use _wfullpath automatically protects us against the \\server\\ case
|
||
|
|
pwszCurr = wcschr (&(pwszCurr[1]), L'\\');
|
||
|
|
if (pwszCurr) //if it is of the form \\server\share\...
|
||
|
|
*pwszCurr = L'\0';
|
||
|
|
|
||
|
|
//now pwszAbsPath is a share name
|
||
|
|
bRetVal = CSCCheckShareOnline (pwszAbsPath);
|
||
|
|
|
||
|
|
if (!bRetVal)
|
||
|
|
{
|
||
|
|
if (!g_bCSCEnabled)
|
||
|
|
{
|
||
|
|
//CSC has not been enabled on this machine, so the fact that
|
||
|
|
//CSC check share online failed means that the share is indeed
|
||
|
|
//offline.
|
||
|
|
return ShareOffline;
|
||
|
|
}
|
||
|
|
if (ERROR_SUCCESS != GetLastError())
|
||
|
|
{
|
||
|
|
//either there is really a problem (e.g. invalid share name) or
|
||
|
|
//it is just a share that is not handled by CSC e.g. a netware share
|
||
|
|
//or a share with a name that is longer than can be handled by CSC
|
||
|
|
//so check if the share actually exists
|
||
|
|
if (0xFFFFFFFF != GetFileAttributes(pwszAbsPath))
|
||
|
|
{
|
||
|
|
//this can still be a share that is offline since GetFileAttributes
|
||
|
|
//will return the attributes stored in the cache
|
||
|
|
Status = 0;
|
||
|
|
bRetVal = GetShareStatus (pwszAbsPath, &Status, &dwPinCount,
|
||
|
|
&dwHints);
|
||
|
|
if (! bRetVal || (! (FLAG_CSC_SHARE_STATUS_DISCONNECTED_OP & Status)))
|
||
|
|
return PathLocal; //this is simply a valid path that CSC cannot handle
|
||
|
|
else if (bRetVal &&
|
||
|
|
(FLAG_CSC_SHARE_STATUS_NO_CACHING ==
|
||
|
|
(FLAG_CSC_SHARE_STATUS_CACHING_MASK & Status)))
|
||
|
|
return PathLocal; //CSC caching is not turned on for the share.
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//it is indeed an inaccessble share
|
||
|
|
return ShareOffline; //for all other cases, treat this as offline
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (!g_bCSCEnabled)
|
||
|
|
{
|
||
|
|
//CSC has not been enabled on this machine, so the fact that
|
||
|
|
//CSCCheckShareOnline succeed means that the share is indeed
|
||
|
|
//accessible. Since nothing can be cached, we must return
|
||
|
|
//PathLocal here.
|
||
|
|
return PathLocal;
|
||
|
|
}
|
||
|
|
//if we are here, it means that the share is live, but CSC might still
|
||
|
|
//think that it is offline.
|
||
|
|
Status = 0;
|
||
|
|
bRetVal = GetShareStatus (pwszAbsPath, &Status, &dwPinCount,
|
||
|
|
&dwHints);
|
||
|
|
if (bRetVal && (FLAG_CSC_SHARE_STATUS_DISCONNECTED_OP & Status))
|
||
|
|
return ShareOffline; //CSC thinks that the share is offline
|
||
|
|
else if (bRetVal &&
|
||
|
|
(FLAG_CSC_SHARE_STATUS_NO_CACHING ==
|
||
|
|
(FLAG_CSC_SHARE_STATUS_CACHING_MASK & Status)))
|
||
|
|
return PathLocal; //CSC caching is not turned on for the share
|
||
|
|
else if (!bRetVal)
|
||
|
|
return ShareOffline;
|
||
|
|
|
||
|
|
//in all other cases, consider the share as online since
|
||
|
|
//CSCCheckShareOnline has already returned TRUE
|
||
|
|
return ShareOnline;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: MoveDirInCSC
|
||
|
|
//
|
||
|
|
// Synopsis: this function moves a directory within the CSC cache without
|
||
|
|
// prejudice. If the destination is a local path, it just deletes
|
||
|
|
// the source tree from the cache
|
||
|
|
//
|
||
|
|
// Arguments: [in] pwszSource : the source path
|
||
|
|
// [in] pwszDest : the dest path
|
||
|
|
// [in] pwszSkipSubdir : the directory to skip while moving
|
||
|
|
// [in] StatusFrom : the CSC status of the source path
|
||
|
|
// [in] StatusTo : the CSC status of the dest. path
|
||
|
|
// [in] bAllowRdrTimeout : if stuff needs to be deleted from the
|
||
|
|
// cache, we may not succeed immediately since
|
||
|
|
// the rdr keeps the handles to recently opened
|
||
|
|
// files open. This paramaters tells the function
|
||
|
|
// whether it needs to wait and retry
|
||
|
|
//
|
||
|
|
// Returns: nothing. it just tries its best.
|
||
|
|
//
|
||
|
|
// History: 11/21/1998 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: the value of bAllowRdrTimeout is always ignored for the
|
||
|
|
// in-cache rename operation. we always want to wait for
|
||
|
|
// the timeout.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
void MoveDirInCSC (const WCHAR * pwszSource, const WCHAR * pwszDest,
|
||
|
|
const WCHAR * pwszSkipSubdir,
|
||
|
|
SHARESTATUS StatusFrom, SHARESTATUS StatusTo,
|
||
|
|
BOOL bAllowRdrTimeoutForDel,
|
||
|
|
BOOL bAllowRdrTimeoutForRen)
|
||
|
|
{
|
||
|
|
WIN32_FIND_DATA findData;
|
||
|
|
DWORD dwFileStatus;
|
||
|
|
DWORD dwPinCount;
|
||
|
|
HANDLE hCSCFind;
|
||
|
|
DWORD dwHintFlags;
|
||
|
|
FILETIME origTime;
|
||
|
|
WCHAR * pwszPath;
|
||
|
|
WCHAR * pwszEnd;
|
||
|
|
int len;
|
||
|
|
DWORD StatusCSCRen = ERROR_SUCCESS;
|
||
|
|
|
||
|
|
if (!g_bCSCEnabled || PathLocal == StatusFrom)
|
||
|
|
return; //there is nothing to do. nothing was cached.
|
||
|
|
|
||
|
|
if (PathLocal == StatusTo)
|
||
|
|
{
|
||
|
|
//the destination is a local path, so we should just delete the
|
||
|
|
//files from the source
|
||
|
|
DeleteCSCFileTree (pwszSource, pwszSkipSubdir, bAllowRdrTimeoutForDel);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
pwszPath = (WCHAR *) alloca (sizeof (WCHAR) * ((len = wcslen (pwszSource)) + MAX_PATH + 2));
|
||
|
|
if (!pwszPath || len <= 0)
|
||
|
|
return;
|
||
|
|
wcscpy (pwszPath, pwszSource);
|
||
|
|
pwszEnd = pwszPath + len;
|
||
|
|
if (L'\\' != pwszEnd[-1])
|
||
|
|
{
|
||
|
|
*pwszEnd++ = L'\\';
|
||
|
|
}
|
||
|
|
hCSCFind = CSCFindFirstFile (pwszSource, &findData, &dwFileStatus,
|
||
|
|
&dwPinCount, &dwHintFlags, &origTime);
|
||
|
|
|
||
|
|
if (INVALID_HANDLE_VALUE != hCSCFind)
|
||
|
|
{
|
||
|
|
do
|
||
|
|
{
|
||
|
|
if (0 != _wcsicmp (L".", findData.cFileName) &&
|
||
|
|
0 != _wcsicmp (L"..", findData.cFileName) &&
|
||
|
|
(!pwszSkipSubdir || (0 != _wcsicmp (findData.cFileName, pwszSkipSubdir))))
|
||
|
|
{
|
||
|
|
wcscpy (pwszEnd, findData.cFileName);
|
||
|
|
if (ERROR_SUCCESS == StatusCSCRen)
|
||
|
|
{
|
||
|
|
StatusCSCRen = DoCSCRename (pwszPath, pwszDest, TRUE, bAllowRdrTimeoutForRen);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
//here we ignore the return value since an error has already occurred.
|
||
|
|
//and we do not wish to spend any more time in timeouts in any subsequent
|
||
|
|
//rename operation.
|
||
|
|
DoCSCRename (pwszPath, pwszDest, TRUE, FALSE);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
} while ( CSCFindNextFile (hCSCFind, &findData, &dwFileStatus,
|
||
|
|
&dwPinCount, &dwHintFlags, &origTime)
|
||
|
|
);
|
||
|
|
|
||
|
|
CSCFindClose (hCSCFind);
|
||
|
|
}
|
||
|
|
|
||
|
|
//merge the pin info. at the top level folder
|
||
|
|
MergePinInfo (pwszSource, pwszDest, StatusFrom, StatusTo);
|
||
|
|
}
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: DoCSCRename
|
||
|
|
//
|
||
|
|
// Synopsis: does a file rename within the CSC cache.
|
||
|
|
//
|
||
|
|
// Arguments: [in] pwszSource : full source path
|
||
|
|
// [in] pwszDest : full path to destination directory
|
||
|
|
// [in] bOverwrite : overwrite if the file/folder exists at
|
||
|
|
// the destination
|
||
|
|
// [in] bAllowRdrTimeout : if TRUE, retry for 10 seconds on failure
|
||
|
|
// so that rdr and mem. mgr. get enough time to
|
||
|
|
// release the handles.
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS if the rename was successful.
|
||
|
|
// an error code otherwise.
|
||
|
|
//
|
||
|
|
// History: 5/26/1999 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: no validation of parameters is done. The caller is responsible
|
||
|
|
// for that
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD DoCSCRename (const WCHAR * pwszSource, const WCHAR * pwszDest,
|
||
|
|
BOOL bOverwrite, BOOL bAllowRdrTimeout)
|
||
|
|
{
|
||
|
|
DWORD Status = ERROR_SUCCESS;
|
||
|
|
BOOL bStatus;
|
||
|
|
int i;
|
||
|
|
|
||
|
|
bStatus = CSCDoLocalRename (pwszSource, pwszDest, bOverwrite);
|
||
|
|
if (!bStatus)
|
||
|
|
{
|
||
|
|
Status = GetLastError();
|
||
|
|
if (ERROR_SUCCESS != Status &&
|
||
|
|
ERROR_FILE_NOT_FOUND != Status &&
|
||
|
|
ERROR_PATH_NOT_FOUND != Status &&
|
||
|
|
ERROR_INVALID_PARAMETER != Status &&
|
||
|
|
ERROR_BAD_NETPATH != Status)
|
||
|
|
{
|
||
|
|
if (bAllowRdrTimeout)
|
||
|
|
{
|
||
|
|
if (!bOverwrite && ERROR_FILE_EXISTS == Status)
|
||
|
|
{
|
||
|
|
Status = ERROR_SUCCESS;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
for (i = 0; i < 11; i++)
|
||
|
|
{
|
||
|
|
Sleep (1000); //wait for the handle to be released
|
||
|
|
bStatus = CSCDoLocalRename (pwszSource, pwszDest, bOverwrite);
|
||
|
|
if (bStatus)
|
||
|
|
{
|
||
|
|
Status = ERROR_SUCCESS;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Status = ERROR_SUCCESS;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ERROR_SUCCESS != Status)
|
||
|
|
{
|
||
|
|
DebugMsg ((DM_VERBOSE, IDS_CSCRENAME_FAIL, pwszSource, pwszDest, Status));
|
||
|
|
}
|
||
|
|
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: DeleteCSCFileTree
|
||
|
|
//
|
||
|
|
// Synopsis: deletes a file tree from the CSC
|
||
|
|
//
|
||
|
|
// Arguments: [in] pwszSource : the path to the folder whose contents should
|
||
|
|
// be deleted
|
||
|
|
// [in] pwszSkipSubdir : name of the subdirectory to be skipped.
|
||
|
|
// [in] bAllowRdrTimeout : if true, makes multiple attempts to
|
||
|
|
// delete the file since the rdr may have left
|
||
|
|
// the handle open for sometime which can result
|
||
|
|
// in an ACCESS_DENIED message.
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS if the deletion was successful. An error code
|
||
|
|
// otherwise.
|
||
|
|
//
|
||
|
|
// History: 11/21/1998 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD DeleteCSCFileTree (const WCHAR * pwszSource, const WCHAR * pwszSkipSubdir,
|
||
|
|
BOOL bAllowRdrTimeout)
|
||
|
|
{
|
||
|
|
WIN32_FIND_DATA findData;
|
||
|
|
DWORD dwFileStatus;
|
||
|
|
DWORD dwPinCount;
|
||
|
|
HANDLE hCSCFind;
|
||
|
|
DWORD dwHintFlags;
|
||
|
|
FILETIME origTime;
|
||
|
|
WCHAR * pwszPath;
|
||
|
|
WCHAR * pwszEnd;
|
||
|
|
int len;
|
||
|
|
DWORD Status = ERROR_SUCCESS;
|
||
|
|
|
||
|
|
if (! g_bCSCEnabled)
|
||
|
|
return ERROR_SUCCESS;
|
||
|
|
|
||
|
|
pwszPath = (WCHAR *) alloca (sizeof(WCHAR) * ((len = wcslen(pwszSource)) + MAX_PATH + 2));
|
||
|
|
if (!pwszPath)
|
||
|
|
return ERROR_OUTOFMEMORY; //nothing much we can do if we run out of memory
|
||
|
|
|
||
|
|
if (len <= 0)
|
||
|
|
return ERROR_BAD_PATHNAME;
|
||
|
|
|
||
|
|
wcscpy (pwszPath, pwszSource);
|
||
|
|
pwszEnd = pwszPath + len;
|
||
|
|
if (L'\\' != pwszEnd[-1])
|
||
|
|
{
|
||
|
|
*pwszEnd++ = L'\\';
|
||
|
|
}
|
||
|
|
|
||
|
|
hCSCFind = CSCFindFirstFile (pwszSource, &findData, &dwFileStatus,
|
||
|
|
&dwPinCount, &dwHintFlags, &origTime);
|
||
|
|
|
||
|
|
if (INVALID_HANDLE_VALUE != hCSCFind)
|
||
|
|
{
|
||
|
|
do
|
||
|
|
{
|
||
|
|
if (0 != _wcsicmp (L".", findData.cFileName) &&
|
||
|
|
0 != _wcsicmp (L"..", findData.cFileName) &&
|
||
|
|
(!pwszSkipSubdir || (0 != _wcsicmp (pwszSkipSubdir, findData.cFileName))))
|
||
|
|
{
|
||
|
|
wcscpy (pwszEnd, findData.cFileName);
|
||
|
|
|
||
|
|
if (findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
|
||
|
|
{
|
||
|
|
if (ERROR_SUCCESS != Status)
|
||
|
|
{
|
||
|
|
//no point delaying the deletes since a delete has already
|
||
|
|
//failed.
|
||
|
|
DeleteCSCFileTree (pwszPath, NULL, FALSE);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Status = DeleteCSCFileTree (pwszPath, NULL, bAllowRdrTimeout);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (ERROR_SUCCESS != Status)
|
||
|
|
{
|
||
|
|
//no point delaying the delete if we have already failed.
|
||
|
|
DeleteCSCFile (pwszPath, FALSE);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Status = DeleteCSCFile (pwszPath, bAllowRdrTimeout);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
} while ( CSCFindNextFile (hCSCFind, &findData, &dwFileStatus,
|
||
|
|
&dwPinCount, &dwHintFlags, &origTime)
|
||
|
|
);
|
||
|
|
|
||
|
|
CSCFindClose (hCSCFind);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ERROR_SUCCESS != Status)
|
||
|
|
{
|
||
|
|
//no point in delaying the delete if we have already failed.
|
||
|
|
DeleteCSCFile (pwszSource, FALSE);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Status = DeleteCSCFile (pwszSource, bAllowRdrTimeout);
|
||
|
|
}
|
||
|
|
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: DeleteCSCFile
|
||
|
|
//
|
||
|
|
// Synopsis: deletes the given path. but might make repeated attempts to
|
||
|
|
// make sure that the rdr has enough time to release any handles
|
||
|
|
// that it holds.
|
||
|
|
//
|
||
|
|
// Arguments: [in] pwszPath : the path to delete.
|
||
|
|
// [in] bAllowRdrTimeout : make multiple attempts to delete the
|
||
|
|
// file with waits in between so that the rdr has
|
||
|
|
// enough time to release any held handles.
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCES if the delete was successful. An error code
|
||
|
|
// otherwise.
|
||
|
|
//
|
||
|
|
// History: 5/26/1999 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD DeleteCSCFile (const WCHAR * pwszPath, BOOL bAllowRdrTimeout)
|
||
|
|
{
|
||
|
|
BOOL bStatus;
|
||
|
|
DWORD Status = ERROR_SUCCESS;
|
||
|
|
int i;
|
||
|
|
|
||
|
|
bStatus = CSCDelete (pwszPath);
|
||
|
|
if (!bStatus)
|
||
|
|
{
|
||
|
|
Status = GetLastError();
|
||
|
|
if (ERROR_SUCCESS != Status &&
|
||
|
|
ERROR_FILE_NOT_FOUND != Status &&
|
||
|
|
ERROR_PATH_NOT_FOUND != Status &&
|
||
|
|
ERROR_INVALID_PARAMETER != Status)
|
||
|
|
{
|
||
|
|
//this is a valid error.
|
||
|
|
//so based on the value of bAllowRdrTimeout and based
|
||
|
|
//on whether we have already failed in deleting something
|
||
|
|
//we will try repeatedly to delete the file for 10 seconds
|
||
|
|
//note: there is no point in repeatedly trying if the deletion
|
||
|
|
//failed because this was a directory which was not empty
|
||
|
|
if (bAllowRdrTimeout && ERROR_DIR_NOT_EMPTY != Status)
|
||
|
|
{
|
||
|
|
for (i = 0; i < 11; i++)
|
||
|
|
{
|
||
|
|
Sleep (1000); //wait for 1 second and try again
|
||
|
|
bStatus = CSCDelete (pwszPath);
|
||
|
|
if (bStatus)
|
||
|
|
{
|
||
|
|
Status = ERROR_SUCCESS;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Status = ERROR_SUCCESS;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (ERROR_SUCCESS != Status)
|
||
|
|
{
|
||
|
|
DebugMsg ((DM_VERBOSE, IDS_CSCDELETE_FAIL, pwszPath, Status));
|
||
|
|
}
|
||
|
|
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: DisplayStatusMessage
|
||
|
|
//
|
||
|
|
// Synopsis: displays the status message in the UI when the verbose status
|
||
|
|
// is on.
|
||
|
|
//
|
||
|
|
// Arguments: resource id of the message to be displayed.
|
||
|
|
//
|
||
|
|
// Returns: nothing
|
||
|
|
//
|
||
|
|
// History: 2/25/1999 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: failures are ignored.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
void DisplayStatusMessage (UINT rid)
|
||
|
|
{
|
||
|
|
WCHAR pwszMessage [MAX_PATH];
|
||
|
|
|
||
|
|
if (!gpStatusCallback)
|
||
|
|
return;
|
||
|
|
|
||
|
|
if (!LoadString (ghDllInstance, rid, pwszMessage, MAX_PATH))
|
||
|
|
return;
|
||
|
|
|
||
|
|
gpStatusCallback (TRUE, pwszMessage);
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: DeleteCSCShareIfEmpty
|
||
|
|
//
|
||
|
|
// Synopsis: given a file name, this function deletes from the local cache
|
||
|
|
// the share to which the file belongs if the local cache for that
|
||
|
|
// share is empty
|
||
|
|
//
|
||
|
|
// Arguments: [in] pwszFileName : the full file name -- must be UNC
|
||
|
|
// [in] shStatus : the share status - online, offline, local etc.
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS : if successful
|
||
|
|
// a win32 error code if something goes wrong
|
||
|
|
//
|
||
|
|
// History: 4/22/1999 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: we do not have to explicitly check if the share is empty
|
||
|
|
// because if it is not, then the delete will fail anyway
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD DeleteCSCShareIfEmpty (LPCTSTR pwszFileName, SHARESTATUS shStatus)
|
||
|
|
{
|
||
|
|
DWORD Status;
|
||
|
|
WCHAR * pwszFullPath = NULL;
|
||
|
|
WCHAR * pwszCurr = NULL;
|
||
|
|
int len;
|
||
|
|
WCHAR * pwszShrEnd;
|
||
|
|
|
||
|
|
if (PathLocal == shStatus || NoCSC == shStatus)
|
||
|
|
return ERROR_SUCCESS;
|
||
|
|
|
||
|
|
if (ShareOffline == shStatus)
|
||
|
|
return ERROR_CSCSHARE_OFFLINE;
|
||
|
|
|
||
|
|
len = wcslen (pwszFileName);
|
||
|
|
|
||
|
|
if (len <= 2)
|
||
|
|
return ERROR_BAD_PATHNAME;
|
||
|
|
|
||
|
|
if (pwszFileName[0] != L'\\' || pwszFileName[1] != L'\\')
|
||
|
|
return ERROR_BAD_PATHNAME;
|
||
|
|
|
||
|
|
pwszFullPath = (WCHAR *) alloca (sizeof (WCHAR) * (len + 1));
|
||
|
|
if (NULL == pwszFullPath)
|
||
|
|
return ERROR_OUTOFMEMORY;
|
||
|
|
|
||
|
|
if (NULL == _wfullpath(pwszFullPath, pwszFileName, len + 1))
|
||
|
|
return ERROR_BAD_PATHNAME; //canonicalization was unsuccessful.
|
||
|
|
// -- rarely happens
|
||
|
|
|
||
|
|
pwszShrEnd = wcschr (pwszFullPath + 2, L'\\');
|
||
|
|
|
||
|
|
if (NULL == pwszShrEnd)
|
||
|
|
return ERROR_BAD_PATHNAME; //the path does not have the share component
|
||
|
|
|
||
|
|
pwszShrEnd++;
|
||
|
|
|
||
|
|
pwszShrEnd = wcschr (pwszShrEnd, L'\\');
|
||
|
|
|
||
|
|
if (NULL == pwszShrEnd)
|
||
|
|
{
|
||
|
|
//we already have the path in \\server\share form, so just try to
|
||
|
|
//delete the share.
|
||
|
|
return DeleteCSCFile (pwszFullPath, TRUE);
|
||
|
|
}
|
||
|
|
|
||
|
|
//if we are here, then we have a path longer than just \\server\share.
|
||
|
|
//so try to delete all the way up to the share name. This is necessary
|
||
|
|
//because a user might be redirected to something like
|
||
|
|
// \\server\share\folder\%username% and we wouldn't want only \\server\share
|
||
|
|
// and \\server\share\folder to be cached.
|
||
|
|
Status = ERROR_SUCCESS;
|
||
|
|
do
|
||
|
|
{
|
||
|
|
pwszCurr = wcsrchr (pwszFullPath, L'\\');
|
||
|
|
if (NULL == pwszCurr)
|
||
|
|
break;
|
||
|
|
*pwszCurr = L'\0';
|
||
|
|
Status = DeleteCSCFile (pwszFullPath, TRUE);
|
||
|
|
//no point trying to delete the parent if deletion of this directory
|
||
|
|
//failed.
|
||
|
|
if (ERROR_SUCCESS != Status)
|
||
|
|
break;
|
||
|
|
} while ( pwszCurr > pwszShrEnd );
|
||
|
|
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: MergePinInfo
|
||
|
|
//
|
||
|
|
// Synopsis: merges the pin info. from the source to destination
|
||
|
|
//
|
||
|
|
// Arguments: [in] pwszSource : the full path to the source
|
||
|
|
// [in] pwszDest : the full path to the destination
|
||
|
|
// [in] StatusFrom : CSC status of the source share
|
||
|
|
// [in] StatusTo : CSC status of the destination share
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS : if it was successful
|
||
|
|
// a Win32 error code otherwise
|
||
|
|
//
|
||
|
|
// History: 4/23/1999 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: the hint flags are a union of the source hint flags and
|
||
|
|
// destination hint flags. The pin count is the greater of the
|
||
|
|
// source and destination pin count
|
||
|
|
//
|
||
|
|
// Usually this function should only be called for folders. The
|
||
|
|
// CSC rename API handles files well. But this function will work
|
||
|
|
// for files as well.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD MergePinInfo (LPCTSTR pwszSource, LPCTSTR pwszDest,
|
||
|
|
SHARESTATUS StatusFrom, SHARESTATUS StatusTo)
|
||
|
|
{
|
||
|
|
BOOL bStatus;
|
||
|
|
DWORD dwSourceStat, dwDestStat;
|
||
|
|
DWORD dwSourcePinCount, dwDestPinCount;
|
||
|
|
DWORD dwSourceHints, dwDestHints;
|
||
|
|
DWORD Status = ERROR_SUCCESS;
|
||
|
|
DWORD i;
|
||
|
|
|
||
|
|
if (ShareOffline == StatusFrom || ShareOffline == StatusTo)
|
||
|
|
return ERROR_CSCSHARE_OFFLINE;
|
||
|
|
|
||
|
|
if (ShareOnline != StatusFrom || ShareOnline != StatusTo)
|
||
|
|
return ERROR_SUCCESS; //there is nothing to do if one of the shares
|
||
|
|
//is local.
|
||
|
|
if (!pwszSource || !pwszDest ||
|
||
|
|
0 == wcslen(pwszSource) || 0 == wcslen(pwszDest))
|
||
|
|
return ERROR_BAD_PATHNAME;
|
||
|
|
|
||
|
|
bStatus = CSCQueryFileStatus (pwszSource, &dwSourceStat, &dwSourcePinCount,
|
||
|
|
&dwSourceHints);
|
||
|
|
if (!bStatus)
|
||
|
|
return GetLastError();
|
||
|
|
|
||
|
|
bStatus = CSCQueryFileStatus (pwszDest, &dwDestStat, &dwDestPinCount,
|
||
|
|
&dwDestHints);
|
||
|
|
if (!bStatus)
|
||
|
|
return GetLastError();
|
||
|
|
|
||
|
|
//first set the hint flags on the destination
|
||
|
|
if (dwDestHints != dwSourceHints)
|
||
|
|
{
|
||
|
|
bStatus = CSCPinFile (pwszDest, dwSourceHints, &dwDestStat,
|
||
|
|
&dwDestPinCount, &dwDestHints);
|
||
|
|
if (!bStatus)
|
||
|
|
Status = GetLastError(); //note: we do not bail out here. we try
|
||
|
|
//to at least merge the pin count before
|
||
|
|
//leaving
|
||
|
|
}
|
||
|
|
|
||
|
|
//now merge the pin count : there is nothing to be done if the destination
|
||
|
|
//pin count is greater than or equal to the source pin count
|
||
|
|
if (dwDestPinCount < dwSourcePinCount)
|
||
|
|
{
|
||
|
|
for (i = 0, bStatus = TRUE; i < (dwSourcePinCount - dwDestPinCount) &&
|
||
|
|
bStatus;
|
||
|
|
i++)
|
||
|
|
{
|
||
|
|
bStatus = CSCPinFile( pwszDest,
|
||
|
|
FLAG_CSC_HINT_COMMAND_ALTER_PIN_COUNT,
|
||
|
|
NULL, NULL, NULL );
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!bStatus && ERROR_SUCCESS == Status)
|
||
|
|
Status = GetLastError();
|
||
|
|
}
|
||
|
|
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: PinIfNecessary
|
||
|
|
//
|
||
|
|
// Synopsis: this function pins a file if necessary.
|
||
|
|
//
|
||
|
|
// Arguments: [in] pwszPath : full path of the file/folder to be pinned
|
||
|
|
// [in] shStatus : CSC status of the share.
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS if it was successful. An error code otherwise.
|
||
|
|
//
|
||
|
|
// History: 5/27/1999 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD PinIfNecessary (const WCHAR * pwszPath, SHARESTATUS shStatus)
|
||
|
|
{
|
||
|
|
DWORD Status = ERROR_SUCCESS;
|
||
|
|
BOOL bStatus;
|
||
|
|
DWORD dwStatus;
|
||
|
|
DWORD dwPinCount;
|
||
|
|
DWORD dwHints;
|
||
|
|
|
||
|
|
if (!pwszPath || !pwszPath[0])
|
||
|
|
return ERROR_BAD_NETPATH;
|
||
|
|
|
||
|
|
if (! g_bCSCEnabled)
|
||
|
|
return ERROR_SUCCESS;
|
||
|
|
|
||
|
|
if (ShareOffline == shStatus)
|
||
|
|
return ERROR_CSCSHARE_OFFLINE;
|
||
|
|
else if (PathLocal == shStatus || NoCSC == shStatus)
|
||
|
|
return ERROR_SUCCESS;
|
||
|
|
|
||
|
|
bStatus = CSCQueryFileStatus (pwszPath, &dwStatus, &dwPinCount, &dwHints);
|
||
|
|
if (!bStatus || dwPinCount <= 0)
|
||
|
|
{
|
||
|
|
bStatus = CSCPinFile (pwszPath,
|
||
|
|
FLAG_CSC_HINT_COMMAND_ALTER_PIN_COUNT,
|
||
|
|
NULL, NULL, NULL);
|
||
|
|
if (!bStatus)
|
||
|
|
Status = GetLastError();
|
||
|
|
}
|
||
|
|
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: CacheDesktopIni
|
||
|
|
//
|
||
|
|
// Synopsis: some special folders use the desktop.ini file to present
|
||
|
|
// special views in explorer (e.g. My Pictures). If a folder is
|
||
|
|
// redirected to a network share and a user goes offline without
|
||
|
|
// ever looking at the folder in explorer, the desktop.ini file
|
||
|
|
// is not in the cache and therefore the special views are lost
|
||
|
|
//
|
||
|
|
// This function tries to cache the desktop.ini file as soon as
|
||
|
|
// the folder is pinned so that special views are not lost even
|
||
|
|
// if the user goes offline
|
||
|
|
//
|
||
|
|
// When the folder is unpinned, this function merely unpins the
|
||
|
|
// dekstop.ini file
|
||
|
|
//
|
||
|
|
// Arguments: [in] pwszPath : the path to the folder
|
||
|
|
// [in] shStatus : the CSC status of the share
|
||
|
|
// [in] uCommand : Pin/Unpin
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS if everything is successful.
|
||
|
|
// a win32 error code otherwise.
|
||
|
|
//
|
||
|
|
// History: 4/25/1999 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: this function should only be called after the folder has been
|
||
|
|
// successfully redirected.
|
||
|
|
//
|
||
|
|
// if desktop.ini is already pinned, this function does not try
|
||
|
|
// to pin it again.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD CacheDesktopIni (LPCTSTR pwszPath, SHARESTATUS shStatus, CSCPINCOMMAND uCommand)
|
||
|
|
{
|
||
|
|
int len;
|
||
|
|
WCHAR szDesktopIniName[] = L"desktop.ini";
|
||
|
|
WCHAR * pwszDesktopIni = NULL;
|
||
|
|
BOOL bStatus;
|
||
|
|
DWORD Status = ERROR_SUCCESS;
|
||
|
|
DWORD dwStatus;
|
||
|
|
DWORD dwPinCount;
|
||
|
|
DWORD dwHints;
|
||
|
|
|
||
|
|
if (PathLocal == shStatus)
|
||
|
|
return ERROR_SUCCESS; //nothing to be done.
|
||
|
|
|
||
|
|
if (ShareOffline == shStatus)
|
||
|
|
return ERROR_CSCSHARE_OFFLINE;
|
||
|
|
|
||
|
|
if (!pwszPath || 0 == (len = wcslen (pwszPath)))
|
||
|
|
return ERROR_BAD_PATHNAME;
|
||
|
|
|
||
|
|
pwszDesktopIni = (WCHAR *) alloca (sizeof (WCHAR) *
|
||
|
|
(len + wcslen(szDesktopIniName) + 2)); //extra char for backslash
|
||
|
|
if (NULL == pwszDesktopIni)
|
||
|
|
return ERROR_OUTOFMEMORY;
|
||
|
|
|
||
|
|
wcscpy (pwszDesktopIni, pwszPath);
|
||
|
|
if (L'\\' != pwszDesktopIni[len - 1])
|
||
|
|
{
|
||
|
|
pwszDesktopIni[len] = L'\\';
|
||
|
|
pwszDesktopIni[len + 1] = L'\0';
|
||
|
|
}
|
||
|
|
wcscat (pwszDesktopIni, szDesktopIniName);
|
||
|
|
|
||
|
|
if (PinFile == uCommand)
|
||
|
|
{
|
||
|
|
bStatus = CSCQueryFileStatus (pwszDesktopIni, &dwStatus, &dwPinCount,
|
||
|
|
&dwHints);
|
||
|
|
//pin only if it has not already been pinned.
|
||
|
|
if (!bStatus || dwPinCount <= 0)
|
||
|
|
{
|
||
|
|
if (bStatus = CSCPinFile(pwszDesktopIni,
|
||
|
|
FLAG_CSC_HINT_COMMAND_ALTER_PIN_COUNT,
|
||
|
|
NULL, NULL, NULL)
|
||
|
|
)
|
||
|
|
{
|
||
|
|
bStatus = CSCFillSparseFiles(pwszDesktopIni, FALSE,
|
||
|
|
CSCCallbackProc, 0);
|
||
|
|
}
|
||
|
|
if (!bStatus)
|
||
|
|
Status = GetLastError();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else if (UnpinFile == uCommand)
|
||
|
|
{
|
||
|
|
if (! CSCUnpinFile (pwszDesktopIni, FLAG_CSC_HINT_COMMAND_ALTER_PIN_COUNT,
|
||
|
|
NULL, NULL, NULL))
|
||
|
|
Status = GetLastError();
|
||
|
|
}
|
||
|
|
|
||
|
|
return Status;
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: CSCCallbackProc
|
||
|
|
//
|
||
|
|
// Synopsis: callback function for CSCFillSparseFiles
|
||
|
|
//
|
||
|
|
// Arguments: see docs
|
||
|
|
//
|
||
|
|
// Returns: see docs
|
||
|
|
//
|
||
|
|
// History: 4/26/1999 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: just returns a default value for all...
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD WINAPI
|
||
|
|
CSCCallbackProc(LPCTSTR pszName,
|
||
|
|
DWORD dwStatus,
|
||
|
|
DWORD dwHintFlags,
|
||
|
|
DWORD dwPinCount,
|
||
|
|
LPWIN32_FIND_DATA pFind32,
|
||
|
|
DWORD dwReason,
|
||
|
|
DWORD dwParam1,
|
||
|
|
DWORD dwParam2,
|
||
|
|
DWORD_PTR dwContext)
|
||
|
|
{
|
||
|
|
return CSCPROC_RETURN_CONTINUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: UpdateMyPicsShellLink
|
||
|
|
//
|
||
|
|
// Synopsis: there is no easy way to get to My Pictures if it is redirected
|
||
|
|
// independently of My Documents since the shell does not really
|
||
|
|
// address this issue. Therefore, this function is required to
|
||
|
|
// make sure that if My Pictures is not located directly under
|
||
|
|
// My Documents, there is at least a shell link pointing to the
|
||
|
|
// location of My Pictures. This function also makes sure that
|
||
|
|
// the shell link is cached in case My Documents is on a network
|
||
|
|
// share. This way, if the share were to go offline before the user
|
||
|
|
// had a chance to access My Documents, then the shell link would
|
||
|
|
// still be accessible.
|
||
|
|
//
|
||
|
|
// Also, if My Pictures is a direct descendant of My Documents,
|
||
|
|
// this function gets rid of the shell link to minimize user
|
||
|
|
// confusion.
|
||
|
|
//
|
||
|
|
// Arguments: [in] pwszMyPicsLocName : localized display name of My Pictures.
|
||
|
|
//
|
||
|
|
// Returns: S_OK : if everything went smoothly.
|
||
|
|
// an HRESULT derived from the error if there is one.
|
||
|
|
//
|
||
|
|
// History: 5/2/1999 RahulTh created
|
||
|
|
// 2/14/2001 RahulTh Fixed shortcut creation problem in free
|
||
|
|
// threaded COM by using SHCoCreateInstance
|
||
|
|
// to short-circuit COM.
|
||
|
|
//
|
||
|
|
// Notes: This function shall not be required if the shell comes up with
|
||
|
|
// an easy way to get to My Pictures even when it does not lie
|
||
|
|
// directly under My Documents.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
HRESULT UpdateMyPicsShellLinks (HANDLE hUserToken, const WCHAR * pwszMyPicsLocName)
|
||
|
|
{
|
||
|
|
WCHAR szMyDocsPath [TARGETPATHLIMIT];
|
||
|
|
WCHAR szMyPicsPath [TARGETPATHLIMIT];
|
||
|
|
WCHAR * pwszMyPicsLink = NULL;
|
||
|
|
int MyDocsLen;
|
||
|
|
int MyPicsLen;
|
||
|
|
HRESULT hr = S_OK;
|
||
|
|
SHARESTATUS MyDocsCSCStatus;
|
||
|
|
BOOL fMyPicsFollows = TRUE;
|
||
|
|
BOOL bStatus;
|
||
|
|
DWORD Status = ERROR_SUCCESS;
|
||
|
|
IShellLink * psl = NULL;
|
||
|
|
IPersistFile * ppf = NULL;
|
||
|
|
DWORD dwPinCount;
|
||
|
|
DWORD dwHints;
|
||
|
|
DWORD dwCSCState;
|
||
|
|
BOOL bComInitialized = FALSE;
|
||
|
|
|
||
|
|
//make sure that we have the user token.
|
||
|
|
if (!hUserToken)
|
||
|
|
{
|
||
|
|
hr = E_FAIL;
|
||
|
|
goto UpdateMyPicsLink_End;
|
||
|
|
}
|
||
|
|
|
||
|
|
//now get the path to My Documents
|
||
|
|
hr = SHGetFolderPath(0, CSIDL_PERSONAL | CSIDL_FLAG_DONT_VERIFY,
|
||
|
|
hUserToken, 0, szMyDocsPath);
|
||
|
|
if (S_OK != hr)
|
||
|
|
goto UpdateMyPicsLink_End;
|
||
|
|
|
||
|
|
//now make sure that we can get enough memory to store the path to the
|
||
|
|
//shell link.
|
||
|
|
MyDocsLen = wcslen (szMyDocsPath);
|
||
|
|
if (0 == MyDocsLen)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32(ERROR_BAD_PATHNAME);
|
||
|
|
goto UpdateMyPicsLink_End;
|
||
|
|
}
|
||
|
|
|
||
|
|
pwszMyPicsLink = (WCHAR *) alloca (sizeof(WCHAR) * (MyDocsLen + wcslen(pwszMyPicsLocName) + 6));
|
||
|
|
if (NULL == pwszMyPicsLink)
|
||
|
|
{
|
||
|
|
hr = E_OUTOFMEMORY;
|
||
|
|
goto UpdateMyPicsLink_End;
|
||
|
|
}
|
||
|
|
|
||
|
|
//now make sure that the share on which My Docs exists is not offline
|
||
|
|
MyDocsCSCStatus = GetCSCStatus (szMyDocsPath);
|
||
|
|
if (ShareOffline == MyDocsCSCStatus)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32 (ERROR_CSCSHARE_OFFLINE);
|
||
|
|
goto UpdateMyPicsLink_End;
|
||
|
|
}
|
||
|
|
|
||
|
|
//now construct the path to the shell link to MyPics in the MyDocs folder
|
||
|
|
wcscpy (pwszMyPicsLink, szMyDocsPath);
|
||
|
|
if (L'\\' != szMyDocsPath[MyDocsLen - 1])
|
||
|
|
{
|
||
|
|
pwszMyPicsLink[MyDocsLen] = L'\\';
|
||
|
|
pwszMyPicsLink[MyDocsLen+1] = L'\0';
|
||
|
|
}
|
||
|
|
wcscat (pwszMyPicsLink, pwszMyPicsLocName);
|
||
|
|
wcscat (pwszMyPicsLink, L".lnk");
|
||
|
|
|
||
|
|
//now obtain the path to My Pictures
|
||
|
|
hr = SHGetFolderPath (0, CSIDL_MYPICTURES | CSIDL_FLAG_DONT_VERIFY,
|
||
|
|
hUserToken, 0, szMyPicsPath);
|
||
|
|
if (S_OK != hr)
|
||
|
|
goto UpdateMyPicsLink_End;
|
||
|
|
|
||
|
|
//now find out if MyPics is a descendant of My Docs.
|
||
|
|
MyPicsLen = wcslen (szMyPicsPath);
|
||
|
|
if (0 == MyPicsLen)
|
||
|
|
{
|
||
|
|
hr = HRESULT_FROM_WIN32 (ERROR_BAD_PATHNAME);
|
||
|
|
goto UpdateMyPicsLink_End;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (MyPicsLen <= MyDocsLen ||
|
||
|
|
0 != _wcsnicmp (szMyPicsPath, szMyDocsPath, MyDocsLen)
|
||
|
|
)
|
||
|
|
{
|
||
|
|
fMyPicsFollows = FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//delete the shell link if MyPics is supposed to follow MyDocs.
|
||
|
|
if (fMyPicsFollows)
|
||
|
|
{
|
||
|
|
Status = ERROR_SUCCESS;
|
||
|
|
if (!DeleteFile (pwszMyPicsLink))
|
||
|
|
{
|
||
|
|
Status = GetLastError();
|
||
|
|
if (ERROR_PATH_NOT_FOUND == Status ||
|
||
|
|
ERROR_FILE_NOT_FOUND == Status)
|
||
|
|
Status = ERROR_SUCCESS;
|
||
|
|
}
|
||
|
|
hr = HRESULT_FROM_WIN32 (Status);
|
||
|
|
goto UpdateMyPicsLink_End;
|
||
|
|
}
|
||
|
|
|
||
|
|
//if we are here, we need to create/update the shell link.
|
||
|
|
|
||
|
|
//
|
||
|
|
// Note: We need to use SHCoCreateInstance. This is because the GP engine
|
||
|
|
// is now freethreaded whereas the threading model for CLSID_ShellLink is
|
||
|
|
// still Apartment. This means that if we use CoCreateInstance, it will
|
||
|
|
// create the object on a COM thread in its own apartment. This means that
|
||
|
|
// it will run as LocalSystem and not impersonated as the logged on user.
|
||
|
|
// This is not what we want, especially when we are creating shortcuts on
|
||
|
|
// a network share and we need to go across the wire as the logged on user
|
||
|
|
// rather than the machine account in order to authenticate successfully.
|
||
|
|
// To get around this problem, we use SHCoCreateInstance() which is an
|
||
|
|
// internal shell API that completely short-circuits COM and calls into
|
||
|
|
// shell32's DllGetClassObject directly thus creating the objects on the
|
||
|
|
// same thread. This API is primarily for shell user *ONLY* to handle crufty
|
||
|
|
// compat stuff so use this *VERY* *VERY *SPARINGLY*. If you want to do
|
||
|
|
// anything remotely fancy with IShellLink, check with the shell team to
|
||
|
|
// make sure that it is still okay to use the SHCoCreateInstance API.
|
||
|
|
//
|
||
|
|
hr = CoInitialize (NULL);
|
||
|
|
if (SUCCEEDED(hr))
|
||
|
|
bComInitialized = TRUE;
|
||
|
|
|
||
|
|
if (SUCCEEDED (hr) || RPC_E_CHANGED_MODE == hr) // If we successfully initialized COM or if it was already initialized.
|
||
|
|
{
|
||
|
|
hr = SHCoCreateInstance(NULL,
|
||
|
|
&CLSID_ShellLink,
|
||
|
|
NULL,
|
||
|
|
IID_IShellLink,
|
||
|
|
(LPVOID*)&psl);
|
||
|
|
if (FAILED(hr))
|
||
|
|
psl = NULL; // For safety.
|
||
|
|
}
|
||
|
|
if (SUCCEEDED(hr))
|
||
|
|
hr = psl->SetPath (szMyPicsPath);
|
||
|
|
if (SUCCEEDED(hr))
|
||
|
|
hr = psl->SetDescription (pwszMyPicsLocName);
|
||
|
|
if (SUCCEEDED(hr))
|
||
|
|
hr = psl->QueryInterface(IID_IPersistFile, (LPVOID*)&ppf);
|
||
|
|
if (SUCCEEDED(hr))
|
||
|
|
{
|
||
|
|
hr = ppf->Save(pwszMyPicsLink, TRUE);
|
||
|
|
ppf->Release();
|
||
|
|
}
|
||
|
|
|
||
|
|
// Release IShellLink if necessary.
|
||
|
|
if (psl)
|
||
|
|
psl->Release();
|
||
|
|
|
||
|
|
// Uninitialize COM if necessary.
|
||
|
|
if (bComInitialized)
|
||
|
|
{
|
||
|
|
CoUninitialize();
|
||
|
|
bComInitialized = FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//also cache the shell link if MyDocs is redirected to a cacheable
|
||
|
|
//network share
|
||
|
|
if (SUCCEEDED(hr) && ShareOnline == MyDocsCSCStatus)
|
||
|
|
{
|
||
|
|
Status = ERROR_SUCCESS;
|
||
|
|
bStatus = TRUE;
|
||
|
|
bStatus = CSCQueryFileStatus (pwszMyPicsLink, &dwCSCState,
|
||
|
|
&dwPinCount, &dwHints);
|
||
|
|
if (bStatus)
|
||
|
|
{
|
||
|
|
if (0 == dwPinCount && (!(dwHints & FLAG_CSC_HINT_PIN_USER)))
|
||
|
|
{
|
||
|
|
if (bStatus = CSCPinFile(pwszMyPicsLink,
|
||
|
|
FLAG_CSC_HINT_COMMAND_ALTER_PIN_COUNT,
|
||
|
|
NULL, NULL, NULL)
|
||
|
|
)
|
||
|
|
{
|
||
|
|
bStatus = CSCFillSparseFiles(pwszMyPicsLink, FALSE,
|
||
|
|
CSCCallbackProc, 0);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!bStatus)
|
||
|
|
{
|
||
|
|
Status = GetLastError();
|
||
|
|
}
|
||
|
|
|
||
|
|
hr = HRESULT_FROM_WIN32 (Status);
|
||
|
|
}
|
||
|
|
|
||
|
|
UpdateMyPicsLink_End:
|
||
|
|
if (FAILED(hr))
|
||
|
|
{
|
||
|
|
DebugMsg ((DM_VERBOSE, IDS_MYPICSLINK_FAILED, GetWin32ErrFromHResult(hr)));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
DebugMsg ((DM_VERBOSE, IDS_MYPICSLINK_SUCCEEDED, szMyDocsPath));
|
||
|
|
}
|
||
|
|
return hr;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: LoadLocalizedFolderNames
|
||
|
|
//
|
||
|
|
// Synopsis: loads the localized folder names into global objects of
|
||
|
|
// CRedirectInfo class.
|
||
|
|
//
|
||
|
|
// Arguments: none.
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS if everything was successful.
|
||
|
|
// an error code otherwise.
|
||
|
|
//
|
||
|
|
// History: 5/6/1999 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: the function bails out at the first failure. Also see notes
|
||
|
|
// on CRedirectInfo::LoadLocalizedNames.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD LoadLocalizedFolderNames (void)
|
||
|
|
{
|
||
|
|
DWORD i;
|
||
|
|
DWORD Status;
|
||
|
|
|
||
|
|
for (i = 0, Status = ERROR_SUCCESS; i < (DWORD)EndRedirectable; i++)
|
||
|
|
{
|
||
|
|
Status = gPolicyResultant[i].LoadLocalizedNames();
|
||
|
|
if (ERROR_SUCCESS == Status)
|
||
|
|
Status = gAddedPolicyResultant[i].LoadLocalizedNames();
|
||
|
|
if (ERROR_SUCCESS == Status)
|
||
|
|
Status = gDeletedPolicyResultant[i].LoadLocalizedNames();
|
||
|
|
if (ERROR_SUCCESS != Status)
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: DeleteCachedConfigFiles
|
||
|
|
//
|
||
|
|
// Synopsis: deletes the locally cached copies of fdeploy.ini for GPOs
|
||
|
|
// in a list of GPOs.
|
||
|
|
//
|
||
|
|
// Arguments: [in] pGPOList : the list of GPOs
|
||
|
|
// [in] pFileDB : a filedb object containing info. about the
|
||
|
|
// location of the files etc.
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS if all the files were successfully deleted.
|
||
|
|
// an error code otherwise.
|
||
|
|
//
|
||
|
|
// History: 5/27/1999 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: this function tries its best to delete as many files as
|
||
|
|
// possible
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD DeleteCachedConfigFiles (const PGROUP_POLICY_OBJECT pGPOList,
|
||
|
|
CFileDB * pFileDB)
|
||
|
|
{
|
||
|
|
DWORD Status = ERROR_SUCCESS;
|
||
|
|
WCHAR * pwszPath = NULL;
|
||
|
|
WCHAR * pwszEnd = NULL;
|
||
|
|
int len;
|
||
|
|
PGROUP_POLICY_OBJECT pGPO;
|
||
|
|
|
||
|
|
pwszPath = (WCHAR *) alloca (sizeof (WCHAR) * ((len = wcslen (pFileDB->GetLocalStoragePath())) + MAX_PATH + 2));
|
||
|
|
if (!pwszPath)
|
||
|
|
return ERROR_OUTOFMEMORY;
|
||
|
|
|
||
|
|
wcscpy (pwszPath, pFileDB->GetLocalStoragePath());
|
||
|
|
wcscat (pwszPath, L"\\");
|
||
|
|
pwszEnd = pwszPath + len + 1;
|
||
|
|
|
||
|
|
for (pGPO = pGPOList; pGPO; pGPO = pGPO->pNext)
|
||
|
|
{
|
||
|
|
wcscpy (pwszEnd, pGPO->szGPOName);
|
||
|
|
wcscat (pwszEnd, L".ini");
|
||
|
|
if (!DeleteFile (pwszPath) && ERROR_SUCCESS == Status)
|
||
|
|
{
|
||
|
|
Status = GetLastError();
|
||
|
|
if (ERROR_PATH_NOT_FOUND == Status ||
|
||
|
|
ERROR_FILE_NOT_FOUND == Status)
|
||
|
|
{
|
||
|
|
Status = ERROR_SUCCESS;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: SimplifyPath
|
||
|
|
//
|
||
|
|
// Synopsis: given a path, this function tries to simplify it by
|
||
|
|
// canonicalizing it and removing extra slashes by calling
|
||
|
|
// _wfullpath
|
||
|
|
//
|
||
|
|
// Arguments: [in/out] pwszPath : the given path
|
||
|
|
//
|
||
|
|
// Returns: nothing
|
||
|
|
//
|
||
|
|
// History: 5/27/1999 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: the function tries its best to simplify the path. If it fails,
|
||
|
|
// it simply returns the path supplied originally.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
void SimplifyPath (WCHAR * pwszPath)
|
||
|
|
{
|
||
|
|
size_t len;
|
||
|
|
WCHAR * pwszAbsPath;
|
||
|
|
|
||
|
|
if (!pwszPath || !pwszPath[0])
|
||
|
|
return;
|
||
|
|
|
||
|
|
len = wcslen (pwszPath);
|
||
|
|
|
||
|
|
pwszAbsPath = (WCHAR *) alloca (sizeof (WCHAR) * (len + 1));
|
||
|
|
|
||
|
|
if (!pwszAbsPath)
|
||
|
|
return;
|
||
|
|
|
||
|
|
if (NULL != _wfullpath (pwszAbsPath, pwszPath, len + 1) &&
|
||
|
|
wcslen (pwszAbsPath) <= len)
|
||
|
|
{
|
||
|
|
wcscpy (pwszPath, pwszAbsPath);
|
||
|
|
}
|
||
|
|
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: PrecreateUnicodeIniFile
|
||
|
|
//
|
||
|
|
// Synopsis: The WritePrivateProfile* functions do not write in unicode
|
||
|
|
// unless the file already exists in unicode format. Therefore,
|
||
|
|
// this function is used to precreate a unicode file so that
|
||
|
|
// the WritePrivateProfile* functions can preserve the unicodeness.
|
||
|
|
//
|
||
|
|
// Arguments: [in] lpszFilePath : the full path of the ini file.
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS if successful.
|
||
|
|
// an error code otherwise.
|
||
|
|
//
|
||
|
|
// History: 7/9/1999 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD PrecreateUnicodeIniFile (LPCTSTR lpszFilePath)
|
||
|
|
{
|
||
|
|
HANDLE hFile;
|
||
|
|
WIN32_FILE_ATTRIBUTE_DATA fad;
|
||
|
|
DWORD Status = ERROR_ALREADY_EXISTS;
|
||
|
|
DWORD dwWritten;
|
||
|
|
|
||
|
|
if (!GetFileAttributesEx (lpszFilePath, GetFileExInfoStandard, &fad))
|
||
|
|
{
|
||
|
|
if (ERROR_FILE_NOT_FOUND == (Status = GetLastError()))
|
||
|
|
{
|
||
|
|
hFile = CreateFile(lpszFilePath, GENERIC_WRITE, 0, NULL,
|
||
|
|
CREATE_NEW, FILE_ATTRIBUTE_HIDDEN, NULL);
|
||
|
|
|
||
|
|
if (hFile != INVALID_HANDLE_VALUE)
|
||
|
|
{
|
||
|
|
//add the unicode mask to the beginning of the file so that
|
||
|
|
//ReadPrivate* APIs do not accidentally think that this an ANSI
|
||
|
|
//file.
|
||
|
|
WriteFile(hFile, L"\xfeff\r\n", 3 * sizeof(WCHAR), &dwWritten, NULL);
|
||
|
|
//add a few unicode characters just to be safe.
|
||
|
|
WriteFile(hFile, L" \r\n", 7 * sizeof(WCHAR),
|
||
|
|
&dwWritten, NULL);
|
||
|
|
CloseHandle(hFile);
|
||
|
|
Status = ERROR_SUCCESS;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Status = GetLastError();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: IsPathLocal
|
||
|
|
//
|
||
|
|
// Synopsis: this function determines if a given path is a local path
|
||
|
|
// or a UNC path.
|
||
|
|
//
|
||
|
|
// Arguments: pwszPath : the full path of the file.
|
||
|
|
//
|
||
|
|
// Returns: FALSE : if it is a UNC path.
|
||
|
|
// TRUE : otherwise
|
||
|
|
//
|
||
|
|
// History: 7/30/1999 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: this function basically returns TRUE unless the first
|
||
|
|
// characters of the supplied path are '\'.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
BOOL IsPathLocal (LPCWSTR pwszPath)
|
||
|
|
{
|
||
|
|
if (NULL == pwszPath || 2 > wcslen (pwszPath))
|
||
|
|
return TRUE; //assume local
|
||
|
|
|
||
|
|
if (L'\\' == pwszPath[0] && L'\\' == pwszPath[1])
|
||
|
|
return FALSE;
|
||
|
|
|
||
|
|
return TRUE; //local in all other cases.
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: ExpandPathSpecial
|
||
|
|
//
|
||
|
|
// Synopsis: expands a path using a given user name.
|
||
|
|
//
|
||
|
|
// Arguments: [in] pFileDB : pointer to the CFileDB object
|
||
|
|
// [in] pwszPath : pointer to the path to be expanded.
|
||
|
|
// [in] pwszUserName : the user name to be used in expansion
|
||
|
|
// [out] wszExpandedPath : the expanded path.
|
||
|
|
// [in, out] pDesiredBufferSize (optional) : on input, the size
|
||
|
|
// of the wszExpandedPath buffer. On output, the size needed
|
||
|
|
// to expand the path to that buffer. This may be NULL, in which
|
||
|
|
// case the buffer is assumed to be TARGETPATHLIMIT size.
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS : if the expanded path was successfully obtained.
|
||
|
|
// STATUS_BUFFER_TOO_SMALL : if the expanded path was too large
|
||
|
|
// to fit in the supplied buffer.
|
||
|
|
// other win32 error codes based on what goes wrong.
|
||
|
|
//
|
||
|
|
// History: 9/20/1999 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: wszExpandedPath is assumed to be a buffer containing
|
||
|
|
// TARGETPATHLIMIT characters, unlesss pDesiredBufferSize
|
||
|
|
// is specified. It is the caller's responsibility
|
||
|
|
// to allocate/free this memory. This function does not try to
|
||
|
|
// validate the memory that wszExpandedPath points to.
|
||
|
|
//
|
||
|
|
// This function is also not equipped to handle multiple
|
||
|
|
// occurrences of the %username% substring in the last path.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD ExpandPathSpecial (
|
||
|
|
CFileDB * pFileDB,
|
||
|
|
const WCHAR * pwszPath,
|
||
|
|
const WCHAR * pwszUserName,
|
||
|
|
WCHAR * wszExpandedPath,
|
||
|
|
ULONG * pDesiredBufferSize
|
||
|
|
)
|
||
|
|
{
|
||
|
|
DWORD Status = ERROR_SUCCESS;
|
||
|
|
UNICODE_STRING Path;
|
||
|
|
UNICODE_STRING ExpandedPath;
|
||
|
|
WCHAR wszLastPath [TARGETPATHLIMIT];
|
||
|
|
WCHAR * wszTemp = NULL;
|
||
|
|
WCHAR wszSuffix [TARGETPATHLIMIT];
|
||
|
|
|
||
|
|
if (TARGETPATHLIMIT <= wcslen(pwszPath))
|
||
|
|
return STATUS_BUFFER_TOO_SMALL;
|
||
|
|
|
||
|
|
wszSuffix[0] = L'\0';
|
||
|
|
wszLastPath[0] = L'\0';
|
||
|
|
|
||
|
|
wcscpy (wszLastPath, pwszPath);
|
||
|
|
//convert it to lower case. useful while searching for other strings
|
||
|
|
//within the string.
|
||
|
|
_wcslwr (wszLastPath);
|
||
|
|
|
||
|
|
//
|
||
|
|
// If the caller does not specify a user name, just use environment
|
||
|
|
// variable substitution to take care of %username% instead of
|
||
|
|
// doing it ourselves
|
||
|
|
//
|
||
|
|
if ( pwszUserName )
|
||
|
|
{
|
||
|
|
//the username has changed since the last logon. must first substitute
|
||
|
|
//the occurence of %username% if any with the supplied user name
|
||
|
|
wszTemp = wcsstr (wszLastPath, L"%username%");
|
||
|
|
}
|
||
|
|
|
||
|
|
//if the %username% string is not present, nothing more needs to be
|
||
|
|
//done. we can just go ahead and expand what we've got.
|
||
|
|
if (NULL != wszTemp)
|
||
|
|
{
|
||
|
|
//the last path contains %username%
|
||
|
|
//get the parts that appear before and after the %username% string
|
||
|
|
//reuse wszLastPath for the prefix
|
||
|
|
*wszTemp = L'\0';
|
||
|
|
wcscpy (wszSuffix, wszTemp + 10); //go past %username%
|
||
|
|
|
||
|
|
//make sure that we are not running out of space.
|
||
|
|
if (TARGETPATHLIMIT <=
|
||
|
|
wcslen (wszLastPath) +
|
||
|
|
wcslen (pwszUserName) +
|
||
|
|
wcslen (wszSuffix))
|
||
|
|
{
|
||
|
|
return STATUS_BUFFER_TOO_SMALL;
|
||
|
|
}
|
||
|
|
wcscat (wszLastPath, pwszUserName);
|
||
|
|
wcscat (wszLastPath, wszSuffix);
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// In planning mode, we are only interested in %username% --
|
||
|
|
// any other environment variables can remain unexpanded since
|
||
|
|
// they may depend on local state to which we do not have access
|
||
|
|
// in planning mode.
|
||
|
|
//
|
||
|
|
if ( pFileDB->GetRsopContext()->IsPlanningModeEnabled() )
|
||
|
|
{
|
||
|
|
if ( ERROR_SUCCESS == Status )
|
||
|
|
{
|
||
|
|
lstrcpy( wszExpandedPath, wszLastPath );
|
||
|
|
}
|
||
|
|
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
USHORT ExpandedBufferMax;
|
||
|
|
|
||
|
|
ExpandedBufferMax = (USHORT)(pDesiredBufferSize ? *pDesiredBufferSize : TARGETPATHLIMIT);
|
||
|
|
|
||
|
|
//now expand other variables in the path
|
||
|
|
Path.Length = (wcslen (wszLastPath) + 1) * sizeof (WCHAR);
|
||
|
|
Path.MaximumLength = sizeof (wszLastPath);
|
||
|
|
Path.Buffer = wszLastPath;
|
||
|
|
|
||
|
|
ExpandedPath.Length = 0;
|
||
|
|
ExpandedPath.MaximumLength = ExpandedBufferMax * sizeof (WCHAR);
|
||
|
|
ExpandedPath.Buffer = wszExpandedPath;
|
||
|
|
|
||
|
|
Status = RtlExpandEnvironmentStrings_U (
|
||
|
|
pFileDB->GetEnvBlock(),
|
||
|
|
&Path,
|
||
|
|
&ExpandedPath,
|
||
|
|
pDesiredBufferSize
|
||
|
|
);
|
||
|
|
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: ExpandHomeDir
|
||
|
|
//
|
||
|
|
// Synopsis: Expands the HOMEDIR component in the path.
|
||
|
|
//
|
||
|
|
// Arguments: [in] rID : the id of the folder
|
||
|
|
// [in] pwszPath : the unexpanded path
|
||
|
|
// [in] bAllowMyPics : allow expansion of homedir for MyPics
|
||
|
|
// [out] ppwszExpandedPath : the expanded result
|
||
|
|
// [in, optional] pwszHomedir : the value of homedir to be used in substitution
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS : if successful.
|
||
|
|
// a Win32 error code otherwise.
|
||
|
|
//
|
||
|
|
// History: 3/10/2000 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: This function has the following additional restrictions:
|
||
|
|
// (a) It is a no-op for all folders except MyDocs and MyPics.
|
||
|
|
// (b) It only acts on paths that begin with
|
||
|
|
// %HOMESHARE%%HOMEPATH%
|
||
|
|
//
|
||
|
|
// Also, if the function does not return ERROR_SUCCESS, then
|
||
|
|
// *ppwszExpandedPath can be null.
|
||
|
|
//
|
||
|
|
// if the caller does not supply the homedir value for
|
||
|
|
// substitution, the value is obtained from the user object.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD ExpandHomeDir (IN REDIRECTABLE rID,
|
||
|
|
IN const WCHAR * pwszPath,
|
||
|
|
BOOL bAllowMyPics,
|
||
|
|
OUT WCHAR ** ppwszExpandedPath,
|
||
|
|
IN const WCHAR * pwszHomedir // = NULL
|
||
|
|
)
|
||
|
|
{
|
||
|
|
DWORD Status = ERROR_SUCCESS;
|
||
|
|
int len;
|
||
|
|
const WCHAR * wszSuffix;
|
||
|
|
int expandedLen;
|
||
|
|
int lenHomedir;
|
||
|
|
|
||
|
|
// First free the supplied buffer if necessary
|
||
|
|
if (*ppwszExpandedPath)
|
||
|
|
{
|
||
|
|
delete [] *ppwszExpandedPath;
|
||
|
|
*ppwszExpandedPath = NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (! pwszPath || L'\0' == *pwszPath)
|
||
|
|
{
|
||
|
|
Status = ERROR_BAD_PATHNAME;
|
||
|
|
goto ExpandHomeDir_End;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Proceed only if the HOMEDIR component is in the right place.
|
||
|
|
if (! IsHomedirPath (rID, pwszPath, bAllowMyPics))
|
||
|
|
{
|
||
|
|
if (! HasHomeVariables (pwszPath))
|
||
|
|
{
|
||
|
|
goto ExpandHomeDir_ReturnSame;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
// This is not a homedir path, so it is not supposed to have any home variables
|
||
|
|
Status = ERROR_BAD_PATHNAME;
|
||
|
|
goto ExpandHomeDir_End;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// If we are here, then we need to substitute the HOMEDIR part
|
||
|
|
// with the actual home directory. We use the current homedir value
|
||
|
|
// only if the caller hasn't already supplied us with one.
|
||
|
|
//
|
||
|
|
len = lstrlen (HOMEDIR_STR);
|
||
|
|
if (! pwszHomedir)
|
||
|
|
pwszHomedir = gUserInfo.GetHomeDir(Status);
|
||
|
|
//
|
||
|
|
// At this point, pwszHomeDir can be NULL even if Status is ERROR_SUCCESS
|
||
|
|
// This happens if the user object does not have a homedir set on it
|
||
|
|
// So we must fail even in that case.
|
||
|
|
//
|
||
|
|
if (! pwszHomedir || ERROR_SUCCESS != Status)
|
||
|
|
{
|
||
|
|
// Do not clobber status set by GetHomeDir if it had failed.
|
||
|
|
Status = (ERROR_SUCCESS == Status) ? ERROR_BAD_PATHNAME : Status;
|
||
|
|
goto ExpandHomeDir_End;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Now we have everything we need to proceed.
|
||
|
|
// First allocate the required buffer.
|
||
|
|
//
|
||
|
|
lenHomedir = lstrlen (pwszHomedir);
|
||
|
|
expandedLen = lenHomedir + lstrlen (&pwszPath[len]);
|
||
|
|
*ppwszExpandedPath = new WCHAR [expandedLen + 1];
|
||
|
|
if (! *ppwszExpandedPath)
|
||
|
|
{
|
||
|
|
Status = ERROR_OUTOFMEMORY;
|
||
|
|
goto ExpandHomeDir_End;
|
||
|
|
}
|
||
|
|
// Generate the new path.
|
||
|
|
lstrcpy (*ppwszExpandedPath, pwszHomedir);
|
||
|
|
|
||
|
|
// Append the suffix
|
||
|
|
wszSuffix = &pwszPath[len];
|
||
|
|
// Eliminate duplicate '\' characters
|
||
|
|
if (L'\\' == (*ppwszExpandedPath)[lenHomedir - 1] && L'\\' == pwszPath[len])
|
||
|
|
wszSuffix++;
|
||
|
|
lstrcat (*ppwszExpandedPath, wszSuffix);
|
||
|
|
|
||
|
|
DebugMsg ((DM_VERBOSE, IDS_HOMEDIR_EXPANDED, pwszPath, *ppwszExpandedPath));
|
||
|
|
|
||
|
|
goto ExpandHomeDir_End;
|
||
|
|
|
||
|
|
//
|
||
|
|
// If we are here, then, there was no error, but no substitution was
|
||
|
|
// necessary either. So we just return the same path.
|
||
|
|
//
|
||
|
|
|
||
|
|
ExpandHomeDir_ReturnSame:
|
||
|
|
len = lstrlen (pwszPath);
|
||
|
|
*ppwszExpandedPath = new WCHAR [len + 1];
|
||
|
|
if (! *ppwszExpandedPath)
|
||
|
|
{
|
||
|
|
Status = ERROR_OUTOFMEMORY;
|
||
|
|
goto ExpandHomeDir_End;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Copy the path.
|
||
|
|
lstrcpy (*ppwszExpandedPath, pwszPath);
|
||
|
|
Status = ERROR_SUCCESS;
|
||
|
|
|
||
|
|
ExpandHomeDir_End:
|
||
|
|
if (ERROR_SUCCESS != Status)
|
||
|
|
{
|
||
|
|
DebugMsg ((DM_VERBOSE, IDS_HOMEDIR_EXPAND_FAIL, pwszPath, Status));
|
||
|
|
}
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: ExpandHomeDirPolicyPath
|
||
|
|
//
|
||
|
|
// Synopsis: Expands the HOMEDIR component in the path as specified in the
|
||
|
|
// ini file (ones that begin with \\%HOMESHARE%%HOMEPATH%)
|
||
|
|
//
|
||
|
|
// Arguments: [in] rID : the id of the folder
|
||
|
|
// [in] pwszPath : the unexpanded path
|
||
|
|
// [in] bAllowMyPics : allow expansion of homedir for MyPics
|
||
|
|
// [out] ppwszExpandedPath : the expanded result
|
||
|
|
// [in, optional] pwszHomedir : the value of homedir to be used in substitution
|
||
|
|
//
|
||
|
|
// Returns: ERROR_SUCCESS : if successful.
|
||
|
|
// a Win32 error code otherwise.
|
||
|
|
//
|
||
|
|
// History: 3/10/2000 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: This function has the following additional restrictions:
|
||
|
|
// (a) It is a no-op for all folders except MyDocs and MyPics.
|
||
|
|
// (b) It only acts on paths that begin with
|
||
|
|
// \\%HOMESHARE%%HOMEPATH% or %HOMESHARE%%HOMEPATH%
|
||
|
|
//
|
||
|
|
// Also, if the function does not return ERROR_SUCCESS, then
|
||
|
|
// *ppwszExpandedPath can be null.
|
||
|
|
//
|
||
|
|
// if the caller does not supply the homedir value for
|
||
|
|
// substitution, the value is obtained from the user object.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD ExpandHomeDirPolicyPath (IN REDIRECTABLE rID,
|
||
|
|
IN const WCHAR * pwszPath,
|
||
|
|
IN BOOL bAllowMyPics,
|
||
|
|
OUT WCHAR ** ppwszExpandedPath,
|
||
|
|
IN const WCHAR * pwszHomedir // = NULL
|
||
|
|
)
|
||
|
|
{
|
||
|
|
if (IsHomedirPolicyPath(rID, pwszPath, bAllowMyPics))
|
||
|
|
{
|
||
|
|
return ExpandHomeDir (rID,
|
||
|
|
&pwszPath[2],
|
||
|
|
bAllowMyPics,
|
||
|
|
ppwszExpandedPath,
|
||
|
|
pwszHomedir
|
||
|
|
);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
return ExpandHomeDir (rID,
|
||
|
|
pwszPath,
|
||
|
|
bAllowMyPics,
|
||
|
|
ppwszExpandedPath,
|
||
|
|
pwszHomedir
|
||
|
|
);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: IsHomedirPath
|
||
|
|
//
|
||
|
|
// Synopsis: determines if a given redirection destination is in the homedir.
|
||
|
|
// This means all paths that begin with %HOMESHARE%%HOMEPATH
|
||
|
|
//
|
||
|
|
// Arguments: [in] rID : The folder identifier.
|
||
|
|
// [in] pwszPath : The path.
|
||
|
|
// [in] bAllowMyPics : allow homedir paths for MyPics folder
|
||
|
|
//
|
||
|
|
// Returns: TRUE : if it is a homedir path
|
||
|
|
// FALSE: otherwise.
|
||
|
|
//
|
||
|
|
// History: 3/12/2000 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: This function returns FALSE for all folders other than
|
||
|
|
// MyDocs because that is the only folder for which redirection
|
||
|
|
// to the home directory is permitted.
|
||
|
|
//
|
||
|
|
// See additional notes about bAllowMyPics in the comments above
|
||
|
|
// IsHomedirPolicyPath
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
BOOL IsHomedirPath (IN REDIRECTABLE rID, IN LPCWSTR pwszPath, BOOL bAllowMyPics)
|
||
|
|
{
|
||
|
|
int len;
|
||
|
|
|
||
|
|
if ((MyDocs != rID && (MyPics != rID || !bAllowMyPics)) ||
|
||
|
|
! pwszPath ||
|
||
|
|
L'\0' == *pwszPath)
|
||
|
|
{
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//
|
||
|
|
// Make sure that the length of the path is longer than that of
|
||
|
|
// %HOMESHARE%%HOMEPATH. If not, there is no way that this can be
|
||
|
|
// a homedir path
|
||
|
|
//
|
||
|
|
len = lstrlen (HOMEDIR_STR);
|
||
|
|
if (lstrlen (pwszPath) < len)
|
||
|
|
return FALSE;
|
||
|
|
|
||
|
|
// If we are here, we need to compare the two strings
|
||
|
|
if (0 == _wcsnicmp (HOMEDIR_STR, pwszPath, len) &&
|
||
|
|
(L'\0' == pwszPath[len] || L'\\' == pwszPath[len]) &&
|
||
|
|
NULL == wcschr (&pwszPath[len], L'%') // no other variable names allowed
|
||
|
|
)
|
||
|
|
{
|
||
|
|
// If all the conditions above are met, then this is indeed a homedir path
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
// If we are here, this cannot be a homedir path.
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: IsHomedirPolicyPath
|
||
|
|
//
|
||
|
|
// Synopsis: determines if a given redirection destination is in the homedir.
|
||
|
|
// This means all paths that begin with \\%HOMESHARE%%HOMEPATH
|
||
|
|
//
|
||
|
|
// Arguments: [in] rID : The folder identifier.
|
||
|
|
// [in] pwszPath : The path.
|
||
|
|
// [in] bAllowMyPics : Allow MyPics to have a homedir path
|
||
|
|
//
|
||
|
|
// Returns: TRUE : if it is a homedir path as specified in the ini file
|
||
|
|
// FALSE: otherwise.
|
||
|
|
//
|
||
|
|
// History: 3/12/2000 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: This function returns FALSE for all folders other than
|
||
|
|
// MyDocs & MyPics because that is the only folder for which
|
||
|
|
// redirection to the home directory is permitted.
|
||
|
|
//
|
||
|
|
// Note: redirection to HOMEDIR is permitted for MyPics only
|
||
|
|
// if it is set to follow MyDocs. Not otherwise. That is why
|
||
|
|
// we need the third parameter.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
BOOL IsHomedirPolicyPath (IN REDIRECTABLE rID,
|
||
|
|
IN LPCWSTR pwszPath,
|
||
|
|
IN BOOL bAllowMyPics)
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// It is a homedir path as specified by the policy if it begins
|
||
|
|
// with \\%HOMESHARE%%HOMEPATH%
|
||
|
|
//
|
||
|
|
if ((MyDocs == rID || (MyPics == rID && bAllowMyPics)) &&
|
||
|
|
pwszPath &&
|
||
|
|
lstrlen (pwszPath) > 2 &&
|
||
|
|
L'\\' == pwszPath[0] &&
|
||
|
|
L'\\' == pwszPath[1] )
|
||
|
|
{
|
||
|
|
return IsHomedirPath (rID, &pwszPath[2], bAllowMyPics);
|
||
|
|
}
|
||
|
|
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: HasHomeVariables
|
||
|
|
//
|
||
|
|
// Synopsis: finds if a given string has any of the home variables
|
||
|
|
// i.e. HOMESHARE, HOMEPATH or HOMEDRIVE
|
||
|
|
//
|
||
|
|
// Arguments: [in] pwszPath : the path string
|
||
|
|
//
|
||
|
|
// Returns: TRUE: if the path has home variables.
|
||
|
|
// FALSE: otherwise
|
||
|
|
//
|
||
|
|
// History: 3/22/2000 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: This function is required because we do not wish to allow
|
||
|
|
// these variables in the path except in highly restricted
|
||
|
|
// conditions, viz. My Docs redirection that begins with
|
||
|
|
// \\%HOMESHARE%%HOMEPATH%
|
||
|
|
//
|
||
|
|
// Therefore, we need to explicitly check for the existence of
|
||
|
|
// variables in paths that don't meet these requirements.
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
BOOL HasHomeVariables (IN LPCWSTR pwszPath)
|
||
|
|
{
|
||
|
|
WCHAR * pszTmp;
|
||
|
|
|
||
|
|
pszTmp = wcschr (pwszPath, L'%');
|
||
|
|
|
||
|
|
while (pszTmp)
|
||
|
|
{
|
||
|
|
if (0 == _wcsnicmp (HOMESHARE_VARIABLE, pszTmp, HOMESHARE_VARLEN) ||
|
||
|
|
0 == _wcsnicmp (HOMEDRIVE_VARIABLE, pszTmp, HOMEDRIVE_VARLEN) ||
|
||
|
|
0 == _wcsnicmp (HOMEPATH_VARIABLE, pszTmp, HOMEPATH_VARLEN))
|
||
|
|
{
|
||
|
|
return TRUE;
|
||
|
|
}
|
||
|
|
|
||
|
|
pszTmp = wcschr (pszTmp + 1, L'%');
|
||
|
|
}
|
||
|
|
|
||
|
|
// If we are here, we did not find any home variables in the path.
|
||
|
|
return FALSE;
|
||
|
|
}
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: GetWin32ErrFromHResult
|
||
|
|
//
|
||
|
|
// Synopsis: given an HResult, this function tries to extract the
|
||
|
|
// corresponding Win 32 error.
|
||
|
|
//
|
||
|
|
// Arguments: [in] hr : the hresult value
|
||
|
|
//
|
||
|
|
// Returns: the Win 32 Error code.
|
||
|
|
//
|
||
|
|
// History: 3/13/2000 RahulTh created
|
||
|
|
//
|
||
|
|
// Notes: if hr is not S_OK, the return value will be something other
|
||
|
|
// than ERROR_SUCCESS;
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD GetWin32ErrFromHResult (IN HRESULT hr)
|
||
|
|
{
|
||
|
|
DWORD Status = ERROR_SUCCESS;
|
||
|
|
|
||
|
|
if (S_OK != hr)
|
||
|
|
{
|
||
|
|
if (FACILITY_WIN32 == HRESULT_FACILITY(hr))
|
||
|
|
{
|
||
|
|
Status = HRESULT_CODE(hr);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Status = GetLastError();
|
||
|
|
if (ERROR_SUCCESS == Status)
|
||
|
|
{
|
||
|
|
//an error had occurred but nobody called SetLastError
|
||
|
|
//should not be mistaken as a success.
|
||
|
|
Status = (DWORD) hr;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//+--------------------------------------------------------------------------
|
||
|
|
//
|
||
|
|
// Function: GetExpandedPath
|
||
|
|
//
|
||
|
|
// Synopsis: given a redirected path that may contain environment variables,
|
||
|
|
// evaluates the variables to produce a fully realized path
|
||
|
|
//
|
||
|
|
// Arguments: [in] pFileDB : object containing general context information
|
||
|
|
// [in] wszSourcePath : the unexpanded path
|
||
|
|
// [in] rID : The folder identifier.
|
||
|
|
// [in] bAllowMyPics : allow homedir paths for MyPics folder
|
||
|
|
// [out] ppwszExpandedPath -- on output, the address of the
|
||
|
|
// expanded path, must be freed by the caller
|
||
|
|
//
|
||
|
|
// Returns: the Win 32 Error code.
|
||
|
|
//
|
||
|
|
// History: 5/30/2000 AdamEd created
|
||
|
|
//
|
||
|
|
// Notes:
|
||
|
|
//
|
||
|
|
//---------------------------------------------------------------------------
|
||
|
|
DWORD
|
||
|
|
GetExpandedPath(
|
||
|
|
IN CFileDB* pFileDB,
|
||
|
|
IN WCHAR* wszSourcePath,
|
||
|
|
IN int rID,
|
||
|
|
IN BOOL bAllowMyPics,
|
||
|
|
OUT WCHAR** ppwszExpandedPath)
|
||
|
|
{
|
||
|
|
WCHAR* wszDestination;
|
||
|
|
WCHAR* wszHomeDir;
|
||
|
|
DWORD Status;
|
||
|
|
|
||
|
|
const WCHAR* wszUserName;
|
||
|
|
|
||
|
|
*ppwszExpandedPath = NULL;
|
||
|
|
|
||
|
|
|
||
|
|
wszDestination = NULL;
|
||
|
|
wszHomeDir = NULL;
|
||
|
|
|
||
|
|
wszUserName = NULL;
|
||
|
|
|
||
|
|
//
|
||
|
|
// In diagnostic mode, we will end up expanding %username% and
|
||
|
|
// the %homedir% and %homepath% vars, as well as any other variables that
|
||
|
|
// are defined, but in planning mode we will only
|
||
|
|
// handle the first 3, and we only do so if a specific user account
|
||
|
|
//
|
||
|
|
if ( pFileDB->GetRsopContext()->IsPlanningModeEnabled() )
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// In planning mode, the thread context is not that
|
||
|
|
// of the desired user, so we must override it
|
||
|
|
//
|
||
|
|
wszUserName = gUserInfo.GetUserName( Status );
|
||
|
|
|
||
|
|
if ( ERROR_SUCCESS != Status )
|
||
|
|
{
|
||
|
|
goto GetExpandedPath_Exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( ! wszUserName )
|
||
|
|
{
|
||
|
|
//
|
||
|
|
// In planning mode, GetUserName can return success
|
||
|
|
// but return a NULL username -- this means that
|
||
|
|
// the planning mode target contained only a SOM, not a user
|
||
|
|
// name, so we can accept the blank user name and cease
|
||
|
|
// further expansion attempts -- we cannot expand %username%
|
||
|
|
// or the %home%* variables if we do not have a user account. Thus,
|
||
|
|
// we use the unexpanded path.
|
||
|
|
//
|
||
|
|
wszDestination = StringDuplicate( wszSourcePath );
|
||
|
|
|
||
|
|
if ( ! wszDestination )
|
||
|
|
{
|
||
|
|
Status = ERROR_NOT_ENOUGH_MEMORY;
|
||
|
|
}
|
||
|
|
|
||
|
|
goto GetExpandedPath_Exit;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
Status = ExpandHomeDirPolicyPath(
|
||
|
|
(REDIRECTABLE) rID,
|
||
|
|
wszSourcePath,
|
||
|
|
bAllowMyPics,
|
||
|
|
&wszHomeDir);
|
||
|
|
|
||
|
|
if ( ERROR_SUCCESS != Status )
|
||
|
|
{
|
||
|
|
goto GetExpandedPath_Exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
USHORT cchDestination;
|
||
|
|
ULONG ReturnedLength;
|
||
|
|
NTSTATUS NtStatus;
|
||
|
|
|
||
|
|
cchDestination = TARGETPATHLIMIT;
|
||
|
|
|
||
|
|
wszDestination = new WCHAR [ cchDestination + 1 ];
|
||
|
|
|
||
|
|
if ( ! wszDestination )
|
||
|
|
{
|
||
|
|
goto GetExpandedPath_Exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
ReturnedLength = cchDestination * sizeof( *wszDestination );
|
||
|
|
|
||
|
|
NtStatus = ExpandPathSpecial(
|
||
|
|
pFileDB,
|
||
|
|
wszHomeDir,
|
||
|
|
wszUserName,
|
||
|
|
wszDestination,
|
||
|
|
&ReturnedLength);
|
||
|
|
|
||
|
|
if ( STATUS_BUFFER_TOO_SMALL == NtStatus )
|
||
|
|
{
|
||
|
|
delete [] wszDestination;
|
||
|
|
|
||
|
|
wszDestination = new WCHAR [ ReturnedLength / sizeof( *wszDestination ) + 1 ];
|
||
|
|
|
||
|
|
if ( ! wszDestination )
|
||
|
|
{
|
||
|
|
Status = ERROR_NOT_ENOUGH_MEMORY;
|
||
|
|
goto GetExpandedPath_Exit;
|
||
|
|
}
|
||
|
|
|
||
|
|
NtStatus = ExpandPathSpecial(
|
||
|
|
pFileDB,
|
||
|
|
wszHomeDir,
|
||
|
|
wszUserName,
|
||
|
|
wszDestination,
|
||
|
|
&ReturnedLength);
|
||
|
|
}
|
||
|
|
|
||
|
|
if ( STATUS_SUCCESS != NtStatus )
|
||
|
|
{
|
||
|
|
Status = RtlNtStatusToDosError( NtStatus );
|
||
|
|
}
|
||
|
|
|
||
|
|
GetExpandedPath_Exit:
|
||
|
|
|
||
|
|
delete [] wszHomeDir;
|
||
|
|
|
||
|
|
if ( ERROR_SUCCESS != Status )
|
||
|
|
{
|
||
|
|
delete [] wszDestination;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
*ppwszExpandedPath = wszDestination;
|
||
|
|
}
|
||
|
|
|
||
|
|
return Status;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|
||
|
|
|