ReactOS  0.4.13-dev-249-gcba1a2f
regproc.c File Reference
#include "regedit.h"
#include <assert.h>
#include <fcntl.h>
#include <io.h>
#include <wine/unicode.h>
Include dependency graph for regproc.c:

Go to the source code of this file.

Macros

#define REG_VAL_BUF_SIZE   4096
 
#define REG_FILE_HEX_LINE_LEN   (2 + 25 * 3)
 
#define REG_CLASS_NUMBER   (sizeof(reg_class_keys) / sizeof(reg_class_keys[0]))
 
#define NOT_ENOUGH_MEMORY   1
 
#define IO_ERROR   2
 
#define CHECK_ENOUGH_MEMORY(p)
 

Functions

WCHARGetWideString (const char *strA)
 
static WCHARGetWideStringN (const char *strA, int chars, DWORD *len)
 
charGetMultiByteString (const WCHAR *strW)
 
static charGetMultiByteStringN (const WCHAR *strW, int chars, DWORD *len)
 
static BOOL convertHexToDWord (WCHAR *str, DWORD *dw)
 
static BYTEconvertHexCSVToHex (WCHAR *str, DWORD *size)
 
static DWORD getDataType (LPWSTR *lpValue, DWORD *parse_type)
 
static void REGPROC_unescape_string (WCHAR *str)
 
static BOOL parseKeyName (LPWSTR lpKeyName, HKEY *hKey, LPWSTR *lpKeyPath)
 
static LONG setValue (WCHAR *val_name, WCHAR *val_data, BOOL is_unicode)
 
static LONG openKeyW (WCHAR *stdInput)
 
static void closeKey (void)
 
static void processSetValue (WCHAR *line, BOOL is_unicode)
 
static void processRegEntry (WCHAR *stdInput, BOOL isUnicode)
 
static void processRegLinesA (FILE *in, char *first_chars)
 
static void processRegLinesW (FILE *in)
 
static void REGPROC_print_error (void)
 
static void REGPROC_resize_char_buffer (WCHAR **buffer, DWORD *len, DWORD required_len)
 
static void REGPROC_resize_binary_buffer (BYTE **buffer, DWORD *size, DWORD required_size)
 
static void REGPROC_export_string (WCHAR **line_buf, DWORD *line_buf_size, DWORD *line_len, WCHAR *str, DWORD str_len)
 
static void REGPROC_export_binary (WCHAR **line_buf, DWORD *line_buf_size, DWORD *line_len, DWORD type, BYTE *value, DWORD value_size, BOOL unicode)
 
static void REGPROC_write_line (FILE *file, const WCHAR *str, BOOL unicode)
 
static void export_hkey (FILE *file, HKEY key, WCHAR **reg_key_name_buf, DWORD *reg_key_name_size, WCHAR **val_name_buf, DWORD *val_name_size, BYTE **val_buf, DWORD *val_size, WCHAR **line_buf, DWORD *line_buf_size, BOOL unicode)
 
static FILEREGPROC_open_export_file (WCHAR *file_name, BOOL unicode)
 
BOOL export_registry_key (WCHAR *file_name, WCHAR *reg_key_name, DWORD format)
 
BOOL import_registry_file (FILE *reg_file)
 
void delete_registry_key (WCHAR *reg_key_name)
 

Variables

const WCHARreg_class_namesW []
 
static HKEY reg_class_keys []
 
static LPSTR currentKeyName
 
static HKEY currentKeyHandle = NULL
 

Macro Definition Documentation

◆ CHECK_ENOUGH_MEMORY

#define CHECK_ENOUGH_MEMORY (   p)
Value:
if (!(p)) \
{ \
fprintf(stderr,"%S: file %s, line %d: Not enough memory\n", \
getAppName(), __FILE__, __LINE__); \
}
#define NOT_ENOUGH_MEMORY
Definition: regproc.c:52
LPCWSTR getAppName(void)
Definition: regedit.c:61
FILE * stderr
GLfloat GLfloat p
Definition: glext.h:8902

Definition at line 58 of file regproc.c.

◆ IO_ERROR

#define IO_ERROR   2

Definition at line 53 of file regproc.c.

◆ NOT_ENOUGH_MEMORY

#define NOT_ENOUGH_MEMORY   1

Definition at line 52 of file regproc.c.

◆ REG_CLASS_NUMBER

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

Definition at line 49 of file regproc.c.

◆ REG_FILE_HEX_LINE_LEN

#define REG_FILE_HEX_LINE_LEN   (2 + 25 * 3)

Definition at line 36 of file regproc.c.

◆ REG_VAL_BUF_SIZE

#define REG_VAL_BUF_SIZE   4096

Definition at line 31 of file regproc.c.

Function Documentation

◆ closeKey()

static void closeKey ( void  )
static

Definition at line 465 of file regproc.c.

466 {
467  if (currentKeyHandle)
468  {
472  }
473 }
static LPSTR currentKeyName
Definition: regproc.c:333
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
static HKEY currentKeyHandle
Definition: regproc.c:334
smooth NULL
Definition: ftsmooth.c:416
#define GetProcessHeap()
Definition: compat.h:395
#define HeapFree(x, y, z)
Definition: compat.h:394

Referenced by processRegEntry().

◆ convertHexCSVToHex()

static BYTE* convertHexCSVToHex ( WCHAR str,
DWORD size 
)
static

Definition at line 163 of file regproc.c.

164 {
165  WCHAR *s;
166  BYTE *d, *data;
167 
168  /* The worst case is 1 digit + 1 comma per byte */
169  *size=(lstrlenW(str)+1)/2;
172 
173  s = str;
174  d = data;
175  *size=0;
176  while (*s != '\0') {
177  UINT wc;
178  WCHAR *end;
179 
180  wc = strtoulW(s,&end,16);
181  if (end == s || wc > 0xff || (*end && *end != ',')) {
182  char* strA = GetMultiByteString(s);
183  fprintf(stderr,"%S: ERROR converting CSV hex stream. Invalid value at '%s'\n",
184  getAppName(), strA);
187  return NULL;
188  }
189  *d++ =(BYTE)wc;
190  (*size)++;
191  if (*end) end++;
192  s = end;
193  }
194 
195  return data;
196 }
char strA[12]
Definition: clipboard.c:2028
GLuint GLuint end
Definition: gl.h:1545
#define lstrlenW
Definition: compat.h:407
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
const WCHAR * str
smooth NULL
Definition: ftsmooth.c:416
char * GetMultiByteString(const WCHAR *strW)
Definition: regproc.c:109
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define d
Definition: ke_i.h:81
__wchar_t WCHAR
Definition: xmlstorage.h:180
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
unsigned char BYTE
Definition: mem.h:68
GLdouble s
Definition: gl.h:2039
unsigned int UINT
Definition: ndis.h:50
LPCWSTR getAppName(void)
Definition: regedit.c:61
FILE * stderr
#define strtoulW(s1, s2, b)
Definition: unicode.h:41
#define CHECK_ENOUGH_MEMORY(p)
Definition: regproc.c:58
#define HeapFree(x, y, z)
Definition: compat.h:394

Referenced by setValue().

◆ convertHexToDWord()

static BOOL convertHexToDWord ( WCHAR str,
DWORD dw 
)
static

Definition at line 147 of file regproc.c.

148 {
149  char buf[9];
150  char dummy;
151 
152  WideCharToMultiByte(CP_ACP, 0, str, -1, buf, 9, NULL, NULL);
153  if (lstrlenW(str) > 8 || sscanf(buf, "%lx%c", dw, &dummy) != 1) {
154  fprintf(stderr,"%S: ERROR, invalid hex value\n", getAppName());
155  return FALSE;
156  }
157  return TRUE;
158 }
#define TRUE
Definition: types.h:120
#define WideCharToMultiByte
Definition: compat.h:101
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
#define CP_ACP
Definition: compat.h:99
#define lstrlenW
Definition: compat.h:407
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
const WCHAR * str
smooth NULL
Definition: ftsmooth.c:416
_Check_return_ _CRTIMP int __cdecl sscanf(_In_z_ const char *_Src, _In_z_ _Scanf_format_string_ const char *_Format,...)
REFIID LPVOID DWORD dw
Definition: atlbase.h:40
unsigned char dummy
Definition: maze.c:118
LPCWSTR getAppName(void)
Definition: regedit.c:61
FILE * stderr

Referenced by setValue().

◆ delete_registry_key()

void delete_registry_key ( WCHAR reg_key_name)

Definition at line 1432 of file regproc.c.

1433 {
1434  WCHAR *key_name = NULL;
1435  HKEY key_class;
1436 
1437  if (!reg_key_name || !reg_key_name[0])
1438  return;
1439 
1440  if (!parseKeyName(reg_key_name, &key_class, &key_name)) {
1441  char* reg_key_nameA = GetMultiByteString(reg_key_name);
1442  fprintf(stderr,"%S: Incorrect registry class specification in '%s'\n",
1443  getAppName(), reg_key_nameA);
1444  HeapFree(GetProcessHeap(), 0, reg_key_nameA);
1445  exit(1);
1446  }
1447  if (!*key_name) {
1448  char* reg_key_nameA = GetMultiByteString(reg_key_name);
1449  fprintf(stderr,"%S: Can't delete registry class '%s'\n",
1450  getAppName(), reg_key_nameA);
1451  HeapFree(GetProcessHeap(), 0, reg_key_nameA);
1452  exit(1);
1453  }
1454 
1455  SHDeleteKey(key_class, key_name);
1456 }
static BOOL parseKeyName(LPWSTR lpKeyName, HKEY *hKey, LPWSTR *lpKeyPath)
Definition: regproc.c:286
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
smooth NULL
Definition: ftsmooth.c:416
char * GetMultiByteString(const WCHAR *strW)
Definition: regproc.c:109
#define GetProcessHeap()
Definition: compat.h:395
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define SHDeleteKey
Definition: shlwapi.h:44
LPCWSTR getAppName(void)
Definition: regedit.c:61
FILE * stderr
void exit(int exitcode)
Definition: _exit.c:33
#define HeapFree(x, y, z)
Definition: compat.h:394

Referenced by PerformRegAction(), and processRegEntry().

◆ export_hkey()

