ReactOS 0.4.15-dev-6057-gd708c79
Classes | Macros | Typedefs | Enumerations | Functions | Variables
regproc.c File Reference
#include <errno.h>
#include <fcntl.h>
#include <io.h>
#include <windows.h>
#include <commctrl.h>
#include "main.h"
Include dependency graph for regproc.c:

Go to the source code of this file.

Classes

struct  parser
 

Macros

#define REG_VAL_BUF_SIZE   4096
 
#define MAX_HEX_CHARS   77
 
#define MAX_SUBKEY_LEN   257
 

Typedefs

typedef WCHAR *(* parser_state_func) (struct parser *parser, WCHAR *pos)
 

Enumerations

enum  parser_state {
  HEADER , PARSE_WIN31_LINE , LINE_START , KEY_NAME ,
  DELETE_KEY , DEFAULT_VALUE_NAME , QUOTED_VALUE_NAME , DATA_START ,
  DELETE_VALUE , DATA_TYPE , STRING_DATA , DWORD_DATA ,
  HEX_DATA , EOL_BACKSLASH , HEX_MULTILINE , UNKNOWN_DATA ,
  SET_VALUE , NB_PARSER_STATES , HEADER , PARSE_WIN31_LINE ,
  LINE_START , KEY_NAME , DELETE_KEY , DEFAULT_VALUE_NAME ,
  QUOTED_VALUE_NAME , DATA_START , DELETE_VALUE , DATA_TYPE ,
  STRING_DATA , DWORD_DATA , HEX_DATA , EOL_BACKSLASH ,
  HEX_MULTILINE , UNKNOWN_DATA , SET_VALUE , NB_PARSER_STATES ,
  LINE_START , SECTION_NAME , KEY_NAME , VALUE_NAME ,
  EOL_BACKSLASH , QUOTES , LEADING_SPACES , TRAILING_SPACES ,
  COMMENT , NB_PARSER_STATES , LINE_START , SECTION_NAME ,
  KEY_NAME , VALUE_NAME , EOL_BACKSLASH , QUOTES ,
  LEADING_SPACES , TRAILING_SPACES , COMMENT , NB_PARSER_STATES ,
  LINE_START , SECTION_NAME , KEY_NAME , VALUE_NAME ,
  EOL_BACKSLASH , QUOTES , LEADING_SPACES , TRAILING_SPACES ,
  COMMENT , NB_PARSER_STATES
}
 
enum  reg_versions {
  REG_VERSION_31 , REG_VERSION_40 , REG_VERSION_50 , REG_VERSION_FUZZY ,
  REG_VERSION_INVALID , REG_VERSION_31 , REG_VERSION_40 , REG_VERSION_50 ,
  REG_VERSION_FUZZY , REG_VERSION_INVALID
}
 

Functions

static WCHAR * GetWideString (const char *strA)
 
static WCHAR * GetWideStringN (const char *strA, int chars, DWORD *len)
 
char * GetMultiByteString (const WCHAR *strW)
 
static char * GetMultiByteStringN (const WCHAR *strW, int chars, DWORD *len)
 
static WCHAR * header_state (struct parser *parser, WCHAR *pos)
 
static WCHAR * parse_win31_line_state (struct parser *parser, WCHAR *pos)
 
static WCHAR * line_start_state (struct parser *parser, WCHAR *pos)
 
static WCHAR * key_name_state (struct parser *parser, WCHAR *pos)
 
static WCHAR * delete_key_state (struct parser *parser, WCHAR *pos)
 
static WCHAR * default_value_name_state (struct parser *parser, WCHAR *pos)
 
static WCHAR * quoted_value_name_state (struct parser *parser, WCHAR *pos)
 
static WCHAR * data_start_state (struct parser *parser, WCHAR *pos)
 
static WCHAR * delete_value_state (struct parser *parser, WCHAR *pos)
 
static WCHAR * data_type_state (struct parser *parser, WCHAR *pos)
 
static WCHAR * string_data_state (struct parser *parser, WCHAR *pos)
 
static WCHAR * dword_data_state (struct parser *parser, WCHAR *pos)
 
static WCHAR * hex_data_state (struct parser *parser, WCHAR *pos)
 
static WCHAR * eol_backslash_state (struct parser *parser, WCHAR *pos)
 
static WCHAR * hex_multiline_state (struct parser *parser, WCHAR *pos)
 
static WCHAR * unknown_data_state (struct parser *parser, WCHAR *pos)
 
static WCHAR * set_value_state (struct parser *parser, WCHAR *pos)
 
static enum parser_state set_state (struct parser *parser, enum parser_state state)
 
static BOOL convert_hex_to_dword (WCHAR *str, DWORD *dw)
 
static BOOL convert_hex_csv_to_hex (struct parser *parser, WCHAR **str)
 
static BOOL parse_data_type (struct parser *parser, WCHAR **line)
 
static BOOL REGPROC_unescape_string (WCHAR *str, WCHAR **unparsed)
 
static HKEY parse_key_name (WCHAR *key_name, WCHAR **key_path)
 
static void close_key (struct parser *parser)
 
static LONG open_key (struct parser *parser, WCHAR *path)
 
static void free_parser_data (struct parser *parser)
 
static void prepare_hex_string_data (struct parser *parser)
 
static enum reg_versions parse_file_header (const WCHAR *s)
 
static WCHAR * get_lineA (FILE *fp)
 
static WCHAR * get_lineW (FILE *fp)
 
BOOL import_registry_file (FILE *reg_file)
 
void delete_registry_key (WCHAR *reg_key_name)
 
static void REGPROC_write_line (FILE *fp, const WCHAR *str, BOOL unicode)
 
static WCHAR * REGPROC_escape_string (WCHAR *str, size_t str_len, size_t *line_len)
 
static size_t export_value_name (FILE *fp, WCHAR *name, size_t len, BOOL unicode)
 
static void export_string_data (WCHAR **buf, WCHAR *data, size_t size)
 
static void export_dword_data (WCHAR **buf, DWORD *data)
 
static size_t export_hex_data_type (FILE *fp, DWORD type, BOOL unicode)
 
static void export_hex_data (FILE *fp, WCHAR **buf, DWORD type, DWORD line_len, void *data, DWORD size, BOOL unicode)
 
static void export_newline (FILE *fp, BOOL unicode)
 
static void export_data (FILE *fp, WCHAR *value_name, DWORD value_len, DWORD type, void *data, size_t size, BOOL unicode)
 
static WCHAR * build_subkey_path (WCHAR *path, DWORD path_len, WCHAR *subkey_name, DWORD subkey_len)
 
static void export_key_name (FILE *fp, WCHAR *name, BOOL unicode)
 
static void export_registry_data (FILE *fp, HKEY key, WCHAR *path, BOOL unicode)
 
static FILE * REGPROC_open_export_file (WCHAR *file_name, BOOL unicode)
 
static HKEY open_export_key (HKEY key_class, WCHAR *subkey, WCHAR *path)
 
static BOOL export_key (WCHAR *file_name, WCHAR *path, BOOL unicode)
 
static BOOL export_all (WCHAR *file_name, WCHAR *path, BOOL unicode)
 
BOOL export_registry_key (WCHAR *file_name, WCHAR *path, DWORD format)
 

Variables

static HKEY reg_class_keys []
 
static WCHAR *(* get_line )(FILE *)
 
static const parser_state_func parser_funcs [NB_PARSER_STATES]
 

Macro Definition Documentation

◆ MAX_HEX_CHARS

#define MAX_HEX_CHARS   77

Definition at line 1263 of file regproc.c.

◆ MAX_SUBKEY_LEN

#define MAX_SUBKEY_LEN   257

Definition at line 1371 of file regproc.c.

◆ REG_VAL_BUF_SIZE

#define REG_VAL_BUF_SIZE   4096

Definition at line 38 of file regproc.c.

Typedef Documentation

◆ parser_state_func

typedef WCHAR *(* parser_state_func) (struct parser *parser, WCHAR *pos)

Definition at line 161 of file regproc.c.

Enumeration Type Documentation

◆ parser_state

enum parser_state
Enumerator
HEADER 
PARSE_WIN31_LINE 
LINE_START 
KEY_NAME 
DELETE_KEY 
DEFAULT_VALUE_NAME 
QUOTED_VALUE_NAME 
DATA_START 
DELETE_VALUE 
DATA_TYPE 
STRING_DATA 
DWORD_DATA 
HEX_DATA 
EOL_BACKSLASH 
HEX_MULTILINE 
UNKNOWN_DATA 
SET_VALUE 
NB_PARSER_STATES 
HEADER 
PARSE_WIN31_LINE 
LINE_START 
KEY_NAME 
DELETE_KEY 
DEFAULT_VALUE_NAME 
QUOTED_VALUE_NAME 
DATA_START 
DELETE_VALUE 
DATA_TYPE 
STRING_DATA 
DWORD_DATA 
HEX_DATA 
EOL_BACKSLASH 
HEX_MULTILINE 
UNKNOWN_DATA 
SET_VALUE 
NB_PARSER_STATES 
LINE_START 
SECTION_NAME 
KEY_NAME 
VALUE_NAME 
EOL_BACKSLASH 
QUOTES 
LEADING_SPACES 
TRAILING_SPACES 
COMMENT 
NB_PARSER_STATES 
LINE_START 
SECTION_NAME 
KEY_NAME 
VALUE_NAME 
EOL_BACKSLASH 
QUOTES 
LEADING_SPACES 
TRAILING_SPACES 
COMMENT 
NB_PARSER_STATES 
LINE_START 
SECTION_NAME 
KEY_NAME 
VALUE_NAME 
EOL_BACKSLASH 
QUOTES 
LEADING_SPACES 
TRAILING_SPACES 
COMMENT 
NB_PARSER_STATES 

