ReactOS  0.4.14-dev-49-gfb4591c
regproc.c File Reference
#include <windows.h>
#include <commctrl.h>
#include <stdlib.h>
#include <tchar.h>
#include <process.h>
#include <stdio.h>
#include <wchar.h>
#include <ctype.h>
#include <limits.h>
#include <winnt.h>
#include <winreg.h>
#include <assert.h>
#include "regproc.h"
Include dependency graph for regproc.c:

Go to the source code of this file.

Macros

#define WIN32_LEAN_AND_MEAN
 
#define REG_VAL_BUF_SIZE   4096
 
#define QUERY_VALUE_MAX_ARGS   1
 
#define REG_FILE_HEX_LINE_LEN   76
 
#define REG_CLASS_NUMBER   (sizeof(reg_class_names) / sizeof(reg_class_names[0]))
 
#define NOT_ENOUGH_MEMORY   1
 
#define IO_ERROR   2
 
#define CHECK_ENOUGH_MEMORY(p)
 
#define _TEOF   EOF
 

Functions

void get_file_nameA (CHAR **command_line, CHAR *file_name, int max_filename)
 
void get_file_nameW (CHAR **command_line, WCHAR *filename, int max_filename)
 
DWORD convertHexToDWord (TCHAR *str, BYTE *buf)
 
TCHARconvertHexToHexCSV (BYTE *buf, ULONG bufLen)
 
TCHARconvertHexToDWORDStr (BYTE *buf, ULONG bufLen)
 
DWORD convertHexCSVToHex (TCHAR *str, BYTE *buf, ULONG bufLen)
 
DWORD getDataType (LPTSTR *lpValue, DWORD *parse_type)
 
LPTSTR getArg (LPTSTR arg)
 
void REGPROC_unescape_string (LPTSTR str)
 
HRESULT setValue (LPTSTR val_name, LPTSTR val_data)
 
HRESULT openKey (LPTSTR stdInput)
 
LPTSTR getRegKeyName (LPTSTR lpLine)
 
HKEY getRegClass (LPTSTR lpClass)
 
void closeKey (VOID)
 
void doSetValue (LPTSTR stdInput)
 
void doQueryValue (LPTSTR stdInput)
 
void doDeleteValue (LPTSTR line)
 
void doDeleteKey (LPTSTR line)
 
void doCreateKey (LPTSTR line)
 
void processSetValue (LPTSTR line)
 
void processQueryValue (LPTSTR cmdline)
 
void processRegLines (FILE *in, CommandAPI command)
 
void doRegisterDLL (LPTSTR stdInput)
 
void doUnregisterDLL (LPTSTR stdInput)
 
void REGPROC_print_error (VOID)
 
void REGPROC_resize_char_buffer (TCHAR **buffer, DWORD *len, DWORD required_len)
 
void REGPROC_export_string (FILE *file, TCHAR *str)
 
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)
 
FILEREGPROC_open_export_file (TCHAR *file_name)
 
BOOL export_registry_key (TCHAR *file_name, TCHAR *reg_key_name)
 
BOOL import_registry_file (LPTSTR filename)
 
BOOL delete_branch (HKEY key, TCHAR **reg_key_name_buf, DWORD *reg_key_name_len)
 
void delete_registry_key (TCHAR *reg_key_name)
 

Variables

static LPTSTR currentKeyName = NULL
 
static HKEY currentKeyClass = 0
 
static HKEY currentKeyHandle = 0
 
static BOOL bTheKeyIsOpen = FALSE
 
static TCHARreg_class_names []
 
static HKEY reg_class_keys [REG_CLASS_NUMBER]
 

Macro Definition Documentation

◆ _TEOF

#define _TEOF   EOF

Definition at line 117 of file regproc.c.

◆ CHECK_ENOUGH_MEMORY

#define CHECK_ENOUGH_MEMORY (   p)
Value:
if (!(p)) \
{ \
_tprintf(_T("file %s, line %d: Not enough memory"), __FILE__, __LINE__); \
assert(0);\
}
#define _T(x)
Definition: vfdio.h:22
#define NOT_ENOUGH_MEMORY
Definition: regproc.c:90
GLfloat GLfloat p
Definition: glext.h:8902

Definition at line 105 of file regproc.c.

◆ IO_ERROR

#define IO_ERROR   2

Definition at line 91 of file regproc.c.

◆ NOT_ENOUGH_MEMORY

#define NOT_ENOUGH_MEMORY   1

Definition at line 90 of file regproc.c.

◆ QUERY_VALUE_MAX_ARGS

#define QUERY_VALUE_MAX_ARGS   1

Definition at line 62 of file regproc.c.

◆ REG_CLASS_NUMBER

#define REG_CLASS_NUMBER   (sizeof(reg_class_names) / sizeof(reg_class_names[0]))

Definition at line 82 of file regproc.c.

◆ REG_FILE_HEX_LINE_LEN

#define REG_FILE_HEX_LINE_LEN   76

Definition at line 66 of file regproc.c.

◆ REG_VAL_BUF_SIZE

#define REG_VAL_BUF_SIZE   4096

Definition at line 59 of file regproc.c.

◆ WIN32_LEAN_AND_MEAN

#define WIN32_LEAN_AND_MEAN

Definition at line 39 of file regproc.c.

Function Documentation

◆ closeKey()

void closeKey ( VOID  )

Definition at line 604 of file regproc.c.

605 {
607  HeapFree(GetProcessHeap(), 0, currentKeyName); /* Allocated by getKeyName */
610  currentKeyClass = 0;
611  currentKeyHandle = 0;
612 }
static HKEY currentKeyHandle
Definition: regproc.c:71
static LPTSTR currentKeyName
Definition: regproc.c:69
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
smooth NULL
Definition: ftsmooth.c:416
#define GetProcessHeap()
Definition: compat.h:395
static BOOL bTheKeyIsOpen
Definition: regproc.c:72
static HKEY currentKeyClass
Definition: regproc.c:70
#define HeapFree(x, y, z)
Definition: compat.h:394

Referenced by doQueryValue(), and doSetValue().

◆ convertHexCSVToHex()

DWORD convertHexCSVToHex ( TCHAR str,
BYTE buf,
ULONG  bufLen 
)

Definition at line 289 of file regproc.c.

290 {
291  TCHAR* s = str; /* Pointer to current */
292  CHAR* b = buf; /* Pointer to result */
293  ULONG strLen = _tcslen(str);
294  ULONG strPos = 0;
295  DWORD byteCount = 0;
296 
297  memset(buf, 0, bufLen);
298  /*
299  * warn the user if we are here with a string longer than 2 bytes that does
300  * not contains ",". It is more likely because the data is invalid.
301  */
302  if ((strLen > 2) && (_tcschr(str, _T(',')) == NULL)) {
303  _tprintf(_T("WARNING converting CSV hex stream with no comma, ") \
304  _T("input data seems invalid.\n"));
305  }
306  if (strLen > 3*bufLen) {
307  _tprintf(_T("ERROR converting CSV hex stream. Too long\n"));
308  }
309  while (strPos < strLen) {
310  TCHAR xbuf[3];
311  TCHAR wc;
312  memcpy(xbuf, s, 2);
313  xbuf[2] = _T('\0');
314  _stscanf(xbuf, _T("%02x"), (UINT*)&wc);
315  if (byteCount < bufLen)
316  *b++ = (unsigned char)wc;
317  s += 3;
318  strPos += 3;
319  ++byteCount;
320  }
321  return byteCount;
322 }
#define _tprintf
Definition: tchar.h:506
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
char CHAR
Definition: xmlstorage.h:175
#define _stscanf
Definition: tchar.h:557
const WCHAR * str
size_t __cdecl _tcslen(const _TCHAR *str)
Definition: tcslen.h:9
smooth NULL
Definition: ftsmooth.c:416
unsigned char
Definition: typeof.h:29
_TCHAR * _tcschr(const _TCHAR *s, _XINT c)
Definition: tcschr.h:4
char TCHAR
Definition: xmlstorage.h:189
GLboolean GLboolean GLboolean b
Definition: glext.h:6204
#define _T(x)
Definition: vfdio.h:22
unsigned long DWORD
Definition: ntddk_ex.h:95
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLdouble s
Definition: gl.h:2039
unsigned int UINT
Definition: ndis.h:50
unsigned int ULONG
Definition: retypes.h:1
#define memset(x, y, z)
Definition: compat.h:39

Referenced by setValue().

◆ convertHexToDWord()

DWORD convertHexToDWord ( TCHAR str,
BYTE buf 
)

Definition at line 231 of file regproc.c.

232 {
233  DWORD dw;
234  TCHAR xbuf[9];
235 
236  memcpy(xbuf, str, 8 * sizeof(TCHAR));
237  xbuf[88 * sizeof(TCHAR)] = '\0';
238  _stscanf(xbuf, _T("%08lx"), &dw);
239  memcpy(buf, &dw, sizeof(DWORD));
240  return sizeof(DWORD);
241 }
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define _stscanf
Definition: tchar.h:557
#define DWORD
Definition: nt_native.h:44
const WCHAR * str
char TCHAR
Definition: xmlstorage.h:189
#define _T(x)
Definition: vfdio.h:22
unsigned long DWORD
Definition: ntddk_ex.h:95
REFIID LPVOID DWORD dw
Definition: atlbase.h:40
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878

Referenced by setValue().

◆ convertHexToDWORDStr()

TCHAR* convertHexToDWORDStr ( BYTE buf,
ULONG  bufLen 
)

Definition at line 272 of file regproc.c.

