regproc.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	KEY_MAX_LEN   1024
#define	SUCCESS   0
#define	KEY_VALUE_ALREADY_SET   2
#define	get_file_name   get_file_nameA

Typedefs
typedef void(*	CommandAPI) (LPTSTR lpsLine)

Functions
void	doSetValue (LPTSTR lpsLine)
void	doDeleteValue (LPTSTR lpsLine)
void	doCreateKey (LPTSTR lpsLine)
void	doDeleteKey (LPTSTR lpsLine)
void	doQueryValue (LPTSTR lpsLine)
void	doRegisterDLL (LPTSTR lpsLine)
void	doUnregisterDLL (LPTSTR lpsLine)
BOOL	export_registry_key (TCHAR *file_name, TCHAR *reg_key_name)
BOOL	import_registry_file (LPTSTR filename)
void	delete_registry_key (TCHAR *reg_key_name)
void	processRegLines (FILE *in, CommandAPI command)
char *	getToken (char **str, const char *delims)
void	get_file_nameA (CHAR **command_line, CHAR *filename, int max_filename)
void	get_file_nameW (CHAR **command_line, WCHAR *filename, int max_filename)
DWORD	convertHexToDWord (TCHAR *str, BYTE *buf)
DWORD	convertHexCSVToHex (TCHAR *str, BYTE *buf, ULONG bufLen)
LPTSTR	convertHexToHexCSV (BYTE *buf, ULONG len)
LPTSTR	convertHexToDWORDStr (BYTE *buf, ULONG len)
LPTSTR	getRegKeyName (LPTSTR lpLine)
HKEY	getRegClass (LPTSTR lpLine)
DWORD	getDataType (LPTSTR *lpValue, DWORD *parse_type)
LPTSTR	getArg (LPTSTR arg)
HRESULT	openKey (LPTSTR stdInput)
void	closeKey (VOID)
void	processSetValue (LPTSTR cmdline)
HRESULT	setValue (LPTSTR val_name, LPTSTR val_data)
void	processQueryValue (LPTSTR cmdline)
LPVOID	RegHeapAlloc (HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes)
LPVOID	RegHeapReAlloc (HANDLE hHeap, DWORD dwFlags, LPVOID lpMem, SIZE_T dwBytes)
BOOL	RegHeapFree (HANDLE hHeap, DWORD dwFlags, LPVOID lpMem)

Macro Definition Documentation

get_file_name

#define get_file_name   get_file_nameA

Definition at line 51 of file regproc.h.

KEY_MAX_LEN

#define KEY_MAX_LEN   1024

Definition at line 23 of file regproc.h.

KEY_VALUE_ALREADY_SET

#define KEY_VALUE_ALREADY_SET   2

Definition at line 27 of file regproc.h.

SUCCESS

#define SUCCESS   0

Definition at line 26 of file regproc.h.

Typedef Documentation

CommandAPI

typedef void(* CommandAPI) (LPTSTR lpsLine)

Definition at line 29 of file regproc.h.

Function Documentation

closeKey()

void closeKey

(

VOID

)

Definition at line 604 of file regproc.c.

{
    RegCloseKey(currentKeyHandle);
    HeapFree(GetProcessHeap(), 0, currentKeyName); /* Allocated by getKeyName */
    bTheKeyIsOpen    = FALSE;
    currentKeyName   = NULL;
    currentKeyClass  = 0;
    currentKeyHandle = 0;
}

Referenced by doQueryValue(), and doSetValue().

convertHexCSVToHex()

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

Definition at line 289 of file regproc.c.

{
    TCHAR* s = str;  /* Pointer to current */
    CHAR* b = buf;  /* Pointer to result  */
    ULONG strLen    = _tcslen(str);
    ULONG strPos    = 0;
    DWORD byteCount = 0;

    memset(buf, 0, bufLen);
    /*
     * warn the user if we are here with a string longer than 2 bytes that does
     * not contains ",".  It is more likely because the data is invalid.
     */
    if ((strLen > 2) && (_tcschr(str, _T(',')) == NULL)) {
        _tprintf(_T("WARNING converting CSV hex stream with no comma, ") \
                 _T("input data seems invalid.\n"));
    }
    if (strLen > 3*bufLen) {
        _tprintf(_T("ERROR converting CSV hex stream.  Too long\n"));
    }
    while (strPos < strLen) {
        TCHAR xbuf[3];
        TCHAR wc;
        memcpy(xbuf, s, 2);
        xbuf[2] = _T('\0');
        _stscanf(xbuf, _T("%02x"), (UINT*)&wc);
        if (byteCount < bufLen)
            *b++ = (unsigned char)wc;
        s += 3;
        strPos += 3;
        ++byteCount;
    }
    return byteCount;
}

