able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/termsrv/tsappcmp/allusrsm.c
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

1081 lines
30 KiB
C
Raw Blame History

/*************************************************************************
*
* allusrsm.c
*
* Move items from a user's start menu to the All Users start menu
*
* copyright notice: Copyright 1998 Micrsoft
*
* When entering install mode, if the start menu snapshot file already
* exists, don't overwrite it. Otherwise, some shortcuts may not get moved
* over. This fixes a problem where an App reboots the machine when it
* finishes installing, without giving the user a chance to switch back to
* execute mode. Now, when the user logs in again, the menu shortcuts will
* be moved because winlogon always does a "change user /install" and then
* "change user /execute". (That's to support RunOnce programs.)
* MS 1057
*
*
*************************************************************************/
#include "precomp.h"
#pragma hdrstop
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <windows.h>
#include <userenv.h>
#include <shlobj.h>
// This program takes a snapshot of the Current User's start menu and
// saves it to a file. When run with the /c option, it compares the
// snapshot to the present contents of the Current User's start menu.
// Each new or changed file/directory is then moved to the All Users
// start menu. Additionally, Read permission is granted to the Everyone
// group for each moved file or directory.
typedef struct File_Struct {
struct File_Struct *Next; // Only used in Memory
WCHAR FileName[MAX_PATH];
BOOL TimeValid;
SYSTEMTIME Time;
} FILENODE, *PFILENODE;
typedef struct Path_Struct {
DWORD FilesInDir;
struct Path_Struct *Next; // Only used in Memory
PFILENODE FileHead; // Only used in Memory
PFILENODE FileTail; // Only used in Memory
WCHAR PathStr[MAX_PATH];
} PATHNODE, *PPATHNODE;
typedef struct Tree_Struct {
DWORD NumPaths;
PPATHNODE PathHead;
PPATHNODE PathTail;
} TREENODE, *PTREENODE;
typedef struct RemoveDir_Struct {
WCHAR PathStr[MAX_PATH];
struct RemoveDir_Struct *Next;
} REMOVEDIRLIST, *PPREMOVEDIRLIST;
int RunMode;
WCHAR SaveName[MAX_PATH];
WCHAR CurUserDir[MAX_PATH];
WCHAR AllUserDir[MAX_PATH];
int CurUserDirLen;
WCHAR StartMenu[MAX_PATH]=L"";
void ReadTree(PTREENODE Tree, WCHAR *Dir);
#define SD_SIZE (65536 + SECURITY_DESCRIPTOR_MIN_LENGTH)
////////////////////////////////////////////////////////////////////////////
BOOLEAN FileExists( WCHAR *path )
{
return( GetFileAttributes(path) == -1 ? FALSE : TRUE );
}
////////////////////////////////////////////////////////////////////////////
NTSTATUS CreateNewSecurityDescriptor( PSECURITY_DESCRIPTOR *ppNewSD,
PSECURITY_DESCRIPTOR pSD,
PACL pAcl )
/*++
Routine Description:
From a SD and a Dacl, create a new SD. The new SD will be fully self
contained (it is self relative) and does not have pointers to other
structures.
Arguments:
ppNewSD - used to return the new SD. Caller should free with LocalFree
pSD - the self relative SD we use to build the new SD
pAcl - the new DACL that will be used for the new SD
Return Value:
NTSTATUS code
--*/
{
PACL pSacl;
PSID psidGroup, psidOwner;
BOOLEAN fSaclPres;
BOOLEAN fSaclDef, fGroupDef, fOwnerDef;
ULONG NewSDSize;
SECURITY_DESCRIPTOR NewSD;
PSECURITY_DESCRIPTOR pNewSD;
NTSTATUS Status;
// extract the originals from the security descriptor
Status = RtlGetSaclSecurityDescriptor(pSD, &fSaclPres, &pSacl, &fSaclDef);
if (!NT_SUCCESS(Status))
return(Status);
Status = RtlGetOwnerSecurityDescriptor(pSD, &psidOwner, &fOwnerDef);
if (!NT_SUCCESS(Status))
return(Status);
Status = RtlGetGroupSecurityDescriptor(pSD, &psidGroup, &fGroupDef);
if (!NT_SUCCESS(Status))
return(Status);
// now create a new SD and set the info in it. we cannot return this one
// since it has pointers to old SD.
Status = RtlCreateSecurityDescriptor(&NewSD, SECURITY_DESCRIPTOR_REVISION);
if (!NT_SUCCESS(Status))
return(Status);
Status = RtlSetDaclSecurityDescriptor(&NewSD, TRUE, pAcl, FALSE);
if (!NT_SUCCESS(Status))
return(Status);
Status = RtlSetSaclSecurityDescriptor(&NewSD, fSaclPres, pSacl, fSaclDef);
if (!NT_SUCCESS(Status))
return(Status);
Status = RtlSetOwnerSecurityDescriptor(&NewSD, psidOwner, fOwnerDef);
if (!NT_SUCCESS(Status))
return(Status);
Status = RtlSetGroupSecurityDescriptor(&NewSD, psidGroup, fGroupDef);
if (!NT_SUCCESS(Status))
return(Status);
// calculate size needed for the returned SD and allocated it
NewSDSize = RtlLengthSecurityDescriptor(&NewSD);
pNewSD = (PSECURITY_DESCRIPTOR) LocalAlloc(LMEM_FIXED, NewSDSize);
if (pNewSD == NULL)
return(STATUS_INSUFFICIENT_RESOURCES);
// convert the absolute to self relative
Status = RtlAbsoluteToSelfRelativeSD(&NewSD, pNewSD, &NewSDSize);
if (NT_SUCCESS(Status))
*ppNewSD = pNewSD;
else
LocalFree(pNewSD);
return(Status);
} // CreateNewSecurityDescriptor
/////////////////////////////////////////////////////////////////////////
// Add Read and Execute permissions for built in "Everyone" Group to
// the indicated file.
BOOLEAN APIENTRY AddEveryoneRXPermissionW( LPCWSTR lpFileName)
{
NTSTATUS Status;
BOOLEAN ExitVal = FALSE;
HANDLE FileHandle=NULL;
OBJECT_ATTRIBUTES Obja;
UNICODE_STRING FileName;
RTL_RELATIVE_NAME RelativeName;
BOOLEAN TranslationStatus;
IO_STATUS_BLOCK IoStatusBlock;
PVOID FreeBuffer;
PSECURITY_DESCRIPTOR pSD = NULL;
PSECURITY_DESCRIPTOR pNewSD = NULL;
DWORD LengthNeeded = 0;
static PACCESS_ALLOWED_ACE pNewAce = NULL;
static USHORT NewAceSize;
ACL Acl;
PACL pAcl, pNewAcl = NULL;
BOOLEAN fDaclPresent, fDaclDef;
USHORT NewAclSize;
////////////////////////////////////////////////////////////////////////
// First time through this routine, create an ACE for the built-in
// "Everyone" group.
////////////////////////////////////////////////////////////////////////
if (pNewAce == NULL)
{
PSID psidEveryone = NULL;
SID_IDENTIFIER_AUTHORITY WorldSidAuthority = SECURITY_WORLD_SID_AUTHORITY;
// Get the SID of the built-in Everyone group
Status = RtlAllocateAndInitializeSid( &WorldSidAuthority, 1,
SECURITY_WORLD_RID, 0,0,0,0,0,0,0, &psidEveryone);
if (!NT_SUCCESS(Status))
goto ErrorExit;
// allocate and initialize new ACE
NewAceSize = (USHORT)(sizeof(ACE_HEADER) + sizeof(ACCESS_MASK) +
RtlLengthSid(psidEveryone));
pNewAce = (PACCESS_ALLOWED_ACE) LocalAlloc(LMEM_FIXED, NewAceSize);
if (pNewAce == NULL)
goto ErrorExit;
pNewAce->Header.AceFlags = (UCHAR) CONTAINER_INHERIT_ACE |
OBJECT_INHERIT_ACE ;
pNewAce->Header.AceType = ACCESS_ALLOWED_ACE_TYPE;
pNewAce->Header.AceSize = NewAceSize;
pNewAce->Mask = FILE_GENERIC_READ | FILE_EXECUTE;
RtlCopySid(RtlLengthSid(psidEveryone), (PSID)(&pNewAce->SidStart),
psidEveryone);
}
////////////////////////////////////////////////////////////////////////
// Open the indicated file.
////////////////////////////////////////////////////////////////////////
TranslationStatus = RtlDosPathNameToNtPathName_U( lpFileName,
&FileName, NULL, &RelativeName );
if ( !TranslationStatus )
goto ErrorExit;
FreeBuffer = FileName.Buffer;
if ( RelativeName.RelativeName.Length )
FileName = *(PUNICODE_STRING)&RelativeName.RelativeName;
else
RelativeName.ContainingDirectory = NULL;
InitializeObjectAttributes( &Obja, &FileName, OBJ_CASE_INSENSITIVE,
RelativeName.ContainingDirectory, NULL );
Status = NtOpenFile( &FileHandle, READ_CONTROL | WRITE_DAC, &Obja, &IoStatusBlock,
FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, 0 );
RtlFreeHeap(RtlProcessHeap(), 0,FreeBuffer);
if (!NT_SUCCESS(Status))
goto ErrorExit;
////////////////////////////////////////////////////////////////////////
// Retrieve the security descriptor for the file and then get the
// file's DACL from it.
////////////////////////////////////////////////////////////////////////
pSD = (PSECURITY_DESCRIPTOR) LocalAlloc(LMEM_FIXED, SD_SIZE);
if (pSD == NULL)
goto ErrorExit;
Status = NtQuerySecurityObject( FileHandle, DACL_SECURITY_INFORMATION,
pSD, SD_SIZE, &LengthNeeded );
if (!NT_SUCCESS(Status))
goto ErrorExit;
// extract the originals from the security descriptor
Status = RtlGetDaclSecurityDescriptor(pSD, &fDaclPresent, &pAcl, &fDaclDef);
if (!NT_SUCCESS(Status))
goto ErrorExit;
////////////////////////////////////////////////////////////////////////
// Create a new DACL by copying the existing DACL and appending the
// "Everyone" ACE.
////////////////////////////////////////////////////////////////////////
// if no DACL present, we create one
if ((fDaclPresent == FALSE) || (pAcl == NULL))
{
Status = RtlCreateAcl(&Acl, sizeof(Acl), ACL_REVISION) ;
if (!NT_SUCCESS(Status))
goto ErrorExit;
pAcl = &Acl;
}
// Copy the DACL into a larger buffer and add the new ACE to the end.
NewAclSize = pAcl->AclSize + NewAceSize;
pNewAcl = (PACL) LocalAlloc(LMEM_FIXED, NewAclSize);
if (!pNewAcl)
goto ErrorExit;
RtlCopyMemory(pNewAcl, pAcl, pAcl->AclSize);
pNewAcl->AclSize = NewAclSize;
Status = RtlAddAce(pNewAcl, ACL_REVISION, pNewAcl->AceCount,
pNewAce, NewAceSize);
if (!NT_SUCCESS(Status))
goto ErrorExit;
////////////////////////////////////////////////////////////////////////
// Create self-relative security descriptor with new DACL. Then
// save the security descriptor back to the file.
////////////////////////////////////////////////////////////////////////
Status = CreateNewSecurityDescriptor(&pNewSD, pSD, pNewAcl);
if (!NT_SUCCESS(Status))
goto ErrorExit;
Status = NtSetSecurityObject(FileHandle, DACL_SECURITY_INFORMATION, pNewSD);
if (!NT_SUCCESS(Status))
goto ErrorExit;
ExitVal = TRUE;
ErrorExit:
if (FileHandle != NULL)
NtClose(FileHandle);
if (pNewAcl != NULL)
LocalFree(pNewAcl);
if (pNewSD != NULL)
LocalFree(pNewSD);
if (pSD != NULL)
LocalFree(pSD);
return(ExitVal);
}
////////////////////////////////////////////////////////////////////////////
#if 0
BOOLEAN APIENTRY AddEveryoneRXPermissionA( WCHAR * lpFileName)
{
PUNICODE_STRING Unicode;
ANSI_STRING AnsiString;
NTSTATUS Status;
Unicode = &NtCurrentTeb()->StaticUnicodeString;
RtlInitAnsiString(&AnsiString,lpFileName);
Status = RtlAnsiStringToUnicodeString(Unicode,&AnsiString,FALSE);
if ( !NT_SUCCESS(Status) )
{
ULONG dwErrorCode;
dwErrorCode = RtlNtStatusToDosError( Status );
SetLastError( dwErrorCode );
return FALSE;
}
return ( AddEveryoneRXPermissionW((LPCWSTR)Unicode->Buffer) );
}
#endif
////////////////////////////////////////////////////////////////////////////
// return -1 for dates invalid, 0 for equal, 1 for f1 newer, 2 for f2 newer
int CheckDates(PFILENODE FN1, PFILENODE FN2)
{
SYSTEMTIME f1s = FN1->Time;
SYSTEMTIME f2s = FN2->Time;
if (FN1->TimeValid == FALSE || FN2->TimeValid == FALSE)
return -1;
if (f1s.wYear > f2s.wYear) return 1;
if (f1s.wYear < f2s.wYear) return 2;
if (f1s.wMonth > f2s.wMonth) return 1;
if (f1s.wMonth < f2s.wMonth) return 2;
if (f1s.wDay > f2s.wDay) return 1;
if (f1s.wDay < f2s.wDay) return 2;
if (f1s.wHour > f2s.wHour) return 1;
if (f1s.wHour < f2s.wHour) return 2;
if (f1s.wMinute > f2s.wMinute) return 1;
if (f1s.wMinute < f2s.wMinute) return 2;
if (f1s.wSecond > f2s.wSecond) return 1;
if (f1s.wSecond < f2s.wSecond) return 2;
return 0;
}
////////////////////////////////////////////////////////////////////////////
PPATHNODE GetPathNode(PTREENODE Tree, WCHAR *Dir)
{
PPATHNODE p;
// Handle Empty List
if (Tree->PathTail == NULL)
{
p = (PPATHNODE) LocalAlloc(0,sizeof(PATHNODE));
if (p == NULL)
return NULL;
Tree->PathHead = p;
Tree->PathTail = p;
Tree->NumPaths++;
p->Next = NULL;
p->FileHead = NULL;
p->FileTail = NULL;
p->FilesInDir = 0;
wcscpy(p->PathStr,Dir);
return p;
}
// Last Node Matches
if (wcscmp(Tree->PathTail->PathStr,Dir) == 0)
return Tree->PathTail;
// Need to add a node
p = (PPATHNODE) LocalAlloc(0,sizeof(PATHNODE));
if (p == NULL)
return NULL;
Tree->PathTail->Next = p;
Tree->PathTail = p;
Tree->NumPaths++;
p->Next = NULL;
p->FileHead = NULL;
p->FileTail = NULL;
p->FilesInDir = 0;
wcscpy(p->PathStr,Dir);
return p;
}
////////////////////////////////////////////////////////////////////////////
void AddFileNode(PTREENODE Tree, WCHAR *Dir, PFILENODE FileNode)
{
PPATHNODE PathNode = GetPathNode(Tree, Dir);
if (FileNode == NULL)
return;
if (PathNode == NULL)
{
LocalFree(FileNode);
return;
}
// New node is always the last.
FileNode->Next = NULL;
// If list isn't empty, link to last node in list
// Otherwise, set head pointer.
if (PathNode->FileTail != NULL)
PathNode->FileTail->Next = FileNode;
else
PathNode->FileHead = FileNode;
// Put new node on end of list.
PathNode->FileTail = FileNode;
PathNode->FilesInDir++;
}
////////////////////////////////////////////////////////////////////////////
void ProcessFile(PTREENODE Tree, LPWIN32_FIND_DATA LocalData, WCHAR *LocalDir)
{
PFILENODE FileNode;
// Don't handle directories
if ((LocalData->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0)
return;
// Allocate a file node
FileNode = (PFILENODE) LocalAlloc(0,sizeof(FILENODE));
if (FileNode == NULL)
return;
// Fill in the Local Fields
wcscpy(FileNode->FileName, LocalData->cFileName);
FileNode->TimeValid = FileTimeToSystemTime(&LocalData->ftLastWriteTime,
&FileNode->Time);
// Add to the list
AddFileNode(Tree, LocalDir, FileNode);
}
////////////////////////////////////////////////////////////////////////////
void ProcessDir(PTREENODE Tree, LPWIN32_FIND_DATA FindData, WCHAR *Dir)
{
WCHAR NewDir[MAX_PATH];
PPATHNODE PathNode;
// Only Handle Directories
if ((FindData->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == 0)
return;
// Don't recurse into these directories
if (wcscmp(FindData->cFileName, L".") == 0)
return;
if (wcscmp(FindData->cFileName, L"..") == 0)
return;
wcscpy(NewDir,Dir);
wcscat(NewDir,L"\\");
wcscat(NewDir,FindData->cFileName);
// This creates a node for the directory. Nodes get automatically
// created when adding files, but that doesn't handle empty
// directories. This does.
PathNode = GetPathNode(Tree, NewDir);
ReadTree(Tree, NewDir);
}
////////////////////////////////////////////////////////////////////////////
// Creates an in-memory representation of the Current User's start menu.
void ReadTree(PTREENODE Tree, WCHAR *Dir)
{
HANDLE FindHandle;
WIN32_FIND_DATA FindData;
int retval;
// First compare all files in current directory.
retval = SetCurrentDirectory(Dir);
if (retval == 0)
{
// printf("Unable to find directory %s\n",Dir);
return;
}
FindHandle = FindFirstFile(L"*.*", &FindData);
if (FindHandle != INVALID_HANDLE_VALUE)
{
ProcessFile(Tree, &FindData, Dir);
while (FindNextFile(FindHandle, &FindData) != FALSE)
ProcessFile(Tree, &FindData, Dir);
FindClose(FindHandle);
}
// Next, handle subdirectories.
retval = SetCurrentDirectory(Dir);
if (retval == 0)
{
// printf("Unable to find directory %s\n",Dir);
return;
}
FindHandle = FindFirstFile(L"*.*", &FindData);
if (FindHandle != INVALID_HANDLE_VALUE)
{
ProcessDir(Tree, &FindData, Dir);
while (FindNextFile(FindHandle, &FindData) != FALSE)
ProcessDir(Tree, &FindData, Dir);
FindClose(FindHandle);
}
}
////////////////////////////////////////////////////////////////////////////
int WriteTreeToDisk(PTREENODE Tree)
{
PPATHNODE PN;
PFILENODE FN;
HANDLE hFile;
DWORD BytesWritten;
DWORD i;
hFile = CreateFile(SaveName, GENERIC_WRITE, 0, NULL,
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE)
return(-1); // error
// DbgPrint("Tree->NumPaths is %d\n",Tree->NumPaths);
if (WriteFile(hFile,&Tree->NumPaths,sizeof(DWORD),&BytesWritten, NULL) == 0)
{
CloseHandle(hFile);
return(-1); // error
}
for (PN = Tree->PathHead; PN != NULL; PN = PN->Next)
{
if (WriteFile(hFile,PN,sizeof(PATHNODE),&BytesWritten, NULL) == 0)
{
CloseHandle(hFile);
return(-1); // error
}
// DbgPrint("\n%s (%d)\n",PN->PathStr, PN->FilesInDir);
FN = PN->FileHead;
for (i = 0; i < PN->FilesInDir; i++)
{
if (WriteFile(hFile,FN,sizeof(FILENODE),&BytesWritten, NULL) == 0)
{
CloseHandle(hFile);
return(-1); // error
}
// DbgPrint(" %s \n", FN->FileName);
FN = FN->Next;
}
}
CloseHandle(hFile);
return(0);
}
////////////////////////////////////////////////////////////////////////////
int ReadTreeFromDisk(PTREENODE Tree)
{
PATHNODE LocalPath;
PPATHNODE PN;
PFILENODE FN;
HANDLE hFile;
DWORD BytesRead;
DWORD i,j;
DWORD NumFiles, NumTrees;
hFile = CreateFile(SaveName, GENERIC_READ, 0, NULL,
OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFile == INVALID_HANDLE_VALUE)
return(-1);
if (ReadFile(hFile,&NumTrees,sizeof(DWORD),&BytesRead, NULL) == 0)
{
CloseHandle(hFile);
return(-1); // error
}
for (i = 0; i < NumTrees; i++)
{
if (ReadFile(hFile,&LocalPath,sizeof(PATHNODE),&BytesRead, NULL) == 0)
{
CloseHandle(hFile);
return(-1); // error
}
PN = GetPathNode(Tree, LocalPath.PathStr);
if (PN == NULL)
{
CloseHandle(hFile);
return(-1); // error
}
NumFiles = LocalPath.FilesInDir;
// DbgPrint("\n<<%s (%d)\n",PN->PathStr, NumFiles);
for (j = 0; j < NumFiles; j++)
{
// Allocate a file node
FN = (PFILENODE) LocalAlloc(0,sizeof(FILENODE));
if (FN == NULL)
{
CloseHandle(hFile);
return(-1); // error
}
if (ReadFile(hFile,FN,sizeof(FILENODE),&BytesRead, NULL) == 0)
{
CloseHandle(hFile);
LocalFree(FN);
return(-1); // error
}
AddFileNode(Tree, PN->PathStr, FN);
// DbgPrint(" %d: %s >>\n", j, FN->FileName);
}
}
CloseHandle(hFile);
return(0);
}
////////////////////////////////////////////////////////////////////////////
// Finds a path in a menu tree. If not found, NULL is returned.
PPATHNODE FindPath(PTREENODE Tree, PPATHNODE PN)
{
PPATHNODE FoundPN;
for (FoundPN = Tree->PathHead; FoundPN != NULL; FoundPN = FoundPN->Next)
{
if (_wcsicmp(FoundPN->PathStr,PN->PathStr) == 0)
return FoundPN;
}
return NULL;
}
////////////////////////////////////////////////////////////////////////////
// Finds a file in a directory node. If not found, NULL is returned.
PFILENODE FindFile(PPATHNODE PN, PFILENODE FN)
{
PFILENODE FoundFN;
for (FoundFN = PN->FileHead; FoundFN != NULL; FoundFN = FoundFN->Next)
{
if (_wcsicmp(FoundFN->FileName,FN->FileName) == 0)
return FoundFN;
}
return NULL;
}
////////////////////////////////////////////////////////////////////////////
/* ==============================================================
Function Name : wcsrevchr
Description : Reverse wcschr
Finds a character in a string starting from the end
Arguments :
Return Value : PWCHAR
============================================================== */
PWCHAR wcsrevchr( PWCHAR string, WCHAR ch )
{
int cLen, iCount;
cLen = wcslen(string);
string += cLen;
for (iCount = cLen; iCount && *string != ch ; iCount--, string--)
;
if (*string == ch)
return string;
else
return NULL;
}
////////////////////////////////////////////////////////////////////////////
// Create the indicated directory. This function creates any parent
// directories that are needed too.
//
// Return: TRUE = directory now exists
// FALSE = directory couldn't be created
BOOLEAN TsCreateDirectory( WCHAR *DirName )
{
BOOL RetVal;
WCHAR *LastSlash;
//
// Try to create the specified directory. If the create works or
// the directory already exists, return TRUE. If the called failed
// because the path wasn't found, continue. This occurs if the
// parent directory doesn't exist.
//
RetVal = CreateDirectory(DirName, NULL);
if ((RetVal == TRUE) || (GetLastError() == ERROR_ALREADY_EXISTS))
return(TRUE);
if (GetLastError() != ERROR_PATH_NOT_FOUND)
return(FALSE);
//
// Remove the last component of the path and try creating the
// parent directory. Upon return, add the last component back
// in and try to create the specified directory again.
//
// Desc : BUG 267014 - replaced
// LastSlash = wcschr(DirName, L'\\');
// Given a full pathname, previous always returns the drive letter.
// Next line returns path components
LastSlash = wcsrevchr(DirName, L'\\');
if (LastSlash == NULL) // Can't reduce path any more
return(FALSE);
*LastSlash = L'\0';
RetVal = TsCreateDirectory(DirName);
*LastSlash = L'\\';
if (RetVal == FALSE) // Couldn't create parent directory
return(FALSE);
RetVal = CreateDirectory(DirName, NULL);
if ((RetVal == TRUE) || (GetLastError() == ERROR_ALREADY_EXISTS))
return(TRUE);
return(FALSE);
}
////////////////////////////////////////////////////////////////////////////
// Moves a file from the current start menu to the All Users start menu.
// Creates any directories that may be needed in the All Users menu.
void TsMoveFile(PPATHNODE PN, PFILENODE FN)
{
WCHAR Src[MAX_PATH];
WCHAR Dest[MAX_PATH];
// Normalize Source Path
wcscpy(Src,PN->PathStr);
if (Src[wcslen(Src)-1] != L'\\')
wcscat(Src,L"\\");
// Create Destination Path.
wcscpy(Dest,AllUserDir);
wcscat(Dest,&Src[CurUserDirLen]);
// If directory doesn't exist, make it. The default permission is fine.
if (TsCreateDirectory(Dest) != TRUE)
return;
wcscat(Src,FN->FileName);
wcscat(Dest,FN->FileName);
// Move Fails if the target already exists. This could happen
// if we're copying a file that has a newer timestamp.
if ( GetFileAttributes(Dest) != -1 )
DeleteFile(Dest);
// DbgPrint("Moving File %s \n to %s\n",Src,Dest);
if (MoveFile(Src, Dest) == FALSE)
return;
AddEveryoneRXPermissionW(Dest);
}
////////////////////////////////////////////////////////////////////////////
// Compare the current start menu with the original. Copy any new or
// changed files to the All Users menu.
void ProcessChanges(PTREENODE OrigTree, PTREENODE NewTree)
{
PPATHNODE NewPN, OrigPN;
PFILENODE NewFN, OrigFN;
BOOL fRet;
PPREMOVEDIRLIST pRemDirList = NULL, pTemp;
for (NewPN = NewTree->PathHead; NewPN != NULL; NewPN = NewPN->Next)
{
// DbgPrint("PC: Dir is %s\n",NewPN->PathStr);
// If directory not found in original tree, move it over
OrigPN = FindPath(OrigTree, NewPN);
if (OrigPN == NULL)
{
for (NewFN = NewPN->FileHead; NewFN != NULL; NewFN = NewFN->Next)
{
// DbgPrint(" Move File is %s\n",NewFN->FileName);
TsMoveFile(NewPN,NewFN);
}
// Desc : BUG 267014 - replaced
// RemoveDirectory(NewPN->PathStr);
// We have a problem if NewPN doesn't contain file items but subfolders.
// In this case, we do not enter the above loop, as there is nothing to move
// But the folder can't be removed because it contains a tree that haven't been moved yet.
// To remove it, we store its name in a LIFO stack. Stack items are removed when the loop exits
fRet = RemoveDirectory(NewPN->PathStr);
if (!fRet && GetLastError() == ERROR_DIR_NOT_EMPTY) {
#if DBG
DbgPrint("Adding to List--%S\n", NewPN->PathStr);
#endif
if (pRemDirList) {
pTemp = (PPREMOVEDIRLIST)LocalAlloc(LMEM_FIXED,sizeof(REMOVEDIRLIST));
wcscpy(pTemp->PathStr, NewPN->PathStr);
pTemp->Next = pRemDirList;
pRemDirList = pTemp;
}
else {
pRemDirList = (PPREMOVEDIRLIST)LocalAlloc(LMEM_FIXED, sizeof(REMOVEDIRLIST));
wcscpy(pRemDirList->PathStr, NewPN->PathStr);
pRemDirList->Next = NULL;
}
}
continue;
}
// Directory was found, check the files
for (NewFN = NewPN->FileHead; NewFN != NULL; NewFN = NewFN->Next)
{
// DbgPrint(" File is %s\n",NewFN->FileName);
// File wasn't found, move it
OrigFN = FindFile(OrigPN,NewFN);
if (OrigFN == NULL)
{
TsMoveFile(NewPN,NewFN);
continue;
}
// Check TimeStamp, if New Scan is more recent, move it.
if (CheckDates(NewFN,OrigFN) == 1)
{
TsMoveFile(NewPN,NewFN);
continue;
}
}
}
// Desc : BUG 267014 - added
// Directories stack removal
if (pRemDirList) {
while (pRemDirList) {
pTemp = pRemDirList;
pRemDirList = pRemDirList->Next;
RemoveDirectory(pTemp->PathStr);
LocalFree(pTemp);
}
}
}
////////////////////////////////////////////////////////////////////////////
// Frees the in-memory representation of a start menu
void FreeTree(PTREENODE Tree)
{
PPATHNODE PN,NextPN;
PFILENODE FN,NextFN;
for (PN = Tree->PathHead; PN != NULL; PN = NextPN)
{
for (FN = PN->FileHead; FN != NULL; FN = NextFN)
{
NextFN = FN->Next;
LocalFree(FN);
}
NextPN = PN->Next;
LocalFree(PN);
}
Tree->PathHead = NULL;
Tree->PathTail = NULL;
Tree->NumPaths = 0;
}
////////////////////////////////////////////////////////////////////////////
// Updates the "All User" menu by moving new items from the Current User's
// start menu. In RunMode 0, a snapshot of the Current User's start menu
// is taken. After modifications to the Current User's start menu are done,
// this function is called again with RunMode 1. Then, it compares the
// current state of the start menu with the saved snapshot. Any new or
// modified files are copied over to the corresponding location in the
// "All User" start menu.
//
// RunMode 0 is invoked when the system is changed into install mode and
// mode 1 is called when the system returns to execute mode.
int TermsrvUpdateAllUserMenu(int RunMode)
{
TREENODE OrigTree;
TREENODE NewTree;
WCHAR p[MAX_PATH];
int retval;
PMESSAGE_RESOURCE_ENTRY MessageEntry;
PVOID DllHandle;
NTSTATUS Status;
DWORD dwlen;
OrigTree.PathHead = NULL;
OrigTree.PathTail = NULL;
OrigTree.NumPaths = 0;
NewTree.PathHead = NULL;
NewTree.PathTail = NULL;
NewTree.NumPaths = 0;
retval = GetEnvironmentVariable(L"UserProfile", p, MAX_PATH);
if (retval == 0)
return(-1);
if (!StartMenu[0]) {
HINSTANCE hInst;
typedef HRESULT (* LPFNSHGETFOLDERPATH)(HWND, int, HANDLE, DWORD, LPWSTR);
LPFNSHGETFOLDERPATH lpfnSHGetFolderPath;
WCHAR ssPath[MAX_PATH];
WCHAR *LastSlash;
wcscpy( StartMenu, L"\\Start Menu");
hInst = LoadLibrary(L"SHELL32.DLL");
if (hInst) {
lpfnSHGetFolderPath = (LPFNSHGETFOLDERPATH)GetProcAddress(hInst,"SHGetFolderPathW");
if (lpfnSHGetFolderPath) {
if (S_OK == lpfnSHGetFolderPath(NULL, CSIDL_STARTMENU, NULL, 0, ssPath)) {
LastSlash = wcsrevchr(ssPath, L'\\');
if (LastSlash) {
wcscpy(StartMenu, LastSlash);
}
}
}
FreeLibrary(hInst);
}
}
wcscpy(SaveName,p);
wcscat(SaveName,L"\\TsAllUsr.Dat");
wcscpy(CurUserDir,p);
wcscat(CurUserDir,StartMenu);
CurUserDirLen = wcslen(CurUserDir);
dwlen = sizeof(AllUserDir)/sizeof(WCHAR);
if (GetAllUsersProfileDirectory(AllUserDir, &dwlen))
{
wcscat(AllUserDir,StartMenu);
#if DBG
DbgPrint("SaveName is '%S'\n",SaveName);
DbgPrint("CurUserDir is '%S'\n",CurUserDir);
DbgPrint("AllUserDir is '%S'\n",AllUserDir);
#endif
if (RunMode == 0)
{
// If the start menu snapshot already exists, don't overwrite it.
// The user may enter "change user /install" twice, or an app may
// force a reboot without changing back to execute mode. The
// existing file is older. If we overwrite it, then some shortcuts
// won't get moved.
if (FileExists(SaveName) != TRUE)
{
ReadTree(&OrigTree, CurUserDir);
if (WriteTreeToDisk(&OrigTree) == -1)
DeleteFile(SaveName);
FreeTree(&OrigTree);
}
}
else if (RunMode == 1)
{
if (ReadTreeFromDisk(&OrigTree) == -1)
{
FreeTree(&OrigTree);
DeleteFile(SaveName); // Could be a bad file. If it doesn't
// exist, this won't hurt anything.
return(-1);
}
ReadTree(&NewTree, CurUserDir);
ProcessChanges(&OrigTree,&NewTree);
DeleteFile(SaveName);
FreeTree(&OrigTree);
FreeTree(&NewTree);
}
}
return(0);
}
Reference in a new issue View git blame Copy permalink