273 {
274  TCHAR* str;
275  DWORD dw;
276 
277  if (bufLen != sizeof(DWORD)) return NULL;
278  str = HeapAlloc(GetProcessHeap(), 0, ((bufLen*2)+1)*sizeof(TCHAR));
279  memcpy(&dw, buf, sizeof(DWORD));
280  _stprintf(str, _T("%08lx"), dw);
281  /* Get rid of the last comma */
282  return str;
283 }
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
const WCHAR * str
smooth NULL
Definition: ftsmooth.c:416
char TCHAR
Definition: xmlstorage.h:189
#define _T(x)
Definition: vfdio.h:22
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned long DWORD
Definition: ntddk_ex.h:95
REFIID LPVOID DWORD dw
Definition: atlbase.h:40
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
#define _stprintf
Definition: utility.h:124

Referenced by processQueryValue().

◆ convertHexToHexCSV()

TCHAR* convertHexToHexCSV ( BYTE buf,
ULONG  bufLen 
)

Definition at line 246 of file regproc.c.

247 {
248  TCHAR* str;
249  TCHAR* ptrStr;
250  BYTE* ptrBuf;
251 
252  ULONG current = 0;
253  str = HeapAlloc(GetProcessHeap(), 0, (bufLen+1)*2*sizeof(TCHAR));
254  memset(str, 0, (bufLen+1)*2);
255  ptrStr = str; /* Pointer to result */
256  ptrBuf = buf; /* Pointer to current */
257  while (current < bufLen) {
258  BYTE bCur = ptrBuf[current++];
259  TCHAR res[3];
260  _stprintf(res, _T("%02x"), (unsigned int)*&bCur);
261  _tcscat(str, res);
262  _tcscat(str, _T(","));
263  }
264  /* Get rid of the last comma */
265  str[_tcslen(str)-1] = _T('\0');
266  return str;
267 }
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
const WCHAR * str
size_t __cdecl _tcslen(const _TCHAR *str)
Definition: tcslen.h:9
char TCHAR
Definition: xmlstorage.h:189
#define _T(x)
Definition: vfdio.h:22
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned char BYTE
Definition: mem.h:68
#define _stprintf
Definition: utility.h:124
_TCHAR * _tcscat(_TCHAR *s, const _TCHAR *append)
Definition: tcscat.h:8
GLuint res
Definition: glext.h:9613
unsigned int ULONG
Definition: retypes.h:1
#define memset(x, y, z)
Definition: compat.h:39
struct task_struct * current
Definition: linux.c:32

Referenced by processQueryValue().

◆ delete_branch()

BOOL delete_branch ( HKEY  key,
TCHAR **  reg_key_name_buf,
DWORD reg_key_name_len 
)

Definition at line 1410 of file regproc.c.

1411 {
1412  HKEY branch_key;
1413  DWORD max_sub_key_len;
1414  DWORD subkeys;
1415  DWORD curr_len;
1416  LONG ret;
1417  long int i;
1418 
1419  if (RegOpenKey(key, *reg_key_name_buf, &branch_key) != ERROR_SUCCESS) {
1421  return FALSE;
1422  }
1423 
1424  /* get size information and resize the buffers if necessary */
1425  if (RegQueryInfoKey(branch_key, NULL, NULL, NULL, &subkeys, &max_sub_key_len,
1426  NULL, NULL, NULL, NULL, NULL, NULL) != ERROR_SUCCESS) {
1428  RegCloseKey(branch_key);
1429  return FALSE;
1430  }
1431  curr_len = _tcslen(*reg_key_name_buf);
1432  REGPROC_resize_char_buffer(reg_key_name_buf, reg_key_name_len, max_sub_key_len + curr_len + 1);
1433 
1434  (*reg_key_name_buf)[curr_len] = '\\';
1435  for (i = subkeys - 1; i >= 0; i--) {
1436  DWORD buf_len = *reg_key_name_len - curr_len;
1437  ret = RegEnumKeyEx(branch_key, i, *reg_key_name_buf + curr_len + 1, &buf_len, NULL, NULL, NULL, NULL);
1440  RegCloseKey(branch_key);
1441  return FALSE;
1442  } else {
1443  delete_branch(key, reg_key_name_buf, reg_key_name_len);
1444  }
1445  }
1446  (*reg_key_name_buf)[curr_len] = '\0';
1447  RegCloseKey(branch_key);
1448  RegDeleteKey(key, *reg_key_name_buf);
1449  return TRUE;
1450 }
#define TRUE
Definition: types.h:120
#define RegQueryInfoKey
Definition: winreg.h:521
#define ERROR_SUCCESS
Definition: deptool.c:10
#define ERROR_NO_MORE_ITEMS
Definition: compat.h:95
BOOL delete_branch(HKEY key, TCHAR **reg_key_name_buf, DWORD *reg_key_name_len)
Definition: regproc.c:1410
void REGPROC_resize_char_buffer(TCHAR **buffer, DWORD *len, DWORD required_len)
Definition: regproc.c:1085
void REGPROC_print_error(VOID)
Definition: regproc.c:1056
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
long LONG
Definition: pedump.c:60
size_t __cdecl _tcslen(const _TCHAR *str)
Definition: tcslen.h:9
smooth NULL
Definition: ftsmooth.c:416
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
#define RegEnumKeyEx
Definition: winreg.h:510
#define ERROR_MORE_DATA
Definition: dderror.h:13
#define RegDeleteKey
Definition: winreg.h:502
#define RegOpenKey
Definition: winreg.h:519
Definition: path.c:42

Referenced by delete_registry_key().

◆ delete_registry_key()

void delete_registry_key ( TCHAR reg_key_name)

Definition at line 1459 of file regproc.c.