Referenced by setValue().

convertHexToDWord()

DWORD convertHexToDWord	(	TCHAR *	str,
		BYTE *	buf
	)

Definition at line 231 of file regproc.c.

{
    DWORD dw;
    TCHAR xbuf[9];

    memcpy(xbuf, str, 8 * sizeof(TCHAR));
    xbuf[88 * sizeof(TCHAR)] = '\0';
    _stscanf(xbuf, _T("%08lx"), &dw);
    memcpy(buf, &dw, sizeof(DWORD));
    return sizeof(DWORD);
}

Referenced by setValue().

convertHexToDWORDStr()

LPTSTR convertHexToDWORDStr	(	BYTE *	buf,
		ULONG	len
	)

Definition at line 272 of file regproc.c.

{
    TCHAR* str;
    DWORD dw;

    if (bufLen != sizeof(DWORD)) return NULL;
    str = HeapAlloc(GetProcessHeap(), 0, ((bufLen*2)+1)*sizeof(TCHAR));
    memcpy(&dw, buf, sizeof(DWORD));
    _stprintf(str, _T("%08lx"), dw);
    /* Get rid of the last comma */
    return str;
}

Referenced by processQueryValue().

convertHexToHexCSV()

LPTSTR convertHexToHexCSV	(	BYTE *	buf,
		ULONG	len
	)

Definition at line 246 of file regproc.c.

{
    TCHAR* str;
    TCHAR* ptrStr;
    BYTE* ptrBuf;

    ULONG current = 0;
    str = HeapAlloc(GetProcessHeap(), 0, (bufLen+1)*2*sizeof(TCHAR));
    memset(str, 0, (bufLen+1)*2);
    ptrStr = str;  /* Pointer to result  */
    ptrBuf = buf;  /* Pointer to current */
    while (current < bufLen) {
        BYTE bCur = ptrBuf[current++];
        TCHAR res[3];
        _stprintf(res, _T("%02x"), (unsigned int)*&bCur);
        _tcscat(str, res);
        _tcscat(str, _T(","));
    }
    /* Get rid of the last comma */
    str[_tcslen(str)-1] = _T('\0');
    return str;
}

Referenced by processQueryValue().

delete_registry_key()

void delete_registry_key

(

TCHAR *

reg_key_name

)

Definition at line 1459 of file regproc.c.

{
    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);
}

doCreateKey()

void doCreateKey

(

LPTSTR

lpsLine

)

Definition at line 704 of file regproc.c.

                                {
  _tprintf(_T("createKey not yet implemented\n"));
}

doDeleteKey()

void doDeleteKey

(

LPTSTR

lpsLine

)

Definition at line 695 of file regproc.c.

                                {
  _tprintf(_T("deleteKey not yet implemented\n"));
}

doDeleteValue()

void doDeleteValue

(

LPTSTR

lpsLine

)

Definition at line 686 of file regproc.c.

                                {
  _tprintf(_T("deleteValue not yet implemented\n"));
}

doQueryValue()

void doQueryValue

(

LPTSTR

lpsLine

)

Definition at line 653 of file regproc.c.

                                   {
  /*
   * We encoutered the end of the file, make sure we
   * close the opened key and exit
   */
  if (stdInput == NULL) {
    if (bTheKeyIsOpen != FALSE)
      closeKey();
    return;
  }

  if (stdInput[0] == _T('[')) {     /* We are reading a new key */
    if (bTheKeyIsOpen != FALSE)
      closeKey();                    /* Close the previous key before */
    if (openKey(stdInput) != ERROR_SUCCESS ) {
      _tprintf(_T("doQueryValue failed to open key %s\n"), stdInput);
    }
  }
  else if( (bTheKeyIsOpen) &&
           ((stdInput[0] == _T('@')) || /* reading a default @=data pair */
           (stdInput[0] == _T('\"')))) { /* reading a new value=data pair */
    processQueryValue(stdInput);
  } else {                /* since we are assuming that the file format is */
    if (bTheKeyIsOpen)    /* valid we must be reading a blank line which  */
      closeKey();         /* indicate end of this key processing */
  }
}

doRegisterDLL()

void doRegisterDLL

(

LPTSTR

lpsLine

)

Definition at line 994 of file regproc.c.