Definition at line 122 of file regproc.c.

123{
124 HEADER, /* parsing the registry file version header */
125 PARSE_WIN31_LINE, /* parsing a Windows 3.1 registry line */
126 LINE_START, /* at the beginning of a registry line */
127 KEY_NAME, /* parsing a key name */
128 DELETE_KEY, /* deleting a registry key */
129 DEFAULT_VALUE_NAME, /* parsing a default value name */
130 QUOTED_VALUE_NAME, /* parsing a double-quoted value name */
131 DATA_START, /* preparing for data parsing operations */
132 DELETE_VALUE, /* deleting a registry value */
133 DATA_TYPE, /* parsing the registry data type */
134 STRING_DATA, /* parsing REG_SZ data */
135 DWORD_DATA, /* parsing DWORD data */
136 HEX_DATA, /* parsing REG_BINARY, REG_NONE, REG_EXPAND_SZ or REG_MULTI_SZ data */
137 EOL_BACKSLASH, /* preparing to parse multiple lines of hex data */
138 HEX_MULTILINE, /* parsing multiple lines of hex data */
139 UNKNOWN_DATA, /* parsing an unhandled or invalid data type */
140 SET_VALUE, /* adding a value to the registry */
141 NB_PARSER_STATES
142};
PARSE_WIN31_LINE
@ PARSE_WIN31_LINE
Definition: regproc.c:125
HEX_DATA
@ HEX_DATA
Definition: regproc.c:136
DEFAULT_VALUE_NAME
@ DEFAULT_VALUE_NAME
Definition: regproc.c:129
HEADER
@ HEADER
Definition: regproc.c:124
NB_PARSER_STATES
@ NB_PARSER_STATES
Definition: regproc.c:141
STRING_DATA
@ STRING_DATA
Definition: regproc.c:134
QUOTED_VALUE_NAME
@ QUOTED_VALUE_NAME
Definition: regproc.c:130
DATA_TYPE
@ DATA_TYPE
Definition: regproc.c:133
HEX_MULTILINE
@ HEX_MULTILINE
Definition: regproc.c:138
UNKNOWN_DATA
@ UNKNOWN_DATA
Definition: regproc.c:139
LINE_START
@ LINE_START
Definition: regproc.c:126
EOL_BACKSLASH
@ EOL_BACKSLASH
Definition: regproc.c:137
SET_VALUE
@ SET_VALUE
Definition: regproc.c:140
DELETE_VALUE
@ DELETE_VALUE
Definition: regproc.c:132
DWORD_DATA
@ DWORD_DATA
Definition: regproc.c:135
KEY_NAME
@ KEY_NAME
Definition: regproc.c:127
DATA_START
@ DATA_START
Definition: regproc.c:131
DELETE_KEY
@ DELETE_KEY
Definition: regproc.c:128

◆ reg_versions

enum reg_versions
Enumerator
REG_VERSION_31 
REG_VERSION_40 
REG_VERSION_50 
REG_VERSION_FUZZY 
REG_VERSION_INVALID 
REG_VERSION_31 
REG_VERSION_40 
REG_VERSION_50 
REG_VERSION_FUZZY 
REG_VERSION_INVALID 

Definition at line 512 of file regproc.c.

512 {
513 REG_VERSION_31,
514 REG_VERSION_40,
515 REG_VERSION_50,
516 REG_VERSION_FUZZY,
517 REG_VERSION_INVALID
518};
REG_VERSION_50
@ REG_VERSION_50
Definition: regproc.c:515
REG_VERSION_INVALID
@ REG_VERSION_INVALID
Definition: regproc.c:517
REG_VERSION_40
@ REG_VERSION_40
Definition: regproc.c:514
REG_VERSION_FUZZY
@ REG_VERSION_FUZZY
Definition: regproc.c:516
REG_VERSION_31
@ REG_VERSION_31
Definition: regproc.c:513

Function Documentation

◆ build_subkey_path()

static WCHAR * build_subkey_path ( WCHAR *  path,
DWORD  path_len,
WCHAR *  subkey_name,
DWORD  subkey_len 
)
static

Definition at line 1343 of file regproc.c.

1344{
1345 WCHAR *subkey_path;
1346
1347 subkey_path = malloc((path_len + subkey_len + 2) * sizeof(WCHAR));
1348#ifdef __REACTOS__
1349 swprintf(subkey_path, L"%s\\%s", path, subkey_name);
1350#else
1351 swprintf(subkey_path, path_len + subkey_len + 2, L"%s\\%s", path, subkey_name);
1352#endif
1353
1354 return subkey_path;
1355}
malloc
#define malloc
Definition: debug_ros.c:4
swprintf
#define swprintf
Definition: precomp.h:40
path_len
static DWORD path_len
Definition: batch.c:31
L
#define L(x)
Definition: ntvdm.h:50
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by export_registry_data().

◆ close_key()

static void close_key ( struct parser *  parser)
static

Definition at line 428 of file regproc.c.

429{
430 if (parser->hkey)
431 {
432 free(parser->key_name);
433 parser->key_name = NULL;
434
435 RegCloseKey(parser->hkey);
436 parser->hkey = NULL;
437 }
438}
RegCloseKey
#define RegCloseKey(hKey)
Definition: registry.h:47
free
#define free
Definition: debug_ros.c:5
NULL
#define NULL
Definition: types.h:112
parser
Definition: import.c:81
parser::hkey
HKEY hkey
Definition: import.c:87
parser::key_name
WCHAR * key_name
Definition: import.c:88

◆ convert_hex_csv_to_hex()

static BOOL convert_hex_csv_to_hex ( struct parser *  parser,
WCHAR **  str 
)
static

Definition at line 248 of file regproc.c.

249{
250 size_t size;
251 BYTE *d;
252 WCHAR *s;
253
254 parser->backslash = FALSE;
255
256 /* The worst case is 1 digit + 1 comma per byte */
257 size = ((lstrlenW(*str) + 1) / 2) + parser->data_size;
258 parser->data = realloc(parser->data, size);
259
260 s = *str;
261 d = (BYTE *)parser->data + parser->data_size;
262
263 while (*s)
264 {
265 WCHAR *end;
266 unsigned long wc;
267
268 wc = wcstoul(s, &end, 16);
269 if (wc > 0xff) return FALSE;
270
271 if (s == end && wc == 0)
272 {
273 while (*end == ' ' || *end == '\t') end++;
274 if (*end == '\\')
275 {
276 parser->backslash = TRUE;
277 *str = end + 1;
278 return TRUE;
279 }
280 else if (*end == ';')
281 return TRUE;
282 return FALSE;
283 }
284
285 *d++ = wc;
286 parser->data_size++;
287
288 if (*end && *end != ',')
289 {
290 while (*end == ' ' || *end == '\t') end++;
291 if (*end && *end != ';') return FALSE;
292 return TRUE;
293 }
294
295 if (*end) end++;
296 s = end;
297 }
298
299 return TRUE;
300}
while
while(CdLookupNextInitialFileDirent(IrpContext, Fcb, FileContext))
realloc
#define realloc
Definition: debug_ros.c:6
TRUE
#define TRUE
Definition: types.h:120
FALSE
#define FALSE
Definition: types.h:117
lstrlenW
#define lstrlenW
Definition: compat.h:750
s
GLdouble s
Definition: gl.h:2039
end
GLuint GLuint end
Definition: gl.h:1545
size
GLsizeiptr size
Definition: glext.h:5919
wcstoul
_Check_return_ unsigned long __cdecl wcstoul(_In_z_ const wchar_t *_Str, _Out_opt_ _Deref_post_z_ wchar_t **_EndPtr, _In_ int _Radix)
d
#define d
Definition: ke_i.h:81
str
const WCHAR * str
Definition: rpc_transport.c:2724
parser::backslash
BOOL backslash
Definition: import.c:94
parser::data_size
DWORD data_size
Definition: import.c:93
parser::data
void * data
Definition: import.c:92
BYTE
unsigned char BYTE
Definition: xxhash.c:193

Referenced by hex_data_state().

◆ convert_hex_to_dword()

static BOOL convert_hex_to_dword ( WCHAR *  str,
DWORD *  dw 
)
static

Definition at line 214 of file regproc.c.

215{
216 WCHAR *p, *end;
217 int count = 0;
218
219 while (*str == ' ' || *str == '\t') str++;
220 if (!*str) goto error;
221
222 p = str;
223 while (iswxdigit(*p))
224 {
225 count++;
226 p++;
227 }
228 if (count > 8) goto error;
229
230 end = p;
231 while (*p == ' ' || *p == '\t') p++;
232 if (*p && *p != ';') goto error;
233
234 *end = 0;
235 *dw = wcstoul(str, &end, 16);
236 return TRUE;
237
238error:
239 return FALSE;
240}
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
p
GLfloat GLfloat p
Definition: glext.h:8902
iswxdigit
#define iswxdigit(_c)
Definition: ctype.h:668
dw
REFIID LPVOID DWORD_PTR dw
Definition: atlbase.h:40
error
#define error(str)
Definition: mkdosfs.c:1605

Referenced by dword_data_state().

◆ data_start_state()

static WCHAR * data_start_state ( struct parser *  parser,
WCHAR *  pos 
)
static

Definition at line 724 of file regproc.c.

725{
726 WCHAR *p = pos;
727 unsigned int len;
728
729 while (*p == ' ' || *p == '\t') p++;
730 if (*p != '=') goto done;
731 p++;
732 while (*p == ' ' || *p == '\t') p++;
733
734 /* trim trailing whitespace */
735 len = lstrlenW(p);
736 while (len > 0 && (p[len - 1] == ' ' || p[len - 1] == '\t')) len--;
737 p[len] = 0;
738
739 if (*p == '-')
740 set_state(parser, DELETE_VALUE);
741 else
742 set_state(parser, DATA_TYPE);
743 return p;
744
745done:
746 set_state(parser, LINE_START);
747 return p;
748}
set_state
static enum parser_state set_state(struct parser *parser, enum parser_state state)
Definition: regproc.c:204
len
GLenum GLsizei len
Definition: glext.h:6722

