2565 lines
79 KiB
C++
2565 lines
79 KiB
C++
//--------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1999 - 2000.
|
|
//
|
|
//
|
|
// File: loadsys
|
|
//
|
|
// Contents: Load system settings.
|
|
//
|
|
//---------------------------------------------------------------
|
|
|
|
#include "loadhead.cxx"
|
|
#pragma hdrstop
|
|
|
|
#include <common.hxx>
|
|
#include <stdlib.h>
|
|
#include <objerror.h>
|
|
#include <loadstate.hxx>
|
|
#include <bothchar.hxx>
|
|
#include <winnetwk.h>
|
|
#include <lmshare.h>
|
|
#include <lmaccess.h>
|
|
#include <winspool.h>
|
|
#include <winuserp.h> // in \nt\private\inc
|
|
#include <wingdip.h> // in \nt\private\inc
|
|
#include <ntlsa.h> // for domain/workgroup membership
|
|
#include <ntexapi.h> // for NtSetDefaultLocale
|
|
#include <devguid.h> // for modem device class
|
|
#include <ras.h>
|
|
#include <raserror.h>
|
|
|
|
#include <loadras.hxx> // State Migration private RAS Phonebook APIs
|
|
|
|
|
|
const TCHAR NETSHARES_SECTION[] = TEXT("NetShares");
|
|
const TCHAR PRINTERS_SECTION[] = TEXT("Printers");
|
|
const TCHAR PRINTER_DRIVER_MAP[] = TEXT("Printer Driver Mapping");
|
|
const TCHAR RAS_SECTION[] = TEXT("RAS");
|
|
const TCHAR ACCESS_SECTION[] = TEXT("Accessibility");
|
|
const TCHAR DESKTOP_SECTION[] = TEXT("Desktop");
|
|
const TCHAR KEYBOARDLAYOUT_MAP[] = TEXT("Keyboard.Layout.Mappings");
|
|
const TCHAR REGKEY_PRELOAD[] = TEXT("Keyboard Layout\\Preload");
|
|
const TCHAR REGKEY_SUBSTITUTES[] = TEXT("Keyboard Layout\\Substitutes");
|
|
const TCHAR REGKEY_INTL[] = TEXT("Control Panel\\International");
|
|
const TCHAR SCHED_PARAMS[] = TEXT(" /s /p");
|
|
|
|
|
|
const DWORD INTL_NT4 = 0x200; // platform ID from intl.inf
|
|
const DWORD INTL_95 = 0x001; // platform ID from intl.inf
|
|
const DWORD INTL_98 = 0x002; // platform ID from intl.inf
|
|
const int SIZE_128 = 128; // for user locale strings
|
|
|
|
// Types and defines
|
|
#define IS_IME_KBDLAYOUT(hkl) ((HIWORD((ULONG_PTR)(hkl)) & 0xf000) == 0xe000)
|
|
#define ChkErr(s) if ((dwErr = (s)) != ERROR_SUCCESS) goto Err;
|
|
#define ChkBoolErr(s) if ((success = (s)) == FALSE) { \
|
|
dwErr = GetLastError(); \
|
|
goto Err;\
|
|
}
|
|
|
|
|
|
#define PRIVATE_RAS // Define this to use our private
|
|
// RasSetEntryProperties implementation.
|
|
|
|
//
|
|
// private structure needed by ConvertRecentDocsMRU
|
|
//
|
|
typedef struct {
|
|
// Link structure
|
|
WORD wSize;
|
|
//ITEMIDLIST idl; // variable-length struct
|
|
// String, plus three bytes appended to struct
|
|
} LINKSTRUCT, *PLINKSTRUCT;
|
|
|
|
//
|
|
// Win95 uses a mix of LOGFONTA and a weird 16-bit LOGFONT
|
|
// structure that uses SHORTs instead of LONGs.
|
|
//
|
|
|
|
typedef struct {
|
|
SHORT lfHeight;
|
|
SHORT lfWidth;
|
|
SHORT lfEscapement;
|
|
SHORT lfOrientation;
|
|
SHORT lfWeight;
|
|
BYTE lfItalic;
|
|
BYTE lfUnderline;
|
|
BYTE lfStrikeOut;
|
|
BYTE lfCharSet;
|
|
BYTE lfOutPrecision;
|
|
BYTE lfClipPrecision;
|
|
BYTE lfQuality;
|
|
BYTE lfPitchAndFamily;
|
|
char lfFaceName[LF_FACESIZE];
|
|
} SHORT_LOGFONT, *PSHORT_LOGFONT;
|
|
|
|
#define COLOR_MAX_V1 25
|
|
#define COLOR_MAX_V3 25
|
|
#define COLOR_MAX_V4 29
|
|
#define COLOR_MAX_NT 29 // this is a modified version 2 format, similar to 4
|
|
|
|
//
|
|
// NT uses only UNICODE structures, and pads the members
|
|
// to 32-bit boundaries.
|
|
//
|
|
|
|
typedef struct {
|
|
SHORT version; // 2 for NT UNICODE
|
|
WORD wDummy; // for alignment
|
|
NONCLIENTMETRICSW ncm;
|
|
LOGFONTW lfIconTitle;
|
|
COLORREF rgb[COLOR_MAX_NT];
|
|
} SCHEMEDATA_NT, *PSCHEMEDATA_NT;
|
|
|
|
//
|
|
// Win95 uses NONCLIENTMETRICSA which has LOGFONTA members,
|
|
// but it uses a 16-bit LOGFONT as well.
|
|
//
|
|
|
|
#pragma pack(push)
|
|
#pragma pack(1)
|
|
|
|
typedef struct {
|
|
SHORT version; // 1 for Win95 ANSI
|
|
NONCLIENTMETRICSA ncm;
|
|
SHORT_LOGFONT lfIconTitle;
|
|
COLORREF rgb[COLOR_MAX_V1];
|
|
} SCHEMEDATA_V1, *PSCHEMEDATA_V1;
|
|
|
|
typedef struct {
|
|
SHORT version; // 1 for Win95 ANSI
|
|
|
|
NONCLIENTMETRICSA ncm;
|
|
SHORT_LOGFONT lfIconTitle;
|
|
COLORREF rgb[COLOR_MAX_V4];
|
|
} SCHEMEDATA_V1A, *PSCHEMEDATA_V1A;
|
|
|
|
typedef struct {
|
|
SHORT version; // 3 for Win98 ANSI, 4 for portable format
|
|
WORD Dummy;
|
|
NONCLIENTMETRICSA ncm;
|
|
LOGFONTA lfIconTitle;
|
|
COLORREF rgb[COLOR_MAX_V3];
|
|
} SCHEMEDATA_V3, *PSCHEMEDATA_V3;
|
|
|
|
typedef struct {
|
|
SHORT version; // 4 for Win32 format (whatever that means)
|
|
WORD Dummy;
|
|
NONCLIENTMETRICSA ncm;
|
|
LOGFONTA lfIconTitle;
|
|
COLORREF rgb[COLOR_MAX_V4];
|
|
} SCHEMEDATA_V4, *PSCHEMEDATA_V4;
|
|
|
|
#pragma pack(pop)
|
|
|
|
typedef struct _APPLET_TIME_ZONE_INFORMATION
|
|
{
|
|
LONG Bias;
|
|
LONG StandardBias;
|
|
LONG DaylightBias;
|
|
SYSTEMTIME StandardDate;
|
|
SYSTEMTIME DaylightDate;
|
|
} APPLET_TIME_ZONE_INFORMATION;
|
|
|
|
// RAS api functions
|
|
typedef DWORD
|
|
(*MRasSetEntryDialParams)(
|
|
IN LPCTSTR lpszPhonebook,
|
|
IN LPRASDIALPARAMS lprasdialparams,
|
|
IN BOOL fRemovePassword);
|
|
|
|
typedef DWORD
|
|
(*MRasGetEntryProperties)(
|
|
IN LPCTSTR lpszPhonebook,
|
|
IN LPCTSTR lpszEntry,
|
|
OUT LPRASENTRYW lpRasEntry,
|
|
OUT LPDWORD lpdwEntryInfoSize,
|
|
OUT LPBYTE lpbDeviceInfo,
|
|
OUT LPDWORD lpdwDeviceInfoSize);
|
|
|
|
#ifdef PRIVATE_RAS
|
|
typedef DWORD
|
|
(*MWinState_RasSetEntryProperties)(
|
|
IN LPCWSTR lpszPhonebook,
|
|
IN LPCWSTR lpszEntry,
|
|
IN LPRASENTRYW lpRasEntry,
|
|
IN DWORD dwcbRasEntry,
|
|
IN LPBYTE lpbDeviceConfig,
|
|
IN DWORD dwcbDeviceConfig);
|
|
#else
|
|
typedef DWORD
|
|
(*MRasSetEntryProperties)(
|
|
IN LPCTSTR lpszPhonebook,
|
|
IN LPCTSTR lpszEntry,
|
|
IN LPRASENTRY lpRasEntry,
|
|
IN DWORD dwEntryInfoSize,
|
|
IN LPBYTE lpbDeviceInfo,
|
|
IN DWORD dwDeviceInfoSize);
|
|
#endif
|
|
|
|
// Statics
|
|
#ifdef PRIVATE_RAS
|
|
static MWinState_RasSetEntryProperties GWinState_RasSetEntryProperties = NULL;
|
|
#else
|
|
static MRasSetEntryProperties GRasSetEntryProperties = NULL;
|
|
#endif
|
|
static MRasSetEntryDialParams GRasSetEntryDialParams = NULL;
|
|
static MRasGetEntryProperties GRasGetEntryProperties = NULL;
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: InitializeRasApi
|
|
//
|
|
// Synopsis: Loads rasapi32.dll, if it exists
|
|
//
|
|
// Arguments: none
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 24-Feb-00 Jay Thaler Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
DWORD InitializeRasApi()
|
|
{
|
|
DWORD result = ERROR_SUCCESS;
|
|
HINSTANCE rasdll;
|
|
HINSTANCE loadrasdll; // State Mig. RAS Wrapper
|
|
|
|
//
|
|
// Load rasapi32.dll
|
|
// If this fails, RAS isn't installed and we won't migrate RAS conectoids
|
|
//
|
|
rasdll = LoadLibraryA( "rasapi32.dll" );
|
|
if (rasdll == NULL)
|
|
{
|
|
result = GetLastError();
|
|
if (Verbose && DebugOutput)
|
|
{
|
|
Win32Printf(STDERR, "Warning: rasapi32.dll not loaded: %d\r\n", result);
|
|
}
|
|
goto cleanup;
|
|
}
|
|
|
|
GRasSetEntryDialParams = (MRasSetEntryDialParams)GetProcAddress(rasdll, "RasSetEntryDialParamsW");
|
|
if (GRasSetEntryDialParams == NULL)
|
|
{
|
|
result = GetLastError();
|
|
goto cleanup;
|
|
}
|
|
|
|
#ifndef PRIVATE_RAS
|
|
GRasSetEntryProperties = (MRasSetEntryProperties)GetProcAddress(rasdll, "RasSetEntryPropertiesW");
|
|
if (GRasSetEntryProperties == NULL)
|
|
{
|
|
result = GetLastError();
|
|
goto cleanup;
|
|
}
|
|
#else
|
|
//
|
|
// Load the private wrapper for RAS APIs
|
|
//
|
|
loadrasdll = LoadLibraryA( "loadras.dll" );
|
|
if (loadrasdll == NULL)
|
|
{
|
|
result = GetLastError();
|
|
if (Verbose && DebugOutput)
|
|
{
|
|
Win32Printf(STDERR, "Warning: loadras.dll not loaded: %d\r\n", result);
|
|
}
|
|
goto cleanup;
|
|
}
|
|
|
|
GWinState_RasSetEntryProperties =
|
|
(MWinState_RasSetEntryProperties)GetProcAddress(loadrasdll, "WinState_RasSetEntryPropertiesW");
|
|
if (GWinState_RasSetEntryProperties == NULL)
|
|
{
|
|
result = GetLastError();
|
|
goto cleanup;
|
|
}
|
|
#endif
|
|
|
|
cleanup:
|
|
if (result != ERROR_SUCCESS)
|
|
{
|
|
#ifdef PRIVATE_RAS
|
|
GWinState_RasSetEntryProperties = NULL;
|
|
#else
|
|
GRasSetEntryProperties = NULL;
|
|
#endif
|
|
GRasSetEntryDialParams = NULL;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: GetInfField
|
|
//
|
|
// Synopsis: returns an allocated string for current line field #N
|
|
//
|
|
// Arguments: [ppBuffer] -- output buffer
|
|
// [pContext] -- INF file context
|
|
// [nArg] -- argument field number
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD GetInfField (TCHAR **ppBuffer, INFCONTEXT *pContext, DWORD nArg)
|
|
{
|
|
ULONG len = 0;
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
TCHAR *buffer;
|
|
|
|
*ppBuffer = NULL;
|
|
if (!SetupGetStringField ( pContext, nArg, NULL, 0, &len ))
|
|
return ERROR_BAD_FORMAT;
|
|
|
|
|
|
// Allocate a buffer. Some callers need an extra char for processing
|
|
buffer = (TCHAR *) malloc( (len+1)*sizeof(TCHAR) );
|
|
if (buffer == NULL)
|
|
{
|
|
dwErr = ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
else
|
|
{
|
|
if (!SetupGetStringField( pContext, nArg, buffer, len, &len ))
|
|
{
|
|
free( buffer );
|
|
dwErr = ERROR_BAD_FORMAT;
|
|
}
|
|
else *ppBuffer = buffer;
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: LogFormatError
|
|
//
|
|
// Synopsis: logs error message in current locale
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD LogFormatError (DWORD dwErr)
|
|
{
|
|
DWORD dwRet = ERROR_SUCCESS;
|
|
TCHAR *pcs = NULL;
|
|
|
|
if (0 != FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM |
|
|
FORMAT_MESSAGE_ALLOCATE_BUFFER, NULL,
|
|
dwErr, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
|
(TCHAR*) &pcs, 0, NULL))
|
|
{
|
|
dwRet = Win32Printf (LogFile, "%ws\r\n", pcs);
|
|
LocalFree (pcs);
|
|
}
|
|
else dwRet = GetLastError();
|
|
|
|
return dwRet;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: IsDefaultShare
|
|
//
|
|
// Synopsis: check if share name is a known system default share
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
BOOL IsDefaultShare (TCHAR *buffer)
|
|
{
|
|
ULONG ul = lstrlen(buffer);
|
|
if (buffer[ul - 1] == '$')
|
|
{
|
|
if (lstrcmp (buffer, TEXT("IPC$")) == 0) return TRUE;
|
|
if (lstrcmp (buffer, TEXT("ADMIN$")) == 0) return TRUE;
|
|
if (ul == 2 && IsCharAlpha (buffer[0])) return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: LoadNetShares
|
|
//
|
|
// Synopsis: loads network share settings
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
// NOTES: This code could be updated to do the following:
|
|
// 1. Get the correct disk type from the field instead of
|
|
// using STYPE_DISKTREE.
|
|
// 2. Store (and retrieve) the correct max user count
|
|
// 3. Handle custom access permissions
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD LoadNetShares ()
|
|
{
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
INFCONTEXT context;
|
|
NETRESOURCE nr;
|
|
BOOL success;
|
|
TCHAR * buffer = NULL;
|
|
TCHAR * buffer2 = NULL;
|
|
|
|
success = SetupFindFirstLine(InputInf, NETSHARES_SECTION, NULL, &context);
|
|
if (!success)
|
|
return ERROR_SUCCESS; // line not found
|
|
|
|
do
|
|
{
|
|
BOOL fPersist = FALSE;
|
|
BOOL bIgnore = FALSE;
|
|
|
|
ZeroMemory (&nr, sizeof(nr));
|
|
// loop through all the network shares and connect to them
|
|
|
|
dwErr = GetInfField (&buffer, &context, 1);
|
|
if (dwErr != ERROR_SUCCESS)
|
|
{
|
|
Win32Printf (LogFile, "Missing share name in [%ws]\r\n",
|
|
NETSHARES_SECTION);
|
|
break;
|
|
}
|
|
nr.dwType = RESOURCETYPE_DISK;
|
|
nr.lpLocalName = buffer;
|
|
|
|
dwErr = GetInfField (&buffer2, &context, 2);
|
|
if (dwErr != ERROR_SUCCESS)
|
|
{
|
|
Win32Printf (LogFile, "Missing remote name in [%ws]\r\n",
|
|
NETSHARES_SECTION);
|
|
free (buffer);
|
|
break;
|
|
}
|
|
nr.lpRemoteName = buffer2;
|
|
|
|
if (buffer2[0] != L'\0' && buffer2[0] == L'\\' && buffer2[1] == L'\\')
|
|
{
|
|
TCHAR *buffer3 = NULL;
|
|
if (ERROR_SUCCESS == GetInfField (&buffer3, &context, 3))
|
|
{
|
|
if (lstrcmp (buffer3, TEXT("persist")) == 0)
|
|
fPersist = TRUE;
|
|
free (buffer3);
|
|
}
|
|
dwErr = WNetAddConnection2 (&nr, NULL, NULL,
|
|
fPersist ? CONNECT_UPDATE_PROFILE : 0);
|
|
}
|
|
else
|
|
{
|
|
TCHAR *buffer3 = NULL;
|
|
TCHAR *buffer4 = NULL;
|
|
SHARE_INFO_2 si2;
|
|
DWORD dwPerm = ACCESS_READ; // default access
|
|
|
|
if (!IsDefaultShare(buffer)) // ignore system shares
|
|
{
|
|
|
|
dwErr = GetInfField (&buffer3, &context, 3);
|
|
if (dwErr == ERROR_SUCCESS)
|
|
{
|
|
dwPerm = _wtoi (buffer3); // share permission bits
|
|
}
|
|
|
|
dwErr = GetInfField (&buffer4, &context, 4);
|
|
ZeroMemory (&si2, sizeof(si2));
|
|
si2.shi2_netname = buffer;
|
|
si2.shi2_type = STYPE_DISKTREE; // should get type from field
|
|
si2.shi2_remark = buffer4;
|
|
si2.shi2_permissions = dwPerm;
|
|
|
|
if (lstrlen(buffer2) == 2 && buffer2[1] == ':')
|
|
lstrcat ((TCHAR*)buffer2, TEXT("\\"));
|
|
|
|
si2.shi2_path = buffer2;
|
|
si2.shi2_max_uses = SHI_USES_UNLIMITED; // should get number
|
|
|
|
// should handle custom access permissions here
|
|
|
|
dwErr = NetShareAdd (NULL, 2, (BYTE *) &si2, NULL);
|
|
|
|
if (buffer3 != NULL)
|
|
free (buffer3);
|
|
if (buffer4 != NULL)
|
|
free (buffer4);
|
|
}
|
|
else bIgnore = TRUE;
|
|
}
|
|
|
|
if (dwErr != ERROR_SUCCESS)
|
|
{
|
|
LogFormatError (dwErr); // log error and keep on going
|
|
dwErr = ERROR_SUCCESS;
|
|
}
|
|
else // log that the share was successfully added
|
|
{
|
|
Win32Printf (LogFile, "NetShare %ws %ws %ws\r\n", buffer, buffer2,
|
|
bIgnore ? TEXT("not processed") : TEXT("added"));
|
|
}
|
|
|
|
free (buffer);
|
|
free (buffer2);
|
|
|
|
if (dwErr != ERROR_SUCCESS)
|
|
break;
|
|
|
|
// Advance to the next line.
|
|
success = SetupFindNextLine( &context, &context );
|
|
} while (success);
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: TranslatePrinterDriver
|
|
//
|
|
// Synopsis: converts Win9x printer driver names to NT driver names
|
|
//
|
|
// Arguments: [pcs9x] -- Win9x printer driver name
|
|
// [pcsNT] -- NT printer driver name
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD TranslatePrinterDriver (WCHAR *pcs9x, WCHAR **ppcsNT)
|
|
{
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
HINF hInf;
|
|
INFCONTEXT InfContext;
|
|
|
|
*ppcsNT = NULL;
|
|
|
|
//
|
|
// See in prtupg9x.inf to see if the driver has a different name on NT
|
|
//
|
|
if ( SetupFindFirstLine(InputInf,
|
|
PRINTER_DRIVER_MAP,
|
|
pcs9x,
|
|
&InfContext) )
|
|
{
|
|
dwErr = GetInfField (ppcsNT, &InfContext, 1);
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: LoadPrinters
|
|
//
|
|
// Synopsis: loads printers settings
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD LoadPrinters ()
|
|
{
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
|
|
INFCONTEXT context;
|
|
BOOL success;
|
|
TCHAR * buffer = NULL;
|
|
DWORD dwReturnUp = ERROR_SUCCESS;
|
|
|
|
success = SetupFindFirstLine(InputInf, PRINTERS_SECTION, NULL, &context);
|
|
if (!success)
|
|
return ERROR_SUCCESS; // line not found
|
|
|
|
do
|
|
{
|
|
dwErr = GetInfField (&buffer, &context, 1);
|
|
if (dwErr != ERROR_SUCCESS)
|
|
{
|
|
Win32PrintfResource (LogFile, IDS_PRINTER_MISSINGNAME,
|
|
PRINTERS_SECTION);
|
|
break;
|
|
}
|
|
|
|
if (!AddPrinterConnection (buffer))
|
|
{
|
|
dwErr = GetLastError();
|
|
LogFormatError (dwErr); // log error and keep on going
|
|
dwReturnUp = dwErr;
|
|
dwErr = ERROR_SUCCESS;
|
|
}
|
|
else
|
|
{
|
|
Win32PrintfResource (LogFile, IDS_PRINTER_MIGRATED,
|
|
buffer, buffer);
|
|
}
|
|
|
|
free (buffer); buffer = NULL;
|
|
|
|
// Advance to the next line.
|
|
success = SetupFindNextLine( &context, &context );
|
|
}
|
|
while (success);
|
|
|
|
if (buffer) free (buffer);
|
|
|
|
return dwReturnUp;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: GetOSMajorID
|
|
//
|
|
// Synopsis: translate GetVersion IDs to INTL IDs
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD GetOSMajorID ()
|
|
{
|
|
if (SourceVersion & 0x80000000)
|
|
{
|
|
if ((SourceVersion & 0xFFFF) == 0x004)
|
|
return INTL_NT4;
|
|
}
|
|
else if ((SourceVersion & 0xFFFF) == 0xA04)
|
|
return INTL_98;
|
|
else if ((SourceVersion & 0xFFFF) == 0x004)
|
|
return INTL_95;
|
|
|
|
return 0;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: IsInExcludeList
|
|
//
|
|
// Synopsis: check if langid is in the exclude list to block migration
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
BOOL IsInExcludeList( HINF Inf, LANGID LangID)
|
|
{
|
|
TCHAR LangIDStr[9];
|
|
TCHAR *Field;
|
|
INFCONTEXT InfContext;
|
|
int iOSID;
|
|
int iLangID;
|
|
|
|
wsprintf(LangIDStr,TEXT("0000%04X"),LangID);
|
|
if (SetupFindFirstLine( Inf,
|
|
TEXT("ExcludeSourceLocale"),
|
|
LangIDStr,
|
|
&InfContext ))
|
|
{
|
|
do {
|
|
//
|
|
// if in excluded field, this is not what we want
|
|
//
|
|
if (ERROR_SUCCESS == SetupGetIntField (&InfContext, 0, &iLangID) &&
|
|
(iLangID == LangID))
|
|
{
|
|
|
|
//
|
|
// if it is in major version list, we also got what we want
|
|
//
|
|
if (ERROR_SUCCESS == SetupGetIntField (&InfContext, 1, &iOSID))
|
|
{
|
|
if (iOSID & GetOSMajorID())
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
} while ( SetupFindNextLine(&InfContext, &InfContext));
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: CheckLanguageVersion
|
|
//
|
|
// Synopsis: verifies that source and target languages allow migration
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
BOOL CheckLanguageVersion (HINF Inf, LANGID SourceLangID, LANGID TargetLangID)
|
|
{
|
|
TCHAR SourceLangIDStr[9];
|
|
LANGID SrcLANGID;
|
|
TCHAR * Field;
|
|
INFCONTEXT InfContext;
|
|
int iOSID;
|
|
int iLangID;
|
|
|
|
if (SourceLangID == 0 || TargetLangID == 0)
|
|
{
|
|
return TRUE;
|
|
}
|
|
if (SourceLangID == TargetLangID)
|
|
{
|
|
//
|
|
// special case, for Middle East version,
|
|
// NT5 is localized build but NT4 is not
|
|
//
|
|
// they don't allow NT5 localized build to upgrade NT4,
|
|
// although they are same language
|
|
//
|
|
// so we need to exclude these
|
|
//
|
|
return ((IsInExcludeList(Inf, SourceLangID) == FALSE));
|
|
}
|
|
//
|
|
// if Src != Dst, then we need to look up inf file to see
|
|
//
|
|
// if we can open a backdoor for Target language
|
|
//
|
|
|
|
//
|
|
// find alternative SourceLangID
|
|
//
|
|
|
|
wsprintf(SourceLangIDStr,TEXT("0000%04X"),SourceLangID);
|
|
|
|
if (SetupFindFirstLine( Inf,
|
|
TEXT("AlternativeSourceLocale"),
|
|
SourceLangIDStr,
|
|
&InfContext ))
|
|
{
|
|
do {
|
|
//
|
|
// Check if we found alternative locale
|
|
//
|
|
//
|
|
if (ERROR_SUCCESS == SetupGetIntField (&InfContext, 0, &iLangID) &&
|
|
(iLangID == SourceLangID))
|
|
{
|
|
if (ERROR_SUCCESS == GetInfField (&Field, &InfContext, 1))
|
|
{
|
|
LANGID AltTargetLangID = LANGIDFROMLCID(
|
|
_tcstoul(Field,NULL,16));
|
|
free (Field);
|
|
if (TargetLangID != AltTargetLangID)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// We are here if we found alternative target lang,
|
|
//
|
|
// now check the version criteria
|
|
//
|
|
//
|
|
// if it is in major version list, we also got what we want
|
|
//
|
|
if (ERROR_SUCCESS == SetupGetIntField (&InfContext, 2, &iOSID))
|
|
{
|
|
if (iOSID & GetOSMajorID())
|
|
{
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
} while ( SetupFindNextLine(&InfContext,&InfContext));
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: LoadVerifyOSLang
|
|
//
|
|
// Synopsis: verifies that source and target languages allow migration
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD LoadVerifyOSLang ()
|
|
{
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
INFCONTEXT InfContext;
|
|
LANGID langidLoad = 0;
|
|
LANGID langidScan = 0;
|
|
UINT errorline;
|
|
TCHAR tcsInf [MAX_PATH+1];
|
|
|
|
if (0 == GetWindowsDirectory ((TCHAR*)tcsInf, MAX_PATH))
|
|
return GetLastError();
|
|
|
|
// This inf file must exist for all Windows 2000 localized versions
|
|
_tcsncat (tcsInf, TEXT("\\inf\\intl.inf"), MAX_PATH-_tcslen(tcsInf));
|
|
|
|
HINF Inf = SetupOpenInfFile(tcsInf, NULL, INF_STYLE_WIN4, &errorline );
|
|
|
|
if (INVALID_HANDLE_VALUE == Inf)
|
|
{
|
|
dwErr = GetLastError();
|
|
Win32Printf (LogFile, "%systemroot%\\system\\inf\\intl.inf"
|
|
"could not be opened Error=%d\r\n", dwErr);
|
|
}
|
|
else
|
|
{
|
|
if (SetupFindFirstLine( Inf,
|
|
TEXT("DefaultValues"),
|
|
TEXT("Locale"),
|
|
&InfContext ))
|
|
{
|
|
TCHAR *pLoadLang = NULL;
|
|
dwErr = GetInfField (&pLoadLang, &InfContext, 1);
|
|
if (ERROR_SUCCESS == dwErr)
|
|
{
|
|
langidLoad = (LANGID)_tcstoul(pLoadLang,NULL,16);
|
|
free (pLoadLang);
|
|
|
|
if ( SetupFindFirstLine(InputInf,
|
|
SOURCE_SECTION,
|
|
LOCALE,
|
|
&InfContext) )
|
|
{
|
|
TCHAR *pScanLang = NULL;
|
|
dwErr = GetInfField (&pScanLang, &InfContext, 1);
|
|
if (ERROR_SUCCESS == dwErr)
|
|
{
|
|
langidScan = (LANGID)_tcstoul(pScanLang,NULL,16);
|
|
free (pScanLang);
|
|
|
|
if (FALSE == CheckLanguageVersion(Inf,
|
|
langidScan,langidLoad))
|
|
{
|
|
dwErr = ERROR_INSTALL_LANGUAGE_UNSUPPORTED;
|
|
LogFormatError (dwErr);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Win32Printf (LogFile, "locale missing in [%ws]\r\n",
|
|
SOURCE_SECTION);
|
|
LogFormatError (dwErr);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dwErr = GetLastError();
|
|
Win32Printf (LogFile, "intl.inf: default locale missing\r\n");
|
|
LogFormatError (dwErr);
|
|
}
|
|
SetupCloseInfFile (Inf);
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: MigrateKeyboardSubstitutes
|
|
//
|
|
// Synopsis: changes the user keyboard layouts
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD MigrateKeyboardSubstitutes (TCHAR *tcsName)
|
|
{
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
ULONG ulOrig = _tcstoul(tcsName, NULL, 16);
|
|
ULONG ulLang = LOWORD(ulOrig);
|
|
HKEY hKey = NULL;
|
|
BOOL fFound = FALSE;
|
|
|
|
if (IS_IME_KBDLAYOUT(ulOrig) || ulLang == ulOrig)
|
|
return ERROR_SUCCESS;
|
|
|
|
if (ERROR_SUCCESS == RegOpenKeyEx (
|
|
CurrentUser ? CurrentUser : HKEY_CURRENT_USER,
|
|
REGKEY_SUBSTITUTES,
|
|
NULL,
|
|
KEY_READ | KEY_WRITE,
|
|
&hKey))
|
|
{
|
|
DWORD dwIndex = 0;
|
|
ULONG ulIndex;
|
|
ULONG ulValue;
|
|
TCHAR tcsIndex[KL_NAMELENGTH];
|
|
TCHAR tcsValue[KL_NAMELENGTH];
|
|
|
|
while (dwErr == ERROR_SUCCESS)
|
|
{
|
|
DWORD cbIndex = sizeof (tcsIndex);
|
|
DWORD cbValue = sizeof(tcsValue);
|
|
dwErr = RegEnumValue (hKey, dwIndex, tcsIndex, &cbIndex,
|
|
NULL, NULL, (BYTE*) tcsValue, &cbValue);
|
|
|
|
if (ERROR_SUCCESS == dwErr)
|
|
{
|
|
ulIndex = _tcstoul(tcsIndex, NULL, 16);
|
|
ulValue = _tcstoul(tcsValue, NULL, 16);
|
|
if (ulIndex == ulLang && ulValue == ulOrig)
|
|
{
|
|
fFound = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
dwIndex++;
|
|
}
|
|
if (dwErr == ERROR_NO_MORE_ITEMS)
|
|
dwErr = ERROR_SUCCESS;
|
|
|
|
if (!fFound) // add a new value
|
|
{
|
|
wsprintf (tcsIndex, TEXT("%08x"), ulLang);
|
|
dwErr = RegSetValueEx (hKey, tcsIndex, 0, REG_SZ, (BYTE*)tcsName,
|
|
(_tcslen(tcsName)+1)*sizeof(TCHAR));
|
|
}
|
|
|
|
RegCloseKey (hKey);
|
|
}
|
|
return dwErr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: MigrateKeyboardPreloads
|
|
//
|
|
// Synopsis: changes the user keyboard layouts
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD MigrateKeyboardPreloads (TCHAR *tcsName)
|
|
{
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
ULONG ul = _tcstoul(tcsName, NULL, 16);
|
|
HKEY hKey = NULL;
|
|
BOOL fFound = FALSE;
|
|
|
|
// look for a preload with this locale
|
|
if (!IS_IME_KBDLAYOUT(ul))
|
|
ul = LOWORD(ul);
|
|
|
|
if (ERROR_SUCCESS == RegOpenKeyEx (
|
|
CurrentUser ? CurrentUser : HKEY_CURRENT_USER,
|
|
REGKEY_PRELOAD,
|
|
NULL,
|
|
KEY_READ | KEY_WRITE,
|
|
&hKey))
|
|
{
|
|
DWORD dwIndex = 0;
|
|
ULONG ulIndexMax = 0;
|
|
ULONG ulIndex;
|
|
ULONG ulValue;
|
|
TCHAR tcsIndex[KL_NAMELENGTH];
|
|
TCHAR tcsValue[KL_NAMELENGTH];
|
|
|
|
while (dwErr == ERROR_SUCCESS)
|
|
{
|
|
DWORD cbIndex = sizeof (tcsIndex);
|
|
DWORD cbValue = sizeof(tcsValue);
|
|
dwErr = RegEnumValue (hKey, dwIndex, tcsIndex, &cbIndex,
|
|
NULL, NULL, (BYTE*)tcsValue, &cbValue);
|
|
|
|
if (ERROR_SUCCESS == dwErr)
|
|
{
|
|
ulIndex = _tcstoul(tcsIndex, NULL, 10);
|
|
if (ulIndex > ulIndexMax)
|
|
ulIndexMax = ulIndex;
|
|
ulValue = _tcstoul(tcsValue, NULL, 16);
|
|
if (ulValue == ul)
|
|
{
|
|
fFound = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
dwIndex++;
|
|
}
|
|
if (dwErr == ERROR_NO_MORE_ITEMS)
|
|
dwErr = ERROR_SUCCESS;
|
|
|
|
if (!fFound) // add a new value
|
|
{
|
|
wsprintf (tcsIndex, TEXT("%d"), ulIndexMax+1);
|
|
wsprintf (tcsValue, TEXT("%08x"), ul);
|
|
dwErr = RegSetValueEx (hKey, tcsIndex, 0, REG_SZ, (BYTE*)tcsValue,
|
|
(_tcslen(tcsValue)+1)*sizeof(TCHAR));
|
|
}
|
|
RegCloseKey (hKey);
|
|
}
|
|
return dwErr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: LoadKeyboardLayouts
|
|
//
|
|
// Synopsis: changes the user keyboard layouts
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD LoadKeyboardLayouts ()
|
|
{
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
INFCONTEXT InfContext;
|
|
BOOL fFound;
|
|
|
|
// translate input locales if source is Win9x
|
|
if (!(SourceVersion & 0x80000000))
|
|
return ERROR_SUCCESS;
|
|
|
|
if (SetupFindFirstLine(InputInf, SOURCE_SECTION, INPUTLOCALE, &InfContext))
|
|
{
|
|
TCHAR *pLayout = NULL;
|
|
UINT iLayouts = SetupGetFieldCount(&InfContext);
|
|
for (UINT i = 1; i <= iLayouts; i++)
|
|
{
|
|
dwErr = GetInfField (&pLayout, &InfContext, i);
|
|
if (ERROR_SUCCESS == dwErr)
|
|
{
|
|
INFCONTEXT InfContext2;
|
|
//
|
|
// See in usermig.inf to see if different ID exists
|
|
//
|
|
if ( SetupFindFirstLine(InputInf,
|
|
KEYBOARDLAYOUT_MAP,
|
|
pLayout,
|
|
&InfContext2) )
|
|
{
|
|
TCHAR *pMap = NULL;
|
|
if (ERROR_SUCCESS == GetInfField (&pMap, &InfContext2, 1))
|
|
{
|
|
free (pLayout);
|
|
pLayout = pMap;
|
|
}
|
|
}
|
|
|
|
dwErr = MigrateKeyboardPreloads (pLayout);
|
|
if (ERROR_SUCCESS == dwErr)
|
|
dwErr = MigrateKeyboardSubstitutes (pLayout);
|
|
|
|
if (CurrentUser == HKEY_CURRENT_USER)
|
|
{
|
|
TCHAR kbname[KL_NAMELENGTH];
|
|
GetKeyboardLayoutName (kbname);
|
|
if (i == 1 && lstrcmp(kbname, pLayout) != 0) // load default
|
|
{
|
|
ULONG ulLayout = _tcstoul(pLayout, NULL, 16);
|
|
HKL hklCurrent = GetKeyboardLayout(0);
|
|
if (Verbose)
|
|
printf ("Loading keyboard layout %ws \n", pLayout);
|
|
|
|
HKL hkl = LoadKeyboardLayoutEx (hklCurrent, pLayout,
|
|
KLF_REORDER | KLF_ACTIVATE | KLF_SETFORPROCESS |
|
|
KLF_SUBSTITUTE_OK);
|
|
if (hkl != NULL)
|
|
{
|
|
SystemParametersInfo (SPI_SETDEFAULTINPUTLANG, 0,
|
|
(VOID *) &hkl, 0);
|
|
if (Verbose)
|
|
{
|
|
#ifdef _WIN64
|
|
printf ("Activated keyboard layout %08I64x\n",hkl);
|
|
#else
|
|
printf ("Activated keyboard layout %08x\n",hkl);
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
else if (i > 1) // load the alternates
|
|
{
|
|
LoadKeyboardLayout (pLayout, KLF_SUBSTITUTE_OK);
|
|
}
|
|
}
|
|
free (pLayout);
|
|
|
|
if (dwErr != ERROR_SUCCESS)
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
Win32Printf (LogFile,"Could not read keyboard layout %d\r\n",i);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (dwErr != ERROR_SUCCESS)
|
|
Win32Printf (LogFile, "Could not load all keyboard layouts\r\n");
|
|
return dwErr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: EnumerateModems
|
|
//
|
|
// Synopsis: enumerates the modem devices on the system
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD EnumerateModems (TCHAR *ptsPort, ULONG ulLen)
|
|
{
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
UINT i = 0;
|
|
BOOL fDetected = FALSE;
|
|
SP_DEVINFO_DATA sdd;
|
|
|
|
HDEVINFO hdi = SetupDiGetClassDevs (&GUID_DEVCLASS_MODEM,
|
|
NULL,
|
|
NULL,
|
|
DIGCF_PRESENT );
|
|
|
|
if (hdi != INVALID_HANDLE_VALUE)
|
|
{
|
|
ZeroMemory (&sdd, sizeof(sdd));
|
|
sdd.cbSize = sizeof(sdd);
|
|
sdd.ClassGuid = GUID_DEVCLASS_MODEM;
|
|
|
|
while (SetupDiEnumDeviceInfo (hdi, i++, &sdd))
|
|
{
|
|
HKEY hKey = SetupDiOpenDevRegKey (hdi,
|
|
&sdd,
|
|
DICS_FLAG_GLOBAL,
|
|
0,
|
|
DIREG_DRV,
|
|
KEY_READ);
|
|
if (hKey != INVALID_HANDLE_VALUE)
|
|
{
|
|
ULONG ulLenQuery = ulLen;
|
|
dwErr = RegQueryValueEx(hKey,
|
|
TEXT("AttachedTo"),
|
|
NULL,
|
|
NULL,
|
|
(BYTE *)ptsPort,
|
|
&ulLenQuery);
|
|
RegCloseKey (hKey);
|
|
|
|
if (dwErr == ERROR_SUCCESS) // found a modem
|
|
{
|
|
fDetected = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
else dwErr = GetLastError();
|
|
}
|
|
if (!fDetected)
|
|
dwErr = ERROR_NO_MORE_DEVICES; // no modem detected
|
|
}
|
|
else dwErr = GetLastError();
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: RasGetPhoneBookFile
|
|
//
|
|
// Synopsis: determines location of RAS settings in phonebook file
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD RasGetPhoneBookFile(TCHAR *strPhoneBook)
|
|
{
|
|
const TCHAR RASPHONE_SUBPATH[] = TEXT("\\ras\\rasphone.pbk");
|
|
|
|
if (0 == GetSystemDirectory ((TCHAR*)strPhoneBook, MAX_PATH))
|
|
return GetLastError();
|
|
|
|
_tcsncat(strPhoneBook, (TCHAR *) RASPHONE_SUBPATH,
|
|
MAX_PATH-_tcslen(strPhoneBook));
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: LoadRas
|
|
//
|
|
// Synopsis: create the phonebook file for RAS settings
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD LoadRas()
|
|
{
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
BOOL success;
|
|
INFCONTEXT context;
|
|
RASENTRY RasEntry;
|
|
RASDIALPARAMS RasDialParams;
|
|
|
|
success = SetupFindFirstLine(InputInf, RAS_SECTION, NULL, &context);
|
|
if (!success)
|
|
return ERROR_SUCCESS; // line not found
|
|
|
|
do {
|
|
ZeroMemory( &RasEntry, sizeof(RASENTRY) );
|
|
ZeroMemory( &RasDialParams, sizeof(RASDIALPARAMS) );
|
|
|
|
RasDialParams.dwSize = sizeof(RASDIALPARAMS);
|
|
RasEntry.dwSize = sizeof(RASENTRY);
|
|
|
|
ChkBoolErr( SetupGetStringField( &context, 1, RasDialParams.szEntryName,
|
|
RAS_MaxEntryName + 1, NULL) );
|
|
// load RasEntry structure
|
|
ChkBoolErr( SetupGetIntField( &context, 2, (int*)&RasEntry.dwfOptions) );
|
|
ChkBoolErr( SetupGetIntField( &context, 3, (int*)&RasEntry.dwCountryID) );
|
|
ChkBoolErr( SetupGetIntField( &context, 4, (int*)&RasEntry.dwCountryCode) );
|
|
ChkBoolErr( SetupGetStringField( &context, 5, RasEntry.szAreaCode,
|
|
RAS_MaxAreaCode + 1, NULL) );
|
|
ChkBoolErr( SetupGetStringField( &context, 6, RasEntry.szLocalPhoneNumber,
|
|
RAS_MaxPhoneNumber + 1, NULL) );
|
|
ChkBoolErr( SetupGetIntField( &context, 7, (int*)&RasEntry.dwAlternateOffset) );
|
|
ChkBoolErr( SetupGetIntField( &context, 8, (int*)&RasEntry.ipaddr) );
|
|
ChkBoolErr( SetupGetIntField( &context, 9, (int*)&RasEntry.ipaddrDns) );
|
|
ChkBoolErr( SetupGetIntField( &context, 10, (int*)&RasEntry.ipaddrDnsAlt) );
|
|
ChkBoolErr( SetupGetIntField( &context, 11, (int*)&RasEntry.ipaddrWins) );
|
|
ChkBoolErr( SetupGetIntField( &context, 12, (int*)&RasEntry.ipaddrWinsAlt) );
|
|
ChkBoolErr( SetupGetIntField( &context, 13, (int*)&RasEntry.dwFrameSize) );
|
|
ChkBoolErr( SetupGetIntField( &context, 14, (int*)&RasEntry.dwfNetProtocols) );
|
|
ChkBoolErr( SetupGetIntField( &context, 15, (int*)&RasEntry.dwFramingProtocol) );
|
|
ChkBoolErr( SetupGetStringField( &context, 16, RasEntry.szScript, MAX_PATH, NULL) );
|
|
ChkBoolErr( SetupGetStringField( &context, 17, RasEntry.szAutodialDll, MAX_PATH, NULL) );
|
|
ChkBoolErr( SetupGetStringField( &context, 18, RasEntry.szAutodialFunc, MAX_PATH, NULL) );
|
|
ChkBoolErr( SetupGetStringField( &context, 19, RasEntry.szDeviceType,
|
|
RAS_MaxDeviceType + 1, NULL) );
|
|
ChkBoolErr( SetupGetStringField( &context, 20, RasEntry.szDeviceName,
|
|
RAS_MaxDeviceName + 1, NULL) );
|
|
ChkBoolErr( SetupGetStringField( &context, 21, RasEntry.szX25PadType,
|
|
RAS_MaxPadType + 1, NULL) );
|
|
ChkBoolErr( SetupGetStringField( &context, 22, RasEntry.szX25Address,
|
|
RAS_MaxX25Address + 1, NULL) );
|
|
ChkBoolErr( SetupGetStringField( &context, 23, RasEntry.szX25Facilities,
|
|
RAS_MaxFacilities + 1, NULL) );
|
|
ChkBoolErr( SetupGetStringField( &context, 24, RasEntry.szX25UserData,
|
|
RAS_MaxUserData + 1, NULL) );
|
|
ChkBoolErr( SetupGetIntField( &context, 25, (int*)&RasEntry.dwChannels) );
|
|
|
|
// load RasDialParams structure
|
|
ChkBoolErr( SetupGetStringField( &context, 26, RasDialParams.szPhoneNumber,
|
|
RAS_MaxPhoneNumber + 1, NULL) );
|
|
ChkBoolErr( SetupGetStringField( &context, 27, RasDialParams.szCallbackNumber,
|
|
RAS_MaxCallbackNumber+1, NULL) );
|
|
ChkBoolErr( SetupGetStringField( &context, 28, RasDialParams.szUserName, UNLEN+1, NULL) );
|
|
ChkBoolErr( SetupGetStringField( &context, 29, RasDialParams.szPassword, PWLEN+1, NULL) );
|
|
ChkBoolErr( SetupGetStringField( &context, 30, RasDialParams.szDomain, DNLEN+1, NULL) );
|
|
|
|
// Set default options that do not exist on pre-Win2000 OS, but are
|
|
// set by default when you create a connection via the Win2000 GUI.
|
|
RasEntry.dwfOptions |= RASEO_PreviewUserPw;
|
|
RasEntry.dwfOptions |= RASEO_ShowDialingProgress;
|
|
RasEntry.dwfOptions |= RASEO_ModemLights;
|
|
|
|
// New Win2k encryption field
|
|
if( RasEntry.dwfOptions & RASEO_RequireDataEncryption )
|
|
{
|
|
RasEntry.dwEncryptionType = ET_Require;
|
|
}
|
|
else
|
|
{
|
|
RasEntry.dwEncryptionType = ET_Optional;
|
|
}
|
|
|
|
#ifdef PRIVATE_RAS
|
|
dwErr = GWinState_RasSetEntryProperties(NULL, // Current user default phonebook
|
|
RasDialParams.szEntryName,
|
|
&RasEntry,
|
|
sizeof(RASENTRY),
|
|
NULL,
|
|
NULL);
|
|
#else
|
|
dwErr = GRasSetEntryProperties(NULL, // Current user default phonebook
|
|
RasDialParams.szEntryName,
|
|
&RasEntry,
|
|
sizeof(RASENTRY),
|
|
NULL,
|
|
NULL);
|
|
#endif
|
|
if ( dwErr != ERROR_SUCCESS)
|
|
{
|
|
Win32PrintfResource (LogFile, IDS_RAS_ENTRY_NOT_MIGRATED, RasDialParams.szEntryName);
|
|
if (DebugOutput)
|
|
Win32Printf(LogFile, "RasSetEntryProperties failed: Error %d\r\n", dwErr);
|
|
}
|
|
|
|
dwErr = GRasSetEntryDialParams(NULL,
|
|
&RasDialParams,
|
|
TRUE); // Never put password in
|
|
if ( dwErr != ERROR_SUCCESS)
|
|
{
|
|
Win32PrintfResource (LogFile, IDS_RAS_ENTRY_NOT_MIGRATED, RasDialParams.szEntryName);
|
|
if (DebugOutput)
|
|
Win32Printf(LogFile, "RasSetEntryDialParams failed: Error %d\r\n", dwErr);
|
|
}
|
|
|
|
// Advance to the next line.
|
|
success = SetupFindNextLine( &context, &context );
|
|
} while (success);
|
|
|
|
Err:
|
|
return dwErr;
|
|
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: ConvertLFShort
|
|
//
|
|
// Synopsis: convert Win9x 16-bit LOGFONTs to NT formats
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD ConvertLFShort (LOGFONTW *plfDest, const SHORT_LOGFONT *plfSrc)
|
|
{
|
|
plfDest->lfHeight = plfSrc->lfHeight;
|
|
plfDest->lfWidth = plfSrc->lfWidth;
|
|
plfDest->lfEscapement = plfSrc->lfEscapement;
|
|
plfDest->lfOrientation = plfSrc->lfOrientation;
|
|
plfDest->lfWeight = plfSrc->lfWeight;
|
|
plfDest->lfItalic = plfSrc->lfItalic;
|
|
plfDest->lfUnderline = plfSrc->lfUnderline;
|
|
plfDest->lfStrikeOut = plfSrc->lfStrikeOut;
|
|
plfDest->lfCharSet = plfSrc->lfCharSet;
|
|
plfDest->lfOutPrecision = plfSrc->lfOutPrecision;
|
|
plfDest->lfClipPrecision = plfSrc->lfClipPrecision;
|
|
plfDest->lfQuality = plfSrc->lfQuality;
|
|
plfDest->lfPitchAndFamily = plfSrc->lfPitchAndFamily;
|
|
ZeroMemory (plfDest->lfFaceName, sizeof(plfDest->lfFaceName));
|
|
|
|
if (0 == MultiByteToWideChar (GetACP(),
|
|
0,
|
|
plfSrc->lfFaceName,
|
|
-1,
|
|
plfDest->lfFaceName,
|
|
sizeof (plfDest->lfFaceName) / sizeof (WCHAR)))
|
|
return GetLastError();
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: ConvertLF
|
|
//
|
|
// Synopsis: convert Win9x LOGFONTs to NT formats
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD ConvertLF (LOGFONTW *plfDest, const LOGFONTA *plfSrc)
|
|
{
|
|
plfDest->lfHeight = plfSrc->lfHeight;
|
|
plfDest->lfWidth = plfSrc->lfWidth;
|
|
plfDest->lfEscapement = plfSrc->lfEscapement;
|
|
plfDest->lfOrientation = plfSrc->lfOrientation;
|
|
plfDest->lfWeight = plfSrc->lfWeight;
|
|
plfDest->lfItalic = plfSrc->lfItalic;
|
|
plfDest->lfUnderline = plfSrc->lfUnderline;
|
|
plfDest->lfStrikeOut = plfSrc->lfStrikeOut;
|
|
plfDest->lfCharSet = plfSrc->lfCharSet;
|
|
plfDest->lfOutPrecision = plfSrc->lfOutPrecision;
|
|
plfDest->lfClipPrecision = plfSrc->lfClipPrecision;
|
|
plfDest->lfQuality = plfSrc->lfQuality;
|
|
plfDest->lfPitchAndFamily = plfSrc->lfPitchAndFamily;
|
|
ZeroMemory (plfDest->lfFaceName, sizeof(plfDest->lfFaceName));
|
|
|
|
if (0 == MultiByteToWideChar (GetACP(),
|
|
0,
|
|
plfSrc->lfFaceName,
|
|
-1,
|
|
plfDest->lfFaceName,
|
|
sizeof (plfDest->lfFaceName) / sizeof (WCHAR)))
|
|
return GetLastError();
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: ConvertNonClientMetrics
|
|
//
|
|
// Synopsis: convert Win9x client metrics to NT formats
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
void ConvertNonClientMetrics (NONCLIENTMETRICSW *Dest, NONCLIENTMETRICSA *Src)
|
|
{
|
|
Dest->cbSize = sizeof (NONCLIENTMETRICSW);
|
|
Dest->iBorderWidth = Src->iBorderWidth;
|
|
Dest->iScrollWidth = Src->iScrollWidth;
|
|
Dest->iScrollHeight = Src->iScrollHeight;
|
|
Dest->iCaptionWidth = Src->iCaptionWidth;
|
|
Dest->iCaptionHeight = Src->iCaptionHeight;
|
|
Dest->iSmCaptionWidth = Src->iSmCaptionWidth;
|
|
Dest->iSmCaptionHeight = Src->iSmCaptionHeight;
|
|
Dest->iMenuWidth = Src->iMenuWidth;
|
|
Dest->iMenuHeight = Src->iMenuHeight;
|
|
|
|
ConvertLF (&Dest->lfCaptionFont, &Src->lfCaptionFont);
|
|
ConvertLF (&Dest->lfSmCaptionFont, &Src->lfSmCaptionFont);
|
|
ConvertLF (&Dest->lfMenuFont, &Src->lfMenuFont);
|
|
ConvertLF (&Dest->lfStatusFont, &Src->lfStatusFont);
|
|
ConvertLF (&Dest->lfMessageFont, &Src->lfMessageFont);
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: ConvertAppearanceScheme
|
|
//
|
|
// Synopsis: convert Win9x schemes to NT formats
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD ConvertAppearanceScheme (DWORD *ptype, BYTE **pdata, DWORD *pdata_len)
|
|
{
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
DWORD dwSize = *pdata_len;
|
|
|
|
if (*ptype == REG_BINARY &&
|
|
(dwSize == sizeof(SCHEMEDATA_V1) ||
|
|
dwSize == sizeof(SCHEMEDATA_V3) ||
|
|
dwSize == sizeof(SCHEMEDATA_V4) ||
|
|
dwSize == sizeof(SCHEMEDATA_V1A)))
|
|
{
|
|
SCHEMEDATA_NT sd_nt;
|
|
SCHEMEDATA_V1 * psd_v1;
|
|
SCHEMEDATA_V3 * psd_v3;
|
|
SCHEMEDATA_V4 * psd_v4;
|
|
SCHEMEDATA_V1A * psd_v1a;
|
|
BOOL Copy3dValues = FALSE;
|
|
BOOL shouldChange = TRUE;
|
|
|
|
psd_v1 = (SCHEMEDATA_V1 *) *pdata;
|
|
if (psd_v1->version == 1)
|
|
{
|
|
sd_nt.version = 2;
|
|
ConvertNonClientMetrics (&sd_nt.ncm, &psd_v1->ncm);
|
|
ConvertLFShort (&sd_nt.lfIconTitle, &psd_v1->lfIconTitle);
|
|
|
|
ZeroMemory (sd_nt.rgb, sizeof (sd_nt.rgb));
|
|
CopyMemory ( &sd_nt.rgb, &psd_v1->rgb,
|
|
min (sizeof (psd_v1->rgb), sizeof (sd_nt.rgb)));
|
|
|
|
Copy3dValues = TRUE;
|
|
}
|
|
else if (psd_v1->version == 3 && dwSize==sizeof(SCHEMEDATA_V1A))
|
|
{
|
|
psd_v1a = (PSCHEMEDATA_V1A) psd_v1;
|
|
sd_nt.version = 2;
|
|
ConvertNonClientMetrics (&sd_nt.ncm, &psd_v1a->ncm);
|
|
ConvertLFShort (&sd_nt.lfIconTitle, &psd_v1a->lfIconTitle);
|
|
|
|
ZeroMemory (sd_nt.rgb, sizeof (sd_nt.rgb));
|
|
CopyMemory ( &sd_nt.rgb, &psd_v1a->rgb,
|
|
min (sizeof (psd_v1a->rgb), sizeof (sd_nt.rgb)) );
|
|
|
|
Copy3dValues = TRUE;
|
|
}
|
|
else if (psd_v1->version == 3 && dwSize==sizeof(SCHEMEDATA_V3))
|
|
{
|
|
psd_v3 = (PSCHEMEDATA_V3) psd_v1;
|
|
|
|
sd_nt.version = 2;
|
|
ConvertNonClientMetrics (&sd_nt.ncm, &psd_v3->ncm);
|
|
ConvertLF (&sd_nt.lfIconTitle, &psd_v3->lfIconTitle);
|
|
|
|
ZeroMemory (sd_nt.rgb, sizeof (sd_nt.rgb));
|
|
CopyMemory ( &sd_nt.rgb, &psd_v3->rgb,
|
|
min (sizeof (psd_v3->rgb), sizeof (sd_nt.rgb)) );
|
|
|
|
Copy3dValues = TRUE;
|
|
|
|
}
|
|
else if (psd_v1->version == 4)
|
|
{
|
|
psd_v4 = (PSCHEMEDATA_V4) psd_v1;
|
|
|
|
sd_nt.version = 2;
|
|
ConvertNonClientMetrics (&sd_nt.ncm, &psd_v4->ncm);
|
|
ConvertLF (&sd_nt.lfIconTitle, &psd_v4->lfIconTitle);
|
|
|
|
ZeroMemory (sd_nt.rgb, sizeof (sd_nt.rgb));
|
|
CopyMemory ( &sd_nt.rgb, &psd_v4->rgb,
|
|
min (sizeof (psd_v4->rgb), sizeof (sd_nt.rgb)) );
|
|
}
|
|
else shouldChange = FALSE;
|
|
|
|
if (Copy3dValues)
|
|
{
|
|
//
|
|
// Make sure the NT structure has values for 3D colors
|
|
//
|
|
|
|
sd_nt.rgb[COLOR_HOTLIGHT] = sd_nt.rgb[COLOR_ACTIVECAPTION];
|
|
sd_nt.rgb[COLOR_GRADIENTACTIVECAPTION] =
|
|
sd_nt.rgb[COLOR_ACTIVECAPTION];
|
|
sd_nt.rgb[COLOR_GRADIENTINACTIVECAPTION] =
|
|
sd_nt.rgb[COLOR_INACTIVECAPTION];
|
|
}
|
|
if (shouldChange)
|
|
{
|
|
BYTE *pnew_data;
|
|
if (NULL == (pnew_data = (BYTE *)malloc (sizeof(sd_nt))))
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
|
|
CopyMemory (pnew_data, &sd_nt, sizeof(sd_nt));
|
|
|
|
free (*pdata);
|
|
*pdata = pnew_data;
|
|
*pdata_len = sizeof(sd_nt);
|
|
}
|
|
}
|
|
else if (Verbose)
|
|
printf ("ConvertAppearanceScheme type=%d, size=%d\n",*ptype,*pdata_len);
|
|
return dwErr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: ConvertRecentDocsMRU
|
|
//
|
|
// Synopsis: convert Win9x "Start Menu" "Documents" settings
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD ConvertRecentDocsMRU (DWORD *ptype, BYTE **pdata, DWORD *pdata_len)
|
|
{
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
|
|
if (*ptype == REG_BINARY)
|
|
{
|
|
LINKSTRUCT *pls95, *plsNT;
|
|
CHAR *str, *strEnd;
|
|
WCHAR *wstr, *wstrEnd;
|
|
DWORD dwLinkSize, dwNewSize;
|
|
DWORD dwRenewSize;
|
|
|
|
str = (CHAR *) *pdata;
|
|
dwNewSize = strlen(str);
|
|
strEnd = str + dwNewSize;
|
|
|
|
pls95 = (LINKSTRUCT *) strEnd;
|
|
dwLinkSize = dwNewSize + 1 + pls95->wSize + sizeof (WORD);
|
|
|
|
if (dwLinkSize != *pdata_len)
|
|
{
|
|
return ERROR_SUCCESS; // length mismatch, do not transform
|
|
}
|
|
|
|
dwNewSize = MultiByteToWideChar (GetACP(),0,str,-1, NULL, 0);
|
|
if (dwNewSize == 0)
|
|
return GetLastError();
|
|
|
|
if (NULL == (wstr = (WCHAR *) malloc (
|
|
(dwNewSize + 1)*sizeof(WCHAR) + dwLinkSize)))
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
|
|
if (0 == MultiByteToWideChar (GetACP(),0,str,-1,wstr,dwNewSize))
|
|
dwErr = GetLastError();
|
|
|
|
if (ERROR_SUCCESS == dwErr)
|
|
{
|
|
wstrEnd = wstr + wcslen(wstr);
|
|
|
|
plsNT = (PLINKSTRUCT) ((LPBYTE) wstr + ((DWORD)(wstrEnd-wstr)));
|
|
CopyMemory (plsNT, pls95, dwLinkSize);
|
|
|
|
free (*pdata);
|
|
*pdata = (BYTE *) wstr;
|
|
*pdata_len = dwNewSize;
|
|
}
|
|
else free (wstr);
|
|
}
|
|
|
|
return dwErr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: ConvertLogFont
|
|
//
|
|
// Synopsis: convert Win9x font binary data
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD ConvertLogFont (DWORD *ptype, BYTE **pdata, DWORD *pdata_len)
|
|
{
|
|
if (*ptype == REG_BINARY && *pdata_len == sizeof(SHORT_LOGFONT))
|
|
{
|
|
BYTE *pnew_data;
|
|
LOGFONTW lfNT;
|
|
ConvertLFShort (&lfNT, (SHORT_LOGFONT *) *pdata);
|
|
|
|
if (NULL == (pnew_data = (BYTE *)malloc (sizeof(lfNT))))
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
|
|
CopyMemory (pnew_data, &lfNT, sizeof(lfNT));
|
|
|
|
free (*pdata);
|
|
*pdata = pnew_data;
|
|
*pdata_len = sizeof(lfNT);
|
|
}
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: ConvertToDword
|
|
//
|
|
// Synopsis: convert string data to DWORD
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD ConvertToDword (DWORD *ptype, BYTE **pdata, DWORD *pdata_len)
|
|
{
|
|
if (*ptype == REG_SZ || *ptype == REG_EXPAND_SZ)
|
|
{
|
|
BYTE *pnew_data;
|
|
DWORD dwValue = _tcstoul ((PCTSTR) *pdata, NULL, 10);
|
|
if (NULL == (pnew_data = (BYTE *)malloc (sizeof(dwValue))))
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
|
|
CopyMemory (pnew_data, &dwValue, sizeof(dwValue));
|
|
|
|
free (*pdata);
|
|
*pdata = pnew_data;
|
|
*pdata_len = sizeof(dwValue);
|
|
*ptype = REG_DWORD;
|
|
}
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: ConvertToString
|
|
//
|
|
// Synopsis: convert DWORD to a string
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD ConvertToString (DWORD *ptype, BYTE **pdata, DWORD *pdata_len)
|
|
{
|
|
if (*ptype == REG_DWORD)
|
|
{
|
|
BYTE *pnew_data;
|
|
DWORD dwSize;
|
|
TCHAR tcsValue[16];
|
|
wsprintf (tcsValue, TEXT("%lu"), * ((DWORD *) *pdata));
|
|
|
|
dwSize = (_tcslen (tcsValue) + 1) * sizeof(TCHAR);
|
|
|
|
if (NULL == (pnew_data = (BYTE *)malloc (dwSize)))
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
|
|
CopyMemory (pnew_data, tcsValue, dwSize);
|
|
|
|
free (*pdata);
|
|
*pdata = pnew_data;
|
|
*pdata_len = dwSize;
|
|
*ptype = REG_SZ;
|
|
}
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: AntiAlias
|
|
//
|
|
// Synopsis: convert FontSmoothing from "1" to "2"
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD AntiAlias (DWORD *ptype, BYTE **pdata, DWORD *pdata_len)
|
|
{
|
|
if (*ptype == REG_SZ)
|
|
{
|
|
DWORD dwValue = _tcstoul ((TCHAR *) *pdata, NULL, 10);
|
|
if (dwValue > 0)
|
|
wsprintf ((TCHAR *) *pdata, TEXT("%d"), FE_AA_ON);
|
|
}
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Function: FixActiveDesktop
|
|
//
|
|
// Synopsis: convert active desktop blob
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
DWORD FixActiveDesktop (DWORD *ptype, BYTE **pdata, DWORD *pdata_len)
|
|
{
|
|
const USHORT BadBufferSize = 16;
|
|
const USHORT GoodBufferSize = 28;
|
|
|
|
BYTE BadBuffer[BadBufferSize] =
|
|
{0x10, 0x00, 0x00, 0x00,
|
|
0x01, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00};
|
|
|
|
BYTE GoodBuffer[GoodBufferSize] =
|
|
{0x1C, 0x00, 0x00, 0x00,
|
|
0x20, 0x08, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00,
|
|
0x00, 0x00, 0x00, 0x00,
|
|
0x0A, 0x00, 0x00, 0x00};
|
|
|
|
if (*ptype == REG_BINARY && *pdata_len == BadBufferSize)
|
|
{
|
|
BOOL shouldChange = TRUE;
|
|
for (USHORT i = 0; i < BadBufferSize; i++)
|
|
{
|
|
if ((*pdata)[i] != BadBuffer[i])
|
|
{
|
|
shouldChange = FALSE;
|
|
break;
|
|
}
|
|
}
|
|
if (shouldChange)
|
|
{
|
|
BYTE *pnew_data;
|
|
if (NULL == (pnew_data = (BYTE *)malloc (sizeof(GoodBuffer))))
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
|
|
CopyMemory (pnew_data, GoodBuffer, sizeof(GoodBuffer));
|
|
|
|
free (*pdata);
|
|
*pdata = pnew_data;
|
|
*pdata_len = sizeof(GoodBuffer);
|
|
}
|
|
}
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Function: LoadTimeZone
|
|
//
|
|
// Synopsis: set the current timezone
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
DWORD LoadTimeZone ()
|
|
{
|
|
const int TZNAME_SIZE = 32;
|
|
const TCHAR REGKEY_TIMEZONES[] =
|
|
_T("Software\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones");
|
|
|
|
const TCHAR REGVAL_TZI[] = _T("TZI");
|
|
const TCHAR REGVAL_DLT[] = _T("Dlt");
|
|
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
const int LINEBUFSIZE = 1024;
|
|
HKEY hKey = NULL;
|
|
INFCONTEXT InfContext;
|
|
TCHAR tcsTimeZone[LINEBUFSIZE];
|
|
TIME_ZONE_INFORMATION tzi;
|
|
APPLET_TIME_ZONE_INFORMATION atzi;
|
|
|
|
if (TIME_ZONE_ID_INVALID == GetTimeZoneInformation (&tzi))
|
|
{
|
|
Win32Printf (LogFile, "Could not get time zone information\r\n");
|
|
ChkErr (GetLastError());
|
|
}
|
|
|
|
if (SetupFindFirstLine(InputInf, SOURCE_SECTION, TIMEZONE, &InfContext))
|
|
{
|
|
TCHAR *buffer = NULL;
|
|
TCHAR *buffer2 = NULL;
|
|
|
|
ChkErr (GetInfField (&buffer, &InfContext, 1));
|
|
|
|
if (lstrcmp (tzi.StandardName, buffer) != 0)
|
|
{
|
|
|
|
_tcsncpy (tcsTimeZone, (TCHAR*) REGKEY_TIMEZONES, LINEBUFSIZE);
|
|
_tcsncat (tcsTimeZone, TEXT("\\"),
|
|
LINEBUFSIZE - _tcslen(tcsTimeZone) - 1);
|
|
_tcsncat (tcsTimeZone, buffer,
|
|
LINEBUFSIZE - _tcslen(tcsTimeZone) - 1);
|
|
|
|
if (RegOpenKey (HKEY_LOCAL_MACHINE, tcsTimeZone, &hKey) ==
|
|
ERROR_SUCCESS)
|
|
{
|
|
ULONG ulLen = sizeof(atzi);
|
|
if (ERROR_SUCCESS == RegQueryValueEx(hKey,
|
|
REGVAL_TZI, 0, NULL, (LPBYTE)&atzi, &ulLen))
|
|
{
|
|
tzi.Bias = atzi.Bias;
|
|
tzi.StandardBias = atzi.StandardBias;
|
|
tzi.DaylightBias = atzi.DaylightBias;
|
|
tzi.StandardDate = atzi.StandardDate;
|
|
tzi.DaylightDate = atzi.DaylightDate;
|
|
_tcsncpy (tzi.StandardName, buffer, TZNAME_SIZE);
|
|
|
|
ULONG ulLen = TZNAME_SIZE;
|
|
if (ERROR_SUCCESS != RegQueryValueEx(hKey, REGVAL_DLT,
|
|
0, NULL, (LPBYTE) &tzi.DaylightName, &ulLen))
|
|
_tcscpy (tzi.DaylightName, TEXT(""));
|
|
|
|
// SetTimeZoneInformation will update local time
|
|
// since the UTC time has not changed
|
|
if (FALSE == SetTimeZoneInformation (&tzi))
|
|
dwErr = GetLastError();
|
|
|
|
if (Verbose)
|
|
printf ("TimeZone = %ws\n", tzi.StandardName);
|
|
}
|
|
}
|
|
}
|
|
free (buffer);
|
|
}
|
|
|
|
Err:
|
|
if (hKey != NULL)
|
|
RegCloseKey (hKey);
|
|
return dwErr;
|
|
}
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Function: SaveLocaleInfo
|
|
//
|
|
// Synopsis: formats a locale setting for registry update
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
DWORD SaveLocaleInfo(HKEY hKey, LCID lcid, LCTYPE LCType, TCHAR *pIniString)
|
|
{
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
TCHAR ptcsBuffer[SIZE_128];
|
|
|
|
if (GetLocaleInfo( lcid,
|
|
LCType | LOCALE_NOUSEROVERRIDE,
|
|
ptcsBuffer,
|
|
SIZE_128 ))
|
|
{
|
|
dwErr = RegSetValueEx( hKey,
|
|
pIniString,
|
|
0L,
|
|
REG_SZ,
|
|
(BYTE *)ptcsBuffer,
|
|
(lstrlen(ptcsBuffer)+1) * sizeof(TCHAR));
|
|
}
|
|
return dwErr;
|
|
}
|
|
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Function: LoadInstallUserLocale
|
|
//
|
|
// Synopsis: sets the current user locale
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
DWORD LoadInstallUserLocale ()
|
|
{
|
|
HKEY hKey = NULL;
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
LCID lcid = 0;
|
|
TCHAR *ptcsUserLocale = NULL;
|
|
TCHAR ptcsOldLocale[25];
|
|
INFCONTEXT infcontext;
|
|
ULONG ulLen = 0;
|
|
|
|
if (SetupFindFirstLine(InputInf, SOURCE_SECTION, USERLOCALE, &infcontext))
|
|
{
|
|
dwErr = GetInfField (&ptcsUserLocale, &infcontext, 1);
|
|
if (ERROR_SUCCESS == dwErr)
|
|
{
|
|
lcid = (LCID)_tcstoul(ptcsUserLocale,NULL,16);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Revert to current user locale if missing from INF
|
|
//
|
|
if (lcid == 0)
|
|
{
|
|
free (ptcsUserLocale);
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Make sure the locale is valid.
|
|
//
|
|
if (!IsValidLocale(lcid, LCID_INSTALLED))
|
|
{
|
|
ChkErr (ERROR_INSTALL_LANGUAGE_UNSUPPORTED);
|
|
}
|
|
|
|
//
|
|
// Set the locale value in the user's control panel international
|
|
// section of the registry.
|
|
//
|
|
ChkErr(RegOpenKeyEx(CurrentUser ? CurrentUser : HKEY_CURRENT_USER,
|
|
REGKEY_INTL,
|
|
0L,
|
|
KEY_READ | KEY_WRITE,
|
|
&hKey ));
|
|
|
|
//
|
|
// Update user locale only if it's different
|
|
//
|
|
ulLen = sizeof (ptcsOldLocale);
|
|
if (ERROR_SUCCESS == RegQueryValueEx(hKey,
|
|
TEXT("Locale"),
|
|
NULL,NULL,
|
|
(BYTE*)ptcsOldLocale, &ulLen) &&
|
|
lstrcmp (ptcsUserLocale, ptcsOldLocale) == 0)
|
|
{
|
|
free (ptcsUserLocale);
|
|
RegCloseKey (hKey);
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
ChkErr (RegSetValueEx( hKey,
|
|
TEXT("Locale"),
|
|
0L,
|
|
REG_SZ,
|
|
(LPBYTE)ptcsUserLocale,
|
|
(lstrlen(ptcsUserLocale)+1) * sizeof(TCHAR)));
|
|
|
|
//
|
|
// When the locale changes, update ALL registry information.
|
|
//
|
|
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_ICALENDARTYPE, TEXT("iCalendarType")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_ICOUNTRY, TEXT("iCountry")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_ICURRDIGITS, TEXT("iCurrDigits")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_ICURRENCY, TEXT("iCurrency")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_IDATE, TEXT("iDate")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_IDIGITS, TEXT("iDigits")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_IFIRSTDAYOFWEEK, TEXT("iFirstDayOfWeek" )));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_IFIRSTWEEKOFYEAR, TEXT("iFirstWeekOfYear")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_ILZERO, TEXT("iLzero")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_IMEASURE, TEXT("iMeasure")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_INEGCURR, TEXT("iNegCurr")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_INEGNUMBER, TEXT("iNegNumber")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_ITIME, TEXT("iTime")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_ITIMEMARKPOSN, TEXT("iTimePrefix")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_ITLZERO, TEXT("iTLZero")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_IDIGITSUBSTITUTION,TEXT("NumShape")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_S1159, TEXT("s1159")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_S2359, TEXT("s2359")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_SCOUNTRY, TEXT("sCountry")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_SCURRENCY, TEXT("sCurrency")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_SDATE, TEXT("sDate")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_SDECIMAL, TEXT("sDecimal")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_SGROUPING, TEXT("sGrouping")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_SABBREVLANGNAME, TEXT("sLanguage")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_SLIST, TEXT("sList")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_SLONGDATE, TEXT("sLongDate")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_SMONDECIMALSEP, TEXT("sMonDecimalSep")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_SMONGROUPING, TEXT("sMonGrouping")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_SMONTHOUSANDSEP, TEXT("sMonThousandSep")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_SNATIVEDIGITS, TEXT("sNativeDigits")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_SNEGATIVESIGN, TEXT("sNegativeSign")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_SPOSITIVESIGN, TEXT("sPositiveSign")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_SSHORTDATE, TEXT("sShortDate")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_STHOUSAND, TEXT("sThousand")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_STIME, TEXT("sTime")));
|
|
ChkErr(SaveLocaleInfo(hKey, lcid, LOCALE_STIMEFORMAT, TEXT("sTimeFormat")));
|
|
|
|
//
|
|
// Set the user's default locale in the system so that any new
|
|
// process will use the new locale.
|
|
//
|
|
if (CurrentUser == HKEY_CURRENT_USER)
|
|
NtSetDefaultLocale(TRUE, lcid);
|
|
|
|
Err:
|
|
//
|
|
// Flush the International key.
|
|
//
|
|
if (hKey != NULL)
|
|
{
|
|
RegFlushKey(hKey);
|
|
RegCloseKey(hKey);
|
|
}
|
|
|
|
if (ptcsUserLocale != NULL)
|
|
free (ptcsUserLocale);
|
|
|
|
//
|
|
// Return success.
|
|
//
|
|
return (dwErr);
|
|
}
|
|
|
|
#if 0
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Function: ReadVersionKey
|
|
//
|
|
// Synopsis: helper function that reads a value in CurrentVersion key
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
DWORD ReadVersionKey (TCHAR *pValueName, TCHAR *pValue, ULONG ulLen)
|
|
{
|
|
HKEY hKey = NULL;
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
static const TCHAR REGKEY_VERSION[] =
|
|
TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion");
|
|
|
|
ChkErr (RegOpenKeyEx(HKEY_LOCAL_MACHINE, REGKEY_VERSION,
|
|
NULL, KEY_READ, &hKey));
|
|
ChkErr (RegQueryValueEx(hKey,pValueName,NULL,NULL,(BYTE*)pValue, &ulLen));
|
|
Err:
|
|
if (hKey != NULL)
|
|
RegCloseKey (hKey);
|
|
return dwErr;
|
|
}
|
|
#endif
|
|
|
|
#if 0
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Function: GetDomainMembershipInfo
|
|
//
|
|
// Synopsis: return domain or workgroup name
|
|
//
|
|
// Arguments: [szname] -- output string for sysprep
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
NTSTATUS GetDomainMembershipInfo (TCHAR *szName)
|
|
{
|
|
NTSTATUS ntstatus;
|
|
POLICY_PRIMARY_DOMAIN_INFO* ppdi;
|
|
LSA_OBJECT_ATTRIBUTES loa;
|
|
LSA_HANDLE hLsa = 0;
|
|
|
|
loa.Length = sizeof(LSA_OBJECT_ATTRIBUTES);
|
|
loa.RootDirectory = NULL;
|
|
loa.ObjectName = NULL;
|
|
loa.Attributes = 0;
|
|
loa.SecurityDescriptor = NULL;
|
|
loa.SecurityQualityOfService = NULL;
|
|
|
|
ntstatus = LsaOpenPolicy(NULL, &loa, POLICY_VIEW_LOCAL_INFORMATION, &hLsa);
|
|
if (LSA_SUCCESS(ntstatus))
|
|
{
|
|
ntstatus = LsaQueryInformationPolicy( hLsa,
|
|
PolicyPrimaryDomainInformation,
|
|
(VOID **) &ppdi );
|
|
if( LSA_SUCCESS( ntstatus ) )
|
|
{
|
|
lstrcpy (szName, (ppdi->Sid > 0 ) ? TEXT("JoinDomain=") :
|
|
TEXT("JoinWorkgroup="));
|
|
lstrcat( szName, ppdi->Name.Buffer );
|
|
}
|
|
LsaClose (hLsa);
|
|
}
|
|
return (ntstatus);
|
|
}
|
|
#endif
|
|
|
|
#if 0
|
|
//+--------------------------------------------------------------------------
|
|
//
|
|
// Function: SysprepFile
|
|
//
|
|
// Synopsis: generates the sysprep unattended file
|
|
//
|
|
// Arguments: [dwLangGroup] -- language group to install
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
DWORD SysprepFile (DWORD dwLangGroup)
|
|
{
|
|
HANDLE hFile = INVALID_HANDLE_VALUE;
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
DWORD dwTimeZone = 0;
|
|
INFCONTEXT InfContext;
|
|
TCHAR * pFullName = NULL;
|
|
TCHAR * pOrgName = NULL;
|
|
const int MAX_WORKGROUP_LENGTH = 15;
|
|
const int NAME_LENGTH = 128;
|
|
const TCHAR REGVAL_FULLNAME[] = TEXT("RegisteredOwner");
|
|
const TCHAR REGVAL_ORGNAME[] = TEXT("RegisteredOrganization");
|
|
const TCHAR REGVAL_INSTALLPATH[] = TEXT("SourcePath");
|
|
TCHAR szFullName[NAME_LENGTH] = TEXT("");
|
|
TCHAR szOrgName[NAME_LENGTH] = TEXT("");
|
|
TCHAR szInstall[MAX_PATH];
|
|
TCHAR szTargetPath[MAX_PATH];
|
|
TCHAR szComputerName[NAME_LENGTH];
|
|
TCHAR *pTargetPath;
|
|
CHAR *pFile = NULL;
|
|
ULONG ulLen;
|
|
TCHAR szJoin [MAX_WORKGROUP_LENGTH + 1 + NAME_LENGTH];
|
|
|
|
CHAR szSysprep[] = "[Unattended]\r\n"
|
|
"OemSkipEula=Yes\r\n"
|
|
"InstallFilesPath=%ws\r\n"
|
|
"TargetPath=%ws\r\n"
|
|
"\r\n"
|
|
"[GuiUnattended]\r\n"
|
|
"AdminPassword=*\r\n"
|
|
"OEMSkipRegional=1\r\n"
|
|
"TimeZone=%x\r\n"
|
|
"OemSkipWelcome=1\r\n"
|
|
"\r\n"
|
|
"[UserData]\r\n"
|
|
"FullName=\"%ws\"\r\n"
|
|
"OrgName=\"%ws\"\r\n"
|
|
"ComputerName=%ws\r\n"
|
|
"\r\n"
|
|
"[Identification]\r\n"
|
|
"%ws\r\n"
|
|
"\r\n"
|
|
"[RegionalSettings]\r\n"
|
|
"LanguageGroup=%d\r\n"
|
|
"\r\n"
|
|
"[Networking]\r\n"
|
|
"InstallDefaultComponents=Yes\r\n";
|
|
|
|
|
|
if (FALSE == GetWindowsDirectory ((TCHAR*) szTargetPath, MAX_PATH))
|
|
ChkErr (GetLastError());
|
|
|
|
if (szTargetPath[1] == ':' && szTargetPath[2] == '\\')
|
|
pTargetPath = &szTargetPath[2];
|
|
else
|
|
pTargetPath = &szTargetPath[0];
|
|
|
|
ulLen = NAME_LENGTH;
|
|
if (FALSE == GetComputerName ((TCHAR*) szComputerName, &ulLen))
|
|
ChkErr (GetLastError());
|
|
|
|
if (SetupFindFirstLine(InputInf, SOURCE_SECTION, FULLNAME, &InfContext))
|
|
{
|
|
ChkErr (GetInfField (&pFullName, &InfContext, 1));
|
|
}
|
|
else // use the current fullname
|
|
{
|
|
ChkErr(ReadVersionKey((TCHAR*)REGVAL_FULLNAME,
|
|
szFullName, sizeof(szFullName)));
|
|
pFullName = szFullName;
|
|
}
|
|
|
|
if (SetupFindFirstLine(InputInf, SOURCE_SECTION, ORGNAME, &InfContext))
|
|
{
|
|
ChkErr (GetInfField (&pOrgName, &InfContext, 1));
|
|
}
|
|
else // use the current org name
|
|
{
|
|
ChkErr(ReadVersionKey((TCHAR*)REGVAL_ORGNAME,
|
|
szFullName, sizeof(szFullName)));
|
|
pFullName = szOrgName;
|
|
}
|
|
|
|
if (ERROR_SUCCESS != ReadVersionKey((TCHAR*)REGVAL_INSTALLPATH,
|
|
szInstall, sizeof(szInstall)))
|
|
{
|
|
lstrcpy ((TCHAR *)szInstall, TEXT("")); // prompt for media?
|
|
}
|
|
|
|
if(!LSA_SUCCESS(GetDomainMembershipInfo(szJoin)))
|
|
lstrcpy (szJoin, TEXT(""));
|
|
|
|
if ((pFile = (CHAR *) malloc (4096)) == NULL)
|
|
ChkErr (ERROR_NOT_ENOUGH_MEMORY);
|
|
|
|
wsprintfA (pFile, szSysprep, szInstall, pTargetPath, dwTimeZone,
|
|
pFullName, pOrgName, szComputerName, szJoin, dwLangGroup);
|
|
|
|
hFile = CreateFile (
|
|
TEXT("sysprep.inf"),
|
|
GENERIC_READ | GENERIC_WRITE,
|
|
0, // No sharing.
|
|
NULL, // No inheritance
|
|
CREATE_ALWAYS,
|
|
FILE_ATTRIBUTE_NORMAL,
|
|
NULL // No template file.
|
|
);
|
|
|
|
if (INVALID_HANDLE_VALUE == hFile)
|
|
ChkErr (GetLastError());
|
|
|
|
if (FALSE == WriteFile (hFile, pFile, lstrlenA(pFile), &ulLen, NULL))
|
|
ChkErr (GetLastError());
|
|
|
|
Err:
|
|
if (pFullName != NULL)
|
|
free (pFullName);
|
|
if (pOrgName != NULL)
|
|
free (pOrgName);
|
|
if (pFile != NULL)
|
|
free (pFile);
|
|
if (hFile != INVALID_HANDLE_VALUE)
|
|
CloseHandle (hFile);
|
|
return dwErr;
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Function: LoadSystem
|
|
//
|
|
// Synopsis: load system settings
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: Appropriate status code
|
|
//
|
|
// History: 20-Sep-99 HenryLee Created
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
DWORD LoadSystem(int argc, char *argv[])
|
|
{
|
|
DWORD dwErr = ERROR_SUCCESS;
|
|
DWORD ccLen;
|
|
WCHAR *pBuf = NULL;
|
|
HKEY hKey;
|
|
WCHAR *pwMigrationPath = NULL;
|
|
int i;
|
|
DWORD dwInfCount = 0;
|
|
|
|
if ((dwErr = LoadVerifyOSLang()) != ERROR_SUCCESS)
|
|
return dwErr;
|
|
|
|
// If the schedule flag is set, write a run once to schedule
|
|
// applying the system settings.
|
|
if (SchedSystem)
|
|
{
|
|
WCHAR wcsModule[MAX_PATH];
|
|
DWORD ccModule = MAX_PATH;
|
|
|
|
if (0 == GetModuleFileName (NULL, wcsModule, ccModule))
|
|
{
|
|
dwErr = GetLastError();
|
|
goto cleanup;
|
|
}
|
|
|
|
|
|
// Convert the migration path to unicode.
|
|
dwErr = MakeUnicode( MigrationPath, &pwMigrationPath );
|
|
|
|
if (dwErr != ERROR_SUCCESS)
|
|
goto cleanup;
|
|
|
|
// Build a command line containing:
|
|
// /p parameter, to indicate running the user portion
|
|
// /s parameter, to indicate migrating system settings
|
|
// path to migration.inf
|
|
ccLen = wcslen(wcsModule) + wcslen(SCHED_PARAMS) + 1;
|
|
pBuf = (WCHAR *) malloc( ccLen * sizeof(WCHAR) );
|
|
if (pBuf == NULL)
|
|
{
|
|
dwErr = ERROR_NOT_ENOUGH_MEMORY;
|
|
goto cleanup;
|
|
}
|
|
wcscpy( pBuf, wcsModule );
|
|
wcscat( pBuf, SCHED_PARAMS);
|
|
|
|
// Open the run once key.
|
|
dwErr = RegOpenKeyEx(CurrentUser ? CurrentUser : HKEY_CURRENT_USER,
|
|
L"Software\\Microsoft\\Windows\\CurrentVersion\\RunOnce",
|
|
0, KEY_WRITE, &hKey );
|
|
if (dwErr != ERROR_SUCCESS)
|
|
goto cleanup;
|
|
|
|
// Write the command to the registry.
|
|
dwErr = RegSetValueEx( hKey, TEXT("loadstate"), 0, REG_SZ,
|
|
(UCHAR *) pBuf, ccLen*sizeof(WCHAR) );
|
|
if (dwErr != ERROR_SUCCESS)
|
|
goto cleanup;
|
|
RegCloseKey( hKey );
|
|
|
|
dwErr = RegCreateKeyEx(CurrentUser ? CurrentUser : HKEY_CURRENT_USER,
|
|
L"Software\\Microsoft\\Windows\\CurrentVersion\\Loadstate",
|
|
0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, NULL );
|
|
if (dwErr != ERROR_SUCCESS)
|
|
goto cleanup;
|
|
|
|
// Write LogFile path to registry
|
|
dwErr = RegSetValueEx( hKey, TEXT("Logfile"), 0, REG_SZ,
|
|
(UCHAR *)szLogFile, (_tcslen(szLogFile) * sizeof(TCHAR)) );
|
|
if (dwErr != ERROR_SUCCESS)
|
|
goto cleanup;
|
|
|
|
// Write Migration path to registry
|
|
dwErr = RegSetValueEx( hKey, TEXT("Store"), 0, REG_SZ,
|
|
(UCHAR *)pwMigrationPath, (_tcslen(pwMigrationPath) * sizeof(TCHAR)) );
|
|
if (dwErr != ERROR_SUCCESS)
|
|
goto cleanup;
|
|
|
|
TCHAR szInfFile[MAX_PATH + 1];
|
|
TCHAR szFullInfFile[MAX_PATH + 1];
|
|
TCHAR szKeyName[6];
|
|
TCHAR *ptsFileNamePart;
|
|
|
|
// Prevent KeyName buffer overflow
|
|
if ( argc > 99)
|
|
{
|
|
if (Verbose)
|
|
{
|
|
Win32Printf(LogFile, "ERROR: Too many command line arguments [%d]\r\n", argc);
|
|
}
|
|
dwErr = ERROR_INVALID_PARAMETER;
|
|
goto cleanup;
|
|
}
|
|
|
|
// Write InfFile paths to registry
|
|
for (i = 1; i < argc; i++)
|
|
{
|
|
if ((argv[i][0] == '/' || argv[i][0] == '-') &&
|
|
(tolower(argv[i][1]) == 'i'))
|
|
{
|
|
i++;
|
|
_stprintf(szKeyName, TEXT("Inf%d"), ++dwInfCount);
|
|
|
|
if (0 == MultiByteToWideChar (GetACP(), 0, argv[i], -1, szInfFile, MAX_PATH))
|
|
{
|
|
dwErr = GetLastError();
|
|
goto cleanup;
|
|
}
|
|
dwErr = GetFullPathName( szInfFile,
|
|
MAX_PATH,
|
|
szFullInfFile,
|
|
&ptsFileNamePart);
|
|
if (0 == dwErr)
|
|
{
|
|
dwErr = GetLastError();
|
|
goto cleanup;
|
|
}
|
|
dwErr = RegSetValueEx( hKey, szKeyName, 0, REG_SZ,
|
|
(UCHAR *)szFullInfFile, (_tcslen(szFullInfFile) * sizeof(TCHAR)) );
|
|
if (dwErr != ERROR_SUCCESS)
|
|
goto cleanup;
|
|
}
|
|
}
|
|
RegCloseKey( hKey );
|
|
|
|
cleanup:
|
|
if (dwErr != ERROR_SUCCESS)
|
|
LogFormatError (dwErr);
|
|
|
|
free( pBuf );
|
|
free( pwMigrationPath );
|
|
}
|
|
else
|
|
{
|
|
if (!CopySystem)
|
|
return ERROR_SUCCESS;
|
|
|
|
ChkErr (LoadNetShares());
|
|
ChkErr (LoadPrinters());
|
|
|
|
dwErr = InitializeRasApi();
|
|
if ( dwErr == ERROR_SUCCESS )
|
|
{
|
|
ChkErr (LoadRas());
|
|
}
|
|
else
|
|
{
|
|
// No problem, just skip Ras processing
|
|
dwErr = ERROR_SUCCESS;
|
|
}
|
|
|
|
if (CopyUser == FALSE)
|
|
{
|
|
if (CurrentUser == NULL)
|
|
CurrentUser = HKEY_CURRENT_USER;
|
|
|
|
ChkErr(InitializeHash());
|
|
}
|
|
|
|
ChkErr(CopyInf (ACCESS_SECTION));
|
|
ChkErr(CopyInf (DESKTOP_SECTION));
|
|
ChkErr(LoadKeyboardLayouts());
|
|
ChkErr (LoadTimeZone());
|
|
ChkErr (LoadInstallUserLocale());
|
|
}
|
|
|
|
Err:
|
|
return dwErr;
|
|
}
|