{
    HMODULE theLib = 0;
    UINT retVal = 0;

    /* Check for valid input */
    if (stdInput == NULL) return;

    /* Load and register the library, then free it */
    theLib = LoadLibrary(stdInput);
    if (theLib) {
        FARPROC lpfnDLLRegProc = GetProcAddress(theLib, "DllRegisterServer");
        if (lpfnDLLRegProc) {
            retVal = (*lpfnDLLRegProc)();
        } else {
            _tprintf(_T("Couldn't find DllRegisterServer proc in '%s'.\n"), stdInput);
        }
        if (retVal != S_OK) {
            _tprintf(_T("Couldn't find DllRegisterServer proc in '%s'.\n"), stdInput);
        }
        FreeLibrary(theLib);
    } else {
        _tprintf(_T("Could not load DLL '%s'.\n"), stdInput);
    }
}

doSetValue()

void doSetValue

(

LPTSTR

lpsLine

)

Definition at line 619 of file regproc.c.

{
  /*
   * We encountered the end of the file, make sure we
   * close the opened key and exit
   */
  if (stdInput == NULL) {
    if (bTheKeyIsOpen != FALSE)
      closeKey();
    return;
  }

  if (stdInput[0] == _T('[')) {     /* We are reading a new key */
      if (bTheKeyIsOpen != FALSE) {
          closeKey();                    /* Close the previous key before */
      }
      if (openKey(stdInput) != ERROR_SUCCESS) {
          _tprintf(_T("doSetValue failed to open key %s\n"), stdInput);
      }
  } else if ((bTheKeyIsOpen) &&
            ((stdInput[0] == _T('@')) || /* reading a default @=data pair */
             (stdInput[0] == _T('\"')))) { /* reading a new value=data pair */
    processSetValue(stdInput);
  } else {             /* since we are assuming that the file format is */
    if (bTheKeyIsOpen) /* valid we must be reading a blank line which  */
      closeKey();      /* indicate end of this key processing */
  }
}

Referenced by import_registry_file().

doUnregisterDLL()

void doUnregisterDLL

(

LPTSTR

lpsLine

)

Definition at line 1024 of file regproc.c.

{
    HMODULE theLib = 0;
    UINT retVal = 0;

    /* Check for valid input */
    if (stdInput == NULL) return;

    /* Load and unregister the library, then free it */
    theLib = LoadLibrary(stdInput);
    if (theLib) {
        FARPROC lpfnDLLRegProc = GetProcAddress(theLib, "DllUnregisterServer");
        if (lpfnDLLRegProc) {
            retVal = (*lpfnDLLRegProc)();
        } else {
            _tprintf(_T("Couldn't find DllUnregisterServer proc in '%s'.\n"), stdInput);
        }
        if (retVal != S_OK) {
            _tprintf(_T("DLLUnregisterServer error 0x%x in '%s'.\n"), retVal, stdInput);
        }
        FreeLibrary(theLib);
    } else {
        _tprintf(_T("Could not load DLL '%s'.\n"), stdInput);
    }
}

export_registry_key()

BOOL export_registry_key	(	TCHAR *	file_name,
		TCHAR *	reg_key_name
	)

Definition at line 1310 of file regproc.c.

{
    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(&reg_key_name_buf, &reg_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,
                        &reg_key_name_buf, &reg_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,
                        &reg_key_name_buf, &reg_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],
                            &reg_key_name_buf, &reg_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;
}

get_file_nameA()

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

Definition at line 160 of file regproc.c.

{
    CHAR *s = *command_line;
    int pos = 0;                /* position of pointer "s" in *command_line */
    file_name[0] = 0;

    if (!s[0]) {
        return;
    }
    if (s[0] == '"') {
        s++;
        (*command_line)++;
        while (s[0] != '"') {
            if (!s[0]) {
                _tprintf(_T("Unexpected end of file name!\n"));
                assert(0);
                //exit(1);
            }
            s++;
            pos++;
        }
    } else {
        while (s[0] && !isspace(s[0])) {
            s++;
            pos++;
        }
    }
    memcpy(file_name, *command_line, pos * sizeof((*command_line)[0]));
    /* remove the last backslash */
    if (file_name[pos - 1] == '\\') {
        file_name[pos - 1] = '\0';
    } else {
        file_name[pos] = '\0';
    }
    if (s[0]) {
        s++;
        pos++;
    }
    while (s[0] && isspace(s[0])) {
        s++;
        pos++;
    }
    (*command_line) += pos;
}

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.

