3134 lines
74 KiB
C
3134 lines
74 KiB
C
/*++
|
|
|
|
Copyright (c) 1996 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
wkstamig.c
|
|
|
|
Abstract:
|
|
|
|
The functions in this module are called to perform migration of
|
|
system-wide settings.
|
|
|
|
Author:
|
|
|
|
Jim Schmidt (jimschm) 04-Feb-1997
|
|
|
|
Revision History:
|
|
|
|
ovidiut 10-May-1999 Added DoIniActions
|
|
jimschm 16-Dec-1998 Changed ATM font migration to use Adobe's
|
|
APIs.
|
|
jimschm 25-Nov-1998 ATM.INI migration; Win9x hive migration
|
|
jimschm 23-Sep-1998 Consolidated memdb saves into usermig.c
|
|
jimschm 19-Feb-1998 Added "none" group support, fixed
|
|
share problems.
|
|
calinn 12-Dec-1997 Added RestoreMMSettings_System
|
|
|
|
--*/
|
|
|
|
#include "pch.h"
|
|
#include "migmainp.h"
|
|
#include "brfcasep.h"
|
|
|
|
#include <lm.h>
|
|
|
|
//
|
|
// Constants, types, declarations
|
|
//
|
|
|
|
#define W95_ACCESS_READ 0x1
|
|
#define W95_ACCESS_WRITE 0x2
|
|
#define W95_ACCESS_CREATE 0x4
|
|
#define W95_ACCESS_EXEC 0x8
|
|
#define W95_ACCESS_DELETE 0x10
|
|
#define W95_ACCESS_ATRIB 0x20
|
|
#define W95_ACCESS_PERM 0x40
|
|
#define W95_ACCESS_FINDFIRST 0x80
|
|
#define W95_ACCESS_FULL 0xff
|
|
#define W95_ACCESS_GROUP 0x8000
|
|
|
|
#define W95_GENERIC_READ (W95_ACCESS_READ|W95_ACCESS_FINDFIRST)
|
|
#define W95_GENERIC_WRITE (W95_ACCESS_WRITE|W95_ACCESS_CREATE|W95_ACCESS_DELETE|W95_ACCESS_ATRIB)
|
|
#define W95_GENERIC_FULL (W95_GENERIC_READ|W95_GENERIC_WRITE|W95_ACCESS_PERM)
|
|
#define W95_GENERIC_NONE 0
|
|
|
|
#define S_DEFAULT_USER_NAME TEXT("DefaultUserName")
|
|
#define S_DEFAULT_DOMAIN_NAME TEXT("DefaultDomainName")
|
|
|
|
|
|
// from private\net\svcdlls\srvsvc\server
|
|
#define SHARES_REGISTRY_PATH L"LanmanServer\\Shares"
|
|
#define SHARES_SECURITY_REGISTRY_PATH L"LanmanServer\\Shares\\Security"
|
|
#define CSCFLAGS_VARIABLE_NAME L"CSCFlags"
|
|
#define MAXUSES_VARIABLE_NAME L"MaxUses"
|
|
#define PATH_VARIABLE_NAME L"Path"
|
|
#define PERMISSIONS_VARIABLE_NAME L"Permissions"
|
|
#define REMARK_VARIABLE_NAME L"Remark"
|
|
#define TYPE_VARIABLE_NAME L"Type"
|
|
|
|
// Win9x-specific flags for NetShareEnum
|
|
#define SHI50F_RDONLY 0x0001
|
|
#define SHI50F_FULL 0x0002
|
|
#define SHI50F_DEPENDSON (SHI50F_RDONLY|SHI50F_FULL)
|
|
#define SHI50F_ACCESSMASK (SHI50F_RDONLY|SHI50F_FULL)
|
|
|
|
#ifndef UNICODE
|
|
#error UNICODE required
|
|
#endif
|
|
|
|
#define DBG_NETSHARES "NetShares"
|
|
#define DBG_INIFILES "IniFiles"
|
|
|
|
#define S_CLEANER_GUID TEXT("{C0E13E61-0CC6-11d1-BBB6-0060978B2AE6}")
|
|
#define S_CLEANER_ALL_FILES TEXT("*")
|
|
|
|
typedef struct {
|
|
// Enumeration return data
|
|
TCHAR PfmFile[MAX_TCHAR_PATH];
|
|
TCHAR PfbFile[MAX_TCHAR_PATH];
|
|
TCHAR MmmFile[MAX_TCHAR_PATH];
|
|
|
|
TCHAR InfName[MAX_TCHAR_PATH];
|
|
|
|
// Internal state
|
|
PTSTR KeyNames;
|
|
POOLHANDLE Pool;
|
|
} ATM_FONT_ENUM, *PATM_FONT_ENUM;
|
|
|
|
typedef INT (WINAPI ATMADDFONTEXW) (
|
|
IN OUT PWSTR MenuName,
|
|
IN OUT PWORD StyleAndType,
|
|
IN PCWSTR MetricsFile,
|
|
IN PCWSTR FontFile,
|
|
IN PCWSTR MMMFile
|
|
);
|
|
|
|
typedef ATMADDFONTEXW * PATMADDFONTEXW;
|
|
|
|
PATMADDFONTEXW AtmAddFontEx;
|
|
typedef VOID (SHUPDATERECYCLEBINICON_PROTOTYPE)(VOID);
|
|
typedef SHUPDATERECYCLEBINICON_PROTOTYPE * SHUPDATERECYCLEBINICON_PROC;
|
|
|
|
typedef struct {
|
|
// enumeration output
|
|
PCTSTR Source;
|
|
PCTSTR Dest;
|
|
|
|
// private members
|
|
POOLHANDLE Pool;
|
|
INFSTRUCT is;
|
|
} HIVEFILE_ENUM, *PHIVEFILE_ENUM;
|
|
|
|
#define MAX_KEY_NAME_LIST 32768
|
|
|
|
|
|
typedef struct {
|
|
// enumeration output
|
|
PCTSTR BrfcaseDb;
|
|
// private
|
|
MEMDB_ENUM mde;
|
|
} BRIEFCASE_ENUM, *PBRIEFCASE_ENUM;
|
|
|
|
|
|
//
|
|
// Implementation
|
|
//
|
|
|
|
DWORD
|
|
Simplify9xAccessFlags (
|
|
IN DWORD Win9xFlags
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Translates the Win9x LanMan flags into NT LanMan flags (for use with Net* APIs).
|
|
|
|
Full permission requires:
|
|
|
|
W95_ACCESS_READ
|
|
W95_ACCESS_WRITE
|
|
W95_ACCESS_CREATE
|
|
W95_ACCESS_DELETE
|
|
W95_ACCESS_ATRIB
|
|
W95_ACCESS_FINDFIRST
|
|
|
|
Read-only permission requires:
|
|
|
|
W95_ACCESS_READ
|
|
W95_ACCESS_FINDFIRST
|
|
|
|
Change-only permission requires:
|
|
|
|
W95_ACCESS_WRITE
|
|
W95_ACCESS_CREATE
|
|
W95_ACCESS_DELETE
|
|
W95_ACCESS_ATRIB
|
|
|
|
Any other combination results in
|
|
|
|
The returned flags are currently converted to security flags based on the
|
|
following mapping:
|
|
|
|
0 - Deny All Rights
|
|
ACCESS_READ - Read-Only Rights
|
|
ACCESS_WRITE - Change-Only Rights
|
|
ACCESS_READ|ACCESS_WRITE - Full Rights
|
|
|
|
See AddAclMember for details.
|
|
|
|
Arguments:
|
|
|
|
Flags - The set of Win9x flags as returned by an API on Win9x
|
|
|
|
Return value:
|
|
|
|
The NT equivalent of the flags.
|
|
|
|
--*/
|
|
|
|
{
|
|
DWORD NtFlags = 0;
|
|
|
|
if (BITSARESET (Win9xFlags, W95_GENERIC_WRITE)) {
|
|
|
|
NtFlags |= ACCESS_WRITE;
|
|
|
|
}
|
|
|
|
if (BITSARESET (Win9xFlags, W95_GENERIC_READ)) {
|
|
|
|
NtFlags |= ACCESS_READ;
|
|
|
|
}
|
|
|
|
DEBUGMSG_IF ((
|
|
!NtFlags,
|
|
DBG_VERBOSE,
|
|
"Unsupported permission %u was translated to disable permission",
|
|
Win9xFlags
|
|
));
|
|
|
|
return NtFlags;
|
|
}
|
|
|
|
|
|
NET_API_STATUS
|
|
MigNetShareAdd (
|
|
IN PTSTR ServerName,
|
|
IN DWORD Level,
|
|
IN PBYTE Buf,
|
|
OUT PDWORD ErrParam
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Our private version of NetShareAdd. The real NetShareAdd does not work
|
|
in GUI mode. We emulate the real thing carefully because maybe some day
|
|
it WILL work and we should use it.
|
|
|
|
For now, we write directly to the registry. (This function is a reverse-
|
|
engineer of the NetShareAdd function.)
|
|
|
|
Arguments:
|
|
|
|
ServerName - Always NULL
|
|
|
|
Level - Always 2
|
|
|
|
Buf - A pointer to a caller-allocated SHARE_INFO_2 buffer cast
|
|
as an PBYTE
|
|
|
|
ErrParam - Not supported
|
|
|
|
Return value:
|
|
|
|
The Win32 result
|
|
|
|
--*/
|
|
|
|
{
|
|
SHARE_INFO_2 *psi;
|
|
DWORD rc;
|
|
HKEY hKey = NULL, hKeyShares = NULL;
|
|
DWORD DontCare;
|
|
GROWBUFFER GrowBuf = GROWBUF_INIT;
|
|
|
|
//
|
|
// This function is for compatibility with NetShareAdd, because one day
|
|
// the real NetShareAdd might be improved to work in GUI mode setup.
|
|
//
|
|
|
|
if (Level != 2) {
|
|
return ERROR_INVALID_LEVEL;
|
|
}
|
|
|
|
psi = (SHARE_INFO_2 *) Buf;
|
|
|
|
|
|
rc = TrackedRegOpenKeyEx (
|
|
HKEY_LOCAL_MACHINE,
|
|
L"SYSTEM\\CurrentControlSet\\Services",
|
|
0,
|
|
KEY_WRITE,
|
|
&hKey
|
|
);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
goto cleanup;
|
|
}
|
|
|
|
rc = TrackedRegCreateKeyEx (
|
|
hKey,
|
|
SHARES_REGISTRY_PATH,
|
|
0,
|
|
S_EMPTY,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&hKeyShares,
|
|
&DontCare
|
|
);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// Prepare multisz
|
|
//
|
|
|
|
if (!MultiSzAppendVal (&GrowBuf, CSCFLAGS_VARIABLE_NAME, 0)) {
|
|
rc = GetLastError();
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!MultiSzAppendVal (&GrowBuf, MAXUSES_VARIABLE_NAME, psi->shi2_max_uses)) {
|
|
rc = GetLastError();
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!psi->shi2_path || !(*psi->shi2_path)) {
|
|
rc = ERROR_INVALID_PARAMETER;
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!MultiSzAppendString (&GrowBuf, PATH_VARIABLE_NAME, psi->shi2_path)) {
|
|
rc = GetLastError();
|
|
goto cleanup;
|
|
}
|
|
|
|
if (!MultiSzAppendVal (&GrowBuf, PERMISSIONS_VARIABLE_NAME, psi->shi2_permissions)) {
|
|
rc = GetLastError();
|
|
goto cleanup;
|
|
}
|
|
|
|
if (psi->shi2_remark && *psi->shi2_remark) {
|
|
// Safety
|
|
if (TcharCount (psi->shi2_remark) >= MAXCOMMENTSZ) {
|
|
psi->shi2_remark[MAXCOMMENTSZ-1] = 0;
|
|
}
|
|
|
|
if (!MultiSzAppendString (&GrowBuf, REMARK_VARIABLE_NAME, psi->shi2_remark)) {
|
|
rc = GetLastError();
|
|
goto cleanup;
|
|
}
|
|
}
|
|
|
|
if (!MultiSzAppendVal (&GrowBuf, TYPE_VARIABLE_NAME, psi->shi2_type)) {
|
|
rc = GetLastError();
|
|
|
|
goto cleanup;
|
|
}
|
|
|
|
// terminate multi-sz string chain
|
|
if (!MultiSzAppend (&GrowBuf, S_EMPTY)) {
|
|
rc = GetLastError();
|
|
goto cleanup;
|
|
}
|
|
|
|
//
|
|
// Save to registry
|
|
//
|
|
|
|
rc = RegSetValueEx (hKeyShares, psi->shi2_netname, 0, REG_MULTI_SZ,
|
|
GrowBuf.Buf, GrowBuf.End);
|
|
|
|
cleanup:
|
|
if (hKeyShares) {
|
|
CloseRegKey (hKeyShares);
|
|
}
|
|
if (hKey) {
|
|
CloseRegKey (hKey);
|
|
}
|
|
FreeGrowBuffer (&GrowBuf);
|
|
return rc;
|
|
}
|
|
|
|
|
|
NET_API_STATUS
|
|
MigNetShareSetInfo (
|
|
IN PTSTR Server, // ignored
|
|
IN PTSTR NetName,
|
|
IN DWORD Level,
|
|
IN PBYTE Buf,
|
|
OUT PDWORD ErrParam // ignored
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
MigNetShareSetInfo implements a NetShareSetInfo emulation routine, because
|
|
the real routine does not work properly in GUI mode setup. See SDK
|
|
documentation for details.
|
|
|
|
Arguments:
|
|
|
|
Server - Unused
|
|
NetName - Specifies the share name to create.
|
|
Level - Specifies the API level (must be 1501)
|
|
Buf - Specifies a filled SHARE_INFO_1501 structure.
|
|
ErrParam - Unused
|
|
|
|
Return Value:
|
|
|
|
The Win32 status code.
|
|
|
|
--*/
|
|
|
|
{
|
|
SHARE_INFO_1501 *psi;
|
|
DWORD rc;
|
|
HKEY hKey;
|
|
DWORD DontCare;
|
|
TCHAR KeyName[MAX_TCHAR_PATH];
|
|
DWORD Len;
|
|
|
|
if (Level != 1501) {
|
|
return ERROR_INVALID_LEVEL;
|
|
}
|
|
|
|
psi = (SHARE_INFO_1501 *) Buf;
|
|
|
|
//
|
|
// Verify share exists
|
|
//
|
|
|
|
StringCopyW (
|
|
KeyName,
|
|
L"SYSTEM\\CurrentControlSet\\Services\\" SHARES_REGISTRY_PATH
|
|
);
|
|
|
|
rc = TrackedRegOpenKeyEx (
|
|
HKEY_LOCAL_MACHINE,
|
|
KeyName,
|
|
0,
|
|
KEY_READ,
|
|
&hKey
|
|
);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
return rc;
|
|
}
|
|
|
|
rc = RegQueryValueEx (hKey, NetName, NULL, NULL, NULL, NULL);
|
|
CloseRegKey (hKey);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
if (rc == ERROR_FILE_NOT_FOUND) {
|
|
rc = ERROR_INVALID_SHARENAME;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
//
|
|
// Save security descriptor as binary type in registry
|
|
//
|
|
|
|
StringCopy (
|
|
KeyName,
|
|
L"SYSTEM\\CurrentControlSet\\Services\\" SHARES_SECURITY_REGISTRY_PATH
|
|
);
|
|
|
|
rc = TrackedRegCreateKeyEx (
|
|
HKEY_LOCAL_MACHINE,
|
|
KeyName,
|
|
0,
|
|
S_EMPTY,
|
|
REG_OPTION_NON_VOLATILE,
|
|
KEY_ALL_ACCESS,
|
|
NULL,
|
|
&hKey,
|
|
&DontCare
|
|
);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
return rc;
|
|
}
|
|
|
|
Len = GetSecurityDescriptorLength (psi->shi1501_security_descriptor);
|
|
|
|
rc = RegSetValueEx (
|
|
hKey,
|
|
NetName,
|
|
0,
|
|
REG_BINARY,
|
|
(PBYTE) psi->shi1501_security_descriptor,
|
|
Len
|
|
);
|
|
|
|
CloseRegKey (hKey);
|
|
return rc;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pCreateNetShare (
|
|
IN PCTSTR NetName,
|
|
IN PCTSTR Path,
|
|
IN PCTSTR Remark,
|
|
IN DWORD Type,
|
|
IN DWORD Permissions
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pCreateNetShare is a wrapper to the Net APIs.
|
|
|
|
Arguments:
|
|
|
|
NetName - Specifies the share name
|
|
Path - Specifies the local path to be shared
|
|
Remark - Specifies the remark to register with the share
|
|
Type - Specifies the share type
|
|
Permissions - Specifies the Win9x share permissions, used only for logging
|
|
errors.
|
|
|
|
Return Value:
|
|
|
|
TRUE if the share was created, FALSE otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
SHARE_INFO_2 si2;
|
|
DWORD rc;
|
|
PWSTR UnicodePath;
|
|
BOOL b = FALSE;
|
|
|
|
UnicodePath = (PWSTR) CreateUnicode (Path);
|
|
MYASSERT (UnicodePath);
|
|
|
|
__try {
|
|
//
|
|
// Make NetShareAdd call
|
|
//
|
|
|
|
ZeroMemory (&si2, sizeof (si2));
|
|
si2.shi2_netname = (PTSTR) NetName;
|
|
si2.shi2_type = (WORD) Type;
|
|
si2.shi2_remark = (PTSTR) Remark;
|
|
si2.shi2_permissions = 0;
|
|
si2.shi2_max_uses = 0xffffffff;
|
|
si2.shi2_path = UnicodePath;
|
|
si2.shi2_passwd = NULL;
|
|
|
|
rc = MigNetShareAdd (NULL, 2, (PBYTE) (&si2), NULL);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
SetLastError (rc);
|
|
DEBUGMSG ((
|
|
DBG_ERROR,
|
|
"CreateShares: NetShareAdd failed for %s ('%s'), permissions=%x",
|
|
NetName,
|
|
Path,
|
|
Permissions
|
|
));
|
|
|
|
if (Permissions == W95_GENERIC_NONE) {
|
|
LOG ((LOG_ERROR, (PCSTR)MSG_UNABLE_TO_CREATE_ACL_SHARE, NetName, Path));
|
|
} else if (Permissions != W95_GENERIC_READ) {
|
|
LOG ((LOG_ERROR, (PCSTR)MSG_UNABLE_TO_CREATE_RO_SHARE, NetName, Path));
|
|
} else {
|
|
LOG ((LOG_ERROR, (PCSTR)MSG_UNABLE_TO_CREATE_SHARE, NetName, Path));
|
|
}
|
|
|
|
__leave;
|
|
}
|
|
|
|
b = TRUE;
|
|
}
|
|
|
|
__finally {
|
|
DestroyUnicode (UnicodePath);
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
|
|
VOID
|
|
LogUsersWhoFailed (
|
|
PBYTE AclMemberList,
|
|
DWORD Members,
|
|
PCTSTR Share,
|
|
PCTSTR Path
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
LogUsersWhoFailed implements logic to log the users who could not be added
|
|
to a share. If there are a small number of users, a popup is given with
|
|
each name. Otherwise, the share users are logged, and a popup tells the
|
|
installer to look in the log for the list.
|
|
|
|
Arguments:
|
|
|
|
AclMemberList - Specifies the ACL data structure containing all the user
|
|
names that need to be logged.
|
|
|
|
Members - Specifies the number of members in AclMemberList.
|
|
|
|
Share - Specifies the share name that could not be added.
|
|
|
|
Path - Specifies the share path that could not be added.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PACLMEMBER AclMember;
|
|
DWORD d;
|
|
DWORD GoodCount;
|
|
DWORD BadCount;
|
|
HWND Parent;
|
|
|
|
GoodCount = 0;
|
|
BadCount = 0;
|
|
AclMember = (PACLMEMBER) AclMemberList;
|
|
for (d = 0 ; d < Members ; d++) {
|
|
if (AclMember->Failed) {
|
|
BadCount++;
|
|
} else {
|
|
GoodCount++;
|
|
}
|
|
|
|
GetNextAclMember (&AclMember);
|
|
}
|
|
|
|
if (!BadCount) {
|
|
return;
|
|
}
|
|
|
|
if (BadCount < 5) {
|
|
Parent = g_ParentWnd;
|
|
} else {
|
|
if (!GoodCount) {
|
|
LOG ((LOG_ERROR, (PCSTR)MSG_ALL_SIDS_BAD, Share, Path));
|
|
} else {
|
|
LOG ((LOG_ERROR, (PCSTR)MSG_MANY_SIDS_BAD,
|
|
BadCount, BadCount + GoodCount, Share, Path));
|
|
}
|
|
|
|
Parent = NULL;
|
|
}
|
|
|
|
AclMember = (PACLMEMBER) AclMemberList;
|
|
for (d = 0 ; d < Members ; d++) {
|
|
if (AclMember->Failed) {
|
|
LOG ((LOG_ERROR, (PCSTR)MSG_NO_USER_SID, AclMember->UserOrGroup, Share, Path));
|
|
}
|
|
|
|
GetNextAclMember (&AclMember);
|
|
}
|
|
}
|
|
|
|
|
|
BOOL
|
|
SetShareAcl (
|
|
IN PCTSTR Share,
|
|
IN PCTSTR Path,
|
|
IN PBYTE AclMemberList,
|
|
IN DWORD MemberCount
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
SetShareAcl applies the access control list to a share that was previously
|
|
created.
|
|
|
|
Arguments:
|
|
|
|
Share - Specifies the share name
|
|
Path - Specifies the share path
|
|
AclMemberList - Specifies the ACL data structure giving the user(s) with
|
|
rights to the share
|
|
MemberCount - Specifies the number of members in AclMemberList.
|
|
|
|
Return Value:
|
|
|
|
TRUE if the ACL was successfully applied to the share, FALSE otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
BYTE Buf[8192];
|
|
PSECURITY_DESCRIPTOR pSD;
|
|
SECURITY_DESCRIPTOR desc;
|
|
PSID Sid;
|
|
PACL Acl;
|
|
SHARE_INFO_1501 shi1501;
|
|
DWORD rc;
|
|
DWORD Size;
|
|
PWSTR UnicodeShare;
|
|
|
|
pSD = (PSECURITY_DESCRIPTOR) Buf;
|
|
|
|
//
|
|
// Get Administrator's SID--they are the owner of the share
|
|
//
|
|
|
|
Sid = GetSidForUser (g_AdministratorsGroupStr);
|
|
if (!Sid) {
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Start building security descriptor
|
|
//
|
|
|
|
InitializeSecurityDescriptor (&desc, SECURITY_DESCRIPTOR_REVISION);
|
|
if (!SetSecurityDescriptorOwner (&desc, Sid, FALSE)) {
|
|
LOG ((LOG_ERROR, "Could not set %s as owner", g_AdministratorsGroupStr));
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Set the defaulted group to Domain\Domain Users (if it exists),
|
|
// otherwise get SID of none
|
|
//
|
|
|
|
Sid = GetSidForUser (g_DomainUsersGroupStr);
|
|
if (!Sid) {
|
|
Sid = GetSidForUser (g_NoneGroupStr);
|
|
}
|
|
|
|
if (Sid) {
|
|
SetSecurityDescriptorGroup (&desc, Sid, FALSE);
|
|
}
|
|
|
|
//
|
|
// Create access allowed ACL from member list
|
|
//
|
|
|
|
Acl = CreateAclFromMemberList (AclMemberList, MemberCount);
|
|
if (!Acl) {
|
|
DEBUGMSG ((DBG_WARNING, "SetShareAcl failed because CreateAclFromMemberList failed"));
|
|
return FALSE;
|
|
}
|
|
|
|
__try {
|
|
UnicodeShare = (PWSTR) CreateUnicode (Share);
|
|
MYASSERT (UnicodeShare);
|
|
|
|
if (!SetSecurityDescriptorDacl (&desc, TRUE, Acl, FALSE)) {
|
|
DEBUGMSG ((DBG_WARNING, "SetShareAcl failed because SetSecurityDescriptorDacl failed"));
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Set security descriptor on share
|
|
//
|
|
|
|
Size = sizeof (Buf);
|
|
if (!MakeSelfRelativeSD (&desc, pSD, &Size)) {
|
|
LOG ((LOG_ERROR, "MakeSelfRelativeSD failed"));
|
|
return FALSE;
|
|
}
|
|
|
|
ZeroMemory (&shi1501, sizeof (shi1501));
|
|
shi1501.shi1501_security_descriptor = pSD;
|
|
|
|
rc = MigNetShareSetInfo (NULL, UnicodeShare, 1501, (PBYTE) &shi1501, NULL);
|
|
if (rc != ERROR_SUCCESS) {
|
|
SetLastError (rc);
|
|
LOG ((LOG_ERROR, "NetShareSetInfo failed"));
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
__finally {
|
|
|
|
if (Acl) {
|
|
FreeMemberListAcl (Acl);
|
|
}
|
|
|
|
DestroyUnicode (UnicodeShare);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
VOID
|
|
DoCreateShares (
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
DoCreateShares enumerates all the shares registered in memdb by WINNT32.
|
|
For each enumeration, a share is created, and permissions or an ACL is
|
|
applied.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
MEMDB_ENUM e, e2;
|
|
TCHAR Path[MEMDB_MAX];
|
|
TCHAR Remark[MEMDB_MAX];
|
|
// we overlap the Remark stack buffer instead of making another
|
|
#define flagKey Remark
|
|
TCHAR Password[MEMDB_MAX];
|
|
DWORD Flags;
|
|
DWORD Members;
|
|
DWORD shareType;
|
|
GROWBUFFER NameList = GROWBUF_INIT;
|
|
PCTSTR pathNT;
|
|
|
|
//
|
|
// Obtain shares from memdb
|
|
//
|
|
|
|
if (MemDbEnumItems (&e, MEMDB_CATEGORY_NETSHARES)) {
|
|
do {
|
|
//
|
|
// Get share attributes
|
|
//
|
|
|
|
Flags = e.dwValue;
|
|
|
|
if (!MemDbGetEndpointValueEx (
|
|
MEMDB_CATEGORY_NETSHARES,
|
|
e.szName,
|
|
MEMDB_FIELD_PATH,
|
|
Path
|
|
)) {
|
|
|
|
DEBUGMSG ((DBG_WARNING, "DoCreateShares: No path found for %s", e.szName));
|
|
continue;
|
|
}
|
|
|
|
// IF YOU CHANGE CODE HERE: Note that flagKey is the same variable as Remark
|
|
MemDbBuildKey (flagKey, MEMDB_CATEGORY_NETSHARES, e.szName, MEMDB_FIELD_TYPE, NULL);
|
|
|
|
if (!MemDbGetValue (flagKey, &shareType)) {
|
|
DEBUGMSG ((DBG_WARNING, "DoCreateShares: No type found for %s", e.szName));
|
|
continue;
|
|
}
|
|
|
|
// IF YOU CHANGE CODE HERE: Note that flagKey is the same variable as Remark
|
|
if (!MemDbGetEndpointValueEx (
|
|
MEMDB_CATEGORY_NETSHARES,
|
|
e.szName,
|
|
MEMDB_FIELD_REMARK,
|
|
Remark
|
|
)) {
|
|
|
|
Remark[0] = 0;
|
|
}
|
|
|
|
//
|
|
// first check if the path changed
|
|
//
|
|
pathNT = GetPathStringOnNt (Path);
|
|
|
|
//
|
|
// Create the share and set appropriate security
|
|
//
|
|
|
|
if (Flags & SHI50F_ACLS) {
|
|
//
|
|
// Share has an ACL
|
|
//
|
|
|
|
if (pCreateNetShare (e.szName, pathNT, Remark, shareType, W95_GENERIC_NONE)) {
|
|
|
|
//
|
|
// For each user indexed, put them in an ACL member list
|
|
//
|
|
|
|
Members = 0;
|
|
if (MemDbGetValueEx (
|
|
&e2,
|
|
MEMDB_CATEGORY_NETSHARES,
|
|
e.szName,
|
|
MEMDB_FIELD_ACCESS_LIST
|
|
)) {
|
|
|
|
do {
|
|
//
|
|
// On Win9x, per-user flags have a 8 flags that control access. We translate
|
|
// them to one of four flavors on NT:
|
|
//
|
|
// 1. Deny All Access: (Flags == 0)
|
|
// 2. Read-Only Access: (Flags & W95_GENERIC_READ) && !(Flags & W95_GENERIC_WRITE)
|
|
// 3. Change-Only Access: !(Flags & W95_GENERIC_READ) && (Flags & W95_GENERIC_WRITE)
|
|
// 4. Full Access: (Flags & W95_GENERIC_FULL) == W95_GENERIC_FULL
|
|
//
|
|
|
|
DEBUGMSG ((DBG_NETSHARES, "Share %s user %s flags %u", e.szName, e2.szName, e2.dwValue));
|
|
|
|
if (AddAclMember (
|
|
&NameList,
|
|
e2.szName,
|
|
Simplify9xAccessFlags (e2.dwValue)
|
|
)) {
|
|
|
|
Members++;
|
|
|
|
}
|
|
|
|
} while (MemDbEnumNextValue (&e2));
|
|
}
|
|
|
|
//
|
|
// Convert member list into a real ACL and apply it to the share
|
|
//
|
|
|
|
if (NameList.Buf) {
|
|
SetShareAcl (e.szName, pathNT, NameList.Buf, Members);
|
|
LogUsersWhoFailed (NameList.Buf, Members, e.szName, pathNT);
|
|
FreeGrowBuffer (&NameList);
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
//
|
|
// Determine if a password is set
|
|
//
|
|
|
|
Password[0] = 0;
|
|
|
|
if (Flags & SHI50F_RDONLY) {
|
|
MemDbGetEndpointValueEx (
|
|
MEMDB_CATEGORY_NETSHARES,
|
|
e.szName,
|
|
MEMDB_FIELD_RO_PASSWORD,
|
|
Password
|
|
);
|
|
}
|
|
|
|
if (!Password[0] && (Flags & SHI50F_FULL)) {
|
|
MemDbGetEndpointValueEx (
|
|
MEMDB_CATEGORY_NETSHARES,
|
|
e.szName,
|
|
MEMDB_FIELD_RW_PASSWORD,
|
|
Password
|
|
);
|
|
}
|
|
|
|
//
|
|
// Enable all permissions for full access
|
|
// Enable read-only permissions for read-only shares
|
|
// Disable all permissions for no access
|
|
//
|
|
|
|
if (!Password[0]) {
|
|
|
|
if (Flags & SHI50F_FULL) {
|
|
|
|
Flags = W95_GENERIC_FULL;
|
|
|
|
} else if (Flags & SHI50F_RDONLY) {
|
|
|
|
Flags = W95_GENERIC_READ;
|
|
|
|
} else if (Flags) {
|
|
|
|
DEBUGMSG ((DBG_WHOOPS, "Flags (0x%X) is not 0, SHI50F_FULL or SHI50F_RDONLY", Flags));
|
|
Flags = W95_GENERIC_NONE;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
DEBUGMSG ((DBG_VERBOSE, "Password on share %s is not supported", e.szName));
|
|
Flags = W95_GENERIC_NONE;
|
|
|
|
}
|
|
|
|
//
|
|
// We do not support share-level security with passwords. We
|
|
// always create the share, but if a password exists, we
|
|
// deny everyone access.
|
|
//
|
|
|
|
pCreateNetShare (e.szName, pathNT, Remark, shareType, Flags);
|
|
|
|
Members = 0;
|
|
if (AddAclMember (
|
|
&NameList,
|
|
g_EveryoneStr,
|
|
Simplify9xAccessFlags (Flags)
|
|
)) {
|
|
|
|
Members++;
|
|
|
|
}
|
|
|
|
//
|
|
// Convert member list into a real ACL and apply it to the share
|
|
//
|
|
|
|
if (NameList.Buf) {
|
|
SetShareAcl (e.szName, pathNT, NameList.Buf, Members);
|
|
FreeGrowBuffer (&NameList);
|
|
}
|
|
}
|
|
|
|
FreePathString (pathNT);
|
|
|
|
} while (MemDbEnumNextValue (&e));
|
|
}
|
|
}
|
|
|
|
|
|
BOOL
|
|
pUpdateRecycleBin (
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Calls SHUpdateRecycleBinIcon to reset the status of the recycle bin. This
|
|
operation takes a few seconds as all hard drives are scanned, the recycle
|
|
bin database is read, and each entry in the database is verified.
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return value:
|
|
|
|
TRUE - the operation was successful
|
|
FALSE - the operation failed (either LoadLibrary or GetProcAddress)
|
|
|
|
--*/
|
|
|
|
{
|
|
SHUPDATERECYCLEBINICON_PROC Fn;
|
|
HINSTANCE LibInst;
|
|
BOOL b = TRUE;
|
|
|
|
LibInst = LoadLibrary (S_SHELL32_DLL);
|
|
if (!LibInst) {
|
|
return FALSE;
|
|
}
|
|
|
|
Fn = (SHUPDATERECYCLEBINICON_PROC) GetProcAddress (
|
|
LibInst,
|
|
S_ANSI_SHUPDATERECYCLEBINICON
|
|
);
|
|
|
|
if (Fn) {
|
|
|
|
//
|
|
// Scan all hard disks and validate the recycle bin status
|
|
//
|
|
|
|
Fn();
|
|
|
|
} else {
|
|
b = FALSE;
|
|
}
|
|
|
|
FreeLibrary (LibInst);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
VOID
|
|
pFixLogonDomainIfUserIsAdministrator (
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pFixLogonDomainIfUserIsAdministrator handles a special error case where
|
|
the logon domain is not equivalent to the computer name, but the user
|
|
is named Administrator. In this case, we change the default logon domain
|
|
to be the computer name.
|
|
|
|
Arguments:
|
|
|
|
None
|
|
|
|
Return value:
|
|
|
|
none
|
|
|
|
--*/
|
|
|
|
{
|
|
PCTSTR AdministratorAcct;
|
|
HKEY Key;
|
|
PCTSTR Data;
|
|
|
|
AdministratorAcct = GetStringResource (MSG_ADMINISTRATOR_ACCOUNT);
|
|
|
|
if (AdministratorAcct) {
|
|
Key = OpenRegKeyStr (S_WINLOGON_KEY);
|
|
if (Key) {
|
|
Data = GetRegValueString (Key, S_DEFAULT_USER_NAME);
|
|
if (Data) {
|
|
if (!StringCompare (Data, AdministratorAcct)) {
|
|
//
|
|
// Account name exactly matches our Administrator
|
|
// string, so there is a good chance we wrote
|
|
// this string. Therefore, we need to write the
|
|
// computer name as the default domain.
|
|
//
|
|
|
|
if (g_ComputerName[0]) {
|
|
RegSetValueEx (
|
|
Key,
|
|
S_DEFAULT_DOMAIN_NAME,
|
|
0,
|
|
REG_SZ,
|
|
(PBYTE) g_ComputerName,
|
|
SizeOfString (g_ComputerName)
|
|
);
|
|
}
|
|
}
|
|
|
|
MemFree (g_hHeap, 0, Data);
|
|
}
|
|
|
|
CloseRegKey (Key);
|
|
}
|
|
|
|
FreeStringResource (AdministratorAcct);
|
|
}
|
|
}
|
|
|
|
|
|
DWORD
|
|
ProcessLocalMachine_First (
|
|
DWORD Request
|
|
)
|
|
|
|
{
|
|
if (Request == REQUEST_QUERYTICKS) {
|
|
return TICKS_INI_ACTIONS_FIRST +
|
|
TICKS_INI_MOVE +
|
|
TICKS_INI_CONVERSION +
|
|
TICKS_INI_MIGRATION;
|
|
}
|
|
|
|
//
|
|
// We process the local machine in the following order:
|
|
//
|
|
// Initialization:
|
|
// (1) Reload memdb
|
|
//
|
|
// Ini files conversion and mapping
|
|
//
|
|
|
|
DEBUGMSG ((DBG_INIFILES, "INI Files Actions.First - START"));
|
|
DEBUGLOGTIME (("Starting function: DoIniActions"));
|
|
if (!DoIniActions (INIACT_WKS_FIRST)) {
|
|
LOG ((LOG_ERROR, "Process Local Machine: Could not perform one or more INI Files Actions.First"));
|
|
}
|
|
DEBUGLOGTIME (("Function complete: DoIniActions"));
|
|
TickProgressBarDelta (TICKS_INI_ACTIONS_FIRST);
|
|
DEBUGMSG ((DBG_INIFILES, "INI Files Actions.First - STOP"));
|
|
|
|
DEBUGMSG ((DBG_INIFILES, "INI file moving - START"));
|
|
DEBUGLOGTIME (("Starting function: MoveIniSettings"));
|
|
if (!MoveIniSettings ()) {
|
|
LOG ((LOG_ERROR, "Process Local Machine: Could not move one or more .INI files settings."));
|
|
return GetLastError();
|
|
}
|
|
DEBUGLOGTIME (("Function complete: MoveIniSettings"));
|
|
TickProgressBarDelta (TICKS_INI_MOVE);
|
|
DEBUGMSG ((DBG_INIFILES, "INI file moving - STOP"));
|
|
|
|
DEBUGMSG ((DBG_INIFILES, "INI file conversion - START"));
|
|
DEBUGLOGTIME (("Starting function: ConvertIniFiles"));
|
|
if (!ConvertIniFiles ()) {
|
|
LOG ((LOG_ERROR, "Process Local Machine: Could not convert one or more .INI files."));
|
|
return GetLastError();
|
|
}
|
|
DEBUGLOGTIME (("Function complete: ConvertIniFiles"));
|
|
TickProgressBarDelta (TICKS_INI_CONVERSION);
|
|
DEBUGMSG ((DBG_INIFILES, "INI file conversion - STOP"));
|
|
|
|
DEBUGMSG ((DBG_INIFILES, "INI file migration - START"));
|
|
DEBUGLOGTIME (("Starting function: ProcessIniFileMapping"));
|
|
if (!ProcessIniFileMapping (FALSE)) {
|
|
LOG ((LOG_ERROR, "Process Local Machine: Could not migrate one or more .INI files."));
|
|
return GetLastError();
|
|
}
|
|
DEBUGLOGTIME (("Function complete: ProcessIniFileMapping"));
|
|
TickProgressBarDelta (TICKS_INI_MIGRATION);
|
|
DEBUGMSG ((DBG_INIFILES, "INI file migration - STOP"));
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
VOID
|
|
pTurnOffNetAccountWizard (
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pTurnOffNetAccountWizard removes the RunNetAccessWizard key to keep the
|
|
network account wizard from appearing before the first logon.
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
HKEY Key;
|
|
|
|
Key = OpenRegKeyStr (TEXT("HKLM\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon"));
|
|
if (Key) {
|
|
RegDeleteValue (Key, TEXT("RunNetAccessWizard"));
|
|
CloseRegKey (Key);
|
|
} else {
|
|
DEBUGMSG ((DBG_WARNING, "Could not open key for RunNetAccessWizard value"));
|
|
}
|
|
}
|
|
|
|
|
|
typedef struct _OLE_CONTROL_DATA {
|
|
LPWSTR FullPath;
|
|
LPCWSTR RegType;
|
|
} OLE_CONTROL_DATA, *POLE_CONTROL_DATA;
|
|
|
|
|
|
|
|
DWORD
|
|
RegisterIndividualOleControl(
|
|
POLE_CONTROL_DATA OleControlData
|
|
)
|
|
{
|
|
PROCESS_INFORMATION processInfo;
|
|
STARTUPINFO startupInfo;
|
|
WCHAR cmdLine [MAX_PATH] = L"";
|
|
WCHAR cmdOptions [MAX_PATH] = L"";
|
|
DWORD WaitResult;
|
|
BOOL b = TRUE;
|
|
|
|
ZeroMemory (&startupInfo, sizeof (STARTUPINFO));
|
|
startupInfo.cb = sizeof (STARTUPINFO);
|
|
|
|
if (OleControlData->RegType && (*OleControlData->RegType == L'B')) {
|
|
// install and register
|
|
wcscpy (cmdOptions, L"/s /i");
|
|
} else if (OleControlData->RegType && (*OleControlData->RegType == L'R')) {
|
|
// register
|
|
wcscpy (cmdOptions, L"/s");
|
|
} else if (OleControlData->RegType && (*OleControlData->RegType == L'I')) {
|
|
// install
|
|
wcscpy (cmdOptions, L"/s /i /n");
|
|
} else if ((OleControlData->RegType == NULL) || (*OleControlData->RegType == L'\0')) {
|
|
// register
|
|
wcscpy (cmdOptions, L"/s");
|
|
}
|
|
|
|
wsprintf (cmdLine, L"%s\\regsvr32.exe %s %s", g_System32Dir, cmdOptions, OleControlData->FullPath);
|
|
|
|
if (CreateProcess (NULL, cmdLine, NULL, NULL, TRUE, 0, NULL, NULL, &startupInfo, &processInfo)) {
|
|
|
|
WaitResult = WaitForSingleObject (processInfo.hProcess, 1000 * 60 * 10 );
|
|
|
|
if (WaitResult == WAIT_TIMEOUT) {
|
|
DEBUGMSG ((DBG_ERROR, "Timeout installing and/or registering OLE control %s", OleControlData->FullPath));
|
|
b = FALSE;
|
|
}
|
|
|
|
CloseHandle (processInfo.hProcess);
|
|
CloseHandle (processInfo.hThread);
|
|
}
|
|
else {
|
|
DEBUGMSG ((DBG_ERROR, "Create process failed: %s", cmdLine));
|
|
b = FALSE;
|
|
}
|
|
return b;
|
|
}
|
|
|
|
|
|
typedef struct _KNOWN_DIRS {
|
|
PCWSTR DirId;
|
|
PCWSTR Translation;
|
|
}
|
|
KNOWN_DIRSW, *PKNOWN_DIRSW;
|
|
|
|
KNOWN_DIRSW g_KnownDirsW [] = {
|
|
{L"10" , g_WinDir},
|
|
{L"11" , g_System32Dir},
|
|
{L"24" , g_WinDrive},
|
|
{L"16422" , g_ProgramFiles},
|
|
{L"16427" , g_ProgramFilesCommon},
|
|
{NULL, NULL}
|
|
};
|
|
|
|
BOOL
|
|
pConvertDirName (
|
|
PCWSTR OldDirName,
|
|
PWSTR NewDirName
|
|
)
|
|
{
|
|
PCWSTR OldDirCurr = OldDirName;
|
|
PCWSTR OldDirNext;
|
|
PKNOWN_DIRSW p;
|
|
|
|
NewDirName[0] = 0;
|
|
OldDirNext = wcschr (OldDirCurr, L'\\');
|
|
if (OldDirNext == NULL) {
|
|
OldDirNext = wcschr (OldDirCurr, 0);
|
|
}
|
|
StringCopyABW (NewDirName, OldDirCurr, OldDirNext);
|
|
p = g_KnownDirsW;
|
|
while (p->DirId!= NULL) {
|
|
if (StringIMatchW (NewDirName, p->DirId)) {
|
|
StringCopyW (NewDirName, p->Translation);
|
|
break;
|
|
}
|
|
p++;
|
|
}
|
|
StringCatW (NewDirName, OldDirNext);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL
|
|
RegisterOleControls(
|
|
VOID
|
|
)
|
|
{
|
|
INFCONTEXT InfLine;
|
|
WCHAR DirId [MAX_PATH];
|
|
WCHAR SubDir [MAX_PATH];
|
|
WCHAR Filename [MAX_PATH];
|
|
WCHAR RegType [MAX_PATH];
|
|
WCHAR FullPathTemp[MAX_PATH];
|
|
WCHAR FullPath[MAX_PATH];
|
|
BOOL b;
|
|
DWORD d;
|
|
UINT Line;
|
|
WCHAR OldCD[MAX_PATH];
|
|
OLE_CONTROL_DATA OleControlData;
|
|
|
|
b = TRUE;
|
|
Line = 0;
|
|
|
|
//
|
|
// Preserve current directory just in case
|
|
//
|
|
d = GetCurrentDirectory(MAX_PATH,OldCD);
|
|
if(!d || (d >= MAX_PATH)) {
|
|
OldCD[0] = 0;
|
|
}
|
|
|
|
if(SetupFindFirstLine(g_WkstaMigInf, L"Win9xUpg_OleControls", NULL, &InfLine)) {
|
|
|
|
do {
|
|
Line++;
|
|
if (!SetupGetStringField (&InfLine, 1, DirId, MAX_PATH, NULL) ||
|
|
!SetupGetStringField (&InfLine, 2, SubDir, MAX_PATH, NULL) ||
|
|
!SetupGetStringField (&InfLine, 3, Filename, MAX_PATH, NULL) ||
|
|
!SetupGetStringField (&InfLine, 4, RegType, MAX_PATH, NULL)
|
|
) {
|
|
DEBUGMSGW ((DBG_ERROR, "Bad line while registering controls %d", Line));
|
|
} else {
|
|
|
|
DEBUGMSG ((DBG_VERBOSE, "SETUP: filename for file to register is %s", Filename));
|
|
//
|
|
// Get full path to dll
|
|
//
|
|
if (pConvertDirName (DirId, FullPathTemp)) {
|
|
wcscpy (FullPath, FullPathTemp);
|
|
if (*SubDir) {
|
|
wcscat (FullPath, L"\\");
|
|
wcscat (FullPath, SubDir);
|
|
}
|
|
SetCurrentDirectory(FullPath);
|
|
wcscat (FullPath, L"\\");
|
|
wcscat (FullPath, Filename);
|
|
OleControlData.FullPath = FullPath;
|
|
OleControlData.RegType = RegType;
|
|
RegisterIndividualOleControl (&OleControlData);
|
|
} else {
|
|
DEBUGMSG ((DBG_ERROR, "SETUP: dll skipped, bad dirid %s", DirId));
|
|
b = FALSE;
|
|
}
|
|
}
|
|
} while(SetupFindNextLine(&InfLine,&InfLine));
|
|
}
|
|
|
|
if(OldCD[0]) {
|
|
SetCurrentDirectory(OldCD);
|
|
}
|
|
|
|
return(b);
|
|
}
|
|
|
|
|
|
DWORD
|
|
ProcessLocalMachine_Last (
|
|
DWORD Request
|
|
)
|
|
|
|
{
|
|
DWORD rc;
|
|
|
|
#ifdef VAR_PROGRESS_BAR
|
|
|
|
CHAR SystemDatPath[MAX_MBCHAR_PATH];
|
|
WIN32_FIND_DATAA fd;
|
|
HANDLE h;
|
|
DWORD SizeKB;
|
|
|
|
#endif
|
|
|
|
static LONG g_TicksHklm;
|
|
|
|
if (Request == REQUEST_QUERYTICKS) {
|
|
|
|
#ifdef VAR_PROGRESS_BAR
|
|
|
|
//
|
|
// estimate g_TicksHklm function of size of file system.dat
|
|
//
|
|
StringCopyA (SystemDatPath, g_SystemHiveDir);
|
|
StringCatA (SystemDatPath, "system.dat");
|
|
h = FindFirstFileA (SystemDatPath, &fd);
|
|
if (h != INVALID_HANDLE_VALUE) {
|
|
FindClose (h);
|
|
MYASSERT (!fd.nFileSizeHigh);
|
|
SizeKB = (fd.nFileSizeLow + 511) / 1024;
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: system.dat size = %lu KB", SizeKB));
|
|
//
|
|
// statistics show that average time is 243 * (filesize in KB) - 372000
|
|
// I'll use 256 instead just to make sure the progress bar will not stop
|
|
// at the end looking like it's hanged
|
|
// The checked build is much slower (about 1.5 times)
|
|
//
|
|
#ifdef DEBUG
|
|
g_TicksHklm = SizeKB * 400;
|
|
#else
|
|
g_TicksHklm = SizeKB * 256;
|
|
#endif
|
|
} else {
|
|
//
|
|
// what's wrong here?
|
|
//
|
|
MYASSERT (FALSE);
|
|
g_TicksHklm = TICKS_HKLM;
|
|
}
|
|
|
|
#else // !defined VAR_PROGRESS_BAR
|
|
|
|
g_TicksHklm = TICKS_HKLM;
|
|
|
|
#endif
|
|
return TICKS_INI_MERGE +
|
|
g_TicksHklm +
|
|
TICKS_SHARES +
|
|
TICKS_LINK_EDIT +
|
|
TICKS_DOSMIG_SYS +
|
|
TICKS_UPDATERECYCLEBIN +
|
|
TICKS_STF +
|
|
TICKS_RAS +
|
|
TICKS_TAPI +
|
|
TICKS_MULTIMEDIA +
|
|
TICKS_INI_ACTIONS_LAST;
|
|
}
|
|
|
|
//
|
|
// We process the local machine in the following order:
|
|
//
|
|
// Initialization:
|
|
// (1) Reload memdb
|
|
//
|
|
// Local machine registry preparation:
|
|
//
|
|
// (1) Process wkstamig.inf
|
|
// (2) Merge Win95 registry with NT hive
|
|
//
|
|
// Process instructions written to memdb:
|
|
//
|
|
// (1) Create Win95 shares
|
|
// (2) Process LinkEdit section
|
|
//
|
|
|
|
//
|
|
// Load in default MemDb state, or at least delete everything if
|
|
// memdb.dat does not exist.
|
|
//
|
|
|
|
MemDbLoad (GetMemDbDat());
|
|
|
|
DEBUGMSG ((DBG_INIFILES, "INI file merge - START"));
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Starting function: MergeIniSettings"));
|
|
if (!MergeIniSettings ()) {
|
|
LOG ((LOG_ERROR, "Process Local Machine: Could not merge one or more .INI files."));
|
|
return GetLastError();
|
|
}
|
|
TickProgressBarDelta (TICKS_INI_MERGE);
|
|
DEBUGMSG ((DBG_INIFILES, "INI file merge - STOP"));
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Function complete: MergeIniSettings"));
|
|
|
|
//
|
|
// Process local machine migration rules
|
|
//
|
|
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Starting function: MergeRegistry"));
|
|
if (!MergeRegistry (S_WKSTAMIG_INF, NULL)) {
|
|
LOG ((LOG_ERROR, "Process Local Machine: MergeRegistry failed for wkstamig.inf"));
|
|
return GetLastError();
|
|
}
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Function complete: MergeRegistry"));
|
|
TickProgressBarDelta (g_TicksHklm);
|
|
|
|
//
|
|
// Process memdb nodes
|
|
//
|
|
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Starting function: DoCreateShares"));
|
|
DoCreateShares(); // we ignore all errors
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Function complete: DoCreateShares"));
|
|
TickProgressBarDelta (TICKS_SHARES);
|
|
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Starting function: DoLinkEdit"));
|
|
if (!DoLinkEdit()) {
|
|
LOG ((LOG_ERROR, "Process Local Machine: DoLinkEdit failed."));
|
|
return GetLastError();
|
|
}
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Function complete: DoLinkEdit"));
|
|
TickProgressBarDelta (TICKS_LINK_EDIT);
|
|
|
|
//
|
|
// Handle DOS system migration.
|
|
//
|
|
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Starting function: DosMigNt_System"));
|
|
__try {
|
|
if (DosMigNt_System() != EXIT_SUCCESS) {
|
|
LOG((LOG_ERROR, "Process Local Machine: DosMigNt_System failed."));
|
|
}
|
|
}
|
|
__except(TRUE) {
|
|
DEBUGMSG ((DBG_WHOOPS, "Exception in DosMigNt_System"));
|
|
}
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Function complete: DosMigNt_System"));
|
|
TickProgressBarDelta (TICKS_DOSMIG_SYS);
|
|
|
|
|
|
//
|
|
// Make the recycled bin the correct status
|
|
//
|
|
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Starting function: pUpdateRecycleBin"));
|
|
if (!pUpdateRecycleBin ()) {
|
|
LOG ((LOG_ERROR, "Process Local Machine: Could not update recycle bin."));
|
|
}
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Function complete: pUpdateRecycleBin"));
|
|
TickProgressBarDelta (TICKS_UPDATERECYCLEBIN);
|
|
|
|
//
|
|
// Migrate all .STF files (ACME Setup)
|
|
//
|
|
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Starting function: ProcessStfFiles"));
|
|
if (!ProcessStfFiles()) {
|
|
LOG ((LOG_ERROR, "Process Local Machine: Could not migrate one or more .STF files."));
|
|
}
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Function complete: ProcessStfFiles"));
|
|
TickProgressBarDelta (TICKS_STF);
|
|
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Starting function: Ras_MigrateSystem"));
|
|
if (!Ras_MigrateSystem()) {
|
|
LOG ((LOG_ERROR, "Ras MigrateSystem: Error migrating system."));
|
|
}
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Function complete: Ras_MigrateSystem"));
|
|
TickProgressBarDelta (TICKS_RAS);
|
|
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Starting function: Tapi_MigrateSystem"));
|
|
if (!Tapi_MigrateSystem()) {
|
|
LOG ((LOG_ERROR, "Tapi MigrateSystem: Error migrating system TAPI settings."));
|
|
}
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Function complete: Tapi_MigrateSystem"));
|
|
TickProgressBarDelta (TICKS_TAPI);
|
|
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Starting function: RestoreMMSettings_System"));
|
|
if (!RestoreMMSettings_System ()) {
|
|
LOG ((LOG_ERROR, "Process Local Machine: Could not restore multimedia settings."));
|
|
return GetLastError();
|
|
}
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Function complete: RestoreMMSettings_System"));
|
|
TickProgressBarDelta (TICKS_MULTIMEDIA);
|
|
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Starting function: DoIniActions.Last"));
|
|
DEBUGMSG ((DBG_INIFILES, "INI Files Actions.Last - START"));
|
|
if (!DoIniActions (INIACT_WKS_LAST)) {
|
|
LOG ((LOG_ERROR, "Process Local Machine: Could not perform one or more INI Files Actions.Last"));
|
|
}
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Function complete: DoIniActions.Last"));
|
|
TickProgressBarDelta (TICKS_INI_ACTIONS_LAST);
|
|
DEBUGMSG ((DBG_INIFILES, "INI Files Actions.Last - STOP"));
|
|
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Starting function: RegisterOleControls"));
|
|
RegisterOleControls ();
|
|
DEBUGLOGTIME (("ProcessLocalMachine_Last: Function complete: RegisterOleControls"));
|
|
|
|
//
|
|
// Blow away the Network Account Wizard (so fast it doesn't need ticks)
|
|
//
|
|
|
|
pTurnOffNetAccountWizard();
|
|
|
|
//
|
|
// Update security for Crypto group
|
|
//
|
|
|
|
rc = SetRegKeySecurity (
|
|
TEXT("HKLM\\Software\\Microsoft\\Cryptography\\MachineKeys"),
|
|
SF_EVERYONE_FULL,
|
|
NULL,
|
|
NULL,
|
|
TRUE
|
|
);
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pEnumWin9xHiveFileWorker (
|
|
IN OUT PHIVEFILE_ENUM EnumPtr
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pEnumWin9xHiveFileWorker parses wkstamig.inf to get the source path to a
|
|
Win9x registry hive, and it gets the destination of where the hive should
|
|
be migrated to. The source is tested, and if it doesn't exist, the
|
|
function returns FALSE.
|
|
|
|
Environment variables in both the source or dest are expanded before
|
|
this function returns success.
|
|
|
|
Arguments:
|
|
|
|
EnumPtr - Specifies partially completed enumeration structure (the
|
|
EnumPtr->is member must be valid). Receives the source and
|
|
destination of the hive to be migrated.
|
|
|
|
Return Value:
|
|
|
|
Returns TRUE if a hive needs to be transfered from EnumPtr->Source to
|
|
EnumPtr->Dest, otherwise FALSE.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCTSTR Source;
|
|
PCTSTR Dest;
|
|
|
|
//
|
|
// Get the source and dest from the INF
|
|
//
|
|
|
|
Source = InfGetStringField (&EnumPtr->is, 0);
|
|
Dest = InfGetStringField (&EnumPtr->is, 1);
|
|
|
|
if (!Source || !Dest) {
|
|
DEBUGMSG ((DBG_WHOOPS, "wkstamig.inf HiveFilesToConvert is not correct"));
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Expand the source and dest
|
|
//
|
|
|
|
if (EnumPtr->Source) {
|
|
FreeText (EnumPtr->Source);
|
|
}
|
|
|
|
EnumPtr->Source = ExpandEnvironmentText (Source);
|
|
|
|
if (EnumPtr->Dest) {
|
|
FreeText (EnumPtr->Dest);
|
|
}
|
|
|
|
EnumPtr->Dest = ExpandEnvironmentText (Dest);
|
|
|
|
//
|
|
// The source must exist
|
|
//
|
|
|
|
if (!DoesFileExist (EnumPtr->Source)) {
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
VOID
|
|
pAbortHiveFileEnum (
|
|
IN OUT PHIVEFILE_ENUM EnumPtr
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pAbortHiveFileEnum cleans up the allocations from an active enumeration of
|
|
Win9x hive files. This routine must be called by the enum first/next when
|
|
the enumeration completes, or it must be called by the code using the
|
|
enumeration. It is safe to call this routine in both places.
|
|
|
|
Arguments:
|
|
|
|
EnumPtr - Specifies the enumeration that needs to be aborted or that has
|
|
completed successfully. Receives a zero'd struct.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
if (EnumPtr->Pool) {
|
|
PoolMemDestroyPool (EnumPtr->Pool);
|
|
}
|
|
|
|
if (EnumPtr->Source) {
|
|
FreeText (EnumPtr->Source);
|
|
}
|
|
|
|
if (EnumPtr->Dest) {
|
|
FreeText (EnumPtr->Dest);
|
|
}
|
|
|
|
ZeroMemory (EnumPtr, sizeof (HIVEFILE_ENUM));
|
|
}
|
|
|
|
|
|
BOOL
|
|
pEnumNextWin9xHiveFile (
|
|
IN OUT PHIVEFILE_ENUM EnumPtr
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pEnumNextWin9xHiveFile continues the enumeration wksatmig.inf until either
|
|
a hive needing migration is found, or no more INF entries are left.
|
|
|
|
Arguments:
|
|
|
|
EnumPtr - Specifies an enumeration structure that was initialized by
|
|
pEnumFirstWin9xHiveFile. Receives the next hive file source &
|
|
dest enumeration if one is available.
|
|
|
|
Return Value:
|
|
|
|
TRUE if a Win9x hive file needs to be migrated (its source and dest
|
|
specified in EnumPtr). FALSE if no more hive files are to be processed.
|
|
|
|
--*/
|
|
|
|
{
|
|
do {
|
|
if (!InfFindNextLine (&EnumPtr->is)) {
|
|
pAbortHiveFileEnum (EnumPtr);
|
|
return FALSE;
|
|
}
|
|
} while (!pEnumWin9xHiveFileWorker (EnumPtr));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pEnumFirstWin9xHiveFile (
|
|
OUT PHIVEFILE_ENUM EnumPtr
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pEnumFirstWin9xHiveFile begins an enumeration of Win9x registry files that
|
|
need to be migrated either to the NT registry, or to an NT registry hive
|
|
file.
|
|
|
|
Arguments:
|
|
|
|
EnumPtr - Receives the source Win9x hive file and the destination (either a
|
|
file or a registry path).
|
|
|
|
Return Value:
|
|
|
|
TRUE if a Win9x hive file was found and needs to be migrated, FALSE if no
|
|
hive file migration is needed.
|
|
|
|
--*/
|
|
|
|
{
|
|
ZeroMemory (EnumPtr, sizeof (HIVEFILE_ENUM));
|
|
|
|
//
|
|
// Begin the enumeration of the Hive Files section of wkstamig.inf
|
|
//
|
|
|
|
EnumPtr->Pool = PoolMemInitNamedPool ("Hive File Enum");
|
|
|
|
InitInfStruct (&EnumPtr->is, NULL, EnumPtr->Pool);
|
|
|
|
if (!InfFindFirstLine (g_WkstaMigInf, S_WKSTAMIG_HIVE_FILES, NULL, &EnumPtr->is)) {
|
|
pAbortHiveFileEnum (EnumPtr);
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Attempt to return the first hive
|
|
//
|
|
|
|
if (pEnumWin9xHiveFileWorker (EnumPtr)) {
|
|
return TRUE;
|
|
}
|
|
|
|
//
|
|
// Hive does not exist, continue enumeration
|
|
//
|
|
|
|
return pEnumNextWin9xHiveFile (EnumPtr);
|
|
}
|
|
|
|
|
|
BOOL
|
|
pTransferWin9xHiveToRegKey (
|
|
IN PCTSTR Win9xHive,
|
|
IN PCTSTR NtRootKey
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pTransferWin9xHiveToRegKey maps in a Win9x hive file, enumerates all the
|
|
keys and values, and transfers them to the NT registry.
|
|
|
|
Arguments:
|
|
|
|
Win9xHive - Specifies the registry hive file (a Win9x hive)
|
|
NtRootKey - Specifies the path to the NT registry destination, such as
|
|
HKLM\foo.
|
|
|
|
Return Value:
|
|
|
|
TRUE if the hive file was transferred without an error, FALSE otherwise.
|
|
Use GetLastError to get the error code.
|
|
|
|
--*/
|
|
|
|
{
|
|
LONG rc;
|
|
HKEY DestKey;
|
|
BOOL b = FALSE;
|
|
REGTREE_ENUM e;
|
|
REGVALUE_ENUM e2;
|
|
PCTSTR SubKey;
|
|
HKEY DestSubKey;
|
|
BOOL EnumAbort = FALSE;
|
|
PBYTE DataBuf;
|
|
GROWBUFFER Data = GROWBUF_INIT;
|
|
DWORD Type;
|
|
DWORD Size;
|
|
BOOL CloseDestSubKey = FALSE;
|
|
|
|
//
|
|
// Map the hive into a temporary key
|
|
//
|
|
|
|
rc = Win95RegLoadKey (
|
|
HKEY_LOCAL_MACHINE,
|
|
S_HIVE_TEMP,
|
|
Win9xHive
|
|
);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
DEBUGMSG ((DBG_ERROR, "Can't load %s for transfer", Win9xHive));
|
|
return FALSE;
|
|
}
|
|
|
|
__try {
|
|
DestKey = CreateRegKeyStr (NtRootKey);
|
|
|
|
if (!DestKey) {
|
|
DEBUGMSG ((DBG_ERROR, "Can't create %s", NtRootKey));
|
|
__leave;
|
|
}
|
|
|
|
if (EnumFirstRegKeyInTree95 (&e, TEXT("HKLM\\") S_HIVE_TEMP)) {
|
|
|
|
EnumAbort = TRUE;
|
|
|
|
do {
|
|
//
|
|
// Create the NT destination; if SubKey is empty, then
|
|
// use the root key for the destination.
|
|
//
|
|
|
|
SubKey = (PCTSTR) ((PBYTE) e.FullKeyName + e.EnumBaseBytes);
|
|
|
|
if (*SubKey) {
|
|
DestSubKey = CreateRegKey (DestKey, SubKey);
|
|
if (!DestSubKey) {
|
|
DEBUGMSG ((DBG_ERROR, "Can't create subkey %s", SubKey));
|
|
__leave;
|
|
}
|
|
|
|
CloseDestSubKey = TRUE;
|
|
|
|
} else {
|
|
DestSubKey = DestKey;
|
|
}
|
|
|
|
//
|
|
// Copy all values in 9x key to NT
|
|
//
|
|
|
|
if (EnumFirstRegValue95 (&e2, e.CurrentKey->KeyHandle)) {
|
|
do {
|
|
Data.End = 0;
|
|
DataBuf = GrowBuffer (&Data, e2.DataSize);
|
|
if (!DataBuf) {
|
|
DEBUGMSG ((DBG_ERROR, "Data size is too big: %s", e2.DataSize));
|
|
__leave;
|
|
}
|
|
|
|
Size = e2.DataSize;
|
|
rc = Win95RegQueryValueEx (
|
|
e2.KeyHandle,
|
|
e2.ValueName,
|
|
NULL,
|
|
&Type,
|
|
DataBuf,
|
|
&Size
|
|
);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
DEBUGMSG ((
|
|
DBG_ERROR,
|
|
"Can't read enumerated value:\n"
|
|
" %s\n"
|
|
" %s [%s]",
|
|
Win9xHive,
|
|
e.FullKeyName,
|
|
e2.ValueName
|
|
));
|
|
|
|
__leave;
|
|
}
|
|
|
|
MYASSERT (Size == e2.DataSize);
|
|
|
|
rc = RegSetValueEx (
|
|
DestSubKey,
|
|
e2.ValueName,
|
|
0,
|
|
e2.Type,
|
|
DataBuf,
|
|
Size
|
|
);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
DEBUGMSG ((
|
|
DBG_ERROR,
|
|
"Can't write enumerated value:\n"
|
|
" %s\n"
|
|
" %s\\%s [%s]",
|
|
Win9xHive,
|
|
NtRootKey,
|
|
SubKey,
|
|
e2.ValueName
|
|
));
|
|
|
|
__leave;
|
|
}
|
|
|
|
} while (EnumNextRegValue95 (&e2));
|
|
}
|
|
|
|
if (CloseDestSubKey) {
|
|
CloseRegKey (DestSubKey);
|
|
CloseDestSubKey = FALSE;
|
|
}
|
|
|
|
} while (EnumNextRegKeyInTree95 (&e));
|
|
|
|
EnumAbort = FALSE;
|
|
}
|
|
ELSE_DEBUGMSG ((DBG_WARNING, "%s is empty", Win9xHive));
|
|
|
|
b = TRUE;
|
|
}
|
|
__finally {
|
|
PushError();
|
|
|
|
if (CloseDestSubKey) {
|
|
CloseRegKey (DestSubKey);
|
|
}
|
|
|
|
if (EnumAbort) {
|
|
AbortRegKeyTreeEnum95 (&e);
|
|
}
|
|
|
|
Win95RegUnLoadKey (HKEY_LOCAL_MACHINE, TEXT("$$$"));
|
|
|
|
if (DestKey) {
|
|
CloseRegKey (DestKey);
|
|
}
|
|
|
|
FreeGrowBuffer (&Data);
|
|
|
|
PopError();
|
|
}
|
|
|
|
return b;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pTransferWin9xHive (
|
|
IN PCTSTR Win9xHive,
|
|
IN PCTSTR Destination
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pTransferWin9xHive transfers a Win9x registry hive file (foo.dat) to either
|
|
an NT registry file, or a key in the NT registry. The source and
|
|
destination can be the same file.
|
|
|
|
Arguments:
|
|
|
|
Win9xHive - Specifies the registry hive file path (a Win9x hive file).
|
|
Destination - Specifies either a path or NT registry location where the
|
|
Win9xHive should be transfered to.
|
|
|
|
Return Value:
|
|
|
|
TRUE if the hive was transfered, FALSE otherwise. Call GetLastError for an
|
|
error code.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCTSTR DestHive;
|
|
BOOL ToHiveFile;
|
|
HKEY Key;
|
|
LONG rc;
|
|
|
|
//
|
|
// Determine if destination is a hive file or a reg location
|
|
//
|
|
|
|
if (_istalpha (Destination[0]) && Destination[1] == TEXT(':')) {
|
|
ToHiveFile = TRUE;
|
|
DestHive = TEXT("HKLM\\") S_TRANSFER_HIVE;
|
|
} else {
|
|
ToHiveFile = FALSE;
|
|
DestHive = Destination;
|
|
}
|
|
|
|
//
|
|
// Blast the Win9x hive data to the temp location
|
|
//
|
|
|
|
if (!pTransferWin9xHiveToRegKey (Win9xHive, DestHive)) {
|
|
RegDeleteKey (HKEY_LOCAL_MACHINE, S_TRANSFER_HIVE);
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Save the key if the destination is a hive file
|
|
//
|
|
|
|
if (ToHiveFile) {
|
|
Key = OpenRegKeyStr (DestHive);
|
|
|
|
if (!Key) {
|
|
DEBUGMSG ((DBG_ERROR, "Transfer hive key %s does not exist", DestHive));
|
|
return FALSE;
|
|
}
|
|
|
|
rc = RegSaveKey (Key, Destination, NULL);
|
|
|
|
CloseRegKey (Key);
|
|
RegDeleteKey (HKEY_LOCAL_MACHINE, S_TRANSFER_HIVE);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
DEBUGMSG ((DBG_ERROR, "Win9x hive %s could not be saved to %s", Win9xHive, Destination));
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Delete the source file if the destination is not the same
|
|
//
|
|
|
|
if (!ToHiveFile || !StringIMatch (Win9xHive, DestHive)) {
|
|
//
|
|
// By adding info to memdb, we must enforce a rule that
|
|
// memdb cannot be reloaded. Otherwise we lose our
|
|
// changes.
|
|
//
|
|
|
|
DeclareTemporaryFile (Win9xHive);
|
|
|
|
#ifdef DEBUG
|
|
g_NoReloadsAllowed = TRUE;
|
|
#endif
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
DWORD
|
|
ConvertHiveFiles (
|
|
DWORD Request
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
ConvertHiveFiles enumerates all the hive files on the system that need
|
|
conversion, and calls pTransferWin9xHive to migrate them to the destination
|
|
specified in wkstamig.inf.
|
|
|
|
Arguments:
|
|
|
|
Request - Specifies the progress bar-driven request.
|
|
|
|
Return Value:
|
|
|
|
If Request is REQUEST_QUERYTICKS, the return value is the number of ticks
|
|
this routine is expected to take. Otherwise, the return value is
|
|
ERROR_SUCCESS.
|
|
|
|
--*/
|
|
|
|
{
|
|
HIVEFILE_ENUM e;
|
|
|
|
switch (Request) {
|
|
|
|
case REQUEST_QUERYTICKS:
|
|
return TICKS_HIVE_CONVERSION;
|
|
|
|
case REQUEST_RUN:
|
|
//
|
|
// Enumerate all the hives that need to be processed
|
|
//
|
|
|
|
if (pEnumFirstWin9xHiveFile (&e)) {
|
|
do {
|
|
|
|
pTransferWin9xHive (e.Source, e.Dest);
|
|
|
|
} while (pEnumNextWin9xHiveFile (&e));
|
|
}
|
|
ELSE_DEBUGMSG ((DBG_NAUSEA, "ConvertHiveFiles: Nothing to do"));
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pRegisterAtmFont (
|
|
IN PCTSTR PfmFile,
|
|
IN PCTSTR PfbFile,
|
|
IN PCTSTR MmmFile OPTIONAL
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pRegisterAtmFont calls the AtmFontExW API to register an Adobe PS font.
|
|
|
|
Arguments:
|
|
|
|
PfmFile - Specifies the path to the PFM file (the font metrics)
|
|
PfbFile - Specifies the path to the PFB file (the font bits)
|
|
MmmFile - Specifies the path to the MMM file (the new style metrics file)
|
|
|
|
Return Value:
|
|
|
|
TRUE if the font was registered, FALSE otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
WORD StyleAndType = 0x2000;
|
|
INT Result;
|
|
|
|
if (AtmAddFontEx == NULL) {
|
|
return FALSE;
|
|
}
|
|
|
|
Result = AtmAddFontEx (
|
|
NULL,
|
|
&StyleAndType,
|
|
PfmFile,
|
|
PfbFile,
|
|
MmmFile
|
|
);
|
|
|
|
DEBUGMSG_IF ((
|
|
Result != ERROR_SUCCESS,
|
|
Result == - 1 ? DBG_WARNING : DBG_ERROR,
|
|
"Font not added, result = %i.\n"
|
|
" PFM: %s\n"
|
|
" PFB: %s\n"
|
|
" MMM: %s\n",
|
|
Result,
|
|
PfmFile,
|
|
PfbFile,
|
|
MmmFile
|
|
));
|
|
|
|
return Result == ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
PCTSTR
|
|
pGetAtmMultiSz (
|
|
POOLHANDLE Pool,
|
|
PCTSTR InfName,
|
|
PCTSTR SectionName,
|
|
PCTSTR KeyName
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pGetAtmMultiSz returns a multi-sz of the ATM font file names in the order
|
|
of PFM, PFB and MMM. Profile APIs are used because the key names have
|
|
commas, and they are unquoted.
|
|
|
|
Arguments:
|
|
|
|
Pool - Specifies the pool where the multi-sz will allocate buffer
|
|
space from.
|
|
InfName - Specifies the full path to the INF, to be used with the
|
|
profile APIs.
|
|
SectionName - Specifies the section name in InfName that is being processed.
|
|
KeyName - Specifies the key name to process
|
|
|
|
Return Value:
|
|
|
|
A pointer to a multi-sz allocated in the specified pool.
|
|
|
|
--*/
|
|
|
|
{
|
|
PTSTR MultiSz;
|
|
PTSTR d;
|
|
TCHAR FileBuf[MAX_TCHAR_PATH * 2];
|
|
UINT Bytes;
|
|
|
|
GetPrivateProfileString (
|
|
SectionName,
|
|
KeyName,
|
|
TEXT(""),
|
|
FileBuf,
|
|
sizeof (FileBuf) / sizeof (FileBuf[0]),
|
|
InfName
|
|
);
|
|
|
|
//
|
|
// Turn all commas into nuls
|
|
//
|
|
|
|
d = FileBuf;
|
|
|
|
while (*d) {
|
|
if (_tcsnextc (d) == TEXT(',')) {
|
|
*d = 0;
|
|
}
|
|
|
|
d = _tcsinc (d);
|
|
}
|
|
|
|
//
|
|
// Terminate the multi-sz
|
|
//
|
|
|
|
d++;
|
|
*d = 0;
|
|
d++;
|
|
|
|
//
|
|
// Transfer to a pool-based allocation and return it
|
|
//
|
|
|
|
Bytes = (UINT) ((PBYTE) d - (PBYTE) FileBuf);
|
|
|
|
MultiSz = (PTSTR) PoolMemGetAlignedMemory (Pool, Bytes);
|
|
|
|
CopyMemory (MultiSz, FileBuf, Bytes);
|
|
|
|
return MultiSz;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pEnumAtmFontWorker (
|
|
IN OUT PATM_FONT_ENUM EnumPtr
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pEnumAtmFontWorker implements the logic of parsing ATM.INI to get the Adobe
|
|
font names. This routine completes an enumeration started by
|
|
pEnumFirstAtmFont or pEnumNextAtmFont.
|
|
|
|
Arguments:
|
|
|
|
EnumPtr - Specifies a partially completed enumeration structure, receives a
|
|
fully completed structure.
|
|
|
|
Return Value:
|
|
|
|
TRUE if an ATM font was enumerated, FALSE otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
PTSTR p;
|
|
PCTSTR MultiSz;
|
|
BOOL MetricFileExists;
|
|
|
|
//
|
|
// Get PFM, PFB and MMM files
|
|
//
|
|
|
|
MultiSz = pGetAtmMultiSz (
|
|
EnumPtr->Pool,
|
|
EnumPtr->InfName,
|
|
S_FONTS,
|
|
EnumPtr->KeyNames
|
|
);
|
|
|
|
if (!MultiSz) {
|
|
return FALSE;
|
|
}
|
|
|
|
if (*MultiSz) {
|
|
_tcssafecpy (EnumPtr->PfmFile, MultiSz, MAX_TCHAR_PATH);
|
|
MultiSz = GetEndOfString (MultiSz) + 1;
|
|
}
|
|
|
|
if (*MultiSz) {
|
|
_tcssafecpy (EnumPtr->PfbFile, MultiSz, MAX_TCHAR_PATH);
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
|
|
MultiSz = pGetAtmMultiSz (
|
|
EnumPtr->Pool,
|
|
EnumPtr->InfName,
|
|
S_MMFONTS,
|
|
EnumPtr->KeyNames
|
|
);
|
|
|
|
if (MultiSz) {
|
|
_tcssafecpy (EnumPtr->MmmFile, MultiSz, MAX_TCHAR_PATH);
|
|
MultiSz = GetEndOfString (MultiSz) + 1;
|
|
|
|
if (*MultiSz) {
|
|
DEBUGMSG_IF ((
|
|
!StringIMatch (MultiSz, EnumPtr->PfbFile),
|
|
DBG_ERROR,
|
|
"ATM.INI: MMFonts and Fonts specify two different PFBs: %s and %s",
|
|
MultiSz,
|
|
EnumPtr->PfbFile
|
|
));
|
|
}
|
|
} else {
|
|
EnumPtr->MmmFile[0] = 0;
|
|
}
|
|
|
|
//
|
|
// Special case: .MMM is listed in [Fonts]
|
|
//
|
|
|
|
p = _tcsrchr (EnumPtr->PfmFile, TEXT('.'));
|
|
if (p && p < _tcschr (p, TEXT('\\'))) {
|
|
p = NULL;
|
|
}
|
|
|
|
if (p && StringIMatch (p, TEXT(".mmm"))) {
|
|
EnumPtr->PfmFile[0] = 0;
|
|
}
|
|
|
|
//
|
|
// Special case: .MMM exists but is not listed in atm.ini
|
|
//
|
|
|
|
if (!EnumPtr->MmmFile[0]) {
|
|
|
|
StringCopy (EnumPtr->MmmFile, EnumPtr->PfmFile);
|
|
|
|
p = _tcsrchr (EnumPtr->MmmFile, TEXT('.'));
|
|
if (p && p < _tcschr (p, TEXT('\\'))) {
|
|
p = NULL;
|
|
}
|
|
|
|
if (p) {
|
|
StringCopy (p, TEXT(".mmm"));
|
|
if (!DoesFileExist (EnumPtr->MmmFile)) {
|
|
EnumPtr->MmmFile[0] = 0;
|
|
}
|
|
} else {
|
|
EnumPtr->MmmFile[0] = 0;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Verify all files exist
|
|
//
|
|
|
|
MetricFileExists = FALSE;
|
|
|
|
if (EnumPtr->PfmFile[0] && DoesFileExist (EnumPtr->PfmFile)) {
|
|
MetricFileExists = TRUE;
|
|
}
|
|
|
|
if (EnumPtr->MmmFile[0] && DoesFileExist (EnumPtr->MmmFile)) {
|
|
MetricFileExists = TRUE;
|
|
}
|
|
|
|
if (!DoesFileExist (EnumPtr->PfbFile) || !MetricFileExists) {
|
|
|
|
DEBUGMSG ((
|
|
DBG_VERBOSE,
|
|
"At least one file is missing: %s, %s or %s",
|
|
EnumPtr->PfmFile[0] ? EnumPtr->PfmFile : TEXT("(no PFM specified)"),
|
|
EnumPtr->MmmFile[0] ? EnumPtr->MmmFile : TEXT("(no MMM specified)"),
|
|
EnumPtr->PfbFile
|
|
));
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
VOID
|
|
pAbortAtmFontEnum (
|
|
IN OUT PATM_FONT_ENUM EnumPtr
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pAbortAtmFontEnum cleans up an enumeration structure after enumeration
|
|
completes or if enumeration needs to be aborted. This routine can safely be
|
|
called multiple times on the same structure.
|
|
|
|
Arguments:
|
|
|
|
EnumPtr - Specifies an initialized and possibly used enumeration structure.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
if (EnumPtr->Pool) {
|
|
PoolMemDestroyPool (EnumPtr->Pool);
|
|
}
|
|
|
|
ZeroMemory (EnumPtr, sizeof (ATM_FONT_ENUM));
|
|
}
|
|
|
|
|
|
BOOL
|
|
pEnumNextAtmFont (
|
|
IN OUT PATM_FONT_ENUM EnumPtr
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pEnumNextAtmFont continues enumeration, returning either another set of ATM
|
|
font paths, or FALSE.
|
|
|
|
Arguments:
|
|
|
|
EnumPtr - Specifies the enumeration structure started by pEnumNextAtmFont.
|
|
|
|
Return Value:
|
|
|
|
TRUE if another set of font paths is available, FALSE otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
if (!EnumPtr->KeyNames || !(*EnumPtr->KeyNames)) {
|
|
pAbortAtmFontEnum (EnumPtr);
|
|
return FALSE;
|
|
}
|
|
|
|
//
|
|
// Continue enumeration, looping until a font path set was found,
|
|
// or there are no more atm.ini lines to enumerate.
|
|
//
|
|
|
|
do {
|
|
EnumPtr->KeyNames = GetEndOfString (EnumPtr->KeyNames) + 1;
|
|
|
|
if (!(*EnumPtr->KeyNames)) {
|
|
pAbortAtmFontEnum (EnumPtr);
|
|
return FALSE;
|
|
}
|
|
|
|
} while (!pEnumAtmFontWorker (EnumPtr));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pEnumFirstAtmFont (
|
|
OUT PATM_FONT_ENUM EnumPtr
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
pEnumFirstAtmFont begins the enumeration of font path sets in ATM.INI.
|
|
|
|
Arguments:
|
|
|
|
EnumPtr - Receivies the first set of font paths found (if any).
|
|
|
|
Return Value:
|
|
|
|
TRUE if a font path set was found, FALSE otherwise.
|
|
|
|
--*/
|
|
|
|
{
|
|
TCHAR AtmIni[MAX_TCHAR_PATH];
|
|
PTSTR FilePart;
|
|
PTSTR KeyNames;
|
|
UINT Bytes;
|
|
|
|
//
|
|
// Init structure
|
|
//
|
|
|
|
ZeroMemory (EnumPtr, sizeof (ATM_FONT_ENUM));
|
|
|
|
//
|
|
// Find full path to atm.ini (usually in %windir%)
|
|
//
|
|
|
|
if (!SearchPath (NULL, TEXT("atm.ini"), NULL, MAX_TCHAR_PATH, AtmIni, &FilePart)) {
|
|
DEBUGMSG ((DBG_VERBOSE, "ATM.INI not found in search path"));
|
|
return FALSE;
|
|
}
|
|
|
|
StringCopy (EnumPtr->InfName, AtmIni);
|
|
|
|
//
|
|
// Establish processing pool and get all key names in [Fonts]
|
|
//
|
|
|
|
EnumPtr->Pool = PoolMemInitNamedPool ("ATM Font Enum");
|
|
MYASSERT (EnumPtr->Pool);
|
|
|
|
KeyNames = MemAlloc (g_hHeap, 0, MAX_KEY_NAME_LIST);
|
|
|
|
GetPrivateProfileString (
|
|
S_FONTS,
|
|
NULL,
|
|
TEXT(""),
|
|
KeyNames,
|
|
MAX_KEY_NAME_LIST,
|
|
AtmIni
|
|
);
|
|
|
|
Bytes = SizeOfMultiSz (KeyNames);
|
|
|
|
EnumPtr->KeyNames = (PTSTR) PoolMemGetAlignedMemory (EnumPtr->Pool, Bytes);
|
|
CopyMemory (EnumPtr->KeyNames, KeyNames, Bytes);
|
|
|
|
MemFree (g_hHeap, 0, KeyNames);
|
|
|
|
//
|
|
// Begin enumeration
|
|
//
|
|
|
|
if (!(*EnumPtr->KeyNames)) {
|
|
pAbortAtmFontEnum (EnumPtr);
|
|
return FALSE;
|
|
}
|
|
|
|
if (pEnumAtmFontWorker (EnumPtr)) {
|
|
return TRUE;
|
|
}
|
|
|
|
return pEnumNextAtmFont (EnumPtr);
|
|
}
|
|
|
|
|
|
DWORD
|
|
MigrateAtmFonts (
|
|
DWORD Request
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
MigrateAtmFonts is called by the progress bar to query ticks or to migrate
|
|
ATM fonts.
|
|
|
|
Arguments:
|
|
|
|
Request - Specifies the reason the progress bar is calling the routine.
|
|
|
|
Return Value:
|
|
|
|
If Request is REQUEST_QUERYTICKS, then the return value is the number of
|
|
estimated ticks needed to complete processing. Otherwise the return value
|
|
is ERROR_SUCCESS.
|
|
|
|
--*/
|
|
|
|
{
|
|
ATM_FONT_ENUM e;
|
|
static HANDLE AtmLib;
|
|
TCHAR AtmIniPath[MAX_TCHAR_PATH];
|
|
|
|
if (Request == REQUEST_QUERYTICKS) {
|
|
|
|
//
|
|
// Dynamically load atmlib.dll
|
|
//
|
|
|
|
AtmAddFontEx = NULL;
|
|
|
|
AtmLib = LoadLibrary (TEXT("atmlib.dll"));
|
|
if (!AtmLib) {
|
|
DEBUGMSG ((DBG_ERROR, "Cannot load entry point from atmlib.dll!"));
|
|
} else {
|
|
(FARPROC) AtmAddFontEx = GetProcAddress (AtmLib, "ATMAddFontExW");
|
|
DEBUGMSG_IF ((!AtmAddFontEx, DBG_ERROR, "Cannot get entry point ATMAddFontExW in atmlib.dll!"));
|
|
}
|
|
|
|
return AtmAddFontEx ? TICKS_ATM_MIGRATION : 0;
|
|
|
|
} else if (Request != REQUEST_RUN) {
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
if (AtmAddFontEx) {
|
|
//
|
|
// Do the ATM font migration
|
|
//
|
|
|
|
if (pEnumFirstAtmFont (&e)) {
|
|
|
|
StringCopy (AtmIniPath, e.InfName);
|
|
|
|
do {
|
|
|
|
if (pRegisterAtmFont (e.PfmFile, e.PfbFile, e.MmmFile)) {
|
|
DEBUGMSG ((DBG_VERBOSE, "ATM font registered %s", e.PfbFile));
|
|
}
|
|
|
|
} while (pEnumNextAtmFont (&e));
|
|
|
|
DeclareTemporaryFile (AtmIniPath);
|
|
|
|
#ifdef DEBUG
|
|
g_NoReloadsAllowed = TRUE;
|
|
#endif
|
|
|
|
}
|
|
|
|
//
|
|
// Clean up use of atmlib.dll - we're finished
|
|
//
|
|
|
|
FreeLibrary (AtmLib);
|
|
AtmLib = NULL;
|
|
AtmAddFontEx = NULL;
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
|
|
DWORD
|
|
RunSystemExternalProcesses (
|
|
IN DWORD Request
|
|
)
|
|
{
|
|
LONG Count;
|
|
|
|
if (Request == REQUEST_QUERYTICKS) {
|
|
//
|
|
// Count the number of entries and multiply by a constant
|
|
//
|
|
|
|
Count = SetupGetLineCount (g_WkstaMigInf, S_EXTERNAL_PROCESSES);
|
|
|
|
#ifdef PROGRESS_BAR
|
|
DEBUGLOGTIME (("RunSystemExternalProcesses: ExternalProcesses=%ld", Count));
|
|
#endif
|
|
|
|
if (Count < 1) {
|
|
return 0;
|
|
}
|
|
|
|
return Count * TICKS_SYSTEM_EXTERN_PROCESSES;
|
|
}
|
|
|
|
if (Request != REQUEST_RUN) {
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Loop through the processes and run each of them
|
|
//
|
|
RunExternalProcesses (g_WkstaMigInf, NULL);
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pEnumFirstWin9xBriefcase (
|
|
OUT PBRIEFCASE_ENUM e
|
|
)
|
|
{
|
|
if (!MemDbGetValueEx (&e->mde, MEMDB_CATEGORY_BRIEFCASES, NULL, NULL)) {
|
|
return FALSE;
|
|
}
|
|
e->BrfcaseDb = e->mde.szName;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pEnumNextWin9xBriefcase (
|
|
IN OUT PBRIEFCASE_ENUM e
|
|
)
|
|
{
|
|
if (!MemDbEnumNextValue (&e->mde)) {
|
|
return FALSE;
|
|
}
|
|
e->BrfcaseDb = e->mde.szName;
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
pMigrateBriefcase (
|
|
IN PCTSTR BriefcaseDatabase,
|
|
IN PCTSTR BriefcaseDir
|
|
)
|
|
{
|
|
HBRFCASE hbrfcase;
|
|
PTSTR NtPath;
|
|
BOOL Save, Success;
|
|
TWINRESULT tr;
|
|
BRFPATH_ENUM e;
|
|
BOOL Result = TRUE;
|
|
|
|
__try {
|
|
|
|
g_BrfcasePool = PoolMemInitNamedPool ("Briefcase");
|
|
if (!g_BrfcasePool) {
|
|
return FALSE;
|
|
}
|
|
|
|
tr = OpenBriefcase (BriefcaseDatabase, OB_FL_OPEN_DATABASE, NULL, &hbrfcase);
|
|
if (tr == TR_SUCCESS) {
|
|
|
|
if (EnumFirstBrfcasePath (hbrfcase, &e)) {
|
|
|
|
Save = FALSE;
|
|
Success = TRUE;
|
|
|
|
do {
|
|
if (StringIMatch (BriefcaseDir, e.PathString)) {
|
|
//
|
|
// ignore this path
|
|
//
|
|
continue;
|
|
}
|
|
|
|
NtPath = GetPathStringOnNt (e.PathString);
|
|
MYASSERT (NtPath);
|
|
|
|
if (!StringIMatch (NtPath, e.PathString)) {
|
|
//
|
|
// try to replace Win9x path with NT path
|
|
//
|
|
if (!ReplaceBrfcasePath (&e, NtPath)) {
|
|
Success = FALSE;
|
|
break;
|
|
}
|
|
Save = TRUE;
|
|
}
|
|
|
|
FreePathString (NtPath);
|
|
|
|
} while (EnumNextBrfcasePath (&e));
|
|
|
|
if (!Success || Save && SaveBriefcase (hbrfcase) != TR_SUCCESS) {
|
|
Result = FALSE;
|
|
}
|
|
}
|
|
|
|
CloseBriefcase(hbrfcase);
|
|
}
|
|
}
|
|
__finally {
|
|
PoolMemDestroyPool (g_BrfcasePool);
|
|
g_BrfcasePool = NULL;
|
|
}
|
|
|
|
return Result;
|
|
}
|
|
|
|
|
|
DWORD
|
|
MigrateBriefcases (
|
|
DWORD Request
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
MigrateBriefcases is called by the progress bar to query ticks or to migrate
|
|
briefcases.
|
|
|
|
Arguments:
|
|
|
|
Request - Specifies the reason the progress bar is calling the routine.
|
|
|
|
Return Value:
|
|
|
|
If Request is REQUEST_QUERYTICKS, then the return value is the number of
|
|
estimated ticks needed to complete processing. Otherwise the return value
|
|
is ERROR_SUCCESS.
|
|
|
|
--*/
|
|
|
|
{
|
|
BRIEFCASE_ENUM e;
|
|
TCHAR BrfcaseDir[MAX_PATH + 2];
|
|
PTSTR p;
|
|
PTSTR BrfcaseDbOnNt;
|
|
|
|
switch (Request) {
|
|
|
|
case REQUEST_QUERYTICKS:
|
|
return TICKS_MIGRATE_BRIEFCASES;
|
|
|
|
case REQUEST_RUN:
|
|
//
|
|
// Enumerate all the briefcases that need to be processed
|
|
//
|
|
if (pEnumFirstWin9xBriefcase (&e)) {
|
|
do {
|
|
BrfcaseDbOnNt = GetPathStringOnNt (e.BrfcaseDb);
|
|
MYASSERT (BrfcaseDbOnNt);
|
|
//
|
|
// get directory name first
|
|
//
|
|
if (CharCount (BrfcaseDbOnNt) <= MAX_PATH) {
|
|
StringCopy (BrfcaseDir, BrfcaseDbOnNt);
|
|
p = _tcsrchr (BrfcaseDir, TEXT('\\'));
|
|
if (p) {
|
|
*p = 0;
|
|
if (!pMigrateBriefcase (BrfcaseDbOnNt, BrfcaseDir)) {
|
|
LOG ((
|
|
LOG_WARNING,
|
|
(PCSTR)MSG_ERROR_MIGRATING_BRIEFCASE,
|
|
BrfcaseDir
|
|
));
|
|
}
|
|
}
|
|
}
|
|
FreePathString (BrfcaseDbOnNt);
|
|
} while (pEnumNextWin9xBriefcase (&e));
|
|
}
|
|
ELSE_DEBUGMSG ((DBG_NAUSEA, "MigrateBriefcases: Nothing to do"));
|
|
break;
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
DWORD
|
|
RunSystemUninstallUserProfileCleanupPreparation (
|
|
IN DWORD Request
|
|
)
|
|
{
|
|
LONG Count;
|
|
|
|
if (Request == REQUEST_QUERYTICKS) {
|
|
//
|
|
// Count the number of entries and multiply by a constant
|
|
//
|
|
|
|
Count = SetupGetLineCount (g_WkstaMigInf, S_UNINSTALL_PROFILE_CLEAN_OUT);
|
|
|
|
#ifdef PROGRESS_BAR
|
|
DEBUGLOGTIME (("RunSystemUninstallUserProfileCleanupPreparation: FileNumber=%ld", Count));
|
|
#endif
|
|
|
|
if (Count < 1) {
|
|
return 1;
|
|
}
|
|
|
|
return Count * TICKS_SYSTEM_UNINSTALL_CLEANUP;
|
|
}
|
|
|
|
if (Request != REQUEST_RUN) {
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Loop through the files and mark them to be deleted during uninstall
|
|
//
|
|
UninstallUserProfileCleanupPreparation (g_WkstaMigInf, NULL, TRUE);
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
DWORD
|
|
AddOptionsDiskCleaner (
|
|
DWORD Request
|
|
)
|
|
{
|
|
HKEY key = NULL;
|
|
HKEY subKey = NULL;
|
|
PCTSTR optionsPath;
|
|
LONG rc;
|
|
PCTSTR descText = NULL;
|
|
DWORD d;
|
|
|
|
if (Request == REQUEST_QUERYTICKS) {
|
|
return 1;
|
|
}
|
|
|
|
if (Request != REQUEST_RUN) {
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
optionsPath = JoinPaths (g_WinDir, TEXT("OPTIONS"));
|
|
|
|
__try {
|
|
if (!DoesFileExist (optionsPath)) {
|
|
__leave;
|
|
}
|
|
|
|
key = OpenRegKeyStr (TEXT("HKLM\\SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Explorer\\VolumeCaches"));
|
|
|
|
if (!key) {
|
|
DEBUGMSG ((DBG_ERROR, "Can't open VolumeCaches"));
|
|
__leave;
|
|
}
|
|
|
|
subKey = CreateRegKey (key, TEXT("Options Folder"));
|
|
|
|
if (!subKey) {
|
|
DEBUGMSG ((DBG_ERROR, "Can't create Options Folder"));
|
|
__leave;
|
|
}
|
|
|
|
rc = RegSetValueEx (
|
|
subKey,
|
|
TEXT(""),
|
|
0,
|
|
REG_SZ,
|
|
(PBYTE) S_CLEANER_GUID,
|
|
sizeof (S_CLEANER_GUID)
|
|
);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
DEBUGMSG ((DBG_ERROR, "Can't write default value to Options Folder key"));
|
|
}
|
|
|
|
descText = GetStringResource (MSG_OPTIONS_CLEANER);
|
|
rc = RegSetValueEx (
|
|
subKey,
|
|
TEXT("Description"),
|
|
0,
|
|
REG_SZ,
|
|
(PBYTE) descText,
|
|
SizeOfString (descText)
|
|
);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
DEBUGMSG ((DBG_ERROR, "Can't write Description value to Options Folder key"));
|
|
}
|
|
|
|
FreeStringResource (descText);
|
|
|
|
descText = GetStringResource (MSG_OPTIONS_CLEANER_TITLE);
|
|
rc = RegSetValueEx (
|
|
subKey,
|
|
TEXT("Display"),
|
|
0,
|
|
REG_SZ,
|
|
(PBYTE) descText,
|
|
SizeOfString (descText)
|
|
);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
DEBUGMSG ((DBG_ERROR, "Can't write Display value to Options Folder key"));
|
|
}
|
|
|
|
rc = RegSetValueEx (
|
|
subKey,
|
|
TEXT("FileList"),
|
|
0,
|
|
REG_SZ,
|
|
(PBYTE) S_CLEANER_ALL_FILES,
|
|
sizeof (S_CLEANER_ALL_FILES)
|
|
);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
DEBUGMSG ((DBG_ERROR, "Can't write FileList value to Options Folder key"));
|
|
}
|
|
|
|
rc = RegSetValueEx (
|
|
subKey,
|
|
TEXT("Folder"),
|
|
0,
|
|
REG_SZ,
|
|
(PBYTE) optionsPath,
|
|
SizeOfString (optionsPath)
|
|
);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
DEBUGMSG ((DBG_ERROR, "Can't write Folder value to Options Folder key"));
|
|
}
|
|
|
|
d = 0x17F; // see shell\applets\cleaner\dataclen\common.h DDEVCF_* flags
|
|
rc = RegSetValueEx (
|
|
subKey,
|
|
TEXT("Flags"),
|
|
0,
|
|
REG_DWORD,
|
|
(PBYTE) &d,
|
|
sizeof (d)
|
|
);
|
|
|
|
if (rc != ERROR_SUCCESS) {
|
|
DEBUGMSG ((DBG_ERROR, "Can't write flags to Options Folder key"));
|
|
}
|
|
}
|
|
__finally {
|
|
FreePathString (optionsPath);
|
|
if (key) {
|
|
CloseRegKey (key);
|
|
}
|
|
if (subKey) {
|
|
CloseRegKey (subKey);
|
|
}
|
|
|
|
FreeStringResource (descText);
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|