You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
595 lines
13 KiB
595 lines
13 KiB
/*++
|
|
|
|
Copyright (c) 1998 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
regrep.c
|
|
|
|
Abstract:
|
|
|
|
Implements a registry search/replace tool.
|
|
|
|
Author:
|
|
|
|
Jim Schmidt (jimschm) 19-Apr-1999
|
|
|
|
Revision History:
|
|
|
|
<full name> (<alias>) <date> <comments>
|
|
|
|
--*/
|
|
|
|
#include "pch.h"
|
|
|
|
HANDLE g_hHeap;
|
|
HINSTANCE g_hInst;
|
|
|
|
#ifdef DEBUG
|
|
|
|
#pragma message ("WARNING: Checked builds are very slow")
|
|
|
|
#endif
|
|
|
|
BOOL WINAPI MigUtil_Entry (HINSTANCE, DWORD, PVOID);
|
|
|
|
BOOL
|
|
pCallEntryPoints (
|
|
DWORD Reason
|
|
)
|
|
{
|
|
HINSTANCE Instance;
|
|
|
|
//
|
|
// Simulate DllMain
|
|
//
|
|
|
|
Instance = g_hInst;
|
|
|
|
//
|
|
// Initialize the common libs
|
|
//
|
|
|
|
if (!MigUtil_Entry (Instance, Reason, NULL)) {
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
BOOL
|
|
Init (
|
|
VOID
|
|
)
|
|
{
|
|
g_hHeap = GetProcessHeap();
|
|
g_hInst = GetModuleHandle (NULL);
|
|
|
|
return pCallEntryPoints (DLL_PROCESS_ATTACH);
|
|
}
|
|
|
|
|
|
VOID
|
|
Terminate (
|
|
VOID
|
|
)
|
|
{
|
|
pCallEntryPoints (DLL_PROCESS_DETACH);
|
|
}
|
|
|
|
|
|
VOID
|
|
HelpAndExit (
|
|
VOID
|
|
)
|
|
{
|
|
//
|
|
// This routine is called whenever command line args are wrong
|
|
//
|
|
|
|
_ftprintf (
|
|
stderr,
|
|
TEXT("Command Line Syntax:\n\n")
|
|
|
|
TEXT(" regrep <srch> <rep> [-r:root] [-p]\n")
|
|
|
|
TEXT("\nDescription:\n\n")
|
|
|
|
TEXT(" RegRep implements a registry search and replace. It updates\n")
|
|
TEXT(" all instances of <srch> with <rep>.\n")
|
|
|
|
TEXT("\nArguments:\n\n")
|
|
|
|
TEXT(" <srch> Specifies the search text\n")
|
|
TEXT(" <rep> Specifies the replace text\n")
|
|
TEXT(" -r Specifies the root key to process, such as HKLM\\Software.\n")
|
|
TEXT(" If not specified, the entire registry is processed.\n")
|
|
TEXT(" -p Enables progress output\n")
|
|
|
|
);
|
|
|
|
exit (1);
|
|
}
|
|
|
|
|
|
VOID
|
|
pUpdateKeyNames (
|
|
IN PCTSTR Search,
|
|
IN PCTSTR Replace,
|
|
IN PCTSTR RootKey
|
|
);
|
|
|
|
VOID
|
|
pUpdateValueNames (
|
|
IN PCTSTR Search,
|
|
IN PCTSTR Replace,
|
|
IN PCTSTR RootKey
|
|
);
|
|
|
|
VOID
|
|
pUpdateValueData (
|
|
IN PCTSTR Search,
|
|
IN PCTSTR Replace,
|
|
IN PCTSTR RootKey
|
|
);
|
|
|
|
|
|
BOOL g_ShowProgress = FALSE;
|
|
|
|
|
|
VOID
|
|
pProgress (
|
|
VOID
|
|
)
|
|
{
|
|
static CHAR String[] = "...... ";
|
|
static DWORD Ticks = 0;
|
|
PSTR p;
|
|
|
|
if (GetTickCount() - Ticks < 500) {
|
|
return;
|
|
}
|
|
|
|
Ticks = GetTickCount();
|
|
|
|
if (!g_ShowProgress) {
|
|
return;
|
|
}
|
|
|
|
p = strchr (String, ' ');
|
|
*p = '.';
|
|
p++;
|
|
if (!*p) {
|
|
p = String;
|
|
}
|
|
*p = ' ';
|
|
|
|
printf ("%s\r", String);
|
|
}
|
|
|
|
|
|
INT
|
|
__cdecl
|
|
_tmain (
|
|
INT argc,
|
|
PCTSTR argv[]
|
|
)
|
|
{
|
|
INT i;
|
|
PCTSTR Root = NULL;
|
|
PCTSTR Search = NULL;
|
|
PCTSTR Replace = NULL;
|
|
|
|
//
|
|
// TODO: Parse command line here
|
|
//
|
|
|
|
for (i = 1 ; i < argc ; i++) {
|
|
if (argv[i][0] == TEXT('/') || argv[i][0] == TEXT('-')) {
|
|
switch (_totlower (_tcsnextc (&argv[i][1]))) {
|
|
|
|
case TEXT('r'):
|
|
|
|
if (Root) {
|
|
HelpAndExit();
|
|
}
|
|
|
|
if (argv[i][2] == TEXT(':')) {
|
|
Root = &argv[i][3];
|
|
} else if (i + 1 < argc) {
|
|
Root = argv[++i];
|
|
} else {
|
|
HelpAndExit();
|
|
}
|
|
|
|
break;
|
|
|
|
case TEXT('p'):
|
|
if (g_ShowProgress) {
|
|
HelpAndExit();
|
|
}
|
|
|
|
g_ShowProgress = TRUE;
|
|
break;
|
|
|
|
default:
|
|
HelpAndExit();
|
|
}
|
|
} else {
|
|
//
|
|
// Parse other args that don't require / or -
|
|
//
|
|
|
|
if (!Search) {
|
|
Search = argv[i];
|
|
} else if (!Replace) {
|
|
Replace = argv[i];
|
|
} else {
|
|
HelpAndExit();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!Replace) {
|
|
HelpAndExit();
|
|
}
|
|
|
|
//
|
|
// Begin processing
|
|
//
|
|
|
|
if (!Init()) {
|
|
return 0;
|
|
}
|
|
|
|
//
|
|
// Pass one - fix all the registry key names
|
|
//
|
|
|
|
if (!Root) {
|
|
pUpdateKeyNames (Search, Replace, TEXT("HKLM"));
|
|
pUpdateKeyNames (Search, Replace, TEXT("HKU"));
|
|
} else {
|
|
pUpdateKeyNames (Search, Replace, Root);
|
|
}
|
|
|
|
//
|
|
// Pass two - fix all value names
|
|
//
|
|
|
|
if (!Root) {
|
|
pUpdateValueNames (Search, Replace, TEXT("HKLM"));
|
|
pUpdateValueNames (Search, Replace, TEXT("HKU"));
|
|
} else {
|
|
pUpdateValueNames (Search, Replace, Root);
|
|
}
|
|
|
|
//
|
|
// Pass three - fix all value data
|
|
//
|
|
|
|
if (!Root) {
|
|
pUpdateValueData (Search, Replace, TEXT("HKLM"));
|
|
pUpdateValueData (Search, Replace, TEXT("HKU"));
|
|
} else {
|
|
pUpdateValueData (Search, Replace, Root);
|
|
}
|
|
|
|
|
|
//
|
|
// End of processing
|
|
//
|
|
|
|
Terminate();
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
VOID
|
|
pMoveKey (
|
|
IN PCTSTR SourceKey,
|
|
IN PCTSTR DestKey
|
|
)
|
|
{
|
|
HKEY Src;
|
|
HKEY Dest;
|
|
REGVALUE_ENUM e;
|
|
DWORD Size;
|
|
PBYTE Data;
|
|
LONG rc;
|
|
GROWBUFFER Buf = GROWBUF_INIT;
|
|
|
|
Src = OpenRegKeyStr (SourceKey);
|
|
Dest = CreateRegKeyStr (DestKey);
|
|
|
|
pProgress();
|
|
|
|
if (Src && Dest) {
|
|
if (EnumFirstRegValue (&e, Src)) {
|
|
|
|
Buf.End = 0;
|
|
Data = GrowBuffer (&Buf, e.DataSize);
|
|
if (Data) {
|
|
|
|
Size = e.DataSize;
|
|
rc = RegQueryValueEx (
|
|
Src,
|
|
e.ValueName,
|
|
NULL,
|
|
NULL,
|
|
Data,
|
|
&Size
|
|
);
|
|
|
|
if (rc == ERROR_SUCCESS) {
|
|
|
|
rc = RegSetValueEx (Dest, e.ValueName, 0, e.Type, Data, Size);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
CloseRegKey (Src);
|
|
CloseRegKey (Dest);
|
|
|
|
FreeGrowBuffer (&Buf);
|
|
}
|
|
|
|
|
|
VOID
|
|
pMoveKeyTree (
|
|
IN PCTSTR SourceKey,
|
|
IN PCTSTR DestKey
|
|
)
|
|
{
|
|
REGTREE_ENUM e;
|
|
TCHAR DestSubKey[MAX_REGISTRY_KEY];
|
|
PTSTR p;
|
|
GROWLIST List = GROWLIST_INIT;
|
|
UINT Count;
|
|
UINT u;
|
|
PCTSTR Item;
|
|
DWORD Len;
|
|
|
|
StringCopy (DestSubKey, DestKey);
|
|
p = AppendWack (DestSubKey);
|
|
|
|
if (EnumFirstRegKeyInTree (&e, SourceKey)) {
|
|
|
|
do {
|
|
|
|
StringCopy (p, (PCTSTR) ((PBYTE) e.FullKeyName + e.EnumBaseBytes));
|
|
pMoveKey (e.FullKeyName, DestSubKey);
|
|
GrowListAppendString (&List, e.FullKeyName);
|
|
|
|
} while (EnumNextRegKeyInTree (&e));
|
|
}
|
|
|
|
Count = GrowListGetSize (&List);
|
|
|
|
u = Count;
|
|
while (u > 0) {
|
|
u--;
|
|
|
|
Item = GrowListGetString (&List, u);
|
|
|
|
ConvertRootStringToKey (Item, &Len);
|
|
RegDeleteKey (ConvertRootStringToKey (Item, NULL), Item + Len);
|
|
}
|
|
|
|
FreeGrowList (&List);
|
|
}
|
|
|
|
|
|
VOID
|
|
pUpdateKeyNames (
|
|
IN PCTSTR Search,
|
|
IN PCTSTR Replace,
|
|
IN PCTSTR RootKey
|
|
)
|
|
{
|
|
REGTREE_ENUM e;
|
|
GROWLIST List = GROWLIST_INIT;
|
|
UINT Count;
|
|
UINT u;
|
|
PCTSTR OldKey;
|
|
PCTSTR NewKey;
|
|
|
|
if (g_ShowProgress) {
|
|
_tprintf ("Scanning for keys to update\n");
|
|
}
|
|
|
|
if (EnumFirstRegKeyInTree (&e, RootKey)) {
|
|
do {
|
|
pProgress();
|
|
|
|
if (_tcsistr (e.CurrentKey->KeyName, Search)) {
|
|
GrowListAppendString (&List, e.FullKeyName);
|
|
}
|
|
} while (EnumNextRegKeyInTree (&e));
|
|
}
|
|
|
|
Count = GrowListGetSize (&List);
|
|
u = Count;
|
|
|
|
if (g_ShowProgress) {
|
|
_tprintf ("Updating %u keys\n", Count);
|
|
}
|
|
|
|
while (u > 0) {
|
|
u--;
|
|
|
|
_tprintf (TEXT("%s\n"), GrowListGetString (&List, u));
|
|
|
|
OldKey = GrowListGetString (&List, u);
|
|
NewKey = StringSearchAndReplace (
|
|
OldKey,
|
|
Search,
|
|
Replace
|
|
);
|
|
|
|
pMoveKeyTree (OldKey, NewKey);
|
|
}
|
|
|
|
FreeGrowList (&List);
|
|
}
|
|
|
|
|
|
VOID
|
|
pUpdateValueNames (
|
|
IN PCTSTR Search,
|
|
IN PCTSTR Replace,
|
|
IN PCTSTR RootKey
|
|
)
|
|
{
|
|
REGTREE_ENUM e;
|
|
REGVALUE_ENUM ev;
|
|
GROWLIST List = GROWLIST_INIT;
|
|
HKEY Key;
|
|
UINT Count;
|
|
UINT u;
|
|
PBYTE Data;
|
|
DWORD Type;
|
|
DWORD Size;
|
|
PCTSTR ValueName;
|
|
PCTSTR NewValueName;
|
|
BOOL b;
|
|
LONG rc;
|
|
|
|
if (g_ShowProgress) {
|
|
_tprintf ("Processing all value names in the keys\n");
|
|
}
|
|
|
|
if (EnumFirstRegKeyInTree (&e, RootKey)) {
|
|
|
|
do {
|
|
pProgress();
|
|
|
|
Key = OpenRegKeyStr (e.FullKeyName);
|
|
|
|
if (Key) {
|
|
if (EnumFirstRegValue (&ev, Key)) {
|
|
do {
|
|
if (_tcsistr (ev.ValueName, Search)) {
|
|
GrowListAppendString (&List, ev.ValueName);
|
|
}
|
|
} while (EnumNextRegValue (&ev));
|
|
|
|
Count = GrowListGetSize (&List);
|
|
u = Count;
|
|
|
|
while (u > 0) {
|
|
u--;
|
|
|
|
ValueName = GrowListGetString (&List, u);
|
|
|
|
b = FALSE;
|
|
|
|
if (GetRegValueTypeAndSize (Key, ValueName, &Type, &Size)) {
|
|
|
|
Data = GetRegValueData (Key, ValueName);
|
|
if (Data) {
|
|
NewValueName = StringSearchAndReplace (
|
|
ValueName,
|
|
Search,
|
|
Replace
|
|
);
|
|
|
|
rc = RegSetValueEx (Key, NewValueName, 0, Type, Data, Size);
|
|
|
|
if (rc == ERROR_SUCCESS) {
|
|
if (!StringIMatch (ValueName, NewValueName)) {
|
|
rc = RegDeleteValue (Key, ValueName);
|
|
}
|
|
}
|
|
|
|
MemFree (g_hHeap, 0, Data);
|
|
FreePathString (NewValueName);
|
|
SetLastError (rc);
|
|
|
|
b = (rc == ERROR_SUCCESS);
|
|
}
|
|
}
|
|
|
|
if (b) {
|
|
_tprintf (TEXT("%s [%s]\n"), e.FullKeyName, ValueName);
|
|
} else {
|
|
_ftprintf (stderr, TEXT("Error %u updating %s [%s]\n"), GetLastError(), e.FullKeyName, ValueName);
|
|
}
|
|
}
|
|
}
|
|
|
|
FreeGrowList (&List);
|
|
CloseRegKey (Key);
|
|
|
|
} else {
|
|
_ftprintf (stderr, TEXT("Can't open %s\n"), Key);
|
|
}
|
|
|
|
} while (EnumNextRegKeyInTree (&e));
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
pUpdateValueData (
|
|
IN PCTSTR Search,
|
|
IN PCTSTR Replace,
|
|
IN PCTSTR RootKey
|
|
)
|
|
{
|
|
REGTREE_ENUM e;
|
|
REGVALUE_ENUM ev;
|
|
HKEY Key;
|
|
PCTSTR Data;
|
|
PCTSTR NewData;
|
|
LONG rc;
|
|
|
|
if (g_ShowProgress) {
|
|
_tprintf ("Processing all value data\n");
|
|
}
|
|
|
|
if (EnumFirstRegKeyInTree (&e, RootKey)) {
|
|
|
|
do {
|
|
pProgress();
|
|
|
|
Key = OpenRegKeyStr (e.FullKeyName);
|
|
|
|
if (Key) {
|
|
if (EnumFirstRegValue (&ev, Key)) {
|
|
do {
|
|
Data = GetRegValueString (Key, ev.ValueName);
|
|
|
|
if (Data) {
|
|
if (_tcsistr (Data, Search)) {
|
|
|
|
NewData = StringSearchAndReplace (Data, Search, Replace);
|
|
rc = RegSetValueEx (Key, ev.ValueName, 0, ev.Type, NewData, SizeOfString (NewData));
|
|
|
|
if (rc == ERROR_SUCCESS) {
|
|
_tprintf (TEXT("%s [%s] %s\n"), e.FullKeyName, ev.ValueName, Data);
|
|
} else {
|
|
_ftprintf (stderr, TEXT("Error %u updating %s [%s] %s\n"), GetLastError(), e.FullKeyName, ev.ValueName, Data);
|
|
}
|
|
|
|
FreePathString (NewData);
|
|
}
|
|
|
|
MemFree (g_hHeap, 0, Data);
|
|
}
|
|
|
|
} while (EnumNextRegValue (&ev));
|
|
}
|
|
|
|
CloseRegKey (Key);
|
|
|
|
} else {
|
|
_ftprintf (stderr, TEXT("Can't open %s\n"), Key);
|
|
}
|
|
} while (EnumNextRegKeyInTree (&e));
|
|
}
|
|
}
|