{
    CHAR filenameA[_MAX_PATH];
    int len;

    get_file_nameA(command_line, filenameA, _MAX_PATH);
    len = strlen(filenameA);
    OemToCharBuffW(filenameA, filename, max_filename);
    filename[len] = _T('\0');
/*
    UNICODE_STRING UnicodeString;
    ANSI_STRING AnsiString;
    CHAR filenameA[_MAX_PATH];

    get_file_nameA(command_line, filenameA, _MAX_PATH);

    //RtlInitAnsiString(&AnsiString, filenameA);
    UnicodeString.Buffer = filename;
    UnicodeString.MaximumLength = max_filename;//MAX_PATH;
    RtlAnsiStringToUnicodeString(&UnicodeString, &AnsiString, FALSE);
 */
}

getArg()

LPTSTR getArg

(

LPTSTR

arg

)

Definition at line 377 of file regproc.c.

{
  LPTSTR tmp = NULL;
  ULONG len;

  if (arg == NULL) return NULL;

  // Get rid of surrounding quotes
  len = _tcslen(arg);
  if (arg[len-1] == _T('\"')) arg[len-1] = _T('\0');
  if (arg[0]     == _T('\"')) arg++;
  tmp = HeapAlloc(GetProcessHeap(), 0, (_tcslen(arg)+1) * sizeof(TCHAR));
  _tcscpy(tmp, arg);
  return tmp;
}

Referenced by processQueryValue().

getDataType()

DWORD getDataType	(	LPTSTR *	lpValue,
		DWORD *	parse_type
	)

Definition at line 331 of file regproc.c.

{
    struct data_type { const TCHAR *tag; int len; int type; int parse_type; };

    static const struct data_type data_types[] =
    {                   /* actual type */  /* type to assume for parsing */
        { _T("\""),        1,   REG_SZ,              REG_SZ },
        { _T("str:\""),    5,   REG_SZ,              REG_SZ },
//        { _T("str(2):\""), 8,   REG_EXPAND_SZ,       REG_SZ },
        { _T("expand:\""), 8,   REG_EXPAND_SZ,       REG_EXPAND_SZ },
        { _T("hex:"),      4,   REG_BINARY,          REG_BINARY },
        { _T("dword:"),    6,   REG_DWORD,           REG_DWORD },
        { _T("hex("),      4,   -1,                  REG_BINARY },
        { NULL,            0,    0,                  0 }
    };

    const struct data_type *ptr;
    int type;

    for (ptr = data_types; ptr->tag; ptr++) {
        if (memcmp(ptr->tag, *lpValue, ptr->len))
            continue;

        /* Found! */
        *parse_type = ptr->parse_type;
        type = ptr->type;
        *lpValue += ptr->len;
        if (type == -1) {
            TCHAR* end;
            /* "hex(xx):" is special */
            type = (int)_tcstoul(*lpValue , &end, 16);
            if (**lpValue == _T('\0') || *end != _T(')') || *(end+1) != _T(':')) {
                type = REG_NONE;
            } else {
                *lpValue = end + 2;
            }
        }
        return type;
    }
    return (**lpValue == _T('\0') ? REG_SZ : REG_NONE);
}

Referenced by setValue().

getRegClass()

HKEY getRegClass

(

LPTSTR

lpLine

)

Definition at line 567 of file regproc.c.

{
  LPTSTR classNameEnd;
  LPTSTR classNameBeg;
  int i;

  TCHAR lpClassCopy[KEY_MAX_LEN];

  if (lpClass == NULL)
    return (HKEY)ERROR_INVALID_PARAMETER;

  _tcsncpy(lpClassCopy, lpClass, KEY_MAX_LEN);

  classNameEnd  = _tcschr(lpClassCopy, _T('\\'));    /* The class name ends by '\' */
  if (!classNameEnd) {                          /* or the whole string */
      classNameEnd = lpClassCopy + _tcslen(lpClassCopy);
      if (classNameEnd[-1] == _T(']')) {
          classNameEnd--;
      }
  }
  *classNameEnd = _T('\0');                       /* Isolate the class name */
  if (lpClassCopy[0] == _T('[')) {
      classNameBeg = lpClassCopy + 1;
  } else {
      classNameBeg = lpClassCopy;
  }
  for (i = 0; i < REG_CLASS_NUMBER; i++) {
      if (!_tcscmp(classNameBeg, reg_class_names[i])) {
          return reg_class_keys[i];
      }
  }
  return (HKEY)ERROR_INVALID_PARAMETER;
}

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