1460 {
1461  TCHAR* branch_name;
1462  DWORD branch_name_len;
1463  HKEY reg_key_class;
1464  HKEY branch_key;
1465 
1466  if (!reg_key_name || !reg_key_name[0]) {
1467  return;
1468  }
1469  /* open the specified key */
1470  reg_key_class = getRegClass(reg_key_name);
1471  if (reg_key_class == (HKEY)ERROR_INVALID_PARAMETER) {
1472  _tprintf(_T("Incorrect registry class specification in '%s'\n"), reg_key_name);
1473  //exit(1);
1474  return;
1475  }
1476  branch_name = getRegKeyName(reg_key_name);
1477  CHECK_ENOUGH_MEMORY(branch_name);
1478  branch_name_len = _tcslen(branch_name);
1479  if (!branch_name[0]) {
1480  _tprintf(_T("Can't delete registry class '%s'\n"), reg_key_name);
1481  //exit(1);
1482  return;
1483  }
1484  if (RegOpenKey(reg_key_class, branch_name, &branch_key) == ERROR_SUCCESS) {
1485  /* check whether the key exists */
1486  RegCloseKey(branch_key);
1487  delete_branch(reg_key_class, &branch_name, &branch_name_len);
1488  }
1489  HeapFree(GetProcessHeap(), 0, branch_name);
1490 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
#define _tprintf
Definition: tchar.h:506
#define ERROR_SUCCESS
Definition: deptool.c:10
BOOL delete_branch(HKEY key, TCHAR **reg_key_name_buf, DWORD *reg_key_name_len)
Definition: regproc.c:1410
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
size_t __cdecl _tcslen(const _TCHAR *str)
Definition: tcslen.h:9
char TCHAR
Definition: xmlstorage.h:189
#define CHECK_ENOUGH_MEMORY(p)
Definition: regproc.c:105
#define _T(x)
Definition: vfdio.h:22
LPTSTR getRegKeyName(LPTSTR lpLine)
Definition: regproc.c:536
#define GetProcessHeap()
Definition: compat.h:395
unsigned long DWORD
Definition: ntddk_ex.h:95
HKEY getRegClass(LPTSTR lpClass)
Definition: regproc.c:567
#define RegOpenKey
Definition: winreg.h:519
#define HeapFree(x, y, z)
Definition: compat.h:394

◆ doCreateKey()

void doCreateKey ( LPTSTR  line)

Definition at line 704 of file regproc.c.

704  {
705  _tprintf(_T("createKey not yet implemented\n"));
706 }
#define _tprintf
Definition: tchar.h:506
#define _T(x)
Definition: vfdio.h:22

◆ doDeleteKey()

void doDeleteKey ( LPTSTR  line)

Definition at line 695 of file regproc.c.

695  {
696  _tprintf(_T("deleteKey not yet implemented\n"));
697 }
#define _tprintf
Definition: tchar.h:506
#define _T(x)
Definition: vfdio.h:22

◆ doDeleteValue()

void doDeleteValue ( LPTSTR  line)

Definition at line 686 of file regproc.c.

686  {
687  _tprintf(_T("deleteValue not yet implemented\n"));
688 }
#define _tprintf
Definition: tchar.h:506
#define _T(x)
Definition: vfdio.h:22

◆ doQueryValue()

void doQueryValue ( LPTSTR  stdInput)

Definition at line 653 of file regproc.c.

653  {
654  /*
655  * We encoutered the end of the file, make sure we
656  * close the opened key and exit
657  */
658  if (stdInput == NULL) {
659  if (bTheKeyIsOpen != FALSE)
660  closeKey();
661  return;
662  }
663 
664  if (stdInput[0] == _T('[')) { /* We are reading a new key */
665  if (bTheKeyIsOpen != FALSE)
666  closeKey(); /* Close the previous key before */
667  if (openKey(stdInput) != ERROR_SUCCESS ) {
668  _tprintf(_T("doQueryValue failed to open key %s\n"), stdInput);
669  }
670  }
671  else if( (bTheKeyIsOpen) &&
672  ((stdInput[0] == _T('@')) || /* reading a default @=data pair */
673  (stdInput[0] == _T('\"')))) { /* reading a new value=data pair */
674  processQueryValue(stdInput);
675  } else { /* since we are assuming that the file format is */
676  if (bTheKeyIsOpen) /* valid we must be reading a blank line which */
677  closeKey(); /* indicate end of this key processing */
678  }
679 }
#define _tprintf
Definition: tchar.h:506
#define ERROR_SUCCESS
Definition: deptool.c:10
void processQueryValue(LPTSTR cmdline)
Definition: regproc.c:770
smooth NULL
Definition: ftsmooth.c:416
#define _T(x)
Definition: vfdio.h:22
HRESULT openKey(LPTSTR stdInput)
Definition: regproc.c:494
static BOOL bTheKeyIsOpen
Definition: regproc.c:72
void closeKey(VOID)
Definition: regproc.c:604

◆ doRegisterDLL()

void doRegisterDLL ( LPTSTR  stdInput)

Definition at line 994 of file regproc.c.

995 {
996  HMODULE theLib = 0;
997  UINT retVal = 0;
998 
999  /* Check for valid input */
1000  if (stdInput == NULL) return;
1001 
1002  /* Load and register the library, then free it */
1003  theLib = LoadLibrary(stdInput);
1004  if (theLib) {
1005  FARPROC lpfnDLLRegProc = GetProcAddress(theLib, "DllRegisterServer");
1006  if (lpfnDLLRegProc) {
1007  retVal = (*lpfnDLLRegProc)();
1008  } else {
1009  _tprintf(_T("Couldn't find DllRegisterServer proc in '%s'.\n"), stdInput);
1010  }
1011  if (retVal != S_OK) {
1012  _tprintf(_T("Couldn't find DllRegisterServer proc in '%s'.\n"), stdInput);
1013  }
1014  FreeLibrary(theLib);
1015  } else {
1016  _tprintf(_T("Could not load DLL '%s'.\n"), stdInput);
1017  }
1018 }
#define _tprintf
Definition: tchar.h:506
#define LoadLibrary
Definition: winbase.h:3679
smooth NULL
Definition: ftsmooth.c:416
#define _T(x)
Definition: vfdio.h:22
#define FreeLibrary(x)
Definition: compat.h:405
#define S_OK
Definition: intsafe.h:59
unsigned int UINT
Definition: ndis.h:50
#define GetProcAddress(x, y)
Definition: compat.h:410
int(* FARPROC)()
Definition: compat.h:28

◆ doSetValue()

void doSetValue ( LPTSTR  stdInput)

Definition at line 619 of file regproc.c.

620 {
621  /*
622  * We encountered the end of the file, make sure we
623  * close the opened key and exit
624  */
625  if (stdInput == NULL) {
626  if (bTheKeyIsOpen != FALSE)
627  closeKey();
628  return;
629  }
630 
631  if (stdInput[0] == _T('[')) { /* We are reading a new key */
632  if (bTheKeyIsOpen != FALSE) {
633  closeKey(); /* Close the previous key before */
634  }
635  if (openKey(stdInput) != ERROR_SUCCESS) {
636  _tprintf(_T("doSetValue failed to open key %s\n"), stdInput);
637  }
638  } else if ((bTheKeyIsOpen) &&
639  ((stdInput[0] == _T('@')) || /* reading a default @=data pair */
640  (stdInput[0] == _T('\"')))) { /* reading a new value=data pair */
641  processSetValue(stdInput);
642  } else { /* since we are assuming that the file format is */
643  if (bTheKeyIsOpen) /* valid we must be reading a blank line which */
644  closeKey(); /* indicate end of this key processing */
645  }
646 }
#define _tprintf
Definition: tchar.h:506
#define ERROR_SUCCESS
Definition: deptool.c:10
void processSetValue(LPTSTR line)
Definition: regproc.c:716
smooth NULL
Definition: ftsmooth.c:416
#define _T(x)
Definition: vfdio.h:22
HRESULT openKey(LPTSTR stdInput)
Definition: regproc.c:494
static BOOL bTheKeyIsOpen
Definition: regproc.c:72
void closeKey(VOID)
Definition: regproc.c:604

Referenced by import_registry_file().

◆ doUnregisterDLL()

void doUnregisterDLL ( LPTSTR  stdInput)

Definition at line 1024 of file regproc.c.

1025 {
1026  HMODULE theLib = 0;
1027  UINT retVal = 0;
1028 
1029  /* Check for valid input */
1030  if (stdInput == NULL) return;
1031 
1032  /* Load and unregister the library, then free it */
1033  theLib = LoadLibrary(stdInput);
1034  if (theLib) {
1035  FARPROC lpfnDLLRegProc = GetProcAddress(theLib, "DllUnregisterServer");
1036  if (lpfnDLLRegProc) {
1037  retVal = (*lpfnDLLRegProc)();
1038  } else {
1039  _tprintf(_T("Couldn't find DllUnregisterServer proc in '%s'.\n"), stdInput);
1040  }
1041  if (retVal != S_OK) {
1042  _tprintf(_T("DLLUnregisterServer error 0x%x in '%s'.\n"), retVal, stdInput);
1043  }
1044  FreeLibrary(theLib);
1045  } else {
1046  _tprintf(_T("Could not load DLL '%s'.\n"), stdInput);
1047  }
1048 }
#define _tprintf
Definition: tchar.h:506
#define LoadLibrary
Definition: winbase.h:3679
smooth NULL
Definition: ftsmooth.c:416
#define _T(x)
Definition: vfdio.h:22
#define FreeLibrary(x)
Definition: compat.h:405
#define S_OK
Definition: intsafe.h:59
unsigned int UINT
Definition: ndis.h:50
#define GetProcAddress(x, y)
Definition: compat.h:410
int(* FARPROC)()
Definition: compat.h:28

◆ export_hkey()

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 
)

Definition at line 1131 of file regproc.c.

1135 {
1136  DWORD max_sub_key_len;
1137  DWORD max_val_name_len;
1138  DWORD max_val_size;
1139  DWORD curr_len;
1140  DWORD i;
1141  BOOL more_data;
1142  LONG ret;
1143 
1144  /* get size information and resize the buffers if necessary */
1145  if (RegQueryInfoKey(key, NULL, NULL, NULL, NULL, &max_sub_key_len, NULL,
1146  NULL, &max_val_name_len, &max_val_size, NULL, NULL) != ERROR_SUCCESS) {
1148  }
1149  curr_len = _tcslen(*reg_key_name_buf);
1150  REGPROC_resize_char_buffer(reg_key_name_buf, reg_key_name_len, max_sub_key_len + curr_len + 1);
1151  REGPROC_resize_char_buffer(val_name_buf, val_name_len, max_val_name_len);
1152  if (max_val_size > *val_size) {
1153  *val_size = max_val_size;
1154  *val_buf = HeapReAlloc(GetProcessHeap(), 0, *val_buf, *val_size * sizeof(TCHAR));
1155  CHECK_ENOUGH_MEMORY(val_buf);
1156  }
1157  /* output data for the current key */
1158  _fputts(_T("\n["), file);
1159  _fputts(*reg_key_name_buf, file);
1160  _fputts(_T("]\n"), file);
1161  /* print all the values */
1162  i = 0;
1163  more_data = TRUE;
1164  while (more_data) {
1165  DWORD value_type;
1166  DWORD val_name_len1 = *val_name_len;
1167  DWORD val_size1 = *val_size;
1168  ret = RegEnumValue(key, i, *val_name_buf, &val_name_len1, NULL, &value_type, *val_buf, &val_size1);
1169  if (ret != ERROR_SUCCESS) {
1170  more_data = FALSE;
1171  if (ret != ERROR_NO_MORE_ITEMS) {
1173  }
1174  } else {
1175  i++;
1176  if ((*val_name_buf)[0]) {
1177  _fputts(_T("\""), file);
1178  REGPROC_export_string(file, *val_name_buf);
1179  _fputts(_T("\"="), file);
1180  } else {
1181  _fputts(_T("@="), file);
1182  }
1183  switch (value_type) {
1184  case REG_EXPAND_SZ:
1185  _fputts(_T("expand:"), file);
1186  case REG_SZ:
1187  _fputts(_T("\""), file);
1188  REGPROC_export_string(file, *val_buf);
1189  _fputts(_T("\"\n"), file);
1190  break;
1191  case REG_DWORD:
1192  _ftprintf(file, _T("dword:%08lx\n"), *((DWORD *)*val_buf));
1193  break;
1194  default:
1195 /*
1196  _tprintf(_T("warning - unsupported registry format '%ld', ") \
1197  _T("treating as binary\n"), value_type);
1198  _tprintf(_T("key name: \"%s\"\n"), *reg_key_name_buf);
1199  _tprintf(_T("value name:\"%s\"\n\n"), *val_name_buf);
1200  */
1201  /* falls through */
1202  case REG_MULTI_SZ:
1203  /* falls through */
1204  case REG_BINARY:
1205  {
1206  DWORD i1;
1207  TCHAR *hex_prefix;
1208  TCHAR buf[20];
1209  int cur_pos;
1210 
1211  if (value_type == REG_BINARY) {
1212  hex_prefix = _T("hex:");
1213  } else {
1214  hex_prefix = buf;
1215  _stprintf(buf, _T("hex(%ld):"), value_type);
1216  }
1217  /* position of where the next character will be printed */
1218  /* NOTE: yes, _tcslen("hex:") is used even for hex(x): */
1219  cur_pos = _tcslen(_T("\"\"=")) + _tcslen(_T("hex:")) +
1220  _tcslen(*val_name_buf);
1221  _fputts(hex_prefix, file);
1222  for (i1 = 0; i1 < val_size1; i1++) {
1223  _ftprintf(file, _T("%02x"), (unsigned int)(*val_buf)[i1]);
1224  if (i1 + 1 < val_size1) {
1225  _fputts(_T(","), file);
1226  }
1227  cur_pos += 3;
1228  /* wrap the line */
1229  if (cur_pos > REG_FILE_HEX_LINE_LEN) {
1230  _fputts(_T("\\\n "), file);
1231  cur_pos = 2;
1232  }
1233  }
1234  _fputts(_T("\n"), file);
1235  break;
1236  }
1237  }
1238  }
1239  }
1240  i = 0;
1241  more_data = TRUE;
1242  (*reg_key_name_buf)[curr_len] = _T('\\');
1243  while (more_data) {
1244  DWORD buf_len = *reg_key_name_len - curr_len;
1245  ret = RegEnumKeyEx(key, i, *reg_key_name_buf + curr_len + 1, &buf_len, NULL, NULL, NULL, NULL);
1246  if (ret != ERROR_SUCCESS && ret != ERROR_MORE_DATA) {
1247  more_data = FALSE;
1248  if (ret != ERROR_NO_MORE_ITEMS) {
1250  }
1251  } else {
1252  HKEY subkey;
1253 
1254  i++;
1255  if (RegOpenKey(key, *reg_key_name_buf + curr_len + 1, &subkey) == ERROR_SUCCESS) {
1256  export_hkey(file, subkey, reg_key_name_buf, reg_key_name_len, val_name_buf, val_name_len, val_buf, val_size);
1257  RegCloseKey(subkey);
1258  } else {
1260  }
1261  }
1262  }
1263  (*reg_key_name_buf)[curr_len] = _T('\0');
1264 }
#define TRUE
Definition: types.h:120
#define RegQueryInfoKey
Definition: winreg.h:521
#define ERROR_SUCCESS
Definition: deptool.c:10
#define ERROR_NO_MORE_ITEMS
Definition: compat.h:95
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define REG_BINARY
Definition: nt_native.h:1496
#define _fputts
Definition: tchar.h:569
#define REG_FILE_HEX_LINE_LEN
Definition: regproc.c:66
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)
Definition: regproc.c:1131
void REGPROC_resize_char_buffer(TCHAR **buffer, DWORD *len, DWORD required_len)
Definition: regproc.c:1085
void REGPROC_print_error(VOID)
Definition: regproc.c:1056
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
#define REG_MULTI_SZ
Definition: nt_native.h:1501
size_t __cdecl _tcslen(const _TCHAR *str)
Definition: tcslen.h:9
smooth NULL
Definition: ftsmooth.c:416
#define _ftprintf
Definition: tchar.h:518
char TCHAR
Definition: xmlstorage.h:189
#define CHECK_ENOUGH_MEMORY(p)
Definition: regproc.c:105
#define _T(x)
Definition: vfdio.h:22
#define GetProcessHeap()
Definition: compat.h:395
unsigned long DWORD
Definition: ntddk_ex.h:95
int ret
#define RegEnumKeyEx
Definition: winreg.h:510
#define ERROR_MORE_DATA
Definition: dderror.h:13
#define _stprintf
Definition: utility.h:124
#define REG_EXPAND_SZ
Definition: nt_native.h:1494
#define HeapReAlloc
Definition: compat.h:393
void REGPROC_export_string(FILE *file, TCHAR *str)
Definition: regproc.c:1098
#define RegOpenKey
Definition: winreg.h:519
#define REG_DWORD
Definition: sdbapi.c:596
#define RegEnumValue
Definition: winreg.h:511
Definition: path.c:42
Definition: fci.c:126
#define REG_SZ
Definition: layer.c:22

