able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/termsrv/admtools/c2config/c2funcs/oschecks.c

1149 lines
32 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1994 Microsoft Corporation
Module Name:
OSChecks.C
Abstract:
functions to used to determine the Operating System(s) installed
on the current system.
Author:
Bob Watson (a-robw)
Revision History:
23 Dec 94
--*/
#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
#include <c2dll.h>
#include <c2inc.h>
#include <c2utils.h>
#include <strings.h>
#include "c2funcs.h"
#include "c2funres.h"
// define action codes here. They are only meaningful in the
// context of this module.
#define AC_NO_CHANGE 0
#define AC_UPDATE 1
//
// for the action value, these are bits in a bit-mask used to
// describe the action to take in the SET procedure
//
#define AV_DELETE_DOS 1
#define AV_SET_TIMEOUT 2
#define AV_SET_DEFAULT 4
#define SECURE C2DLL_C2
//
// define local macros
//
#define MALLOC(size) (PVOID)LocalAlloc(LPTR,size)
#define FREE(block) {LocalFree(block); block = NULL;}
//
// Unicode Specific macros
//
#if _UNICODE
#define DriveLetterToArcPath(a) DriveLetterToArcPathW(a)
#else // not unicode
#define DriveLetterToArcPath(a) DriveLetterToArcPathA(a)
#endif
//
// Leave as array because some code uses sizeof(ArcNameDirectory)
//
WCHAR ArcNameDirectory[] = L"\\ArcName";
BOOL bTargetsDefined = FALSE;
PWSTR DosDeviceTargets[24];
//
//
// Helper macro to make object attribute initialization a little cleaner.
//
#define INIT_OBJA(Obja,UnicodeString,UnicodeText) \
\
RtlInitUnicodeString((UnicodeString),(UnicodeText)); \
\
InitializeObjectAttributes( \
(Obja), \
(UnicodeString), \
OBJ_CASE_INSENSITIVE, \
NULL, \
NULL \
)
static
BOOL
IsIntelProcessor()
{
SYSTEM_INFO si;
memset (&si, 0, sizeof(si));
GetSystemInfo(&si);
if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL) {
return TRUE;
} else {
return FALSE;
}
}
static
VOID
DnConcatenatePaths(
IN OUT PWSTR Path1,
IN PWSTR Path2,
IN DWORD BufferSizeBytes
)
{
BOOL NeedBackslash = TRUE;
DWORD l = lstrlenW(Path1);
DWORD BufferSizeChars;
BufferSizeChars = (BufferSizeBytes >= sizeof(WCHAR))
? ((BufferSizeBytes/sizeof(WCHAR))-1) // leave room for nul
: 0;
//
// Determine whether we need to stick a backslash
// between the components.
//
if(l && (Path1[l-1] == L'\\')) {
NeedBackslash = FALSE;
}
if(*Path2 == L'\\') {
if(NeedBackslash) {
NeedBackslash = FALSE;
} else {
//
// Not only do we not need a backslash, but we
// need to eliminate one before concatenating.
//
Path2++;
}
}
//
// Append backslash if necessary and if it fits.
//
if(NeedBackslash && (l < BufferSizeChars)) {
lstrcatW(Path1,L"\\");
}
//
// Append second part of string to first part if it fits.
//
if(l+lstrlenW(Path2) < BufferSizeChars) {
lstrcatW(Path1,Path2);
}
}
static
PWSTR
DupString(
IN PWSTR String
)
{
PWSTR p;
p = MALLOC((lstrlenW(String)+1)*sizeof(WCHAR));
lstrcpyW(p,String);
return(p);
}
static
VOID
InitDriveNameTranslations(
VOID
)
{
WCHAR DriveName[3];
WCHAR Drive;
WCHAR DriveRoot[4];
WCHAR Buffer[512];
DriveName[1] = L':';
DriveName[2] = 0;
DriveRoot[0] = L' ';
DriveRoot[1] = L':';
DriveRoot[2] = L'\\';
DriveRoot[3] = 0;
//
// Calculate NT names for all local hard disks C-Z.
//
for(Drive=L'C'; Drive<=L'Z'; Drive++) {
DosDeviceTargets[Drive-L'C'] = NULL;
DriveRoot[0] = Drive;
if(GetDriveTypeW(DriveRoot) == DRIVE_FIXED) {
DriveName[0] = Drive;
// BUGBUG: this could be a mem leak...
if(QueryDosDeviceW(DriveName,Buffer,(sizeof(Buffer)/sizeof(WCHAR)))) {
DosDeviceTargets[Drive-L'C'] = DupString(Buffer);
}
}
}
}
static
PWSTR
DriveLetterToArcPathW(
IN WCHAR DriveLetter
)
{
UNICODE_STRING UnicodeString;
HANDLE DirectoryHandle;
HANDLE ObjectHandle;
OBJECT_ATTRIBUTES Obja;
NTSTATUS Status;
BOOL RestartScan;
DWORD Context;
BOOL MoreEntries;
PWSTR ArcName;
UCHAR Buffer[1024];
POBJECT_DIRECTORY_INFORMATION DirInfo = (POBJECT_DIRECTORY_INFORMATION)Buffer;
PWSTR ArcPath;
PWSTR NtPath;
NtPath = DosDeviceTargets[towupper(DriveLetter) - L'C'];
if(!NtPath) {
return(NULL);
}
//
// Assume failure.
//
ArcPath = NULL;
//
// Open the \ArcName directory.
//
INIT_OBJA(&Obja,&UnicodeString,ArcNameDirectory);
Status = NtOpenDirectoryObject(&DirectoryHandle,DIRECTORY_QUERY,&Obja);
if(NT_SUCCESS(Status)) {
RestartScan = TRUE;
Context = 0;
MoreEntries = TRUE;
do {
Status = NtQueryDirectoryObject(
(HANDLE)DirectoryHandle,
(PVOID)&Buffer[0],
(ULONG)sizeof(Buffer),
(BOOLEAN)TRUE, // return single entry
(BOOLEAN)RestartScan,
(PULONG)&Context,
(PULONG)NULL // return length
);
if(NT_SUCCESS(Status)) {
_wcslwr(DirInfo->Name.Buffer);
//
// Make sure this name is a symbolic link.
//
if(DirInfo->Name.Length
&& (DirInfo->TypeName.Length >= (sizeof(L"SymbolicLink") - sizeof(WCHAR)))
&& !_wcsnicmp(DirInfo->TypeName.Buffer,L"SymbolicLink",12))
{
ArcName = MALLOC(DirInfo->Name.Length + sizeof(ArcNameDirectory) + sizeof(WCHAR));
wcscpy(ArcName,ArcNameDirectory);
DnConcatenatePaths(ArcName,DirInfo->Name.Buffer,(DWORD)(-1));
//
// We have the entire arc name in ArcName. Now open it as a symbolic link.
//
INIT_OBJA(&Obja,&UnicodeString,ArcName);
Status = NtOpenSymbolicLinkObject(
&ObjectHandle,
READ_CONTROL | SYMBOLIC_LINK_QUERY,
&Obja
);
if(NT_SUCCESS(Status)) {
//
// Finally, query the object to get the link target.
//
UnicodeString.Buffer = (PWSTR)Buffer;
UnicodeString.Length = 0;
UnicodeString.MaximumLength = sizeof(Buffer);
Status = NtQuerySymbolicLinkObject(
ObjectHandle,
&UnicodeString,
NULL
);
if(NT_SUCCESS(Status)) {
//
// nul-terminate the returned string
//
UnicodeString.Buffer[UnicodeString.Length/sizeof(WCHAR)] = 0;
if(!_wcsicmp(UnicodeString.Buffer,NtPath)) {
ArcPath = ArcName
+ (sizeof(ArcNameDirectory)/sizeof(WCHAR));
}
}
NtClose(ObjectHandle);
}
if(!ArcPath) {
FREE(ArcName);
}
}
} else {
MoreEntries = FALSE;
if(Status == STATUS_NO_MORE_ENTRIES) {
Status = STATUS_SUCCESS;
}
}
RestartScan = FALSE;
} while(MoreEntries && !ArcPath);
NtClose(DirectoryHandle);
}
//
// ArcPath points into thje middle of a buffer.
// The caller needs to be able to free it, so place it in its
// own buffer here.
//
if(ArcPath) {
ArcPath = DupString(ArcPath);
FREE(ArcName);
}
return(ArcPath);
}
static
WCHAR
ArcPathToDriveLetter(
IN PWSTR ArcPath
)
{
NTSTATUS Status;
HANDLE ObjectHandle;
OBJECT_ATTRIBUTES Obja;
UNICODE_STRING UnicodeString;
UCHAR Buffer[1024];
WCHAR DriveLetter;
WCHAR drive;
PWSTR arcPath;
//
// Assume failure
//
DriveLetter = 0;
arcPath = MALLOC(((wcslen(ArcPath)+1)*sizeof(WCHAR)) + sizeof(ArcNameDirectory));
wcscpy(arcPath,ArcNameDirectory);
wcscat(arcPath,L"\\");
wcscat(arcPath,ArcPath);
INIT_OBJA(&Obja,&UnicodeString,arcPath);
Status = NtOpenSymbolicLinkObject(
&ObjectHandle,
READ_CONTROL | SYMBOLIC_LINK_QUERY,
&Obja
);
if(NT_SUCCESS(Status)) {
//
// Query the object to get the link target.
//
UnicodeString.Buffer = (PWSTR)Buffer;
UnicodeString.Length = 0;
UnicodeString.MaximumLength = sizeof(Buffer);
Status = NtQuerySymbolicLinkObject(
ObjectHandle,
&UnicodeString,
NULL
);
if(NT_SUCCESS(Status)) {
UnicodeString.Buffer[UnicodeString.Length/sizeof(WCHAR)] = 0;
for(drive=L'C'; drive<=L'Z'; drive++) {
if(DosDeviceTargets[drive-L'C']
&& !_wcsicmp(UnicodeString.Buffer,DosDeviceTargets[drive-L'C']))
{
DriveLetter = drive;
break;
}
}
}
NtClose(ObjectHandle);
}
FREE(arcPath);
return(DriveLetter);
}
static
BOOL
IsBootIniTimeoutZero (
)
{
TCHAR szTimeOut[MAX_PATH];
LONG lRetLen;
LONG lTimeOut;
lRetLen = GetPrivateProfileString (
GetStringResource (GetDllInstance(), IDS_BOOT_LOADER_SECTION),
GetStringResource (GetDllInstance(), IDS_TIMEOUT),
cmszEmptyString,
szTimeOut,
MAX_PATH,
GetStringResource (GetDllInstance(), IDS_BOOT_INI_PATH));
if (lRetLen > 0) {
lTimeOut = _tcstol (szTimeOut, NULL, 10);
// note that 0 is returned if the string cannot be translated!
if (lTimeOut > 0) {
return FALSE;
} else {
return TRUE;
}
} else {
// no time out string found
return FALSE;
}
}
static
LPSTR
DriveLetterToArcPathA (
IN CHAR DriveLetter
)
{
WCHAR wDriveLetter;
PWSTR wszArcPath;
LPSTR szArcPath;
int nRetLen;
wDriveLetter = (WCHAR)DriveLetter;
wszArcPath = DriveLetterToArcPathW(wDriveLetter);
if (wszArcPath != NULL) {
// convert back to ASCII
nRetLen = lstrlenW(wszArcPath);
szArcPath = MALLOC (nRetLen+1);
if (szArcPath != NULL) {
wcstombs (szArcPath, wszArcPath, nRetLen);
}
} else {
szArcPath = NULL;
}
return szArcPath;
}
static
LONG
GetArcWindowsPath (
OUT LPTSTR szArcPath, // buffer to write path to
IN DWORD dwChars // buffer length in chars
)
{
TCHAR szDosWindowsDir[MAX_PATH];
LPTSTR szArcWindowsDrive;
DWORD dwBufReqd;
if (szArcPath != NULL) {
if (GetWindowsDirectory(szDosWindowsDir, MAX_PATH) > 0) {
// convert Dos path to Arc Path
szArcWindowsDrive = DriveLetterToArcPath(szDosWindowsDir[0]);
if (szArcWindowsDrive != NULL) {
// make sure there's room in the buffer
dwBufReqd = lstrlen(szArcWindowsDrive) +
lstrlen(&szDosWindowsDir[2]);
if (dwBufReqd < dwChars) {
// theres room so copy and
// make full path
lstrcpy (szArcPath, szArcWindowsDrive);
lstrcat (szArcPath, &szDosWindowsDir[2]);
} else {
// insufficient room so return 0
dwBufReqd = 0;
*szArcPath = 0;
}
// release memory allocated by conversion
FREE (szArcWindowsDrive);
} else {
// unable to convert drive to arc path so return 0
dwBufReqd = 0;
*szArcPath = 0;
}
} else {
// unable to get current windows dir so return 0
dwBufReqd = 0;
*szArcPath = 0;
}
} else {
// empty or null buffer passed so just return 0 len
dwBufReqd = 0;
}
return (LONG)dwBufReqd;
}
static
BOOL
IsCurrentSystemDefault (
)
{
TCHAR szArcWindowsDir[MAX_PATH*2];
TCHAR szArcDefaultDir[MAX_PATH];
LONG lStatus;
BOOL bReturn;
if (GetArcWindowsPath(szArcWindowsDir, MAX_PATH*2) > 0) {
// get boot.ini default from [Boot Loader] section
lStatus = GetPrivateProfileString (
GetStringResource (GetDllInstance(), IDS_BOOT_LOADER_SECTION),
GetStringResource (GetDllInstance(), IDS_DEFAULT_KEY),
cszEmptyString,
&szArcDefaultDir[0],
MAX_PATH,
GetStringResource (GetDllInstance(), IDS_BOOT_INI_FILENAME));
if (lStatus > 0) {
if (lstrcmpi (szArcDefaultDir, szArcWindowsDir) == 0) {
// default is current system
bReturn = TRUE;
} else {
// default is not current system
bReturn = FALSE;
}
}
} else {
//unable to get windows dir
bReturn = FALSE;
}
return bReturn;
}
static
BOOL
ZeroFileByName (
IN LPCTSTR szFileName
)
{
DWORD dwOldAttrib = 0;
DWORD dwNewAttrib = 0;
HANDLE hFile;
BOOL bReturn = FALSE;
if (FileExists (szFileName)) {
// save the original attributes for later
dwOldAttrib = GetFileAttributes (szFileName);
// set file attributes on file to allow modification
SetFileAttributes (szFileName, FILE_ATTRIBUTE_NORMAL);
// make sure it went OK
dwNewAttrib = GetFileAttributes (szFileName);
if (dwNewAttrib == FILE_ATTRIBUTE_NORMAL) {
hFile = CreateFile (
szFileName,
GENERIC_WRITE,
0L, // no sharing while this is done
NULL, // no security
TRUNCATE_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (hFile != INVALID_HANDLE_VALUE) {
CloseHandle (hFile);
bReturn = TRUE;
}
// reset the attributes
SetFileAttributes (szFileName, dwOldAttrib);
}
} else {
// file doesn't exist so it's already 0'd
bReturn = TRUE;
}
return bReturn;
}
static
BOOL
DeleteDosFiles (
)
{
BOOL bReturn;
bReturn = ZeroFileByName (
GetStringResource(GetDllInstance(), IDS_IO_SYS));
if (bReturn) {
bReturn = ZeroFileByName (
GetStringResource(GetDllInstance(), IDS_MSDOS_SYS));
}
if (bReturn) {
bReturn = ZeroFileByName (
GetStringResource(GetDllInstance(), IDS_PCDOS_SYS));
}
return bReturn;
}
static
BOOL
SetBootIniTimeoutToZero (
)
{
BOOL bReturn = TRUE;
DWORD dwNewBootIniAttrib = 0;
DWORD dwOrigBootIniAttrib = 0;
// save the original attributes for later
dwOrigBootIniAttrib = GetFileAttributes (
GetStringResource (GetDllInstance(), IDS_BOOT_INI_FILENAME));
// set file attributes on Boot.INI file
SetFileAttributes (
GetStringResource (GetDllInstance(), IDS_BOOT_INI_FILENAME),
FILE_ATTRIBUTE_NORMAL);
// make sure it went OK
dwNewBootIniAttrib = GetFileAttributes (
GetStringResource (GetDllInstance(), IDS_BOOT_INI_FILENAME));
if (dwNewBootIniAttrib == FILE_ATTRIBUTE_NORMAL) {
bReturn = WritePrivateProfileString (
GetStringResource (GetDllInstance(), IDS_BOOT_LOADER_SECTION),
GetStringResource (GetDllInstance(), IDS_TIMEOUT),
GetStringResource (GetDllInstance(), IDS_0),
GetStringResource (GetDllInstance(), IDS_BOOT_INI_PATH));
// reset file attributes on Boot.INI file
SetFileAttributes (
GetStringResource (GetDllInstance(), IDS_BOOT_INI_FILENAME),
dwOrigBootIniAttrib);
return bReturn;
} else {
return FALSE;
}
}
static
BOOL
SetBootDefaultToCurrentSystem (
)
{
TCHAR szArcSystemPath[MAX_PATH*2];
BOOL bReturn = TRUE;
DWORD dwNewBootIniAttrib = 0;
DWORD dwOrigBootIniAttrib = 0;
// save the original attributes for later
dwOrigBootIniAttrib = GetFileAttributes (
GetStringResource (GetDllInstance(), IDS_BOOT_INI_FILENAME));
// set file attributes on Boot.INI file
SetFileAttributes (
GetStringResource (GetDllInstance(), IDS_BOOT_INI_FILENAME),
FILE_ATTRIBUTE_NORMAL);
// make sure it went OK
dwNewBootIniAttrib = GetFileAttributes (
GetStringResource (GetDllInstance(), IDS_BOOT_INI_FILENAME));
if (dwNewBootIniAttrib == FILE_ATTRIBUTE_NORMAL) {
// file set OK so continue and get new path for ini
if (GetArcWindowsPath(szArcSystemPath, MAX_PATH*2) > 0) {
bReturn = WritePrivateProfileString (
GetStringResource (GetDllInstance(), IDS_BOOT_LOADER_SECTION),
GetStringResource (GetDllInstance(), IDS_DEFAULT_KEY),
szArcSystemPath,
GetStringResource (GetDllInstance(), IDS_BOOT_INI_PATH));
// reset file attributes on Boot.INI file
SetFileAttributes (
GetStringResource (GetDllInstance(), IDS_BOOT_INI_FILENAME),
dwOrigBootIniAttrib);
}
return bReturn;
} else {
return FALSE;
}
}
static
BOOL
IsDosOnSystem (
)
{
BOOL bFileFound;
LPCTSTR szFileToCheck;
szFileToCheck = GetStringResource(GetDllInstance(), IDS_IO_SYS);
bFileFound = FileExists(szFileToCheck);
if (bFileFound) {
// check to see if it's really there
if (GetFileSizeFromPath(szFileToCheck) == 0) {
// just a name so reset flag
bFileFound = FALSE;
}
}
if (!bFileFound) {
szFileToCheck = GetStringResource(GetDllInstance(), IDS_MSDOS_SYS);
bFileFound = FileExists(szFileToCheck);
if (bFileFound) {
// check to see if it's really there
if (GetFileSizeFromPath(szFileToCheck) == 0) {
// just a name so reset flag
bFileFound = FALSE;
}
}
}
if (!bFileFound) {
szFileToCheck = GetStringResource(GetDllInstance(), IDS_PCDOS_SYS);
bFileFound = FileExists(szFileToCheck);
if (bFileFound) {
// check to see if it's really there
if (GetFileSizeFromPath(szFileToCheck) == 0) {
// just a name so reset flag
bFileFound = FALSE;
}
}
}
return bFileFound;
}
BOOL CALLBACK
C2OpSysDlgProc(
IN HWND hDlg, // window handle of the dialog box
IN UINT message, // type of message
IN WPARAM wParam,
IN LPARAM lParam
)
/*++
Routine Description:
Window procedure for Operating System List Box
Arguments:
Standard DlgProc arguments
ReturnValue:
TRUE the message was handled by this routine
FALSE DefDialogProc should handle the message
--*/
{
LONG lItemCount = 0;
static LPDWORD lpdwActionMask;
DWORD dwAction;
LONG lIndex;
LONG lItems;
switch (message) {
case WM_INITDIALOG:
// bail out here if an invalid param was passed
if (lParam == 0) {
EndDialog (hDlg, IDCANCEL);
return FALSE;
}
// save pointer to param
lpdwActionMask = (LPDWORD)lParam;
// set the dialog box caption and static text
SetDlgItemText (hDlg, IDC_TEXT,
GetStringResource (GetDllInstance(), IDS_OS_DLG_TEXT));
SetWindowText (hDlg,
GetStringResource (GetDllInstance(), IDS_OS_CAPTION));
// load list box with characteristics that are not C2
if (IsDosOnSystem()) {
lIndex = SendDlgItemMessage (hDlg, IDC_LIST_BOX,
LB_ADDSTRING, 0,
(LPARAM)GetStringResource (GetDllInstance(), IDS_DOS_ON_SYSTEM));
if (lIndex != LB_ERR) {
lItemCount++;
SendDlgItemMessage (hDlg, IDC_LIST_BOX, LB_SETITEMDATA,
(WPARAM)lIndex, (LPARAM)AV_DELETE_DOS);
}
}
if (!IsBootIniTimeoutZero()) {
lIndex = SendDlgItemMessage (hDlg, IDC_LIST_BOX,
LB_ADDSTRING, 0,
(LPARAM)GetStringResource (GetDllInstance(), IDS_TIMEOUT_NOT_ZERO));
if (lIndex != LB_ERR) {
lItemCount++;
SendDlgItemMessage (hDlg, IDC_LIST_BOX, LB_SETITEMDATA,
(WPARAM)lIndex, (LPARAM)AV_SET_TIMEOUT);
}
}
// check for current system defined as default
if (!IsCurrentSystemDefault()) {
lIndex = SendDlgItemMessage (hDlg, IDC_LIST_BOX, LB_ADDSTRING, 0,
(LPARAM)GetStringResource (GetDllInstance(), IDS_CURRENT_SYS_NOT_DEFAULT));
if (lIndex != LB_ERR) {
lItemCount++;
SendDlgItemMessage (hDlg, IDC_LIST_BOX, LB_SETITEMDATA,
(WPARAM)lIndex, (LPARAM)AV_SET_DEFAULT);
}
}
SetFocus (GetDlgItem (hDlg, IDOK)); // set focus to OK Button
return FALSE; // we don't want Windows to set the focus
case WM_COMMAND:
switch (LOWORD(wParam)){
case IDC_C2:
if (HIWORD(wParam) == BN_CLICKED) {
// select all entries in the list box
SendDlgItemMessage (hDlg, IDC_LIST_BOX,
LB_SETSEL, TRUE, (LPARAM)-1);
return TRUE;
} else {
return FALSE;
}
case IDOK:
dwAction = 0;
// scan through list box to see which Items are to be
// changed (if any)
lItems = SendDlgItemMessage (hDlg, IDC_LIST_BOX, LB_GETCOUNT,
0, 0);
for (lIndex = 0; lIndex < lItems; lIndex++) {
// if item is selected, then "or" it's value to the mask
// i.e. set it's bit
if (SendDlgItemMessage (hDlg, IDC_LIST_BOX, LB_GETSEL, (WPARAM)lIndex, 0) != 0) {
dwAction |= (DWORD) SendDlgItemMessage (hDlg, IDC_LIST_BOX,
LB_GETITEMDATA, (WPARAM)lIndex, 0);
}
}
// update action value with flag bits
*lpdwActionMask = dwAction;
// fall through to next case
case IDCANCEL:
if (HIWORD(wParam) == BN_CLICKED) {
// exit and return button that caused exit
EndDialog (hDlg, (int)LOWORD(wParam));
return TRUE;
} else {
return FALSE;
}
case IDC_HELP:
PostMessage (GetParent(hDlg), UM_SHOW_CONTEXT_HELP, 0, 0);
return TRUE;
default:
return FALSE;
}
default:
return (FALSE); // Didn't process the message
}
}
LONG
C2QueryOpSystems (
IN LPARAM lParam
)
/*++
Routine Description:
Function called to find out the operating system(s) installed
on the system. For C2 compliance, ONLY Windows NT is
allowed on the system.
Arguments:
Pointer to the Dll data block passed as an LPARAM.
ReturnValue:
ERROR_SUCCESS if the function succeeds otherwise a
WIN32 error is returned if an error occurs
--*/
{
PC2DLL_DATA pC2Data;
if (lParam != 0) {
SET_WAIT_CURSOR;
if (!bTargetsDefined) {
InitDriveNameTranslations();
bTargetsDefined = TRUE;
}
pC2Data = (PC2DLL_DATA)lParam;
pC2Data->lC2Compliance = SECURE; // assume true for now
// check for DOS files found on system
if (IsDosOnSystem()) {
pC2Data->lC2Compliance = C2DLL_NOT_SECURE;
lstrcpy (pC2Data->szStatusName,
GetStringResource (GetDllInstance(), IDS_DOS_ON_SYSTEM));
}
// check for boot.ini timeout > 0
if (pC2Data->lC2Compliance == SECURE) {
if (!IsBootIniTimeoutZero()) {
pC2Data->lC2Compliance = C2DLL_NOT_SECURE;
lstrcpy (pC2Data->szStatusName,
GetStringResource (GetDllInstance(), IDS_TIMEOUT_NOT_ZERO));
}
}
// check for current system defined as default
if (pC2Data->lC2Compliance == SECURE) {
if (!IsCurrentSystemDefault()) {
pC2Data->lC2Compliance = C2DLL_NOT_SECURE;
lstrcpy (pC2Data->szStatusName,
GetStringResource (GetDllInstance(), IDS_CURRENT_SYS_NOT_DEFAULT));
}
}
if (pC2Data->lC2Compliance == SECURE) {
lstrcpy (pC2Data->szStatusName,
GetStringResource (GetDllInstance(), IDS_OS_OK));
}
SET_ARROW_CURSOR;
} else {
return ERROR_BAD_ARGUMENTS;
}
return ERROR_SUCCESS;
}
LONG
C2SetOpSystems (
IN LPARAM lParam
)
/*++
Routine Description:
Function called to change the current state of this configuration
item based on an action code passed in the DLL data block. If
this function successfully sets the state of the configuration
item, then the C2 Compliance flag and the Status string to reflect
the new value of the configuration item.
Arguments:
Pointer to the Dll data block passed as an LPARAM.
ReturnValue:
ERROR_SUCCESS if the function succeeds otherwise a
WIN32 error is returned if an error occurs
--*/
{
PC2DLL_DATA pC2Data;
if (lParam != 0) {
pC2Data = (PC2DLL_DATA)lParam;
if ((pC2Data->lActionCode == AC_UPDATE) && (pC2Data->lActionValue != 0)) {
SET_WAIT_CURSOR;
if (pC2Data->lActionValue & AV_DELETE_DOS) {
if (DisplayDllMessageBox (
pC2Data->hWnd,
IDS_OS_DELETE_DOS_FILES,
IDS_OS_CAPTION,
MBOKCANCEL_EXCLAIM | MB_DEFBUTTON2) == IDOK) {
DeleteDosFiles();
}
}
if (pC2Data->lActionValue & AV_SET_TIMEOUT) {
if (IsIntelProcessor()) {
if (DisplayDllMessageBox (
pC2Data->hWnd,
IDS_OS_ZERO_BOOT_TIMEOUT,
IDS_OS_CAPTION,
MBOKCANCEL_EXCLAIM | MB_DEFBUTTON2) == IDOK) {
SetBootIniTimeoutToZero();
}
} else {
DisplayDllMessageBox (
pC2Data->hWnd,
IDS_OS_RISC_BOOT_TIMEOUT,
IDS_OS_CAPTION,
MBOK_EXCLAIM);
}
}
if (pC2Data->lActionValue & AV_SET_DEFAULT) {
SetBootDefaultToCurrentSystem ();
}
// now check to see what happened
pC2Data->lC2Compliance = SECURE; // assume true for now
// check for DOS files found on system
if (IsDosOnSystem()) {
pC2Data->lC2Compliance = C2DLL_NOT_SECURE;
lstrcpy (pC2Data->szStatusName,
GetStringResource (GetDllInstance(), IDS_DOS_ON_SYSTEM));
}
// check for boot.ini timeout > 0
if (pC2Data->lC2Compliance == SECURE) {
if (!IsBootIniTimeoutZero()) {
pC2Data->lC2Compliance = C2DLL_NOT_SECURE;
lstrcpy (pC2Data->szStatusName,
GetStringResource (GetDllInstance(), IDS_TIMEOUT_NOT_ZERO));
}
}
// check for current system defined as default
if (pC2Data->lC2Compliance == SECURE) {
if (!IsCurrentSystemDefault()) {
pC2Data->lC2Compliance = C2DLL_NOT_SECURE;
lstrcpy (pC2Data->szStatusName,
GetStringResource (GetDllInstance(), IDS_CURRENT_SYS_NOT_DEFAULT));
}
}
if (pC2Data->lC2Compliance == SECURE) {
lstrcpy (pC2Data->szStatusName,
GetStringResource (GetDllInstance(), IDS_OS_OK));
}
SET_ARROW_CURSOR;
}
pC2Data->lActionCode = 0;
} else {
return ERROR_BAD_ARGUMENTS;
}
return ERROR_SUCCESS;
}
LONG
C2DisplayOpSystems (
IN LPARAM lParam
)
/*++
Routine Description:
Function called to display more information on the configuration
item and provide the user with the option to change the current
setting (if appropriate). If the User "OK's" out of the UI,
then the action code field in the DLL data block is set to the
appropriate (and configuration item-specific) action code so the
"Set" function can be called to perform the desired action. If
the user Cancels out of the UI, then the Action code field is
set to 0 (no action) and no action is performed.
Arguments:
Pointer to the Dll data block passed as an LPARAM.
ReturnValue:
ERROR_SUCCESS if the function succeeds otherwise a
WIN32 error is returned if an error occurs
--*/
{
PC2DLL_DATA pC2Data;
INT nDlgBoxReturn;
LONG lDlgBoxParam;
if (lParam != 0) {
pC2Data = (PC2DLL_DATA)lParam;
// check the C2 Compliance flag to see if the list box or
// message box should be displayed
if (pC2Data->lC2Compliance == SECURE) {
// all volumes are OK so just pop a message box
lDlgBoxParam = 0;
DisplayDllMessageBox (
pC2Data->hWnd,
IDS_OS_OK,
IDS_OS_CAPTION,
MBOK_INFO);
pC2Data->lActionCode = 0;
pC2Data->lActionValue = 0;
} else {
//one or more volumes are not NTFS so display the list box
// listing the ones that arent.
nDlgBoxReturn = DialogBoxParam (
GetDllInstance(),
MAKEINTRESOURCE (IDD_LIST_DLG),
pC2Data->hWnd,
C2OpSysDlgProc,
(LPARAM)&lDlgBoxParam);
if (nDlgBoxReturn == IDOK) {
pC2Data->lActionCode = 1;
pC2Data->lActionValue = lDlgBoxParam;
} else {
pC2Data->lActionCode = 0;
pC2Data->lActionValue = 0;
}
}
} else {
return ERROR_BAD_ARGUMENTS;
}
return ERROR_SUCCESS;
}

Reference in a new issue Copy permalink