Added command line tool to access the registry.
This commit is contained in:
Sylvain St.Germain
Alexandre Julliard
parent
0dd1b5b239
commit
1bb0e66fa2
|
|
@ -4643,6 +4643,7 @@ programs/avitools/Makefile
|
|||
programs/notepad/Makefile
|
||||
programs/progman/Makefile
|
||||
programs/regtest/Makefile
|
||||
programs/regapi/Makefile
|
||||
programs/view/Makefile
|
||||
programs/winhelp/Makefile
|
||||
programs/winver/Makefile
|
||||
|
|
@ -4806,6 +4807,7 @@ programs/avitools/Makefile
|
|||
programs/notepad/Makefile
|
||||
programs/progman/Makefile
|
||||
programs/regtest/Makefile
|
||||
programs/regapi/Makefile
|
||||
programs/view/Makefile
|
||||
programs/winhelp/Makefile
|
||||
programs/winver/Makefile
|
||||
|
|
|
|||
|
|
@ -668,6 +668,7 @@ programs/avitools/Makefile
|
|||
programs/notepad/Makefile
|
||||
programs/progman/Makefile
|
||||
programs/regtest/Makefile
|
||||
programs/regapi/Makefile
|
||||
programs/view/Makefile
|
||||
programs/winhelp/Makefile
|
||||
programs/winver/Makefile
|
||||
|
|
|
|||
|
|
@ -5,6 +5,7 @@ SUBDIRS = \
|
|||
control \
|
||||
notepad \
|
||||
progman \
|
||||
regapi \
|
||||
regtest \
|
||||
view \
|
||||
winhelp \
|
||||
|
|
|
|||
|
|
@ -0,0 +1,2 @@
|
|||
Makefile
|
||||
regapi
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
DEFS = -DWINELIB
|
||||
TOPSRCDIR = @top_srcdir@
|
||||
TOPOBJDIR = ../..
|
||||
SRCDIR = @srcdir@
|
||||
VPATH = @srcdir@
|
||||
MODULE = none
|
||||
PROGRAMS = regapi
|
||||
ALL_LIBS = $(WINELIB) $(X_LIBS) $(XLIB) $(LIBS)
|
||||
RCFLAGS = -w32 -h
|
||||
WRCEXTRA = -A -p $*
|
||||
|
||||
C_SRCS = \
|
||||
regapi.c
|
||||
|
||||
all: $(PROGRAMS)
|
||||
|
||||
depend::
|
||||
|
||||
@MAKE_RULES@
|
||||
|
||||
regapi: $(OBJS)
|
||||
$(CC) -o regapi $(OBJS) $(LDOPTIONS) $(ALL_LIBS)
|
||||
|
||||
install: dummy
|
||||
$(INSTALL_PROGRAM) regapi $(bindir)/regapi
|
||||
|
||||
uninstall: dummy
|
||||
$(RM) $(bindir)/regapi
|
||||
|
||||
dummy:
|
||||
|
||||
### Dependencies:
|
||||
|
|
@ -0,0 +1,89 @@
|
|||
|
||||
Registry Command Line API Tool
|
||||
------------------------------
|
||||
|
||||
This progam is intended to fill a particular need. I needed to make the
|
||||
wine registry look like it would have been if my application would have
|
||||
been installed by its installation program. Since this was not possible I
|
||||
took the following approach.
|
||||
|
||||
1 - Use regedit to export my full Windows registry before I install my
|
||||
application.
|
||||
|
||||
2 - Use regedit to export my full Windows registry after I had install my
|
||||
application.
|
||||
|
||||
3 - Generate the differences between the two image. What I obtain from the
|
||||
diff is what I need to apply to the wine registry.
|
||||
|
||||
Obvisouly the process is not that straight forward to solve, first,
|
||||
you don't get the diff between two Windows regedit exported .reg file by
|
||||
doing a simple diff. What I had to do is a little more complex, but not
|
||||
that much...
|
||||
|
||||
(Assuming that the registry picture files are
|
||||
named ./before.reg and ./after.reg)
|
||||
|
||||
1 - Parse the before.reg and after.reg file into regFixer.pl, in order to
|
||||
obtain lines in the form [HKEY\Sub1\Sub2\...\Subn]"Value"="Data"
|
||||
(where "Data" can be prefixed by the type identifyer : hex:, hex(0000000?)
|
||||
or dword:)
|
||||
|
||||
2 - Generate the diff between the before.reg.fix and after.reg.fix
|
||||
into app.diff
|
||||
|
||||
Now we have a app.reg file that contain what has been done by installing the
|
||||
application. To this we extract the part's that we are interested in using
|
||||
grep (and fix it with sed) and put that into app.added by example
|
||||
( let say we keep the added values only ).
|
||||
|
||||
At this point we know which registry entry to add to the wine registry. It
|
||||
only remains to take the format we have and reset it into a format similar
|
||||
to the one we get from regedit.
|
||||
|
||||
I say "similar" because there is a tiny difference between Windows regedit
|
||||
export format and the format actualy required by the tool.
|
||||
|
||||
The problem with this (and it is not a big one) is that regedit export long
|
||||
data streams onto many lines, and since I dont have tons of time I setup
|
||||
another Perl script (regRestorer.pl) that fixes this (this could easily
|
||||
be done in C obviously) (left as excercise ;-) ).
|
||||
|
||||
So, once you parsed app.added into regRestorer.pl you get a app.reg ready to
|
||||
process by regapi.
|
||||
|
||||
So, this package comes with a few pieces:
|
||||
|
||||
regFixer.pl - Will convert the export of regedit
|
||||
into something "diff-able"
|
||||
|
||||
regRestorer.pl - Will convert "cleaned" diff file into
|
||||
something "regapi-able"
|
||||
|
||||
regSet - Will do the procedure explained herein
|
||||
for the added key only.
|
||||
|
||||
|
||||
FAQ
|
||||
---
|
||||
|
||||
Quick Start Guide
|
||||
-----------------
|
||||
1 - Get a snapshot of your windows registry in before.reg, (regedit/export)
|
||||
2 - Install you're application,
|
||||
3 - Get a snapshot of your windows registry in after.reg.
|
||||
4 - Invoke ./regSet.sh before.reg after.reg
|
||||
|
||||
|
||||
Adding key I have in a regedit export file (nothing to diff with...)
|
||||
------------------------------------------
|
||||
1 - Invoke ./regSet.sh /dev/null myRegistry.reg
|
||||
|
||||
regapi help
|
||||
-----------
|
||||
1 - regapi has some sort of "man page like" help in it, simply invoke it
|
||||
without any arguments.
|
||||
|
||||
Hope this is of any use to you.
|
||||
|
||||
Sylvain St-Germain.
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
#!/usr/bin/perl
|
||||
|
||||
# This script takes as STDIN an output from the Registry
|
||||
# (export from regedit.exe) and prefixes every subkey-value
|
||||
# pair by their hkey,key data member
|
||||
#
|
||||
# Copyright 1999 Sylvain St-Germain
|
||||
#
|
||||
|
||||
${prefix} = "";
|
||||
${line} = "";
|
||||
|
||||
LINE: while(<>) {
|
||||
chomp; # Get rid of 0x0a
|
||||
chop; # Get rid of 0x0d
|
||||
|
||||
next LINE if(/^$/); # This is an empty line
|
||||
|
||||
if( /^\[/ ) {
|
||||
${prefix} = ${_}; # assign the prefix for the forthcomming section
|
||||
next LINE;
|
||||
}
|
||||
s/\\\\/\\/g; # Still some more substitutions... To fix paths...
|
||||
|
||||
s/^ //; # Get rid of the stupid two spaces at the begining
|
||||
# they are there in the case of a multi-line thing
|
||||
|
||||
if (/\\$/) { # The line ends with '\', it means it is a multi
|
||||
s/\\$//; # line thing, remove it.
|
||||
|
||||
${line} = "${line}${_}";# Add the current line to the line to output
|
||||
next LINE; # process the next line
|
||||
}
|
||||
|
||||
${line} = "${line}${_}"; # Set line to the multi line thing+the current line
|
||||
|
||||
print "${prefix}${line}\n";
|
||||
${line} = ""; # start over...
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,51 @@
|
|||
#!/usr/bin/perl
|
||||
|
||||
# This script takes as STDIN an output from the regFixer.pl
|
||||
# and reformat the file as if it would have been exported from the registry
|
||||
#
|
||||
# Note: the output file is not exactly the one we get when exporting from
|
||||
# regedit, the tiny difference is that multilines (which were
|
||||
# single-linized by regFixer.pl) values are not re-multi-linized by
|
||||
# this script.
|
||||
#
|
||||
# Copyright 1999 Sylvain St-Germain
|
||||
#
|
||||
|
||||
${newkey} = "";
|
||||
${key} = "";
|
||||
${data} = "";
|
||||
|
||||
# I do not validate the integrity of the file, I am assuming that
|
||||
# the input file comes from the output of regFixer.pl, therefore things
|
||||
# should be ok, if they are not, investigate and send me an email...
|
||||
|
||||
LINE: while(<>) {
|
||||
chomp; # get rid of new line
|
||||
|
||||
next LINE if(/^$/); # This is an empty line
|
||||
|
||||
(${key}, ${data}, ${rest})= split /]/,$_ ; # Extract the values from the line
|
||||
|
||||
${key} = "${key}]"; # put the ']' back there...
|
||||
|
||||
if (${rest} ne "") # concat we had more than 1 ']'
|
||||
{ # on the line
|
||||
${data} = "${data}]${rest}";
|
||||
}
|
||||
|
||||
if (${key} eq ${newkey})
|
||||
{
|
||||
print "${data}\n";
|
||||
}
|
||||
else
|
||||
{
|
||||
${newkey} = ${key}; # assign it
|
||||
|
||||
print "\n";
|
||||
print "${key}\n";
|
||||
print "${data}\n";
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,62 @@
|
|||
#!/bin/bash
|
||||
|
||||
# This script is the receipe to generate the key that have to be created like
|
||||
# if an applicaiton was installed by its installer. It processes using a
|
||||
# registry based on the picture of the registry before the application is
|
||||
# installed and the picture of the registry after the application is installed.
|
||||
#
|
||||
# Copyright 1999 Sylvain St-Germain
|
||||
#
|
||||
|
||||
if [ $# -ne 2 ]; then
|
||||
echo "$0 Usage: "
|
||||
echo " You must provide 2 arguments."
|
||||
echo " 1 - Registry output before the application's installation."
|
||||
echo " 2 - Registry output after the application's installation."
|
||||
echo
|
||||
exit 1
|
||||
fi
|
||||
|
||||
echo "Assuming that $1 is the \"before\" file..."
|
||||
echo "Assuming that $2 is the \"after\" file..."
|
||||
|
||||
#
|
||||
# do not attempt to regFix.pl /dev/null ...
|
||||
#
|
||||
echo "Fixing exported registry files..."
|
||||
if [ $1 != "/dev/null" ]; then
|
||||
cat $1 | ./regFixer.pl > $1.fix
|
||||
fi
|
||||
|
||||
cat $2 | ./regFixer.pl > $2.fix
|
||||
|
||||
#
|
||||
# diff accordingly depending on /dev/null
|
||||
#
|
||||
echo "Diffing..."
|
||||
if [ $1 != "/dev/null" ]; then
|
||||
diff $1.fix $2.fix > $2.diff
|
||||
else
|
||||
diff /dev/null $2.fix > $2.diff
|
||||
fi
|
||||
#
|
||||
# Keep only added lines
|
||||
#
|
||||
echo "Grepping keys to add and generating cleaned fixed registry file."
|
||||
cat $2.diff | grep '^> ' | sed -e 's/^> //' > $2.toAdd
|
||||
|
||||
#
|
||||
# Restore the file format to the regedit export 'like' format
|
||||
#
|
||||
echo "Restoring key's in the regedit export format..."
|
||||
cat $2.toAdd | ./regRestorer.pl > $2.toAdd.final
|
||||
|
||||
echo "Cleaning..."
|
||||
rm $1.fix $2.fix >/dev/null 2>&1
|
||||
rm $2.diff >/dev/null 2>&1
|
||||
rm $2.toAdd >/dev/null 2>&1
|
||||
mv $2.toAdd.final $2.toAdd
|
||||
|
||||
echo "Operation completed, result file is $2.toAdd"
|
||||
|
||||
exit 0
|
||||
|
|
@ -0,0 +1,983 @@
|
|||
/*
|
||||
* Command line Registry implementation
|
||||
*
|
||||
* Copyright 1999 Sylvain St-Germain
|
||||
*
|
||||
* Note: Please consult the README file for more information.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <malloc.h>
|
||||
#include <windows.h>
|
||||
#include <winreg.h>
|
||||
#include <winerror.h>
|
||||
#include <winnt.h>
|
||||
#include <string.h>
|
||||
#include <shell.h>
|
||||
|
||||
/******************************************************************************
|
||||
* Defines and consts
|
||||
*/
|
||||
#define IDENTICAL 0
|
||||
#define COMMAND_COUNT 5
|
||||
|
||||
#define KEY_MAX_LEN 1024
|
||||
#define STDIN_MAX_LEN 2048
|
||||
|
||||
/* Return values */
|
||||
#define COMMAND_NOT_FOUND -1
|
||||
#define SUCCESS 0
|
||||
#define NOT_ENOUGH_MEMORY 1
|
||||
#define KEY_VALUE_ALREADY_SET 2
|
||||
#define COMMAND_NOT_SUPPORTED 3
|
||||
|
||||
/* Generic global */
|
||||
static BOOL bForce = FALSE; /* Is set to TRUE when -force is
|
||||
passed on the command line */
|
||||
|
||||
/* Globals used by the api setValue, queryValue */
|
||||
static LPSTR currentKeyName = NULL;
|
||||
static HKEY currentKeyClass = NULL;
|
||||
static HKEY currentKeyHandle = NULL;
|
||||
static BOOL bTheKeyIsOpen = FALSE;
|
||||
|
||||
/* Delimitors used to parse the "value"="data" pair for setValue*/
|
||||
#define SET_VALUE_MAX_ARGS 2
|
||||
/* Delimitors used to parse the "value" to query queryValue*/
|
||||
#define QUERY_VALUE_MAX_ARGS 1
|
||||
|
||||
static const char *setValueDelim[SET_VALUE_MAX_ARGS] = {"=", ""};
|
||||
static const char *queryValueDelim[QUERY_VALUE_MAX_ARGS] = {""};
|
||||
|
||||
/* Array used to extract the data type from a string in getDataType. */
|
||||
typedef struct tagDataTypeMap
|
||||
{
|
||||
char mask[15];
|
||||
DWORD dataType;
|
||||
} dataTypeMap;
|
||||
|
||||
static const dataTypeMap typeMap[] =
|
||||
{
|
||||
{"hex:", REG_BINARY},/* could be REG_NONE (?) */
|
||||
{"dword:", REG_DWORD},
|
||||
{"hex(0):", REG_NONE},
|
||||
{"hex(1):", REG_SZ},
|
||||
{"hex(2):", REG_EXPAND_SZ},
|
||||
{"hex(3):", REG_BINARY},
|
||||
{"hex(4):", REG_DWORD},
|
||||
{"hex(5):", REG_DWORD_BIG_ENDIAN},
|
||||
{"hex(6):", REG_LINK},
|
||||
{"hex(7):", REG_MULTI_SZ},
|
||||
{"hex(8):", REG_RESOURCE_LIST},
|
||||
{"hex(9):", REG_FULL_RESOURCE_DESCRIPTOR},
|
||||
{"hex(80000000):", REG_NONE},
|
||||
{"hex(80000001):", REG_SZ},
|
||||
{"hex(80000002):", REG_EXPAND_SZ},
|
||||
{"hex(80000003):", REG_BINARY},
|
||||
{"hex(80000004):", REG_DWORD},
|
||||
{"hex(80000005):", REG_DWORD_BIG_ENDIAN},
|
||||
{"hex(80000006):", REG_LINK},
|
||||
{"hex(80000007):", REG_MULTI_SZ},
|
||||
{"hex(80000008):", REG_RESOURCE_LIST},
|
||||
{"hex(80000009):", REG_FULL_RESOURCE_DESCRIPTOR},
|
||||
{"hex(8000000a):", REG_BINARY}, /* REG_RESOURCE_REQUIREMENTS_LIST}, !Exist */
|
||||
{"hex(8000000A):", REG_BINARY}, /* REG_RESOURCE_REQUIREMENTS_LIST}, !Exist */
|
||||
};
|
||||
const static int LAST_TYPE_MAP = sizeof(typeMap)/sizeof(dataTypeMap);
|
||||
|
||||
|
||||
/*
|
||||
* Forward declaration
|
||||
*/
|
||||
typedef void (*commandAPI)(LPSTR lpsLine);
|
||||
|
||||
static void doSetValue(LPSTR lpsLine);
|
||||
static void doDeleteValue(LPSTR lpsLine);
|
||||
static void doCreateKey(LPSTR lpsLine);
|
||||
static void doDeleteKey(LPSTR lpsLine);
|
||||
static void doQueryValue(LPSTR lpsLine);
|
||||
|
||||
/*
|
||||
* current suuported api
|
||||
*/
|
||||
static const char* commandNames[COMMAND_COUNT] = {
|
||||
"setValue",
|
||||
"deleteValue",
|
||||
"createKey",
|
||||
"deleteKey",
|
||||
"queryValue"
|
||||
};
|
||||
|
||||
/*
|
||||
* Pointers to processing entry points
|
||||
*/
|
||||
static const commandAPI commandAPIs[COMMAND_COUNT] = {
|
||||
doSetValue,
|
||||
doDeleteValue,
|
||||
doCreateKey,
|
||||
doDeleteKey,
|
||||
doQueryValue
|
||||
};
|
||||
|
||||
/*
|
||||
* This array controls the registry saving needs at the end of the process
|
||||
*/
|
||||
static const BOOL commandSaveRegistry[COMMAND_COUNT] = {
|
||||
TRUE,
|
||||
TRUE,
|
||||
TRUE,
|
||||
TRUE,
|
||||
FALSE
|
||||
};
|
||||
|
||||
/*
|
||||
* Generic prototyes
|
||||
*/
|
||||
static HKEY getDataType(LPSTR *lpValue);
|
||||
static LPSTR getRegKeyName(LPSTR lpLine);
|
||||
static HKEY getRegClass(LPSTR lpLine);
|
||||
static LPSTR getArg(LPSTR arg);
|
||||
static INT getCommand(LPSTR commandName);
|
||||
static DWORD convertHexToDWord(char *str, BYTE *buf);
|
||||
static DWORD convertHexCSVToHex(char *str, BYTE *buf, ULONG bufLen);
|
||||
static LPSTR convertHexToHexCSV( BYTE *buf, ULONG len);
|
||||
static LPSTR convertHexToDWORDStr( BYTE *buf, ULONG len);
|
||||
static HRESULT openKey(LPSTR stdInput);
|
||||
static void closeKey();
|
||||
|
||||
/*
|
||||
* api setValue prototypes
|
||||
*/
|
||||
static void processSetValue(LPSTR cmdline);
|
||||
static HRESULT setValue(LPSTR *argv);
|
||||
|
||||
/*
|
||||
* api queryValue prototypes
|
||||
*/
|
||||
static void processQueryValue(LPSTR cmdline);
|
||||
|
||||
/*
|
||||
* Help Text displyed when invalid parameters are provided
|
||||
*/
|
||||
static char helpText[] = "
|
||||
NAME
|
||||
regapi - provide a command line interface to the wine registry.
|
||||
|
||||
SYNOPSYS
|
||||
regapi commandName [-force] < file
|
||||
|
||||
DESCRIPTION
|
||||
regapi allows editing the wine resgistry. It processes the given
|
||||
commandName for every line in the stdin data stream. Input data
|
||||
format may vary depending on the commandName see INPUT FILE FORMAT.
|
||||
|
||||
OPTIONS
|
||||
commandName
|
||||
Instruct regapi about what action to perform on the data stream.
|
||||
Currently, only setValue and queryValue are supported and
|
||||
implemented.
|
||||
|
||||
-force
|
||||
When provided the action will be performed anyway. This may
|
||||
have a different meaning depending on the context. For example,
|
||||
when providing -force to setValue, the value is set even if it
|
||||
was previously set to another value.
|
||||
|
||||
< file
|
||||
STDIN chanel, provide a file name with line of the appropriate
|
||||
format.
|
||||
|
||||
INPUT FILE FORMAT
|
||||
|
||||
setValue
|
||||
The input file format required by the setValue command is similar
|
||||
to the one obtained from regedit.exe export option. The only
|
||||
difference is that multi line values are not supported, the
|
||||
value data must be on a single line.
|
||||
|
||||
[KEY_CLASS\\Some\\Path\\For\\A\\Key]
|
||||
\"Value1\"=\"Data1\"
|
||||
\"Value2\"=\"Data2\"
|
||||
\"Valuen\"=\"Datan\"
|
||||
...
|
||||
|
||||
queryValue
|
||||
The input file format required by the queryValue command is
|
||||
similar to the one required by setValue. The only
|
||||
difference is that you only provide the value name.
|
||||
|
||||
[KEY_CLASS\\Some\\Path\\For\\A\\Key]
|
||||
\"Value1\"
|
||||
\"Value2\"
|
||||
\"Valuen\"
|
||||
...
|
||||
February 1999.
|
||||
";
|
||||
|
||||
|
||||
/******************************************************************************
|
||||
* This funtion returns the HKEY associated with the data type encoded in the
|
||||
* value. It modify the input parameter (key value) in order to skip this
|
||||
* "now useless" data type information.
|
||||
*/
|
||||
HKEY getDataType(LPSTR *lpValue)
|
||||
{
|
||||
INT counter = 0;
|
||||
DWORD dwReturn = REG_SZ;
|
||||
|
||||
for (; counter < LAST_TYPE_MAP; counter++)
|
||||
{
|
||||
LONG len = strlen(typeMap[counter].mask);
|
||||
if ( strncmp( *lpValue, typeMap[counter].mask, len) == IDENTICAL)
|
||||
{
|
||||
/*
|
||||
* We found it, modify the value's pointer in order to skip the data
|
||||
* type identifier, set the return value and exit the loop.
|
||||
*/
|
||||
(*lpValue) += len;
|
||||
dwReturn = typeMap[counter].dataType;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return dwReturn;
|
||||
}
|
||||
/******************************************************************************
|
||||
* Extracts from a [HKEY\some\key\path] type of line the key name (what starts
|
||||
* after the first '\' and end before the ']'
|
||||
*/
|
||||
LPSTR getRegKeyName(LPSTR lpLine)
|
||||
{
|
||||
LPSTR keyNameBeg = NULL;
|
||||
LPSTR keyNameEnd = NULL;
|
||||
char lpLineCopy[KEY_MAX_LEN];
|
||||
|
||||
if (lpLine == NULL)
|
||||
return NULL;
|
||||
|
||||
strcpy(lpLineCopy, lpLine);
|
||||
|
||||
keyNameBeg = strstr(lpLineCopy, "\\"); /* The key name start by '\' */
|
||||
keyNameBeg++; /* but is not part of the key name */
|
||||
keyNameEnd = strstr(lpLineCopy, "]"); /* The key name end by ']' */
|
||||
*keyNameEnd = NULL; /* Isolate the key name */
|
||||
|
||||
currentKeyName = HeapAlloc(GetProcessHeap(), 0, strlen(keyNameBeg)+1);
|
||||
if (currentKeyName != NULL)
|
||||
strcpy(currentKeyName, keyNameBeg);
|
||||
|
||||
return currentKeyName;
|
||||
}
|
||||
|
||||
/******************************************************************************
|
||||
* Extracts from a [HKEY/some/key/path] type of line the key class (what
|
||||
* starts after the '[' and end before the first '\'
|
||||
*/
|
||||
static HKEY getRegClass(LPSTR lpClass)
|
||||
{
|
||||
LPSTR classNameEnd;
|
||||
LPSTR classNameBeg;
|
||||
|
||||
char lpClassCopy[KEY_MAX_LEN];
|
||||
|
||||
if (lpClass == NULL)
|
||||
return ERROR_INVALID_PARAMETER;
|
||||
|
||||
strcpy(lpClassCopy, lpClass);
|
||||
|
||||
classNameEnd = strstr(lpClassCopy, "\\"); /* The class name end by '\' */
|
||||
*classNameEnd = NULL; /* Isolate the class name */
|
||||
classNameBeg = &lpClassCopy[1]; /* Skip the '[' */
|
||||
|
||||
if (strcmp( classNameBeg, "HKEY_LOCAL_MACHINE") == IDENTICAL )
|
||||
return HKEY_LOCAL_MACHINE;
|
||||
else if (strcmp( classNameBeg, "HKEY_USERS") == IDENTICAL )
|
||||
return HKEY_USERS;
|
||||
else if (strcmp( classNameBeg, "HKEY_CLASSES_ROOT") == IDENTICAL )
|
||||
return HKEY_CLASSES_ROOT;
|
||||
else if (strcmp( classNameBeg, "HKEY_CURRENT_CONFIG") == IDENTICAL )
|
||||
return HKEY_CURRENT_CONFIG;
|
||||
else if (strcmp( classNameBeg, "HKEY_CURRENT_USER") == IDENTICAL )
|
||||
return HKEY_CURRENT_USER;
|
||||
else
|
||||
return ERROR_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
/******************************************************************************
|
||||
* Returns an allocated buffer with a cleaned copy (removed the surrounding
|
||||
* dbl quotes) of the passed value.
|
||||
*/
|
||||
static LPSTR getArg( LPSTR arg)
|
||||
{
|
||||
LPSTR tmp = NULL;
|
||||
ULONG len;
|
||||
|
||||
if (arg == NULL)
|
||||
return NULL;
|
||||
|
||||
/*
|
||||
* Get rid of surrounding quotes
|
||||
*/
|
||||
len = strlen(arg);
|
||||
|
||||
if( arg[len-1] == '\"' ) arg[len-1] = NULL;
|
||||
if( arg[0] == '\"' ) arg++;
|
||||
|
||||
tmp = HeapAlloc(GetProcessHeap(), 0, strlen(arg)+1);
|
||||
strcpy(tmp, arg);
|
||||
|
||||
return tmp;
|
||||
}
|
||||
|
||||
/******************************************************************************
|
||||
* Returns the index in the commands array of the command to process.
|
||||
*/
|
||||
static INT getCommand(LPSTR commandName)
|
||||
{
|
||||
INT count;
|
||||
for (count=0; count < COMMAND_COUNT; count++)
|
||||
if ( strcmp(commandName, commandNames[count]) == IDENTICAL)
|
||||
return count;
|
||||
|
||||
return COMMAND_NOT_FOUND;
|
||||
}
|
||||
|
||||
/******************************************************************************
|
||||
* Converts a hex representation of a DWORD into a DWORD.
|
||||
*/
|
||||
static DWORD convertHexToDWord(char *str, BYTE *buf)
|
||||
{
|
||||
char *s = str; /* Pointer to current */
|
||||
char *b = buf; /* Pointer to result */
|
||||
ULONG strPos = 0;
|
||||
|
||||
memset(buf, 0, 4);
|
||||
|
||||
while (strPos < 4) /* 8 byte in a DWORD */
|
||||
{
|
||||
char xbuf[3];
|
||||
char wc;
|
||||
|
||||
memcpy(xbuf,s,2); xbuf[2]='\0';
|
||||
sscanf(xbuf,"%02x",(UINT*)&wc);
|
||||
*b++ =(unsigned char)wc;
|
||||
|
||||
s+=2;
|
||||
strPos+=1;
|
||||
}
|
||||
|
||||
return 4; /* always 4 byte for the word */
|
||||
}
|
||||
|
||||
/******************************************************************************
|
||||
* Converts a hex buffer into a hex coma separated values
|
||||
*/
|
||||
static char* convertHexToHexCSV(BYTE *buf, ULONG bufLen)
|
||||
{
|
||||
char* str;
|
||||
char* ptrStr;
|
||||
BYTE* ptrBuf;
|
||||
|
||||
ULONG current = 0;
|
||||
|
||||
str = HeapAlloc(GetProcessHeap(), 0, (bufLen+1)*2);
|
||||
memset(str, 0, (bufLen+1)*2);
|
||||
ptrStr = str; /* Pointer to result */
|
||||
ptrBuf = buf; /* Pointer to current */
|
||||
|
||||
while (current < bufLen)
|
||||
{
|
||||
BYTE bCur = ptrBuf[current++];
|
||||
char res[3];
|
||||
|
||||
sprintf(res, "%02x", (unsigned int)*&bCur);
|
||||
strcat(str, res);
|
||||
strcat(str, ",");
|
||||
}
|
||||
|
||||
/* Get rid of the last coma */
|
||||
str[strlen(str)-1] = NULL;
|
||||
return str;
|
||||
}
|
||||
|
||||
/******************************************************************************
|
||||
* Converts a hex buffer into a DWORD string
|
||||
*/
|
||||
static char* convertHexToDWORDStr(BYTE *buf, ULONG bufLen)
|
||||
{
|
||||
char* str;
|
||||
char* ptrStr;
|
||||
BYTE* ptrBuf;
|
||||
|
||||
ULONG current = 0;
|
||||
|
||||
str = HeapAlloc(GetProcessHeap(), 0, (bufLen*2)+1);
|
||||
memset(str, 0, (bufLen*2)+1);
|
||||
ptrStr = str; /* Pointer to result */
|
||||
ptrBuf = buf; /* Pointer to current */
|
||||
|
||||
while (current < bufLen)
|
||||
{
|
||||
BYTE bCur = ptrBuf[current++];
|
||||
char res[3];
|
||||
|
||||
sprintf(res, "%02x", (unsigned int)*&bCur);
|
||||
strcat(str, res);
|
||||
}
|
||||
|
||||
/* Get rid of the last coma */
|
||||
return str;
|
||||
}
|
||||
/******************************************************************************
|
||||
* Converts a hex coma separated values list into a hex list.
|
||||
*/
|
||||
static DWORD convertHexCSVToHex(char *str, BYTE *buf, ULONG bufLen)
|
||||
{
|
||||
char *s = str; /* Pointer to current */
|
||||
char *b = buf; /* Pointer to result */
|
||||
|
||||
ULONG strLen = strlen(str);
|
||||
ULONG strPos = 0;
|
||||
DWORD byteCount = 0;
|
||||
|
||||
memset(buf, 0, bufLen);
|
||||
|
||||
/*
|
||||
* warn the user if we are here with a string longer than 2 bytes that does
|
||||
* not contains ",". It is more likely because the data is invalid.
|
||||
*/
|
||||
if ( ( strlen(str) > 2) && ( strstr(str, ",") == NULL) )
|
||||
printf("regapi: WARNING converting CSV hex stream with no coma, "
|
||||
"input data seems invalid.\n");
|
||||
|
||||
while (strPos < strLen)
|
||||
{
|
||||
char xbuf[3];
|
||||
char wc;
|
||||
|
||||
memcpy(xbuf,s,2); xbuf[3]='\0';
|
||||
sscanf(xbuf,"%02x",(UINT*)&wc);
|
||||
*b++ =(unsigned char)wc;
|
||||
|
||||
s+=3;
|
||||
strPos+=3;
|
||||
byteCount++;
|
||||
}
|
||||
|
||||
return byteCount;
|
||||
}
|
||||
|
||||
|
||||
/******************************************************************************
|
||||
* Sets the value in argv[0] to the data in argv[1] for the currently
|
||||
* opened key.
|
||||
*/
|
||||
static HRESULT setValue(LPSTR *argv)
|
||||
{
|
||||
HRESULT hRes;
|
||||
DWORD dwSize = KEY_MAX_LEN;
|
||||
DWORD dwType = NULL;
|
||||
DWORD dwDataType;
|
||||
|
||||
CHAR lpsCurrentValue[KEY_MAX_LEN];
|
||||
|
||||
LPSTR keyValue = argv[0];
|
||||
LPSTR keyData = argv[1];
|
||||
|
||||
/* Make some checks */
|
||||
if ( (keyValue == NULL) || (keyData == NULL) )
|
||||
return ERROR_INVALID_PARAMETER;
|
||||
|
||||
/*
|
||||
* Default registry values are encoded in the input stream as '@' but as
|
||||
* blank in the wine registry.
|
||||
*/
|
||||
if( (keyValue[0] == '@') && (strlen(keyValue) == 1) )
|
||||
keyValue[0] = NULL;
|
||||
|
||||
/* Get the data type stored into the value field */
|
||||
dwDataType = getDataType(&keyData);
|
||||
|
||||
memset(lpsCurrentValue, 0, KEY_MAX_LEN);
|
||||
hRes = RegQueryValueExA(
|
||||
currentKeyHandle,
|
||||
keyValue,
|
||||
NULL,
|
||||
&dwType,
|
||||
(LPBYTE)lpsCurrentValue,
|
||||
&dwSize);
|
||||
|
||||
if( ( strlen(lpsCurrentValue) == 0 ) || /* The value is not existing */
|
||||
( bForce )) /* -force option */
|
||||
{
|
||||
LPBYTE lpbData;
|
||||
BYTE convert[KEY_MAX_LEN];
|
||||
DWORD dwLen;
|
||||
|
||||
if ( dwDataType == REG_SZ ) /* no convertion for string */
|
||||
{
|
||||
dwLen = strlen(keyData);
|
||||
lpbData = keyData;
|
||||
}
|
||||
else if (dwDataType == REG_DWORD) /* Convert the dword types */
|
||||
{
|
||||
dwLen = convertHexToDWord(keyData, convert);
|
||||
lpbData = convert;
|
||||
}
|
||||
else /* Convert the hexadecimal types */
|
||||
{
|
||||
dwLen = convertHexCSVToHex(keyData, convert, KEY_MAX_LEN);
|
||||
lpbData = convert;
|
||||
}
|
||||
|
||||
hRes = RegSetValueEx(
|
||||
currentKeyHandle,
|
||||
keyValue,
|
||||
0, /* Reserved */
|
||||
dwDataType,
|
||||
lpbData,
|
||||
dwLen);
|
||||
}
|
||||
else
|
||||
{
|
||||
/* return the current value data into argv[1] */
|
||||
if (argv[1] != NULL)
|
||||
{
|
||||
HeapFree(GetProcessHeap(), 0, argv[1]);
|
||||
argv[1] = HeapAlloc(GetProcessHeap(), 0, dwSize+1);
|
||||
|
||||
if ( argv[1] != NULL )
|
||||
strncpy(argv[1], lpsCurrentValue, dwSize);
|
||||
}
|
||||
|
||||
return KEY_VALUE_ALREADY_SET;
|
||||
}
|
||||
return hRes;
|
||||
}
|
||||
|
||||
|
||||
/******************************************************************************
|
||||
* Open the key
|
||||
*/
|
||||
static HRESULT openKey( LPSTR stdInput)
|
||||
{
|
||||
DWORD dwDisp;
|
||||
HRESULT hRes;
|
||||
|
||||
/* Sanity checks */
|
||||
if (stdInput == NULL)
|
||||
return ERROR_INVALID_PARAMETER;
|
||||
|
||||
/* Get the registry class */
|
||||
currentKeyClass = getRegClass(stdInput); /* Sets global variable */
|
||||
if (currentKeyClass == ERROR_INVALID_PARAMETER)
|
||||
return ERROR_INVALID_PARAMETER;
|
||||
|
||||
/* Get the key name */
|
||||
currentKeyName = getRegKeyName(stdInput); /* Sets global variable */
|
||||
if (currentKeyName == NULL)
|
||||
return ERROR_INVALID_PARAMETER;
|
||||
|
||||
hRes = RegCreateKeyEx(
|
||||
currentKeyClass, /* Class */
|
||||
currentKeyName, /* Sub Key */
|
||||
0, /* MUST BE 0 */
|
||||
NULL, /* object type */
|
||||
REG_OPTION_NON_VOLATILE, /* option, REG_OPTION_NON_VOLATILE ... */
|
||||
KEY_ALL_ACCESS, /* access mask, KEY_ALL_ACCESS */
|
||||
NULL, /* security attribute */
|
||||
¤tKeyHandle, /* result */
|
||||
&dwDisp); /* disposition, REG_CREATED_NEW_KEY or
|
||||
REG_OPENED_EXISTING_KEY */
|
||||
|
||||
if (hRes == ERROR_SUCCESS)
|
||||
bTheKeyIsOpen = TRUE;
|
||||
|
||||
return hRes;
|
||||
|
||||
}
|
||||
/******************************************************************************
|
||||
* This function is a wrapper arround the setValue function. It prepares the
|
||||
* land and clean the area once completed.
|
||||
*/
|
||||
static void processSetValue(LPSTR cmdline)
|
||||
{
|
||||
LPSTR argv[SET_VALUE_MAX_ARGS]; /* args storage */
|
||||
|
||||
LPSTR token = NULL; /* current token analized */
|
||||
ULONG argCounter = 0; /* counter of args */
|
||||
INT counter;
|
||||
HRESULT hRes = NULL;
|
||||
|
||||
/*
|
||||
* Init storage and parse the line
|
||||
*/
|
||||
for (counter=0; counter<SET_VALUE_MAX_ARGS; counter++)
|
||||
argv[counter]=NULL;
|
||||
|
||||
while( (token = strsep(&cmdline, setValueDelim[argCounter])) != NULL )
|
||||
{
|
||||
argv[argCounter++] = getArg(token);
|
||||
|
||||
if (argCounter == SET_VALUE_MAX_ARGS)
|
||||
break; /* Stop processing args no matter what */
|
||||
}
|
||||
|
||||
hRes = setValue(argv);
|
||||
if ( hRes == ERROR_SUCCESS )
|
||||
printf(
|
||||
"regapi: Value \"%s\" has been set to \"%s\" in key [%s]\n",
|
||||
argv[0],
|
||||
argv[1],
|
||||
currentKeyName);
|
||||
|
||||
else if ( hRes == KEY_VALUE_ALREADY_SET )
|
||||
printf(
|
||||
"regapi: Value \"%s\" already set to \"%s\" in key [%s]\n",
|
||||
argv[0],
|
||||
argv[1],
|
||||
currentKeyName);
|
||||
|
||||
else
|
||||
printf("regapi: ERROR Key %s not created. Value: %s, Data: %s\n",
|
||||
currentKeyName,
|
||||
argv[0],
|
||||
argv[1]);
|
||||
|
||||
/*
|
||||
* Do some cleanup
|
||||
*/
|
||||
for (counter=0; counter<argCounter; counter++)
|
||||
if (argv[counter] != NULL)
|
||||
HeapFree(GetProcessHeap(), 0, argv[counter]);
|
||||
}
|
||||
|
||||
/******************************************************************************
|
||||
* This function is a wrapper arround the queryValue function. It prepares the
|
||||
* land and clean the area once completed.
|
||||
*/
|
||||
static void processQueryValue(LPSTR cmdline)
|
||||
{
|
||||
LPSTR argv[QUERY_VALUE_MAX_ARGS];/* args storage */
|
||||
LPSTR token = NULL; /* current token analized */
|
||||
ULONG argCounter = 0; /* counter of args */
|
||||
INT counter;
|
||||
HRESULT hRes = NULL;
|
||||
LPSTR keyValue = NULL;
|
||||
LPSTR lpsRes = NULL;
|
||||
|
||||
/*
|
||||
* Init storage and parse the line
|
||||
*/
|
||||
for (counter=0; counter<QUERY_VALUE_MAX_ARGS; counter++)
|
||||
argv[counter]=NULL;
|
||||
|
||||
while( (token = strsep(&cmdline, queryValueDelim[argCounter])) != NULL )
|
||||
{
|
||||
argv[argCounter++] = getArg(token);
|
||||
|
||||
if (argCounter == QUERY_VALUE_MAX_ARGS)
|
||||
break; /* Stop processing args no matter what */
|
||||
}
|
||||
|
||||
/* The value we look for is the first token on the line */
|
||||
if ( argv[0] == NULL )
|
||||
return; /* SHOULD NOT OCCURS */
|
||||
else
|
||||
keyValue = argv[0];
|
||||
|
||||
if( (keyValue[0] == '@') && (strlen(keyValue) == 1) )
|
||||
{
|
||||
LONG lLen = KEY_MAX_LEN;
|
||||
CHAR lpsData[KEY_MAX_LEN];
|
||||
/*
|
||||
* We need to query the key default value
|
||||
*/
|
||||
hRes = RegQueryValue(
|
||||
currentKeyHandle,
|
||||
currentKeyName,
|
||||
(LPBYTE)lpsData,
|
||||
&lLen);
|
||||
|
||||
if (hRes == ERROR_SUCCESS)
|
||||
{
|
||||
lpsRes = HeapAlloc( GetProcessHeap(), 0, lLen);
|
||||
strncpy(lpsRes, lpsData, lLen);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
DWORD dwLen = KEY_MAX_LEN;
|
||||
BYTE lpbData[KEY_MAX_LEN];
|
||||
DWORD dwType;
|
||||
/*
|
||||
* We need to query a specific value for the key
|
||||
*/
|
||||
hRes = RegQueryValueEx(
|
||||
currentKeyHandle,
|
||||
keyValue,
|
||||
0,
|
||||
&dwType,
|
||||
(LPBYTE)lpbData,
|
||||
&dwLen);
|
||||
|
||||
if (hRes == ERROR_SUCCESS)
|
||||
{
|
||||
/*
|
||||
* Convert the returned data to a displayable format
|
||||
*/
|
||||
switch ( dwType )
|
||||
{
|
||||
case REG_SZ:
|
||||
{
|
||||
lpsRes = HeapAlloc( GetProcessHeap(), 0, dwLen);
|
||||
strncpy(lpsRes, lpbData, dwLen);
|
||||
break;
|
||||
}
|
||||
case REG_DWORD:
|
||||
{
|
||||
lpsRes = convertHexToDWORDStr(lpbData, dwLen);
|
||||
break;
|
||||
}
|
||||
default:
|
||||
{
|
||||
lpsRes = convertHexToHexCSV(lpbData, dwLen);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
if ( hRes == ERROR_SUCCESS )
|
||||
printf(
|
||||
"regapi: Value \"%s\" = \"%s\" in key [%s]\n",
|
||||
keyValue,
|
||||
lpsRes,
|
||||
currentKeyName);
|
||||
|
||||
else
|
||||
printf("regapi: ERROR Value \"%s\" not found. for key \"%s\"\n",
|
||||
keyValue,
|
||||
currentKeyName);
|
||||
|
||||
/*
|
||||
* Do some cleanup
|
||||
*/
|
||||
for (counter=0; counter<argCounter; counter++)
|
||||
if (argv[counter] != NULL)
|
||||
HeapFree(GetProcessHeap(), 0, argv[counter]);
|
||||
|
||||
if (lpsRes != NULL)
|
||||
HeapFree(GetProcessHeap(), 0, lpsRes);
|
||||
|
||||
}
|
||||
|
||||
/******************************************************************************
|
||||
* Close the currently opened key.
|
||||
*/
|
||||
static void closeKey()
|
||||
{
|
||||
RegCloseKey(currentKeyHandle);
|
||||
|
||||
HeapFree(GetProcessHeap(), 0, currentKeyName); /* Allocated by getKeyName */
|
||||
|
||||
bTheKeyIsOpen = FALSE;
|
||||
|
||||
currentKeyName = NULL;
|
||||
currentKeyClass = NULL;
|
||||
currentKeyHandle = NULL;
|
||||
}
|
||||
|
||||
/******************************************************************************
|
||||
* This funtion is the main entry point to the setValue type of action. It
|
||||
* receives the currently read line and dispatch the work depending on the
|
||||
* context.
|
||||
*/
|
||||
static void doSetValue(LPSTR stdInput)
|
||||
{
|
||||
/*
|
||||
* We encoutered the end of the file, make sure we
|
||||
* close the opened key and exit
|
||||
*/
|
||||
if (stdInput == NULL)
|
||||
{
|
||||
if (bTheKeyIsOpen != FALSE)
|
||||
closeKey();
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if ( stdInput[0] == '[') /* We are reading a new key */
|
||||
{
|
||||
if ( bTheKeyIsOpen != FALSE )
|
||||
closeKey(); /* Close the previous key before */
|
||||
|
||||
if ( openKey(stdInput) != ERROR_SUCCESS )
|
||||
printf ("regapi: doSetValue failed to open key %s\n", stdInput);
|
||||
}
|
||||
else if( ( bTheKeyIsOpen ) &&
|
||||
(( stdInput[0] == '@') || /* reading a default @=data pair */
|
||||
( stdInput[0] == '\"'))) /* reading a new value=data pair */
|
||||
{
|
||||
processSetValue(stdInput);
|
||||
}
|
||||
else /* since we are assuming that the */
|
||||
{ /* file format is valid we must */
|
||||
if ( bTheKeyIsOpen ) /* be reading a blank line which */
|
||||
closeKey(); /* indicate end of this key processing */
|
||||
}
|
||||
}
|
||||
|
||||
/******************************************************************************
|
||||
* This funtion is the main entry point to the queryValue type of action. It
|
||||
* receives the currently read line and dispatch the work depending on the
|
||||
* context.
|
||||
*/
|
||||
static void doQueryValue(LPSTR stdInput) {
|
||||
/*
|
||||
* We encoutered the end of the file, make sure we
|
||||
* close the opened key and exit
|
||||
*/
|
||||
if (stdInput == NULL)
|
||||
{
|
||||
if (bTheKeyIsOpen != FALSE)
|
||||
closeKey();
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if ( stdInput[0] == '[') /* We are reading a new key */
|
||||
{
|
||||
if ( bTheKeyIsOpen != FALSE )
|
||||
closeKey(); /* Close the previous key before */
|
||||
|
||||
if ( openKey(stdInput) != ERROR_SUCCESS )
|
||||
printf ("regapi: doSetValue failed to open key %s\n", stdInput);
|
||||
}
|
||||
else if( ( bTheKeyIsOpen ) &&
|
||||
(( stdInput[0] == '@') || /* reading a default @=data pair */
|
||||
( stdInput[0] == '\"'))) /* reading a new value=data pair */
|
||||
{
|
||||
processQueryValue(stdInput);
|
||||
}
|
||||
else /* since we are assuming that the */
|
||||
{ /* file format is valid we must */
|
||||
if ( bTheKeyIsOpen ) /* be reading a blank line which */
|
||||
closeKey(); /* indicate end of this key processing */
|
||||
}
|
||||
}
|
||||
|
||||
/******************************************************************************
|
||||
* This funtion is the main entry point to the deletetValue type of action. It
|
||||
* receives the currently read line and dispatch the work depending on the
|
||||
* context.
|
||||
*/
|
||||
static void doDeleteValue(LPSTR line) {
|
||||
printf ("regapi: deleteValue not yet implemented\n");
|
||||
}
|
||||
/******************************************************************************
|
||||
* This funtion is the main entry point to the deleteKey type of action. It
|
||||
* receives the currently read line and dispatch the work depending on the
|
||||
* context.
|
||||
*/
|
||||
static void doDeleteKey(LPSTR line) {
|
||||
printf ("regapi: deleteKey not yet implemented\n");
|
||||
}
|
||||
/******************************************************************************
|
||||
* This funtion is the main entry point to the createKey type of action. It
|
||||
* receives the currently read line and dispatch the work depending on the
|
||||
* context.
|
||||
*/
|
||||
static void doCreateKey(LPSTR line) {
|
||||
printf ("regapi: createKey not yet implemented\n");
|
||||
}
|
||||
|
||||
/******************************************************************************
|
||||
* MAIN - The main simply validate the first parameter (command to perform)
|
||||
* It then read the STDIN lines by lines forwarding their processing
|
||||
* to the appropriate method.
|
||||
*/
|
||||
int PASCAL WinMain (HANDLE inst, HANDLE prev, LPSTR cmdline, int show)
|
||||
{
|
||||
LPSTR token = NULL; /* current token analized */
|
||||
LPSTR stdInput = NULL; /* line read from stdin */
|
||||
INT cmdIndex = -1; /* index of the command in array */
|
||||
|
||||
stdInput = HeapAlloc(GetProcessHeap(), 0, STDIN_MAX_LEN);
|
||||
if (stdInput == NULL)
|
||||
return NOT_ENOUGH_MEMORY;
|
||||
|
||||
/*
|
||||
* get the command, should be the first arg (modify cmdLine)
|
||||
*/
|
||||
token = strsep(&cmdline, " ");
|
||||
if (token != NULL)
|
||||
{
|
||||
cmdIndex = getCommand(token);
|
||||
if (cmdIndex == COMMAND_NOT_FOUND)
|
||||
{
|
||||
printf("regapi: Command \"%s\" is not supported.\n", token);
|
||||
printf(helpText);
|
||||
return COMMAND_NOT_SUPPORTED;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
printf(
|
||||
"regapi: The first item on the command line must be the command name.\n");
|
||||
printf(helpText);
|
||||
return COMMAND_NOT_SUPPORTED;
|
||||
}
|
||||
|
||||
/*
|
||||
* check to see weather we force the action
|
||||
* (meaning differ depending on the command performed)
|
||||
*/
|
||||
if ( cmdline != NULL ) /* will be NULL if '-force' is not provided */
|
||||
if ( strstr(cmdline, "-force") != NULL )
|
||||
bForce = TRUE;
|
||||
|
||||
printf("Processing stdin...\n");
|
||||
|
||||
while ( TRUE )
|
||||
{
|
||||
/*
|
||||
* read a line
|
||||
*/
|
||||
stdInput = fgets(stdInput, STDIN_MAX_LEN, stdin);
|
||||
|
||||
/*
|
||||
* Make some handy generic stuff here...
|
||||
*/
|
||||
if ( stdInput != NULL )
|
||||
{
|
||||
stdInput[strlen(stdInput) -1] = NULL; /* get rid of new line */
|
||||
|
||||
if( stdInput[0] == '#' ) /* this is a comment, skip */
|
||||
continue;
|
||||
}
|
||||
|
||||
/*
|
||||
* We process every lines even the NULL (last) line, to indicate the
|
||||
* end of the processing to the specific process.
|
||||
*/
|
||||
commandAPIs[cmdIndex](stdInput);
|
||||
|
||||
if (stdInput == NULL) /* EOF encountered */
|
||||
break;
|
||||
}
|
||||
|
||||
/*
|
||||
* Save the registry only if it was modified
|
||||
*/
|
||||
if ( commandSaveRegistry[cmdIndex] != FALSE )
|
||||
SHELL_SaveRegistry();
|
||||
|
||||
HeapFree(GetProcessHeap(), 0, stdInput);
|
||||
return SUCCESS;
|
||||
}
|
||||
|
||||
|
||||
|
||||
Loading…
Reference in New Issue