◆ data_type_state()

static WCHAR * data_type_state ( struct parser *  parser,
WCHAR *  pos 
)
static

Definition at line 766 of file regproc.c.

767{
768 WCHAR *line = pos;
769
770 if (!parse_data_type(parser, &line))
771 {
772 set_state(parser, LINE_START);
773 return line;
774 }
775
776 switch (parser->parse_type)
777 {
778 case REG_SZ:
779 set_state(parser, STRING_DATA);
780 break;
781 case REG_DWORD:
782 set_state(parser, DWORD_DATA);
783 break;
784 case REG_BINARY: /* all hex data types, including undefined */
785 set_state(parser, HEX_DATA);
786 break;
787 default:
788 set_state(parser, UNKNOWN_DATA);
789 }
790
791 return line;
792}
parse_data_type
static BOOL parse_data_type(struct parser *parser, WCHAR **line)
Definition: regproc.c:308
REG_SZ
#define REG_SZ
Definition: layer.c:22
REG_BINARY
#define REG_BINARY
Definition: nt_native.h:1496
REG_DWORD
#define REG_DWORD
Definition: sdbapi.c:596
line
Definition: parser.c:49
parser::parse_type
DWORD parse_type
Definition: import.c:90

◆ default_value_name_state()

static WCHAR * default_value_name_state ( struct parser *  parser,
WCHAR *  pos 
)
static

Definition at line 691 of file regproc.c.

692{
693 free(parser->value_name);
694 parser->value_name = NULL;
695
696 set_state(parser, DATA_START);
697 return pos + 1;
698}
parser::value_name
WCHAR * value_name
Definition: import.c:89

◆ delete_key_state()

static WCHAR * delete_key_state ( struct parser *  parser,
WCHAR *  pos 
)
static

Definition at line 677 of file regproc.c.

678{
679 WCHAR *p = pos;
680
681 close_key(parser);
682
683 if (*p == 'H' || *p == 'h')
684 delete_registry_key(p);
685
686 set_state(parser, LINE_START);
687 return p;
688}
delete_registry_key
void delete_registry_key(WCHAR *reg_key_name)
Definition: regproc.c:1097
close_key
#define close_key(k)
Definition: reg_test.h:52

◆ delete_registry_key()

void delete_registry_key ( WCHAR *  reg_key_name)

Definition at line 1097 of file regproc.c.

1098{
1099 WCHAR *key_name = NULL;
1100 HKEY key_class;
1101
1102 if (!reg_key_name || !reg_key_name[0])
1103 return;
1104
1105 if (!(key_class = parse_key_name(reg_key_name, &key_name)))
1106 {
1107 if (key_name) *(key_name - 1) = 0;
1108 error_exit(STRING_INVALID_SYSTEM_KEY, reg_key_name);
1109 }
1110
1111 if (!key_name || !*key_name)
1112 error_exit(STRING_DELETE_FAILED, reg_key_name);
1113
1114#ifdef __REACTOS__
1115 SHDeleteKey(key_class, key_name);
1116#else
1117 RegDeleteTreeW(key_class, key_name);
1118#endif
1119}
STRING_INVALID_SYSTEM_KEY
#define STRING_INVALID_SYSTEM_KEY
Definition: resource.h:54
error_exit
void WINAPIV error_exit(unsigned int id,...)
Definition: regedit.c:103
parse_key_name
static HKEY parse_key_name(WCHAR *key_name, WCHAR **key_path)
Definition: regproc.c:402
STRING_DELETE_FAILED
#define STRING_DELETE_FAILED
Definition: resource.h:323
RegDeleteTreeW
LSTATUS WINAPI RegDeleteTreeW(HKEY hKey, LPCWSTR lpszSubKey)
Definition: reg.c:1743
SHDeleteKey
#define SHDeleteKey
Definition: shlwapi.h:44
key_name
Definition: registry.c:449

Referenced by delete_key_state(), and PerformRegAction().

◆ delete_value_state()

static WCHAR * delete_value_state ( struct parser *  parser,
WCHAR *  pos 
)
static

Definition at line 751 of file regproc.c.

752{
753 WCHAR *p = pos + 1;
754
755 while (*p == ' ' || *p == '\t') p++;
756 if (*p && *p != ';') goto done;
757
758 RegDeleteValueW(parser->hkey, parser->value_name);
759
760done:
761 set_state(parser, LINE_START);
762 return p;
763}
RegDeleteValueW
LONG WINAPI RegDeleteValueW(HKEY hKey, LPCWSTR lpValueName)
Definition: reg.c:2352

◆ dword_data_state()

static WCHAR * dword_data_state ( struct parser *  parser,
WCHAR *  pos 
)
static

Definition at line 819 of file regproc.c.

820{
821 WCHAR *line = pos;
822
823 parser->data = malloc(sizeof(DWORD));
824
825 if (!convert_hex_to_dword(line, parser->data))
826 goto invalid;
827
828 parser->data_size = sizeof(DWORD);
829
830 set_state(parser, SET_VALUE);
831 return line;
832
833invalid:
834 free_parser_data(parser);
835 set_state(parser, LINE_START);
836 return line;
837}
convert_hex_to_dword
static BOOL convert_hex_to_dword(WCHAR *str, DWORD *dw)
Definition: regproc.c:214
free_parser_data
static void free_parser_data(struct parser *parser)
Definition: regproc.c:470
DWORD
unsigned long DWORD
Definition: ntddk_ex.h:95
invalid
static const WCHAR invalid[]
Definition: assoc.c:39
DWORD
#define DWORD
Definition: nt_native.h:44

◆ eol_backslash_state()

static WCHAR * eol_backslash_state ( struct parser *  parser,
WCHAR *  pos 
)
static

Definition at line 869 of file regproc.c.

870{
871 WCHAR *p = pos;
872
873 while (*p == ' ' || *p == '\t') p++;
874 if (*p && *p != ';') goto invalid;
875
876 set_state(parser, HEX_MULTILINE);
877 return pos;
878
879invalid:
880 free_parser_data(parser);
881 set_state(parser, LINE_START);
882 return p;
883}

◆ export_all()

static BOOL export_all ( WCHAR *  file_name,
WCHAR *  path,
BOOL  unicode 
)
static

Definition at line 1514 of file regproc.c.

1515{
1516 FILE *fp;
1517 int i;
1518 HKEY classes[] = {HKEY_LOCAL_MACHINE, HKEY_USERS}, key;
1519 WCHAR *class_name;
1520
1521 fp = REGPROC_open_export_file(file_name, unicode);
1522
1523 for (i = 0; i < ARRAY_SIZE(classes); i++)
1524 {
1525 if (!(key = open_export_key(classes[i], NULL, path)))
1526 {
1527 fclose(fp);
1528 return FALSE;
1529 }
1530
1531 class_name = malloc((lstrlenW(reg_class_namesW[i]) + 1) * sizeof(WCHAR));
1532 lstrcpyW(class_name, reg_class_namesW[i]);
1533
1534 export_registry_data(fp, classes[i], class_name, unicode);
1535
1536 free(class_name);
1537 RegCloseKey(key);
1538 }
1539
1540 export_newline(fp, unicode);
1541 fclose(fp);
1542
1543 return TRUE;
1544}
reg_class_namesW
const WCHAR * reg_class_namesW[]
Definition: main.c:25
ARRAY_SIZE
#define ARRAY_SIZE(A)
Definition: main.h:33
export_newline
static void export_newline(FILE *fp, BOOL unicode)
Definition: regproc.c:1302
export_registry_data
static void export_registry_data(FILE *fp, HKEY key, WCHAR *path, BOOL unicode)
Definition: regproc.c:1373
REGPROC_open_export_file
static FILE * REGPROC_open_export_file(WCHAR *file_name, BOOL unicode)
Definition: regproc.c:1445
open_export_key
static HKEY open_export_key(HKEY key_class, WCHAR *subkey, WCHAR *path)
Definition: regproc.c:1478
lstrcpyW
#define lstrcpyW
Definition: compat.h:749
i
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
fclose
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
file_name
static LPCWSTR file_name
Definition: protocol.c:147
_iobuf
Definition: mbstring.h:19
key
Definition: copy.c:22
HKEY_LOCAL_MACHINE
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12
HKEY_USERS
#define HKEY_USERS
Definition: winreg.h:13

Referenced by export_registry_key().

◆ export_data()

static void export_data ( FILE *  fp,
WCHAR *  value_name,
DWORD  value_len,
DWORD  type,
void *  data,
size_t  size,
BOOL  unicode 
)
static

Definition at line 1307 of file regproc.c.