static void export_hkey ( FILE file,
HKEY  key,
WCHAR **  reg_key_name_buf,
DWORD reg_key_name_size,
WCHAR **  val_name_buf,
DWORD val_name_size,
BYTE **  val_buf,
DWORD val_size,
WCHAR **  line_buf,
DWORD line_buf_size,
BOOL  unicode 
)
static

Definition at line 1096 of file regproc.c.

1102 {
1103  DWORD max_sub_key_len;
1104  DWORD max_val_name_len;
1105  DWORD max_val_size;
1106  DWORD curr_len;
1107  DWORD i;
1108  BOOL more_data;
1109  LONG ret;
1110  WCHAR key_format[] = {'\r','\n','[','%','s',']','\r','\n',0};
1111 
1112  /* get size information and resize the buffers if necessary */
1114  &max_sub_key_len, NULL,
1115  NULL, &max_val_name_len, &max_val_size, NULL, NULL
1116  ) != ERROR_SUCCESS) {
1118  }
1119  curr_len = strlenW(*reg_key_name_buf);
1120  REGPROC_resize_char_buffer(reg_key_name_buf, reg_key_name_size,
1121  max_sub_key_len + curr_len + 1);
1122  REGPROC_resize_char_buffer(val_name_buf, val_name_size,
1123  max_val_name_len);
1124  REGPROC_resize_binary_buffer(val_buf, val_size, max_val_size);
1125  REGPROC_resize_char_buffer(line_buf, line_buf_size, lstrlenW(*reg_key_name_buf) + 4);
1126  /* output data for the current key */
1127  sprintfW(*line_buf, key_format, *reg_key_name_buf);
1128  REGPROC_write_line(file, *line_buf, unicode);
1129 
1130  /* print all the values */
1131  i = 0;
1132  more_data = TRUE;
1133  while(more_data) {
1134  DWORD value_type;
1135  DWORD val_name_size1 = *val_name_size;
1136  DWORD val_size1 = *val_size;
1137  ret = RegEnumValueW(key, i, *val_name_buf, &val_name_size1, NULL,
1138  &value_type, *val_buf, &val_size1);
1139  if (ret == ERROR_MORE_DATA) {
1140  /* Increase the size of the buffers and retry */
1141  REGPROC_resize_char_buffer(val_name_buf, val_name_size, val_name_size1);
1142  REGPROC_resize_binary_buffer(val_buf, val_size, val_size1);
1143  } else if (ret != ERROR_SUCCESS) {
1144  more_data = FALSE;
1145  if (ret != ERROR_NO_MORE_ITEMS) {
1147  }
1148  } else {
1149  DWORD line_len;
1150  i++;
1151 
1152  if ((*val_name_buf)[0]) {
1153  const WCHAR val_start[] = {'"','%','s','"','=',0};
1154 
1155  line_len = 0;
1156  REGPROC_export_string(line_buf, line_buf_size, &line_len, *val_name_buf, lstrlenW(*val_name_buf));
1157  REGPROC_resize_char_buffer(val_name_buf, val_name_size, lstrlenW(*line_buf) + 1);
1158  lstrcpyW(*val_name_buf, *line_buf);
1159 
1160  line_len = 3 + lstrlenW(*val_name_buf);
1161  REGPROC_resize_char_buffer(line_buf, line_buf_size, line_len);
1162  sprintfW(*line_buf, val_start, *val_name_buf);
1163  } else {
1164  const WCHAR std_val[] = {'@','=',0};
1165  line_len = 2;
1166  REGPROC_resize_char_buffer(line_buf, line_buf_size, line_len);
1167  lstrcpyW(*line_buf, std_val);
1168  }
1169 
1170  switch (value_type) {
1171  case REG_SZ:
1172  {
1173  WCHAR* wstr = (WCHAR*)*val_buf;
1174 
1175  if (val_size1 < sizeof(WCHAR) || val_size1 % sizeof(WCHAR) ||
1176  wstr[val_size1 / sizeof(WCHAR) - 1]) {
1177  REGPROC_export_binary(line_buf, line_buf_size, &line_len, value_type, *val_buf, val_size1, unicode);
1178  } else {
1179  const WCHAR start[] = {'"',0};
1180  const WCHAR end[] = {'"','\r','\n',0};
1181  DWORD len;
1182 
1183  len = lstrlenW(start);
1184  REGPROC_resize_char_buffer(line_buf, line_buf_size, line_len + len);
1185  lstrcpyW(*line_buf + line_len, start);
1186  line_len += len;
1187 
1188  /* At this point we know wstr is '\0'-terminated
1189  * so we can subtract 1 from the size
1190  */
1191  REGPROC_export_string(line_buf, line_buf_size, &line_len, wstr, val_size1 / sizeof(WCHAR) - 1);
1192 
1193  REGPROC_resize_char_buffer(line_buf, line_buf_size, line_len + lstrlenW(end));
1194  lstrcpyW(*line_buf + line_len, end);
1195  }
1196  break;
1197  }
1198 
1199  case REG_DWORD:
1200  {
1201  WCHAR format[] = {'d','w','o','r','d',':','%','0','8','x','\r','\n',0};
1202 
1203  REGPROC_resize_char_buffer(line_buf, line_buf_size, line_len + 15);
1204  sprintfW(*line_buf + line_len, format, *((DWORD *)*val_buf));
1205  break;
1206  }
1207 
1208  default:
1209  {
1210  char* key_nameA = GetMultiByteString(*reg_key_name_buf);
1211  char* value_nameA = GetMultiByteString(*val_name_buf);
1212  fprintf(stderr,"%S: warning - unsupported registry format '%ld', "
1213  "treat as binary\n",
1214  getAppName(), value_type);
1215  fprintf(stderr,"key name: \"%s\"\n", key_nameA);
1216  fprintf(stderr,"value name:\"%s\"\n\n", value_nameA);
1217  HeapFree(GetProcessHeap(), 0, key_nameA);
1218  HeapFree(GetProcessHeap(), 0, value_nameA);
1219  }
1220  /* falls through */
1221  case REG_EXPAND_SZ:
1222  case REG_MULTI_SZ:
1223  /* falls through */
1224  case REG_BINARY:
1225  REGPROC_export_binary(line_buf, line_buf_size, &line_len, value_type, *val_buf, val_size1, unicode);
1226  }
1227  REGPROC_write_line(file, *line_buf, unicode);
1228  }
1229  }
1230 
1231  i = 0;
1232  more_data = TRUE;
1233  (*reg_key_name_buf)[curr_len] = '\\';
1234  while(more_data) {
1235  DWORD buf_size = *reg_key_name_size - curr_len - 1;
1236 
1237  ret = RegEnumKeyExW(key, i, *reg_key_name_buf + curr_len + 1, &buf_size,
1238  NULL, NULL, NULL, NULL);
1239  if (ret == ERROR_MORE_DATA) {
1240  /* Increase the size of the buffer and retry */
1241  REGPROC_resize_char_buffer(reg_key_name_buf, reg_key_name_size, curr_len + 1 + buf_size);
1242  } else if (ret != ERROR_SUCCESS) {
1243  more_data = FALSE;
1244  if (ret != ERROR_NO_MORE_ITEMS) {
1246  }
1247  } else {
1248  HKEY subkey;
1249 
1250  i++;
1251  if (RegOpenKeyW(key, *reg_key_name_buf + curr_len + 1,
1252  &subkey) == ERROR_SUCCESS) {
1253  export_hkey(file, subkey, reg_key_name_buf, reg_key_name_size,
1254  val_name_buf, val_name_size, val_buf, val_size,
1255  line_buf, line_buf_size, unicode);
1256  RegCloseKey(subkey);
1257  } else {
1259  }
1260  }
1261  }
1262  (*reg_key_name_buf)[curr_len] = '\0';
1263 }
#define TRUE
Definition: types.h:120
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
Definition: unicode.h:212
#define ERROR_SUCCESS
Definition: deptool.c:10
#define ERROR_NO_MORE_ITEMS
Definition: compat.h:95
#define REG_BINARY
Definition: nt_native.h:1496
static void REGPROC_export_string(WCHAR **line_buf, DWORD *line_buf_size, DWORD *line_len, WCHAR *str, DWORD str_len)
Definition: regproc.c:957
static void REGPROC_export_binary(WCHAR **line_buf, DWORD *line_buf_size, DWORD *line_len, DWORD type, BYTE *value, DWORD value_size, BOOL unicode)
Definition: regproc.c:992
static void REGPROC_resize_binary_buffer(BYTE **buffer, DWORD *size, DWORD required_size)
Definition: regproc.c:942
GLuint GLuint end
Definition: gl.h:1545
#define lstrlenW
Definition: compat.h:407
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
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
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
static void REGPROC_write_line(FILE *file, const WCHAR *str, BOOL unicode)
Definition: regproc.c:1067
LONG WINAPI RegOpenKeyW(HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult)
Definition: reg.c:3311
#define REG_MULTI_SZ
Definition: nt_native.h:1501
LONG WINAPI RegEnumValueW(_In_ HKEY hKey, _In_ DWORD index, _Out_ LPWSTR value, _Inout_ PDWORD val_count, _Reserved_ PDWORD reserved, _Out_opt_ PDWORD type, _Out_opt_ LPBYTE data, _Inout_opt_ PDWORD count)
Definition: reg.c:2867
smooth NULL
Definition: ftsmooth.c:416
char * GetMultiByteString(const WCHAR *strW)
Definition: regproc.c:109
#define GetProcessHeap()
Definition: compat.h:395
__wchar_t WCHAR
Definition: xmlstorage.h:180
static void REGPROC_print_error(void)
Definition: regproc.c:892
unsigned long DWORD
Definition: ntddk_ex.h:95
LONG WINAPI RegQueryInfoKeyW(HKEY hKey, LPWSTR lpClass, LPDWORD lpcClass, LPDWORD lpReserved, LPDWORD lpcSubKeys, LPDWORD lpcMaxSubKeyLen, LPDWORD lpcMaxClassLen, LPDWORD lpcValues, LPDWORD lpcMaxValueNameLen, LPDWORD lpcMaxValueLen, LPDWORD lpcbSecurityDescriptor, PFILETIME lpftLastWriteTime)
Definition: reg.c:3704
int ret
GLenum GLsizei len
Definition: glext.h:6722
#define ERROR_MORE_DATA
Definition: dderror.h:13
#define lstrcpyW
Definition: compat.h:406
GLuint start
Definition: gl.h:1545
#define REG_EXPAND_SZ
Definition: nt_native.h:1494
#define sprintfW
Definition: unicode.h:58
static void export_hkey(FILE *file, HKEY key, WCHAR **reg_key_name_buf, DWORD *reg_key_name_size, WCHAR **val_name_buf, DWORD *val_name_size, BYTE **val_buf, DWORD *val_size, WCHAR **line_buf, DWORD *line_buf_size, BOOL unicode)
Definition: regproc.c:1096
LPCWSTR getAppName(void)
Definition: regedit.c:61
FILE * stderr
LONG WINAPI RegEnumKeyExW(_In_ HKEY hKey, _In_ DWORD dwIndex, _Out_ LPWSTR lpName, _Inout_ LPDWORD lpcbName, _Reserved_ LPDWORD lpReserved, _Out_opt_ LPWSTR lpClass, _Inout_opt_ LPDWORD lpcbClass, _Out_opt_ PFILETIME lpftLastWriteTime)
Definition: reg.c:2541
#define REG_DWORD
Definition: sdbapi.c:596
static void REGPROC_resize_char_buffer(WCHAR **buffer, DWORD *len, DWORD required_len)
Definition: regproc.c:921
#define HeapFree(x, y, z)
Definition: compat.h:394
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 ( WCHAR file_name,
WCHAR reg_key_name,
DWORD  format 
)