getRegKeyName()

LPTSTR getRegKeyName

(

LPTSTR

lpLine

)

Definition at line 536 of file regproc.c.

{
  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;
}

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

getToken()

char* getToken	(	char **	str,
		const char *	delims
	)

Referenced by processQueryValue().

import_registry_file()

BOOL import_registry_file

(

LPTSTR

filename

)

Definition at line 1396 of file regproc.c.

{
    FILE* reg_file = _tfopen(filename, _T("r"));

    if (reg_file) {
        processRegLines(reg_file, doSetValue);
        return TRUE;
    }
    return FALSE;
}

openKey()

HRESULT openKey

(

LPTSTR

stdInput

)

Definition at line 494 of file regproc.c.

{
  DWORD   dwDisp;
  HRESULT hRes;

  /* Sanity checks */
  if (stdInput == NULL)
    return ERROR_INVALID_PARAMETER;

  /* Get the registry class */
  currentKeyClass = getRegClass(stdInput); /* Sets global variable */
  if (currentKeyClass == (HKEY)ERROR_INVALID_PARAMETER)
    return (HRESULT)ERROR_INVALID_PARAMETER;

  /* Get the key name */
  currentKeyName = getRegKeyName(stdInput); /* Sets global variable */
  if (currentKeyName == NULL)
    return ERROR_INVALID_PARAMETER;

  hRes = RegCreateKeyEx(
          currentKeyClass,          /* Class     */
          currentKeyName,           /* Sub Key   */
          0,                        /* MUST BE 0 */
          NULL,                     /* object type */
          REG_OPTION_NON_VOLATILE,  /* option, REG_OPTION_NON_VOLATILE ... */
          KEY_ALL_ACCESS,           /* access mask, KEY_ALL_ACCESS */
          NULL,                     /* security attribute */
          &currentKeyHandle,        /* result */
          &dwDisp);                 /* disposition, REG_CREATED_NEW_KEY or
                                                    REG_OPENED_EXISTING_KEY */

  if (hRes == ERROR_SUCCESS)
    bTheKeyIsOpen = TRUE;

  return hRes;

}

Referenced by doQueryValue(), and doSetValue().

processQueryValue()

void processQueryValue

(

LPTSTR

cmdline

)

Definition at line 770 of file regproc.c.

{
  _tprintf(_T("ERROR!!! - temporary disabled"));
  //exit(1);
  return;
#if 0
  LPSTR   argv[QUERY_VALUE_MAX_ARGS];/* args storage    */
  LPSTR   token      = NULL;         /* current token analized */
  ULONG   argCounter = 0;            /* counter of args */
  INT     counter;
  HRESULT hRes       = 0;
  LPSTR   keyValue   = NULL;
  LPSTR   lpsRes     = NULL;

  /*
   * Init storage and parse the line
   */
  for (counter = 0; counter < QUERY_VALUE_MAX_ARGS; counter++)
    argv[counter] = NULL;

  while ((token = getToken(&cmdline, queryValueDelim[argCounter])) != NULL) {
    argv[argCounter++] = getArg(token);
    if (argCounter == QUERY_VALUE_MAX_ARGS)
      break;  /* Stop processing args no matter what */
  }

  /* The value we look for is the first token on the line */
  if (argv[0] == NULL)
    return; /* SHOULD NOT HAPPEN */
  else
    keyValue = argv[0];

  if ((keyValue[0] == '@') && (_tcslen(keyValue) == 1)) {
    LONG lLen = KEY_MAX_LEN;
    TCHAR* lpsData = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,KEY_MAX_LEN);
    /*
     * We need to query the key default value
     */
    hRes = RegQueryValue(currentKeyHandle, currentKeyName, (LPBYTE)lpsData, &lLen);
    if (hRes == ERROR_MORE_DATA) {
        lpsData = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lpsData, lLen);
        hRes = RegQueryValue(currentKeyHandle, currentKeyName, (LPBYTE)lpsData, &lLen);
    }
    if (hRes == ERROR_SUCCESS) {
      lpsRes = HeapAlloc(GetProcessHeap(), 0, lLen);
      strncpy(lpsRes, lpsData, lLen);
      lpsRes[lLen-1]='\0';
    }
  } else {
    DWORD dwLen = KEY_MAX_LEN;
    BYTE* lpbData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, KEY_MAX_LEN);
    DWORD dwType;
    /*
     * We need to query a specific value for the key
     */
    hRes = RegQueryValueEx(
             currentKeyHandle,
             keyValue,
             0,
             &dwType,
             (LPBYTE)lpbData,
             &dwLen);

    if (hRes == ERROR_MORE_DATA) {
        lpbData = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, lpbData, dwLen * sizeof(TCHAR));
        hRes = RegQueryValueEx(currentKeyHandle, keyValue, NULL, &dwType, (LPBYTE)lpbData, &dwLen);
    }

    if (hRes == ERROR_SUCCESS) {
      /*
       * Convert the returned data to a displayable format
       */
      switch (dwType) {
        case REG_SZ:
        case REG_EXPAND_SZ:
          lpsRes = HeapAlloc(GetProcessHeap(), 0, dwLen * sizeof(TCHAR));
          strncpy(lpsRes, lpbData, dwLen);
          lpsRes[dwLen-1] = '\0';
          break;
        case REG_DWORD:
          lpsRes = convertHexToDWORDStr(lpbData, dwLen);
          break;
        default:
          lpsRes = convertHexToHexCSV(lpbData, dwLen);
          break;
      }
    }

    HeapFree(GetProcessHeap(), 0, lpbData);
  }
  if (hRes == ERROR_SUCCESS) {
    _tprintf(_T("Value \"%s\" = \"%s\" in key [%s]\n"), keyValue, lpsRes, currentKeyName);

  } else {
    _tprintf(_T("ERROR Value \"%s\" not found. for key \"%s\"\n"), keyValue, currentKeyName);
  }

  /*
   * Do some cleanup
   */
  for (counter=0; counter<argCounter; counter++)
    if (argv[counter] != NULL)
      HeapFree(GetProcessHeap(), 0, argv[counter]);

  if (lpsRes != NULL)
    HeapFree(GetProcessHeap(), 0, lpsRes);