1309{
1310 WCHAR *buf = NULL;
1311 size_t line_len = export_value_name(fp, value_name, value_len, unicode);
1312
1313 switch (type)
1314 {
1315 case REG_SZ:
1316 export_string_data(&buf, data, size);
1317 break;
1318 case REG_DWORD:
1319 if (size)
1320 {
1321 export_dword_data(&buf, data);
1322 break;
1323 }
1324 /* fall through */
1325 case REG_NONE:
1326 case REG_EXPAND_SZ:
1327 case REG_BINARY:
1328 case REG_MULTI_SZ:
1329 default:
1330 export_hex_data(fp, &buf, type, line_len, data, size, unicode);
1331 break;
1332 }
1333
1334 if (size || type == REG_SZ)
1335 {
1336 REGPROC_write_line(fp, buf, unicode);
1337 free(buf);
1338 }
1339
1340 export_newline(fp, unicode);
1341}
export_dword_data
static void export_dword_data(WCHAR **buf, DWORD *data)
Definition: regproc.c:1228
export_string_data
static void export_string_data(WCHAR **buf, WCHAR *data, size_t size)
Definition: regproc.c:1211
export_hex_data
static void export_hex_data(FILE *fp, WCHAR **buf, DWORD type, DWORD line_len, void *data, DWORD size, BOOL unicode)
Definition: regproc.c:1265
export_value_name
static size_t export_value_name(FILE *fp, WCHAR *name, size_t len, BOOL unicode)
Definition: regproc.c:1184
REGPROC_write_line
static void REGPROC_write_line(FILE *fp, const WCHAR *str, BOOL unicode)
Definition: regproc.c:1121
type
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
REG_MULTI_SZ
#define REG_MULTI_SZ
Definition: nt_native.h:1501
REG_NONE
#define REG_NONE
Definition: nt_native.h:1492
REG_EXPAND_SZ
#define REG_EXPAND_SZ
Definition: nt_native.h:1494

Referenced by export_registry_data().

◆ export_dword_data()

static void export_dword_data ( WCHAR **  buf,
DWORD *  data 
)
static

Definition at line 1228 of file regproc.c.

1229{
1230 *buf = malloc(15 * sizeof(WCHAR));
1231#ifdef __REACTOS__
1232 swprintf(*buf, L"dword:%08x", *data);
1233#else
1234 swprintf(*buf, 15, L"dword:%08x", *data);
1235#endif
1236}

Referenced by export_data().

◆ export_hex_data()

static void export_hex_data ( FILE *  fp,
WCHAR **  buf,
DWORD  type,
DWORD  line_len,
void *  data,
DWORD  size,
BOOL  unicode 
)
static

Definition at line 1265 of file regproc.c.

1267{
1268 size_t num_commas, i, pos;
1269
1270 line_len += export_hex_data_type(fp, type, unicode);
1271
1272 if (!size) return;
1273
1274 if (!unicode && (type == REG_EXPAND_SZ || type == REG_MULTI_SZ))
1275 data = GetMultiByteStringN(data, size / sizeof(WCHAR), &size);
1276
1277 num_commas = size - 1;
1278 *buf = malloc(size * 3 * sizeof(WCHAR));
1279
1280 for (i = 0, pos = 0; i < size; i++)
1281 {
1282#ifdef __REACTOS__
1283 pos += swprintf(*buf + pos, L"%02x", ((BYTE *)data)[i]);
1284#else
1285 pos += swprintf(*buf + pos, 3, L"%02x", ((BYTE *)data)[i]);
1286#endif
1287 if (i == num_commas) break;
1288 (*buf)[pos++] = ',';
1289 (*buf)[pos] = 0;
1290 line_len += 3;
1291
1292 if (line_len >= MAX_HEX_CHARS)
1293 {
1294 REGPROC_write_line(fp, *buf, unicode);
1295 REGPROC_write_line(fp, L"\\\r\n ", unicode);
1296 line_len = 2;
1297 pos = 0;
1298 }
1299 }
1300}
MAX_HEX_CHARS
#define MAX_HEX_CHARS
Definition: regproc.c:1263
GetMultiByteStringN
static char * GetMultiByteStringN(const WCHAR *strW, int chars, DWORD *len)
Definition: regproc.c:104
export_hex_data_type
static size_t export_hex_data_type(FILE *fp, DWORD type, BOOL unicode)
Definition: regproc.c:1238

Referenced by export_data().

◆ export_hex_data_type()

static size_t export_hex_data_type ( FILE *  fp,
DWORD  type,
BOOL  unicode 
)
static

Definition at line 1238 of file regproc.c.

1239{
1240 static const WCHAR hex[] = L"hex:";
1241 size_t line_len;
1242
1243 if (type == REG_BINARY)
1244 {
1245 line_len = lstrlenW(hex);
1246 REGPROC_write_line(fp, hex, unicode);
1247 }
1248 else
1249 {
1250 WCHAR *buf = malloc(15 * sizeof(WCHAR));
1251#ifdef __REACTOS__
1252 line_len = swprintf(buf, L"hex(%x):", type);
1253#else
1254 line_len = swprintf(buf, 15, L"hex(%x):", type);
1255#endif
1256 REGPROC_write_line(fp, buf, unicode);
1257 free(buf);
1258 }
1259
1260 return line_len;
1261}
hex
int hex(char ch)
Definition: i386-stub-win32.c:512

Referenced by export_hex_data().

◆ export_key()

static BOOL export_key ( WCHAR *  file_name,
WCHAR *  path,
BOOL  unicode 
)
static

Definition at line 1489 of file regproc.c.

1490{
1491 HKEY key_class, key;
1492 WCHAR *subkey;
1493 FILE *fp;
1494
1495 if (!(key_class = parse_key_name(path, &subkey)))
1496 {
1497 if (subkey) *(subkey - 1) = 0;
1498 output_message(STRING_INVALID_SYSTEM_KEY, path);
1499 return FALSE;
1500 }
1501
1502 if (!(key = open_export_key(key_class, subkey, path)))
1503 return FALSE;
1504
1505 fp = REGPROC_open_export_file(file_name, unicode);
1506 export_registry_data(fp, key, path, unicode);
1507 export_newline(fp, unicode);
1508 fclose(fp);
1509
1510 RegCloseKey(key);
1511 return TRUE;
1512}
output_message
void WINAPIV output_message(unsigned int id,...)
Definition: reg.c:92

Referenced by export_registry_key().

◆ export_key_name()

static void export_key_name ( FILE *  fp,
WCHAR *  name,
BOOL  unicode 
)
static

Definition at line 1357 of file regproc.c.

1358{
1359 WCHAR *buf;
1360
1361 buf = malloc((lstrlenW(name) + 7) * sizeof(WCHAR));
1362#ifdef __REACTOS__
1363 swprintf(buf, L"\r\n[%s]\r\n", name);
1364#else
1365 swprintf(buf, lstrlenW(name) + 7, L"\r\n[%s]\r\n", name);
1366#endif
1367 REGPROC_write_line(fp, buf, unicode);
1368 free(buf);
1369}
name
Definition: name.c:39

Referenced by export_registry_data().

◆ export_newline()

static void export_newline ( FILE *  fp,
BOOL  unicode 
)
static

Definition at line 1302 of file regproc.c.

1303{
1304 REGPROC_write_line(fp, L"\r\n", unicode);
1305}

Referenced by export_all(), export_data(), and export_key().

◆ export_registry_data()

static void export_registry_data ( FILE *  fp,
HKEY  key,
WCHAR *  path,
BOOL  unicode 
)
static

Definition at line 1373 of file regproc.c.

1374{
1375 LONG rc;
1376 DWORD max_value_len = 256, value_len;
1377 DWORD max_data_bytes = 2048, data_size;
1378 DWORD subkey_len;
1379 DWORD i, type, path_len;
1380 WCHAR *value_name, *subkey_name, *subkey_path;
1381 BYTE *data;
1382 HKEY subkey;
1383
1384 export_key_name(fp, path, unicode);
1385
1386 value_name = malloc(max_value_len * sizeof(WCHAR));
1387 data = malloc(max_data_bytes);
1388
1389 i = 0;
1390 for (;;)
1391 {
1392 value_len = max_value_len;
1393 data_size = max_data_bytes;
1394 rc = RegEnumValueW(key, i, value_name, &value_len, NULL, &type, data, &data_size);
1395 if (rc == ERROR_SUCCESS)
1396 {
1397 export_data(fp, value_name, value_len, type, data, data_size, unicode);
1398 i++;
1399 }
1400 else if (rc == ERROR_MORE_DATA)
1401 {
1402 if (data_size > max_data_bytes)
1403 {
1404 max_data_bytes = data_size;
1405 data = realloc(data, max_data_bytes);
1406 }
1407 else
1408 {
1409 max_value_len *= 2;
1410 value_name = realloc(value_name, max_value_len * sizeof(WCHAR));
1411 }
1412 }
1413 else break;
1414 }
1415
1416 free(data);
1417 free(value_name);
1418
1419 subkey_name = malloc(MAX_SUBKEY_LEN * sizeof(WCHAR));
1420
1421 path_len = lstrlenW(path);
1422
1423 i = 0;
1424 for (;;)
1425 {
1426 subkey_len = MAX_SUBKEY_LEN;
1427 rc = RegEnumKeyExW(key, i, subkey_name, &subkey_len, NULL, NULL, NULL, NULL);
1428 if (rc == ERROR_SUCCESS)
1429 {
1430 subkey_path = build_subkey_path(path, path_len, subkey_name, subkey_len);
1431 if (!RegOpenKeyExW(key, subkey_name, 0, KEY_READ, &subkey))
1432 {
1433 export_registry_data(fp, subkey, subkey_path, unicode);
1434 RegCloseKey(subkey);
1435 }
1436 free(subkey_path);
1437 i++;
1438 }
1439 else break;
1440 }
1441
1442 free(subkey_name);
1443}
export_key_name
static void export_key_name(FILE *fp, WCHAR *name, BOOL unicode)
Definition: regproc.c:1357
build_subkey_path
static WCHAR * build_subkey_path(WCHAR *path, DWORD path_len, WCHAR *subkey_name, DWORD subkey_len)
Definition: regproc.c:1343
MAX_SUBKEY_LEN
#define MAX_SUBKEY_LEN
Definition: regproc.c:1371
export_data
static void export_data(FILE *fp, WCHAR *value_name, DWORD value_len, DWORD type, void *data, size_t size, BOOL unicode)
Definition: regproc.c:1307
ERROR_MORE_DATA
#define ERROR_MORE_DATA
Definition: dderror.h:13
ERROR_SUCCESS
#define ERROR_SUCCESS
Definition: deptool.c:10
RegOpenKeyExW
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3353
RegEnumKeyExW
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:2524
RegEnumValueW
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:2850
KEY_READ
#define KEY_READ
Definition: nt_native.h:1023
LONG
long LONG
Definition: pedump.c:60

