able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/ntsetup/opktools/setupmgr/supplib/pathsup.c

1040 lines
25 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//----------------------------------------------------------------------------
//
// Copyright (c) 1997-1999 Microsoft Corporation
// All rights reserved.
//
// File Name:
// pathsup.c
//
// Description:
// Some path support routines.
//
//----------------------------------------------------------------------------
#include "pch.h"
static TCHAR g_szSetupMgrFileExtensions[MAX_PATH + 1] = _T("");
//---------------------------------------------------------------------------
//
// Function: CleanTrailingSlashes
//
// Purpose: Cleans up trailing slashes off pathnames. This is a support
// routine for ConcatenatePaths().
//
// Arguments:
// LPTSTR lpBuffer - MAX_PATH buffer
//
// Returns: VOID
//
//---------------------------------------------------------------------------
static VOID CleanTrailingSlashes(LPTSTR lpBuffer)
{
TCHAR *p = lpBuffer + lstrlen(lpBuffer) - 1;
while ( p >= lpBuffer && *p == _T('\\') )
*p-- = _T('\0');
}
//---------------------------------------------------------------------------
//
// Function: CleanLeadingSlashes
//
// Purpose: Removes leading slashes from the given string.
//
// Arguments:
// LPTSTR lpStr - str to clean
//
// Returns:
// A pointer to the character after the run of back-slashes.
//
//---------------------------------------------------------------------------
static LPTSTR CleanLeadingSlashes(LPTSTR lpStr)
{
TCHAR *p=lpStr;
while ( *p && *p == TEXT('\\') )
p++;
return p;
}
//---------------------------------------------------------------------------
//
// Function: ConcatenatePaths
//
// Purpose: This function cats path components together. It makes sure
// that there are not multiple slashes separating each item, and
// that there isn't a trailing back-slash.
//
// The last string passed must be NULL.
//
// Arguments:
// LPTSTR lpBuffer - MAX_PATH buffer
// ...
//
// Returns:
// TRUE if all is ok
// FALSE if resultant string is >= MAX_PATH chars
//
//---------------------------------------------------------------------------
BOOL __cdecl ConcatenatePaths(LPTSTR lpBuffer, ...)
{
LPTSTR lpString;
va_list arglist;
HRESULT hrCat;
va_start(arglist, lpBuffer);
lpString = va_arg(arglist, LPTSTR);
while ( lpString != NULL ) {
if ( lstrlen(lpBuffer) + lstrlen(lpString) >= MAX_PATH )
return FALSE;
lpString = CleanLeadingSlashes(lpString);
CleanTrailingSlashes(lpString);
CleanTrailingSlashes(lpBuffer);
if ( lpBuffer[0] ) {
hrCat=StringCchCat(lpBuffer, MAX_PATH, _T("\\"));
hrCat=StringCchCat(lpBuffer, MAX_PATH, lpString);
} else {
lstrcpyn(lpBuffer, lpString, MAX_PATH);
}
lpString = va_arg(arglist, LPTSTR);
}
va_end(arglist);
return TRUE;
}
//---------------------------------------------------------------------------
//
// Function: ParseDriveLetterOrUnc
//
// Purpose: Will parse past the \\srv\share\ or D:\ and return a pointer
// to the character after that mess.
//
// Returns: Pointer to the pathname 1 char past the volume descriptor,
// NULL if errors. GetLastError() will be valid when NULL
// is returned.
//
// Notes:
// - Only pass in fully qualified pathnames. Use MyGetFullPath().
//
//---------------------------------------------------------------------------
LPTSTR ParseDriveLetterOrUnc(LPTSTR lpFileName)
{
TCHAR *p=NULL;
//
// If path is of form \\srv\share\, get a pointer past the whole mess.
//
// Note we start at lpFileName+3 because "srv" (in this example) must
// be at least 1 character.
//
if ( lpFileName[0] == _T('\\') && lpFileName[1] == _T('\\') ) {
//
// Move past the computer name
//
p = lpFileName + 2;
while( *p != _T('\\') )
{
if( *p == _T('\0') )
{
SetLastError( ERROR_BAD_PATHNAME );
return( NULL );
}
p++;
}
p++;
//
// Scan past the share name
//
while( *p != _T('\\') )
{
if( *p == _T('\0') )
{
SetLastError( ERROR_BAD_PATHNAME );
return( NULL );
}
p++;
}
p++;
}
//
// Get past the D:\ if path is of that form
//
if ( towupper(lpFileName[0]) >= _T('A') &&
towupper(lpFileName[0]) <= _T('Z') &&
lpFileName[1] == _T(':') &&
lpFileName[2] == _T('\\') ) {
p = lpFileName + 3;
}
//
// If we never set *p, then the path is not in a valid form.
//
if ( p == NULL ) {
SetLastError(ERROR_BAD_PATHNAME);
return NULL;
}
return p;
}
//---------------------------------------------------------------------------
//
// Function: GetComputerNameFromUnc
//
// Purpose: To strip out the computer name from a full UNC path.
//
// Example: \\computername\sharename\dir1\dir2 would return
// \\computername
//
// Arguments:
//
// szComputerName is assumed to be MAX_PATH length
//
// Returns: VOID
//
// Notes:
// - Only pass in fully qualified pathnames. Use MyGetFullPath().
//
//---------------------------------------------------------------------------
VOID
GetComputerNameFromUnc( IN TCHAR *szFullUncPath,
OUT TCHAR *szComputerName,
IN DWORD cbSize) {
TCHAR *pString;
AssertMsg( szFullUncPath[0] == _T('\\') && szFullUncPath[1] == _T('\\'),
"szFullUncPath is not a well formed net path" );
lstrcpyn( szComputerName, szFullUncPath, cbSize );
pString = &(szComputerName[2]);
//
// Scan past the computer name
//
while( *pString != _T('\\') )
{
if( *pString == _T('\0') )
{
AssertMsg( FALSE,
"Bad UNC path");
return;
}
pString++;
}
*pString = _T('\0');
}
//---------------------------------------------------------------------------
//
// Function: GetComputerAndShareNameFromUnc
//
// Purpose: To strip out the computer and share name from a full UNC path.
//
// Example: \\computername\sharename\dir1\dir2 would return
// \\computername\sharename
//
// Arguments:
//
// szComputerAndShareName is assumed to be MAX_PATH length
//
// Returns: VOID
//
// Notes:
// - Only pass in fully qualified pathnames. Use MyGetFullPath().
//
//---------------------------------------------------------------------------
VOID
GetComputerAndShareNameFromUnc( IN TCHAR *szFullUncPath,
OUT TCHAR *szComputerAndShareName,
IN DWORD cbSize) {
TCHAR *pString;
AssertMsg( szFullUncPath[0] == _T('\\') && szFullUncPath[1] == _T('\\'),
"szFullUncPath is not a well formed net path");
lstrcpyn( szComputerAndShareName, szFullUncPath, cbSize );
pString = &(szComputerAndShareName[2]);
//
// Scan past the computer name
//
while( *pString != _T('\\') )
{
if( *pString == _T('\0') )
{
AssertMsg( FALSE,
"Bad UNC path");
return;
}
pString++;
}
pString++;
//
// Scan past the share name
//
while( *pString != _T('\\') )
{
if( *pString == _T('\0') )
{
//
// already just the computer and share name so just return
//
return;
}
pString++;
}
*pString = _T('\0');
}
//---------------------------------------------------------------------------
//
// Function: MyGetFullPath
//
// Purpose: Small wrapper on GetFullPathName(). It assumes the buffer
// is MAX_PATH.
//
// Returns:
// Pointer to filename part in the buffer, NULL if errors. The
// Win32 error code will be valid if fails.
//
// Notes:
// - This function should be called whenever obtaining a pathname
// from the user. Some of the other routines in this file
// require a fully qualified and cleaned up pathname (i.e. no
// trailing space and such).
//
//---------------------------------------------------------------------------
LPTSTR MyGetFullPath(LPTSTR lpFileName)
{
TCHAR Buffer[MAX_PATH], *lpFilePart;
lstrcpyn(Buffer, lpFileName, AS(Buffer));
if ( ! GetFullPathName(Buffer,
MAX_PATH,
lpFileName,
&lpFilePart) ) {
lpFilePart = NULL;
return NULL;
}
return lpFilePart;
}
//---------------------------------------------------------------------------
//
// Function: GetPathFromPathAndFilename
//
// Purpose: To obtain the just the path from a string that contains a path
// and a filename.
//
// Arguments: LPTSTR lpPathAndFileName - the full path and filename
// TCHAR *szPath - buffer the path is to be returned in, it is
// assumed to be of MAX_PATH length
//
// Returns:
// Inside szBuffer is just the path from the input of the path and file
// name
// BOOL - TRUE on success, FALSE on failure
//
//
// Examples:
// lpPathAndFileName szBuffer
//
// c:\foo\bar.exe returns c:\foo
// c:\bar.exe c:\
//
//---------------------------------------------------------------------------
BOOL
GetPathFromPathAndFilename( IN LPTSTR lpPathAndFileName, OUT TCHAR *szPath, IN DWORD cbSize )
{
INT iFileNameLength;
INT iPathLength;
INT iPathAndFileNameLength;
TCHAR Buffer[MAX_PATH];
TCHAR *lpFilePart;
lstrcpyn(Buffer, lpPathAndFileName, AS(Buffer));
if ( ! GetFullPathName(Buffer,
MAX_PATH,
lpPathAndFileName,
&lpFilePart) ) {
return( FALSE );
}
iFileNameLength = lstrlen( lpFilePart );
iPathAndFileNameLength = lstrlen( lpPathAndFileName );
lstrcpyn( szPath, lpPathAndFileName, cbSize );
szPath[iPathAndFileNameLength - iFileNameLength] = _T('\0');
//
// At this point szPath looks like either c:\foo\ or c:\
// So trim the last back slash unless at the root
//
iPathLength = lstrlen( szPath );
if( iPathLength > 3 )
{
szPath[iPathLength-1] = _T('\0');
}
return( TRUE );
}
//---------------------------------------------------------------------------
//
// Function: MyGetDiskFreeSpace
//
// Purpose: Gets the free space in bytes on the given drive and returns
// a LONGLONG (int64).
//
// The Win32 apis won't return an int64. Also, the Win32 apis
// require d:\. But this function will accept any fully
// qualified path.
//
// Arguments:
// LPTSTR - any fully qualified path
//
// Returns:
// LONGLONG - free space
//
//---------------------------------------------------------------------------
LONGLONG
MyGetDiskFreeSpace(LPTSTR Drive)
{
BOOL bRet;
DWORD nSectorsPerCluster,
nBytesPerSector,
nFreeClusters,
nTotalClusters;
TCHAR DriveBuffer[MAX_PATH];
LONGLONG FreeBytes;
HRESULT hrCat;
if( _istalpha( Drive[0] ) )
{
lstrcpyn(DriveBuffer, Drive, 4);
DriveBuffer[3] = _T('\0');
}
else if( Drive[0] == _T('\\') )
{
GetComputerNameFromUnc( Drive, DriveBuffer, AS(DriveBuffer) );
hrCat=StringCchCat( DriveBuffer, AS(DriveBuffer), _T("\\") );
hrCat=StringCchCat( DriveBuffer, AS(DriveBuffer), WizGlobals.DistShareName );
hrCat=StringCchCat( DriveBuffer, AS(DriveBuffer), _T("\\") );
}
else
{
AssertMsg(FALSE,
"MyGetDiskFreeSpace failed, programming error, bad Drive parameter");
}
bRet = GetDiskFreeSpace( DriveBuffer,
&nSectorsPerCluster,
&nBytesPerSector,
&nFreeClusters,
&nTotalClusters );
if( bRet == FALSE )
{
ReportErrorId( NULL,
MSGTYPE_ERR | MSGTYPE_WIN32,
IDS_ERR_UNABLE_TO_DETERMINE_FREE_SPACE,
DriveBuffer );
return( 0 );
}
FreeBytes = (LONGLONG) nFreeClusters *
(LONGLONG) nBytesPerSector *
(LONGLONG) nSectorsPerCluster;
return( FreeBytes );
}
//---------------------------------------------------------------------------
//
// Function: MySetupQuerySpaceRequiredOnDrive
//
// Purpose: Uses setupapi disk-space-list and returns the LONGLONG
// of how many bytes are needed.
//
// Arguments:
// LPTSTR - any fully qualified path
//
// Returns:
// LONGLONG - free space
//
//---------------------------------------------------------------------------
LONGLONG
MySetupQuerySpaceRequiredOnDrive(HDSKSPC hDiskSpace, LPTSTR Drive)
{
BOOL bRet;
LONGLONG llRequiredSpace;
TCHAR DriveBuffer[MAX_PATH];
if( _istalpha( Drive[0] ) )
{
lstrcpyn(DriveBuffer, Drive, 3);
DriveBuffer[2] = _T('\0');
}
else if( Drive[0] == _T('\\') )
{
GetComputerAndShareNameFromUnc( Drive, DriveBuffer, AS(DriveBuffer) );
}
else
{
AssertMsg(FALSE,
"SetupQuerySpaceRequiredOnDrive failed, programming error, bad Drive parameter");
}
bRet = SetupQuerySpaceRequiredOnDrive(
hDiskSpace,
DriveBuffer,
&llRequiredSpace,
NULL, 0);
AssertMsg(bRet,
"SetupQuerySpaceRequiredOnDrive failed, programming error");
return llRequiredSpace;
}
//---------------------------------------------------------------------------
//
// Function: IsPathOnLocalDiskDrive
//
// Purpose: Determines if the path is on a local disk drive or not.
//
// Arguments:
// LPTSTR lpPath - fully qualified path
//
// Returns: BOOL
//
//---------------------------------------------------------------------------
BOOL
IsPathOnLocalDiskDrive(LPCTSTR lpPath)
{
UINT nDriveType;
TCHAR szDrivePath[MAX_PATH + 1];
//
// Use GetDriveType to determine if the path is a local or a network path
//
lstrcpyn( szDrivePath, lpPath, AS(szDrivePath) );
if( szDrivePath[0] != _T('\\') )
{
//
// Truncate the path to the root dir
//
szDrivePath[3] = _T('\0');
}
nDriveType = GetDriveType( szDrivePath );
if( nDriveType == DRIVE_REMOTE )
{
return( FALSE );
}
else
{
return( TRUE );
}
}
//---------------------------------------------------------------------------
//
// Function: EnsureDirExists
//
// Purpose: Function that will iteratively create the given directory
// by creating each piece of the pathname if necessary.
//
// Arguments:
// LPTSTR lpDirName - dir name
//
// Returns: BOOL
//
// Notes:
// - This function requires a fully qualified pathname. Translate
// pathnames using MyGetFullPath() first.
//
// - The Win32 error code will be valid upon failure.
//
//---------------------------------------------------------------------------
BOOL EnsureDirExists(LPTSTR lpDirName)
{
BOOL bRestoreSlash;
DWORD dwAttribs;
TCHAR *p;
//
// Parse off the D:\ or \\srv\shr\. The lasterror will already
// be set by ParseDriveLetterOrUnc() if any errors occured.
//
if ( (p = ParseDriveLetterOrUnc(lpDirName)) == NULL )
return FALSE;
//
// Now parse off each piece of the pathname and make sure dir exists
//
while ( *p ) {
// find next \ or end // of pathname
while ( *p && *p != _T('\\') )
p++;
bRestoreSlash = FALSE;
if ( *p == _T('\\') ) {
*p = _T('\0');
bRestoreSlash = TRUE;
}
// see if a file with that name already exists
dwAttribs = GetFileAttributes(lpDirName);
if ( dwAttribs != (DWORD) -1 &&
!(dwAttribs & FILE_ATTRIBUTE_DIRECTORY) ) {
if ( bRestoreSlash )
*p = _T('\\');
SetLastError(ERROR_ALREADY_EXISTS);
return FALSE;
}
// create the dir and allow a failure if the dir already exists
if ( !CreateDirectory(lpDirName, NULL) &&
GetLastError() != ERROR_ALREADY_EXISTS ) {
if ( bRestoreSlash )
*p = _T('\\');
return FALSE;
}
if ( bRestoreSlash )
*p = _T('\\');
// advance to next piece of the pathname
p++;
}
return TRUE;
}
//---------------------------------------------------------------------------
//
// Function: DoesFolderExist
//
// Purpose: Checks if the given folder exists or not.
//
// Arguments:
// LPTSTR lpDirName - dir name
//
// Returns: BOOL
//
//---------------------------------------------------------------------------
BOOL DoesFolderExist(LPTSTR lpDirName)
{
DWORD dwAttribs = GetFileAttributes(lpDirName);
if ( dwAttribs == (DWORD) -1 )
return FALSE;
if ( !(dwAttribs & FILE_ATTRIBUTE_DIRECTORY) )
return FALSE;
return TRUE;
}
//---------------------------------------------------------------------------
//
// Function: DoesFileExist
//
// Purpose: Checks if the given file exists or not.
//
// Arguments:
// LPTSTR lpFileName - file name
//
// Returns: BOOL
//
//---------------------------------------------------------------------------
BOOL DoesFileExist(LPTSTR lpFileName)
{
DWORD dwAttribs = GetFileAttributes(lpFileName);
if ( dwAttribs == (DWORD) -1 )
return FALSE;
if ( dwAttribs & FILE_ATTRIBUTE_DIRECTORY )
return FALSE;
return TRUE;
}
//---------------------------------------------------------------------------
//
// Function: DoesPathExist
//
// Purpose: Checks if the given path exists or not. It does not pay
// attention to whether it is a file or directory.
//
// Arguments:
// LPTSTR lpPathName - path name
//
// Returns: BOOL
//
//---------------------------------------------------------------------------
BOOL DoesPathExist(LPTSTR lpPathName)
{
DWORD dwAttribs = GetFileAttributes(lpPathName);
if ( dwAttribs == (DWORD) -1 )
return FALSE;
return TRUE;
}
//---------------------------------------------------------------------------
//
// Function: ILFreePriv
//
// Purpose: Frees an ID list that some shell apis allocate with it's own
// special allocator.
//
// Arguments:
// LPITEMIDLIST pidl - pointer to shell specially alloced mem
//
// Returns: VOID
//
//---------------------------------------------------------------------------
VOID ILFreePriv(LPITEMIDLIST pidl)
{
LPMALLOC pMalloc;
if (pidl)
{
if ( NOERROR == SHGetMalloc(&pMalloc) )
{
pMalloc->lpVtbl->Free(pMalloc, pidl);
pMalloc->lpVtbl->Release(pMalloc);
}
}
}
//
// Constants used for GetOpenFileName() and GetSaveFileName() calls that
// allow user to browse for an answer file.
//
//#define TEXT_FILE_FILTER _T("Text Files (*.txt)\0*.txt\0Remote Boot Files (*.sif)\0*.sif\0Sysprep Inf Files (*.inf)\0*.inf\0All Files (*.*)\0*.*\0")
#define TEXT_EXTENSION _T("txt")
//----------------------------------------------------------------------------
//
// Function: GetAnswerFileName
//
// Purpose: Function for the 'Browse' button on the SaveScript page and
// the NewOrEdit page.
//
// Arguments:
// HWND hwnd - calling window
// LPTSTR buffer - output, pass in a MAX_PATH buffer
//
// Returns:
// BOOL - success
//
//----------------------------------------------------------------------------
BOOL GetAnswerFileName(HWND hwnd,
LPTSTR lpFileName,
BOOL bSavingFile)
{
OPENFILENAME ofn;
DWORD dwFlags;
TCHAR PathBuffer[MAX_PATH];
INT iRet;
HRESULT hrPrintf;
//
// If we haven't already loaded the resource strings, then load them now.
//
if( g_szSetupMgrFileExtensions[0] == _T('\0') )
{
TCHAR *StrTextFiles;
TCHAR *StrRemoteBootFiles;
TCHAR *StrSysprepFiles;
TCHAR *StrAllFiles;
//
// Load the resource strings
//
StrTextFiles = AllocateString(NULL, IDS_TEXT_FILES);
StrRemoteBootFiles = AllocateString(NULL, IDS_REMOTE_BOOT_FILES);
StrSysprepFiles = AllocateString(NULL, IDS_SYSPREP_FILES);
StrAllFiles = AllocateString(NULL, IDS_ALL_FILES);
//
// Build the text file filter string
//
//
// The question marks (?) are just placehoders for where the NULL char
// will be inserted.
//
hrPrintf=StringCchPrintf( g_szSetupMgrFileExtensions,AS(g_szSetupMgrFileExtensions),
_T("%s (*.txt)?*.txt?%s (*.sif)?*.sif?%s (*.inf)?*.inf?%s (*.*)?*.*?"),
StrTextFiles,
StrRemoteBootFiles,
StrSysprepFiles,
StrAllFiles );
FREE(StrTextFiles);
FREE(StrRemoteBootFiles);
FREE(StrSysprepFiles);
FREE(StrAllFiles);
ConvertQuestionsToNull( g_szSetupMgrFileExtensions );
}
if ( bSavingFile )
dwFlags = OFN_HIDEREADONLY |
OFN_PATHMUSTEXIST;
else
dwFlags = OFN_HIDEREADONLY |
OFN_FILEMUSTEXIST;
GetCurrentDirectory(MAX_PATH, PathBuffer);
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = hwnd;
ofn.hInstance = NULL;
ofn.lpstrFilter = g_szSetupMgrFileExtensions;
ofn.lpstrCustomFilter = NULL;
ofn.nMaxCustFilter = 0L;
ofn.nFilterIndex = 1;
ofn.lpstrFile = lpFileName;
ofn.nMaxFile = MAX_PATH;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = PathBuffer;
ofn.lpstrTitle = NULL;
ofn.Flags = dwFlags;
ofn.nFileOffset = 0;
ofn.nFileExtension = 0;
ofn.lpstrDefExt = TEXT_EXTENSION;
if ( bSavingFile )
iRet = GetSaveFileName(&ofn);
else
iRet = GetOpenFileName(&ofn);
if ( ! iRet )
return FALSE;
MyGetFullPath(lpFileName);
return TRUE;
}
//----------------------------------------------------------------------------
//
// Function: ShowBrowseFolder
//
// Purpose: Displays a browse folder for the user to select a file from.
// Takes the headache out of making an OPENFILENAME struct and filling
// it up.
//
// Arguments:
// HWND hwnd - handle to the dialog box
// TCHAR *szFileFilter - string to display descriptions and extensions
// on the files
// TCHAR *szFileExtension - string that is the default extension for the file
// DWORD dwFlags - bit flags used to initialize the browse dialog
// TCHAR *szStartingPath - path the browse should start at
// TCHAR *szFileNameAndPath - path and filename the user selected
//
// Returns: Non-Zero - if user specified a file
// Zero - if user did not specify a file
//
//----------------------------------------------------------------------------
INT
ShowBrowseFolder( IN HWND hwnd,
IN TCHAR *szFileFilter,
IN TCHAR *szFileExtension,
IN DWORD dwFlags,
IN TCHAR *szStartingPath,
IN OUT TCHAR *szFileNameAndPath ) {
OPENFILENAME ofn;
ofn.lStructSize = sizeof(OPENFILENAME);
ofn.hwndOwner = hwnd;
ofn.hInstance = NULL;
ofn.lpstrFilter = szFileFilter;
ofn.lpstrCustomFilter = NULL;
ofn.nMaxCustFilter = 0L;
ofn.nFilterIndex = 1;
ofn.lpstrFile = szFileNameAndPath;
ofn.nMaxFile = MAX_PATH;
ofn.lpstrFileTitle = NULL;
ofn.nMaxFileTitle = 0;
ofn.lpstrInitialDir = szStartingPath;
ofn.lpstrTitle = NULL;
ofn.Flags = dwFlags;
ofn.nFileOffset = 0;
ofn.nFileExtension = 0;
ofn.lpstrDefExt = szFileExtension;
return( GetOpenFileName( &ofn ) );
}
//----------------------------------------------------------------------------
//
// Function: GetPlatform
//
// Purpose:
//
// Arguments: OUT TCHAR *pBuffer - buffer to copy the platform string to,
// assumed to be able to hold MAX_PATH chars
//
// Returns: VOID
//
//----------------------------------------------------------------------------
VOID
GetPlatform( OUT TCHAR *pBuffer )
{
SYSTEM_INFO SystemInfo;
GetSystemInfo( &SystemInfo );
switch( SystemInfo.wProcessorArchitecture )
{
case PROCESSOR_ARCHITECTURE_INTEL:
lstrcpyn( pBuffer, _T("i386"), MAX_PATH );
break;
case PROCESSOR_ARCHITECTURE_AMD64:
lstrcpyn( pBuffer, _T("amd64"), MAX_PATH );
break;
default:
lstrcpyn( pBuffer, _T("i386"), MAX_PATH );
AssertMsg( FALSE,
"Unknown Processor. Can't set sysprep language files path." );
}
}
Reference in a new issue Copy permalink