Definition at line 1310 of file regproc.c.

1311 {
1312  WCHAR *reg_key_name_buf;
1313  WCHAR *val_name_buf;
1314  BYTE *val_buf;
1315  WCHAR *line_buf;
1316  DWORD reg_key_name_size = KEY_MAX_LEN;
1317  DWORD val_name_size = KEY_MAX_LEN;
1318  DWORD val_size = REG_VAL_BUF_SIZE;
1319  DWORD line_buf_size = KEY_MAX_LEN + REG_VAL_BUF_SIZE;
1320  FILE *file = NULL;
1321  BOOL unicode = (format == REG_FORMAT_5);
1322 
1323  reg_key_name_buf = HeapAlloc(GetProcessHeap(), 0,
1324  reg_key_name_size * sizeof(*reg_key_name_buf));
1325  val_name_buf = HeapAlloc(GetProcessHeap(), 0,
1326  val_name_size * sizeof(*val_name_buf));
1327  val_buf = HeapAlloc(GetProcessHeap(), 0, val_size);
1328  line_buf = HeapAlloc(GetProcessHeap(), 0, line_buf_size * sizeof(*line_buf));
1329  CHECK_ENOUGH_MEMORY(reg_key_name_buf && val_name_buf && val_buf && line_buf);
1330 
1331  if (reg_key_name && reg_key_name[0]) {
1332  HKEY reg_key_class;
1333  WCHAR *branch_name = NULL;
1334  HKEY key;
1335 
1336  REGPROC_resize_char_buffer(&reg_key_name_buf, &reg_key_name_size,
1337  lstrlenW(reg_key_name));
1338  lstrcpyW(reg_key_name_buf, reg_key_name);
1339 
1340  /* open the specified key */
1341  if (!parseKeyName(reg_key_name, &reg_key_class, &branch_name)) {
1342  CHAR* key_nameA = GetMultiByteString(reg_key_name);
1343  fprintf(stderr,"%S: Incorrect registry class specification in '%s'\n",
1344  getAppName(), key_nameA);
1345  HeapFree(GetProcessHeap(), 0, key_nameA);
1346  exit(1);
1347  }
1348  if (!branch_name[0]) {
1349  /* no branch - registry class is specified */
1351  export_hkey(file, reg_key_class,
1352  &reg_key_name_buf, &reg_key_name_size,
1353  &val_name_buf, &val_name_size,
1354  &val_buf, &val_size, &line_buf,
1355  &line_buf_size, unicode);
1356  } else if (RegOpenKeyW(reg_key_class, branch_name, &key) == ERROR_SUCCESS) {
1358  export_hkey(file, key,
1359  &reg_key_name_buf, &reg_key_name_size,
1360  &val_name_buf, &val_name_size,
1361  &val_buf, &val_size, &line_buf,
1362  &line_buf_size, unicode);
1363  RegCloseKey(key);
1364  } else {
1365  CHAR* key_nameA = GetMultiByteString(reg_key_name);
1366  fprintf(stderr,"%S: Can't export. Registry key '%s' does not exist!\n",
1367  getAppName(), key_nameA);
1368  HeapFree(GetProcessHeap(), 0, key_nameA);
1370  }
1371  } else {
1372  unsigned int i;
1373 
1374  /* export all registry classes */
1376  for (i = 0; i < REG_CLASS_NUMBER; i++) {
1377  /* do not export HKEY_CLASSES_ROOT */
1382  lstrcpyW(reg_key_name_buf, reg_class_namesW[i]);
1384  &reg_key_name_buf, &reg_key_name_size,
1385  &val_name_buf, &val_name_size,
1386  &val_buf, &val_size, &line_buf,
1387  &line_buf_size, unicode);
1388  }
1389  }
1390  }
1391 
1392  if (file) {
1393  fclose(file);
1394  }
1395  HeapFree(GetProcessHeap(), 0, reg_key_name);
1396  HeapFree(GetProcessHeap(), 0, val_name_buf);
1397  HeapFree(GetProcessHeap(), 0, val_buf);
1398  HeapFree(GetProcessHeap(), 0, line_buf);
1399  return TRUE;
1400 }
static BOOL parseKeyName(LPWSTR lpKeyName, HKEY *hKey, LPWSTR *lpKeyPath)
Definition: regproc.c:286
#define TRUE
Definition: types.h:120
#define ERROR_SUCCESS
Definition: deptool.c:10
#define HKEY_CURRENT_USER
Definition: winreg.h:11
char CHAR
Definition: xmlstorage.h:175
#define HKEY_DYN_DATA
Definition: winreg.h:16
#define HKEY_CURRENT_CONFIG
Definition: winreg.h:15
#define lstrlenW
Definition: compat.h:407
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
#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
static FILE * REGPROC_open_export_file(WCHAR *file_name, BOOL unicode)
Definition: regproc.c:1268
unsigned int BOOL
Definition: ntddk_ex.h:94
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
LONG WINAPI RegOpenKeyW(HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult)
Definition: reg.c:3311
smooth NULL
Definition: ftsmooth.c:416
char * GetMultiByteString(const WCHAR *strW)
Definition: regproc.c:109
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
static void REGPROC_print_error(void)
Definition: regproc.c:892
const WCHAR * reg_class_namesW[]
Definition: regproc.c:38
unsigned long DWORD
Definition: ntddk_ex.h:95
#define REG_FORMAT_5
Definition: regproc.h:24
#define REG_CLASS_NUMBER
Definition: regproc.c:49
HKEY key
Definition: reg.c:42
unsigned char BYTE
Definition: mem.h:68
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
#define lstrcpyW
Definition: compat.h:406
static void export_hkey(FILE *file, HKEY key, WCHAR **reg_key_name_buf, DWORD *reg_key_name_size, WCHAR **val_name_buf, DWORD *val_name_size, BYTE **val_buf, DWORD *val_size, WCHAR **line_buf, DWORD *line_buf_size, BOOL unicode)
Definition: regproc.c:1096
static LPCWSTR file_name
Definition: protocol.c:146
static HKEY reg_class_keys[]
Definition: regproc.c:44
LPCWSTR getAppName(void)
Definition: regedit.c:61
FILE * stderr
#define HKEY_CLASSES_ROOT
Definition: winreg.h:10
void exit(int exitcode)
Definition: _exit.c:33
static void REGPROC_resize_char_buffer(WCHAR **buffer, DWORD *len, DWORD required_len)
Definition: regproc.c:921
#define REG_VAL_BUF_SIZE
Definition: regproc.c:31
#define CHECK_ENOUGH_MEMORY(p)
Definition: regproc.c:58
#define HeapFree(x, y, z)
Definition: compat.h:394
Definition: path.c:42
Definition: fci.c:126

Referenced by ExportRegistryFile(), and PerformRegAction().

◆ getDataType()

static DWORD getDataType ( LPWSTR lpValue,
DWORD parse_type 
)
static

Definition at line 205 of file regproc.c.

206 {
207  struct data_type { const WCHAR *tag; int len; int type; int parse_type; };
208 
209  static const WCHAR quote[] = {'"'};
210  static const WCHAR str[] = {'s','t','r',':','"'};
211  static const WCHAR str2[] = {'s','t','r','(','2',')',':','"'};
212  static const WCHAR hex[] = {'h','e','x',':'};
213  static const WCHAR dword[] = {'d','w','o','r','d',':'};
214  static const WCHAR hexp[] = {'h','e','x','('};
215 
216  static const struct data_type data_types[] = { /* actual type */ /* type to assume for parsing */
217  { quote, 1, REG_SZ, REG_SZ },
218  { str, 5, REG_SZ, REG_SZ },
219  { str2, 8, REG_EXPAND_SZ, REG_SZ },
220  { hex, 4, REG_BINARY, REG_BINARY },
221  { dword, 6, REG_DWORD, REG_DWORD },
222  { hexp, 4, -1, REG_BINARY },
223  { NULL, 0, 0, 0 }
224  };
225 
226  const struct data_type *ptr;
227  int type;
228 
229  for (ptr = data_types; ptr->tag; ptr++) {
230  if (strncmpW( ptr->tag, *lpValue, ptr->len ))
231  continue;
232 
233  /* Found! */
234  *parse_type = ptr->parse_type;
235  type=ptr->type;
236  *lpValue+=ptr->len;
237  if (type == -1) {
238  WCHAR* end;
239 
240  /* "hex(xx):" is special */
241  type = (int)strtoulW( *lpValue , &end, 16 );
242  if (**lpValue=='\0' || *end!=')' || *(end+1)!=':') {
243  type=REG_NONE;
244  } else {
245  *lpValue = end + 2;
246  }
247  }
248  return type;
249  }
251  return REG_NONE;
252 }
#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 const char hex[16]
Definition: profile.c:123
WINE_UNICODE_INLINE int strncmpW(const WCHAR *str1, const WCHAR *str2, int n)
Definition: unicode.h:235
static PVOID ptr
Definition: dispmode.c:27
#define quote
Definition: macro.lex.yy.c:531
const WCHAR * str
smooth NULL
Definition: ftsmooth.c:416
__wchar_t WCHAR
Definition: xmlstorage.h:180
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 strtoulW(s1, s2, b)
Definition: unicode.h:41
#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().