Referenced by export_all(), export_key(), and export_registry_data().

◆ export_registry_key()

BOOL export_registry_key ( WCHAR *  file_name,
WCHAR *  path,
DWORD  format 
)

Definition at line 1546 of file regproc.c.

1547{
1548 BOOL unicode = (format == REG_FORMAT_5);
1549
1550 if (path && *path)
1551 return export_key(file_name, path, unicode);
1552 else
1553 return export_all(file_name, path, unicode);
1554}
REG_FORMAT_5
#define REG_FORMAT_5
Definition: main.h:44
export_all
static BOOL export_all(WCHAR *file_name, WCHAR *path, BOOL unicode)
Definition: regproc.c:1514
export_key
static BOOL export_key(WCHAR *file_name, WCHAR *path, BOOL unicode)
Definition: regproc.c:1489
BOOL
unsigned int BOOL
Definition: ntddk_ex.h:94
format
GLint GLint GLsizei GLsizei GLsizei GLint GLenum format
Definition: gl.h:1546

Referenced by ExportRegistryFile(), and PerformRegAction().

◆ export_string_data()

static void export_string_data ( WCHAR **  buf,
WCHAR *  data,
size_t  size 
)
static

Definition at line 1211 of file regproc.c.

1212{
1213 size_t len = 0, line_len;
1214 WCHAR *str;
1215
1216 if (size)
1217 len = size / sizeof(WCHAR) - 1;
1218 str = REGPROC_escape_string(data, len, &line_len);
1219 *buf = malloc((line_len + 3) * sizeof(WCHAR));
1220#ifdef __REACTOS__
1221 swprintf(*buf, L"\"%s\"", str);
1222#else
1223 swprintf(*buf, line_len + 3, L"\"%s\"", str);
1224#endif
1225 free(str);
1226}
REGPROC_escape_string
static WCHAR * REGPROC_escape_string(WCHAR *str, size_t str_len, size_t *line_len)
Definition: regproc.c:1133

Referenced by export_data().

◆ export_value_name()

static size_t export_value_name ( FILE *  fp,
WCHAR *  name,
size_t  len,
BOOL  unicode 
)
static

Definition at line 1184 of file regproc.c.

1185{
1186 static const WCHAR default_name[] = L"@=";
1187 size_t line_len;
1188
1189 if (name && *name)
1190 {
1191 WCHAR *str = REGPROC_escape_string(name, len, &line_len);
1192 WCHAR *buf = malloc((line_len + 4) * sizeof(WCHAR));
1193#ifdef __REACTOS__
1194 line_len = swprintf(buf, L"\"%s\"=", str);
1195#else
1196 line_len = swprintf(buf, line_len + 4, L"\"%s\"=", str);
1197#endif
1198 REGPROC_write_line(fp, buf, unicode);
1199 free(buf);
1200 free(str);
1201 }
1202 else
1203 {
1204 line_len = lstrlenW(default_name);
1205 REGPROC_write_line(fp, default_name, unicode);
1206 }
1207
1208 return line_len;
1209}

Referenced by export_data().

◆ free_parser_data()

static void free_parser_data ( struct parser *  parser)
static

Definition at line 470 of file regproc.c.

471{
472 if (parser->parse_type == REG_DWORD || parser->parse_type == REG_BINARY)
473 free(parser->data);
474
475 parser->data = NULL;
476 parser->data_size = 0;
477}

Referenced by dword_data_state(), eol_backslash_state(), hex_data_state(), hex_multiline_state(), set_value_state(), and string_data_state().

◆ get_lineA()

static WCHAR * get_lineA ( FILE *  fp)
static

Definition at line 936 of file regproc.c.

937{
938 static WCHAR *lineW;
939 static size_t size;
940 static char *buf, *next;
941 char *line;
942
943 free(lineW);
944
945 if (!fp) goto cleanup;
946
947 if (!size)
948 {
949 size = REG_VAL_BUF_SIZE;
950 buf = malloc(size);
951 *buf = 0;
952 next = buf;
953 }
954 line = next;
955
956 while (next)
957 {
958 char *p = strpbrk(line, "\r\n");
959 if (!p)
960 {
961 size_t len, count;
962 len = strlen(next);
963 memmove(buf, next, len + 1);
964 if (size - len < 3)
965 {
966 size *= 2;
967 buf = realloc(buf, size);
968 }
969 if (!(count = fread(buf + len, 1, size - len - 1, fp)))
970 {
971 next = NULL;
972 lineW = GetWideString(buf);
973 return lineW;
974 }
975 buf[len + count] = 0;
976 next = buf;
977 line = buf;
978 continue;
979 }
980 next = p + 1;
981 if (*p == '\r' && *(p + 1) == '\n') next++;
982 *p = 0;
983 lineW = GetWideString(line);
984 return lineW;
985 }
986
987cleanup:
988 lineW = NULL;
989 if (size) free(buf);
990 size = 0;
991 return NULL;
992}
strlen
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
strpbrk
char * strpbrk(const char *String, const char *Delimiters)
Definition: utclib.c:302
REG_VAL_BUF_SIZE
#define REG_VAL_BUF_SIZE
Definition: regproc.c:38
GetWideString
static WCHAR * GetWideString(const char *strA)
Definition: regproc.c:49
cleanup
static void cleanup(void)
Definition: main.c:1335
fread
_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)
memmove
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
next
static unsigned __int64 next
Definition: rand_nt.c:6

Referenced by import_registry_file().

◆ get_lineW()

static WCHAR * get_lineW ( FILE *  fp)
static

Definition at line 994 of file regproc.c.

995{
996 static size_t size;
997 static WCHAR *buf, *next;
998 WCHAR *line;
999
1000 if (!fp) goto cleanup;
1001
1002 if (!size)
1003 {
1004 size = REG_VAL_BUF_SIZE;
1005 buf = malloc(size * sizeof(WCHAR));
1006 *buf = 0;
1007 next = buf;
1008 }
1009 line = next;
1010
1011 while (next)
1012 {
1013 WCHAR *p = wcspbrk(line, L"\r\n");
1014 if (!p)
1015 {
1016 size_t len, count;
1017 len = lstrlenW(next);
1018 memmove(buf, next, (len + 1) * sizeof(WCHAR));
1019 if (size - len < 3)
1020 {
1021 size *= 2;
1022 buf = realloc(buf, size * sizeof(WCHAR));
1023 }
1024 if (!(count = fread(buf + len, sizeof(WCHAR), size - len - 1, fp)))
1025 {
1026 next = NULL;
1027 return buf;
1028 }
1029 buf[len + count] = 0;
1030 next = buf;
1031 line = buf;
1032 continue;
1033 }
1034 next = p + 1;
1035 if (*p == '\r' && *(p + 1) == '\n') next++;
1036 *p = 0;
1037 return line;
1038 }
1039
1040cleanup:
1041 if (size) free(buf);
1042 size = 0;
1043 return NULL;
1044}
wcspbrk
_Check_return_ _CRTIMP _CONST_RETURN wchar_t *__cdecl wcspbrk(_In_z_ const wchar_t *_Str, _In_z_ const wchar_t *_Control)

Referenced by import_registry_file().

◆ GetMultiByteString()

char * GetMultiByteString ( const WCHAR *  strW)

Definition at line 86 of file regproc.c.

87{
88 if(strW)
89 {
90 char* strA;
91 int len = WideCharToMultiByte(CP_ACP, 0, strW, -1, NULL, 0, NULL, NULL);
92
93 strA = malloc(len);
94 WideCharToMultiByte(CP_ACP, 0, strW, -1, strA, len, NULL, NULL);
95 return strA;
96 }
97 return NULL;
98}
CP_ACP
#define CP_ACP
Definition: compat.h:109
WideCharToMultiByte
#define WideCharToMultiByte
Definition: compat.h:111
strW
WCHAR strW[12]
Definition: clipboard.c:2029
strA
char strA[12]
Definition: clipboard.c:2028

Referenced by REGPROC_write_line().

◆ GetMultiByteStringN()

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

Definition at line 104 of file regproc.c.

105{
106 if(strW)
107 {
108 char* strA;
109 *len = WideCharToMultiByte(CP_ACP, 0, strW, chars, NULL, 0, NULL, NULL);
110
111 strA = malloc(*len);
112 WideCharToMultiByte(CP_ACP, 0, strW, chars, strA, *len, NULL, NULL);
113 return strA;
114 }
115 *len = 0;
116 return NULL;
117}

Referenced by export_hex_data().

◆ GetWideString()

static WCHAR * GetWideString ( const char *  strA)
static

Definition at line 49 of file regproc.c.

50{
51 if(strA)
52 {
53 WCHAR* strW;
54 int len = MultiByteToWideChar(CP_ACP, 0, strA, -1, NULL, 0);
55
56 strW = malloc(len * sizeof(WCHAR));
57 MultiByteToWideChar(CP_ACP, 0, strA, -1, strW, len);
58 return strW;
59 }
60 return NULL;
61}
MultiByteToWideChar
#define MultiByteToWideChar
Definition: compat.h:110

Referenced by get_lineA().

◆ GetWideStringN()

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

Definition at line 67 of file regproc.c.

68{
69 if(strA)
70 {
71 WCHAR* strW;
72 *len = MultiByteToWideChar(CP_ACP, 0, strA, chars, NULL, 0);
73
74 strW = malloc(*len * sizeof(WCHAR));
75 MultiByteToWideChar(CP_ACP, 0, strA, chars, strW, *len);
76 return strW;
77 }
78 *len = 0;
79 return NULL;
80}