Referenced by export_registry_key().

◆ export_registry_key()

BOOL export_registry_key ( TCHAR file_name,
TCHAR reg_key_name 
)

Definition at line 1310 of file regproc.c.

1311 {
1312  HKEY reg_key_class;
1313 
1314  TCHAR *reg_key_name_buf;
1315  TCHAR *val_name_buf;
1316  BYTE *val_buf;
1317  DWORD reg_key_name_len = KEY_MAX_LEN;
1318  DWORD val_name_len = KEY_MAX_LEN;
1319  DWORD val_size = REG_VAL_BUF_SIZE;
1320  FILE *file = NULL;
1321 
1322  //_tprintf(_T("export_registry_key(%s, %s)\n"), reg_key_name, file_name);
1323 
1324  reg_key_name_buf = HeapAlloc(GetProcessHeap(), 0, reg_key_name_len * sizeof(*reg_key_name_buf));
1325  val_name_buf = HeapAlloc(GetProcessHeap(), 0, val_name_len * sizeof(*val_name_buf));
1326  val_buf = HeapAlloc(GetProcessHeap(), 0, val_size);
1327  CHECK_ENOUGH_MEMORY(reg_key_name_buf && val_name_buf && val_buf);
1328 
1329  if (reg_key_name && reg_key_name[0]) {
1330  TCHAR *branch_name;
1331  HKEY key;
1332 
1333  REGPROC_resize_char_buffer(&reg_key_name_buf, &reg_key_name_len,
1334  _tcslen(reg_key_name));
1335  _tcscpy(reg_key_name_buf, reg_key_name);
1336 
1337  /* open the specified key */
1338  reg_key_class = getRegClass(reg_key_name);
1339  if (reg_key_class == (HKEY)ERROR_INVALID_PARAMETER) {
1340  _tprintf(_T("Incorrect registry class specification in '%s\n"), reg_key_name);
1341  //exit(1);
1342  return FALSE;
1343  }
1344  branch_name = getRegKeyName(reg_key_name);
1345  CHECK_ENOUGH_MEMORY(branch_name);
1346  if (!branch_name[0]) {
1347  /* no branch - registry class is specified */
1349  export_hkey(file, reg_key_class,
1350  &reg_key_name_buf, &reg_key_name_len,
1351  &val_name_buf, &val_name_len,
1352  &val_buf, &val_size);
1353  } else if (RegOpenKey(reg_key_class, branch_name, &key) == ERROR_SUCCESS) {
1355  export_hkey(file, key,
1356  &reg_key_name_buf, &reg_key_name_len,
1357  &val_name_buf, &val_name_len,
1358  &val_buf, &val_size);
1359  RegCloseKey(key);
1360  } else {
1361  _tprintf(_T("Can't export. Registry key '%s does not exist!\n"), reg_key_name);
1363  }
1364  HeapFree(GetProcessHeap(), 0, branch_name);
1365  } else {
1366  int i;
1367 
1368  /* export all registry classes */
1370  for (i = 0; i < REG_CLASS_NUMBER; i++) {
1371  /* do not export HKEY_CLASSES_ROOT */
1375  _tcscpy(reg_key_name_buf, reg_class_names[i]);
1377  &reg_key_name_buf, &reg_key_name_len,
1378  &val_name_buf, &val_name_len,
1379  &val_buf, &val_size);
1380  }
1381  }
1382  }
1383  if (file) {
1384  fclose(file);
1385  }
1386 // HeapFree(GetProcessHeap(), 0, reg_key_name);
1387  HeapFree(GetProcessHeap(), 0, val_buf);
1388  HeapFree(GetProcessHeap(), 0, val_name_buf);
1389  HeapFree(GetProcessHeap(), 0, reg_key_name_buf);
1390  return TRUE;
1391 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
#define _tprintf
Definition: tchar.h:506
#define TRUE
Definition: types.h:120
#define ERROR_SUCCESS
Definition: deptool.c:10
#define HKEY_CURRENT_USER
Definition: winreg.h:11
_TCHAR * _tcscpy(_TCHAR *to, const _TCHAR *from)
Definition: tcscpy.h:8
FILE * REGPROC_open_export_file(TCHAR *file_name)
Definition: regproc.c:1284
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)
Definition: regproc.c:1131
#define HKEY_CURRENT_CONFIG
Definition: winreg.h:15
static HKEY reg_class_keys[REG_CLASS_NUMBER]
Definition: regproc.c:84
void REGPROC_resize_char_buffer(TCHAR **buffer, DWORD *len, DWORD required_len)
Definition: regproc.c:1085
void REGPROC_print_error(VOID)
Definition: regproc.c:1056
#define KEY_MAX_LEN
Definition: regproc.h:22
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
#define REG_VAL_BUF_SIZE
Definition: regproc.c:59
size_t __cdecl _tcslen(const _TCHAR *str)
Definition: tcslen.h:9
smooth NULL
Definition: ftsmooth.c:416
static TCHAR * reg_class_names[]
Definition: regproc.c:74
char TCHAR
Definition: xmlstorage.h:189
#define CHECK_ENOUGH_MEMORY(p)
Definition: regproc.c:105
#define _T(x)
Definition: vfdio.h:22
LPTSTR getRegKeyName(LPTSTR lpLine)
Definition: regproc.c:536
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
unsigned long DWORD
Definition: ntddk_ex.h:95
HKEY key
Definition: reg.c:42
unsigned char BYTE
Definition: mem.h:68
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
static LPCWSTR file_name
Definition: protocol.c:146
HKEY getRegClass(LPTSTR lpClass)
Definition: regproc.c:567
#define HKEY_CLASSES_ROOT
Definition: winreg.h:10
#define REG_CLASS_NUMBER
Definition: regproc.c:82
#define RegOpenKey
Definition: winreg.h:519
#define HeapFree(x, y, z)
Definition: compat.h:394
Definition: path.c:42
Definition: fci.c:126

◆ get_file_nameA()

void get_file_nameA ( CHAR **  command_line,
CHAR file_name,
int  max_filename 
)

Definition at line 160 of file regproc.c.

161 {
162  CHAR *s = *command_line;
163  int pos = 0; /* position of pointer "s" in *command_line */
164  file_name[0] = 0;
165 
166  if (!s[0]) {
167  return;
168  }
169  if (s[0] == '"') {
170  s++;
171  (*command_line)++;
172  while (s[0] != '"') {
173  if (!s[0]) {
174  _tprintf(_T("Unexpected end of file name!\n"));
175  assert(0);
176  //exit(1);
177  }
178  s++;
179  pos++;
180  }
181  } else {
182  while (s[0] && !isspace(s[0])) {
183  s++;
184  pos++;
185  }
186  }
187  memcpy(file_name, *command_line, pos * sizeof((*command_line)[0]));
188  /* remove the last backslash */
189  if (file_name[pos - 1] == '\\') {
190  file_name[pos - 1] = '\0';
191  } else {
192  file_name[pos] = '\0';
193  }
194  if (s[0]) {
195  s++;
196  pos++;
197  }
198  while (s[0] && isspace(s[0])) {
199  s++;
200  pos++;
201  }
202  (*command_line) += pos;
203 }
#define isspace(c)
Definition: acclib.h:69
#define _tprintf
Definition: tchar.h:506
char CHAR
Definition: xmlstorage.h:175
#define assert(x)
Definition: debug.h:53
#define _T(x)
Definition: vfdio.h:22
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLdouble s
Definition: gl.h:2039
static LPCWSTR file_name
Definition: protocol.c:146