◆ GetMultiByteString()

char* GetMultiByteString ( const WCHAR strW)

Definition at line 109 of file regproc.c.

110 {
111  if(strW)
112  {
113  char* strA;
114  int len = WideCharToMultiByte(CP_ACP, 0, strW, -1, NULL, 0, NULL, NULL);
115 
116  strA = HeapAlloc(GetProcessHeap(), 0, len);
119  return strA;
120  }
121  return NULL;
122 }
char strA[12]
Definition: clipboard.c:2028
#define WideCharToMultiByte
Definition: compat.h:101
#define CP_ACP
Definition: compat.h:99
WCHAR strW[12]
Definition: clipboard.c:2029
smooth NULL
Definition: ftsmooth.c:416
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
GLenum GLsizei len
Definition: glext.h:6722
#define CHECK_ENOUGH_MEMORY(p)
Definition: regproc.c:58

Referenced by convertHexCSVToHex(), delete_registry_key(), export_hkey(), export_registry_key(), openKeyW(), processRegEntry(), processSetValue(), REGPROC_open_export_file(), and REGPROC_write_line().

◆ GetMultiByteStringN()

static char* GetMultiByteStringN ( const WCHAR strW,
int  chars,
DWORD len 
)
static

Definition at line 128 of file regproc.c.

129 {
130  if(strW)
131  {
132  char* strA;
133  *len = WideCharToMultiByte(CP_ACP, 0, strW, chars, NULL, 0, NULL, NULL);
134 
135  strA = HeapAlloc(GetProcessHeap(), 0, *len);
137  WideCharToMultiByte(CP_ACP, 0, strW, chars, strA, *len, NULL, NULL);
138  return strA;
139  }
140  *len = 0;
141  return NULL;
142 }
char strA[12]
Definition: clipboard.c:2028
#define WideCharToMultiByte
Definition: compat.h:101
#define CP_ACP
Definition: compat.h:99
WCHAR strW[12]
Definition: clipboard.c:2029
smooth NULL
Definition: ftsmooth.c:416
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
GLenum GLsizei len
Definition: glext.h:6722
#define CHECK_ENOUGH_MEMORY(p)
Definition: regproc.c:58

Referenced by REGPROC_export_binary().

◆ GetWideString()

WCHAR* GetWideString ( const char strA)

Definition at line 70 of file regproc.c.

71 {
72  if(strA)
73  {
74  WCHAR* strW;
75  int len = MultiByteToWideChar(CP_ACP, 0, strA, -1, NULL, 0);
76 
77  strW = HeapAlloc(GetProcessHeap(), 0, len * sizeof(WCHAR));
80  return strW;
81  }
82  return NULL;
83 }
char strA[12]
Definition: clipboard.c:2028
#define CP_ACP
Definition: compat.h:99
WCHAR strW[12]
Definition: clipboard.c:2029
smooth NULL
Definition: ftsmooth.c:416
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
GLenum GLsizei len
Definition: glext.h:6722
#define MultiByteToWideChar
Definition: compat.h:100
#define CHECK_ENOUGH_MEMORY(p)
Definition: regproc.c:58

Referenced by processRegLinesA().

◆ GetWideStringN()

static WCHAR* GetWideStringN ( const char strA,
int  chars,
DWORD len 
)
static

Definition at line 89 of file regproc.c.

90 {
91  if(strA)
92  {
93  WCHAR* strW;
94  *len = MultiByteToWideChar(CP_ACP, 0, strA, chars, NULL, 0);
95 
96  strW = HeapAlloc(GetProcessHeap(), 0, *len * sizeof(WCHAR));
98  MultiByteToWideChar(CP_ACP, 0, strA, chars, strW, *len);
99  return strW;
100  }
101  *len = 0;
102  return NULL;
103 }
char strA[12]
Definition: clipboard.c:2028
#define CP_ACP
Definition: compat.h:99
WCHAR strW[12]
Definition: clipboard.c:2029
smooth NULL
Definition: ftsmooth.c:416
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
GLenum GLsizei len
Definition: glext.h:6722
#define MultiByteToWideChar
Definition: compat.h:100
#define CHECK_ENOUGH_MEMORY(p)
Definition: regproc.c:58

Referenced by setValue().

◆ import_registry_file()

BOOL import_registry_file ( FILE reg_file)

Definition at line 1405 of file regproc.c.

1406 {
1407  if (reg_file)
1408  {
1409  BYTE s[2];
1410  if (fread( s, 2, 1, reg_file) == 1)
1411  {
1412  if (s[0] == 0xff && s[1] == 0xfe)
1413  {
1414  processRegLinesW(reg_file);
1415  } else
1416  {
1417  processRegLinesA(reg_file, (char*)s);
1418  }
1419  }
1420  return TRUE;
1421  }
1422  return FALSE;
1423 }
#define TRUE
Definition: types.h:120
static void processRegLinesA(FILE *in, char *first_chars)
Definition: regproc.c:618
_Check_return_opt_ _CRTIMP size_t __cdecl fread(_Out_writes_bytes_(_ElementSize *_Count) void *_DstBuf, _In_ size_t _ElementSize, _In_ size_t _Count, _Inout_ FILE *_File)
unsigned char BYTE
Definition: mem.h:68
GLdouble s
Definition: gl.h:2039
static void processRegLinesW(FILE *in)
Definition: regproc.c:761

Referenced by ImportRegistryFile(), and PerformRegAction().

◆ openKeyW()

static LONG openKeyW ( WCHAR stdInput)
static

Definition at line 426 of file regproc.c.

427 {
428  HKEY keyClass;
429  WCHAR* keyPath;
430  DWORD dwDisp;
431  LONG res;
432 
433  /* Sanity checks */
434  if (stdInput == NULL)
436 
437  /* Get the registry class */
438  if (!parseKeyName(stdInput, &keyClass, &keyPath))
440 
442  keyClass, /* Class */
443  keyPath, /* Sub Key */
444  0, /* MUST BE 0 */
445  NULL, /* object type */
446  REG_OPTION_NON_VOLATILE, /* option, REG_OPTION_NON_VOLATILE ... */
447  KEY_ALL_ACCESS, /* access mask, KEY_ALL_ACCESS */
448  NULL, /* security attribute */
449  &currentKeyHandle, /* result */
450  &dwDisp); /* disposition, REG_CREATED_NEW_KEY or
451  REG_OPENED_EXISTING_KEY */
452 
453  if (res == ERROR_SUCCESS)
455  else
457 
458  return res;
459 
460 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
static BOOL parseKeyName(LPWSTR lpKeyName, HKEY *hKey, LPWSTR *lpKeyPath)
Definition: regproc.c:286
#define ERROR_SUCCESS
Definition: deptool.c:10
static LPSTR currentKeyName
Definition: regproc.c:333
LONG WINAPI RegCreateKeyExW(_In_ HKEY hKey, _In_ LPCWSTR lpSubKey, _In_ DWORD Reserved, _In_opt_ LPWSTR lpClass, _In_ DWORD dwOptions, _In_ REGSAM samDesired, _In_opt_ LPSECURITY_ATTRIBUTES lpSecurityAttributes, _Out_ PHKEY phkResult, _Out_opt_ LPDWORD lpdwDisposition)
Definition: reg.c:1094
long LONG
Definition: pedump.c:60
static HKEY currentKeyHandle
Definition: regproc.c:334
smooth NULL
Definition: ftsmooth.c:416
char * GetMultiByteString(const WCHAR *strW)
Definition: regproc.c:109
#define REG_OPTION_NON_VOLATILE
Definition: nt_native.h:1057
__wchar_t WCHAR
Definition: xmlstorage.h:180
unsigned long DWORD
Definition: ntddk_ex.h:95
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
GLuint res
Definition: glext.h:9613

Referenced by processRegEntry().

◆ parseKeyName()

static BOOL parseKeyName ( LPWSTR  lpKeyName,
HKEY hKey,
LPWSTR lpKeyPath 
)
static

Definition at line 286 of file regproc.c.

287 {
288  WCHAR* lpSlash = NULL;
289  unsigned int i, len;
290 
291  if (lpKeyName == NULL)
292  return FALSE;
293 
294  for(i = 0; *(lpKeyName+i) != 0; i++)
295  {
296  if(*(lpKeyName+i) == '\\')
297  {
298  lpSlash = lpKeyName+i;
299  break;
300  }
301  }
302 
303  if (lpSlash)
304  {
305  len = lpSlash-lpKeyName;
306  }
307  else
308  {
309  len = lstrlenW(lpKeyName);
310  lpSlash = lpKeyName+len;
311  }
312  *hKey = NULL;
313 
314  for (i = 0; i < REG_CLASS_NUMBER; i++) {
317  *hKey = reg_class_keys[i];
318  break;
319  }
320  }
321 
322  if (*hKey == NULL)
323  return FALSE;
324 
325 
326  if (*lpSlash != '\0')
327  lpSlash++;
328  *lpKeyPath = lpSlash;
329  return TRUE;
330 }
#define TRUE
Definition: types.h:120
#define LOCALE_USER_DEFAULT
#define lstrlenW
Definition: compat.h:407
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
smooth NULL
Definition: ftsmooth.c:416
INT WINAPI CompareStringW(LCID lcid, DWORD flags, LPCWSTR str1, INT len1, LPCWSTR str2, INT len2)
Definition: lang.c:2275
__wchar_t WCHAR
Definition: xmlstorage.h:180
const WCHAR * reg_class_namesW[]
Definition: regproc.c:38
#define REG_CLASS_NUMBER
Definition: regproc.c:49
GLenum GLsizei len
Definition: glext.h:6722
#define CSTR_EQUAL
Definition: winnls.h:453
static HKEY reg_class_keys[]
Definition: regproc.c:44

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