Referenced by prepare_hex_string_data().

◆ header_state()

static WCHAR * header_state ( struct parser *  parser,
WCHAR *  pos 
)
static

Definition at line 547 of file regproc.c.

548{
549 WCHAR *line, *header;
550
551 if (!(line = get_line(parser->file)))
552 return NULL;
553
554 if (!parser->is_unicode)
555 {
556 header = malloc((lstrlenW(line) + 3) * sizeof(WCHAR));
557 header[0] = parser->two_wchars[0];
558 header[1] = parser->two_wchars[1];
559 lstrcpyW(header + 2, line);
560 parser->reg_version = parse_file_header(header);
561 free(header);
562 }
563 else parser->reg_version = parse_file_header(line);
564
565 switch (parser->reg_version)
566 {
567 case REG_VERSION_31:
568 set_state(parser, PARSE_WIN31_LINE);
569 break;
570 case REG_VERSION_40:
571 case REG_VERSION_50:
572 set_state(parser, LINE_START);
573 break;
574 default:
575 get_line(NULL); /* Reset static variables */
576 return NULL;
577 }
578
579 return line;
580}
parse_file_header
static enum reg_versions parse_file_header(const WCHAR *s)
Definition: regproc.c:520
get_line
static WCHAR *(* get_line)(FILE *)
Definition: regproc.c:119
parser::is_unicode
BOOL is_unicode
Definition: import.c:84
parser::two_wchars
WCHAR two_wchars[2]
Definition: import.c:83
parser::reg_version
short int reg_version
Definition: import.c:85
parser::file
FILE * file
Definition: import.c:82

◆ hex_data_state()

static WCHAR * hex_data_state ( struct parser *  parser,
WCHAR *  pos 
)
static

Definition at line 840 of file regproc.c.

841{
842 WCHAR *line = pos;
843
844 if (!*line)
845 goto set_value;
846
847 if (!convert_hex_csv_to_hex(parser, &line))
848 goto invalid;
849
850 if (parser->backslash)
851 {
852 set_state(parser, EOL_BACKSLASH);
853 return line;
854 }
855
856 prepare_hex_string_data(parser);
857
858set_value:
859 set_state(parser, SET_VALUE);
860 return line;
861
862invalid:
863 free_parser_data(parser);
864 set_state(parser, LINE_START);
865 return line;
866}
prepare_hex_string_data
static void prepare_hex_string_data(struct parser *parser)
Definition: regproc.c:479
convert_hex_csv_to_hex
static BOOL convert_hex_csv_to_hex(struct parser *parser, WCHAR **str)
Definition: regproc.c:248
set_value
static HRESULT set_value(struct d3dx_parameter *param, const void *data, unsigned int bytes, void *dst_data)
Definition: effect.c:889

◆ hex_multiline_state()

static WCHAR * hex_multiline_state ( struct parser *  parser,
WCHAR *  pos 
)
static

Definition at line 886 of file regproc.c.

887{
888 WCHAR *line;
889
890 if (!(line = get_line(parser->file)))
891 {
892 prepare_hex_string_data(parser);
893 set_state(parser, SET_VALUE);
894 return pos;
895 }
896
897 while (*line == ' ' || *line == '\t') line++;
898 if (!*line || *line == ';') return line;
899
900 if (!iswxdigit(*line)) goto invalid;
901
902 set_state(parser, HEX_DATA);
903 return line;
904
905invalid:
906 free_parser_data(parser);
907 set_state(parser, LINE_START);
908 return line;
909}

◆ import_registry_file()

BOOL import_registry_file ( FILE *  reg_file)

Definition at line 1049 of file regproc.c.

1050{
1051 BYTE s[2];
1052 struct parser parser;
1053 WCHAR *pos;
1054
1055 if (!reg_file || (fread(s, 2, 1, reg_file) != 1))
1056 return FALSE;
1057
1058 parser.is_unicode = (s[0] == 0xff && s[1] == 0xfe);
1059 get_line = parser.is_unicode ? get_lineW : get_lineA;
1060
1061 parser.file = reg_file;
1062 parser.two_wchars[0] = s[0];
1063 parser.two_wchars[1] = s[1];
1064 parser.reg_version = -1;
1065 parser.hkey = NULL;
1066 parser.key_name = NULL;
1067 parser.value_name = NULL;
1068 parser.parse_type = 0;
1069 parser.data_type = 0;
1070 parser.data = NULL;
1071 parser.data_size = 0;
1072 parser.backslash = FALSE;
1073 parser.state = HEADER;
1074
1075 pos = parser.two_wchars;
1076
1077 /* parser main loop */
1078 while (pos)
1079 pos = (parser_funcs[parser.state])(&parser, pos);
1080
1081 if (parser.reg_version == REG_VERSION_FUZZY || parser.reg_version == REG_VERSION_INVALID)
1082 return parser.reg_version == REG_VERSION_FUZZY;
1083
1084 free(parser.value_name);
1085 close_key(&parser);
1086
1087 return TRUE;
1088}
get_lineA
static WCHAR * get_lineA(FILE *fp)
Definition: regproc.c:936
get_lineW
static WCHAR * get_lineW(FILE *fp)
Definition: regproc.c:994
parser_funcs
static const parser_state_func parser_funcs[NB_PARSER_STATES]
Definition: regproc.c:182
parser::state
enum parser_state state
Definition: import.c:95
parser::data_type
DWORD data_type
Definition: import.c:91

Referenced by ImportRegistryFile(), and PerformRegAction().

◆ key_name_state()

static WCHAR * key_name_state ( struct parser *  parser,
WCHAR *  pos 
)
static

Definition at line 654 of file regproc.c.

655{
656 WCHAR *p = pos, *key_end;
657
658 if (*p == ' ' || *p == '\t' || !(key_end = wcsrchr(p, ']')))
659 goto done;
660
661 *key_end = 0;
662
663 if (*p == '-')
664 {
665 set_state(parser, DELETE_KEY);
666 return p + 1;
667 }
668 else if (open_key(parser, p) != ERROR_SUCCESS)
669 output_message(STRING_OPEN_KEY_FAILED, p);
670
671done:
672 set_state(parser, LINE_START);
673 return p;
674}
STRING_OPEN_KEY_FAILED
#define STRING_OPEN_KEY_FAILED
Definition: resource.h:318
wcsrchr
#define wcsrchr
Definition: compat.h:16
open_key
#define open_key(r, p, s, k)
Definition: reg_test.h:49

◆ line_start_state()

static WCHAR * line_start_state ( struct parser *  parser,
WCHAR *  pos 
)
static

Definition at line 622 of file regproc.c.

623{
624 WCHAR *line, *p;
625
626 if (!(line = get_line(parser->file)))
627 return NULL;
628
629 for (p = line; *p; p++)
630 {
631 switch (*p)
632 {
633 case '[':
634 set_state(parser, KEY_NAME);
635 return p + 1;
636 case '@':
637 set_state(parser, DEFAULT_VALUE_NAME);
638 return p;
639 case '"':
640 set_state(parser, QUOTED_VALUE_NAME);
641 return p + 1;
642 case ' ':
643 case '\t':
644 break;
645 default:
646 return p;
647 }
648 }
649
650 return p;
651}

◆ open_export_key()

static HKEY open_export_key ( HKEY  key_class,
WCHAR *  subkey,
WCHAR *  path 
)
static

Definition at line 1478 of file regproc.c.

1479{
1480 HKEY key;
1481
1482 if (!RegOpenKeyExW(key_class, subkey, 0, KEY_READ, &key))
1483 return key;
1484
1485 output_message(STRING_OPEN_KEY_FAILED, path);
1486 return NULL;
1487}

Referenced by export_all(), and export_key().

◆ open_key()

static LONG open_key ( struct parser *  parser,
WCHAR *  path 
)
static

Definition at line 444 of file regproc.c.

445{
446 HKEY key_class;
447 WCHAR *key_path;
448 LONG res;
449
450 close_key(parser);
451
452 /* Get the registry class */
453 if (!path || !(key_class = parse_key_name(path, &key_path)))
454 return ERROR_INVALID_PARAMETER;
455
456 res = RegCreateKeyExW(key_class, key_path, 0, NULL, REG_OPTION_NON_VOLATILE,
457 KEY_ALL_ACCESS, NULL, &parser->hkey, NULL);
458
459 if (res == ERROR_SUCCESS)
460 {
461 parser->key_name = malloc((lstrlenW(path) + 1) * sizeof(WCHAR));
462 lstrcpyW(parser->key_name, path);
463 }
464 else
465 parser->hkey = NULL;
466
467 return res;
468}
RegCreateKeyExW
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:1091
ERROR_INVALID_PARAMETER
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
res
GLuint res
Definition: glext.h:9613
KEY_ALL_ACCESS
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
REG_OPTION_NON_VOLATILE
#define REG_OPTION_NON_VOLATILE
Definition: nt_native.h:1057

◆ parse_data_type()

static BOOL parse_data_type ( struct parser *  parser,
WCHAR **  line 
)
static

Definition at line 308 of file regproc.c.