Referenced by get_file_nameW().

◆ get_file_nameW()

void get_file_nameW ( CHAR **  command_line,
WCHAR filename,
int  max_filename 
)

Definition at line 205 of file regproc.c.

206 {
208  int len;
209 
210  get_file_nameA(command_line, filenameA, _MAX_PATH);
211  len = strlen(filenameA);
212  OemToCharBuffW(filenameA, filename, max_filename);
213  filename[len] = _T('\0');
214 /*
215  UNICODE_STRING UnicodeString;
216  ANSI_STRING AnsiString;
217  CHAR filenameA[_MAX_PATH];
218 
219  get_file_nameA(command_line, filenameA, _MAX_PATH);
220 
221  //RtlInitAnsiString(&AnsiString, filenameA);
222  UnicodeString.Buffer = filename;
223  UnicodeString.MaximumLength = max_filename;//MAX_PATH;
224  RtlAnsiStringToUnicodeString(&UnicodeString, &AnsiString, FALSE);
225  */
226 }
BOOL WINAPI OemToCharBuffW(_In_ LPCSTR lpszSrc, _Out_writes_(cchDstLength) LPWSTR lpszDst, _In_ DWORD cchDstLength)
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
char CHAR
Definition: xmlstorage.h:175
const char * filename
Definition: ioapi.h:135
#define _MAX_PATH
Definition: utility.h:77
#define _T(x)
Definition: vfdio.h:22
static CHAR filenameA[MAX_PATH]
Definition: storage32.c:42
GLenum GLsizei len
Definition: glext.h:6722
void get_file_nameA(CHAR **command_line, CHAR *file_name, int max_filename)
Definition: regproc.c:160

◆ getArg()

LPTSTR getArg ( LPTSTR  arg)

Definition at line 377 of file regproc.c.

378 {
379  LPTSTR tmp = NULL;
380  ULONG len;
381 
382  if (arg == NULL) return NULL;
383 
384  // Get rid of surrounding quotes
385  len = _tcslen(arg);
386  if (arg[len-1] == _T('\"')) arg[len-1] = _T('\0');
387  if (arg[0] == _T('\"')) arg++;
388  tmp = HeapAlloc(GetProcessHeap(), 0, (_tcslen(arg)+1) * sizeof(TCHAR));
389  _tcscpy(tmp, arg);
390  return tmp;
391 }
_TCHAR * _tcscpy(_TCHAR *to, const _TCHAR *from)
Definition: tcscpy.h:8
CHAR * LPTSTR
Definition: xmlstorage.h:192
size_t __cdecl _tcslen(const _TCHAR *str)
Definition: tcslen.h:9
smooth NULL
Definition: ftsmooth.c:416
char TCHAR
Definition: xmlstorage.h:189
#define _T(x)
Definition: vfdio.h:22
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
GLenum GLsizei len
Definition: glext.h:6722
unsigned int ULONG
Definition: retypes.h:1

Referenced by processQueryValue().

◆ getDataType()

DWORD getDataType ( LPTSTR lpValue,
DWORD parse_type 
)

Definition at line 331 of file regproc.c.

332 {
333  struct data_type { const TCHAR *tag; int len; int type; int parse_type; };
334 
335  static const struct data_type data_types[] =
336  { /* actual type */ /* type to assume for parsing */
337  { _T("\""), 1, REG_SZ, REG_SZ },
338  { _T("str:\""), 5, REG_SZ, REG_SZ },
339 // { _T("str(2):\""), 8, REG_EXPAND_SZ, REG_SZ },
340  { _T("expand:\""), 8, REG_EXPAND_SZ, REG_EXPAND_SZ },
341  { _T("hex:"), 4, REG_BINARY, REG_BINARY },
342  { _T("dword:"), 6, REG_DWORD, REG_DWORD },
343  { _T("hex("), 4, -1, REG_BINARY },
344  { NULL, 0, 0, 0 }
345  };
346 
347  const struct data_type *ptr;
348  int type;
349 
350  for (ptr = data_types; ptr->tag; ptr++) {
351  if (memcmp(ptr->tag, *lpValue, ptr->len))
352  continue;
353 
354  /* Found! */
355  *parse_type = ptr->parse_type;
356  type = ptr->type;
357  *lpValue += ptr->len;
358  if (type == -1) {
359  TCHAR* end;
360  /* "hex(xx):" is special */
361  type = (int)_tcstoul(*lpValue , &end, 16);
362  if (**lpValue == _T('\0') || *end != _T(')') || *(end+1) != _T(':')) {
363  type = REG_NONE;
364  } else {
365  *lpValue = end + 2;
366  }
367  }
368  return type;
369  }
370  return (**lpValue == _T('\0') ? REG_SZ : REG_NONE);
371 }
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
#define REG_BINARY
Definition: nt_native.h:1496
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLuint GLuint end
Definition: gl.h:1545
static PVOID ptr
Definition: dispmode.c:27
smooth NULL
Definition: ftsmooth.c:416
char TCHAR
Definition: xmlstorage.h:189
#define _T(x)
Definition: vfdio.h:22
#define _tcstoul
Definition: tchar.h:595
int parse_type(Type t, const vector< string > &tokens, int off, vector< string > &names, vector< string > &dependencies)
Definition: sdkparse.cpp:653
GLenum GLsizei len
Definition: glext.h:6722
#define REG_EXPAND_SZ
Definition: nt_native.h:1494
#define REG_NONE
Definition: nt_native.h:1492
#define REG_DWORD
Definition: sdbapi.c:596
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
#define REG_SZ
Definition: layer.c:22
char * tag
Definition: main.c:59

Referenced by setValue().

◆ getRegClass()

HKEY getRegClass ( LPTSTR  lpClass)

Definition at line 567 of file regproc.c.

568 {
569  LPTSTR classNameEnd;
570  LPTSTR classNameBeg;
571  int i;
572 
573  TCHAR lpClassCopy[KEY_MAX_LEN];
574 
575  if (lpClass == NULL)
577 
578  _tcsncpy(lpClassCopy, lpClass, KEY_MAX_LEN);
579 
580  classNameEnd = _tcschr(lpClassCopy, _T('\\')); /* The class name ends by '\' */
581  if (!classNameEnd) { /* or the whole string */
582  classNameEnd = lpClassCopy + _tcslen(lpClassCopy);
583  if (classNameEnd[-1] == _T(']')) {
584  classNameEnd--;
585  }
586  }
587  *classNameEnd = _T('\0'); /* Isolate the class name */
588  if (lpClassCopy[0] == _T('[')) {
589  classNameBeg = lpClassCopy + 1;
590  } else {
591  classNameBeg = lpClassCopy;
592  }
593  for (i = 0; i < REG_CLASS_NUMBER; i++) {
594  if (!_tcscmp(classNameBeg, reg_class_names[i])) {
595  return reg_class_keys[i];
596  }
597  }
599 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
int _tcscmp(const _TCHAR *s1, const _TCHAR *s2)
Definition: tcscmp.h:8
_TCHAR * _tcsncpy(_TCHAR *dst, const _TCHAR *src, size_t n)
Definition: tcsncpy.h:9
CHAR * LPTSTR
Definition: xmlstorage.h:192
static HKEY reg_class_keys[REG_CLASS_NUMBER]
Definition: regproc.c:84
#define KEY_MAX_LEN
Definition: regproc.h:22
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
size_t __cdecl _tcslen(const _TCHAR *str)
Definition: tcslen.h:9
smooth NULL
Definition: ftsmooth.c:416
_TCHAR * _tcschr(const _TCHAR *s, _XINT c)
Definition: tcschr.h:4
static TCHAR * reg_class_names[]
Definition: regproc.c:74
char TCHAR
Definition: xmlstorage.h:189
#define _T(x)
Definition: vfdio.h:22
#define REG_CLASS_NUMBER
Definition: regproc.c:82

Referenced by delete_registry_key(), export_registry_key(), and openKey().

◆ getRegKeyName()

LPTSTR getRegKeyName ( LPTSTR  lpLine)

Definition at line 536 of file regproc.c.

537 {
538  LPTSTR keyNameBeg;
539  TCHAR lpLineCopy[KEY_MAX_LEN];
540 
541  if (lpLine == NULL)
542  return NULL;
543 
544  _tcscpy(lpLineCopy, lpLine);
545  keyNameBeg = _tcschr(lpLineCopy, _T('\\')); /* The key name start by '\' */
546  if (keyNameBeg) {
547  LPTSTR keyNameEnd;
548 
549  keyNameBeg++; /* is not part of the name */
550  keyNameEnd = _tcschr(lpLineCopy, _T(']'));
551  if (keyNameEnd) {
552  *keyNameEnd = _T('\0'); /* remove ']' from the key name */
553  }
554  } else {
555  keyNameBeg = lpLineCopy + _tcslen(lpLineCopy); /* branch - empty string */
556  }
557  currentKeyName = HeapAlloc(GetProcessHeap(), 0, (_tcslen(keyNameBeg)+1)*sizeof(TCHAR));
559  _tcscpy(currentKeyName, keyNameBeg);
560  return currentKeyName;
561 }
static LPTSTR currentKeyName
Definition: regproc.c:69
_TCHAR * _tcscpy(_TCHAR *to, const _TCHAR *from)
Definition: tcscpy.h:8
CHAR * LPTSTR
Definition: xmlstorage.h:192
#define KEY_MAX_LEN
Definition: regproc.h:22
size_t __cdecl _tcslen(const _TCHAR *str)
Definition: tcslen.h:9
smooth NULL
Definition: ftsmooth.c:416
_TCHAR * _tcschr(const _TCHAR *s, _XINT c)
Definition: tcschr.h:4
char TCHAR
Definition: xmlstorage.h:189
#define CHECK_ENOUGH_MEMORY(p)
Definition: regproc.c:105
#define _T(x)
Definition: vfdio.h:22
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)