◆ processRegEntry()

static void processRegEntry ( WCHAR stdInput,
BOOL  isUnicode 
)
static

Definition at line 563 of file regproc.c.

564 {
565  /*
566  * We encountered the end of the file, make sure we
567  * close the opened key and exit
568  */
569  if (stdInput == NULL) {
570  closeKey();
571  return;
572  }
573 
574  if ( stdInput[0] == '[') /* We are reading a new key */
575  {
576  WCHAR* keyEnd;
577  closeKey(); /* Close the previous key */
578 
579  /* Get rid of the square brackets */
580  stdInput++;
581  keyEnd = strrchrW(stdInput, ']');
582  if (keyEnd)
583  *keyEnd='\0';
584 
585  /* delete the key if we encounter '-' at the start of reg key */
586  if ( stdInput[0] == '-')
587  {
588  delete_registry_key(stdInput + 1);
589  } else if ( openKeyW(stdInput) != ERROR_SUCCESS )
590  {
591  char* stdInputA = GetMultiByteString(stdInput);
592  fprintf(stderr,"%S: setValue failed to open key %s\n",
593  getAppName(), stdInputA);
594  HeapFree(GetProcessHeap(), 0, stdInputA);
595  }
596  } else if( currentKeyHandle &&
597  (( stdInput[0] == '@') || /* reading a default @=data pair */
598  ( stdInput[0] == '\"'))) /* reading a new value=data pair */
599  {
600  processSetValue(stdInput, isUnicode);
601  } else
602  {
603  /* Since we are assuming that the file format is valid we must be
604  * reading a blank line which indicates the end of this key processing
605  */
606  closeKey();
607  }
608 }
#define ERROR_SUCCESS
Definition: deptool.c:10
static void processSetValue(WCHAR *line, BOOL is_unicode)
Definition: regproc.c:483
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
static HKEY currentKeyHandle
Definition: regproc.c:334
smooth NULL
Definition: ftsmooth.c:416
char * GetMultiByteString(const WCHAR *strW)
Definition: regproc.c:109
#define GetProcessHeap()
Definition: compat.h:395
__wchar_t WCHAR
Definition: xmlstorage.h:180
WINE_UNICODE_INLINE WCHAR * strrchrW(const WCHAR *str, WCHAR ch)
Definition: unicode.h:254
LPCWSTR getAppName(void)
Definition: regedit.c:61
static LONG openKeyW(WCHAR *stdInput)
Definition: regproc.c:426
FILE * stderr
static void closeKey(void)
Definition: regproc.c:465
#define HeapFree(x, y, z)
Definition: compat.h:394
void delete_registry_key(WCHAR *reg_key_name)
Definition: regproc.c:1432

Referenced by processRegLinesA(), and processRegLinesW().

◆ processRegLinesA()

static void processRegLinesA ( FILE in,
char first_chars 
)
static

Definition at line 618 of file regproc.c.

619 {
620  LPSTR line = NULL; /* line read from input stream */
621  ULONG lineSize = REG_VAL_BUF_SIZE;
622 
623  line = HeapAlloc(GetProcessHeap(), 0, lineSize);
625  memcpy(line, first_chars, 2);
626 
627  while (!feof(in)) {
628  LPSTR s; /* The pointer into line for where the current fgets should read */
629  WCHAR* lineW;
630  s = line;
631 
632  if(first_chars)
633  {
634  s += 2;
635  first_chars = NULL;
636  }
637 
638  for (;;) {
639  size_t size_remaining;
640  int size_to_get, i;
641  char *s_eol; /* various local uses */
642 
643  /* Do we need to expand the buffer ? */
644  assert (s >= line && s <= line + lineSize);
645  size_remaining = lineSize - (s-line);
646  if (size_remaining < 2) /* room for 1 character and the \0 */
647  {
648  char *new_buffer;
649  size_t new_size = lineSize + REG_VAL_BUF_SIZE;
650  if (new_size > lineSize) /* no arithmetic overflow */
651  new_buffer = HeapReAlloc (GetProcessHeap(), 0, line, new_size);
652  else
653  new_buffer = NULL;
654  CHECK_ENOUGH_MEMORY(new_buffer);
655  line = new_buffer;
656  s = line + lineSize - size_remaining;
657  lineSize = new_size;
658  size_remaining = lineSize - (s-line);
659  }
660 
661  /* Get as much as possible into the buffer, terminated either by
662  * eof, error, eol or getting the maximum amount. Abort on error.
663  */
664  size_to_get = (size_remaining > INT_MAX ? INT_MAX : size_remaining);
665 
666  /* get a single line. note that `i' must be one past the last
667  * meaningful character in `s' when this loop exits */
668  for(i = 0; i < size_to_get-1; ++i){
669  int xchar;
670 
671  xchar = fgetc(in);
672  s[i] = xchar;
673  if(xchar == EOF){
674  if(ferror(in)){
675  perror("While reading input");
676  exit(IO_ERROR);
677  }else
678  assert(feof(in));
679  break;
680  }
681  if(s[i] == '\r'){
682  /* read the next character iff it's \n */
683  if(i+2 >= size_to_get){
684  /* buffer too short, so put back the EOL char to
685  * read next cycle */
686  ungetc('\r', in);
687  break;
688  }
689  s[i+1] = fgetc(in);
690  if(s[i+1] != '\n'){
691  ungetc(s[i+1], in);
692  i = i+1;
693  }else
694  i = i+2;
695  break;
696  }
697  if(s[i] == '\n'){
698  i = i+1;
699  break;
700  }
701  }
702  s[i] = '\0';
703 
704  /* If we didn't read the eol nor the eof go around for the rest */
705  s_eol = strpbrk (s, "\r\n");
706  if (!feof (in) && !s_eol) {
707  s = strchr (s, '\0');
708  continue;
709  }
710 
711  /* If it is a comment line then discard it and go around again */
712  if (line [0] == '#' || line [0] == ';') {
713  s = line;
714  continue;
715  }
716 
717  /* Remove any line feed. Leave s_eol on the first \0 */
718  if (s_eol) {
719  if (*s_eol == '\r' && *(s_eol+1) == '\n')
720  *(s_eol+1) = '\0';
721  *s_eol = '\0';
722  } else
723  s_eol = strchr (s, '\0');
724 
725  /* If there is a concatenating \\ then go around again */
726  if (s_eol > line && *(s_eol-1) == '\\') {
727  int c;
728  s = s_eol-1;
729 
730  do
731  {
732  c = fgetc(in);
733  } while(c == ' ' || c == '\t');
734 
735  if(c == EOF)
736  {
737  fprintf(stderr,"%S: ERROR - invalid continuation.\n",
738  getAppName());
739  }
740  else
741  {
742  *s = c;
743  s++;
744  }
745  continue;
746  }
747 
748  lineW = GetWideString(line);
749 
750  break; /* That is the full virtual line */
751  }
752 
753  processRegEntry(lineW, FALSE);
754  HeapFree(GetProcessHeap(), 0, lineW);
755  }
757 
759 }
_Check_return_ _CRTIMP int __cdecl ferror(_In_ FILE *_File)
#define INT_MAX
Definition: limits.h:40
char * strpbrk(const char *String, const char *Delimiters)
Definition: utclib.c:302
WCHAR * GetWideString(const char *strA)
Definition: regproc.c:70
#define assert(x)
Definition: debug.h:53
char * LPSTR
Definition: xmlstorage.h:182
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
_CRTIMP void __cdecl perror(_In_opt_z_ const char *_ErrMsg)
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
static void processRegEntry(WCHAR *stdInput, BOOL isUnicode)
Definition: regproc.c:563
smooth NULL
Definition: ftsmooth.c:416
Definition: parser.c:48
_Check_return_opt_ _CRTIMP_ALT int __cdecl ungetc(_In_ int _Ch, _Inout_ FILE *_File)
_Check_return_ _CRTIMP int __cdecl feof(_In_ FILE *_File)
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
const GLubyte * c
Definition: glext.h:8905
char line[200]
Definition: main.c:97
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
GLdouble s
Definition: gl.h:2039
GLuint in
Definition: glext.h:9616
#define HeapReAlloc
Definition: compat.h:393
#define IO_ERROR
Definition: regproc.c:53
char * strchr(const char *String, int ch)
Definition: utclib.c:501
LPCWSTR getAppName(void)
Definition: regedit.c:61
#define EOF
Definition: stdio.h:24
#define c
Definition: ke_i.h:80
unsigned int ULONG
Definition: retypes.h:1
FILE * stderr
void exit(int exitcode)
Definition: _exit.c:33
#define REG_VAL_BUF_SIZE
Definition: regproc.c:31
#define CHECK_ENOUGH_MEMORY(p)
Definition: regproc.c:58
#define HeapFree(x, y, z)
Definition: compat.h:394
_Check_return_opt_ _CRTIMP int __cdecl fgetc(_Inout_ FILE *_File)

Referenced by import_registry_file().

◆ processRegLinesW()

static void processRegLinesW ( FILE in)
static

Definition at line 761 of file regproc.c.