309{
310 struct data_type { const WCHAR *tag; int len; int type; int parse_type; };
311
312 static const struct data_type data_types[] = {
313 /* tag len type parse type */
314 { L"\"", 1, REG_SZ, REG_SZ },
315 { L"hex:", 4, REG_BINARY, REG_BINARY },
316 { L"dword:", 6, REG_DWORD, REG_DWORD },
317 { L"hex(", 4, -1, REG_BINARY }, /* REG_NONE, REG_EXPAND_SZ, REG_MULTI_SZ */
318 { NULL, 0, 0, 0 }
319 };
320
321 const struct data_type *ptr;
322
323 for (ptr = data_types; ptr->tag; ptr++)
324 {
325 if (wcsncmp(ptr->tag, *line, ptr->len))
326 continue;
327
328 parser->parse_type = ptr->parse_type;
329 parser->data_type = ptr->parse_type;
330 *line += ptr->len;
331
332 if (ptr->type == -1)
333 {
334 WCHAR *end;
335 DWORD val;
336
337 if (!**line || towlower((*line)[1]) == 'x')
338 return FALSE;
339
340 /* "hex(xx):" is special */
341 val = wcstoul(*line, &end, 16);
342 if (*end != ')' || *(end + 1) != ':' || (val == ~0u && errno == ERANGE))
343 return FALSE;
344
345 parser->data_type = val;
346 *line = end + 2;
347 }
348 return TRUE;
349 }
350 return FALSE;
351}
ERANGE
#define ERANGE
Definition: acclib.h:92
val
GLuint GLfloat * val
Definition: glext.h:7180
u
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 * u
Definition: glfuncs.h:240
ptr
static PVOID ptr
Definition: dispmode.c:27
errno
#define errno
Definition: errno.h:18
wcsncmp
_Check_return_ _CRTIMP int __cdecl wcsncmp(_In_reads_or_z_(_MaxCount) const wchar_t *_Str1, _In_reads_or_z_(_MaxCount) const wchar_t *_Str2, _In_ size_t _MaxCount)
parse_type
int parse_type(Type t, const vector< string > &tokens, int off, vector< string > &names, vector< string > &dependencies)
Definition: sdkparse.cpp:653
tag
Definition: ecma_167.h:138
towlower
#define towlower(c)
Definition: wctype.h:97

Referenced by data_type_state().

◆ parse_file_header()

static enum reg_versions parse_file_header ( const WCHAR *  s)
static

Definition at line 520 of file regproc.c.

521{
522 static const WCHAR header_31[] = L"REGEDIT";
523
524 while (*s == ' ' || *s == '\t') s++;
525
526 if (!lstrcmpW(s, header_31))
527 return REG_VERSION_31;
528
529 if (!lstrcmpW(s, L"REGEDIT4"))
530 return REG_VERSION_40;
531
532 if (!lstrcmpW(s, L"Windows Registry Editor Version 5.00"))
533 return REG_VERSION_50;
534
535 /* The Windows version accepts registry file headers beginning with "REGEDIT" and ending
536 * with other characters, as long as "REGEDIT" appears at the start of the line. For example,
537 * "REGEDIT 4", "REGEDIT9" and "REGEDIT4FOO" are all treated as valid file headers.
538 * In all such cases, however, the contents of the registry file are not imported.
539 */
540 if (!wcsncmp(s, header_31, 7)) /* "REGEDIT" without NUL */
541 return REG_VERSION_FUZZY;
542
543 return REG_VERSION_INVALID;
544}
lstrcmpW
int WINAPI lstrcmpW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:170

Referenced by header_state().

◆ parse_key_name()

static HKEY parse_key_name ( WCHAR *  key_name,
WCHAR **  key_path 
)
static

Definition at line 402 of file regproc.c.

