You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1053 lines
29 KiB
1053 lines
29 KiB
/*++
|
|
|
|
Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
|
Module Name:
|
|
|
|
filelog.c
|
|
|
|
Abstract:
|
|
|
|
Routines for logging files in copy logs.
|
|
|
|
Author:
|
|
|
|
Ted Miller (tedm) 14-Jun-1995
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
|
|
#include "precomp.h"
|
|
#pragma hdrstop
|
|
|
|
|
|
//
|
|
// Define name of system log file and various strings used
|
|
// within it.
|
|
//
|
|
PCTSTR SystemLogFileName = TEXT("repair\\setup.log");
|
|
PCTSTR NtFileSectionName = TEXT("Files.WinNT");
|
|
|
|
//
|
|
// Define structure used internally to represent a file log file.
|
|
//
|
|
typedef struct _SETUP_FILE_LOG {
|
|
PCTSTR FileName;
|
|
BOOL QueryOnly;
|
|
BOOL SystemLog;
|
|
} SETUP_FILE_LOG, *PSETUP_FILE_LOG;
|
|
|
|
|
|
#ifdef UNICODE
|
|
//
|
|
// ANSI version
|
|
//
|
|
HSPFILELOG
|
|
SetupInitializeFileLogA(
|
|
IN PCSTR LogFileName, OPTIONAL
|
|
IN DWORD Flags
|
|
)
|
|
{
|
|
PWSTR p;
|
|
DWORD d;
|
|
HSPFILELOG h;
|
|
|
|
if(LogFileName) {
|
|
d = pSetupCaptureAndConvertAnsiArg(LogFileName,&p);
|
|
if(d != NO_ERROR) {
|
|
SetLastError(d);
|
|
return(INVALID_HANDLE_VALUE);
|
|
}
|
|
} else {
|
|
p = NULL;
|
|
}
|
|
|
|
h = SetupInitializeFileLogW(p,Flags);
|
|
d = GetLastError();
|
|
|
|
if(p) {
|
|
MyFree(p);
|
|
}
|
|
|
|
SetLastError(d);
|
|
return(h);
|
|
}
|
|
#else
|
|
//
|
|
// Unicode stub
|
|
//
|
|
HSPFILELOG
|
|
SetupInitializeFileLogW(
|
|
IN PCWSTR LogFileName, OPTIONAL
|
|
IN DWORD Flags
|
|
)
|
|
{
|
|
UNREFERENCED_PARAMETER(LogFileName);
|
|
UNREFERENCED_PARAMETER(Flags);
|
|
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
|
return(INVALID_HANDLE_VALUE);
|
|
}
|
|
#endif
|
|
|
|
HSPFILELOG
|
|
SetupInitializeFileLog(
|
|
IN PCTSTR LogFileName, OPTIONAL
|
|
IN DWORD Flags
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Initialize a file for logging or query. The caller may specify that he
|
|
wishes to use the system log, which is where the system tracks which
|
|
files are installed as part of Windows NT; or the caller may specify
|
|
any other random file to be used as a log.
|
|
|
|
If the user specifies the system log not for query only, the function fails
|
|
unless the user is administrator. However this only guarantees security
|
|
on the log when the system is installed on a drive with a filesystem that
|
|
supports ACLs; the log is simply a file and anyone can access it unless
|
|
setup can secure it via ACLs.
|
|
|
|
Arguments:
|
|
|
|
LogFileName - if specified, supplies the filename of the file to be used
|
|
as the log file. Must be specified if Flags does not include
|
|
SPFILELOG_SYSTEMLOG. Must not be specified if Flags includes
|
|
SPFILELOG_SYSTEMLOG.
|
|
|
|
Flags - supplies a combination of the following values:
|
|
|
|
SPFILELOG_SYSTEMLOG - use the Windows NT system file log, which is used
|
|
to track what files are installed as part of Windows NT. The user must
|
|
be administrator to specify this option unless SPFILELOG_QUERYONLY
|
|
is specified, and LogFileName must not be specified. May not be specified
|
|
in combination with SPFILELOG_FORCENEW.
|
|
|
|
SPFILELOG_FORCENEW - if the log file exists, it will be overwritten.
|
|
If the log file exists and this flag is not specified then additional
|
|
files are added to the existing log. May not be specified in combination
|
|
with SPFILELOG_SYSTEMLOG.
|
|
|
|
SPFILELOG_QUERYONLY - open the log file for querying only. The user
|
|
|
|
Return Value:
|
|
|
|
Handle to file log or INVALID_HANDLE_VALUE if the function fails;
|
|
extended error info is available via GetLastError() in this case.
|
|
|
|
--*/
|
|
|
|
{
|
|
TCHAR SysLogFileName[MAX_PATH];
|
|
PCTSTR FileName;
|
|
PSETUP_FILE_LOG FileLog;
|
|
DWORD Err;
|
|
HANDLE hFile;
|
|
|
|
//
|
|
// Validate args.
|
|
//
|
|
Err = ERROR_INVALID_PARAMETER;
|
|
if(Flags & SPFILELOG_SYSTEMLOG) {
|
|
if((Flags & SPFILELOG_FORCENEW) || LogFileName) {
|
|
goto clean0;
|
|
}
|
|
//
|
|
// User must be administrator to gain write access to system log.
|
|
//
|
|
if(!(Flags & SPFILELOG_QUERYONLY) && !pSetupIsUserAdmin()) {
|
|
Err = ERROR_ACCESS_DENIED;
|
|
goto clean0;
|
|
}
|
|
|
|
//
|
|
// uses actual windows directory instead of hydra remapped
|
|
//
|
|
lstrcpyn(SysLogFileName,WindowsDirectory,MAX_PATH);
|
|
pSetupConcatenatePaths(SysLogFileName,SystemLogFileName,MAX_PATH,NULL);
|
|
FileName = SysLogFileName;
|
|
} else {
|
|
if(LogFileName) {
|
|
if(!lstrcpyn(SysLogFileName,LogFileName,MAX_PATH)) {
|
|
//
|
|
// lstrcpyn faulted, LogFileName must be bad
|
|
//
|
|
Err = ERROR_INVALID_PARAMETER;
|
|
goto clean0;
|
|
}
|
|
FileName = SysLogFileName;
|
|
} else {
|
|
goto clean0;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Allocate a log file structure.
|
|
//
|
|
Err = ERROR_NOT_ENOUGH_MEMORY;
|
|
if(FileLog = MyMalloc(sizeof(SETUP_FILE_LOG))) {
|
|
FileLog->FileName = DuplicateString(FileName);
|
|
if(!FileLog->FileName) {
|
|
goto clean1;
|
|
}
|
|
} else {
|
|
goto clean0;
|
|
}
|
|
|
|
FileLog->QueryOnly = ((Flags & SPFILELOG_QUERYONLY) != 0);
|
|
FileLog->SystemLog = ((Flags & SPFILELOG_SYSTEMLOG) != 0);
|
|
|
|
//
|
|
// See if the file exists.
|
|
//
|
|
if(FileExists(FileName,NULL)) {
|
|
|
|
//
|
|
// If it's the system log, take ownership of the file.
|
|
//
|
|
if(FileLog->SystemLog) {
|
|
Err = TakeOwnershipOfFile(FileName);
|
|
if(Err != NO_ERROR) {
|
|
goto clean2;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Set attribute to normal. This ensures we can delete/open/create the file
|
|
// as appropriate below.
|
|
//
|
|
if(!SetFileAttributes(FileName,FILE_ATTRIBUTE_NORMAL)) {
|
|
Err = GetLastError();
|
|
goto clean2;
|
|
}
|
|
|
|
//
|
|
// Delete the file now if the caller specified the force_new flag.
|
|
//
|
|
if((Flags & SPFILELOG_FORCENEW) && !DeleteFile(FileName)) {
|
|
Err = GetLastError();
|
|
goto clean2;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Make sure we can open/create the file by attempting to do that now.
|
|
//
|
|
hFile = CreateFile(
|
|
FileName,
|
|
GENERIC_READ | (FileLog->QueryOnly ? 0 : GENERIC_WRITE),
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_ALWAYS, // Open if exists, create if not
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL
|
|
);
|
|
|
|
if(hFile == INVALID_HANDLE_VALUE) {
|
|
Err = GetLastError();
|
|
goto clean2;
|
|
}
|
|
|
|
CloseHandle(hFile);
|
|
return((HSPFILELOG)FileLog);
|
|
|
|
clean2:
|
|
MyFree(FileLog->FileName);
|
|
clean1:
|
|
MyFree(FileLog);
|
|
clean0:
|
|
SetLastError(Err);
|
|
return(INVALID_HANDLE_VALUE);
|
|
}
|
|
|
|
|
|
BOOL
|
|
SetupTerminateFileLog(
|
|
IN HSPFILELOG FileLogHandle
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Releases resources associated with a file log.
|
|
|
|
Arguments:
|
|
|
|
FileLogHandle - supplies the handle to the file log, as returned
|
|
by SetupInitializeLogFile.
|
|
|
|
Return Value:
|
|
|
|
Boolean value indicating outcome. If FALSE, the caller can use
|
|
GetLastError() to get extended error info.
|
|
|
|
--*/
|
|
|
|
{
|
|
PSETUP_FILE_LOG FileLog;
|
|
DWORD Err;
|
|
|
|
FileLog = (PSETUP_FILE_LOG)FileLogHandle;
|
|
Err = NO_ERROR;
|
|
|
|
try {
|
|
MyFree(FileLog->FileName);
|
|
MyFree(FileLog);
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Err = ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
SetLastError(Err);
|
|
return(Err == NO_ERROR);
|
|
}
|
|
|
|
|
|
#ifdef UNICODE
|
|
//
|
|
// ANSI version
|
|
//
|
|
BOOL
|
|
SetupLogFileA(
|
|
IN HSPFILELOG FileLogHandle,
|
|
IN PCSTR LogSectionName, OPTIONAL
|
|
IN PCSTR SourceFilename,
|
|
IN PCSTR TargetFilename,
|
|
IN DWORD Checksum, OPTIONAL
|
|
IN PCSTR DiskTagfile, OPTIONAL
|
|
IN PCSTR DiskDescription, OPTIONAL
|
|
IN PCSTR OtherInfo, OPTIONAL
|
|
IN DWORD Flags
|
|
)
|
|
{
|
|
PWSTR logsectionname = NULL;
|
|
PWSTR sourcefilename = NULL;
|
|
PWSTR targetfilename = NULL;
|
|
PWSTR disktagfile = NULL;
|
|
PWSTR diskdescription = NULL;
|
|
PWSTR otherinfo = NULL;
|
|
DWORD d;
|
|
BOOL b;
|
|
|
|
if(LogSectionName) {
|
|
d = pSetupCaptureAndConvertAnsiArg(LogSectionName,&logsectionname);
|
|
} else {
|
|
d = NO_ERROR;
|
|
}
|
|
if(d == NO_ERROR) {
|
|
d = pSetupCaptureAndConvertAnsiArg(SourceFilename,&sourcefilename);
|
|
}
|
|
if(d == NO_ERROR) {
|
|
d = pSetupCaptureAndConvertAnsiArg(TargetFilename,&targetfilename);
|
|
}
|
|
if((d == NO_ERROR) && DiskTagfile) {
|
|
d = pSetupCaptureAndConvertAnsiArg(DiskTagfile,&disktagfile);
|
|
}
|
|
if((d == NO_ERROR) && DiskDescription) {
|
|
d = pSetupCaptureAndConvertAnsiArg(DiskDescription,&diskdescription);
|
|
}
|
|
if((d == NO_ERROR) && OtherInfo) {
|
|
d = pSetupCaptureAndConvertAnsiArg(OtherInfo,&otherinfo);
|
|
}
|
|
|
|
if(d == NO_ERROR) {
|
|
|
|
b = SetupLogFileW(
|
|
FileLogHandle,
|
|
logsectionname,
|
|
sourcefilename,
|
|
targetfilename,
|
|
Checksum,
|
|
disktagfile,
|
|
diskdescription,
|
|
otherinfo,
|
|
Flags
|
|
);
|
|
|
|
d = GetLastError();
|
|
|
|
} else {
|
|
b = FALSE;
|
|
}
|
|
|
|
if(logsectionname) {
|
|
MyFree(logsectionname);
|
|
}
|
|
if(sourcefilename) {
|
|
MyFree(sourcefilename);
|
|
}
|
|
if(targetfilename) {
|
|
MyFree(targetfilename);
|
|
}
|
|
if(disktagfile) {
|
|
MyFree(disktagfile);
|
|
}
|
|
if(diskdescription) {
|
|
MyFree(diskdescription);
|
|
}
|
|
if(otherinfo) {
|
|
MyFree(otherinfo);
|
|
}
|
|
|
|
SetLastError(d);
|
|
return(b);
|
|
}
|
|
#else
|
|
//
|
|
// Unicode stub
|
|
//
|
|
BOOL
|
|
SetupLogFileW(
|
|
IN HSPFILELOG FileLogHandle,
|
|
IN PCWSTR LogSectionName, OPTIONAL
|
|
IN PCWSTR SourceFilename,
|
|
IN PCWSTR TargetFilename,
|
|
IN DWORD Checksum, OPTIONAL
|
|
IN PCWSTR DiskTagfile, OPTIONAL
|
|
IN PCWSTR DiskDescription, OPTIONAL
|
|
IN PCWSTR OtherInfo, OPTIONAL
|
|
IN DWORD Flags
|
|
)
|
|
{
|
|
UNREFERENCED_PARAMETER(FileLogHandle);
|
|
UNREFERENCED_PARAMETER(LogSectionName);
|
|
UNREFERENCED_PARAMETER(SourceFilename);
|
|
UNREFERENCED_PARAMETER(TargetFilename);
|
|
UNREFERENCED_PARAMETER(Checksum);
|
|
UNREFERENCED_PARAMETER(DiskTagfile);
|
|
UNREFERENCED_PARAMETER(DiskDescription);
|
|
UNREFERENCED_PARAMETER(OtherInfo);
|
|
UNREFERENCED_PARAMETER(Flags);
|
|
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
|
return(FALSE);
|
|
}
|
|
#endif
|
|
|
|
BOOL
|
|
SetupLogFile(
|
|
IN HSPFILELOG FileLogHandle,
|
|
IN PCTSTR LogSectionName, OPTIONAL
|
|
IN PCTSTR SourceFilename,
|
|
IN PCTSTR TargetFilename,
|
|
IN DWORD Checksum, OPTIONAL
|
|
IN PCTSTR DiskTagfile, OPTIONAL
|
|
IN PCTSTR DiskDescription, OPTIONAL
|
|
IN PCTSTR OtherInfo, OPTIONAL
|
|
IN DWORD Flags
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Logs a file into a file log.
|
|
|
|
Arguments:
|
|
|
|
FileLogHandle - supplies the handle to the file log, as returned
|
|
by SetupInitializeLogFile(). The caller must not have passed
|
|
SPFILELOG_QUERYONLY when the log file was opened/initialized.
|
|
|
|
LogSectionName - required if SPFILELOG_SYSTEMLOG was not passed when
|
|
the file log was opened/initialized; optional otherwise.
|
|
Supplies the name for a logical grouping of files within the log.
|
|
|
|
SourceFilename - supplies the name of the file as it exists on the
|
|
source media from which it was installed. This name should be in
|
|
whatever format is meaningful to the caller.
|
|
|
|
TargetFilename - supplies the name of the file as it exists on the
|
|
Target. This name should be in whatever format is meaningful to
|
|
the caller.
|
|
|
|
Checksum - supplies a 32-bit checksum value. Required for the system log.
|
|
|
|
DiskTagfile - Gives the tagfile for the media from which the file
|
|
was installed. Required for the system log if SPFILELOG_OEMFILE
|
|
is specified. Ignored for the system log if SPFILELOG_OEMFILE is
|
|
not specified.
|
|
|
|
DiskDescription - Gives the human-readable description for the media
|
|
from which the file was installed. Required for the system log if
|
|
SPFILELOG_OEMFILE is specified. Ignored for the system log if
|
|
SPFILELOG_OEMFILE is not specified.
|
|
|
|
OtherInfo - supplies additional information to be associated with the
|
|
file.
|
|
|
|
Flags - may supply SPFILELOG_OEMFILE, which is meaningful only for
|
|
the system log and indicates that the file is not an MS-supplied file.
|
|
Can be used to convert an existing file's entry such as when an oem
|
|
overwrites an MS-supplied system file.
|
|
|
|
Return Value:
|
|
|
|
Boolean value indicating outcome. If FALSE, the caller can use
|
|
GetLastError() to get extended error info.
|
|
|
|
--*/
|
|
|
|
{
|
|
PSETUP_FILE_LOG FileLog;
|
|
DWORD Err;
|
|
BOOL b;
|
|
TCHAR LineToWrite[512];
|
|
TCHAR sourceFilename[MAX_PATH];
|
|
PTSTR p,Directory;
|
|
|
|
FileLog = (PSETUP_FILE_LOG)FileLogHandle;
|
|
|
|
try {
|
|
//
|
|
// Validate params. Handle must be for non-queryonly.
|
|
// If for the system log and oem file is specified,
|
|
// caller must have passed disk tagfile and description.
|
|
// There's really no way to validate the checksum because
|
|
// 0 is a perfectly valid one.
|
|
// If not the system log, caller must have passed a section name.
|
|
//
|
|
if(FileLog->QueryOnly
|
|
|| ( FileLog->SystemLog
|
|
&& (Flags & SPFILELOG_OEMFILE)
|
|
&& (!DiskTagfile || !DiskDescription))
|
|
|| (!FileLog->SystemLog && !LogSectionName))
|
|
{
|
|
Err = ERROR_INVALID_PARAMETER;
|
|
|
|
} else {
|
|
//
|
|
// Use default section if not specified.
|
|
//
|
|
if(!LogSectionName) {
|
|
MYASSERT(FileLog->SystemLog);
|
|
LogSectionName = NtFileSectionName;
|
|
}
|
|
|
|
//
|
|
// IF THIS LOGIC IS CHANGED BE SURE TO CHANGE
|
|
// SetupQueryFileLog() AS WELL!
|
|
//
|
|
// Split up the source filename into filename and
|
|
// directory if appropriate.
|
|
//
|
|
lstrcpyn(sourceFilename,SourceFilename,MAX_PATH);
|
|
if(FileLog->SystemLog && (Flags & SPFILELOG_OEMFILE)) {
|
|
if(p = _tcsrchr(sourceFilename,TEXT('\\'))) {
|
|
*p++ = 0;
|
|
Directory = p;
|
|
} else {
|
|
Directory = TEXT("\\");
|
|
}
|
|
} else {
|
|
Directory = TEXT("");
|
|
}
|
|
|
|
wnsprintf(
|
|
LineToWrite,
|
|
sizeof(LineToWrite)/sizeof(LineToWrite[0]),
|
|
TEXT("%s,%x,%s,%s,\"%s\""),
|
|
sourceFilename,
|
|
Checksum,
|
|
Directory,
|
|
DiskTagfile ? DiskTagfile : TEXT(""),
|
|
DiskDescription ? DiskDescription : TEXT("")
|
|
);
|
|
|
|
|
|
b = WritePrivateProfileString(
|
|
LogSectionName,
|
|
TargetFilename,
|
|
LineToWrite,
|
|
FileLog->FileName
|
|
);
|
|
|
|
Err = b ? NO_ERROR : GetLastError();
|
|
}
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Err = ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
SetLastError(Err);
|
|
return(Err == NO_ERROR);
|
|
}
|
|
|
|
|
|
#ifdef UNICODE
|
|
//
|
|
// ANSI version
|
|
//
|
|
BOOL
|
|
SetupRemoveFileLogEntryA(
|
|
IN HSPFILELOG FileLogHandle,
|
|
IN PCSTR LogSectionName, OPTIONAL
|
|
IN PCSTR TargetFilename OPTIONAL
|
|
)
|
|
{
|
|
PWSTR logsectionname,targetfilename;
|
|
DWORD d;
|
|
BOOL b;
|
|
|
|
if(LogSectionName) {
|
|
d = pSetupCaptureAndConvertAnsiArg(LogSectionName,&logsectionname);
|
|
if(d != NO_ERROR) {
|
|
SetLastError(d);
|
|
return(FALSE);
|
|
}
|
|
} else {
|
|
logsectionname = NULL;
|
|
}
|
|
if(TargetFilename) {
|
|
d = pSetupCaptureAndConvertAnsiArg(TargetFilename,&targetfilename);
|
|
if(d != NO_ERROR) {
|
|
if(logsectionname) {
|
|
MyFree(logsectionname);
|
|
}
|
|
SetLastError(d);
|
|
return(FALSE);
|
|
}
|
|
} else {
|
|
targetfilename = NULL;
|
|
}
|
|
|
|
b = SetupRemoveFileLogEntryW(FileLogHandle,logsectionname,targetfilename);
|
|
d = GetLastError();
|
|
|
|
if(logsectionname) {
|
|
MyFree(logsectionname);
|
|
}
|
|
if(targetfilename) {
|
|
MyFree(targetfilename);
|
|
}
|
|
|
|
SetLastError(d);
|
|
return(b);
|
|
}
|
|
#else
|
|
//
|
|
// Unicode stub
|
|
//
|
|
BOOL
|
|
SetupRemoveFileLogEntryW(
|
|
IN HSPFILELOG FileLogHandle,
|
|
IN PCWSTR LogSectionName, OPTIONAL
|
|
IN PCWSTR TargetFilename OPTIONAL
|
|
)
|
|
{
|
|
UNREFERENCED_PARAMETER(FileLogHandle);
|
|
UNREFERENCED_PARAMETER(LogSectionName);
|
|
UNREFERENCED_PARAMETER(TargetFilename);
|
|
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
|
return(FALSE);
|
|
}
|
|
#endif
|
|
|
|
BOOL
|
|
SetupRemoveFileLogEntry(
|
|
IN HSPFILELOG FileLogHandle,
|
|
IN PCTSTR LogSectionName, OPTIONAL
|
|
IN PCTSTR TargetFilename OPTIONAL
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Removes an entry or section from a file log.
|
|
|
|
Arguments:
|
|
|
|
FileLogHandle - supplies the handle to the file log, as returned
|
|
by SetupInitializeLogFile(). The caller must not have passed
|
|
SPFILELOG_QUERYONLY when the log file was opened/initialized.
|
|
|
|
LogSectionName - Supplies the name for a logical grouping of files
|
|
within the log. Required for non-system logs; optional for the
|
|
system log.
|
|
|
|
TargetFilename - supplies the name of the file as it exists on the
|
|
Target. This name should be in whatever format is meaningful to
|
|
the caller. If not specified, the entire section specified by
|
|
LogSectionName is removed. Removing the main section for NT files
|
|
is not allowed.
|
|
|
|
Return Value:
|
|
|
|
Boolean value indicating outcome. If FALSE, the caller can use
|
|
GetLastError() to get extended error info.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD Err;
|
|
PSETUP_FILE_LOG FileLog;
|
|
BOOL b;
|
|
|
|
FileLog = (PSETUP_FILE_LOG)FileLogHandle;
|
|
|
|
try {
|
|
|
|
Err = NO_ERROR;
|
|
if(FileLog->QueryOnly) {
|
|
Err = ERROR_INVALID_PARAMETER;
|
|
} else {
|
|
if(!LogSectionName) {
|
|
if(FileLog->SystemLog) {
|
|
LogSectionName = NtFileSectionName;
|
|
} else {
|
|
Err = ERROR_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
//
|
|
// Diallow removing the main nt files section.
|
|
//
|
|
if((Err == NO_ERROR)
|
|
&& FileLog->SystemLog
|
|
&& !TargetFilename
|
|
&& !lstrcmpi(LogSectionName,NtFileSectionName))
|
|
{
|
|
Err = ERROR_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
|
|
if(Err == NO_ERROR) {
|
|
b = WritePrivateProfileString(LogSectionName,TargetFilename,NULL,FileLog->FileName);
|
|
Err = b ? NO_ERROR : GetLastError();
|
|
}
|
|
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Err = ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
return(Err == NO_ERROR);
|
|
}
|
|
|
|
|
|
#ifdef UNICODE
|
|
//
|
|
// ANSI version
|
|
//
|
|
BOOL
|
|
SetupQueryFileLogA(
|
|
IN HSPFILELOG FileLogHandle,
|
|
IN PCSTR LogSectionName, OPTIONAL
|
|
IN PCSTR TargetFilename,
|
|
IN SetupFileLogInfo DesiredInfo,
|
|
OUT PSTR DataOut, OPTIONAL
|
|
IN DWORD ReturnBufferSize,
|
|
OUT PDWORD RequiredSize OPTIONAL
|
|
)
|
|
{
|
|
PWSTR logsectionname;
|
|
PWSTR targetfilename;
|
|
PWSTR unicodeBuffer = NULL;
|
|
DWORD unicodeSize = 2048;
|
|
PSTR ansidata;
|
|
DWORD requiredsize;
|
|
DWORD d;
|
|
BOOL b;
|
|
|
|
d = pSetupCaptureAndConvertAnsiArg(TargetFilename,&targetfilename);
|
|
if(d != NO_ERROR) {
|
|
SetLastError(d);
|
|
return(FALSE);
|
|
}
|
|
if(LogSectionName) {
|
|
d = pSetupCaptureAndConvertAnsiArg(LogSectionName,&logsectionname);
|
|
if(d != NO_ERROR) {
|
|
MyFree(targetfilename);
|
|
SetLastError(d);
|
|
return(FALSE);
|
|
}
|
|
} else {
|
|
logsectionname = NULL;
|
|
}
|
|
unicodeBuffer = MyMalloc(unicodeSize*sizeof(WCHAR));
|
|
if(!unicodeBuffer) {
|
|
if(targetfilename) {
|
|
MyFree(targetfilename);
|
|
}
|
|
if(logsectionname) {
|
|
MyFree(logsectionname);
|
|
}
|
|
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
|
|
return FALSE;
|
|
}
|
|
|
|
b = SetupQueryFileLogW(
|
|
FileLogHandle,
|
|
logsectionname,
|
|
targetfilename,
|
|
DesiredInfo,
|
|
unicodeBuffer,
|
|
unicodeSize,
|
|
&requiredsize
|
|
);
|
|
|
|
d = GetLastError();
|
|
|
|
if(b) {
|
|
d = NO_ERROR;
|
|
|
|
if(ansidata = pSetupUnicodeToAnsi(unicodeBuffer)) {
|
|
|
|
requiredsize = lstrlenA(ansidata)+1;
|
|
|
|
if(RequiredSize) {
|
|
try {
|
|
*RequiredSize = requiredsize;
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
b = FALSE;
|
|
d = ERROR_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
|
|
if(b && DataOut) {
|
|
if(ReturnBufferSize >= requiredsize) {
|
|
if(!lstrcpyA(DataOut,ansidata)) {
|
|
//
|
|
// lstrcpy faulted, ReturnBuffer must be invalid
|
|
//
|
|
d = ERROR_INVALID_PARAMETER;
|
|
b = FALSE;
|
|
}
|
|
} else {
|
|
d = ERROR_INSUFFICIENT_BUFFER;
|
|
b = FALSE;
|
|
}
|
|
}
|
|
|
|
MyFree(ansidata);
|
|
} else {
|
|
b = FALSE;
|
|
d = ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
}
|
|
|
|
MyFree(targetfilename);
|
|
if(logsectionname) {
|
|
MyFree(logsectionname);
|
|
}
|
|
if(unicodeBuffer) {
|
|
MyFree(unicodeBuffer);
|
|
}
|
|
|
|
SetLastError(d);
|
|
return(b);
|
|
}
|
|
#else
|
|
//
|
|
// Unicode stub
|
|
//
|
|
BOOL
|
|
SetupQueryFileLogW(
|
|
IN HSPFILELOG FileLogHandle,
|
|
IN PCWSTR LogSectionName, OPTIONAL
|
|
IN PCWSTR TargetFilename,
|
|
IN SetupFileLogInfo DesiredInfo,
|
|
OUT PWSTR DataOut, OPTIONAL
|
|
IN DWORD ReturnBufferSize,
|
|
OUT PDWORD RequiredSize OPTIONAL
|
|
)
|
|
{
|
|
UNREFERENCED_PARAMETER(FileLogHandle);
|
|
UNREFERENCED_PARAMETER(LogSectionName);
|
|
UNREFERENCED_PARAMETER(TargetFilename);
|
|
UNREFERENCED_PARAMETER(DesiredInfo);
|
|
UNREFERENCED_PARAMETER(DataOut);
|
|
UNREFERENCED_PARAMETER(ReturnBufferSize);
|
|
UNREFERENCED_PARAMETER(RequiredSize);
|
|
SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
|
|
return(FALSE);
|
|
}
|
|
#endif
|
|
|
|
BOOL
|
|
SetupQueryFileLog(
|
|
IN HSPFILELOG FileLogHandle,
|
|
IN PCTSTR LogSectionName, OPTIONAL
|
|
IN PCTSTR TargetFilename,
|
|
IN SetupFileLogInfo DesiredInfo,
|
|
OUT PTSTR DataOut, OPTIONAL
|
|
IN DWORD ReturnBufferSize,
|
|
OUT PDWORD RequiredSize OPTIONAL
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Returns information from a setup file log.
|
|
|
|
Arguments:
|
|
|
|
FileLogHandle - supplies handle to open file log, as returned by
|
|
SetupInitializeFileLog().
|
|
|
|
LogSectionName - required for non-system logs; if not specified
|
|
for the system log a default is supplied. Supplies the name
|
|
for a logical grouping within the log that is meaningful
|
|
to the caller.
|
|
|
|
TargetFilename - supplies name of file for which log information
|
|
is desired.
|
|
|
|
DesiredInfo - supplies an ordinal indicating what information
|
|
is desired about the file.
|
|
|
|
DataOut - If specified, points to a buffer that receives the
|
|
requested information for the file. Note that not all info
|
|
is provided for every file; an error is not returned if an entry
|
|
for the file exists in the log but is empty.
|
|
|
|
ReturnBufferSize - supplies size of the buffer (in chars) pointed to
|
|
by DataOut. If the buffer is too small and DataOut is specified,
|
|
no data is stored and the function returns FALSE. If DataOut is
|
|
not specified this value is ignored.
|
|
|
|
RequiredSize - receives the number of characters (including the
|
|
terminating nul) required to hold the result.
|
|
|
|
Return Value:
|
|
|
|
Boolean value indicating result. If FALSE, extended error info is
|
|
available from GetLastError().
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD Err;
|
|
PSETUP_FILE_LOG FileLog;
|
|
BOOL b;
|
|
TCHAR ProfileValue[2*MAX_PATH];
|
|
INT n;
|
|
DWORD d;
|
|
PTCHAR Field,End,Info;
|
|
UINT InfoLength;
|
|
BOOL Quoted;
|
|
|
|
FileLog = (PSETUP_FILE_LOG)FileLogHandle;
|
|
|
|
try {
|
|
//
|
|
// Validate arguments.
|
|
// Section name must be supplied for non-system log.
|
|
//
|
|
if((!FileLog->SystemLog && !LogSectionName)
|
|
|| (DesiredInfo >= SetupFileLogMax) || !TargetFilename) {
|
|
Err = ERROR_INVALID_PARAMETER;
|
|
} else {
|
|
|
|
if(!LogSectionName) {
|
|
MYASSERT(FileLog->SystemLog);
|
|
LogSectionName = NtFileSectionName;
|
|
}
|
|
|
|
//
|
|
// Query the log file via profile API.
|
|
//
|
|
d = GetPrivateProfileString(
|
|
LogSectionName,
|
|
TargetFilename,
|
|
TEXT(""),
|
|
ProfileValue,
|
|
sizeof(ProfileValue)/sizeof(ProfileValue[0]),
|
|
FileLog->FileName
|
|
);
|
|
|
|
if(d) {
|
|
//
|
|
// We want to retreive the Nth item in the value we just
|
|
// retreived, where N is based on what the caller wants.
|
|
// This routine assumes that the SetupFileLogInfo enum is
|
|
// in the same order as items appear in a line in the log!
|
|
//
|
|
Field = ProfileValue;
|
|
n = 0;
|
|
|
|
nextfield:
|
|
//
|
|
// Find the end of the current field, which is
|
|
// the first comma, or the end of the value.
|
|
// Skip leading spaces.
|
|
//
|
|
while(*Field == TEXT(' ')) {
|
|
Field++;
|
|
}
|
|
End = Field;
|
|
Quoted = FALSE;
|
|
while(*End) {
|
|
if(*End == TEXT('\"')) {
|
|
Quoted = !Quoted;
|
|
} else {
|
|
if(!Quoted && *End == TEXT(',')) {
|
|
//
|
|
// Got the end of the field.
|
|
//
|
|
break;
|
|
}
|
|
}
|
|
End++;
|
|
}
|
|
//
|
|
// At this point, Field points to the start of the field
|
|
// and End points at the character that terminated it.
|
|
//
|
|
if(n == DesiredInfo) {
|
|
Info = Field;
|
|
InfoLength = (UINT)(End-Field);
|
|
//
|
|
// Compensate for trailing space.
|
|
//
|
|
while (*--End == TEXT(' ')) {
|
|
InfoLength--;
|
|
}
|
|
} else {
|
|
//
|
|
// Skip trailing spaces and the comma, if any.
|
|
//
|
|
while(*End == ' ') {
|
|
End++;
|
|
}
|
|
if(*End == ',') {
|
|
//
|
|
// More fields exist.
|
|
//
|
|
Field = End+1;
|
|
n++;
|
|
goto nextfield;
|
|
} else {
|
|
//
|
|
// Item doesn't exist.
|
|
//
|
|
Info = TEXT("");
|
|
InfoLength = 0;
|
|
}
|
|
}
|
|
|
|
if(RequiredSize) {
|
|
*RequiredSize = InfoLength+1;
|
|
}
|
|
Err = NO_ERROR;
|
|
if(DataOut) {
|
|
if(ReturnBufferSize > InfoLength) {
|
|
lstrcpyn(DataOut,Info,InfoLength+1);
|
|
} else {
|
|
Err = ERROR_INSUFFICIENT_BUFFER;
|
|
}
|
|
}
|
|
} else {
|
|
Err = ERROR_FILE_NOT_FOUND;
|
|
}
|
|
}
|
|
} except(EXCEPTION_EXECUTE_HANDLER) {
|
|
Err = ERROR_INVALID_PARAMETER;
|
|
}
|
|
|
|
SetLastError(Err);
|
|
return(Err == NO_ERROR);
|
|
}
|
|
|