Referenced by delete_registry_key(), export_registry_key(), and openKey().

◆ import_registry_file()

BOOL import_registry_file ( LPTSTR  filename)

Definition at line 1396 of file regproc.c.

1397 {
1398  FILE* reg_file = _tfopen(filename, _T("r"));
1399 
1400  if (reg_file) {
1401  processRegLines(reg_file, doSetValue);
1402  return TRUE;
1403  }
1404  return FALSE;
1405 }
void processRegLines(FILE *in, CommandAPI command)
Definition: regproc.c:887
#define TRUE
Definition: types.h:120
void doSetValue(LPTSTR stdInput)
Definition: regproc.c:619
const char * filename
Definition: ioapi.h:135
#define _tfopen
Definition: xmlstorage.h:196
#define _T(x)
Definition: vfdio.h:22

◆ openKey()

HRESULT openKey ( LPTSTR  stdInput)

Definition at line 494 of file regproc.c.

495 {
496  DWORD dwDisp;
497  HRESULT hRes;
498 
499  /* Sanity checks */
500  if (stdInput == NULL)
502 
503  /* Get the registry class */
504  currentKeyClass = getRegClass(stdInput); /* Sets global variable */
507 
508  /* Get the key name */
509  currentKeyName = getRegKeyName(stdInput); /* Sets global variable */
510  if (currentKeyName == NULL)
512 
513  hRes = RegCreateKeyEx(
514  currentKeyClass, /* Class */
515  currentKeyName, /* Sub Key */
516  0, /* MUST BE 0 */
517  NULL, /* object type */
518  REG_OPTION_NON_VOLATILE, /* option, REG_OPTION_NON_VOLATILE ... */
519  KEY_ALL_ACCESS, /* access mask, KEY_ALL_ACCESS */
520  NULL, /* security attribute */
521  &currentKeyHandle, /* result */
522  &dwDisp); /* disposition, REG_CREATED_NEW_KEY or
523  REG_OPENED_EXISTING_KEY */
524 
525  if (hRes == ERROR_SUCCESS)
527 
528  return hRes;
529 
530 }
static HKEY currentKeyHandle
Definition: regproc.c:71
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
#define TRUE
Definition: types.h:120
#define ERROR_SUCCESS
Definition: deptool.c:10
static LPTSTR currentKeyName
Definition: regproc.c:69
smooth NULL
Definition: ftsmooth.c:416
#define REG_OPTION_NON_VOLATILE
Definition: nt_native.h:1057
LPTSTR getRegKeyName(LPTSTR lpLine)
Definition: regproc.c:536
LONG HRESULT
Definition: typedefs.h:77
unsigned long DWORD
Definition: ntddk_ex.h:95
static BOOL bTheKeyIsOpen
Definition: regproc.c:72
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
HKEY getRegClass(LPTSTR lpClass)
Definition: regproc.c:567
static HKEY currentKeyClass
Definition: regproc.c:70
#define RegCreateKeyEx
Definition: winreg.h:501

Referenced by doQueryValue(), and doSetValue().

◆ processQueryValue()

void processQueryValue ( LPTSTR  cmdline)

Definition at line 770 of file regproc.c.

771 {
772  _tprintf(_T("ERROR!!! - temporary disabled"));
773  //exit(1);
774  return;
775 #if 0
776  LPSTR argv[QUERY_VALUE_MAX_ARGS];/* args storage */
777  LPSTR token = NULL; /* current token analized */
778  ULONG argCounter = 0; /* counter of args */
779  INT counter;
780  HRESULT hRes = 0;
781  LPSTR keyValue = NULL;
782  LPSTR lpsRes = NULL;
783 
784  /*
785  * Init storage and parse the line
786  */
788  argv[counter] = NULL;
789 
790  while ((token = getToken(&cmdline, queryValueDelim[argCounter])) != NULL) {
791  argv[argCounter++] = getArg(token);
792  if (argCounter == QUERY_VALUE_MAX_ARGS)
793  break; /* Stop processing args no matter what */
794  }
795 
796  /* The value we look for is the first token on the line */
797  if (argv[0] == NULL)
798  return; /* SHOULD NOT HAPPEN */
799  else
800  keyValue = argv[0];
801 
802  if ((keyValue[0] == '@') && (_tcslen(keyValue) == 1)) {
803  LONG lLen = KEY_MAX_LEN;
805  /*
806  * We need to query the key default value
807  */
808  hRes = RegQueryValue(currentKeyHandle, currentKeyName, (LPBYTE)lpsData, &lLen);
809  if (hRes == ERROR_MORE_DATA) {
810  lpsData = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lpsData, lLen);
811  hRes = RegQueryValue(currentKeyHandle, currentKeyName, (LPBYTE)lpsData, &lLen);
812  }
813  if (hRes == ERROR_SUCCESS) {
814  lpsRes = HeapAlloc(GetProcessHeap(), 0, lLen);
815  strncpy(lpsRes, lpsData, lLen);
816  lpsRes[lLen-1]='\0';
817  }
818  } else {
819  DWORD dwLen = KEY_MAX_LEN;
821  DWORD dwType;
822  /*
823  * We need to query a specific value for the key
824  */
825  hRes = RegQueryValueEx(
827  keyValue,
828  0,
829  &dwType,
830  (LPBYTE)lpbData,
831  &dwLen);
832 
833  if (hRes == ERROR_MORE_DATA) {
834  lpbData = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lpbData, dwLen * sizeof(TCHAR));
835  hRes = RegQueryValueEx(currentKeyHandle, keyValue, NULL, &dwType, (LPBYTE)lpbData, &dwLen);
836  }
837 
838  if (hRes == ERROR_SUCCESS) {
839  /*
840  * Convert the returned data to a displayable format
841  */
842  switch (dwType) {
843  case REG_SZ:
844  case REG_EXPAND_SZ:
845  lpsRes = HeapAlloc(GetProcessHeap(), 0, dwLen * sizeof(TCHAR));
846  strncpy(lpsRes, lpbData, dwLen);
847  lpsRes[dwLen-1] = '\0';
848  break;
849  case REG_DWORD:
850  lpsRes = convertHexToDWORDStr(lpbData, dwLen);
851  break;
852  default:
853  lpsRes = convertHexToHexCSV(lpbData, dwLen);
854  break;
855  }
856  }
857 
858  HeapFree(GetProcessHeap(), 0, lpbData);
859  }
860  if (hRes == ERROR_SUCCESS) {
861  _tprintf(_T("Value \"%s\" = \"%s\" in key [%s]\n"), keyValue, lpsRes, currentKeyName);
862 
863  } else {
864  _tprintf(_T("ERROR Value \"%s\" not found. for key \"%s\"\n"), keyValue, currentKeyName);
865  }
866 
867  /*
868  * Do some cleanup
869  */
870  for (counter=0; counter<argCounter; counter++)
871  if (argv[counter] != NULL)
873 
874  if (lpsRes != NULL)
875  HeapFree(GetProcessHeap(), 0, lpsRes);
876 #endif
877 }
#define RegQueryValueEx
Definition: winreg.h:524
static HKEY currentKeyHandle
Definition: regproc.c:71
#define _tprintf
Definition: tchar.h:506
#define ERROR_SUCCESS
Definition: deptool.c:10
char * strncpy(char *DstString, const char *SrcString, ACPI_SIZE Count)
Definition: utclib.c:427
static LPTSTR currentKeyName
Definition: regproc.c:69
TCHAR * cmdline
Definition: stretchblt.cpp:32
#define argv
Definition: mplay32.c:18
char * LPSTR
Definition: xmlstorage.h:182
int32_t INT
Definition: typedefs.h:56
char * getToken(char **str, const char *delims)
#define KEY_MAX_LEN
Definition: regproc.h:22
unsigned char * LPBYTE
Definition: typedefs.h:52
long LONG
Definition: pedump.c:60
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat token
Definition: glfuncs.h:210
size_t __cdecl _tcslen(const _TCHAR *str)
Definition: tcslen.h:9
smooth NULL
Definition: ftsmooth.c:416
GLuint counter
Definition: glext.h:11116
#define QUERY_VALUE_MAX_ARGS
Definition: regproc.c:62
char TCHAR
Definition: xmlstorage.h:189
#define _T(x)
Definition: vfdio.h:22
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
TCHAR * convertHexToHexCSV(BYTE *buf, ULONG bufLen)
Definition: regproc.c:246
LONG HRESULT
Definition: typedefs.h:77
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned char BYTE
Definition: mem.h:68
#define ERROR_MORE_DATA
Definition: dderror.h:13
LPTSTR getArg(LPTSTR arg)
Definition: regproc.c:377
#define REG_EXPAND_SZ
Definition: nt_native.h:1494
#define HeapReAlloc
Definition: compat.h:393
TCHAR * convertHexToDWORDStr(BYTE *buf, ULONG bufLen)
Definition: regproc.c:272
#define HEAP_ZERO_MEMORY
Definition: compat.h:123
#define RegQueryValue
Definition: winreg.h:523
unsigned int ULONG
Definition: retypes.h:1
#define REG_DWORD
Definition: sdbapi.c:596
#define HeapFree(x, y, z)
Definition: compat.h:394
#define REG_SZ
Definition: layer.c:22