403{
404 unsigned int i;
405
406 if (!key_name) return 0;
407
408 *key_path = wcschr(key_name, '\\');
409 if (*key_path) (*key_path)++;
410
411 for (i = 0; i < ARRAY_SIZE(reg_class_keys); i++)
412 {
413 int len = lstrlenW(reg_class_namesW[i]);
414#ifdef __REACTOS__
415 if (!_wcsnicmp(key_name, reg_class_namesW[i], len) &&
416#else
417 if (!wcsnicmp(key_name, reg_class_namesW[i], len) &&
418#endif
419 (key_name[len] == 0 || key_name[len] == '\\'))
420 {
421 return reg_class_keys[i];
422 }
423 }
424
425 return 0;
426}
reg_class_keys
static HKEY reg_class_keys[]
Definition: regproc.c:40
wcschr
#define wcschr
Definition: compat.h:17
wcsnicmp
#define wcsnicmp
Definition: compat.h:14
_wcsnicmp
_Check_return_ _CRTIMP int __cdecl _wcsnicmp(_In_reads_or_z_(_MaxCount) const wchar_t *_Str1, _In_reads_or_z_(_MaxCount) const wchar_t *_Str2, _In_ size_t _MaxCount)

Referenced by delete_registry_key(), export_key(), and open_key().

◆ parse_win31_line_state()

static WCHAR * parse_win31_line_state ( struct parser *  parser,
WCHAR *  pos 
)
static

Definition at line 583 of file regproc.c.

584{
585 WCHAR *line, *value;
586 static WCHAR hkcr[] = L"HKEY_CLASSES_ROOT";
587 unsigned int key_end = 0;
588
589 if (!(line = get_line(parser->file)))
590 return NULL;
591
592 if (wcsncmp(line, hkcr, lstrlenW(hkcr)))
593 return line;
594
595 /* get key name */
596 while (line[key_end] && !iswspace(line[key_end])) key_end++;
597
598 value = line + key_end;
599 while (*value == ' ' || *value == '\t') value++;
600
601 if (*value == '=') value++;
602 if (*value == ' ') value++; /* at most one space is skipped */
603
604 line[key_end] = 0;
605
606 if (open_key(parser, line) != ERROR_SUCCESS)
607 {
608 output_message(STRING_OPEN_KEY_FAILED, line);
609 return line;
610 }
611
612 parser->value_name = NULL;
613 parser->data_type = REG_SZ;
614 parser->data = value;
615 parser->data_size = (lstrlenW(value) + 1) * sizeof(WCHAR);
616
617 set_state(parser, SET_VALUE);
618 return value;
619}
iswspace
#define iswspace(_c)
Definition: ctype.h:669
value
Definition: pdh_main.c:94

◆ prepare_hex_string_data()

static void prepare_hex_string_data ( struct parser *  parser)
static

Definition at line 479 of file regproc.c.

480{
481 if (parser->data_type == REG_EXPAND_SZ || parser->data_type == REG_MULTI_SZ ||
482 parser->data_type == REG_SZ)
483 {
484 if (parser->is_unicode)
485 {
486 WCHAR *data = parser->data;
487 DWORD len = parser->data_size / sizeof(WCHAR);
488
489 if (data[len - 1] != 0)
490 {
491 data[len] = 0;
492 parser->data_size += sizeof(WCHAR);
493 }
494 }
495 else
496 {
497 BYTE *data = parser->data;
498
499 if (data[parser->data_size - 1] != 0)
500 {
501 data[parser->data_size] = 0;
502 parser->data_size++;
503 }
504
505 parser->data = GetWideStringN(parser->data, parser->data_size, &parser->data_size);
506 parser->data_size *= sizeof(WCHAR);
507 free(data);
508 }
509 }
510}
GetWideStringN
static WCHAR * GetWideStringN(const char *strA, int chars, DWORD *len)
Definition: regproc.c:67

Referenced by hex_data_state(), and hex_multiline_state().

◆ quoted_value_name_state()

static WCHAR * quoted_value_name_state ( struct parser *  parser,
WCHAR *  pos 
)
static

Definition at line 701 of file regproc.c.

702{
703 WCHAR *val_name = pos, *p;
704
705 free(parser->value_name);
706 parser->value_name = NULL;
707
708 if (!REGPROC_unescape_string(val_name, &p))
709 goto invalid;
710
711 /* copy the value name in case we need to parse multiple lines and the buffer is overwritten */
712 parser->value_name = malloc((lstrlenW(val_name) + 1) * sizeof(WCHAR));
713 lstrcpyW(parser->value_name, val_name);
714
715 set_state(parser, DATA_START);
716 return p;
717
718invalid:
719 set_state(parser, LINE_START);
720 return val_name;
721}
REGPROC_unescape_string
static BOOL REGPROC_unescape_string(WCHAR *str, WCHAR **unparsed)
Definition: regproc.c:360

◆ REGPROC_escape_string()

static WCHAR * REGPROC_escape_string ( WCHAR *  str,
size_t  str_len,
size_t *  line_len 
)
static

Definition at line 1133 of file regproc.c.

1134{
1135 size_t i, escape_count, pos;
1136 WCHAR *buf;
1137
1138 for (i = 0, escape_count = 0; i < str_len; i++)
1139 {
1140 WCHAR c = str[i];
1141
1142 if (!c) break;
1143
1144 if (c == '\r' || c == '\n' || c == '\\' || c == '"')
1145 escape_count++;
1146 }
1147
1148 buf = malloc((str_len + escape_count + 1) * sizeof(WCHAR));
1149
1150 for (i = 0, pos = 0; i < str_len; i++, pos++)
1151 {
1152 WCHAR c = str[i];
1153
1154 if (!c) break;
1155
1156 switch (c)
1157 {
1158 case '\r':
1159 buf[pos++] = '\\';
1160 buf[pos] = 'r';
1161 break;
1162 case '\n':
1163 buf[pos++] = '\\';
1164 buf[pos] = 'n';
1165 break;
1166 case '\\':
1167 buf[pos++] = '\\';
1168 buf[pos] = '\\';
1169 break;
1170 case '"':
1171 buf[pos++] = '\\';
1172 buf[pos] = '"';
1173 break;
1174 default:
1175 buf[pos] = c;
1176 }
1177 }
1178
1179 buf[pos] = 0;
1180 *line_len = pos;
1181 return buf;
1182}
c
const GLubyte * c
Definition: glext.h:8905
c
#define c
Definition: ke_i.h:80
str_len
#define str_len
Definition: treelist.c:89

Referenced by export_string_data(), and export_value_name().

◆ REGPROC_open_export_file()

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

Definition at line 1445 of file regproc.c.

1446{
1447 FILE *file;
1448
1449 if (!lstrcmpW(file_name, L"-"))
1450 {
1451 file = stdout;
1452 _setmode(_fileno(file), _O_BINARY);
1453 }
1454 else
1455 {
1456 file = _wfopen(file_name, L"wb");
1457 if (!file)
1458 {
1459 _wperror(L"regedit");
1460 error_exit(STRING_CANNOT_OPEN_FILE, file_name);
1461 }
1462 }
1463
1464 if (unicode)
1465 {
1466 static const BYTE bom[] = {0xff,0xfe};
1467 static const WCHAR header[] = L"Windows Registry Editor Version 5.00\r\n";
1468
1469 fwrite(bom, sizeof(BYTE), ARRAY_SIZE(bom), file);
1470 fwrite(header, sizeof(WCHAR), lstrlenW(header), file);
1471 }
1472 else
1473 fputs("REGEDIT4\r\n", file);
1474
1475 return file;
1476}
STRING_CANNOT_OPEN_FILE
#define STRING_CANNOT_OPEN_FILE
Definition: resource.h:308
_setmode
#define _setmode(fd, mode)
Definition: cat.c:21
_O_BINARY
#define _O_BINARY
Definition: cabinet.h:51
stdout
#define stdout
Definition: stdio.h:99
_fileno
_Check_return_ _CRTIMP int __cdecl _fileno(_In_ FILE *_File)
fputs
_Check_return_opt_ _CRTIMP int __cdecl fputs(_In_z_ const char *_Str, _Inout_ FILE *_File)
_wfopen
_Check_return_ _CRTIMP FILE *__cdecl _wfopen(_In_z_ const wchar_t *_Filename, _In_z_ const wchar_t *_Mode)
_wperror
_CRTIMP void __cdecl _wperror(_In_opt_z_ const wchar_t *_ErrMsg)
fwrite
_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
Definition: fci.c:127

Referenced by export_all(), export_key(), and export_registry_key().

◆ REGPROC_unescape_string()

static BOOL REGPROC_unescape_string ( WCHAR *  str,
WCHAR **  unparsed 
)
static

Definition at line 360 of file regproc.c.

361{
362 int str_idx = 0; /* current character under analysis */
363 int val_idx = 0; /* the last character of the unescaped string */
364 int len = lstrlenW(str);
365 BOOL ret;
366
367 for (str_idx = 0; str_idx < len; str_idx++, val_idx++) {
368 if (str[str_idx] == '\\') {
369 str_idx++;
370 switch (str[str_idx]) {
371 case 'n':
372 str[val_idx] = '\n';
373 break;
374 case 'r':
375 str[val_idx] = '\r';
376 break;
377 case '0':
378 return FALSE;
379 case '\\':
380 case '"':
381 str[val_idx] = str[str_idx];
382 break;
383 default:
384 if (!str[str_idx]) return FALSE;
385 output_message(STRING_ESCAPE_SEQUENCE, str[str_idx]);
386 str[val_idx] = str[str_idx];
387 break;
388 }
389 } else if (str[str_idx] == '"') {
390 break;
391 } else {
392 str[val_idx] = str[str_idx];
393 }
394 }
395
396 ret = (str[str_idx] == '"');
397 *unparsed = str + str_idx + 1;
398 str[val_idx] = '\0';
399 return ret;
400}
STRING_ESCAPE_SEQUENCE
#define STRING_ESCAPE_SEQUENCE
Definition: resource.h:80
ret
int ret
Definition: wcstombs-tests.c:31

Referenced by processSetValue(), quoted_value_name_state(), setValue(), and string_data_state().

◆ REGPROC_write_line()

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

Definition at line 1121 of file regproc.c.

1122{
1123 if (unicode)
1124 fwrite(str, sizeof(WCHAR), lstrlenW(str), fp);
1125 else
1126 {
1127 char *strA = GetMultiByteString(str);
1128 fputs(strA, fp);
1129 free(strA);
1130 }
1131}
GetMultiByteString
char * GetMultiByteString(const WCHAR *strW)
Definition: regproc.c:86

Referenced by export_data(), export_hex_data(), export_hex_data_type(), export_key_name(), export_newline(), and export_value_name().

◆ set_state()

static enum parser_state set_state ( struct parser *  parser,
enum parser_state  state 
)
inlinestatic

Definition at line 204 of file regproc.c.

205{
206 enum parser_state ret = parser->state;
207 parser->state = state;
208 return ret;
209}
state
static int state
Definition: maze.c:121
parser_state
parser_state
Definition: import.c:59

Referenced by data_start_state(), data_type_state(), default_value_name_state(), delete_key_state(), delete_value_state(), dword_data_state(), eol_backslash_state(), header_state(), hex_data_state(), hex_multiline_state(), key_name_state(), line_start_state(), parse_win31_line_state(), quoted_value_name_state(), set_value_state(), string_data_state(), and unknown_data_state().

◆ set_value_state()

static WCHAR * set_value_state ( struct parser *  parser,
WCHAR *  pos 
)
static

Definition at line 921 of file regproc.c.

922{
923 RegSetValueExW(parser->hkey, parser->value_name, 0, parser->data_type,
924 parser->data, parser->data_size);
925
926 free_parser_data(parser);
927
928 if (parser->reg_version == REG_VERSION_31)
929 set_state(parser, PARSE_WIN31_LINE);
930 else
931 set_state(parser, LINE_START);
932
933 return pos;
934}
RegSetValueExW
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:4897

◆ string_data_state()

static WCHAR * string_data_state ( struct parser *  parser,
WCHAR *  pos 
)
static

Definition at line 795 of file regproc.c.

796{
797 WCHAR *line;
798
799 parser->data = pos;
800
801 if (!REGPROC_unescape_string(parser->data, &line))
802 goto invalid;
803
804 while (*line == ' ' || *line == '\t') line++;
805 if (*line && *line != ';') goto invalid;
806
807 parser->data_size = (lstrlenW(parser->data) + 1) * sizeof(WCHAR);
808
809 set_state(parser, SET_VALUE);
810 return line;
811
812invalid:
813 free_parser_data(parser);
814 set_state(parser, LINE_START);
815 return line;
816}

◆ unknown_data_state()

static WCHAR * unknown_data_state ( struct parser *  parser,
WCHAR *  pos 
)
static

Definition at line 912 of file regproc.c.

913{
914 output_message(STRING_UNKNOWN_DATA_FORMAT, parser->data_type);
915
916 set_state(parser, LINE_START);
917 return pos;
918}
STRING_UNKNOWN_DATA_FORMAT
#define STRING_UNKNOWN_DATA_FORMAT
Definition: resource.h:314

Variable Documentation

◆ get_line

WCHAR *(* get_line) (FILE *) ( FILE *  )
static

Definition at line 119 of file regproc.c.

Referenced by header_state(), hex_multiline_state(), import_registry_file(), line_start_state(), and parse_win31_line_state().

◆ parser_funcs

const parser_state_func parser_funcs[NB_PARSER_STATES]
static
Initial value:
=
{
header_state,
parse_win31_line_state,
line_start_state,
key_name_state,
delete_key_state,
default_value_name_state,
quoted_value_name_state,
data_start_state,
delete_value_state,
data_type_state,
string_data_state,
dword_data_state,
hex_data_state,
eol_backslash_state,
hex_multiline_state,
unknown_data_state,
set_value_state,
}
default_value_name_state
static WCHAR * default_value_name_state(struct parser *parser, WCHAR *pos)
Definition: regproc.c:691
hex_data_state
static WCHAR * hex_data_state(struct parser *parser, WCHAR *pos)
Definition: regproc.c:840
dword_data_state
static WCHAR * dword_data_state(struct parser *parser, WCHAR *pos)
Definition: regproc.c:819
string_data_state
static WCHAR * string_data_state(struct parser *parser, WCHAR *pos)
Definition: regproc.c:795
key_name_state
static WCHAR * key_name_state(struct parser *parser, WCHAR *pos)
Definition: regproc.c:654
delete_value_state
static WCHAR * delete_value_state(struct parser *parser, WCHAR *pos)
Definition: regproc.c:751
eol_backslash_state
static WCHAR * eol_backslash_state(struct parser *parser, WCHAR *pos)
Definition: regproc.c:869
data_type_state
static WCHAR * data_type_state(struct parser *parser, WCHAR *pos)
Definition: regproc.c:766
set_value_state
static WCHAR * set_value_state(struct parser *parser, WCHAR *pos)
Definition: regproc.c:921
data_start_state
static WCHAR * data_start_state(struct parser *parser, WCHAR *pos)
Definition: regproc.c:724
unknown_data_state
static WCHAR * unknown_data_state(struct parser *parser, WCHAR *pos)
Definition: regproc.c:912
quoted_value_name_state
static WCHAR * quoted_value_name_state(struct parser *parser, WCHAR *pos)
Definition: regproc.c:701
parse_win31_line_state
static WCHAR * parse_win31_line_state(struct parser *parser, WCHAR *pos)
Definition: regproc.c:583
delete_key_state
static WCHAR * delete_key_state(struct parser *parser, WCHAR *pos)
Definition: regproc.c:677
hex_multiline_state
static WCHAR * hex_multiline_state(struct parser *parser, WCHAR *pos)
Definition: regproc.c:886
header_state
static WCHAR * header_state(struct parser *parser, WCHAR *pos)
Definition: regproc.c:547
line_start_state
static WCHAR * line_start_state(struct parser *parser, WCHAR *pos)
Definition: regproc.c:622

Definition at line 182 of file regproc.c.

Referenced by import_registry_file().

◆ reg_class_keys

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

Definition at line 40 of file regproc.c.

Referenced by export_registry_key(), getRegClass(), and parse_key_name().