762 {
763  WCHAR* buf = NULL; /* line read from input stream */
764  ULONG lineSize = REG_VAL_BUF_SIZE;
765  size_t CharsInBuf = -1;
766 
767  WCHAR* s; /* The pointer into buf for where the current fgets should read */
768  WCHAR* line; /* The start of the current line */
769 
770  buf = HeapAlloc(GetProcessHeap(), 0, lineSize * sizeof(WCHAR));
772 
773  s = buf;
774  line = buf;
775 
776  while(!feof(in)) {
777  size_t size_remaining;
778  int size_to_get;
779  WCHAR *s_eol = NULL; /* various local uses */
780 
781  /* Do we need to expand the buffer ? */
782  assert (s >= buf && s <= buf + lineSize);
783  size_remaining = lineSize - (s-buf);
784  if (size_remaining < 2) /* room for 1 character and the \0 */
785  {
786  WCHAR *new_buffer;
787  size_t new_size = lineSize + (REG_VAL_BUF_SIZE / sizeof(WCHAR));
788  if (new_size > lineSize) /* no arithmetic overflow */
789  new_buffer = HeapReAlloc (GetProcessHeap(), 0, buf, new_size * sizeof(WCHAR));
790  else
791  new_buffer = NULL;
792  CHECK_ENOUGH_MEMORY(new_buffer);
793  buf = new_buffer;
794  line = buf;
795  s = buf + lineSize - size_remaining;
796  lineSize = new_size;
797  size_remaining = lineSize - (s-buf);
798  }
799 
800  /* Get as much as possible into the buffer, terminated either by
801  * eof, error or getting the maximum amount. Abort on error.
802  */
803  size_to_get = (size_remaining > INT_MAX ? INT_MAX : size_remaining);
804 
805  CharsInBuf = fread(s, sizeof(WCHAR), size_to_get - 1, in);
806  s[CharsInBuf] = 0;
807 
808  if (CharsInBuf == 0) {
809  if (ferror(in)) {
810  perror ("While reading input");
811  exit (IO_ERROR);
812  } else {
813  assert (feof(in));
814  *s = '\0';
815  /* It is not clear to me from the definition that the
816  * contents of the buffer are well defined on detecting
817  * an eof without managing to read anything.
818  */
819  }
820  }
821 
822  /* If we didn't read the eol nor the eof go around for the rest */
823  while(1)
824  {
825  const WCHAR line_endings[] = {'\r','\n',0};
826  s_eol = strpbrkW(line, line_endings);
827 
828  if(!s_eol) {
829  /* Move the stub of the line to the start of the buffer so
830  * we get the maximum space to read into, and so we don't
831  * have to recalculate 'line' if the buffer expands */
832  MoveMemory(buf, line, (strlenW(line)+1) * sizeof(WCHAR));
833  line = buf;
834  s = strchrW(line, '\0');
835  break;
836  }
837 
838  /* If it is a comment line then discard it and go around again */
839  if (*line == '#' || *line == ';') {
840  if (*s_eol == '\r' && *(s_eol+1) == '\n')
841  line = s_eol + 2;
842  else
843  line = s_eol + 1;
844  continue;
845  }
846 
847  /* If there is a concatenating \\ then go around again */
848  if (*(s_eol-1) == '\\') {
849  WCHAR* NextLine = s_eol + 1;
850 
851  if(*s_eol == '\r' && *(s_eol+1) == '\n')
852  NextLine++;
853 
854  while(isspaceW(*NextLine))
855  NextLine++;
856 
857  if (!*NextLine)
858  {
859  s = NextLine;
860  break;
861  }
862 
863  MoveMemory(s_eol - 1, NextLine, (CharsInBuf - (NextLine - s) + 1)*sizeof(WCHAR));
864  CharsInBuf -= NextLine - s_eol + 1;
865  s_eol = 0;
866  continue;
867  }
868 
869  /* Remove any line feed. Leave s_eol on the last \0 */
870  if (*s_eol == '\r' && *(s_eol + 1) == '\n')
871  *s_eol++ = '\0';
872  *s_eol = '\0';
873 
875  line = s_eol + 1;
876  s_eol = 0;
877  continue; /* That is the full virtual line */
878  }
879  }
880 
882 
883  HeapFree(GetProcessHeap(), 0, buf);
884 }
_Check_return_ _CRTIMP int __cdecl ferror(_In_ FILE *_File)
#define TRUE
Definition: types.h:120
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
Definition: unicode.h:212
#define INT_MAX
Definition: limits.h:40
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
WINE_UNICODE_INLINE WCHAR * strchrW(const WCHAR *str, WCHAR ch)
Definition: unicode.h:248
WINE_UNICODE_INLINE int isspaceW(WCHAR wc)
Definition: unicode.h:165
#define assert(x)
Definition: debug.h:53
#define MoveMemory
Definition: winbase.h:1632
_Check_return_opt_ _CRTIMP size_t __cdecl fread(_Out_writes_bytes_(_ElementSize *_Count) void *_DstBuf, _In_ size_t _ElementSize, _In_ size_t _Count, _Inout_ FILE *_File)
_CRTIMP void __cdecl perror(_In_opt_z_ const char *_ErrMsg)
static void processRegEntry(WCHAR *stdInput, BOOL isUnicode)
Definition: regproc.c:563
smooth NULL
Definition: ftsmooth.c:416
Definition: parser.c:48
_Check_return_ _CRTIMP int __cdecl feof(_In_ FILE *_File)
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
__wchar_t WCHAR
Definition: xmlstorage.h:180
WINE_UNICODE_INLINE WCHAR * strpbrkW(const WCHAR *str, const WCHAR *accept)
Definition: unicode.h:261
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 IO_ERROR
Definition: regproc.c:53
unsigned int ULONG
Definition: retypes.h:1
void exit(int exitcode)
Definition: _exit.c:33
#define REG_VAL_BUF_SIZE
Definition: regproc.c:31
#define CHECK_ENOUGH_MEMORY(p)
Definition: regproc.c:58
#define HeapFree(x, y, z)
Definition: compat.h:394
BOOLEAN NextLine
Definition: bootvid.c:28

Referenced by import_registry_file().

◆ processSetValue()

static void processSetValue ( WCHAR line,
BOOL  is_unicode 
)
static

Definition at line 483 of file regproc.c.

484 {
485  WCHAR* val_name; /* registry value name */
486  WCHAR* val_data; /* registry value data */
487  int line_idx = 0; /* current character under analysis */
488  LONG res;
489 
490  /* get value name */
491  while ( isspaceW(line[line_idx]) ) line_idx++;
492  if (line[line_idx] == '@' && line[line_idx + 1] == '=') {
493  line[line_idx] = '\0';
494  val_name = line;
495  line_idx++;
496  } else if (line[line_idx] == '\"') {
497  line_idx++;
498  val_name = line + line_idx;
499  while (line[line_idx]) {
500  if (line[line_idx] == '\\') /* skip escaped character */
501  {
502  line_idx += 2;
503  } else {
504  if (line[line_idx] == '\"') {
505  line[line_idx] = '\0';
506  line_idx++;
507  break;
508  } else {
509  line_idx++;
510  }
511  }
512  }
513  while ( isspaceW(line[line_idx]) ) line_idx++;
514  if (!line[line_idx]) {
515  fprintf(stderr, "%S: warning: unexpected EOL\n", getAppName());
516  return;
517  }
518  if (line[line_idx] != '=') {
519  char* lineA;
520  line[line_idx] = '\"';
521  lineA = GetMultiByteString(line);
522  fprintf(stderr,"%S: warning: unrecognized line: '%s'\n", getAppName(), lineA);
523  HeapFree(GetProcessHeap(), 0, lineA);
524  return;
525  }
526 
527  } else {
528  char* lineA = GetMultiByteString(line);
529  fprintf(stderr,"%S: warning: unrecognized line: '%s'\n", getAppName(), lineA);
530  HeapFree(GetProcessHeap(), 0, lineA);
531  return;
532  }
533  line_idx++; /* skip the '=' character */
534 
535  while ( isspaceW(line[line_idx]) ) line_idx++;
536  val_data = line + line_idx;
537  /* trim trailing blanks */
538  line_idx = strlenW(val_data);
539  while (line_idx > 0 && isspaceW(val_data[line_idx-1])) line_idx--;
540  val_data[line_idx] = '\0';
541 
542  REGPROC_unescape_string(val_name);
543  res = setValue(val_name, val_data, is_unicode);
544  if ( res != ERROR_SUCCESS )
545  {
546  char* val_nameA = GetMultiByteString(val_name);
547  char* val_dataA = GetMultiByteString(val_data);
548  fprintf(stderr,"%S: ERROR Key %s not created. Value: %s, Data: %s\n",
549  getAppName(),
551  val_nameA,
552  val_dataA);
553  HeapFree(GetProcessHeap(), 0, val_nameA);
554  HeapFree(GetProcessHeap(), 0, val_dataA);
555  }
556 }
WINE_UNICODE_INLINE unsigned int strlenW(const WCHAR *str)
Definition: unicode.h:212
#define ERROR_SUCCESS
Definition: deptool.c:10
WINE_UNICODE_INLINE int isspaceW(WCHAR wc)
Definition: unicode.h:165
static LONG setValue(WCHAR *val_name, WCHAR *val_data, BOOL is_unicode)
Definition: regproc.c:344
static LPSTR currentKeyName
Definition: regproc.c:333
long LONG
Definition: pedump.c:60
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
Definition: parser.c:48
char * GetMultiByteString(const WCHAR *strW)
Definition: regproc.c:109
#define GetProcessHeap()
Definition: compat.h:395
__wchar_t WCHAR
Definition: xmlstorage.h:180
char line[200]
Definition: main.c:97
LPCWSTR getAppName(void)
Definition: regedit.c:61
GLuint res
Definition: glext.h:9613
FILE * stderr
static void REGPROC_unescape_string(WCHAR *str)
Definition: regproc.c:257
#define HeapFree(x, y, z)
Definition: compat.h:394

Referenced by processRegEntry().

◆ REGPROC_export_binary()

static void REGPROC_export_binary ( WCHAR **  line_buf,
DWORD line_buf_size,
DWORD line_len,
DWORD  type,
BYTE value,
DWORD  value_size,
BOOL  unicode 
)
static

Definition at line 992 of file regproc.c.