Referenced by doQueryValue().

◆ processRegLines()

void processRegLines ( FILE in,
CommandAPI  command 
)

Definition at line 887 of file regproc.c.

888 {
889  LPTSTR line = NULL; /* line read from input stream */
890  ULONG lineSize = REG_VAL_BUF_SIZE;
891 
892  line = HeapAlloc(GetProcessHeap(), 0, lineSize * sizeof(TCHAR));
894 
895  while (!feof(in)) {
896  LPTSTR s; /* The pointer into line for where the current fgets should read */
897  s = line;
898  for (;;) {
899  size_t size_remaining;
900  int size_to_get;
901  TCHAR *s_eol; /* various local uses */
902 
903  /* Do we need to expand the buffer ? */
904  assert (s >= line && s <= line + lineSize);
905  size_remaining = lineSize - (s-line);
906  if (size_remaining < 2) { /* room for 1 character and the \0 */
907  TCHAR *new_buffer;
908  size_t new_size = lineSize + REG_VAL_BUF_SIZE;
909  if (new_size > lineSize) /* no arithmetic overflow */
910  new_buffer = HeapReAlloc (GetProcessHeap(), 0, line, new_size * sizeof(TCHAR));
911  else
912  new_buffer = NULL;
913  CHECK_ENOUGH_MEMORY(new_buffer);
914  line = new_buffer;
915  s = line + lineSize - size_remaining;
916  lineSize = new_size;
917  size_remaining = lineSize - (s-line);
918  }
919 
920  /* Get as much as possible into the buffer, terminated either by
921  * eof, error, eol or getting the maximum amount. Abort on error.
922  */
923 //
924 // This line is surely foobar, don't want to read INT_MAX in buffer at s, it's never going to be that big...
925 // size_to_get = (size_remaining > INT_MAX ? INT_MAX : size_remaining);
926 //
927 // Looks as if 'lineSize' contains the number of characters of buffer size
928 //
929  size_to_get = (size_remaining > lineSize ? lineSize : size_remaining);
930 
931  if (NULL == _fgetts(s, size_to_get, in)) {
932  if (ferror(in)) {
933  //_tperror(_T("While reading input"));
934  perror ("While reading input");
935  //exit(IO_ERROR);
936  return;
937  } else {
938  assert (feof(in));
939  *s = _T('\0');
940  /* It is not clear to me from the definition that the
941  * contents of the buffer are well defined on detecting
942  * an eof without managing to read anything.
943  */
944  }
945  }
946 
947  /* If we didn't read the eol nor the eof go around for the rest */
948  s_eol = _tcschr (s, _T('\n'));
949  if (!feof (in) && !s_eol) {
950  s = _tcschr (s, _T('\0'));
951  /* It should be s + size_to_get - 1 but this is safer */
952  continue;
953  }
954 
955  /* If it is a comment line then discard it and go around again */
956  if (line [0] == _T('#')) {
957  s = line;
958  continue;
959  }
960 
961  /* Remove any line feed. Leave s_eol on the \0 */
962  if (s_eol) {
963  *s_eol = _T('\0');
964  if (s_eol > line && *(s_eol-1) == _T('\r'))
965  *--s_eol = _T('\0');
966  } else {
967  s_eol = _tcschr (s, _T('\0'));
968  }
969  /* If there is a concatenating \\ then go around again */
970  if (s_eol > line && *(s_eol-1) == _T('\\')) {
971  int c;
972  s = s_eol-1;
973  /* The following error protection could be made more self-
974  * correcting but I thought it not worth trying.
975  */
976 
977  if ((c = _fgettc(in)) == _TEOF || c != _T(' ') ||
978  (c = _fgettc(in)) == _TEOF || c != _T(' '))
979  _tprintf(_T("ERROR - invalid continuation.\n"));
980  continue;
981  }
982  break; /* That is the full virtual line */
983  }
984  command(line);
985  }
986  command(NULL);
988 }
#define _tprintf
Definition: tchar.h:506
_Check_return_ _CRTIMP int __cdecl ferror(_In_ FILE *_File)
#define _fgettc
Definition: tchar.h:562
#define _fgetts
Definition: tchar.h:565
#define assert(x)
Definition: debug.h:53
CHAR * LPTSTR
Definition: xmlstorage.h:192
_CRTIMP void __cdecl perror(_In_opt_z_ const char *_ErrMsg)
#define REG_VAL_BUF_SIZE
Definition: regproc.c:59
smooth NULL
Definition: ftsmooth.c:416
Definition: parser.c:48
_TCHAR * _tcschr(const _TCHAR *s, _XINT c)
Definition: tcschr.h:4
char TCHAR
Definition: xmlstorage.h:189
#define CHECK_ENOUGH_MEMORY(p)
Definition: regproc.c:105
_Check_return_ _CRTIMP int __cdecl feof(_In_ FILE *_File)
#define _T(x)
Definition: vfdio.h:22
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
const GLubyte * c
Definition: glext.h:8905
char line[200]
Definition: main.c:97
GLdouble s
Definition: gl.h:2039
GLuint in
Definition: glext.h:9616
#define HeapReAlloc
Definition: compat.h:393
#define _TEOF
Definition: regproc.c:117
int command(const char *fmt,...)
Definition: ftp.c:266
#define c
Definition: ke_i.h:80
unsigned int ULONG
Definition: retypes.h:1
#define HeapFree(x, y, z)
Definition: compat.h:394

Referenced by import_registry_file().

◆ processSetValue()

void processSetValue ( LPTSTR  line)

Definition at line 716 of file regproc.c.

717 {
718  LPTSTR val_name; /* registry value name */
719  LPTSTR val_data; /* registry value data */
720 
721  int line_idx = 0; /* current character under analysis */
722  HRESULT hRes = 0;
723 
724  /* get value name */
725  if (line[line_idx] == _T('@') && line[line_idx + 1] == _T('=')) {
726  line[line_idx] = _T('\0');
727  val_name = line;
728  line_idx++;
729  } else if (line[line_idx] == _T('\"')) {
730  line_idx++;
731  val_name = line + line_idx;
732  while (TRUE) {
733  if (line[line_idx] == _T('\\')) { /* skip escaped character */
734  line_idx += 2;
735  } else {
736  if (line[line_idx] == _T('\"')) {
737  line[line_idx] = _T('\0');
738  line_idx++;
739  break;
740  } else {
741  line_idx++;
742  }
743  }
744  }
745  if (line[line_idx] != _T('=')) {
746  line[line_idx] = _T('\"');
747  _tprintf(_T("Warning! uncrecognized line:\n%s\n"), line);
748  return;
749  }
750  } else {
751  _tprintf(_T("Warning! unrecognized line:\n%s\n"), line);
752  return;
753  }
754  line_idx++; /* skip the '=' character */
755  val_data = line + line_idx;
756  REGPROC_unescape_string(val_name);
757 
758  _tprintf(_T("Key: %s, Value: %s, Data: %s\n"), currentKeyName, val_name, val_data);
759 
760  hRes = setValue(val_name, val_data);
761  if (hRes != ERROR_SUCCESS) {
762  _tprintf(_T("ERROR Key %s not created. Value: %s, Data: %s\n"), currentKeyName, val_name, val_data);
763  }
764 }
#define _tprintf
Definition: tchar.h:506
#define TRUE
Definition: types.h:120
#define ERROR_SUCCESS
Definition: deptool.c:10
static LPTSTR currentKeyName
Definition: regproc.c:69
CHAR * LPTSTR
Definition: xmlstorage.h:192
Definition: parser.c:48
#define _T(x)
Definition: vfdio.h:22
LONG HRESULT
Definition: typedefs.h:77
char line[200]
Definition: main.c:97
HRESULT setValue(LPTSTR val_name, LPTSTR val_data)
Definition: regproc.c:432
void REGPROC_unescape_string(LPTSTR str)
Definition: regproc.c:396

Referenced by doSetValue().

◆ REGPROC_export_string()

void REGPROC_export_string ( FILE file,
TCHAR str 
)

Definition at line 1098 of file regproc.c.

1099 {
1100  size_t len = _tcslen(str);
1101  size_t i;
1102 
1103  /* escaping characters */
1104  for (i = 0; i < len; i++) {
1105  TCHAR c = str[i];
1106  switch (c) {
1107  //case _T('\\'): _fputts(_T("\\\\"), file); break;
1108  case _T('\"'): _fputts(_T("\\\""), file); break;
1109  case _T('\n'): _fputts(_T("\\\n"), file); break;
1110  default: _fputtc(c, file); break;
1111  }
1112  }
1113 }
#define _fputts
Definition: tchar.h:569
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
const WCHAR * str
size_t __cdecl _tcslen(const _TCHAR *str)
Definition: tcslen.h:9
char TCHAR
Definition: xmlstorage.h:189
#define _T(x)
Definition: vfdio.h:22
#define _fputtc
Definition: tchar.h:566
const GLubyte * c
Definition: glext.h:8905
GLenum GLsizei len
Definition: glext.h:6722
Definition: fci.c:126

Referenced by export_hkey().

◆ REGPROC_open_export_file()

FILE* REGPROC_open_export_file ( TCHAR file_name)

Definition at line 1284 of file regproc.c.

1285 {
1286 //_CRTIMP FILE * __cdecl _wfopen(const wchar_t *, const wchar_t *);
1287 
1288 //FILE* fopen (const char* szFileName, const char* szMode);
1289 //FILE* _wfopen(const wchar_t *file, const wchar_t *mode);
1290 
1291  FILE *file = _tfopen(file_name, _T("w"));
1292  if (!file) {
1293  perror("");
1294  _tprintf(_T("REGPROC_open_export_file(%s) - Can't open file.\n"), file_name);
1295  //exit(1);
1296  return NULL;
1297  }
1298  _fputts(_T("REGEDIT4\n"), file);
1299  return file;
1300 }
#define _tprintf
Definition: tchar.h:506
#define _fputts
Definition: tchar.h:569
_CRTIMP void __cdecl perror(_In_opt_z_ const char *_ErrMsg)
smooth NULL
Definition: ftsmooth.c:416
#define _tfopen
Definition: xmlstorage.h:196
#define _T(x)
Definition: vfdio.h:22
const char file[]
Definition: icontest.c:11
static LPCWSTR file_name
Definition: protocol.c:146
Definition: fci.c:126

