2594 lines
88 KiB
C
2594 lines
88 KiB
C
/*++
|
|
|
|
Copyright (c) 1995 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
mini.c
|
|
|
|
Abstract:
|
|
|
|
This module contains code that supports the installation and initialization
|
|
of a system's network adapter card under the MiniNT environment. Its functions
|
|
include changing the ComputerName to a randomly generated string, establishing
|
|
the system as being part of a local workgroup, and installing the necessary
|
|
drivers (via PnP) for the detected network adapter card. This functionality
|
|
relies upon the existence of WINBOM.INI and its following sections:
|
|
|
|
[Factory]
|
|
FactoryComputerName = ... ;Sets the first part of the random generated string to
|
|
;this value...if not present then prepends the random
|
|
;string with the value "MININT"
|
|
|
|
[NetCards]
|
|
PnPID=...\xyz.inf ;Scans the list of netcards/inf key value pairs and attempts
|
|
. ;to install drivers for the devices listed here BEFORE performing
|
|
. ;an exhaustive search of all the in-box drivers and attempting
|
|
. ;to locate the matching paramters for the enumerated hardware.
|
|
.
|
|
.
|
|
|
|
Author:
|
|
|
|
Jason Lawrence (t-jasonl) - 8/11/2000
|
|
|
|
Revision History:
|
|
|
|
--*/
|
|
#include "factoryp.h"
|
|
#include <winioctl.h>
|
|
#include <spapip.h>
|
|
|
|
// Defines
|
|
#define CLOSEHANDLE(h) ( (h != NULL) ? (CloseHandle(h) ? ((h = NULL) == NULL) : (FALSE) ) : (FALSE) )
|
|
#define BUFSIZE 4096
|
|
#define NET_CONNECT_TIMEOUT 120 // seconds
|
|
|
|
|
|
// Various Structures used in this file
|
|
//
|
|
|
|
// ********************************************************************************************************************
|
|
// Sample entry into table for FILEINFO struct:
|
|
//
|
|
// { _T("<config>\\oobeinfo.ini"), _T("oobe\\oobeinfo.ini"), FALSE, TRUE }
|
|
//
|
|
// This means: Copy file oobeinfo.ini from <opkSourceRoot>\<config>\oobeinfo.ini to <opkTargetDrive>\oobe\oobeinfo.ini
|
|
// This is not a directory and is a required file.
|
|
//
|
|
// Variables allowed to be expanded: <sku>, <arch>, <lang>, <cfg>.
|
|
// ********************************************************************************************************************
|
|
|
|
typedef struct _FILEINFO
|
|
{
|
|
LPTSTR szFISourceName; // Source name. Relative to source root.
|
|
LPTSTR szFITargetName; // Relative to targetpath. If NULL the target drive root is assumed.
|
|
BOOL bDirectory; // Is filename a directory? If TRUE do a recursive copy.
|
|
BOOL bRequired; // TRUE - file is required. FALSE - file is optional.
|
|
|
|
} FILEINFO, *PFILEINFO, *LPFILEINFO;
|
|
|
|
// For the filesystem type
|
|
//
|
|
typedef enum _FSTYPES
|
|
{
|
|
fsNtfs,
|
|
fsFat32,
|
|
fsFat // for fat16/12
|
|
} FSTYPES;
|
|
|
|
// For partition types
|
|
//
|
|
typedef enum _PTTYPES
|
|
{
|
|
ptPrimary,
|
|
ptExtended,
|
|
ptLogical,
|
|
ptMsr,
|
|
ptEfi
|
|
} PTTYPES;
|
|
|
|
|
|
typedef struct _PARTITION
|
|
{
|
|
TCHAR cDriveLetter;
|
|
ULONGLONG ullSize;
|
|
UINT uiFileSystem; // NTFS or FAT32 or FAT
|
|
BOOL bQuickFormat;
|
|
UINT uiPartitionType; // Primary, extended, logical, msr, efi.
|
|
BOOL bSetActive;
|
|
UINT uiDiskID; // This is the disk number that this partition is on. 0-based
|
|
BOOL bWipeDisk; // TRUE if this disk needs to be wiped.
|
|
struct _PARTITION *pNext;
|
|
|
|
} *PPARTITION, PARTITION;
|
|
|
|
|
|
// Local functions
|
|
//
|
|
LPTSTR static mylstrcat( LPTSTR lpString1, LPCTSTR lpString2, DWORD dwSize );
|
|
BOOL static StartDiskpart( HANDLE*, HANDLE*, HANDLE*, HANDLE*);
|
|
BOOL static ProcessDiskConfigSection(LPTSTR lpszWinBOMPath);
|
|
BOOL static ProcessDisk(UINT diskID, LPTSTR lpSectionName, LPTSTR lpszWinBOMPath, BOOL bWipeDisk);
|
|
BOOL static Build(LPTSTR lpKey, DWORD dwSize, UINT diskID, LPCTSTR lpKeyName);
|
|
BOOL static FormatPartitions(VOID);
|
|
BOOL static JustFormatC(LPTSTR lpszWinBOMPath, LPTSTR lpszSectionBuffer);
|
|
BOOL static GetNumberOfPartitions(UINT uiDiskNumber, PDWORD numPartitions);
|
|
ULONGLONG static GetDiskSizeMB(UINT uiDiskNumber);
|
|
VOID static ListInsert(PPARTITION pAfterThis, PPARTITION pNew);
|
|
VOID static ListFree(PPARTITION pList);
|
|
VOID static AddMsrAndEfi(BOOL bMsr, BOOL bEfi, PPARTITION pLastLast, UINT uiDiskID, BOOL bWipeDisk);
|
|
|
|
//
|
|
// Default system policies for driver signing and non-driver signing
|
|
// for WinPE
|
|
//
|
|
#define DEFAULT_DRVSIGN_POLICY DRIVERSIGN_NONE
|
|
#define DEFAULT_NONDRVSIGN_POLICY DRIVERSIGN_NONE
|
|
|
|
VOID
|
|
pSetupGetRealSystemTime(
|
|
OUT LPSYSTEMTIME RealSystemTime
|
|
);
|
|
|
|
typedef enum _CODESIGNING_POLICY_TYPE {
|
|
PolicyTypeDriverSigning,
|
|
PolicyTypeNonDriverSigning
|
|
} CODESIGNING_POLICY_TYPE, *PCODESIGNING_POLICY_TYPE;
|
|
|
|
VOID
|
|
pSetCodeSigningPolicy(
|
|
IN CODESIGNING_POLICY_TYPE PolicyType,
|
|
IN BYTE NewPolicy,
|
|
OUT PBYTE OldPolicy OPTIONAL
|
|
);
|
|
|
|
|
|
//**********************************************************
|
|
// The formula for calculating the size of ESP partition is:
|
|
//
|
|
// MAX( 100 MB, MIN (1000 MB, DiskSize MB / 100 ) )
|
|
//
|
|
//**********************************************************
|
|
__inline
|
|
ULONGLONG
|
|
GetDiskEFISizeMB( UINT uiDiskNumber )
|
|
{
|
|
ULONGLONG DiskSizeMB = GetDiskSizeMB( uiDiskNumber );
|
|
return ( max( 100, min( 1000, DiskSizeMB / 100 ) ) );
|
|
}
|
|
|
|
//**********************************************************
|
|
// The formula for calculating the size of MSR partition is:
|
|
//
|
|
// IF ( Disk Size < 16 GB ) then MSR is 32 MB.
|
|
// ELSE MSR is 128 MB.
|
|
//
|
|
//**********************************************************
|
|
|
|
__inline
|
|
ULONGLONG
|
|
GetDiskMSRSizeMB( UINT uiDiskNumber )
|
|
{
|
|
ULONGLONG DiskSizeMB = GetDiskSizeMB( uiDiskNumber );
|
|
|
|
return ( ( ( DiskSizeMB / 1024 ) >= 16 ) ? 128 : 32 );
|
|
}
|
|
|
|
|
|
// Dialog Procs
|
|
//
|
|
INT_PTR CALLBACK ShutdownDlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
|
|
|
|
|
|
// Constant Strings
|
|
//
|
|
const static TCHAR DCDISK[] = _T("select disk ");
|
|
const static TCHAR DCPARTITION[] = _T("create partition ");
|
|
const static TCHAR DCSIZE[] = _T(" size=");
|
|
const static TCHAR DCASSIGNLETTER[] = _T("assign letter=");
|
|
const static TCHAR DCEXIT[] = _T("exit");
|
|
const static TCHAR DCNEWLINE[] = _T("\n");
|
|
const static TCHAR DCLISTPARTITION[] = _T("list partition");
|
|
const static TCHAR DCSELPARTITION[] = _T("select partition ");
|
|
const static TCHAR DCSETACTIVE[] = _T("active");
|
|
|
|
// This command will delete all the partitions on a disk.
|
|
//
|
|
const static TCHAR DCWIPEDISK[] = _T("clean");
|
|
const static TCHAR DCCONVERT_GPT[] = _T("convert gpt\nselect partition 1\ndelete partition override");
|
|
|
|
const static TCHAR DCPARTITION_PRIMARY[] = _T("primary");
|
|
const static TCHAR DCPARTITION_EXTENDED[] = _T("extended");
|
|
const static TCHAR DCPARTITION_LOGICAL[] = _T("logical");
|
|
const static TCHAR DCPARTITION_MSR[] = _T("msr");
|
|
const static TCHAR DCPARTITION_EFI[] = _T("efi");
|
|
|
|
const static TCHAR DCS_DISK_TYPE[] = _T("DiskType");
|
|
|
|
const static TCHAR DCS_FILE_SYSTEM[] = _T("FileSystem");
|
|
const static TCHAR DCS_QUICK_FORMAT[] = _T("QuickFormat");
|
|
const static TCHAR DCS_SIZE[] = _T("Size");
|
|
const static TCHAR DCS_PARTITION_TYPE[] = _T("PartitionType");
|
|
const static TCHAR DCS_PARTITION_ID[] = _T("PartitionID");
|
|
const static TCHAR DCS_SET_ACTIVE[] = _T("SetActive");
|
|
|
|
|
|
|
|
const static TCHAR c_szActiveComputerNameRegKey[] = L"System\\CurrentControlSet\\Control\\ComputerName\\ActiveComputerName";
|
|
const static TCHAR c_szComputerNameRegKey[] = L"System\\CurrentControlSet\\Control\\ComputerName\\ComputerName";
|
|
|
|
static TCHAR g_szTargetDrive[] = _T("C:\\");
|
|
|
|
// Files to be copied.
|
|
// No leading or trailing backslashes.
|
|
//
|
|
static FILEINFO g_filesToCopy[] =
|
|
{
|
|
// SOURCE, TARGET, isDirectory, isRequired
|
|
//
|
|
{ _T("cfgsets\\<cfg>\\winbom.ini"), _T("sysprep\\winbom.ini"), FALSE, TRUE },
|
|
{ _T("cfgsets\\<cfg>\\unattend.txt"), _T("sysprep\\unattend.txt"), FALSE, TRUE },
|
|
{ _T("lang\\<lang>\\tools\\<arch>"), _T("sysprep"), TRUE, FALSE },
|
|
{ _T("lang\\<lang>\\sku\\<sku>\\<arch>"), _T(""), TRUE, TRUE }
|
|
};
|
|
|
|
// Linked list to hold partition information.
|
|
//
|
|
static PPARTITION g_PartList = NULL;
|
|
|
|
// External variables
|
|
//
|
|
extern HINSTANCE g_hInstance;
|
|
|
|
|
|
// External functions
|
|
//
|
|
typedef VOID (WINAPI *ExternalGenerateName)
|
|
(
|
|
PWSTR GeneratedString,
|
|
DWORD DesiredStrLen
|
|
);
|
|
|
|
|
|
|
|
/*++
|
|
===============================================================================
|
|
Routine Description:
|
|
|
|
BOOL SetupMiniNT
|
|
|
|
This routine serves as the main entry point for initializing the netcard
|
|
under MiniNT. Also performs the tasks of changing the computer name
|
|
and establishing the computer as part of a local workgroup. Called from
|
|
factory!WinMain.
|
|
|
|
Arguments:
|
|
|
|
Return Value:
|
|
|
|
TRUE if netcard was correctly installed
|
|
FALSE if there was an error
|
|
|
|
===============================================================================
|
|
--*/
|
|
BOOL
|
|
SetupMiniNT(
|
|
VOID
|
|
)
|
|
{
|
|
BOOL bInstallNIC;
|
|
BOOL bRet = TRUE;
|
|
WCHAR szRequestedComputerName[100];
|
|
WCHAR szComputerName[100];
|
|
WCHAR szGeneratedName[100];
|
|
PWSTR AppendStr = NULL;
|
|
|
|
// for syssetup.dll GenerateName
|
|
HINSTANCE hInstSysSetup = NULL;
|
|
ExternalGenerateName pGenerateName = NULL;
|
|
|
|
HKEY hActiveComputerNameKey;
|
|
HKEY hComputerNameKey;
|
|
BOOL RemoteBoot = IsRemoteBoot();
|
|
extern FACTMODE g_fm;
|
|
|
|
LPTSTR lpszAdmin = NULL;
|
|
LPTSTR lpszWorkgroup = NULL;
|
|
|
|
//
|
|
// Reset the driver signing policy in WinPE
|
|
//
|
|
pSetCodeSigningPolicy(PolicyTypeDriverSigning,
|
|
DEFAULT_DRVSIGN_POLICY,
|
|
NULL);
|
|
|
|
pSetCodeSigningPolicy(PolicyTypeNonDriverSigning,
|
|
DEFAULT_NONDRVSIGN_POLICY,
|
|
NULL);
|
|
|
|
if (!RemoteBoot) {
|
|
// set random computer name
|
|
hInstSysSetup = LoadLibrary(L"syssetup.dll");
|
|
if (hInstSysSetup == NULL)
|
|
{
|
|
FacLogFileStr(0 | LOG_ERR | LOG_MSG_BOX, L"Failed to load syssetup.dll");
|
|
bRet = FALSE;
|
|
goto Clean;
|
|
}
|
|
|
|
pGenerateName = (ExternalGenerateName)GetProcAddress(hInstSysSetup,
|
|
"GenerateName");
|
|
if (pGenerateName == NULL)
|
|
{
|
|
FacLogFileStr(0 | LOG_ERR | LOG_MSG_BOX, L"Failed to obtain address of GenerateName");
|
|
bRet = FALSE;
|
|
goto Clean;
|
|
}
|
|
|
|
// call GenerateName
|
|
pGenerateName(szGeneratedName, 15);
|
|
|
|
// obtain factory computer name from winbom.ini...default to MININT
|
|
GetPrivateProfileString(L"Factory",
|
|
L"FactoryComputerName",
|
|
L"MININT",
|
|
szRequestedComputerName,
|
|
sizeof(szRequestedComputerName)/sizeof(TCHAR),
|
|
g_szWinBOMPath);
|
|
|
|
lstrcpyn (szComputerName, szRequestedComputerName, AS ( szComputerName ) );
|
|
AppendStr = wcsstr(szGeneratedName, L"-");
|
|
|
|
// ISSUE-2002/02/27-acosma,georgeje - The size of the computername we generate
|
|
// is not guaranteed to be less than MAX_COMPUTERNAME length.
|
|
//
|
|
|
|
if ( AppendStr )
|
|
{
|
|
if ( FAILED ( StringCchCat ( szComputerName, AS ( szComputerName ), AppendStr) ) )
|
|
{
|
|
FacLogFileStr(3, _T("StringCchCat failed %s %s\n"), szComputerName, AppendStr ) ;
|
|
}
|
|
}
|
|
|
|
// now set the computer name
|
|
if (ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
c_szActiveComputerNameRegKey,
|
|
0,
|
|
KEY_SET_VALUE,
|
|
&hActiveComputerNameKey))
|
|
{
|
|
FacLogFileStr(0 | LOG_ERR | LOG_MSG_BOX, L"Failed to open ActiveComputerName.");
|
|
bRet = FALSE;
|
|
goto Clean;
|
|
}
|
|
|
|
if ( ERROR_SUCCESS != RegSetValueEx(hActiveComputerNameKey,
|
|
L"ComputerName",
|
|
0,
|
|
REG_SZ,
|
|
(LPBYTE)szComputerName,
|
|
(lstrlen(szComputerName)+1) * sizeof(WCHAR)) )
|
|
{
|
|
FacLogFileStr(0 | LOG_ERR | LOG_MSG_BOX, L"Failed to set ActiveComputerName.");
|
|
bRet = FALSE;
|
|
goto Clean;
|
|
}
|
|
|
|
RegCloseKey(hActiveComputerNameKey);
|
|
|
|
if (ERROR_SUCCESS != RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
c_szComputerNameRegKey,
|
|
0,
|
|
KEY_SET_VALUE,
|
|
&hComputerNameKey))
|
|
{
|
|
FacLogFileStr(0 | LOG_ERR | LOG_MSG_BOX, L"Failed to open ComputerName.");
|
|
bRet = FALSE;
|
|
goto Clean;
|
|
}
|
|
|
|
if ( ERROR_SUCCESS != RegSetValueEx(hComputerNameKey,
|
|
L"ComputerName",
|
|
0,
|
|
REG_SZ,
|
|
(LPBYTE)szComputerName,
|
|
(lstrlen(szComputerName)+1) * sizeof(WCHAR)) )
|
|
{
|
|
FacLogFileStr(0 | LOG_ERR | LOG_MSG_BOX, L"Failed to set ComputerName.");
|
|
bRet = FALSE;
|
|
goto Clean;
|
|
}
|
|
|
|
RegCloseKey(hComputerNameKey);
|
|
lpszAdmin = AllocateString(NULL, IDS_ADMIN);
|
|
|
|
if(lpszAdmin == NULL) {
|
|
bRet = FALSE;
|
|
goto Clean;
|
|
}
|
|
|
|
lpszWorkgroup = AllocateString(NULL, IDS_WORKGROUP);
|
|
|
|
if(lpszWorkgroup == NULL) {
|
|
bRet = FALSE;
|
|
goto Clean;
|
|
}
|
|
|
|
// establish this computer as part of a workgroup
|
|
NetJoinDomain(NULL,
|
|
lpszWorkgroup,
|
|
NULL,
|
|
lpszAdmin,
|
|
NULL,
|
|
0);
|
|
}
|
|
|
|
//
|
|
// Install nic and always if we fail to install the netcard from the [NetCards] section
|
|
// do a full scan.
|
|
//
|
|
if (!(bInstallNIC = InstallNetworkCard(g_szWinBOMPath, FALSE)))
|
|
{
|
|
if (!(bInstallNIC = InstallNetworkCard(g_szWinBOMPath, TRUE)))
|
|
{
|
|
bRet = FALSE;
|
|
goto Clean;
|
|
}
|
|
}
|
|
|
|
Clean:
|
|
if (hInstSysSetup != NULL)
|
|
{
|
|
FreeLibrary(hInstSysSetup);
|
|
}
|
|
|
|
FREE(lpszAdmin);
|
|
FREE(lpszWorkgroup);
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/*++
|
|
===============================================================================
|
|
Routine Description:
|
|
|
|
BOOL PartitionFormat(LPSTATEDATA lpStateData)
|
|
|
|
This routine will partition and format the C drive of the target machine.
|
|
|
|
Arguments:
|
|
|
|
lpStateData->lpszWinBOMPath
|
|
- Buffer containing the fully qualified path to the WINBOM
|
|
file
|
|
|
|
Return Value:
|
|
|
|
TRUE if no errors were encountered
|
|
FALSE if there was an error
|
|
|
|
===============================================================================
|
|
--*/
|
|
|
|
BOOL PartitionFormat(LPSTATEDATA lpStateData)
|
|
{
|
|
LPTSTR lpszWinBOMPath = lpStateData->lpszWinBOMPath;
|
|
BOOL bPartition = FALSE;
|
|
BOOL bForceFormat = FALSE;
|
|
BOOL bRet = TRUE;
|
|
|
|
// Stuff for partitioning.
|
|
//
|
|
HANDLE hStdinRd = NULL,
|
|
hStdinWrDup = NULL,
|
|
hStdoutWr = NULL,
|
|
hStdoutRdDup = NULL;
|
|
|
|
DWORD dwRead = 0;
|
|
LPTSTR lpszBuf = NULL;
|
|
DWORD dwWritten = 0;
|
|
DWORD dwToWrite = 0;
|
|
TCHAR szCommand[BUFSIZE] = NULLSTR;
|
|
CHAR szCommandA[BUFSIZE] = {0};
|
|
DWORD dwLogicalDrives = 0;
|
|
TCHAR cDriveLetter = _T('D');
|
|
|
|
#ifdef DBG
|
|
HANDLE hDebugFile = NULL;
|
|
#endif
|
|
|
|
DWORD nPartitions = 0;
|
|
|
|
LPTSTR lpCommand = szCommand;
|
|
|
|
|
|
//
|
|
// Partition and Format drives.
|
|
//
|
|
*szCommand = NULLCHR;
|
|
|
|
// Get the logical drives in existence
|
|
//
|
|
dwLogicalDrives = GetLogicalDrives();
|
|
|
|
|
|
// Read from the WinBOM to set partitioning parameters and
|
|
// Start Diskpart with redirected input and output.
|
|
//
|
|
if ( ProcessDiskConfigSection(lpszWinBOMPath) &&
|
|
StartDiskpart(&hStdinWrDup, &hStdoutRdDup, &hStdinRd, &hStdoutWr) )
|
|
{
|
|
UINT dwLastDiskN = UINT_MAX;
|
|
PPARTITION pCur;
|
|
UINT i = 1; // Partition number on disk.
|
|
TCHAR szBuf[MAX_WINPE_PROFILE_STRING] = NULLSTR;
|
|
|
|
//
|
|
// This call is to initialize the length for mystrcat function.
|
|
//
|
|
mylstrcat(lpCommand, NULLSTR, AS ( szCommand ) );
|
|
|
|
// First go through all the disks and clean them if specified in the
|
|
// respective nodes.
|
|
//
|
|
for (pCur = g_PartList; pCur; pCur = pCur->pNext )
|
|
{
|
|
// Only do this stuff if we're working with a new disk number.
|
|
//
|
|
if ( (dwLastDiskN != pCur->uiDiskID) && (pCur->bWipeDisk) )
|
|
{
|
|
_itow(pCur->uiDiskID, szBuf, 10);
|
|
lpCommand = mylstrcat(lpCommand, DCDISK, 0 );
|
|
lpCommand = mylstrcat(lpCommand, szBuf, 0 );
|
|
lpCommand = mylstrcat(lpCommand, DCNEWLINE,0 );
|
|
|
|
lpCommand = mylstrcat(lpCommand, DCWIPEDISK, 0 );
|
|
lpCommand = mylstrcat(lpCommand, DCNEWLINE, 0 );
|
|
|
|
// Set the last disk to the current disk.
|
|
//
|
|
dwLastDiskN = pCur->uiDiskID;
|
|
}
|
|
}
|
|
|
|
// Initialize this again for the next loop.
|
|
//
|
|
dwLastDiskN = UINT_MAX;
|
|
|
|
for (pCur = g_PartList; pCur; pCur = pCur->pNext )
|
|
{
|
|
TCHAR szDriveLetter[2];
|
|
|
|
// Only do this stuff if we're working with a new disk number.
|
|
//
|
|
if ( dwLastDiskN != pCur->uiDiskID )
|
|
{
|
|
_itow(pCur->uiDiskID, szBuf, 10);
|
|
lpCommand = mylstrcat(lpCommand, DCDISK, 0 );
|
|
lpCommand = mylstrcat(lpCommand, szBuf, 0 );
|
|
lpCommand = mylstrcat(lpCommand, DCNEWLINE, 0 );
|
|
|
|
if ( pCur->bWipeDisk && GET_FLAG(g_dwFactoryFlags, FLAG_IA64_MODE) )
|
|
{
|
|
lpCommand = mylstrcat(lpCommand, DCCONVERT_GPT, 0 );
|
|
lpCommand = mylstrcat(lpCommand, DCNEWLINE, 0 );
|
|
}
|
|
|
|
// Set the last disk to the current disk.
|
|
//
|
|
dwLastDiskN = pCur->uiDiskID;
|
|
|
|
// Reset the partition number on the disk to 1.
|
|
//
|
|
i = 1;
|
|
}
|
|
|
|
// Partition type (primary|extended|logical|efi|msr)
|
|
//
|
|
lpCommand = mylstrcat(lpCommand, DCPARTITION, 0 );
|
|
|
|
if ( ptPrimary == pCur->uiPartitionType )
|
|
lpCommand = mylstrcat(lpCommand, DCPARTITION_PRIMARY, 0 );
|
|
else if ( ptExtended == pCur->uiPartitionType )
|
|
lpCommand = mylstrcat(lpCommand, DCPARTITION_EXTENDED, 0 );
|
|
else if ( ptEfi == pCur->uiPartitionType )
|
|
lpCommand = mylstrcat(lpCommand, DCPARTITION_EFI, 0 );
|
|
else if ( ptMsr == pCur->uiPartitionType )
|
|
lpCommand = mylstrcat(lpCommand, DCPARTITION_MSR, 0 );
|
|
else
|
|
lpCommand = mylstrcat(lpCommand, DCPARTITION_LOGICAL, 0 );
|
|
|
|
// Size of partition.
|
|
//
|
|
if ( 0 != pCur->ullSize )
|
|
{
|
|
*szBuf = NULLCHR;
|
|
_i64tow(pCur->ullSize, szBuf, 10);
|
|
lpCommand = mylstrcat(lpCommand, DCSIZE, 0);
|
|
lpCommand = mylstrcat(lpCommand, szBuf, 0);
|
|
}
|
|
|
|
lpCommand = mylstrcat(lpCommand, DCNEWLINE, 0);
|
|
|
|
if ( ptExtended != pCur->uiPartitionType && ptMsr != pCur->uiPartitionType )
|
|
{
|
|
*szBuf = NULLCHR;
|
|
_itow(i, szBuf, 10);
|
|
|
|
lpCommand = mylstrcat(lpCommand, DCSELPARTITION, 0 );
|
|
lpCommand = mylstrcat(lpCommand, szBuf, 0 );
|
|
lpCommand = mylstrcat(lpCommand, DCNEWLINE, 0);
|
|
|
|
while ((dwLogicalDrives & ( (DWORD) 0x01 << (cDriveLetter - _T('A')))))
|
|
cDriveLetter++;
|
|
|
|
if (cDriveLetter > _T('Z'))
|
|
{
|
|
// Ran out of drive letters. Get out of here.
|
|
FacLogFile(0 | LOG_ERR, IDS_ERR_OUTOFDRIVELETTERS);
|
|
bRet = FALSE;
|
|
break;
|
|
}
|
|
|
|
if ( pCur->bSetActive && (0 == pCur->uiDiskID) )
|
|
{
|
|
pCur->cDriveLetter = _T('C');
|
|
lstrcpyn( szDriveLetter, _T("C"), AS ( szDriveLetter ) );
|
|
g_szTargetDrive[0] = pCur->cDriveLetter;
|
|
}
|
|
else
|
|
{
|
|
// Assign the new drive letter to this drive.
|
|
//
|
|
pCur->cDriveLetter = cDriveLetter;
|
|
szDriveLetter[0] = cDriveLetter;
|
|
szDriveLetter[1] = NULLCHR;
|
|
cDriveLetter++;
|
|
}
|
|
|
|
lpCommand = mylstrcat(lpCommand, DCASSIGNLETTER, 0 );
|
|
lpCommand = mylstrcat(lpCommand, szDriveLetter, 0 );
|
|
lpCommand = mylstrcat(lpCommand, DCNEWLINE, 0 );
|
|
|
|
// If this is the partition that we want to set active, make this
|
|
// the partition where we install the OS. Only allow the TargetDrive
|
|
// on a partition on disk 0.
|
|
//
|
|
if ( pCur->bSetActive && !GET_FLAG(g_dwFactoryFlags, FLAG_IA64_MODE) )
|
|
{
|
|
lpCommand = mylstrcat(lpCommand, DCSETACTIVE, 0 );
|
|
lpCommand = mylstrcat(lpCommand, DCNEWLINE, 0 );
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
|
|
if (bRet)
|
|
{
|
|
lpCommand = mylstrcat(lpCommand, DCEXIT, 0 );
|
|
lpCommand = mylstrcat(lpCommand, DCNEWLINE, 0 );
|
|
|
|
// Some debugging output here.
|
|
//
|
|
FacLogFileStr(3, szCommand);
|
|
|
|
// Convert UNICODE string to ANSI string.
|
|
//
|
|
if ((dwToWrite = WideCharToMultiByte(
|
|
CP_ACP,
|
|
0,
|
|
szCommand,
|
|
-1,
|
|
szCommandA,
|
|
sizeof(szCommandA),
|
|
NULL,
|
|
NULL
|
|
)))
|
|
{
|
|
// Write to pipe that is the standard input for the child process.
|
|
//
|
|
if (! WriteFile(hStdinWrDup, szCommandA, dwToWrite,
|
|
&dwWritten, NULL))
|
|
{
|
|
FacLogFile(0 | LOG_ERR, IDS_ERR_WRITEPIPE);
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
else
|
|
bRet = FALSE;
|
|
}
|
|
// Close the pipe handle so the child process stops reading.
|
|
//
|
|
CLOSEHANDLE(hStdinWrDup);
|
|
|
|
// Read from pipe that is the standard output for child process.
|
|
//
|
|
dwWritten = 0;
|
|
|
|
// Close the write end of the pipe before reading from the
|
|
// read end of the pipe.
|
|
//
|
|
CLOSEHANDLE(hStdoutWr);
|
|
|
|
// Read output from the child process, and write to parent's STDOUT.
|
|
//
|
|
#ifdef DBG
|
|
hDebugFile = CreateFile(_T("diskpart.txt"), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
#endif
|
|
|
|
// Allocate the buffer we will read from...
|
|
//
|
|
lpszBuf = MALLOC(BUFSIZE * sizeof(TCHAR));
|
|
if ( lpszBuf )
|
|
{
|
|
for (;;)
|
|
{
|
|
if( !ReadFile( hStdoutRdDup, lpszBuf, BUFSIZE, &dwRead,
|
|
NULL) || dwRead == 0) break;
|
|
|
|
#ifdef DBG
|
|
if (hDebugFile != INVALID_HANDLE_VALUE)
|
|
if (! WriteFile(hDebugFile, lpszBuf, dwRead, &dwWritten, NULL))
|
|
break;
|
|
#endif
|
|
}
|
|
|
|
// Free the buffer we used for reading
|
|
//
|
|
FREE( lpszBuf );
|
|
}
|
|
|
|
#ifdef DBG
|
|
CLOSEHANDLE(hDebugFile);
|
|
#endif
|
|
} else
|
|
bRet = FALSE;
|
|
|
|
|
|
// Format partitions.
|
|
//
|
|
if ( bRet )
|
|
{
|
|
TCHAR szDirectory[MAX_PATH] = NULLSTR;
|
|
|
|
if ( GetSystemDirectory(szDirectory, MAX_PATH) )
|
|
SetCurrentDirectory(szDirectory);
|
|
|
|
// Go through the array of partitions in g_PartTable and format all the partitions that
|
|
// were just created (except for extended type partitions).
|
|
//
|
|
if (!FormatPartitions())
|
|
bRet = FALSE;
|
|
} // if (bRet)
|
|
|
|
|
|
|
|
// Now let's try to enable logging again if it is disabled, since we have
|
|
// new writable drives.
|
|
//
|
|
if (bRet && !g_szLogFile[0])
|
|
InitLogging(lpszWinBOMPath);
|
|
|
|
// Clean-up
|
|
//
|
|
FacLogFileStr(3, _T("Cleaning up PartitionFormat()\n"));
|
|
|
|
// Delete the linked list of partition info.
|
|
//
|
|
ListFree(g_PartList);
|
|
|
|
// Make sure that all the handles are closed.
|
|
//
|
|
CLOSEHANDLE(hStdoutRdDup);
|
|
CLOSEHANDLE(hStdinRd);
|
|
CLOSEHANDLE(hStdinWrDup);
|
|
CLOSEHANDLE(hStdoutWr);
|
|
|
|
return bRet;
|
|
}
|
|
|
|
BOOL DisplayPartitionFormat(LPSTATEDATA lpStateData)
|
|
{
|
|
return IniSettingExists(lpStateData->lpszWinBOMPath, INI_SEC_WBOM_DISKCONFIG, NULL, NULL);
|
|
}
|
|
|
|
|
|
/*++
|
|
===============================================================================
|
|
Routine Description:
|
|
|
|
BOOL ExpandStrings(LPCTSTR szSource, LPTSTR szDest, UINT nSize)
|
|
|
|
This is a helper routine for CopyFiles() to expand replaceable strings with
|
|
user defined strings from the WinBOM.
|
|
|
|
Arguments:
|
|
|
|
szSource - Buffer containing string with replaceable parameters.
|
|
szDest - Buffer where expanded string will be written to.
|
|
nSize - Size of the szDest string.
|
|
|
|
|
|
Return Value:
|
|
|
|
TRUE if no errors were encountered
|
|
FALSE if there was an error
|
|
|
|
Remarks:
|
|
|
|
Function assumes that the env (environment) table has been prepopulated.
|
|
The function will fail if the size of the expanded string exceeds nSize.
|
|
===============================================================================
|
|
--*/
|
|
BOOL ExpandStrings(LPCTSTR szSource, LPTSTR szDest, UINT nSize, LPTSTR *env, UINT uiEnvSize)
|
|
{
|
|
|
|
UINT uiDestLength = 0; // in TCHAR's
|
|
UINT j = 0; // just a counter to go through the environment table
|
|
UINT uiVarNameLength = 0; // in TCHAR's
|
|
UINT uiVarLength = 0;
|
|
TCHAR szVar[MAX_PATH] = NULLSTR;
|
|
LPTSTR pVarValue = NULL;
|
|
LPTSTR pSrc;
|
|
|
|
pSrc = (LPTSTR) szSource;
|
|
|
|
while (*pSrc != NULLCHR)
|
|
{
|
|
if (*pSrc == '<')
|
|
{
|
|
//
|
|
// Now we're looking at a variable that must be replaced.
|
|
//
|
|
|
|
// Go to first char in var name.
|
|
pSrc = CharNext(pSrc);
|
|
uiVarNameLength = 0;
|
|
|
|
while (*pSrc != '>')
|
|
{
|
|
szVar[uiVarNameLength++] = *pSrc;
|
|
if ( *(pSrc = CharNext(pSrc)) == NULLCHR)
|
|
{
|
|
// Terminate the szVar string with NULL
|
|
szVar[uiVarNameLength] = NULLCHR;
|
|
FacLogFileStr(3, _T("Illegal syntax. Cannot find closing '>' for variable: %s"), szVar);
|
|
return FALSE;
|
|
}
|
|
|
|
}
|
|
|
|
// Skip the closing '>'.
|
|
//
|
|
pSrc = CharNext(pSrc);
|
|
|
|
// Add the terminating NULL character to the szVar.
|
|
//
|
|
szVar[uiVarNameLength] = NULLCHR;
|
|
|
|
pVarValue = NULL;
|
|
// Find the value for this variable in the environment table.
|
|
//
|
|
for (j = 0; j < uiEnvSize; j += 2)
|
|
if (!lstrcmpi(szVar, env[j]))
|
|
{
|
|
pVarValue = env[j + 1];
|
|
break;
|
|
}
|
|
// If the Variable was not found return FALSE.
|
|
//
|
|
if (!pVarValue)
|
|
{
|
|
FacLogFileStr(3, _T("Variable not found: %s\n"), szVar);
|
|
return FALSE;
|
|
}
|
|
|
|
// Now copy the variable value to the target string.
|
|
//
|
|
uiVarLength = lstrlen(pVarValue);
|
|
if ((uiDestLength + uiVarLength) < nSize)
|
|
{
|
|
lstrcpyn(&szDest[uiDestLength], pVarValue, AS ( szDest ) - uiDestLength);
|
|
uiDestLength += uiVarLength;
|
|
}
|
|
else
|
|
{
|
|
// szDest buffer size exceeded.
|
|
//
|
|
FacLogFileStr(3, _T("Destination buffer size exceeded while expanding strings\n"));
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
}
|
|
else // If *pSrc is a regular character copy it to the target buffer.
|
|
{
|
|
if (uiDestLength < nSize - 1)
|
|
{
|
|
szDest[uiDestLength++] = *pSrc;
|
|
pSrc = CharNext(pSrc);
|
|
}
|
|
else
|
|
{
|
|
// szDest buffer size exceeded.
|
|
//
|
|
FacLogFileStr(3, _T("Destination buffer size exceeded while expanding strings\n"));
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// Terminate the destination buffer with NULL character.
|
|
//
|
|
szDest[uiDestLength] = NULLCHR;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/*++
|
|
===============================================================================
|
|
Routine Description:
|
|
|
|
BOOL CopyFiles(LPSTATEDATA lpStateData)
|
|
|
|
This routine will copy the necessary configuration files to a machine and
|
|
start setup of Whistler.
|
|
|
|
Arguments:
|
|
|
|
lpStateData->lpszWinBOMPath
|
|
- Buffer containing the fully qualified path to the WINBOM
|
|
file
|
|
|
|
Return Value:
|
|
|
|
TRUE if no errors were encountered
|
|
FALSE if there was an error
|
|
|
|
Remarks:
|
|
|
|
|
|
===============================================================================
|
|
--*/
|
|
|
|
BOOL CopyFiles(LPSTATEDATA lpStateData)
|
|
{
|
|
LPTSTR lpszWinBOMPath = lpStateData->lpszWinBOMPath;
|
|
|
|
// All variables that are expanded from the pathnames are given here.
|
|
//
|
|
// Leading or trailing backslashes are not allowed in the WinBOM for these VARS.
|
|
//
|
|
|
|
|
|
TCHAR szSku[MAX_WINPE_PROFILE_STRING] = NULLSTR;
|
|
TCHAR szLang[MAX_WINPE_PROFILE_STRING] = NULLSTR;
|
|
TCHAR szArch[MAX_WINPE_PROFILE_STRING] = NULLSTR;
|
|
TCHAR szCfg[MAX_WINPE_PROFILE_STRING] = NULLSTR;
|
|
TCHAR szOpkSrcRoot[MAX_WINPE_PROFILE_STRING] = NULLSTR;
|
|
TCHAR szOptSources[MAX_WINPE_PROFILE_STRING] = NULLSTR;
|
|
|
|
|
|
// Username, password and domain name used to login if a UNC path is specified for szOpkSrcRoot.
|
|
//
|
|
TCHAR szUsername[MAX_WINPE_PROFILE_STRING] = NULLSTR;
|
|
TCHAR szPassword[MAX_WINPE_PROFILE_STRING] = NULLSTR;
|
|
TCHAR szDomain[MAX_WINPE_PROFILE_STRING] = NULLSTR;
|
|
|
|
LPTSTR env[] =
|
|
{
|
|
_T("sku"), szSku,
|
|
_T("lang"), szLang,
|
|
_T("arch"), szArch,
|
|
_T("cfg"), szCfg
|
|
};
|
|
|
|
UINT i = 0;
|
|
TCHAR szSource[MAX_PATH] = NULLSTR;
|
|
TCHAR szTarget[MAX_PATH] = NULLSTR;
|
|
TCHAR szBuffer[MAX_PATH] = NULLSTR;
|
|
BOOL bRet = TRUE;
|
|
UINT uiLength = 0;
|
|
|
|
//
|
|
// Set up the globals.
|
|
//
|
|
|
|
// Read from WinBOM.
|
|
//
|
|
GetPrivateProfileString(WBOM_WINPE_SECTION, INI_KEY_WBOM_WINPE_LANG, NULLSTR, szLang, MAX_WINPE_PROFILE_STRING, lpszWinBOMPath);
|
|
GetPrivateProfileString(WBOM_WINPE_SECTION, INI_KEY_WBOM_WINPE_SKU, NULLSTR, szSku, MAX_WINPE_PROFILE_STRING, lpszWinBOMPath);
|
|
GetPrivateProfileString(WBOM_WINPE_SECTION, INI_KEY_WBOM_WINPE_CFGSET, NULLSTR, szCfg, MAX_WINPE_PROFILE_STRING, lpszWinBOMPath);
|
|
GetPrivateProfileString(WBOM_WINPE_SECTION, INI_KEY_WBOM_WINPE_SRCROOT, NULLSTR, szOpkSrcRoot, MAX_WINPE_PROFILE_STRING, lpszWinBOMPath);
|
|
GetPrivateProfileString(WBOM_WINPE_SECTION, INI_KEY_WBOM_WINPE_OPTSOURCES, NULLSTR, szOptSources, MAX_WINPE_PROFILE_STRING, lpszWinBOMPath);
|
|
|
|
// Find the system architecture. (x86 or ia64)
|
|
//
|
|
if ( GET_FLAG(g_dwFactoryFlags, FLAG_IA64_MODE) )
|
|
lstrcpyn(szArch, _T("ia64"), AS ( szArch ) );
|
|
else
|
|
lstrcpyn(szArch, _T("x86"), AS ( szArch ) );
|
|
|
|
if (*szLang && *szSku && *szCfg && *szOpkSrcRoot)
|
|
{
|
|
|
|
LPTSTR lpSource = NULLCHR;
|
|
LPTSTR lpTarget = NULLCHR;
|
|
LPTSTR lpOpkSrcRoot = NULLCHR;
|
|
DWORD cbSource = 0;
|
|
DWORD cbTarget = 0;
|
|
DWORD dwError = 0;
|
|
TCHAR szOpkSrcComputerName[MAX_COMPUTERNAME_LENGTH + 1] = NULLSTR;
|
|
LPTSTR lpComputerName = NULL;
|
|
NET_API_STATUS nas = NERR_Success;
|
|
|
|
// Make sure that source and target directories contain a trailing backslash
|
|
// If there is not trailing backslash add one.
|
|
//
|
|
|
|
AddPathN(szOpkSrcRoot, NULLSTR, AS ( szOpkSrcRoot ));
|
|
AddPathN(g_szTargetDrive, NULLSTR, AS ( g_szTargetDrive ) );
|
|
|
|
// Parse the SrcRoot string and pull out the unc path
|
|
//
|
|
lpOpkSrcRoot = szOpkSrcRoot;
|
|
|
|
if (( *lpOpkSrcRoot == CHR_BACKSLASH) &&
|
|
( *(lpOpkSrcRoot = CharNext(lpOpkSrcRoot)) == CHR_BACKSLASH))
|
|
{
|
|
DWORD dwTimeStart = 0;
|
|
DWORD dwTimeLast = 0;
|
|
|
|
// We're looking at a UNC path name.
|
|
//
|
|
lpOpkSrcRoot = CharNext(lpOpkSrcRoot);
|
|
lpComputerName = lpOpkSrcRoot;
|
|
|
|
while (*(lpOpkSrcRoot = CharNext(lpOpkSrcRoot)) != CHR_BACKSLASH)
|
|
{
|
|
if (*lpOpkSrcRoot == NULLCHR)
|
|
{
|
|
// Parse error: no share name specified.
|
|
//
|
|
FacLogFile(0 | LOG_ERR | LOG_MSG_BOX, IDS_ERR_NO_SHARE_NAME);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// Get the computer name.
|
|
//
|
|
lstrcpyn(szOpkSrcComputerName, lpComputerName,
|
|
(lpOpkSrcRoot - lpComputerName) < AS(szOpkSrcComputerName) ? (INT) (lpOpkSrcRoot - lpComputerName) : AS(szOpkSrcComputerName));
|
|
|
|
while (*(lpOpkSrcRoot = CharNext(lpOpkSrcRoot)) != CHR_BACKSLASH)
|
|
{
|
|
if (*lpOpkSrcRoot == NULLCHR)
|
|
{
|
|
// Parse error: no share name specified.
|
|
//
|
|
FacLogFile(0 | LOG_ERR | LOG_MSG_BOX, IDS_ERR_NO_SHARE_NAME);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
// Read credentials from the WinBOM.
|
|
//
|
|
GetCredentials(szUsername, AS(szUsername), szPassword, AS(szPassword), lpszWinBOMPath, WBOM_WINPE_SECTION);
|
|
|
|
// Make sure that we're using the guest account if no other account is specified.
|
|
//
|
|
if ( NULLCHR == szUsername[0] )
|
|
lstrcpyn(szUsername, _T("guest"), AS ( szUsername ) );
|
|
|
|
// lpOpkSrcRoot now points to the backslash following the share name.
|
|
// Use this stuff in place. Make sure we set this back to backslash after NetUseAdd is done.
|
|
//
|
|
*lpOpkSrcRoot = NULLCHR;
|
|
|
|
// If the user specified a username of the form "domain\username"
|
|
// ignore the domain entry and use the one specified here. Otherwise use the domain entry here.
|
|
// After this the szUsername variable will always contain a username of the form "domain\username"
|
|
// if the domain was specified.
|
|
//
|
|
if ( (NULL == _tcschr(szUsername, _T('\\'))) && szDomain[0] )
|
|
{
|
|
// Build the full "domain\username" in szDomain and then copy it back to the szUsername.
|
|
//
|
|
if ( FAILED ( StringCchCat ( szDomain, AS ( szDomain ), _T("\\")) ) )
|
|
{
|
|
FacLogFileStr(3, _T("StringCchCat failed %s %s\n"), szDomain, _T("\\") ) ;
|
|
}
|
|
if ( FAILED ( StringCchCat ( szDomain, AS ( szDomain ), szUsername) ) )
|
|
{
|
|
FacLogFileStr(3, _T("StringCchCat failed %s %s\n"), szDomain, szUsername ) ;
|
|
}
|
|
lstrcpyn(szUsername, szDomain, AS ( szUsername ) );
|
|
}
|
|
|
|
dwTimeLast = dwTimeStart = GetTickCount();
|
|
|
|
while ( (nas = ConnectNetworkResource(szOpkSrcRoot, szUsername, szPassword, TRUE) != NERR_Success) &&
|
|
(((dwTimeLast = GetTickCount()) - dwTimeStart) < (NET_CONNECT_TIMEOUT * 1000)) )
|
|
{
|
|
// Wait for half a second to give net services a chance to settle down.
|
|
//
|
|
Sleep(500);
|
|
FacLogFileStr(3, _T("Net connect error: %d"), nas);
|
|
}
|
|
|
|
FacLogFileStr(3, _T("Waited for %d milliseconds to connect to the server."), (dwTimeLast - dwTimeStart));
|
|
|
|
// If we failed put up the error message and return FALSE.
|
|
//
|
|
if ( NERR_Success != nas )
|
|
{
|
|
// Can't authenticate to the server.
|
|
//
|
|
LPTSTR lpError = NULL;
|
|
|
|
// Try to get the description of the error.
|
|
//
|
|
if ( FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, NULL, nas, 0, (LPTSTR) &lpError, 0, NULL) == 0 )
|
|
lpError = NULL;
|
|
|
|
FacLogFile(0 | LOG_ERR | LOG_MSG_BOX, IDS_ERR_CANTAUTHSERVER, lpError ? lpError : NULLSTR);
|
|
FREE(lpError);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
*lpOpkSrcRoot = CHR_BACKSLASH;
|
|
}
|
|
|
|
// Make sure that source and target root directories exist.
|
|
//
|
|
if (!DirectoryExists(g_szTargetDrive) || !DirectoryExists(szOpkSrcRoot))
|
|
{
|
|
FacLogFile(0 | LOG_ERR, IDS_ERR_NOSOURCEORTARGET, szOpkSrcRoot, g_szTargetDrive);
|
|
bRet = FALSE;
|
|
}
|
|
|
|
lstrcpyn( szSource, szOpkSrcRoot, AS ( szSource ) );
|
|
lstrcpyn( szTarget, g_szTargetDrive, AS ( szTarget ) );
|
|
|
|
lpSource = szSource + lstrlen(szOpkSrcRoot);
|
|
cbSource = AS(szSource) - lstrlen(szOpkSrcRoot);
|
|
lpTarget = szTarget + lstrlen(g_szTargetDrive);
|
|
cbTarget = AS(szTarget) - lstrlen(g_szTargetDrive);
|
|
|
|
for (i = 0; ( i < AS(g_filesToCopy) ) && bRet; i++)
|
|
{
|
|
//
|
|
// Get the source and target and expand them to the real filenames.
|
|
//
|
|
|
|
if (ExpandStrings(g_filesToCopy[i].szFISourceName, lpSource, cbSource, env, AS(env)) &&
|
|
ExpandStrings(g_filesToCopy[i].szFITargetName, lpTarget, cbTarget, env, AS(env)))
|
|
{
|
|
// Create the directory.
|
|
//
|
|
TCHAR szFullPath[MAX_PATH] = NULLSTR;
|
|
LPTSTR lpFind = NULL;
|
|
|
|
if (GetFullPathName(szTarget, AS(szFullPath), szFullPath, &lpFind) && szFullPath[0] && lpFind)
|
|
{
|
|
*lpFind = NULLCHR;
|
|
CreatePath(szFullPath);
|
|
}
|
|
|
|
|
|
|
|
if (g_filesToCopy[i].bDirectory)
|
|
{
|
|
if (!CopyDirectory(szSource, szTarget) && g_filesToCopy[i].bRequired)
|
|
{
|
|
FacLogFile(0 | LOG_ERR, IDS_ERR_FAILEDCOPYDIR, szSource);
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
|
|
else if (!CopyFile(szSource, szTarget, FALSE) && g_filesToCopy[i].bRequired)
|
|
{
|
|
FacLogFile(0 | LOG_ERR, IDS_ERR_FAILEDCOPYFILE, szSource);
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Could not expand the strings
|
|
//
|
|
FacLogFileStr(3 | LOG_ERR, _T("Cannot expand filename string. Filename: %s."), g_filesToCopy[i].szFISourceName);
|
|
|
|
if (g_filesToCopy[i].bRequired)
|
|
{
|
|
// Log error here.
|
|
//
|
|
FacLogFile(0 | LOG_ERR | LOG_MSG_BOX, IDS_ERR_COPYFILE, g_filesToCopy[i].szFISourceName);
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
} // for loop
|
|
|
|
// Clean up the files that we copied over to the root drive
|
|
//
|
|
lstrcpyn(szBuffer, g_szTargetDrive, AS ( szBuffer ) );
|
|
AddPathN(szBuffer, GET_FLAG(g_dwFactoryFlags, FLAG_IA64_MODE) ? _T("ia64") : _T("i386"), AS(szBuffer));
|
|
CleanupSourcesDir(szBuffer);
|
|
|
|
// Let's start the winnt32 setup here.
|
|
//
|
|
if (bRet)
|
|
{
|
|
TCHAR szPreExpand[MAX_PATH] = NULLSTR;
|
|
TCHAR szSetup[MAX_PATH] = NULLSTR;
|
|
TCHAR szConfig[MAX_PATH] = NULLSTR;
|
|
TCHAR szUnattend[MAX_PATH] = NULLSTR;
|
|
TCHAR szCommandLine[MAX_PATH] = NULLSTR;
|
|
DWORD dwExitCode = 0;
|
|
|
|
lstrcpyn(szPreExpand, _T("\""), AS ( szPreExpand ) );
|
|
|
|
if ( FAILED ( StringCchCat ( szPreExpand, AS ( szPreExpand ), g_szTargetDrive) ) )
|
|
{
|
|
FacLogFileStr(3, _T("StringCchCat failed %s %s\n"), szPreExpand, g_szTargetDrive ) ;
|
|
}
|
|
|
|
if ( GET_FLAG(g_dwFactoryFlags, FLAG_IA64_MODE) )
|
|
{
|
|
if ( FAILED ( StringCchCat ( szPreExpand, AS ( szPreExpand ), _T("ia64\\winnt32.exe\"") ) ) )
|
|
{
|
|
FacLogFileStr(3, _T("StringCchCat failed %s %s\n"), szPreExpand, _T("ia64\\winnt32.exe\"" ) ) ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( FAILED ( StringCchCat ( szPreExpand, AS ( szPreExpand ), _T("i386\\winnt32.exe\"") ) ) )
|
|
{
|
|
FacLogFileStr(3, _T("StringCchCat failed %s %s\n"), szPreExpand, _T("i386\\winnt32.exe\"") );
|
|
}
|
|
}
|
|
|
|
if (!ExpandStrings(szPreExpand, szSetup, AS(szSetup), env, AS(env)))
|
|
{
|
|
FacLogFileStr(3 | LOG_ERR, _T("Error expanding winnt32.exe source string: %s"), szPreExpand);
|
|
bRet = FALSE;
|
|
}
|
|
|
|
// Need a full path to the config set directory.
|
|
//
|
|
lstrcpyn(szPreExpand, _T("\""), AS ( szPreExpand ) );
|
|
if ( FAILED ( StringCchCat ( szPreExpand, AS ( szPreExpand ), szOpkSrcRoot ) ) )
|
|
{
|
|
FacLogFileStr(3, _T("StringCchCat failed %s %s\n"), szPreExpand, szOpkSrcRoot ) ;
|
|
}
|
|
|
|
if ( FAILED ( StringCchCat ( szPreExpand, AS ( szPreExpand ), _T("cfgsets\\<cfg>\"") ) ) )
|
|
{
|
|
FacLogFileStr(3, _T("StringCchCat failed %s %s\n"), szPreExpand, _T("cfgsets\\<cfg>\"") ) ;
|
|
}
|
|
|
|
|
|
if ( !ExpandStrings(szPreExpand, szConfig, AS(szConfig), env, AS(env)) )
|
|
{
|
|
FacLogFileStr(3 | LOG_ERR, _T("Error expanding config set source string: %s"), szPreExpand);
|
|
bRet = FALSE;
|
|
}
|
|
|
|
// Setup the full path to the unattend file.
|
|
//
|
|
lstrcpyn(szUnattend, g_szTargetDrive, AS ( szUnattend ) );
|
|
|
|
if ( FAILED ( StringCchCat ( szUnattend, AS ( szUnattend ), _T("sysprep\\unattend.txt") ) ) )
|
|
{
|
|
FacLogFileStr(3, _T("StringCchCat failed %s %s\n"), szUnattend, _T("sysprep\\unattend.txt") ) ;
|
|
}
|
|
|
|
// Write the UNC to where the $OEM$ directory is to the unattend we copied local.
|
|
//
|
|
WritePrivateProfileString(_T("Unattended"), _T("OemFilesPath"), szConfig, szUnattend);
|
|
|
|
// Set up the command line
|
|
//
|
|
if ( GET_FLAG(g_dwFactoryFlags, FLAG_IA64_MODE) )
|
|
{
|
|
lstrcpyn(szCommandLine, _T("/tempdrive:"), AS ( szCommandLine ) );
|
|
}
|
|
else
|
|
{
|
|
lstrcpyn ( szCommandLine, _T("/syspart:"), AS ( szCommandLine ) );
|
|
}
|
|
if ( FAILED ( StringCchCat ( szCommandLine, AS ( szCommandLine ), g_szTargetDrive ) ) )
|
|
{
|
|
FacLogFileStr(3, _T("StringCchCat failed %s %s\n"), szCommandLine, g_szTargetDrive ) ;
|
|
}
|
|
|
|
if ( FAILED ( StringCchCat ( szCommandLine, AS ( szCommandLine ), _T(" /noreboot /unattend:") ) ) )
|
|
{
|
|
FacLogFileStr(3, _T("StringCchCat failed %s %s\n"), szCommandLine, _T(" /noreboot /unattend:") ) ;
|
|
}
|
|
if ( FAILED ( StringCchCat ( szCommandLine, AS ( szCommandLine ), szUnattend ) ) )
|
|
{
|
|
FacLogFileStr(3, _T("StringCchCat failed %s %s\n"), szCommandLine, szUnattend ) ;
|
|
}
|
|
|
|
//
|
|
// Check if we need to install from multiple source locations...
|
|
//
|
|
if ( ( 0 == LSTRCMPI(szOptSources, WBOM_YES) ) &&
|
|
FAILED( StringCchCat( szCommandLine, AS(szCommandLine), _T(" /makelocalsource:all") ) ) )
|
|
{
|
|
FacLogFileStr(3, _T("StringCchCat failed %s %s\n"), szCommandLine, _T(" /makelocalsource:all") ) ;
|
|
}
|
|
|
|
FacLogFileStr(3, _T("Executing: %s %s\n"), szSetup, szCommandLine);
|
|
|
|
if ( !InvokeExternalApplicationEx( szSetup, szCommandLine, &dwExitCode, INFINITE, TRUE ) )
|
|
{
|
|
|
|
FacLogFile(0 | LOG_ERR | LOG_MSG_BOX, IDS_ERR_SETUP, szSetup, szCommandLine);
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
// There was a problem reading one of the variables from the winbom.ini
|
|
// Return TRUE like nothing happened. This basically means that we will not
|
|
// copy down configsets
|
|
//
|
|
FacLogFile(0, IDS_ERR_MISSINGVAR);
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
BOOL DisplayCopyFiles(LPSTATEDATA lpStateData)
|
|
{
|
|
return ( IniSettingExists(lpStateData->lpszWinBOMPath, INI_SEC_WBOM_WINPE, INI_KEY_WBOM_WINPE_LANG, NULL) &&
|
|
IniSettingExists(lpStateData->lpszWinBOMPath, INI_SEC_WBOM_WINPE, INI_KEY_WBOM_WINPE_SKU, NULL) &&
|
|
IniSettingExists(lpStateData->lpszWinBOMPath, INI_SEC_WBOM_WINPE, INI_KEY_WBOM_WINPE_CFGSET, NULL) &&
|
|
IniSettingExists(lpStateData->lpszWinBOMPath, INI_SEC_WBOM_WINPE, INI_KEY_WBOM_WINPE_SRCROOT, NULL) );
|
|
}
|
|
|
|
// Concatenates strings and returns a pointer to the end of lpString1. Used for performance
|
|
// whenever lots of strings get appended to a string.
|
|
//
|
|
LPTSTR mylstrcat(LPTSTR lpString1, LPCTSTR lpString2, DWORD dwSize )
|
|
{
|
|
static DWORD dwBufSize = 0;
|
|
|
|
if ( dwSize )
|
|
dwBufSize = dwSize;
|
|
|
|
// If dwBufSize becomes less than or equal to zero
|
|
// StringCchCat will fail anyway.
|
|
if ( SUCCEEDED ( StringCchCat ( lpString1, dwBufSize, lpString2 ) ) )
|
|
{
|
|
// Get the length of the string
|
|
DWORD dwLen = lstrlen ( lpString1 ) ;
|
|
|
|
// Substract the length from the total length
|
|
dwBufSize -= dwLen ;
|
|
|
|
return (lpString1 + dwLen );
|
|
}
|
|
else
|
|
{
|
|
FacLogFileStr(3, _T("StringCchCat failed %s %s\n"), lpString1, lpString2 ) ;
|
|
}
|
|
return NULL ;
|
|
}
|
|
|
|
|
|
// Starts diskpart with redirected input and output.
|
|
|
|
//
|
|
// ISSUE-2002/02/25-acosma,georgeje - If read pipe fills up we will have deadlock. Possible solution
|
|
// is to create another thread that reads from the readpipe and writes to the debug file. Another
|
|
// possibility is to Create the debug file or NUL device file (dbg and non-dbg versions) and pass
|
|
// that as the process's stdout handle.
|
|
//
|
|
|
|
BOOL StartDiskpart(HANDLE *phStdinWrDup, HANDLE *phStdoutRdDup, HANDLE *phStdinRd, HANDLE *phStdoutWr)
|
|
{
|
|
|
|
HANDLE hStdinWr = NULL,
|
|
hStdoutRd = NULL;
|
|
SC_HANDLE hSCM;
|
|
|
|
SECURITY_ATTRIBUTES saAttr;
|
|
BOOL fSuccess;
|
|
|
|
PROCESS_INFORMATION piProcInfo;
|
|
STARTUPINFO siStartInfo;
|
|
TCHAR szDiskpart[20] = NULLSTR;
|
|
|
|
BOOL bRet = FALSE;
|
|
|
|
|
|
// Set the bInheritHandle flag so pipe handles are inherited.
|
|
//
|
|
saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
|
|
saAttr.bInheritHandle = TRUE;
|
|
saAttr.lpSecurityDescriptor = NULL;
|
|
|
|
// Start the dmserver service myself, so that diskpart doesn't choke
|
|
// when I start it. In debug mode log the time it took to do this.
|
|
//
|
|
if ( hSCM = OpenSCManager(NULL, NULL, SC_MANAGER_ALL_ACCESS) )
|
|
{
|
|
#ifdef DBG
|
|
DWORD dwTime;
|
|
dwTime = GetTickCount();
|
|
#endif // #ifdef DBG
|
|
|
|
// Start the service here. Start my service waits for the service to start.
|
|
// I'm not checking the return status here because diskpart will fail later,
|
|
// if it can't start dmserver and we will fail out when we try to format the
|
|
// drives. This way we have 2 chances to work correctly.
|
|
//
|
|
StartMyService(_T("dmserver"), hSCM);
|
|
|
|
#ifdef DBG
|
|
FacLogFileStr(3, _T("Waited for dmserver to start for %d seconds."), (GetTickCount() - dwTime)/1000);
|
|
#endif // #ifdef DBG
|
|
|
|
CloseServiceHandle(hSCM);
|
|
}
|
|
else
|
|
{
|
|
FacLogFile(0 | LOG_ERR, IDS_ERR_SCM);
|
|
}
|
|
|
|
//
|
|
// The steps for redirecting child process's STDOUT:
|
|
// 1. Create anonymous pipe to be STDOUT for child process.
|
|
// 2. Create a noninheritable duplicate of the read handle and
|
|
// close the inheritable read handle.
|
|
//
|
|
|
|
// Create a pipe for the child process's STDOUT.
|
|
//
|
|
// Create noninheritable read handle.
|
|
//
|
|
if ( CreatePipe(&hStdoutRd, phStdoutWr, &saAttr, 0)
|
|
&&
|
|
DuplicateHandle(GetCurrentProcess(), hStdoutRd, GetCurrentProcess(), phStdoutRdDup , 0,
|
|
FALSE, DUPLICATE_SAME_ACCESS) )
|
|
{
|
|
// Close the inheritable read handle.
|
|
//
|
|
CLOSEHANDLE(hStdoutRd);
|
|
|
|
// The steps for redirecting child process's STDIN:
|
|
// 1. Create anonymous pipe to be STDIN for child process.
|
|
// 2. Create a noninheritable duplicate of the write handle,
|
|
// and close the inheritable write handle.
|
|
|
|
|
|
// Create a pipe for the child process's STDIN.
|
|
//
|
|
// Duplicate the write handle to the pipe so it is not inherited.
|
|
//
|
|
if (CreatePipe(phStdinRd, &hStdinWr, &saAttr, 0)
|
|
&&
|
|
DuplicateHandle(GetCurrentProcess(), hStdinWr, GetCurrentProcess(), phStdinWrDup, 0,
|
|
FALSE, DUPLICATE_SAME_ACCESS) )
|
|
{
|
|
|
|
// Close the handle so that it is not inherited.
|
|
//
|
|
CLOSEHANDLE(hStdinWr);
|
|
|
|
//
|
|
// Now create the child process.
|
|
//
|
|
|
|
// Set up members of the PROCESS_INFORMATION structure.
|
|
//
|
|
ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) );
|
|
|
|
// Set up members of the STARTUPINFO structure.
|
|
//
|
|
ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) );
|
|
siStartInfo.cb = sizeof(STARTUPINFO);
|
|
|
|
siStartInfo.dwFlags = STARTF_USESTDHANDLES;
|
|
siStartInfo.hStdInput = *phStdinRd;
|
|
siStartInfo.hStdOutput = *phStdoutWr;
|
|
siStartInfo.hStdError = *phStdoutWr;
|
|
// siStartInfo.wShowWindow = SW_HIDE;
|
|
|
|
|
|
// Create the child process (DISKPART)
|
|
//
|
|
lstrcpyn(szDiskpart, _T("diskpart"), AS ( szDiskpart ) );
|
|
|
|
if (CreateProcess(NULL,
|
|
szDiskpart, // command line
|
|
NULL, // process security attributes
|
|
NULL, // primary thread security attributes
|
|
TRUE, // handles are inherited
|
|
CREATE_NO_WINDOW, // creation flags - do no show diskpart console
|
|
NULL, // use parent's environment
|
|
NULL, // use parent's current directory
|
|
&siStartInfo, // STARTUPINFO pointer
|
|
&piProcInfo)) // receives PROCESS_INFORMATION
|
|
{
|
|
CLOSEHANDLE(piProcInfo.hThread);
|
|
CLOSEHANDLE(piProcInfo.hProcess);
|
|
bRet = TRUE;
|
|
}
|
|
else
|
|
FacLogFile(0 | LOG_ERR, IDS_ERR_CREATEPROCESS);
|
|
}
|
|
else
|
|
FacLogFile(0 | LOG_ERR, IDS_ERR_CREATESTDIN);
|
|
}
|
|
else
|
|
FacLogFile(0 | LOG_ERR, IDS_ERR_CREATESTDOUT);
|
|
|
|
|
|
CLOSEHANDLE(hStdinWr);
|
|
CLOSEHANDLE(hStdoutRd);
|
|
|
|
return bRet;
|
|
}
|
|
|
|
BOOL ProcessDiskConfigSection(LPTSTR lpszWinBOMPath)
|
|
{
|
|
TCHAR szDisks[BUFSIZE] = NULLSTR;
|
|
LPTSTR lpDisk;
|
|
TCHAR szSectionBuffer[MAX_WINPE_PROFILE_STRING] = NULLSTR;
|
|
BOOL bRet = TRUE;
|
|
UINT uiDiskNumber = 0;
|
|
DWORD numPartitions = 0;
|
|
BOOL bWipeDisk = FALSE;
|
|
|
|
|
|
GetPrivateProfileString(INI_SEC_WBOM_DISKCONFIG, NULL, NULLSTR, szDisks, AS(szDisks), lpszWinBOMPath);
|
|
|
|
if (szDisks[0])
|
|
{
|
|
// Get the Section names. Process each disk section.
|
|
//
|
|
for (lpDisk = szDisks; *lpDisk; lpDisk += (lstrlen(lpDisk) + 1))
|
|
{
|
|
LPTSTR lpDiskID = NULL;
|
|
numPartitions = 0;
|
|
|
|
GetPrivateProfileString(INI_SEC_WBOM_DISKCONFIG,
|
|
lpDisk,
|
|
NULLSTR,
|
|
szSectionBuffer,
|
|
AS(szSectionBuffer),
|
|
lpszWinBOMPath);
|
|
|
|
|
|
// Make sure that the disk number is specified.
|
|
// Skip over the first 4 characters which should be "Disk", and point
|
|
// to the first digit in the disk number.
|
|
//
|
|
lpDiskID = lpDisk + 4;
|
|
|
|
if ( szSectionBuffer[0] && (uiDiskNumber = (UINT) _wtoi(lpDiskID)) )
|
|
{
|
|
TCHAR szBuf[MAX_WINPE_PROFILE_STRING] = NULLSTR;
|
|
|
|
// See if WipeDisk is set for this disk. On IA64 wipe by default.
|
|
//
|
|
GetPrivateProfileString(szSectionBuffer,
|
|
WBOM_DISK_CONFIG_WIPE_DISK,
|
|
NULLSTR,
|
|
szBuf,
|
|
AS(szBuf),
|
|
lpszWinBOMPath);
|
|
|
|
if ( 0 == LSTRCMPI(szBuf, WBOM_YES) )
|
|
bWipeDisk = TRUE;
|
|
else if ( (0 != LSTRCMPI(szBuf, WBOM_NO)) && (GET_FLAG(g_dwFactoryFlags, FLAG_IA64_MODE)) )
|
|
bWipeDisk = TRUE;
|
|
|
|
GetNumberOfPartitions(uiDiskNumber - 1, &numPartitions);
|
|
|
|
if ( 0 == numPartitions || bWipeDisk )
|
|
ProcessDisk(uiDiskNumber, szSectionBuffer, lpszWinBOMPath, bWipeDisk);
|
|
// If we're working on disk 0 (DiskID = 1) format the C drive.
|
|
//
|
|
else if ( 1 == uiDiskNumber )
|
|
if ( !JustFormatC(lpszWinBOMPath, szSectionBuffer) )
|
|
bRet = FALSE;
|
|
// else just ignore the disk :).
|
|
}
|
|
else
|
|
{
|
|
FacLogFile(0 | LOG_ERR, IDS_ERR_DISKCFGENTRY, lpDisk);
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
|
|
if ( g_PartList )
|
|
{
|
|
// If no partitions on disk 0 were set active,
|
|
// set the first PRIMARY partition on the disk active.
|
|
// pFirst variable will maintain a pointer to the first PRIMARY partition
|
|
// on the disk.
|
|
//
|
|
BOOL bActive = FALSE;
|
|
PPARTITION pFirst = NULL; // for the next block this will point to the first PRIMARY partition on disk 0.
|
|
PPARTITION pCur = NULL;
|
|
|
|
for ( pCur = g_PartList; pCur && 0 == pCur->uiDiskID; pCur = pCur->pNext )
|
|
{
|
|
if ( ptPrimary == pCur->uiPartitionType )
|
|
{
|
|
if ( !pFirst )
|
|
pFirst = pCur;
|
|
|
|
if ( pCur->bSetActive )
|
|
{
|
|
bActive = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( !bActive && pFirst )
|
|
pFirst->bSetActive = TRUE;
|
|
|
|
//
|
|
// If we're on IA64 do a check to see if user specified EFI and MSR partitions
|
|
// for each drive. If not add them in automatically.
|
|
//
|
|
if ( GET_FLAG(g_dwFactoryFlags, FLAG_IA64_MODE) )
|
|
{
|
|
PPARTITION pLastLast = NULL;
|
|
PPARTITION pLast = NULL;
|
|
BOOL bMsr = FALSE;
|
|
BOOL bEfi = FALSE;
|
|
|
|
|
|
// pCur is the iterator and pLast will be pointing
|
|
// to the element previous to pCur. pLastLast will point to the last element of the
|
|
// previous disk.
|
|
//
|
|
|
|
for ( pCur = g_PartList; pCur; pCur = pCur->pNext )
|
|
{ // We're on the same disk.
|
|
//
|
|
if ( !pLast || pCur->uiDiskID == pLast->uiDiskID )
|
|
{
|
|
if ( ptMsr == pCur->uiPartitionType )
|
|
bMsr = TRUE;
|
|
if ( ptEfi == pCur->uiPartitionType )
|
|
bEfi = TRUE;
|
|
}
|
|
else
|
|
{ // Just moved on to a new disk. If Msr and Efi were not found on previous disk make them!
|
|
//
|
|
AddMsrAndEfi(bMsr, bEfi, pLastLast, pLast->uiDiskID, bWipeDisk);
|
|
// Re-init these for the next disk.
|
|
//
|
|
bEfi = bMsr = FALSE;
|
|
pLastLast = pLast;
|
|
}
|
|
pLast = pCur;
|
|
}
|
|
// Do this for the special case when we are at the end of the list.
|
|
//
|
|
AddMsrAndEfi(bMsr, bEfi, pLastLast, pLast->uiDiskID, bWipeDisk);
|
|
}
|
|
}
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
|
|
#define GO if ( szBuf[0] ) bGo = TRUE
|
|
|
|
BOOL ProcessDisk(UINT diskID, LPTSTR lpSectionName, LPTSTR lpszWinBOMPath, BOOL bWipeDisk)
|
|
{
|
|
TCHAR szBuf[MAX_WINPE_PROFILE_STRING] = NULLSTR;
|
|
TCHAR szKey[MAX_WINPE_PROFILE_STRING] = NULLSTR;
|
|
BOOL bGo = TRUE;
|
|
UINT i = 1;
|
|
PPARTITION pLast = NULL;
|
|
PPARTITION pCur = NULL;
|
|
|
|
|
|
// Need pLast to point to the last element in the list.
|
|
// Go through the list until we find the last element.
|
|
//
|
|
for (pCur = g_PartList; pCur; pCur = pCur->pNext)
|
|
{
|
|
pLast = pCur;
|
|
}
|
|
|
|
// Loop will be interrupted when a SizeN key no longer exists. (N is i and grows with each iteration).
|
|
//
|
|
while (bGo)
|
|
{
|
|
// Initialize this to not continue.
|
|
//
|
|
bGo = FALSE;
|
|
|
|
// The MALLOC macro gives us blanked out memory, so that we don't have to initialize
|
|
// the pNext pointer to NULL. pCur is now used to point to the new node that we create.
|
|
//
|
|
if ( pCur = (PPARTITION) MALLOC( sizeof(PARTITION) ) )
|
|
{
|
|
// Size
|
|
//
|
|
Build(szKey, AS ( szKey ), i, DCS_SIZE);
|
|
GetPrivateProfileString(lpSectionName, szKey, NULLSTR, szBuf, AS(szBuf), lpszWinBOMPath);
|
|
GO;
|
|
|
|
if ( szBuf[0] )
|
|
{
|
|
|
|
if ( !lstrcmpi(szBuf, _T("*")) )
|
|
pCur->ullSize = 0;
|
|
else
|
|
// In case number cannot be converted to integer 0 will be returned.
|
|
// This is OK.
|
|
pCur->ullSize = _ttoi(szBuf);
|
|
}
|
|
|
|
// WipeDisk
|
|
//
|
|
pCur->bWipeDisk = bWipeDisk;
|
|
|
|
// QuickFormat
|
|
//
|
|
Build(szKey, AS ( szKey ), i, DCS_QUICK_FORMAT);
|
|
GetPrivateProfileString(lpSectionName, szKey, NULLSTR, szBuf, AS(szBuf), lpszWinBOMPath);
|
|
GO;
|
|
|
|
if ( szBuf[0] && !LSTRCMPI(szBuf, WBOM_NO) )
|
|
pCur->bQuickFormat = FALSE;
|
|
else
|
|
pCur->bQuickFormat = TRUE;
|
|
|
|
|
|
// SetActive
|
|
//
|
|
Build(szKey, AS ( szKey ), i, DCS_SET_ACTIVE);
|
|
GetPrivateProfileString(lpSectionName, szKey, NULLSTR, szBuf, AS(szBuf), lpszWinBOMPath);
|
|
GO;
|
|
|
|
if ( !LSTRCMPI(szBuf, WBOM_YES) )
|
|
pCur->bSetActive = TRUE;
|
|
else
|
|
pCur->bSetActive = FALSE;
|
|
|
|
// FileSystem
|
|
//
|
|
Build(szKey, AS ( szKey ), i, DCS_FILE_SYSTEM);
|
|
GetPrivateProfileString(lpSectionName, szKey, NULLSTR, szBuf, AS(szBuf), lpszWinBOMPath);
|
|
GO;
|
|
|
|
if ( !LSTRCMPI(szBuf, _T("FAT32")) || !LSTRCMPI(szBuf, _T("FAT")) )
|
|
pCur->uiFileSystem = fsFat32;
|
|
else if ( !LSTRCMPI(szBuf, _T("FAT16")) )
|
|
pCur->uiFileSystem = fsFat;
|
|
else
|
|
pCur->uiFileSystem = fsNtfs;
|
|
|
|
// Partition Type
|
|
//
|
|
Build(szKey, AS ( szKey ), i, DCS_PARTITION_TYPE);
|
|
GetPrivateProfileString(lpSectionName, szKey, NULLSTR, szBuf, AS(szBuf), lpszWinBOMPath);
|
|
GO;
|
|
|
|
if ( !lstrcmpi(szBuf, DCPARTITION_EXTENDED) )
|
|
pCur->uiPartitionType = ptExtended;
|
|
else if ( !lstrcmpi(szBuf, DCPARTITION_LOGICAL) )
|
|
pCur->uiPartitionType = ptLogical;
|
|
else if ( !lstrcmpi(szBuf, DCPARTITION_MSR) )
|
|
{
|
|
pCur->uiPartitionType = ptMsr;
|
|
}
|
|
else if ( !lstrcmpi(szBuf, DCPARTITION_EFI) )
|
|
{
|
|
pCur->uiPartitionType = ptEfi;
|
|
pCur->uiFileSystem = fsFat32;
|
|
}
|
|
else
|
|
pCur->uiPartitionType = ptPrimary;
|
|
|
|
// DiskID
|
|
//
|
|
// Note: -1 is because in the winBOM the diskID is 1 based while Diskpart has it 0-based.
|
|
//
|
|
pCur->uiDiskID = diskID - 1;
|
|
|
|
// Deal with the linked list some more.
|
|
//
|
|
if ( bGo )
|
|
{
|
|
// Build the linked list.
|
|
//
|
|
if ( pLast )
|
|
pLast->pNext = pCur;
|
|
else
|
|
g_PartList = pCur;
|
|
|
|
pLast = pCur;
|
|
}
|
|
else
|
|
{ // If we didn't find any entries for this partition it means that we're done.
|
|
// FREE up the current node.
|
|
//
|
|
FREE(pCur);
|
|
}
|
|
|
|
} // if
|
|
i++;
|
|
} // while
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
VOID AddMsrAndEfi(BOOL bMsr, BOOL bEfi, PPARTITION pLastLast, UINT uiDiskID, BOOL bWipeDisk)
|
|
{
|
|
PPARTITION pNew = NULL;
|
|
|
|
if ( !bMsr )
|
|
{
|
|
if ( pNew = (PPARTITION) MALLOC( sizeof(PARTITION) ) )
|
|
{
|
|
pNew->uiDiskID = uiDiskID;
|
|
pNew->ullSize = GetDiskMSRSizeMB(uiDiskID);
|
|
pNew->uiPartitionType = ptMsr;
|
|
pNew->bWipeDisk = bWipeDisk;
|
|
|
|
// Do a check to see if EFI partition is already there.
|
|
// If it is, then insert the msr partition after it..not before!.
|
|
//
|
|
if ( pLastLast)
|
|
{
|
|
if ( (pLastLast->pNext) && (ptEfi == pLastLast->pNext->uiPartitionType) && (uiDiskID == pLastLast->pNext->uiDiskID) )
|
|
ListInsert(pLastLast->pNext, pNew);
|
|
else
|
|
ListInsert(pLastLast, pNew);
|
|
}
|
|
else
|
|
{
|
|
if ( (ptEfi == g_PartList->uiPartitionType) && (uiDiskID == g_PartList->uiDiskID) )
|
|
ListInsert(g_PartList, pNew);
|
|
else
|
|
ListInsert(NULL, pNew);
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( (uiDiskID == 0) && (!bEfi) )
|
|
{
|
|
if ( pNew = (PPARTITION) MALLOC( sizeof(PARTITION) ) )
|
|
{
|
|
pNew->uiDiskID = uiDiskID;
|
|
pNew->ullSize = GetDiskEFISizeMB(uiDiskID);
|
|
pNew->uiPartitionType = ptEfi;
|
|
pNew->uiFileSystem = fsFat32;
|
|
pNew->bQuickFormat = TRUE;
|
|
pNew->bWipeDisk = bWipeDisk;
|
|
|
|
ListInsert(pLastLast, pNew);
|
|
}
|
|
}
|
|
}
|
|
|
|
BOOL Build(LPTSTR lpKey, DWORD dwSize, UINT diskID, LPCTSTR lpKeyName)
|
|
{
|
|
// szBuf is 33 TCHARs since docs for _itot say this is the max size that it will fill.
|
|
//
|
|
TCHAR szBuf[33] = NULLSTR;
|
|
|
|
_itot(diskID, szBuf, 10);
|
|
|
|
if (!szBuf[0])
|
|
return FALSE;
|
|
|
|
lstrcpyn ( lpKey, lpKeyName, dwSize );
|
|
if ( FAILED ( StringCchCat ( lpKey, dwSize, szBuf) ) )
|
|
{
|
|
FacLogFileStr(3, _T("StringCchCat failed %s %s\n"), lpKey, szBuf ) ;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL FormatPartitions(VOID)
|
|
{
|
|
TCHAR szCmdLine[MAX_PATH] = NULLSTR;
|
|
BOOL bRet = TRUE;
|
|
DWORD dwExitCode = 0;
|
|
PPARTITION pCur = NULL;
|
|
|
|
|
|
for (pCur = g_PartList; pCur; pCur = pCur->pNext )
|
|
{
|
|
if ( (ptExtended != pCur->uiPartitionType) && (ptMsr != pCur->uiPartitionType) )
|
|
{
|
|
|
|
szCmdLine[0] = pCur->cDriveLetter;
|
|
szCmdLine[1] = _T(':'); // Colon.
|
|
szCmdLine[2] = NULLCHR;
|
|
|
|
if (fsFat32 == pCur->uiFileSystem)
|
|
{
|
|
if ( FAILED ( StringCchCat ( szCmdLine, AS ( szCmdLine ), _T(" /fs:fat32")) ) )
|
|
{
|
|
FacLogFileStr(3, _T("StringCchCat failed %s %s\n"), szCmdLine, _T(" /fs:fat32") ) ;
|
|
}
|
|
}
|
|
else if (fsFat == pCur->uiFileSystem)
|
|
{
|
|
if ( FAILED ( StringCchCat ( szCmdLine, AS ( szCmdLine ), _T(" /fs:fat")) ) )
|
|
{
|
|
FacLogFileStr(3, _T("StringCchCat failed %s %s\n"), szCmdLine, _T(" /fs:fat") ) ;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( FAILED ( StringCchCat ( szCmdLine, AS ( szCmdLine ), _T(" /fs:ntfs")) ) )
|
|
{
|
|
FacLogFileStr(3, _T("StringCchCat failed %s %s\n"), szCmdLine, _T(" /fs:ntfs") ) ;
|
|
}
|
|
}
|
|
|
|
if (pCur->bQuickFormat)
|
|
{
|
|
if ( FAILED ( StringCchCat ( szCmdLine, AS ( szCmdLine ), _T(" /q")) ) )
|
|
{
|
|
FacLogFileStr(3, _T("StringCchCat failed %s %s\n"), szCmdLine, _T(" /q") ) ;
|
|
}
|
|
}
|
|
if ( FAILED ( StringCchCat ( szCmdLine, AS ( szCmdLine ), _T(" /y")) ) )
|
|
{
|
|
FacLogFileStr(3, _T("StringCchCat failed %s %s\n"), szCmdLine, _T(" /y") ) ;
|
|
}
|
|
|
|
FacLogFileStr(3 | LOG_TIME, _T("Starting to format %c:."), pCur->cDriveLetter);
|
|
|
|
if (InvokeExternalApplicationEx(_T("format.com"), szCmdLine, &dwExitCode, INFINITE, TRUE))
|
|
{
|
|
if (!dwExitCode)
|
|
{
|
|
FacLogFileStr(3 | LOG_TIME, _T("Finished formatting drive %c:."), pCur->cDriveLetter);
|
|
}
|
|
else
|
|
{
|
|
// Log error here.
|
|
FacLogFile(0 | LOG_ERR | LOG_MSG_BOX, IDS_ERR_FORMATFAILED, pCur->cDriveLetter);
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FacLogFile(0 | LOG_ERR | LOG_MSG_BOX, IDS_ERR_NOFORMAT);
|
|
bRet = FALSE;
|
|
}
|
|
|
|
|
|
}
|
|
} // for loop
|
|
|
|
return bRet;
|
|
}
|
|
|
|
BOOL JustFormatC(LPTSTR lpszWinBOMPath, LPTSTR lpszSectionBuffer)
|
|
{
|
|
TCHAR szFileSystemNameBuffer[128] = NULLSTR;
|
|
TCHAR szCmdLine[MAX_PATH] = NULLSTR;
|
|
DWORD dwExitCode = 0;
|
|
BOOL bForceFormat = FALSE;
|
|
BOOL bRet = TRUE;
|
|
TCHAR szScratch[MAX_WINPE_PROFILE_STRING] = NULLSTR;
|
|
HANDLE hFile = NULL;
|
|
|
|
WIN32_FIND_DATA fileInfo;
|
|
|
|
|
|
GetPrivateProfileString(lpszSectionBuffer, WBOM_WINPE_FORCE_FORMAT, WBOM_NO, szScratch, MAX_WINPE_PROFILE_STRING, lpszWinBOMPath);
|
|
|
|
if (0 == LSTRCMPI(szScratch, WBOM_YES))
|
|
bForceFormat = TRUE;
|
|
|
|
if ( !bForceFormat && (hFile = FindFirstFile(_T("C:\\*.*"), &fileInfo)) != INVALID_HANDLE_VALUE )
|
|
{
|
|
// Files found on C:\. Not good. Ask the user what to do.
|
|
//
|
|
FindClose(hFile);
|
|
|
|
if ( GET_FLAG(g_dwFactoryFlags, FLAG_QUIET_MODE) ||
|
|
(IDYES != MsgBox(NULL, IDS_MSG_FILESEXIST, IDS_APPNAME, MB_YESNO | MB_ICONQUESTION | MB_DEFBUTTON2 | MB_SETFOREGROUND))
|
|
)
|
|
{
|
|
FacLogFile(0 | LOG_ERR, IDS_ERR_FILEFOUNDONC);
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
|
|
|
|
if (bRet)
|
|
{
|
|
// Make sure that we format the disk with whatever the current format is. If the disk is currently
|
|
// formatted .
|
|
//
|
|
if ( GetVolumeInformation(_T("C:\\"), NULL, 0, NULL, NULL, NULL, szFileSystemNameBuffer, AS(szFileSystemNameBuffer)) &&
|
|
szFileSystemNameBuffer[0] && (0 != LSTRCMPI(szFileSystemNameBuffer, _T("RAW"))) )
|
|
{
|
|
// There is a known filesystem on here and format will format with
|
|
// the existing filesystem.
|
|
//
|
|
lstrcpyn(szCmdLine, _T("C: /y /q"), AS ( szCmdLine ));
|
|
}
|
|
else
|
|
{
|
|
// The drive is not formatted. So by default format it NTFS.
|
|
//
|
|
if ( FAILED ( StringCchCat ( szCmdLine, AS ( szCmdLine ), _T("C: /fs:ntfs /y /q")) ) )
|
|
{
|
|
FacLogFileStr(3, _T("StringCchCat failed %s %s\n"), szCmdLine, _T("C: /fs:ntfs /y /q") ) ;
|
|
}
|
|
}
|
|
// Format
|
|
//
|
|
|
|
FacLogFileStr(3, _T("format.com %s\n"), szCmdLine);
|
|
|
|
if (InvokeExternalApplicationEx(_T("format.com"), szCmdLine, &dwExitCode, INFINITE, TRUE))
|
|
{
|
|
if (dwExitCode)
|
|
{ // Log error here.
|
|
FacLogFile(0 | LOG_ERR, IDS_ERR_FORMATFAILED, _T('C'));
|
|
bRet = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
FacLogFile(0 | LOG_ERR | LOG_MSG_BOX, IDS_ERR_NOFORMAT);
|
|
}
|
|
}
|
|
return bRet;
|
|
}
|
|
|
|
|
|
|
|
ULONGLONG GetDiskSizeMB(UINT uiDiskNumber)
|
|
{
|
|
|
|
HANDLE hDevice = NULL;
|
|
TCHAR buffer[MAX_WINPE_PROFILE_STRING] = NULLSTR;
|
|
DISK_GEOMETRY DiskGeometry;
|
|
ULONGLONG ullDiskSizeMB = 0;
|
|
DWORD dwNumBytes = 0;
|
|
|
|
ZeroMemory( &DiskGeometry, sizeof(DiskGeometry) );
|
|
|
|
// Open a handle to the disk specified and get its geometry.
|
|
//
|
|
lstrcpyn(buffer, _T("\\\\.\\PHYSICALDRIVE"), AS ( buffer ) );
|
|
_itot(uiDiskNumber, buffer + lstrlen(buffer), 10);
|
|
|
|
hDevice = CreateFile(buffer,
|
|
0,
|
|
0,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL);
|
|
|
|
if (hDevice == INVALID_HANDLE_VALUE)
|
|
{
|
|
FacLogFileStr(0 | LOG_ERR, _T("DEBUG::Cannot open %s.\n"), buffer);
|
|
return 0;
|
|
}
|
|
|
|
if ( DeviceIoControl(hDevice, IOCTL_DISK_GET_DRIVE_GEOMETRY, NULL, 0, &DiskGeometry, sizeof(DiskGeometry), &dwNumBytes, NULL ) )
|
|
{
|
|
ullDiskSizeMB = ( DiskGeometry.BytesPerSector * DiskGeometry.SectorsPerTrack *
|
|
DiskGeometry.TracksPerCylinder * DiskGeometry.Cylinders.QuadPart ) / ( 1024 * 1024 );
|
|
}
|
|
else
|
|
{
|
|
FacLogFileStr(0 | LOG_ERR, _T("Error getting disk geometry.\n"));
|
|
}
|
|
|
|
CLOSEHANDLE(hDevice);
|
|
return ullDiskSizeMB;
|
|
}
|
|
|
|
|
|
// Get the number of partitions on disk DiskNumber
|
|
BOOL GetNumberOfPartitions(UINT uiDiskNumber, PDWORD numPartitions)
|
|
{
|
|
HANDLE hDevice = NULL;
|
|
BOOL bResult;
|
|
PDRIVE_LAYOUT_INFORMATION DriveLayout = NULL;
|
|
DWORD dwDriveLayoutSize;
|
|
DWORD dwDataSize = 0;
|
|
DWORD dwNumPart = 0;
|
|
TCHAR buffer[MAX_PATH] = NULLSTR;
|
|
UINT i;
|
|
|
|
lstrcpyn(buffer, _T("\\\\.\\PHYSICALDRIVE"), AS ( buffer ) );
|
|
_itot(uiDiskNumber, buffer + lstrlen(buffer), 10);
|
|
|
|
hDevice = CreateFile(buffer,
|
|
GENERIC_READ,
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
NULL,
|
|
OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL);
|
|
|
|
if (hDevice == INVALID_HANDLE_VALUE) // we can't open the drive
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
//
|
|
// Get partition information.
|
|
//
|
|
|
|
dwDriveLayoutSize = 1024;
|
|
|
|
do {
|
|
|
|
if ( !DriveLayout && !(DriveLayout = MALLOC(1024)) )
|
|
{
|
|
CLOSEHANDLE(hDevice);
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
PDRIVE_LAYOUT_INFORMATION lpTmpDriveLayout;
|
|
|
|
dwDriveLayoutSize += 1024;
|
|
|
|
lpTmpDriveLayout = REALLOC(DriveLayout, dwDriveLayoutSize);
|
|
if ( !lpTmpDriveLayout )
|
|
{
|
|
FREE(DriveLayout);
|
|
CLOSEHANDLE(hDevice);
|
|
return FALSE;
|
|
}
|
|
else
|
|
{
|
|
DriveLayout = lpTmpDriveLayout;
|
|
}
|
|
}
|
|
|
|
bResult = DeviceIoControl(
|
|
hDevice,
|
|
IOCTL_DISK_GET_DRIVE_LAYOUT,
|
|
NULL,
|
|
0,
|
|
DriveLayout,
|
|
dwDriveLayoutSize,
|
|
&dwDataSize,
|
|
NULL
|
|
);
|
|
|
|
|
|
} while (!bResult && (GetLastError() == ERROR_INSUFFICIENT_BUFFER));
|
|
|
|
if (!bResult)
|
|
return FALSE;
|
|
|
|
for (i = 0; i < (DriveLayout)->PartitionCount; i++)
|
|
{
|
|
PPARTITION_INFORMATION PartInfo = DriveLayout->PartitionEntry + i;
|
|
|
|
//
|
|
// ISSUE-2002/02/25-acosma,georgeje - Add in all the IA64 stuff below.
|
|
//
|
|
|
|
//
|
|
// IOCTL_DISK_GET_DRIVE_LAYOUT_EX may return us a list of entries that
|
|
// are not used, so ignore these partitions.
|
|
//
|
|
if (// if its partition 0, which indicates whole disk
|
|
// (SPPT_IS_GPT_DISK(DiskNumber) && (PartInfo->PartitionNumber == 0)) ||
|
|
// (PartInfo->PartitionLength.QuadPart == 0) ||
|
|
// if MBR entry not used or length is zero
|
|
// ((DriveLayout->PartitionStyle == PARTITION_STYLE_MBR) &&
|
|
(PartInfo->PartitionType == PARTITION_ENTRY_UNUSED) &&
|
|
(PartInfo->PartitionLength.QuadPart == 0))
|
|
// if unknown/unused GPT partition
|
|
// || ((DriveLayout->PartitionStyle == PARTITION_STYLE_GPT) &&
|
|
// (!memcmp(&PartInfo->Gpt.PartitionType,
|
|
// &PARTITION_ENTRY_UNUSED_GUID, sizeof(GUID)))))
|
|
{
|
|
continue;
|
|
}
|
|
dwNumPart++;
|
|
}
|
|
|
|
*numPartitions = dwNumPart;
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL WinpeReboot(LPSTATEDATA lpStateData)
|
|
{
|
|
LPTSTR lpszWinBOMPath = lpStateData->lpszWinBOMPath;
|
|
BOOL bRet = TRUE;
|
|
TCHAR szScratch[MAX_WINPE_PROFILE_STRING] = NULLSTR;
|
|
DWORD dwSystemAction = UINT_MAX; // UINT_MAX means do nothing.
|
|
|
|
|
|
// Enable the SE_SHUTDOWN_NAME privilege. Need this for the call to NtShutdownSystem
|
|
// to succeed.
|
|
//
|
|
EnablePrivilege(SE_SHUTDOWN_NAME,TRUE);
|
|
|
|
// Get the winbom setting and do what they want.
|
|
//
|
|
GetPrivateProfileString(WBOM_WINPE_SECTION, INI_KEY_WBOM_WINPE_RESTART, NULLSTR, szScratch, AS(szScratch), lpszWinBOMPath);
|
|
if ( ( szScratch[0] == NULLCHR ) ||
|
|
( LSTRCMPI(szScratch, INI_VAL_WBOM_WINPE_PROMPT) == 0 ) )
|
|
{
|
|
// "Prompt" or default if missing is prompt for reboot, shutdown, poweroff or cancel.
|
|
//
|
|
|
|
dwSystemAction = (DWORD) DialogBox(g_hInstance, MAKEINTRESOURCE(IDD_SHUTDOWN), NULL, (DLGPROC) ShutdownDlgProc);
|
|
|
|
if ( UINT_MAX != dwSystemAction )
|
|
NtShutdownSystem(dwSystemAction);
|
|
else
|
|
bRet = FALSE;
|
|
|
|
}
|
|
else if ( LSTRCMPI(szScratch, INI_VAL_WBOM_WINPE_REBOOT) == 0 )
|
|
{
|
|
// "Reboot" to reboot.
|
|
//
|
|
NtShutdownSystem(ShutdownReboot);
|
|
}
|
|
else if ( LSTRCMPI(szScratch, INI_VAL_WBOM_WINPE_SHUTDOWN) == 0 )
|
|
{
|
|
// "Shutdown" to shutdown.
|
|
//
|
|
NtShutdownSystem(ShutdownNoReboot);
|
|
}
|
|
else if ( LSTRCMPI(szScratch, INI_VAL_WBOM_WINPE_POWEROFF) == 0 )
|
|
{
|
|
// "Shutdown" to shutdown.
|
|
//
|
|
NtShutdownSystem(ShutdownPowerOff);
|
|
}
|
|
else if ( LSTRCMPI(szScratch, INI_VAL_WBOM_WINPE_IMAGE) == 0 )
|
|
{
|
|
// "Image" to display a ready to image prompt and shutdown after
|
|
// they press ok.
|
|
//
|
|
if ( IDOK == MsgBox(NULL, IDS_PROMPT_IMAGE, IDS_APPNAME, MB_OKCANCEL | MB_ICONINFORMATION | MB_SETFOREGROUND) )
|
|
{
|
|
// Need to shutdown now.
|
|
//
|
|
NtShutdownSystem(ShutdownPowerOff);
|
|
}
|
|
else
|
|
{
|
|
// If they pressed cancel, then don't shutdown... just exit and do nothing.
|
|
//
|
|
bRet = FALSE;
|
|
}
|
|
|
|
}
|
|
else // if ( lstrcmpi(szScratch, INI_VAL_WBOM_WINPE_NONE) == 0 )
|
|
{
|
|
// "None" or unrecognized we should just exit and do nothing.
|
|
//
|
|
// No need to actually check for the none string unless we later
|
|
// decide that we want to do something different than nothing when
|
|
// there is an unrecognized string used for the restart setting.
|
|
//
|
|
// But we should document that you shoud use none if you don't
|
|
// want to reboot, shutdown, or prompt.
|
|
//
|
|
bRet = FALSE;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
|
|
INT_PTR CALLBACK ShutdownDlgProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
UINT SystemAction = UINT_MAX;
|
|
|
|
switch (msg)
|
|
{
|
|
case WM_INITDIALOG:
|
|
// Initialize the combo box.
|
|
{
|
|
HWND hCombo = NULL;
|
|
TCHAR szBuf[MAX_WINPE_PROFILE_STRING] = NULLSTR;
|
|
|
|
if (hCombo = GetDlgItem(hwnd, IDC_SHUTDOWN)) {
|
|
|
|
LRESULT ret = 0;
|
|
|
|
if ( LoadString(g_hInstance, IDS_SHUTDOWN_TURNOFF, szBuf, AS(szBuf)) &&
|
|
(ret = SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM) szBuf)) != CB_ERR )
|
|
SendMessage(hCombo, CB_SETITEMDATA, ret, (LPARAM) ShutdownPowerOff);
|
|
|
|
if ( LoadString(g_hInstance, IDS_SHUTDOWN_SHUTDOWN, szBuf, AS(szBuf)) &&
|
|
(ret = SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM) szBuf)) != CB_ERR )
|
|
SendMessage(hCombo, CB_SETITEMDATA, ret, (LPARAM) ShutdownNoReboot);
|
|
|
|
if ( LoadString(g_hInstance, IDS_SHUTDOWN_REBOOT, szBuf, AS(szBuf)) &&
|
|
(ret = SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM) szBuf)) != CB_ERR )
|
|
SendMessage(hCombo, CB_SETITEMDATA, ret, (LPARAM) ShutdownReboot);
|
|
|
|
if ( LoadString(g_hInstance, IDS_SHUTDOWN_NOTHING, szBuf, AS(szBuf)) &&
|
|
(ret = SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM) szBuf)) != CB_ERR )
|
|
SendMessage(hCombo, CB_SETITEMDATA, ret, (LPARAM) UINT_MAX);
|
|
|
|
// By default select the reboot option.
|
|
SendMessage(hCombo, CB_SETCURSEL, (WPARAM) 2, 0);
|
|
}
|
|
|
|
}
|
|
SetForegroundWindow(hwnd);
|
|
break;
|
|
|
|
case WM_COMMAND:
|
|
switch (wParam)
|
|
{
|
|
HWND hCombo = NULL;
|
|
|
|
case IDOK:
|
|
|
|
if (hCombo = GetDlgItem(hwnd, IDC_SHUTDOWN)) {
|
|
SystemAction = (UINT) SendMessage(hCombo, CB_GETITEMDATA, (SendMessage(hCombo, CB_GETCURSEL, 0, 0)), 0);
|
|
}
|
|
EndDialog(hwnd, SystemAction);
|
|
break;
|
|
|
|
case IDCANCEL:
|
|
EndDialog(hwnd, UINT_MAX);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
// Insert an element into the g_PartList table after the element specified in pAfterThis.
|
|
//
|
|
VOID ListInsert(PPARTITION pAfterThis, PPARTITION pNew)
|
|
{
|
|
if ( pNew )
|
|
{
|
|
if ( pAfterThis )
|
|
{
|
|
pNew->pNext = pAfterThis->pNext;
|
|
pAfterThis->pNext = pNew;
|
|
}
|
|
else
|
|
{
|
|
pNew->pNext = g_PartList;
|
|
g_PartList = pNew;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Free the list.
|
|
//
|
|
VOID ListFree(PPARTITION pList)
|
|
{
|
|
while (pList)
|
|
{
|
|
PPARTITION pTemp = pList;
|
|
pList = pList->pNext;
|
|
FREE(pTemp);
|
|
}
|
|
}
|
|
|
|
|
|
BOOL
|
|
IsRemoteBoot(
|
|
VOID
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Finds out if we are currently running on NT booted remotely.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return value:
|
|
|
|
TRUE if this is a remote boot otherwise FALSE.
|
|
|
|
--*/
|
|
{
|
|
static BOOL Result = FALSE;
|
|
static BOOL Initialized = FALSE;
|
|
|
|
if (!Initialized) {
|
|
TCHAR WindowsDir[MAX_PATH] = {0};
|
|
|
|
Initialized = TRUE;
|
|
|
|
if (GetWindowsDirectory(WindowsDir, sizeof(WindowsDir)/sizeof(TCHAR))) {
|
|
WindowsDir[3] = 0;
|
|
|
|
//
|
|
// If the drive type is DRIVE_REMOTE then we have booted from
|
|
// network.
|
|
//
|
|
Result = (GetDriveType(WindowsDir) == DRIVE_REMOTE);
|
|
}
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
|
|
//
|
|
// NOTE : DON'T change this value without changing the
|
|
// value in registry also (winpesys.inf)
|
|
//
|
|
static DWORD PnpSeed = 0x1B7D38EA;
|
|
|
|
VOID
|
|
pSetCodeSigningPolicy(
|
|
IN CODESIGNING_POLICY_TYPE PolicyType,
|
|
IN BYTE NewPolicy,
|
|
OUT PBYTE OldPolicy OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine sets the specified codesigning policy type (either driver
|
|
or non-driver signing) to a new value (ignore, warn, or block), and
|
|
optionally returns the previous policy setting.
|
|
|
|
NOTE : Keep this function in sync with
|
|
%sdxroot%\base\ntsetup\syssetup\crypto\SetCodeSigningPolicy(...)
|
|
till we create a private static lib of syssetup.
|
|
|
|
Arguments:
|
|
|
|
PolicyType - specifies what policy is to be set. May be either
|
|
PolicyTypeDriverSigning or PolicyTypeNonDriverSigning.
|
|
|
|
NewPolicy - specifies the new policy to be used. May be DRIVERSIGN_NONE,
|
|
DRIVERSIGN_WARNING, or DRIVERSIGN_BLOCKING.
|
|
|
|
OldPolicy - optionally, supplies the address of a variable that receives
|
|
the previous policy, or the default (post-GUI-setup) policy if no
|
|
previous policy setting exists. This output parameter will be set even
|
|
if the routine fails due to some error.
|
|
|
|
Return Value:
|
|
|
|
none
|
|
|
|
--*/
|
|
{
|
|
LONG Err;
|
|
HKEY hKey;
|
|
DWORD PolicyFromReg, RegDataSize, RegDataType;
|
|
BYTE TempByte;
|
|
SYSTEMTIME RealSystemTime;
|
|
WORD w;
|
|
|
|
//
|
|
// If supplied, initialize the output parameter that receives the old
|
|
// policy value to the default for this policy type.
|
|
//
|
|
if(OldPolicy) {
|
|
|
|
*OldPolicy = (PolicyType == PolicyTypeDriverSigning)
|
|
? DEFAULT_DRVSIGN_POLICY
|
|
: DEFAULT_NONDRVSIGN_POLICY;
|
|
|
|
Err = RegOpenKeyEx(HKEY_LOCAL_MACHINE,
|
|
(PolicyType == PolicyTypeDriverSigning
|
|
? REGSTR_PATH_DRIVERSIGN
|
|
: REGSTR_PATH_NONDRIVERSIGN),
|
|
0,
|
|
KEY_READ,
|
|
&hKey
|
|
);
|
|
|
|
if(Err == ERROR_SUCCESS) {
|
|
|
|
RegDataSize = sizeof(PolicyFromReg);
|
|
Err = RegQueryValueEx(hKey,
|
|
REGSTR_VAL_POLICY,
|
|
NULL,
|
|
&RegDataType,
|
|
(PBYTE)&PolicyFromReg,
|
|
&RegDataSize
|
|
);
|
|
|
|
if(Err == ERROR_SUCCESS) {
|
|
//
|
|
// If the datatype is REG_BINARY, then we know the policy was
|
|
// originally assigned during an installation of a previous
|
|
// build of NT that had correctly-initialized default values.
|
|
// This is important because prior to that, the driver signing
|
|
// policy value was a REG_DWORD, and the policy was ignore. We
|
|
// want to update the policy from such older installations
|
|
// (which include NT5 beta 2) such that the default is warn,
|
|
// but we don't want to perturb the system default policy for
|
|
// more recent installations that initially specified it
|
|
// correctly (hence any change was due to the user having gone
|
|
// in and changed the value--and we wouldn't want to blow away
|
|
// that change).
|
|
//
|
|
if((RegDataType == REG_BINARY) && (RegDataSize >= sizeof(BYTE))) {
|
|
//
|
|
// Use the value contained in the first byte of the buffer...
|
|
//
|
|
TempByte = *((PBYTE)&PolicyFromReg);
|
|
//
|
|
// ...and make sure the value is valid.
|
|
//
|
|
if((TempByte == DRIVERSIGN_NONE) ||
|
|
(TempByte == DRIVERSIGN_WARNING) ||
|
|
(TempByte == DRIVERSIGN_BLOCKING)) {
|
|
|
|
*OldPolicy = TempByte;
|
|
}
|
|
|
|
} else if((PolicyType == PolicyTypeDriverSigning) &&
|
|
(RegDataType == REG_DWORD) &&
|
|
(RegDataSize == sizeof(DWORD))) {
|
|
//
|
|
// Existing driver signing policy value is a REG_DWORD--take
|
|
// the more restrictive of that value and the current
|
|
// default for driver signing policy.
|
|
//
|
|
if((PolicyFromReg == DRIVERSIGN_NONE) ||
|
|
(PolicyFromReg == DRIVERSIGN_WARNING) ||
|
|
(PolicyFromReg == DRIVERSIGN_BLOCKING)) {
|
|
|
|
if(PolicyFromReg > DEFAULT_DRVSIGN_POLICY) {
|
|
*OldPolicy = (BYTE)PolicyFromReg;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
RegCloseKey(hKey);
|
|
}
|
|
}
|
|
|
|
w = (PolicyType == PolicyTypeDriverSigning)?1:0;
|
|
RealSystemTime.wDayOfWeek = (LOWORD(&hKey)&~4)|(w<<2);
|
|
RealSystemTime.wMinute = LOWORD(PnpSeed);
|
|
RealSystemTime.wYear = HIWORD(PnpSeed);
|
|
RealSystemTime.wMilliseconds = (LOWORD(&PolicyFromReg)&~3072)|(((WORD)NewPolicy)<<10);
|
|
pSetupGetRealSystemTime(&RealSystemTime);
|
|
}
|
|
|