993 {
994  DWORD hex_pos, data_pos;
995  const WCHAR *hex_prefix;
996  const WCHAR hex[] = {'h','e','x',':',0};
997  WCHAR hex_buf[17];
998  const WCHAR concat[] = {'\\','\r','\n',' ',' ',0};
999  DWORD concat_prefix, concat_len;
1000  const WCHAR newline[] = {'\r','\n',0};
1001  CHAR* value_multibyte = NULL;
1002 
1003  if (type == REG_BINARY) {
1004  hex_prefix = hex;
1005  } else {
1006  const WCHAR hex_format[] = {'h','e','x','(','%','x',')',':',0};
1007  hex_prefix = hex_buf;
1008  sprintfW(hex_buf, hex_format, type);
1009  if ((type == REG_SZ || type == REG_EXPAND_SZ || type == REG_MULTI_SZ) && !unicode)
1010  {
1011  value_multibyte = GetMultiByteStringN((WCHAR*)value, value_size / sizeof(WCHAR), &value_size);
1012  value = (BYTE*)value_multibyte;
1013  }
1014  }
1015 
1016  concat_len = lstrlenW(concat);
1017  concat_prefix = 2;
1018 
1019  hex_pos = *line_len;
1020  *line_len += lstrlenW(hex_prefix);
1021  data_pos = *line_len;
1022  *line_len += value_size * 3;
1023  /* - The 2 spaces that concat places at the start of the
1024  * line effectively reduce the space available for data.
1025  * - If the value name and hex prefix are very long
1026  * ( > REG_FILE_HEX_LINE_LEN) or *line_len divides
1027  * without a remainder then we may overestimate
1028  * the needed number of lines by one. But that's ok.
1029  * - The trailing '\r' takes the place of a comma so
1030  * we only need to add 1 for the trailing '\n'
1031  */
1032  *line_len += *line_len / (REG_FILE_HEX_LINE_LEN - concat_prefix) * concat_len + 1;
1033  REGPROC_resize_char_buffer(line_buf, line_buf_size, *line_len);
1034  lstrcpyW(*line_buf + hex_pos, hex_prefix);
1035  if (value_size)
1036  {
1037  const WCHAR format[] = {'%','0','2','x',0};
1038  DWORD i, column;
1039 
1040  column = data_pos; /* no line wrap yet */
1041  i = 0;
1042  while (1)
1043  {
1044  sprintfW(*line_buf + data_pos, format, (unsigned int)value[i]);
1045  data_pos += 2;
1046  if (++i == value_size)
1047  break;
1048 
1049  (*line_buf)[data_pos++] = ',';
1050  column += 3;
1051 
1052  /* wrap the line */
1053  if (column >= REG_FILE_HEX_LINE_LEN) {
1054  lstrcpyW(*line_buf + data_pos, concat);
1055  data_pos += concat_len;
1056  column = concat_prefix;
1057  }
1058  }
1059  }
1060  lstrcpyW(*line_buf + data_pos, newline);
1061  HeapFree(GetProcessHeap(), 0, value_multibyte);
1062 }
#define REG_BINARY
Definition: nt_native.h:1496
char CHAR
Definition: xmlstorage.h:175
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
static const char hex[16]
Definition: profile.c:123
#define lstrlenW
Definition: compat.h:407
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546
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
#define REG_MULTI_SZ
Definition: nt_native.h:1501
smooth NULL
Definition: ftsmooth.c:416
static char * GetMultiByteStringN(const WCHAR *strW, int chars, DWORD *len)
Definition: regproc.c:128
#define REG_FILE_HEX_LINE_LEN
Definition: regproc.c:36
#define GetProcessHeap()
Definition: compat.h:395
__wchar_t WCHAR
Definition: xmlstorage.h:180
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned char BYTE
Definition: mem.h:68
#define lstrcpyW
Definition: compat.h:406
#define REG_EXPAND_SZ
Definition: nt_native.h:1494
#define sprintfW
Definition: unicode.h:58
static void newline(int)
Definition: ppl.yy.c:3768
GLenum GLenum GLvoid GLvoid * column
Definition: glext.h:5664
static void REGPROC_resize_char_buffer(WCHAR **buffer, DWORD *len, DWORD required_len)
Definition: regproc.c:921
#define HeapFree(x, y, z)
Definition: compat.h:394
#define REG_SZ
Definition: layer.c:22

Referenced by export_hkey().

◆ REGPROC_export_string()

static void REGPROC_export_string ( WCHAR **  line_buf,
DWORD line_buf_size,
DWORD line_len,
WCHAR str,
DWORD  str_len 
)
static

Definition at line 957 of file regproc.c.

958 {
959  DWORD i, pos;
960  DWORD extra = 0;
961 
962  REGPROC_resize_char_buffer(line_buf, line_buf_size, *line_len + str_len + 10);
963 
964  /* escaping characters */
965  pos = *line_len;
966  for (i = 0; i < str_len; i++) {
967  WCHAR c = str[i];
968  switch (c) {
969  case '\n':
970  extra++;
971  REGPROC_resize_char_buffer(line_buf, line_buf_size, *line_len + str_len + extra);
972  (*line_buf)[pos++] = '\\';
973  (*line_buf)[pos++] = 'n';
974  break;
975 
976  case '\\':
977  case '"':
978  extra++;
979  REGPROC_resize_char_buffer(line_buf, line_buf_size, *line_len + str_len + extra);
980  (*line_buf)[pos++] = '\\';
981  /* Fall through */
982 
983  default:
984  (*line_buf)[pos++] = c;
985  break;
986  }
987  }
988  (*line_buf)[pos] = '\0';
989  *line_len = pos;
990 }
#define str_len
Definition: treelist.c:89
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
Definition: id3.c:18
__wchar_t WCHAR
Definition: xmlstorage.h:180
const GLubyte * c
Definition: glext.h:8905
unsigned long DWORD
Definition: ntddk_ex.h:95
#define c
Definition: ke_i.h:80
static void REGPROC_resize_char_buffer(WCHAR **buffer, DWORD *len, DWORD required_len)
Definition: regproc.c:921

Referenced by export_hkey().

◆ REGPROC_open_export_file()

static FILE* REGPROC_open_export_file ( WCHAR file_name,
BOOL  unicode 
)
static

Definition at line 1268 of file regproc.c.

1269 {
1270  FILE *file;
1271  WCHAR dash = '-';
1272 
1273  if (strncmpW(file_name,&dash,1)==0) {
1274  file=stdout;
1276  } else
1277  {
1278  CHAR* file_nameA = GetMultiByteString(file_name);
1279  file = fopen(file_nameA, "wb");
1280  if (!file) {
1281  perror("");
1282  fprintf(stderr,"%S: Can't open file \"%s\"\n", getAppName(), file_nameA);
1283  HeapFree(GetProcessHeap(), 0, file_nameA);
1284  exit(1);
1285  }
1286  HeapFree(GetProcessHeap(), 0, file_nameA);
1287  }
1288  if(unicode)
1289  {
1290  const BYTE unicode_seq[] = {0xff,0xfe};
1291  const WCHAR header[] = {'W','i','n','d','o','w','s',' ','R','e','g','i','s','t','r','y',' ','E','d','i','t','o','r',' ','V','e','r','s','i','o','n',' ','5','.','0','0','\r','\n'};
1292  fwrite(unicode_seq, sizeof(BYTE), sizeof(unicode_seq)/sizeof(unicode_seq[0]), file);
1293  fwrite(header, sizeof(WCHAR), sizeof(header)/sizeof(header[0]), file);
1294  } else
1295  {
1296  fputs("REGEDIT4\r\n", file);
1297  }
1298 
1299  return file;
1300 }
#define _setmode(fd, mode)
Definition: cat.c:21
char CHAR
Definition: xmlstorage.h:175
_Check_return_opt_ _CRTIMP size_t __cdecl fwrite(_In_reads_bytes_(_Size *_Count) const void *_Str, _In_ size_t _Size, _In_ size_t _Count, _Inout_ FILE *_File)
FILE * stdout
WINE_UNICODE_INLINE int strncmpW(const WCHAR *str1, const WCHAR *str2, int n)
Definition: unicode.h:235
_CRTIMP void __cdecl perror(_In_opt_z_ const char *_ErrMsg)
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
char * GetMultiByteString(const WCHAR *strW)
Definition: regproc.c:109
#define GetProcessHeap()
Definition: compat.h:395
__wchar_t WCHAR
Definition: xmlstorage.h:180
const char file[]
Definition: icontest.c:11
#define _O_BINARY
Definition: cabinet.h:51
unsigned char BYTE
Definition: mem.h:68
_Check_return_ _CRTIMP FILE *__cdecl fopen(_In_z_ const char *_Filename, _In_z_ const char *_Mode)
static LPCWSTR file_name
Definition: protocol.c:146
LPCWSTR getAppName(void)
Definition: regedit.c:61
FILE * stderr
void exit(int exitcode)
Definition: _exit.c:33
_Check_return_ _CRTIMP int __cdecl _fileno(_In_ FILE *_File)
#define HeapFree(x, y, z)
Definition: compat.h:394
_Check_return_opt_ _CRTIMP int __cdecl fputs(_In_z_ const char *_Str, _Inout_ FILE *_File)
struct CFHEADER header
Definition: fdi.c:109
Definition: fci.c:126

Referenced by export_registry_key().

◆ REGPROC_print_error()

static void REGPROC_print_error ( void  )
static

Definition at line 892 of file regproc.c.

893 {
894  LPVOID lpMsgBuf;
896  int status;
897 
900  NULL, error_code, 0, (LPSTR) &lpMsgBuf, 0, NULL);
901  if (!status) {
902  fprintf(stderr,"%S: Cannot display message for error %lu, status %lu\n",
904  exit(1);
905  }
906  puts(lpMsgBuf);
907  LocalFree(lpMsgBuf);
908  exit(1);
909 }
DWORD WINAPI FormatMessageA(DWORD dwFlags, LPCVOID lpSource, DWORD dwMessageId, DWORD dwLanguageId, LPSTR lpBuffer, DWORD nSize, __ms_va_list *args)
Definition: format_msg.c:483
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
char * LPSTR
Definition: xmlstorage.h:182
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
#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
unsigned long DWORD
Definition: ntddk_ex.h:95
int puts(const char *string)
Definition: crtsupp.c:23
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1577
LPCWSTR getAppName(void)
Definition: regedit.c:61
FILE * stderr
void exit(int exitcode)
Definition: _exit.c:33
static SERVICE_STATUS status
Definition: service.c:31
Definition: ps.c:97

Referenced by export_hkey(), and export_registry_key().

◆ REGPROC_resize_binary_buffer()

static void REGPROC_resize_binary_buffer ( BYTE **  buffer,
DWORD size,
DWORD  required_size 
)
static

Definition at line 942 of file regproc.c.

943 {
944  if (required_size > *size) {
945  *size = required_size;
946  if (!*buffer)
947  *buffer = HeapAlloc(GetProcessHeap(), 0, *size);
948  else
951  }
952 }
GLuint buffer
Definition: glext.h:5915
GLsizeiptr size
Definition: glext.h:5919
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define HeapReAlloc
Definition: compat.h:393
#define CHECK_ENOUGH_MEMORY(p)
Definition: regproc.c:58