Referenced by export_registry_key().

◆ REGPROC_print_error()

void REGPROC_print_error ( VOID  )

Definition at line 1056 of file regproc.c.

1057 {
1058  LPVOID lpMsgBuf;
1059  DWORD error_code;
1060  int status;
1061 
1062  error_code = GetLastError ();
1064  NULL, error_code, 0, (LPTSTR) &lpMsgBuf, 0, NULL);
1065  if (!status) {
1066  _tprintf(_T("Cannot display message for error %ld, status %ld\n"), error_code, GetLastError());
1067  } else {
1068  _tprintf(_T("REGPROC_print_error() - "));
1069  puts(lpMsgBuf);
1070  LocalFree((HLOCAL)lpMsgBuf);
1071  }
1072  //exit(1);
1073 }
#define _tprintf
Definition: tchar.h:506
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
CHAR * LPTSTR
Definition: xmlstorage.h:192
#define FORMAT_MESSAGE_ALLOCATE_BUFFER
Definition: winbase.h:400
static int error_code[8]
Definition: odbccp32.c:62
smooth NULL
Definition: ftsmooth.c:416
#define FORMAT_MESSAGE_FROM_SYSTEM
Definition: winbase.h:404
#define _T(x)
Definition: vfdio.h:22
unsigned long DWORD
Definition: ntddk_ex.h:95
#define FormatMessage
Definition: winbase.h:3612
int puts(const char *string)
Definition: crtsupp.c:23
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1577
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

Referenced by delete_branch(), export_hkey(), and export_registry_key().

◆ REGPROC_resize_char_buffer()

void REGPROC_resize_char_buffer ( TCHAR **  buffer,
DWORD len,
DWORD  required_len 
)

Definition at line 1085 of file regproc.c.

1086 {
1087  required_len++;
1088  if (required_len > *len) {
1089  *len = required_len;
1090  *buffer = HeapReAlloc(GetProcessHeap(), 0, *buffer, *len * sizeof(**buffer));
1092  }
1093 }
GLuint buffer
Definition: glext.h:5915
#define CHECK_ENOUGH_MEMORY(p)
Definition: regproc.c:105
#define GetProcessHeap()
Definition: compat.h:395
GLenum GLsizei len
Definition: glext.h:6722
#define HeapReAlloc
Definition: compat.h:393

Referenced by delete_branch(), export_hkey(), and export_registry_key().

◆ REGPROC_unescape_string()

void REGPROC_unescape_string ( LPTSTR  str)

Definition at line 396 of file regproc.c.

397 {
398  int str_idx = 0; /* current character under analysis */
399  int val_idx = 0; /* the last character of the unescaped string */
400  int len = _tcslen(str);
401  for (str_idx = 0; str_idx < len; str_idx++, val_idx++) {
402  if (str[str_idx] == _T('\\')) {
403  str_idx++;
404  switch (str[str_idx]) {
405  case _T('n'):
406  str[val_idx] = _T('\n');
407  break;
408  case _T('\\'):
409  case _T('"'):
410  str[val_idx] = str[str_idx];
411  break;
412  default:
413  _tprintf(_T("Warning! Unrecognized escape sequence: \\%c'\n"), str[str_idx]);
414  str[val_idx] = str[str_idx];
415  break;
416  }
417  } else {
418  str[val_idx] = str[str_idx];
419  }
420  }
421  str[val_idx] = _T('\0');
422 }
#define _tprintf
Definition: tchar.h:506
const WCHAR * str
size_t __cdecl _tcslen(const _TCHAR *str)
Definition: tcslen.h:9
#define _T(x)
Definition: vfdio.h:22
GLenum GLsizei len
Definition: glext.h:6722

Referenced by processSetValue(), and setValue().

◆ setValue()

HRESULT setValue ( LPTSTR  val_name,
LPTSTR  val_data 
)

Definition at line 432 of file regproc.c.

433 {
434  HRESULT hRes;
435  DWORD dwDataType, dwParseType;
436  LPBYTE lpbData;
438  BYTE *bBigBuffer = 0;
439  DWORD dwLen;
440 
441  if ((val_name == NULL) || (val_data == NULL))
443 
444  /* Get the data type stored into the value field */
445  dwDataType = getDataType(&val_data, &dwParseType);
446 
447 // if (dwParseType == REG_EXPAND_SZ) {
448 // }
449 // if (dwParseType == REG_SZ || dwParseType == REG_EXPAND_SZ) { /* no conversion for string */
450 
451  if (dwParseType == REG_SZ) { /* no conversion for string */
452  dwLen = _tcslen(val_data);
453  if (dwLen > 0 && val_data[dwLen-1] == _T('"')) {
454  dwLen--;
455  val_data[dwLen] = _T('\0');
456  }
457  dwLen++;
458  dwLen *= sizeof(TCHAR);
459  REGPROC_unescape_string(val_data);
460  lpbData = val_data;
461  } else if (dwParseType == REG_DWORD) { /* Convert the dword types */
462  dwLen = convertHexToDWord(val_data, convert);
463  lpbData = convert;
464  } else { /* Convert the hexadecimal types */
465  int b_len = _tcslen(val_data)+2/3;
466  if (b_len > KEY_MAX_LEN) {
467  bBigBuffer = HeapAlloc (GetProcessHeap(), 0, b_len * sizeof(TCHAR));
468  if (bBigBuffer == NULL) {
470  }
471  CHECK_ENOUGH_MEMORY(bBigBuffer);
472  dwLen = convertHexCSVToHex(val_data, bBigBuffer, b_len);
473  lpbData = bBigBuffer;
474  } else {
475  dwLen = convertHexCSVToHex(val_data, convert, KEY_MAX_LEN);
476  lpbData = convert;
477  }
478  }
479  hRes = RegSetValueEx(currentKeyHandle, val_name,
480  0, /* Reserved */dwDataType, lpbData, dwLen);
481 
482  _tprintf(_T(" Value: %s, Data: %s\n"), val_name, lpbData);
483 
484 
485  if (bBigBuffer)
486  HeapFree(GetProcessHeap(), 0, bBigBuffer);
487  return hRes;
488 }
static HKEY currentKeyHandle
Definition: regproc.c:71
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
#define _tprintf
Definition: tchar.h:506
DWORD getDataType(LPTSTR *lpValue, DWORD *parse_type)
Definition: regproc.c:331
DWORD convertHexCSVToHex(TCHAR *str, BYTE *buf, ULONG bufLen)
Definition: regproc.c:289
#define KEY_MAX_LEN
Definition: regproc.h:22
unsigned char * LPBYTE
Definition: typedefs.h:52
size_t __cdecl _tcslen(const _TCHAR *str)
Definition: tcslen.h:9
smooth NULL
Definition: ftsmooth.c:416
char TCHAR
Definition: xmlstorage.h:189
#define CHECK_ENOUGH_MEMORY(p)
Definition: regproc.c:105
#define _T(x)
Definition: vfdio.h:22
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
int convert
Definition: msacm.c:1362
LONG HRESULT
Definition: typedefs.h:77
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned char BYTE
Definition: mem.h:68
#define ERROR_REGISTRY_IO_FAILED
Definition: winerror.h:595
#define REG_DWORD
Definition: sdbapi.c:596
#define HeapFree(x, y, z)
Definition: compat.h:394
#define RegSetValueEx
Definition: winreg.h:533
DWORD convertHexToDWord(TCHAR *str, BYTE *buf)
Definition: regproc.c:231
#define REG_SZ
Definition: layer.c:22
void REGPROC_unescape_string(LPTSTR str)
Definition: regproc.c:396

Referenced by processSetValue().

Variable Documentation

◆ bTheKeyIsOpen

BOOL bTheKeyIsOpen = FALSE
static

Definition at line 72 of file regproc.c.

Referenced by closeKey(), doQueryValue(), doSetValue(), and openKey().

◆ currentKeyClass

HKEY currentKeyClass = 0
static

Definition at line 70 of file regproc.c.

Referenced by closeKey(), and openKey().

◆ currentKeyHandle

HKEY currentKeyHandle = 0
static

Definition at line 71 of file regproc.c.

Referenced by closeKey(), openKey(), processQueryValue(), and setValue().

◆ currentKeyName

LPTSTR currentKeyName = NULL
static

Definition at line 69 of file regproc.c.

Referenced by closeKey(), getRegKeyName(), openKey(), processQueryValue(), and processSetValue().

◆ reg_class_keys

HKEY reg_class_keys[REG_CLASS_NUMBER]
static
Initial value:
= {
}
#define HKEY_USERS
Definition: winreg.h:13
#define HKEY_CURRENT_USER
Definition: winreg.h:11
#define HKEY_CURRENT_CONFIG
Definition: winreg.h:15
#define HKEY_CLASSES_ROOT
Definition: winreg.h:10
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12

Definition at line 84 of file regproc.c.

Referenced by export_registry_key(), and getRegClass().

◆ reg_class_names

TCHAR* reg_class_names[]
static
Initial value:
= {
_T("HKEY_LOCAL_MACHINE"),
_T("HKEY_USERS"),
_T("HKEY_CLASSES_ROOT"),
_T("HKEY_CURRENT_CONFIG"),
}
#define _T(x)
Definition: vfdio.h:22

Definition at line 74 of file regproc.c.

Referenced by export_registry_key(), and getRegClass().