#endif
}

Referenced by doQueryValue().

processRegLines()

void processRegLines	(	FILE *	in,
		CommandAPI	command
	)

Definition at line 887 of file regproc.c.

{
    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);
}

Referenced by import_registry_file().

processSetValue()

void processSetValue

(

LPTSTR

cmdline

)

Definition at line 716 of file regproc.c.

{
  LPTSTR val_name;                   /* registry value name   */
  LPTSTR val_data;                   /* registry value data   */

  int line_idx = 0;                 /* current character under analysis */
  HRESULT hRes = 0;

  /* get value name */
  if (line[line_idx] == _T('@') && line[line_idx + 1] == _T('=')) {
      line[line_idx] = _T('\0');
      val_name = line;
      line_idx++;
  } else if (line[line_idx] == _T('\"')) {
      line_idx++;
      val_name = line + line_idx;
      while (TRUE) {
          if (line[line_idx] == _T('\\')) {  /* skip escaped character */
              line_idx += 2;
          } else {
              if (line[line_idx] == _T('\"')) {
                  line[line_idx] = _T('\0');
                  line_idx++;
                  break;
              } else {
                  line_idx++;
              }
          }
      }
      if (line[line_idx] != _T('=')) {
          line[line_idx] = _T('\"');
          _tprintf(_T("Warning! uncrecognized line:\n%s\n"), line);
          return;
      }
  } else {
      _tprintf(_T("Warning! unrecognized line:\n%s\n"), line);
      return;
  }
  line_idx++;                   /* skip the '=' character */
  val_data = line + line_idx;
  REGPROC_unescape_string(val_name);

    _tprintf(_T("Key: %s, Value: %s, Data: %s\n"), currentKeyName, val_name, val_data);

  hRes = setValue(val_name, val_data);
  if (hRes != ERROR_SUCCESS) {
    _tprintf(_T("ERROR Key %s not created. Value: %s, Data: %s\n"), currentKeyName, val_name, val_data);
  }
}

Referenced by doSetValue().

RegHeapAlloc()

LPVOID RegHeapAlloc	(	HANDLE	hHeap,
		DWORD	dwFlags,
		SIZE_T	dwBytes
	)

RegHeapFree()

BOOL RegHeapFree	(	HANDLE	hHeap,
		DWORD	dwFlags,
		LPVOID	lpMem
	)

RegHeapReAlloc()

LPVOID RegHeapReAlloc	(	HANDLE	hHeap,
		DWORD	dwFlags,
		LPVOID	lpMem,
		SIZE_T	dwBytes
	)

setValue()

HRESULT setValue	(	LPTSTR	val_name,
		LPTSTR	val_data
	)

Definition at line 432 of file regproc.c.

{
  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;
}

Referenced by processSetValue().