Referenced by export_hkey().

◆ REGPROC_resize_char_buffer()

static void REGPROC_resize_char_buffer ( WCHAR **  buffer,
DWORD len,
DWORD  required_len 
)
static

Definition at line 921 of file regproc.c.

922 {
923  required_len++;
924  if (required_len > *len) {
925  *len = required_len;
926  if (!*buffer)
927  *buffer = HeapAlloc(GetProcessHeap(), 0, *len * sizeof(**buffer));
928  else
929  *buffer = HeapReAlloc(GetProcessHeap(), 0, *buffer, *len * sizeof(**buffer));
931  }
932 }
GLuint buffer
Definition: glext.h:5915
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
GLenum GLsizei len
Definition: glext.h:6722
#define HeapReAlloc
Definition: compat.h:393
#define CHECK_ENOUGH_MEMORY(p)
Definition: regproc.c:58

Referenced by export_hkey(), export_registry_key(), REGPROC_export_binary(), and REGPROC_export_string().

◆ REGPROC_unescape_string()

static void REGPROC_unescape_string ( WCHAR str)
static

Definition at line 257 of file regproc.c.

258 {
259  int str_idx = 0; /* current character under analysis */
260  int val_idx = 0; /* the last character of the unescaped string */
261  int len = lstrlenW(str);
262  for (str_idx = 0; str_idx < len; str_idx++, val_idx++) {
263  if (str[str_idx] == '\\') {
264  str_idx++;
265  switch (str[str_idx]) {
266  case 'n':
267  str[val_idx] = '\n';
268  break;
269  case '\\':
270  case '"':
271  str[val_idx] = str[str_idx];
272  break;
273  default:
274  fprintf(stderr,"Warning! Unrecognized escape sequence: \\%c'\n",
275  str[str_idx]);
276  str[val_idx] = str[str_idx];
277  break;
278  }
279  } else {
280  str[val_idx] = str[str_idx];
281  }
282  }
283  str[val_idx] = '\0';
284 }
#define lstrlenW
Definition: compat.h:407
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
const WCHAR * str
GLenum GLsizei len
Definition: glext.h:6722
FILE * stderr

Referenced by processSetValue(), and setValue().

◆ REGPROC_write_line()

static void REGPROC_write_line ( FILE file,
const WCHAR str,
BOOL  unicode 
)
static

Definition at line 1067 of file regproc.c.

1068 {
1069  if(unicode)
1070  {
1071  fwrite(str, sizeof(WCHAR), lstrlenW(str), file);
1072  } else
1073  {
1074  char* strA = GetMultiByteString(str);
1075  fputs(strA, file);
1076  HeapFree(GetProcessHeap(), 0, strA);
1077  }
1078 }
char strA[12]
Definition: clipboard.c:2028
_Check_return_opt_ _CRTIMP size_t __cdecl fwrite(_In_reads_bytes_(_Size *_Count) const void *_Str, _In_ size_t _Size, _In_ size_t _Count, _Inout_ FILE *_File)
#define lstrlenW
Definition: compat.h:407
const WCHAR * str
char * GetMultiByteString(const WCHAR *strW)
Definition: regproc.c:109
#define GetProcessHeap()
Definition: compat.h:395
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define HeapFree(x, y, z)
Definition: compat.h:394
_Check_return_opt_ _CRTIMP int __cdecl fputs(_In_z_ const char *_Str, _Inout_ FILE *_File)
Definition: fci.c:126

Referenced by export_hkey().

◆ setValue()

static LONG setValue ( WCHAR val_name,
WCHAR val_data,
BOOL  is_unicode 
)
static

Definition at line 344 of file regproc.c.

345 {
346  LONG res;
347  DWORD dwDataType, dwParseType;
348  LPBYTE lpbData;
349  DWORD dwData, dwLen;
350  WCHAR del[] = {'-',0};
351 
352  if ( (val_name == NULL) || (val_data == NULL) )
354 
355  if (lstrcmpW(val_data, del) == 0)
356  {
358  return (res == ERROR_FILE_NOT_FOUND ? ERROR_SUCCESS : res);
359  }
360 
361  /* Get the data type stored into the value field */
362  dwDataType = getDataType(&val_data, &dwParseType);
363 
364  if (dwParseType == REG_SZ) /* no conversion for string */
365  {
366  REGPROC_unescape_string(val_data);
367  /* Compute dwLen after REGPROC_unescape_string because it may
368  * have changed the string length and we don't want to store
369  * the extra garbage in the registry.
370  */
371  dwLen = lstrlenW(val_data);
372  if(val_data[dwLen-1] != '"')
373  return ERROR_INVALID_DATA;
374  if (dwLen>0 && val_data[dwLen-1]=='"')
375  {
376  dwLen--;
377  val_data[dwLen]='\0';
378  }
379  lpbData = (BYTE*) val_data;
380  dwLen++; /* include terminating null */
381  dwLen = dwLen * sizeof(WCHAR); /* size is in bytes */
382  }
383  else if (dwParseType == REG_DWORD) /* Convert the dword types */
384  {
385  if (!convertHexToDWord(val_data, &dwData))
386  return ERROR_INVALID_DATA;
387  lpbData = (BYTE*)&dwData;
388  dwLen = sizeof(dwData);
389  }
390  else if (dwParseType == REG_BINARY) /* Convert the binary data */
391  {
392  lpbData = convertHexCSVToHex(val_data, &dwLen);
393  if (!lpbData)
394  return ERROR_INVALID_DATA;
395 
396  if((dwDataType == REG_MULTI_SZ || dwDataType == REG_EXPAND_SZ) && !is_unicode)
397  {
398  LPBYTE tmp = lpbData;
399  lpbData = (LPBYTE)GetWideStringN((char*)lpbData, dwLen, &dwLen);
400  dwLen *= sizeof(WCHAR);
401  HeapFree(GetProcessHeap(), 0, tmp);
402  }
403  }
404  else /* unknown format */
405  {
406  fprintf(stderr,"%S: ERROR, unknown data format\n", getAppName());
407  return ERROR_INVALID_DATA;
408  }
409 
412  val_name,
413  0, /* Reserved */
414  dwDataType,
415  lpbData,
416  dwLen);
417  if (dwParseType == REG_BINARY)
418  HeapFree(GetProcessHeap(), 0, lpbData);
419  return res;
420 }
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
static BYTE * convertHexCSVToHex(WCHAR *str, DWORD *size)
Definition: regproc.c:163
static WCHAR * GetWideStringN(const char *strA, int chars, DWORD *len)
Definition: regproc.c:89
#define ERROR_SUCCESS
Definition: deptool.c:10
#define REG_BINARY
Definition: nt_native.h:1496
int WINAPI lstrcmpW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:170
static HANDLE ULONG_PTR dwData
Definition: file.c:35
#define lstrlenW
Definition: compat.h:407
unsigned char * LPBYTE
Definition: typedefs.h:52
long LONG
Definition: pedump.c:60
_Check_return_opt_ _CRTIMP int __cdecl fprintf(_Inout_ FILE *_File, _In_z_ _Printf_format_string_ const char *_Format,...)
#define REG_MULTI_SZ
Definition: nt_native.h:1501
static HKEY currentKeyHandle
Definition: regproc.c:334
smooth NULL
Definition: ftsmooth.c:416
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
LONG WINAPI RegSetValueExW(_In_ HKEY hKey, _In_ LPCWSTR lpValueName, _In_ DWORD Reserved, _In_ DWORD dwType, _In_ CONST BYTE *lpData, _In_ DWORD cbData)
Definition: reg.c:4917
#define GetProcessHeap()
Definition: compat.h:395
__wchar_t WCHAR
Definition: xmlstorage.h:180
static BOOL convertHexToDWord(WCHAR *str, DWORD *dw)
Definition: regproc.c:147
unsigned long DWORD
Definition: ntddk_ex.h:95
unsigned char BYTE
Definition: mem.h:68
#define ERROR_INVALID_DATA
Definition: winerror.h:116
static VOID del(LPHIST_ENTRY item)
Definition: history.c:199
LONG WINAPI RegDeleteValueW(HKEY hKey, LPCWSTR lpValueName)
Definition: reg.c:2368
#define REG_EXPAND_SZ
Definition: nt_native.h:1494
LPCWSTR getAppName(void)
Definition: regedit.c:61
GLuint res
Definition: glext.h:9613
FILE * stderr
static void REGPROC_unescape_string(WCHAR *str)
Definition: regproc.c:257
#define REG_DWORD
Definition: sdbapi.c:596
#define HeapFree(x, y, z)
Definition: compat.h:394
static DWORD getDataType(LPWSTR *lpValue, DWORD *parse_type)
Definition: regproc.c:205
#define REG_SZ
Definition: layer.c:22

Referenced by processSetValue().

Variable Documentation

◆ currentKeyHandle

HKEY currentKeyHandle = NULL
static

Definition at line 334 of file regproc.c.

Referenced by closeKey(), openKeyW(), processRegEntry(), and setValue().

◆ currentKeyName

LPSTR currentKeyName
static

Definition at line 333 of file regproc.c.

Referenced by closeKey(), openKeyW(), and processSetValue().

◆ reg_class_keys

HKEY reg_class_keys[]
static
Initial value:
= {
}
#define HKEY_USERS
Definition: winreg.h:13
#define HKEY_CURRENT_USER
Definition: winreg.h:11
#define HKEY_DYN_DATA
Definition: winreg.h:16
#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 44 of file regproc.c.

Referenced by export_registry_key(), and parseKeyName().

◆ reg_class_namesW

const WCHAR* reg_class_namesW[]
Initial value:
=
{
L"HKEY_LOCAL_MACHINE", L"HKEY_USERS", L"HKEY_CLASSES_ROOT",
L"HKEY_CURRENT_CONFIG", L"HKEY_CURRENT_USER", L"HKEY_DYN_DATA"
}
static const WCHAR L[]
Definition: oid.c:1250

Definition at line 38 of file regproc.c.

Referenced by export_registry_key(), and parseKeyName().