/******************************************************************************
* Extracts from [HKEY\some\key\path] or HKEY\some\key\path types of line
* the key name (what starts after the first '\')
*/
LPTSTR getRegKeyName(LPTSTR lpLine)
{
LPTSTR keyNameBeg;
TCHAR lpLineCopy[KEY_MAX_LEN];
if (lpLine == NULL)
return NULL;
_tcscpy(lpLineCopy, lpLine);
keyNameBeg = _tcschr(lpLineCopy, _T('\\')); /* The key name start by '\' */
if (keyNameBeg) {
LPTSTR keyNameEnd;
keyNameBeg++; /* is not part of the name */
keyNameEnd = _tcschr(lpLineCopy, _T(']'));
if (keyNameEnd) {
*keyNameEnd = _T('\0'); /* remove ']' from the key name */
}
} else {
keyNameBeg = lpLineCopy + _tcslen(lpLineCopy); /* branch - empty string */
}
currentKeyName = HeapAlloc(GetProcessHeap(), 0, (_tcslen(keyNameBeg)+1)*sizeof(TCHAR));
CHECK_ENOUGH_MEMORY(currentKeyName);
_tcscpy(currentKeyName, keyNameBeg);
return currentKeyName;
}
/******************************************************************************
* Removes the registry key with all subkeys. Parses full key name.
*
* Parameters:
* reg_key_name - full name of registry branch to delete. Ignored if is NULL,
* empty, points to register key class, does not exist.
*/
void delete_registry_key(TCHAR* reg_key_name)
{
TCHAR* branch_name;
DWORD branch_name_len;
HKEY reg_key_class;
HKEY branch_key;
if (!reg_key_name || !reg_key_name[0]) {
return;
}
/* open the specified key */
reg_key_class = getRegClass(reg_key_name);
if (reg_key_class == (HKEY)ERROR_INVALID_PARAMETER) {
_tprintf(_T("Incorrect registry class specification in '%s'\n"), reg_key_name);
//exit(1);
return;
}
branch_name = getRegKeyName(reg_key_name);
CHECK_ENOUGH_MEMORY(branch_name);
branch_name_len = _tcslen(branch_name);
if (!branch_name[0]) {
_tprintf(_T("Can't delete registry class '%s'\n"), reg_key_name);
//exit(1);
return;
}
if (RegOpenKey(reg_key_class, branch_name, &branch_key) == ERROR_SUCCESS) {
/* check whether the key exists */
RegCloseKey(branch_key);
delete_branch(reg_key_class, &branch_name, &branch_name_len);
}
HeapFree(GetProcessHeap(), 0, branch_name);
}
/******************************************************************************
* Converts a hex comma separated values list into a binary string.
*/
static BYTE* convertHexCSVToHex(WCHAR *str, DWORD *size)
{
WCHAR *s;
BYTE *d, *data;
/* The worst case is 1 digit + 1 comma per byte */
*size=(lstrlenW(str)+1)/2;
data=HeapAlloc(GetProcessHeap(), 0, *size);
CHECK_ENOUGH_MEMORY(data);
s = str;
d = data;
*size=0;
while (*s != '\0') {
UINT wc;
WCHAR *end;
wc = strtoulW(s,&end,16);
if (end == s || wc > 0xff || (*end && *end != ',')) {
char* strA = GetMultiByteString(s);
fprintf(stderr,"%s: ERROR converting CSV hex stream. Invalid value at '%s'\n",
getAppName(), strA);
HeapFree(GetProcessHeap(), 0, data);
HeapFree(GetProcessHeap(), 0, strA);
return NULL;
}
*d++ =(BYTE)wc;
(*size)++;
if (*end) end++;
s = end;
}
return data;
}
/******************************************************************************
* Converts a hex comma separated values list into a binary string.
*/
static BYTE* convertHexCSVToHex(WCHAR *str, DWORD *size)
{
WCHAR *s;
BYTE *d, *data;
/* The worst case is 1 digit + 1 comma per byte */
*size=(lstrlenW(str)+1)/2;
data=HeapAlloc(GetProcessHeap(), 0, *size);
CHECK_ENOUGH_MEMORY(data);
s = str;
d = data;
*size=0;
while (*s != '\0') {
UINT wc;
WCHAR *end;
wc = strtoulW(s,&end,16);
if (end == s || wc > 0xff || (*end && *end != ',')) {
output_message(STRING_CSV_HEX_ERROR, s);
HeapFree(GetProcessHeap(), 0, data);
return NULL;
}
*d++ =(BYTE)wc;
(*size)++;
if (*end) end++;
s = end;
}
return data;
}
/******************************************************************************
* Sets the value with name val_name to the data in val_data for the currently
* opened key.
*
* Parameters:
* val_name - name of the registry value
* val_data - registry value data
*/
HRESULT setValue(LPTSTR val_name, LPTSTR val_data)
{
HRESULT hRes;
DWORD dwDataType, dwParseType;
LPBYTE lpbData;
BYTE convert[KEY_MAX_LEN];
BYTE *bBigBuffer = 0;
DWORD dwLen;
if ((val_name == NULL) || (val_data == NULL))
return ERROR_INVALID_PARAMETER;
/* Get the data type stored into the value field */
dwDataType = getDataType(&val_data, &dwParseType);
// if (dwParseType == REG_EXPAND_SZ) {
// }
// if (dwParseType == REG_SZ || dwParseType == REG_EXPAND_SZ) { /* no conversion for string */
if (dwParseType == REG_SZ) { /* no conversion for string */
dwLen = _tcslen(val_data);
if (dwLen > 0 && val_data[dwLen-1] == _T('"')) {
dwLen--;
val_data[dwLen] = _T('\0');
}
dwLen++;
dwLen *= sizeof(TCHAR);
REGPROC_unescape_string(val_data);
lpbData = val_data;
} else if (dwParseType == REG_DWORD) { /* Convert the dword types */
dwLen = convertHexToDWord(val_data, convert);
lpbData = convert;
} else { /* Convert the hexadecimal types */
int b_len = _tcslen(val_data)+2/3;
if (b_len > KEY_MAX_LEN) {
bBigBuffer = HeapAlloc (GetProcessHeap(), 0, b_len * sizeof(TCHAR));
if (bBigBuffer == NULL) {
return ERROR_REGISTRY_IO_FAILED;
}
CHECK_ENOUGH_MEMORY(bBigBuffer);
dwLen = convertHexCSVToHex(val_data, bBigBuffer, b_len);
lpbData = bBigBuffer;
} else {
dwLen = convertHexCSVToHex(val_data, convert, KEY_MAX_LEN);
lpbData = convert;
}
}
hRes = RegSetValueEx(currentKeyHandle, val_name,
0, /* Reserved */dwDataType, lpbData, dwLen);
_tprintf(_T(" Value: %s, Data: %s\n"), val_name, lpbData);
if (bBigBuffer)
HeapFree(GetProcessHeap(), 0, bBigBuffer);
return hRes;
}
/******************************************************************************
* Checks whether the buffer has enough room for the string or required size.
* Resizes the buffer if necessary.
*
* Parameters:
* buffer - pointer to a buffer for string
* len - current length of the buffer in characters.
* required_len - length of the string to place to the buffer in characters.
* The length does not include the terminating null character.
*/
void REGPROC_resize_char_buffer(TCHAR **buffer, DWORD *len, DWORD required_len)
{
required_len++;
if (required_len > *len) {
*len = required_len;
*buffer = HeapReAlloc(GetProcessHeap(), 0, *buffer, *len * sizeof(**buffer));
CHECK_ENOUGH_MEMORY(*buffer);
}
}
/******************************************************************************
* Same as REGPROC_resize_char_buffer() but on a regular buffer.
*
* Parameters:
* buffer - pointer to a buffer
* len - current size of the buffer in bytes
* required_size - size of the data to place in the buffer in bytes
*/
static void REGPROC_resize_binary_buffer(BYTE **buffer, DWORD *size, DWORD required_size)
{
if (required_size > *size) {
*size = required_size;
if (!*buffer)
*buffer = HeapAlloc(GetProcessHeap(), 0, *size);
else
*buffer = HeapReAlloc(GetProcessHeap(), 0, *buffer, *size);
CHECK_ENOUGH_MEMORY(*buffer);
}
}
/******************************************************************************
* Allocates memory and converts input from multibyte to wide chars
* Returned string must be freed by the caller
*/
WCHAR* GetWideString(const char* strA)
{
if(strA)
{
WCHAR* strW;
int len = MultiByteToWideChar(CP_ACP, 0, strA, -1, NULL, 0);
strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
CHECK_ENOUGH_MEMORY(strW);
MultiByteToWideChar(CP_ACP, 0, strA, -1, strW, len);
return strW;
}
return NULL;
}
/******************************************************************************
* Allocates memory and converts input from wide chars to multibyte
* Returned string must be freed by the caller
*/
char* GetMultiByteString(const WCHAR* strW)
{
if(strW)
{
char* strA;
int len = WideCharToMultiByte(CP_ACP, 0, strW, -1, NULL, 0, NULL, NULL);
strA = HeapAlloc(GetProcessHeap(), 0, len);
CHECK_ENOUGH_MEMORY(strA);
WideCharToMultiByte(CP_ACP, 0, strW, -1, strA, len, NULL, NULL);
return strA;
}
return NULL;
}
/******************************************************************************
* Allocates memory and converts input from multibyte to wide chars
* Returned string must be freed by the caller
*/
static WCHAR* GetWideStringN(const char* strA, int chars, DWORD *len)
{
if(strA)
{
WCHAR* strW;
*len = MultiByteToWideChar(CP_ACP, 0, strA, chars, NULL, 0);
strW = HeapAlloc(GetProcessHeap(), 0, *len * sizeof(WCHAR));
CHECK_ENOUGH_MEMORY(strW);
MultiByteToWideChar(CP_ACP, 0, strA, chars, strW, *len);
return strW;
}
*len = 0;
return NULL;
}
/******************************************************************************
* Allocates memory and converts input from wide chars to multibyte
* Returned string must be freed by the caller
*/
static char* GetMultiByteStringN(const WCHAR* strW, int chars, DWORD* len)
{
if(strW)
{
char* strA;
*len = WideCharToMultiByte(CP_ACP, 0, strW, chars, NULL, 0, NULL, NULL);
strA = HeapAlloc(GetProcessHeap(), 0, *len);
CHECK_ENOUGH_MEMORY(strA);
WideCharToMultiByte(CP_ACP, 0, strW, chars, strA, *len, NULL, NULL);
return strA;
}
*len = 0;
return NULL;
}
/******************************************************************************
* A helper function for processRegEntry() that opens the current key.
* That key must be closed by calling closeKey().
*/
static LONG openKeyW(WCHAR* stdInput)
{
HKEY keyClass;
WCHAR* keyPath;
DWORD dwDisp;
LONG res;
/* Sanity checks */
if (stdInput == NULL)
return ERROR_INVALID_PARAMETER;
/* Get the registry class */
if (!parseKeyName(stdInput, &keyClass, &keyPath))
return ERROR_INVALID_PARAMETER;
res = RegCreateKeyExW(
keyClass, /* Class */
keyPath, /* 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 (res == ERROR_SUCCESS)
{
currentKeyName = HeapAlloc(GetProcessHeap(), 0, (strlenW(stdInput) + 1) * sizeof(WCHAR));
CHECK_ENOUGH_MEMORY(currentKeyName);
strcpyW(currentKeyName, stdInput);
}
else
currentKeyHandle = NULL;
return res;
}
/******************************************************************************
* Processes a registry file.
* Correctly processes comments (in # and ; form), line continuation.
*
* Parameters:
* in - input stream to read from
* first_chars - beginning of stream, read due to Unicode check
*/
static void processRegLinesA(FILE *in, char* first_chars)
{
char *buf = NULL; /* the line read from the input stream */
unsigned long line_size = REG_VAL_BUF_SIZE;
size_t chars_in_buf = -1;
char *s; /* A pointer to buf for fread */
char *line; /* The start of the current line */
WCHAR *lineW;
buf = HeapAlloc(GetProcessHeap(), 0, line_size);
CHECK_ENOUGH_MEMORY(buf);
s = buf;
line = buf;
memcpy(line, first_chars, 2);
if (first_chars)
s += 2;
while (!feof(in)) {
size_t size_remaining;
int size_to_get;
char *s_eol = NULL; /* various local uses */
/* Do we need to expand the buffer? */
assert(s >= buf && s <= buf + line_size);
size_remaining = line_size - (s - buf);
if (size_remaining < 3) /* we need at least 3 bytes of room for \r\n\0 */
{
char *new_buffer;
size_t new_size = line_size + REG_VAL_BUF_SIZE;
if (new_size > line_size) /* no arithmetic overflow */
new_buffer = HeapReAlloc(GetProcessHeap(), 0, buf, new_size);
else
new_buffer = NULL;
CHECK_ENOUGH_MEMORY(new_buffer);
buf = new_buffer;
line = buf;
s = buf + line_size - size_remaining;
line_size = new_size;
size_remaining = line_size - (s - buf);
}
/* Get as much as possible into the buffer, terminating on EOF,
* error or once we have read the maximum amount. Abort on error.
*/
size_to_get = (size_remaining > INT_MAX ? INT_MAX : size_remaining);
chars_in_buf = fread(s, 1, size_to_get - 1, in);
s[chars_in_buf] = 0;
if (chars_in_buf == 0) {
if (ferror(in)) {
perror("While reading input");
exit(IO_ERROR);
} else {
assert(feof(in));
*s = '\0';
}
}
/* If we didn't read the end-of-line sequence or EOF, go around again */
while (1)
{
s_eol = strpbrk(line, "\r\n");
if (!s_eol) {
/* Move the stub of the line to the start of the buffer so
* we get the maximum space to read into, and so we don't
* have to recalculate 'line' if the buffer expands */
MoveMemory(buf, line, strlen(line) + 1);
line = buf;
s = strchr(line, '\0');
break;
}
/* If we find a comment line, discard it and go around again */
if (line [0] == '#' || line [0] == ';') {
if (*s_eol == '\r' && *(s_eol + 1) == '\n')
line = s_eol + 2;
else
line = s_eol + 1;
continue;
}
/* If there is a concatenating '\\', go around again */
if (*(s_eol - 1) == '\\') {
char *next_line = s_eol + 1;
if (*s_eol == '\r' && *(s_eol + 1) == '\n')
next_line++;
while (*(next_line + 1) == ' ' || *(next_line + 1) == '\t')
next_line++;
MoveMemory(s_eol - 1, next_line, chars_in_buf - (next_line - s) + 1);
chars_in_buf -= next_line - s_eol + 1;
s_eol = 0;
continue;
}
/* Remove any line feed. Leave s_eol on the last \0 */
if (*s_eol == '\r' && *(s_eol + 1) == '\n')
*s_eol++ = '\0';
*s_eol = '\0';
lineW = GetWideString(line);
processRegEntry(lineW, FALSE);
HeapFree(GetProcessHeap(), 0, lineW);
line = s_eol + 1;
s_eol = 0;
continue; /* That is the full virtual line */
}
}
processRegEntry(NULL, FALSE);
HeapFree(GetProcessHeap(), 0, buf);
}
static void processRegLinesW(FILE *in)
{
WCHAR* buf = NULL; /* line read from input stream */
ULONG lineSize = REG_VAL_BUF_SIZE;
size_t CharsInBuf = -1;
WCHAR* s; /* The pointer into buf for where the current fgets should read */
WCHAR* line; /* The start of the current line */
buf = HeapAlloc(GetProcessHeap(), 0, lineSize * sizeof(WCHAR));
CHECK_ENOUGH_MEMORY(buf);
s = buf;
line = buf;
while(!feof(in)) {
size_t size_remaining;
int size_to_get;
WCHAR *s_eol = NULL; /* various local uses */
/* Do we need to expand the buffer ? */
assert (s >= buf && s <= buf + lineSize);
size_remaining = lineSize - (s-buf);
if (size_remaining < 2) /* room for 1 character and the \0 */
{
WCHAR *new_buffer;
size_t new_size = lineSize + (REG_VAL_BUF_SIZE / sizeof(WCHAR));
if (new_size > lineSize) /* no arithmetic overflow */
new_buffer = HeapReAlloc (GetProcessHeap(), 0, buf, new_size * sizeof(WCHAR));
else
new_buffer = NULL;
CHECK_ENOUGH_MEMORY(new_buffer);
buf = new_buffer;
line = buf;
s = buf + lineSize - size_remaining;
lineSize = new_size;
size_remaining = lineSize - (s-buf);
}
/* Get as much as possible into the buffer, terminated either by
* eof, error or getting the maximum amount. Abort on error.
*/
size_to_get = (size_remaining > INT_MAX ? INT_MAX : size_remaining);
CharsInBuf = fread(s, sizeof(WCHAR), size_to_get - 1, in);
s[CharsInBuf] = 0;
if (CharsInBuf == 0) {
if (ferror(in)) {
perror ("While reading input");
exit (IO_ERROR);
} else {
assert (feof(in));
*s = '\0';
/* It is not clear to me from the definition that the
* contents of the buffer are well defined on detecting
* an eof without managing to read anything.
*/
}
}
/* If we didn't read the eol nor the eof go around for the rest */
while(1)
{
const WCHAR line_endings[] = {'\r','\n',0};
s_eol = strpbrkW(line, line_endings);
if(!s_eol) {
/* Move the stub of the line to the start of the buffer so
* we get the maximum space to read into, and so we don't
* have to recalculate 'line' if the buffer expands */
MoveMemory(buf, line, (strlenW(line)+1) * sizeof(WCHAR));
line = buf;
s = strchrW(line, '\0');
break;
}
/* If it is a comment line then discard it and go around again */
if (*line == '#' || *line == ';') {
if (*s_eol == '\r' && *(s_eol+1) == '\n')
line = s_eol + 2;
else
line = s_eol + 1;
continue;
}
/* If there is a concatenating \\ then go around again */
if (*(s_eol-1) == '\\') {
WCHAR* NextLine = s_eol + 1;
if(*s_eol == '\r' && *(s_eol+1) == '\n')
NextLine++;
while(*(NextLine+1) == ' ' || *(NextLine+1) == '\t')
NextLine++;
MoveMemory(s_eol - 1, NextLine, (CharsInBuf - (NextLine - s) + 1)*sizeof(WCHAR));
CharsInBuf -= NextLine - s_eol + 1;
s_eol = 0;
continue;
}
/* Remove any line feed. Leave s_eol on the last \0 */
if (*s_eol == '\r' && *(s_eol + 1) == '\n')
*s_eol++ = '\0';
*s_eol = '\0';
processRegEntry(line, TRUE);
line = s_eol + 1;
s_eol = 0;
continue; /* That is the full virtual line */
}
}
processRegEntry(NULL, TRUE);
HeapFree(GetProcessHeap(), 0, buf);
}
/******************************************************************************
* Processes a registry file.
* Correctly processes comments (in # and ; form), line continuation.
*
* Parameters:
* in - input stream to read from
* first_chars - beginning of stream, read due to Unicode check
*/
static void processRegLinesA(FILE *in, char* first_chars)
{
LPSTR line = NULL; /* line read from input stream */
ULONG lineSize = REG_VAL_BUF_SIZE;
line = HeapAlloc(GetProcessHeap(), 0, lineSize);
CHECK_ENOUGH_MEMORY(line);
memcpy(line, first_chars, 2);
while (!feof(in)) {
LPSTR s; /* The pointer into line for where the current fgets should read */
WCHAR* lineW;
s = line;
if(first_chars)
{
s += 2;
first_chars = NULL;
}
for (;;) {
size_t size_remaining;
int size_to_get, i;
char *s_eol; /* various local uses */
/* Do we need to expand the buffer ? */
assert (s >= line && s <= line + lineSize);
size_remaining = lineSize - (s-line);
if (size_remaining < 2) /* room for 1 character and the \0 */
{
char *new_buffer;
size_t new_size = lineSize + REG_VAL_BUF_SIZE;
if (new_size > lineSize) /* no arithmetic overflow */
new_buffer = HeapReAlloc (GetProcessHeap(), 0, line, new_size);
else
new_buffer = NULL;
CHECK_ENOUGH_MEMORY(new_buffer);
line = new_buffer;
s = line + lineSize - size_remaining;
lineSize = new_size;
size_remaining = lineSize - (s-line);
}
/* Get as much as possible into the buffer, terminated either by
* eof, error, eol or getting the maximum amount. Abort on error.
*/
size_to_get = (size_remaining > INT_MAX ? INT_MAX : size_remaining);
/* get a single line. note that `i' must be one past the last
* meaningful character in `s' when this loop exits */
for(i = 0; i < size_to_get-1; ++i){
int xchar;
xchar = fgetc(in);
s[i] = xchar;
if(xchar == EOF){
if(ferror(in)){
perror("While reading input");
exit(IO_ERROR);
}else
assert(feof(in));
break;
}
if(s[i] == '\r'){
/* read the next character iff it's \n */
if(i+2 >= size_to_get){
/* buffer too short, so put back the EOL char to
* read next cycle */
ungetc('\r', in);
break;
}
s[i+1] = fgetc(in);
if(s[i+1] != '\n'){
ungetc(s[i+1], in);
i = i+1;
}else
i = i+2;
break;
}
if(s[i] == '\n'){
i = i+1;
break;
}
}
s[i] = '\0';
/* If we didn't read the eol nor the eof go around for the rest */
s_eol = strpbrk (s, "\r\n");
if (!feof (in) && !s_eol) {
s = strchr (s, '\0');
continue;
}
/* If it is a comment line then discard it and go around again */
if (line [0] == '#' || line [0] == ';') {
s = line;
continue;
}
/* Remove any line feed. Leave s_eol on the first \0 */
if (s_eol) {
if (*s_eol == '\r' && *(s_eol+1) == '\n')
*(s_eol+1) = '\0';
*s_eol = '\0';
} else
s_eol = strchr (s, '\0');
/* If there is a concatenating \\ then go around again */
if (s_eol > line && *(s_eol-1) == '\\') {
int c;
s = s_eol-1;
do
{
c = fgetc(in);
} while(c == ' ' || c == '\t');
if(c == EOF)
{
fprintf(stderr,"%s: ERROR - invalid continuation.\n",
getAppName());
}
else
{
*s = c;
s++;
}
continue;
}
lineW = GetWideString(line);
break; /* That is the full virtual line */
}
processRegEntry(lineW, FALSE);
HeapFree(GetProcessHeap(), 0, lineW);
}
processRegEntry(NULL, FALSE);
HeapFree(GetProcessHeap(), 0, line);
}
/******************************************************************************
* Writes contents of the registry key to the specified file stream.
*
* Parameters:
* file_name - name of a file to export registry branch to.
* reg_key_name - registry branch to export. The whole registry is exported if
* reg_key_name is NULL or contains an empty string.
*/
BOOL export_registry_key(TCHAR* file_name, TCHAR* reg_key_name)
{
HKEY reg_key_class;
TCHAR *reg_key_name_buf;
TCHAR *val_name_buf;
BYTE *val_buf;
DWORD reg_key_name_len = KEY_MAX_LEN;
DWORD val_name_len = KEY_MAX_LEN;
DWORD val_size = REG_VAL_BUF_SIZE;
FILE *file = NULL;
//_tprintf(_T("export_registry_key(%s, %s)\n"), reg_key_name, file_name);
reg_key_name_buf = HeapAlloc(GetProcessHeap(), 0, reg_key_name_len * sizeof(*reg_key_name_buf));
val_name_buf = HeapAlloc(GetProcessHeap(), 0, val_name_len * sizeof(*val_name_buf));
val_buf = HeapAlloc(GetProcessHeap(), 0, val_size);
CHECK_ENOUGH_MEMORY(reg_key_name_buf && val_name_buf && val_buf);
if (reg_key_name && reg_key_name[0]) {
TCHAR *branch_name;
HKEY key;
REGPROC_resize_char_buffer(®_key_name_buf, ®_key_name_len,
_tcslen(reg_key_name));
_tcscpy(reg_key_name_buf, reg_key_name);
/* open the specified key */
reg_key_class = getRegClass(reg_key_name);
if (reg_key_class == (HKEY)ERROR_INVALID_PARAMETER) {
_tprintf(_T("Incorrect registry class specification in '%s\n"), reg_key_name);
//exit(1);
return FALSE;
}
branch_name = getRegKeyName(reg_key_name);
CHECK_ENOUGH_MEMORY(branch_name);
if (!branch_name[0]) {
/* no branch - registry class is specified */
file = REGPROC_open_export_file(file_name);
export_hkey(file, reg_key_class,
®_key_name_buf, ®_key_name_len,
&val_name_buf, &val_name_len,
&val_buf, &val_size);
} else if (RegOpenKey(reg_key_class, branch_name, &key) == ERROR_SUCCESS) {
file = REGPROC_open_export_file(file_name);
export_hkey(file, key,
®_key_name_buf, ®_key_name_len,
&val_name_buf, &val_name_len,
&val_buf, &val_size);
RegCloseKey(key);
} else {
_tprintf(_T("Can't export. Registry key '%s does not exist!\n"), reg_key_name);
REGPROC_print_error();
}
HeapFree(GetProcessHeap(), 0, branch_name);
} else {
int i;
/* export all registry classes */
file = REGPROC_open_export_file(file_name);
for (i = 0; i < REG_CLASS_NUMBER; i++) {
/* do not export HKEY_CLASSES_ROOT */
if (reg_class_keys[i] != HKEY_CLASSES_ROOT &&
reg_class_keys[i] != HKEY_CURRENT_USER &&
reg_class_keys[i] != HKEY_CURRENT_CONFIG) {
_tcscpy(reg_key_name_buf, reg_class_names[i]);
export_hkey(file, reg_class_keys[i],
®_key_name_buf, ®_key_name_len,
&val_name_buf, &val_name_len,
&val_buf, &val_size);
}
}
}
if (file) {
fclose(file);
}
// HeapFree(GetProcessHeap(), 0, reg_key_name);
HeapFree(GetProcessHeap(), 0, val_buf);
HeapFree(GetProcessHeap(), 0, val_name_buf);
HeapFree(GetProcessHeap(), 0, reg_key_name_buf);
return TRUE;
}
/******************************************************************************
* Writes contents of the registry key to the specified file stream.
*
* Parameters:
* file_name - name of a file to export registry branch to.
* reg_key_name - registry branch to export. The whole registry is exported if
* reg_key_name is NULL or contains an empty string.
*/
BOOL export_registry_key(WCHAR *file_name, WCHAR *reg_key_name, DWORD format)
{
WCHAR *reg_key_name_buf;
WCHAR *val_name_buf;
BYTE *val_buf;
WCHAR *line_buf;
DWORD reg_key_name_size = KEY_MAX_LEN;
DWORD val_name_size = KEY_MAX_LEN;
DWORD val_size = REG_VAL_BUF_SIZE;
DWORD line_buf_size = KEY_MAX_LEN + REG_VAL_BUF_SIZE;
FILE *file = NULL;
BOOL unicode = (format == REG_FORMAT_5);
reg_key_name_buf = HeapAlloc(GetProcessHeap(), 0,
reg_key_name_size * sizeof(*reg_key_name_buf));
val_name_buf = HeapAlloc(GetProcessHeap(), 0,
val_name_size * sizeof(*val_name_buf));
val_buf = HeapAlloc(GetProcessHeap(), 0, val_size);
line_buf = HeapAlloc(GetProcessHeap(), 0, line_buf_size * sizeof(*line_buf));
CHECK_ENOUGH_MEMORY(reg_key_name_buf && val_name_buf && val_buf && line_buf);
if (reg_key_name && reg_key_name[0]) {
HKEY reg_key_class;
WCHAR *branch_name = NULL;
HKEY key;
REGPROC_resize_char_buffer(®_key_name_buf, ®_key_name_size,
lstrlenW(reg_key_name));
lstrcpyW(reg_key_name_buf, reg_key_name);
/* open the specified key */
if (!parseKeyName(reg_key_name, ®_key_class, &branch_name)) {
CHAR* key_nameA = GetMultiByteString(reg_key_name);
fprintf(stderr,"%s: Incorrect registry class specification in '%s'\n",
getAppName(), key_nameA);
HeapFree(GetProcessHeap(), 0, key_nameA);
exit(1);
}
if (!branch_name[0]) {
/* no branch - registry class is specified */
file = REGPROC_open_export_file(file_name, unicode);
export_hkey(file, reg_key_class,
®_key_name_buf, ®_key_name_size,
&val_name_buf, &val_name_size,
&val_buf, &val_size, &line_buf,
&line_buf_size, unicode);
} else if (RegOpenKeyW(reg_key_class, branch_name, &key) == ERROR_SUCCESS) {
file = REGPROC_open_export_file(file_name, unicode);
export_hkey(file, key,
®_key_name_buf, ®_key_name_size,
&val_name_buf, &val_name_size,
&val_buf, &val_size, &line_buf,
&line_buf_size, unicode);
RegCloseKey(key);
} else {
CHAR* key_nameA = GetMultiByteString(reg_key_name);
fprintf(stderr,"%s: Can't export. Registry key '%s' does not exist!\n",
getAppName(), key_nameA);
HeapFree(GetProcessHeap(), 0, key_nameA);
REGPROC_print_error();
}
} else {
unsigned int i;
/* export all registry classes */
file = REGPROC_open_export_file(file_name, unicode);
for (i = 0; i < REG_CLASS_NUMBER; i++) {
/* do not export HKEY_CLASSES_ROOT */
if (reg_class_keys[i] != HKEY_CLASSES_ROOT &&
reg_class_keys[i] != HKEY_CURRENT_USER &&
reg_class_keys[i] != HKEY_CURRENT_CONFIG &&
reg_class_keys[i] != HKEY_DYN_DATA) {
lstrcpyW(reg_key_name_buf, reg_class_namesW[i]);
export_hkey(file, reg_class_keys[i],
®_key_name_buf, ®_key_name_size,
&val_name_buf, &val_name_size,
&val_buf, &val_size, &line_buf,
&line_buf_size, unicode);
}
}
}
if (file) {
fclose(file);
}
HeapFree(GetProcessHeap(), 0, reg_key_name);
HeapFree(GetProcessHeap(), 0, val_name_buf);
HeapFree(GetProcessHeap(), 0, val_buf);
HeapFree(GetProcessHeap(), 0, line_buf);
return TRUE;
}
/******************************************************************************
* Writes contents of the registry key to the specified file stream.
*
* Parameters:
* file - writable file stream to export registry branch to.
* key - registry branch to export.
* reg_key_name_buf - name of the key with registry class.
* Is resized if necessary.
* reg_key_name_len - length of the buffer for the registry class in characters.
* val_name_buf - buffer for storing value name.
* Is resized if necessary.
* val_name_len - length of the buffer for storing value names in characters.
* val_buf - buffer for storing values while extracting.
* Is resized if necessary.
* val_size - size of the buffer for storing values in bytes.
*/
void export_hkey(FILE *file, HKEY key,
TCHAR **reg_key_name_buf, DWORD *reg_key_name_len,
TCHAR **val_name_buf, DWORD *val_name_len,
BYTE **val_buf, DWORD *val_size)
{
DWORD max_sub_key_len;
DWORD max_val_name_len;
DWORD max_val_size;
DWORD curr_len;
DWORD i;
BOOL more_data;
LONG ret;
/* get size information and resize the buffers if necessary */
if (RegQueryInfoKey(key, NULL, NULL, NULL, NULL, &max_sub_key_len, NULL,
NULL, &max_val_name_len, &max_val_size, NULL, NULL) != ERROR_SUCCESS) {
REGPROC_print_error();
}
curr_len = _tcslen(*reg_key_name_buf);
REGPROC_resize_char_buffer(reg_key_name_buf, reg_key_name_len, max_sub_key_len + curr_len + 1);
REGPROC_resize_char_buffer(val_name_buf, val_name_len, max_val_name_len);
if (max_val_size > *val_size) {
*val_size = max_val_size;
*val_buf = HeapReAlloc(GetProcessHeap(), 0, *val_buf, *val_size * sizeof(TCHAR));
CHECK_ENOUGH_MEMORY(val_buf);
}
/* output data for the current key */
_fputts(_T("\n["), file);
_fputts(*reg_key_name_buf, file);
_fputts(_T("]\n"), file);
/* print all the values */
i = 0;
more_data = TRUE;
while (more_data) {
DWORD value_type;
DWORD val_name_len1 = *val_name_len;
DWORD val_size1 = *val_size;
ret = RegEnumValue(key, i, *val_name_buf, &val_name_len1, NULL, &value_type, *val_buf, &val_size1);
if (ret != ERROR_SUCCESS) {
more_data = FALSE;
if (ret != ERROR_NO_MORE_ITEMS) {
REGPROC_print_error();
}
} else {
i++;
if ((*val_name_buf)[0]) {
_fputts(_T("\""), file);
REGPROC_export_string(file, *val_name_buf);
_fputts(_T("\"="), file);
} else {
_fputts(_T("@="), file);
}
switch (value_type) {
case REG_EXPAND_SZ:
_fputts(_T("expand:"), file);
case REG_SZ:
_fputts(_T("\""), file);
REGPROC_export_string(file, *val_buf);
_fputts(_T("\"\n"), file);
break;
case REG_DWORD:
_ftprintf(file, _T("dword:%08lx\n"), *((DWORD *)*val_buf));
break;
default:
/*
_tprintf(_T("warning - unsupported registry format '%ld', ") \
_T("treating as binary\n"), value_type);
_tprintf(_T("key name: \"%s\"\n"), *reg_key_name_buf);
_tprintf(_T("value name:\"%s\"\n\n"), *val_name_buf);
*/
/* falls through */
case REG_MULTI_SZ:
/* falls through */
case REG_BINARY:
{
DWORD i1;
TCHAR *hex_prefix;
TCHAR buf[20];
int cur_pos;
if (value_type == REG_BINARY) {
hex_prefix = _T("hex:");
} else {
hex_prefix = buf;
_stprintf(buf, _T("hex(%ld):"), value_type);
}
/* position of where the next character will be printed */
/* NOTE: yes, _tcslen("hex:") is used even for hex(x): */
cur_pos = _tcslen(_T("\"\"=")) + _tcslen(_T("hex:")) +
_tcslen(*val_name_buf);
_fputts(hex_prefix, file);
for (i1 = 0; i1 < val_size1; i1++) {
_ftprintf(file, _T("%02x"), (unsigned int)(*val_buf)[i1]);
if (i1 + 1 < val_size1) {
_fputts(_T(","), file);
}
cur_pos += 3;
/* wrap the line */
if (cur_pos > REG_FILE_HEX_LINE_LEN) {
_fputts(_T("\\\n "), file);
cur_pos = 2;
}
}
_fputts(_T("\n"), file);
break;
}
}
}
}
i = 0;
more_data = TRUE;
(*reg_key_name_buf)[curr_len] = _T('\\');
while (more_data) {
DWORD buf_len = *reg_key_name_len - curr_len;
ret = RegEnumKeyEx(key, i, *reg_key_name_buf + curr_len + 1, &buf_len, NULL, NULL, NULL, NULL);
if (ret != ERROR_SUCCESS && ret != ERROR_MORE_DATA) {
more_data = FALSE;
if (ret != ERROR_NO_MORE_ITEMS) {
REGPROC_print_error();
}
} else {
HKEY subkey;
i++;
if (RegOpenKey(key, *reg_key_name_buf + curr_len + 1, &subkey) == ERROR_SUCCESS) {
export_hkey(file, subkey, reg_key_name_buf, reg_key_name_len, val_name_buf, val_name_len, val_buf, val_size);
RegCloseKey(subkey);
} else {
REGPROC_print_error();
}
}
}
(*reg_key_name_buf)[curr_len] = _T('\0');
}
/******************************************************************************
* Calls command for each line of a registry file.
* Correctly processes comments (in # form), line continuation.
*
* Parameters:
* in - input stream to read from
* command - command to be called for each line
*/
void processRegLines(FILE *in, CommandAPI command)
{
LPTSTR line = NULL; /* line read from input stream */
ULONG lineSize = REG_VAL_BUF_SIZE;
line = HeapAlloc(GetProcessHeap(), 0, lineSize * sizeof(TCHAR));
CHECK_ENOUGH_MEMORY(line);
while (!feof(in)) {
LPTSTR s; /* The pointer into line for where the current fgets should read */
s = line;
for (;;) {
size_t size_remaining;
int size_to_get;
TCHAR *s_eol; /* various local uses */
/* Do we need to expand the buffer ? */
assert (s >= line && s <= line + lineSize);
size_remaining = lineSize - (s-line);
if (size_remaining < 2) { /* room for 1 character and the \0 */
TCHAR *new_buffer;
size_t new_size = lineSize + REG_VAL_BUF_SIZE;
if (new_size > lineSize) /* no arithmetic overflow */
new_buffer = HeapReAlloc (GetProcessHeap(), 0, line, new_size * sizeof(TCHAR));
else
new_buffer = NULL;
CHECK_ENOUGH_MEMORY(new_buffer);
line = new_buffer;
s = line + lineSize - size_remaining;
lineSize = new_size;
size_remaining = lineSize - (s-line);
}
/* Get as much as possible into the buffer, terminated either by
* eof, error, eol or getting the maximum amount. Abort on error.
*/
//
// This line is surely foobar, don't want to read INT_MAX in buffer at s, it's never going to be that big...
// size_to_get = (size_remaining > INT_MAX ? INT_MAX : size_remaining);
//
// Looks as if 'lineSize' contains the number of characters of buffer size
//
size_to_get = (size_remaining > lineSize ? lineSize : size_remaining);
if (NULL == _fgetts(s, size_to_get, in)) {
if (ferror(in)) {
//_tperror(_T("While reading input"));
perror ("While reading input");
//exit(IO_ERROR);
return;
} else {
assert (feof(in));
*s = _T('\0');
/* It is not clear to me from the definition that the
* contents of the buffer are well defined on detecting
* an eof without managing to read anything.
*/
}
}
/* If we didn't read the eol nor the eof go around for the rest */
s_eol = _tcschr (s, _T('\n'));
if (!feof (in) && !s_eol) {
s = _tcschr (s, _T('\0'));
/* It should be s + size_to_get - 1 but this is safer */
continue;
}
/* If it is a comment line then discard it and go around again */
if (line [0] == _T('#')) {
s = line;
continue;
}
/* Remove any line feed. Leave s_eol on the \0 */
if (s_eol) {
*s_eol = _T('\0');
if (s_eol > line && *(s_eol-1) == _T('\r'))
*--s_eol = _T('\0');
} else {
s_eol = _tcschr (s, _T('\0'));
}
/* If there is a concatenating \\ then go around again */
if (s_eol > line && *(s_eol-1) == _T('\\')) {
int c;
s = s_eol-1;
/* The following error protection could be made more self-
* correcting but I thought it not worth trying.
*/
if ((c = _fgettc(in)) == _TEOF || c != _T(' ') ||
(c = _fgettc(in)) == _TEOF || c != _T(' '))
_tprintf(_T("ERROR - invalid continuation.\n"));
continue;
}
break; /* That is the full virtual line */
}
command(line);
}
command(NULL);
HeapFree(GetProcessHeap(), 0, line);
}
/******************************************************************************
* Writes contents of the registry key to the specified file stream.
*
* Parameters:
* file_name - name of a file to export registry branch to.
* reg_key_name - registry branch to export. The whole registry is exported if
* reg_key_name is NULL or contains an empty string.
*/
BOOL export_registry_key(WCHAR *file_name, WCHAR *reg_key_name, DWORD format)
{
WCHAR *reg_key_name_buf;
WCHAR *val_name_buf;
BYTE *val_buf;
WCHAR *line_buf;
DWORD reg_key_name_size = KEY_MAX_LEN;
DWORD val_name_size = KEY_MAX_LEN;
DWORD val_size = REG_VAL_BUF_SIZE;
DWORD line_buf_size = KEY_MAX_LEN + REG_VAL_BUF_SIZE;
FILE *file = NULL;
BOOL unicode = (format == REG_FORMAT_5);
reg_key_name_buf = HeapAlloc(GetProcessHeap(), 0,
reg_key_name_size * sizeof(*reg_key_name_buf));
val_name_buf = HeapAlloc(GetProcessHeap(), 0,
val_name_size * sizeof(*val_name_buf));
val_buf = HeapAlloc(GetProcessHeap(), 0, val_size);
line_buf = HeapAlloc(GetProcessHeap(), 0, line_buf_size * sizeof(*line_buf));
CHECK_ENOUGH_MEMORY(reg_key_name_buf && val_name_buf && val_buf && line_buf);
if (reg_key_name && reg_key_name[0]) {
HKEY reg_key_class;
WCHAR *branch_name = NULL;
HKEY key;
REGPROC_resize_char_buffer(®_key_name_buf, ®_key_name_size,
lstrlenW(reg_key_name));
lstrcpyW(reg_key_name_buf, reg_key_name);
/* open the specified key */
if (!parseKeyName(reg_key_name, ®_key_class, &branch_name)) {
output_message(STRING_INCORRECT_REG_CLASS, reg_key_name);
exit(1);
}
if (!branch_name[0]) {
/* no branch - registry class is specified */
file = REGPROC_open_export_file(file_name, unicode);
export_hkey(file, reg_key_class,
®_key_name_buf, ®_key_name_size,
&val_name_buf, &val_name_size,
&val_buf, &val_size, &line_buf,
&line_buf_size, unicode);
} else if (RegOpenKeyW(reg_key_class, branch_name, &key) == ERROR_SUCCESS) {
file = REGPROC_open_export_file(file_name, unicode);
export_hkey(file, key,
®_key_name_buf, ®_key_name_size,
&val_name_buf, &val_name_size,
&val_buf, &val_size, &line_buf,
&line_buf_size, unicode);
RegCloseKey(key);
} else {
output_message(STRING_REG_KEY_NOT_FOUND, reg_key_name);
}
} else {
unsigned int i;
/* export all registry classes */
file = REGPROC_open_export_file(file_name, unicode);
for (i = 0; i < ARRAY_SIZE(reg_class_keys); i++) {
/* do not export HKEY_CLASSES_ROOT */
if (reg_class_keys[i] != HKEY_CLASSES_ROOT &&
reg_class_keys[i] != HKEY_CURRENT_USER &&
reg_class_keys[i] != HKEY_CURRENT_CONFIG &&
reg_class_keys[i] != HKEY_DYN_DATA) {
lstrcpyW(reg_key_name_buf, reg_class_namesW[i]);
export_hkey(file, reg_class_keys[i],
®_key_name_buf, ®_key_name_size,
&val_name_buf, &val_name_size,
&val_buf, &val_size, &line_buf,
&line_buf_size, unicode);
}
}
}
if (file) {
fclose(file);
}
HeapFree(GetProcessHeap(), 0, reg_key_name);
HeapFree(GetProcessHeap(), 0, val_name_buf);
HeapFree(GetProcessHeap(), 0, val_buf);
HeapFree(GetProcessHeap(), 0, line_buf);
return TRUE;
}
