ReactOS 0.4.15-dev-7897-g78dc504
import.c
Go to the documentation of this file.
1/*
2 * Copyright 2017 Hugh McMaster
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18
19#include <errno.h>
20#include <stdio.h>
21#include "reg.h"
22#include <wine/debug.h>
23
25
26static WCHAR *GetWideString(const char *strA)
27{
28 if (strA)
29 {
30 WCHAR *strW;
31 int len = MultiByteToWideChar(CP_ACP, 0, strA, -1, NULL, 0);
32
33 strW = malloc(len * sizeof(WCHAR));
35 return strW;
36 }
37 return NULL;
38}
39
40static WCHAR *GetWideStringN(const char *strA, int size, DWORD *len)
41{
42 if (strA)
43 {
44 WCHAR *strW;
46
47 strW = malloc(*len * sizeof(WCHAR));
49 return strW;
50 }
51 *len = 0;
52 return NULL;
53}
54
55static WCHAR *(*get_line)(FILE *);
56
57/* parser definitions */
59{
60 HEADER, /* parsing the registry file version header */
61 PARSE_WIN31_LINE, /* parsing a Windows 3.1 registry line */
62 LINE_START, /* at the beginning of a registry line */
63 KEY_NAME, /* parsing a key name */
64 DELETE_KEY, /* deleting a registry key */
65 DEFAULT_VALUE_NAME, /* parsing a default value name */
66 QUOTED_VALUE_NAME, /* parsing a double-quoted value name */
67 DATA_START, /* preparing for data parsing operations */
68 DELETE_VALUE, /* deleting a registry value */
69 DATA_TYPE, /* parsing the registry data type */
70 STRING_DATA, /* parsing REG_SZ data */
71 DWORD_DATA, /* parsing DWORD data */
72 HEX_DATA, /* parsing REG_BINARY, REG_NONE, REG_EXPAND_SZ or REG_MULTI_SZ data */
73 EOL_BACKSLASH, /* preparing to parse multiple lines of hex data */
74 HEX_MULTILINE, /* parsing multiple lines of hex data */
75 UNKNOWN_DATA, /* parsing an unhandled or invalid data type */
76 SET_VALUE, /* adding a value to the registry */
78};
79
80struct parser
81{
82 FILE *file; /* pointer to a registry file */
83 WCHAR two_wchars[2]; /* first two characters from the encoding check */
84 BOOL is_unicode; /* parsing Unicode or ASCII data */
85 short int reg_version; /* registry file version */
86 REGSAM sam; /* 32-bit or 64-bit registry view (if set) */
87 HKEY hkey; /* current registry key */
88 WCHAR *key_name; /* current key name */
89 WCHAR *value_name; /* value name */
90 DWORD parse_type; /* generic data type for parsing */
91 DWORD data_type; /* data type */
92 void *data; /* value data */
93 DWORD data_size; /* size of the data (in bytes) */
94 BOOL backslash; /* TRUE if the current line contains a backslash */
95 enum parser_state state; /* current parser state */
96};
97
98typedef WCHAR *(*parser_state_func)(struct parser *parser, WCHAR *pos);
99
100/* parser state machine functions */
101static WCHAR *header_state(struct parser *parser, WCHAR *pos);
103static WCHAR *line_start_state(struct parser *parser, WCHAR *pos);
104static WCHAR *key_name_state(struct parser *parser, WCHAR *pos);
105static WCHAR *delete_key_state(struct parser *parser, WCHAR *pos);
108static WCHAR *data_start_state(struct parser *parser, WCHAR *pos);
109static WCHAR *delete_value_state(struct parser *parser, WCHAR *pos);
110static WCHAR *data_type_state(struct parser *parser, WCHAR *pos);
111static WCHAR *string_data_state(struct parser *parser, WCHAR *pos);
112static WCHAR *dword_data_state(struct parser *parser, WCHAR *pos);
113static WCHAR *hex_data_state(struct parser *parser, WCHAR *pos);
116static WCHAR *unknown_data_state(struct parser *parser, WCHAR *pos);
117static WCHAR *set_value_state(struct parser *parser, WCHAR *pos);
118
120{
121 header_state, /* HEADER */
122 parse_win31_line_state, /* PARSE_WIN31_LINE */
123 line_start_state, /* LINE_START */
124 key_name_state, /* KEY_NAME */
125 delete_key_state, /* DELETE_KEY */
126 default_value_name_state, /* DEFAULT_VALUE_NAME */
127 quoted_value_name_state, /* QUOTED_VALUE_NAME */
128 data_start_state, /* DATA_START */
129 delete_value_state, /* DELETE_VALUE */
130 data_type_state, /* DATA_TYPE */
131 string_data_state, /* STRING_DATA */
132 dword_data_state, /* DWORD_DATA */
133 hex_data_state, /* HEX_DATA */
134 eol_backslash_state, /* EOL_BACKSLASH */
135 hex_multiline_state, /* HEX_MULTILINE */
136 unknown_data_state, /* UNKNOWN_DATA */
137 set_value_state, /* SET_VALUE */
138};
139
140/* set the new parser state and return the previous one */
141static inline enum parser_state set_state(struct parser *parser, enum parser_state state)
142{
144 parser->state = state;
145 return ret;
146}
147
148/******************************************************************************
149 * Converts a hex representation of a DWORD into a DWORD.
150 */
152{
153 WCHAR *p, *end;
154 int count = 0;
155
156 while (*str == ' ' || *str == '\t') str++;
157 if (!*str) goto error;
158
159 p = str;
160 while (iswxdigit(*p))
161 {
162 count++;
163 p++;
164 }
165 if (count > 8) goto error;
166
167 end = p;
168 while (*p == ' ' || *p == '\t') p++;
169 if (*p && *p != ';') goto error;
170
171 *end = 0;
172 *dw = wcstoul(str, &end, 16);
173 return TRUE;
174
175error:
176 return FALSE;
177}
178
179/******************************************************************************
180 * Converts comma-separated hex data into a binary string and modifies
181 * the input parameter to skip the concatenating backslash, if found.
182 *
183 * Returns TRUE or FALSE to indicate whether parsing was successful.
184 */
186{
187 size_t size;
188 BYTE *d;
189 WCHAR *s;
190
192
193 /* The worst case is 1 digit + 1 comma per byte */
194 size = ((lstrlenW(*str) + 1) / 2) + parser->data_size;
196
197 s = *str;
198 d = (BYTE *)parser->data + parser->data_size;
199
200 while (*s)
201 {
202 WCHAR *end;
203 unsigned long wc;
204
205 wc = wcstoul(s, &end, 16);
206 if (wc > 0xff) return FALSE;
207
208 if (s == end && wc == 0)
209 {
210 while (*end == ' ' || *end == '\t') end++;
211 if (*end == '\\')
212 {
214 *str = end + 1;
215 return TRUE;
216 }
217 else if (*end == ';')
218 return TRUE;
219 return FALSE;
220 }
221
222 *d++ = wc;
223 parser->data_size++;
224
225 if (*end && *end != ',')
226 {
227 while (*end == ' ' || *end == '\t') end++;
228 if (*end && *end != ';') return FALSE;
229 return TRUE;
230 }
231
232 if (*end) end++;
233 s = end;
234 }
235
236 return TRUE;
237}
238
239/******************************************************************************
240 * Parses the data type of the registry value being imported and modifies
241 * the input parameter to skip the string representation of the data type.
242 *
243 * Returns TRUE or FALSE to indicate whether a data type was found.
244 */
246{
247 struct data_type { const WCHAR *tag; int len; int type; int parse_type; };
248
249 static const struct data_type data_types[] = {
250 /* tag len type parse type */
251 { L"\"", 1, REG_SZ, REG_SZ },
252 { L"hex:", 4, REG_BINARY, REG_BINARY },
253 { L"dword:", 6, REG_DWORD, REG_DWORD },
254 { L"hex(", 4, -1, REG_BINARY }, /* REG_NONE, REG_EXPAND_SZ, REG_MULTI_SZ */
255 { NULL, 0, 0, 0 }
256 };
257
258 const struct data_type *ptr;
259
260 for (ptr = data_types; ptr->tag; ptr++)
261 {
262 if (wcsncmp(ptr->tag, *line, ptr->len))
263 continue;
264
265 parser->parse_type = ptr->parse_type;
266 parser->data_type = ptr->parse_type;
267 *line += ptr->len;
268
269 if (ptr->type == -1)
270 {
271 WCHAR *end;
272 DWORD val;
273
274 if (!**line || towlower((*line)[1]) == 'x')
275 return FALSE;
276
277 /* "hex(xx):" is special */
278 val = wcstoul(*line, &end, 16);
279#ifdef __REACTOS__
280 /* Up to 8 hex digits, "hex(000000002)" is invalid */
281 if (*end != ')' || *(end + 1) != ':' || (val == ~0u && errno == ERANGE) || end - *line > 8)
282#else
283 if (*end != ')' || *(end + 1) != ':' || (val == ~0u && errno == ERANGE))
284#endif
285 return FALSE;
286
288 *line = end + 2;
289 }
290 return TRUE;
291 }
292 return FALSE;
293}
294
295/******************************************************************************
296 * Replaces escape sequences with their character equivalents and
297 * null-terminates the string on the first non-escaped double quote.
298 *
299 * Assigns a pointer to the remaining unparsed data in the line.
300 * Returns TRUE or FALSE to indicate whether a closing double quote was found.
301 */
302static BOOL unescape_string(WCHAR *str, WCHAR **unparsed)
303{
304 int str_idx = 0; /* current character under analysis */
305 int val_idx = 0; /* the last character of the unescaped string */
306 int len = lstrlenW(str);
307 BOOL ret;
308
309 for (str_idx = 0; str_idx < len; str_idx++, val_idx++)
310 {
311 if (str[str_idx] == '\\')
312 {
313 str_idx++;
314 switch (str[str_idx])
315 {
316 case 'n':
317 str[val_idx] = '\n';
318 break;
319 case 'r':
320 str[val_idx] = '\r';
321 break;
322 case '0':
323 return FALSE;
324 case '\\':
325 case '"':
326 str[val_idx] = str[str_idx];
327 break;
328 default:
329 if (!str[str_idx]) return FALSE;
331 str[val_idx] = str[str_idx];
332 break;
333 }
334 }
335 else if (str[str_idx] == '"')
336 break;
337 else
338 str[val_idx] = str[str_idx];
339 }
340
341 ret = (str[str_idx] == '"');
342 *unparsed = str + str_idx + 1;
343 str[val_idx] = '\0';
344 return ret;
345}
346
348{
349 if (!key_name) return 0;
350
351 *key_path = wcschr(key_name, '\\');
352 if (*key_path) (*key_path)++;
353
355}
356
357static void close_key(struct parser *parser)
358{
359 if (parser->hkey)
360 {
363
365 parser->hkey = NULL;
366 }
367}
368
370{
371 HKEY key_class;
372 WCHAR *key_path;
373 LONG res;
374
376
377 /* Get the registry class */
378 if (!path || !(key_class = parse_key_name(path, &key_path)))
380
381 res = RegCreateKeyExW(key_class, key_path, 0, NULL, REG_OPTION_NON_VOLATILE,
383
384 if (res == ERROR_SUCCESS)
385 {
386 parser->key_name = malloc((lstrlenW(path) + 1) * sizeof(WCHAR));
388 }
389 else
390 parser->hkey = NULL;
391
392 return res;
393}
394
395static void free_parser_data(struct parser *parser)
396{
398 free(parser->data);
399
400 parser->data = NULL;
401 parser->data_size = 0;
402}
403
405{
408 {
409 if (parser->is_unicode)
410 {
411 WCHAR *data = parser->data;
412 DWORD len = parser->data_size / sizeof(WCHAR);
413
414 if (data[len - 1] != 0)
415 {
416 data[len] = 0;
417 parser->data_size += sizeof(WCHAR);
418 }
419 }
420 else
421 {
422 BYTE *data = parser->data;
423
424 if (data[parser->data_size - 1] != 0)
425 {
426 data[parser->data_size] = 0;
427 parser->data_size++;
428 }
429
431 parser->data_size *= sizeof(WCHAR);
432 free(data);
433 }
434 }
435}
436
444
446{
447 static const WCHAR *header_31 = L"REGEDIT";
448
449 while (*s == ' ' || *s == '\t') s++;
450
451 if (!lstrcmpW(s, header_31))
452 return REG_VERSION_31;
453
454 if (!lstrcmpW(s, L"REGEDIT4"))
455 return REG_VERSION_40;
456
457 if (!lstrcmpW(s, L"Windows Registry Editor Version 5.00"))
458 return REG_VERSION_50;
459
460 /* The Windows version accepts registry file headers beginning with "REGEDIT" and ending
461 * with other characters, as long as "REGEDIT" appears at the start of the line. For example,
462 * "REGEDIT 4", "REGEDIT9" and "REGEDIT4FOO" are all treated as valid file headers.
463 * In all such cases, however, the contents of the registry file are not imported.
464 */
465 if (!wcsncmp(s, header_31, 7)) /* "REGEDIT" without NUL */
466 return REG_VERSION_FUZZY;
467
468 return REG_VERSION_INVALID;
469}
470
471/* handler for parser HEADER state */
473{
474 WCHAR *line, *header;
475
476 if (!(line = get_line(parser->file)))
477 return NULL;
478
479 if (!parser->is_unicode)
480 {
481 header = malloc((lstrlenW(line) + 3) * sizeof(WCHAR));
482 header[0] = parser->two_wchars[0];
483 header[1] = parser->two_wchars[1];
484 lstrcpyW(header + 2, line);
486 free(header);
487 }
489
490 switch (parser->reg_version)
491 {
492 case REG_VERSION_31:
494 break;
495 case REG_VERSION_40:
496 case REG_VERSION_50:
498 break;
499 default:
500 get_line(NULL); /* Reset static variables */
501 return NULL;
502 }
503
504 return line;
505}
506
507/* handler for parser PARSE_WIN31_LINE state */
509{
510 WCHAR *line, *value;
511 unsigned int key_end = 0;
512
513 if (!(line = get_line(parser->file)))
514 return NULL;
515
516 if (wcsncmp(line, L"HKEY_CLASSES_ROOT", 17)) /* "HKEY_CLASSES_ROOT" without NUL */
517 return line;
518
519 /* get key name */
520 while (line[key_end] && !iswspace(line[key_end])) key_end++;
521
522 value = line + key_end;
523 while (*value == ' ' || *value == '\t') value++;
524
525 if (*value == '=') value++;
526 if (*value == ' ') value++; /* at most one space is skipped */
527
528 line[key_end] = 0;
529
531 {
533 return line;
534 }
535
538 parser->data = value;
539 parser->data_size = (lstrlenW(value) + 1) * sizeof(WCHAR);
540
542 return value;
543}
544
545/* handler for parser LINE_START state */
547{
548 WCHAR *line, *p;
549
550 if (!(line = get_line(parser->file)))
551 return NULL;
552
553 for (p = line; *p; p++)
554 {
555 switch (*p)
556 {
557 case '[':
559 return p + 1;
560 case '@':
562 return p;
563 case '"':
565 return p + 1;
566 case ' ':
567 case '\t':
568 break;
569 default:
570 return p;
571 }
572 }
573
574 return p;
575}
576
577/* handler for parser KEY_NAME state */
579{
580 WCHAR *p = pos, *key_end;
581
582 if (*p == ' ' || *p == '\t' || !(key_end = wcsrchr(p, ']')))
583 goto done;
584
585 *key_end = 0;
586
587 if (*p == '-')
588 {
590 return p + 1;
591 }
592 else if (open_key(parser, p) != ERROR_SUCCESS)
594
595done:
597 return p;
598}
599
600/* handler for parser DELETE_KEY state */
602{
603 WCHAR *p = pos;
604
606
607 if (*p == 'H' || *p == 'h')
608 {
609 HKEY root;
610 WCHAR *path;
611
613
614 if (root && path && *path)
616 }
617
619 return p;
620}
621
622/* handler for parser DEFAULT_VALUE_NAME state */
624{
627
629 return pos + 1;
630}
631
632/* handler for parser QUOTED_VALUE_NAME state */
634{
635 WCHAR *val_name = pos, *p;
636
639
640 if (!unescape_string(val_name, &p))
641 goto invalid;
642
643 /* copy the value name in case we need to parse multiple lines and the buffer is overwritten */
644 parser->value_name = malloc((lstrlenW(val_name) + 1) * sizeof(WCHAR));
645 lstrcpyW(parser->value_name, val_name);
646
648 return p;
649
650invalid:
652 return val_name;
653}
654
655/* handler for parser DATA_START state */
657{
658 WCHAR *p = pos;
659 unsigned int len;
660
661 while (*p == ' ' || *p == '\t') p++;
662 if (*p != '=') goto invalid;
663 p++;
664 while (*p == ' ' || *p == '\t') p++;
665
666 /* trim trailing whitespace */
667 len = lstrlenW(p);
668 while (len > 0 && (p[len - 1] == ' ' || p[len - 1] == '\t')) len--;
669 p[len] = 0;
670
671 if (*p == '-')
673 else
675 return p;
676
677invalid:
679 return p;
680}
681
682/* handler for parser DELETE_VALUE state */
684{
685 WCHAR *p = pos + 1;
686
687 while (*p == ' ' || *p == '\t') p++;
688 if (*p && *p != ';') goto done;
689
691
692done:
694 return p;
695}
696
697/* handler for parser DATA_TYPE state */
699{
700 WCHAR *line = pos;
701
703 {
705 return line;
706 }
707
708 switch (parser->parse_type)
709 {
710 case REG_SZ:
712 break;
713 case REG_DWORD:
715 break;
716 case REG_BINARY: /* all hex data types, including undefined */
718 break;
719 default:
721 }
722
723 return line;
724}
725
726/* handler for parser STRING_DATA state */
728{
729 WCHAR *line;
730
731 parser->data = pos;
732
734 goto invalid;
735
736 while (*line == ' ' || *line == '\t') line++;
737 if (*line && *line != ';') goto invalid;
738
739 parser->data_size = (lstrlenW(parser->data) + 1) * sizeof(WCHAR);
740
742 return line;
743
744invalid:
747 return line;
748}
749
750/* handler for parser DWORD_DATA state */
752{
753 WCHAR *line = pos;
754
755 parser->data = malloc(sizeof(DWORD));
756
758 goto invalid;
759
760 parser->data_size = sizeof(DWORD);
761
763 return line;
764
765invalid:
768 return line;
769}
770
771/* handler for parser HEX_DATA state */
773{
774 WCHAR *line = pos;
775
776 if (!*line)
777 goto set_value;
778
780 goto invalid;
781
782 if (parser->backslash)
783 {
785 return line;
786 }
787
789
792 return line;
793
794invalid:
797 return line;
798}
799
800/* handler for parser EOL_BACKSLASH state */
802{
803 WCHAR *p = pos;
804
805 while (*p == ' ' || *p == '\t') p++;
806 if (*p && *p != ';') goto invalid;
807
809 return pos;
810
811invalid:
814 return p;
815}
816
817/* handler for parser HEX_MULTILINE state */
819{
820 WCHAR *line;
821
822 if (!(line = get_line(parser->file)))
823 {
826 return pos;
827 }
828
829 while (*line == ' ' || *line == '\t') line++;
830 if (!*line || *line == ';') return line;
831
832 if (!iswxdigit(*line)) goto invalid;
833
835 return line;
836
837invalid:
840 return line;
841}
842
843/* handler for parser UNKNOWN_DATA state */
845{
846 FIXME("Unknown registry data type [0x%x]\n", parser->data_type);
847
849 return pos;
850}
851
852/* handler for parser SET_VALUE state */
854{
857
859
862 else
864
865 return pos;
866}
867
868#define REG_VAL_BUF_SIZE 4096
869
870static WCHAR *get_lineA(FILE *fp)
871{
872 static WCHAR *lineW;
873 static size_t size;
874 static char *buf, *next;
875 char *line;
876
877 free(lineW);
878
879 if (!fp) goto cleanup;
880
881 if (!size)
882 {
884 buf = malloc(size);
885 *buf = 0;
886 next = buf;
887 }
888 line = next;
889
890 while (next)
891 {
892 char *p = strpbrk(line, "\r\n");
893 if (!p)
894 {
895 size_t len, count;
896 len = strlen(next);
897 memmove(buf, next, len + 1);
898 if (size - len < 3)
899 {
900 size *= 2;
901 buf = realloc(buf, size);
902 }
903 if (!(count = fread(buf + len, 1, size - len - 1, fp)))
904 {
905 next = NULL;
906 lineW = GetWideString(buf);
907 return lineW;
908 }
909 buf[len + count] = 0;
910 next = buf;
911 line = buf;
912 continue;
913 }
914 next = p + 1;
915 if (*p == '\r' && *(p + 1) == '\n') next++;
916 *p = 0;
917 lineW = GetWideString(line);
918 return lineW;
919 }
920
921cleanup:
922 lineW = NULL;
923 free(buf);
924 size = 0;
925 return NULL;
926}
927
928static WCHAR *get_lineW(FILE *fp)
929{
930 static size_t size;
931 static WCHAR *buf, *next;
932 WCHAR *line;
933
934 if (!fp) goto cleanup;
935
936 if (!size)
937 {
939 buf = malloc(size * sizeof(WCHAR));
940 *buf = 0;
941 next = buf;
942 }
943 line = next;
944
945 while (next)
946 {
947 WCHAR *p = wcspbrk(line, L"\r\n");
948 if (!p)
949 {
950 size_t len, count;
951 len = lstrlenW(next);
952 memmove(buf, next, (len + 1) * sizeof(WCHAR));
953 if (size - len < 3)
954 {
955 size *= 2;
956 buf = realloc(buf, size * sizeof(WCHAR));
957 }
958 if (!(count = fread(buf + len, sizeof(WCHAR), size - len - 1, fp)))
959 {
960 next = NULL;
961 return buf;
962 }
963 buf[len + count] = 0;
964 next = buf;
965 line = buf;
966 continue;
967 }
968 next = p + 1;
969 if (*p == '\r' && *(p + 1) == '\n') next++;
970 *p = 0;
971 return line;
972 }
973
974cleanup:
975 free(buf);
976 size = 0;
977 return NULL;
978}
979
980int reg_import(int argc, WCHAR *argvW[])
981{
982 WCHAR *filename, *pos;
983 FILE *fp;
984 BYTE s[2];
985 struct parser parser;
986
987 if (argc > 4) goto invalid;
988
989 parser.sam = 0;
990
991 if (argc == 4)
992 {
993 WCHAR *str = argvW[3];
994
995 if (*str != '/' && *str != '-')
996 goto invalid;
997
998 str++;
999
1000 if (!lstrcmpiW(str, L"reg:32"))
1002 else if (!lstrcmpiW(str, L"reg:64"))
1004 else
1005 goto invalid;
1006 }
1007
1008 filename = argvW[2];
1009
1010 fp = _wfopen(filename, L"rb");
1011 if (!fp)
1012 {
1014 return 1;
1015 }
1016
1017 if (fread(s, sizeof(WCHAR), 1, fp) != 1)
1018 goto error;
1019
1020 parser.is_unicode = (s[0] == 0xff && s[1] == 0xfe);
1022
1023 parser.file = fp;
1024 parser.two_wchars[0] = s[0];
1025 parser.two_wchars[1] = s[1];
1026 parser.reg_version = -1;
1027 parser.hkey = NULL;
1030 parser.parse_type = 0;
1031 parser.data_type = 0;
1032 parser.data = NULL;
1033 parser.data_size = 0;
1036
1038
1039 /* parser main loop */
1040 while (pos)
1042
1044 goto error;
1045
1047 close_key(&parser);
1048
1049 fclose(fp);
1050 return 0;
1051
1052error:
1053 fclose(fp);
1054 return 1;
1055
1056invalid:
1059 return 1;
1060}
static int argc
Definition: ServiceArgs.c:12
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
#define ERANGE
Definition: acclib.h:92
char * strpbrk(const char *String, const char *Delimiters)
Definition: utclib.c:302
static int state
Definition: maze.c:121
#define WINE_DEFAULT_DEBUG_CHANNEL(t)
Definition: precomp.h:23
#define STRING_FILE_NOT_FOUND
Definition: resource.h:8
static WCHAR * default_value_name_state(struct parser *parser, WCHAR *pos)
Definition: import.c:623
#define REG_VAL_BUF_SIZE
Definition: import.c:868
static WCHAR * hex_data_state(struct parser *parser, WCHAR *pos)
Definition: import.c:772
static WCHAR * dword_data_state(struct parser *parser, WCHAR *pos)
Definition: import.c:751
static WCHAR * string_data_state(struct parser *parser, WCHAR *pos)
Definition: import.c:727
int reg_import(int argc, WCHAR *argvW[])
Definition: import.c:980
static WCHAR * key_name_state(struct parser *parser, WCHAR *pos)
Definition: import.c:578
static void prepare_hex_string_data(struct parser *parser)
Definition: import.c:404
static WCHAR * delete_value_state(struct parser *parser, WCHAR *pos)
Definition: import.c:683
static WCHAR * eol_backslash_state(struct parser *parser, WCHAR *pos)
Definition: import.c:801
static WCHAR * data_type_state(struct parser *parser, WCHAR *pos)
Definition: import.c:698
static BOOL convert_hex_to_dword(WCHAR *str, DWORD *dw)
Definition: import.c:151
static WCHAR * GetWideString(const char *strA)
Definition: import.c:26
static enum reg_versions parse_file_header(const WCHAR *s)
Definition: import.c:445
static BOOL convert_hex_csv_to_hex(struct parser *parser, WCHAR **str)
Definition: import.c:185
static enum parser_state set_state(struct parser *parser, enum parser_state state)
Definition: import.c:141
static void free_parser_data(struct parser *parser)
Definition: import.c:395
static WCHAR * set_value_state(struct parser *parser, WCHAR *pos)
Definition: import.c:853
static WCHAR * data_start_state(struct parser *parser, WCHAR *pos)
Definition: import.c:656
WCHAR *(* parser_state_func)(struct parser *parser, WCHAR *pos)
Definition: import.c:98
static WCHAR * get_lineA(FILE *fp)
Definition: import.c:870
static WCHAR * unknown_data_state(struct parser *parser, WCHAR *pos)
Definition: import.c:844
static BOOL parse_data_type(struct parser *parser, WCHAR **line)
Definition: import.c:245
parser_state
Definition: import.c:59
@ PARSE_WIN31_LINE
Definition: import.c:61
@ HEX_DATA
Definition: import.c:72
@ DEFAULT_VALUE_NAME
Definition: import.c:65
@ HEADER
Definition: import.c:60
@ NB_PARSER_STATES
Definition: import.c:77
@ STRING_DATA
Definition: import.c:70
@ QUOTED_VALUE_NAME
Definition: import.c:66
@ DATA_TYPE
Definition: import.c:69
@ HEX_MULTILINE
Definition: import.c:74
@ UNKNOWN_DATA
Definition: import.c:75
@ LINE_START
Definition: import.c:62
@ EOL_BACKSLASH
Definition: import.c:73
@ SET_VALUE
Definition: import.c:76
@ DELETE_VALUE
Definition: import.c:68
@ DWORD_DATA
Definition: import.c:71
@ KEY_NAME
Definition: import.c:63
@ DATA_START
Definition: import.c:67
@ DELETE_KEY
Definition: import.c:64
reg_versions
Definition: import.c:437
@ REG_VERSION_50
Definition: import.c:440
@ REG_VERSION_INVALID
Definition: import.c:442
@ REG_VERSION_40
Definition: import.c:439
@ REG_VERSION_FUZZY
Definition: import.c:441
@ REG_VERSION_31
Definition: import.c:438
static WCHAR * get_lineW(FILE *fp)
Definition: import.c:928
static WCHAR * quoted_value_name_state(struct parser *parser, WCHAR *pos)
Definition: import.c:633
static HKEY parse_key_name(WCHAR *key_name, WCHAR **key_path)
Definition: import.c:347
static WCHAR *(* get_line)(FILE *)
Definition: import.c:55
static WCHAR * parse_win31_line_state(struct parser *parser, WCHAR *pos)
Definition: import.c:508
static WCHAR * delete_key_state(struct parser *parser, WCHAR *pos)
Definition: import.c:601
static WCHAR * GetWideStringN(const char *strA, int size, DWORD *len)
Definition: import.c:40
static WCHAR * hex_multiline_state(struct parser *parser, WCHAR *pos)
Definition: import.c:818
static BOOL unescape_string(WCHAR *str, WCHAR **unparsed)
Definition: import.c:302
static WCHAR * header_state(struct parser *parser, WCHAR *pos)
Definition: import.c:472
static WCHAR * line_start_state(struct parser *parser, WCHAR *pos)
Definition: import.c:546
static const parser_state_func parser_funcs[NB_PARSER_STATES]
Definition: import.c:119
HKEY path_get_rootkey(const WCHAR *path)
Definition: reg.c:165
void WINAPIV output_message(unsigned int id,...)
Definition: reg.c:92
#define STRING_INVALID_SYNTAX
Definition: resource.h:33
#define STRING_KEY_IMPORT_FAILED
Definition: resource.h:81
#define STRING_FUNC_HELP
Definition: resource.h:34
#define STRING_ESCAPE_SEQUENCE
Definition: resource.h:80
#define FIXME(fmt,...)
Definition: debug.h:111
#define RegCloseKey(hKey)
Definition: registry.h:49
struct _root root
while(CdLookupNextInitialFileDirent(IrpContext, Fcb, FileContext))
LSTATUS WINAPI RegDeleteTreeW(_In_ HKEY, _In_opt_ LPCWSTR)
#define realloc
Definition: debug_ros.c:6
#define free
Definition: debug_ros.c:5
#define malloc
Definition: debug_ros.c:4
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
static HRESULT set_value(struct d3dx_parameter *param, const void *data, unsigned int bytes, void *dst_data)
Definition: effect.c:889
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:1096
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:4882
LONG WINAPI RegDeleteValueW(HKEY hKey, LPCWSTR lpValueName)
Definition: reg.c:2330
#define wcschr
Definition: compat.h:17
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define wcsrchr
Definition: compat.h:16
#define CP_ACP
Definition: compat.h:109
#define lstrcpyW
Definition: compat.h:749
#define MultiByteToWideChar
Definition: compat.h:110
#define lstrlenW
Definition: compat.h:750
static void cleanup(void)
Definition: main.c:1335
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLdouble s
Definition: gl.h:2039
GLuint GLuint end
Definition: gl.h:1545
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLsizeiptr size
Definition: glext.h:5919
GLuint res
Definition: glext.h:9613
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLuint GLfloat * val
Definition: glext.h:7180
GLfloat GLfloat p
Definition: glext.h:8902
GLenum GLsizei len
Definition: glext.h:6722
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
static int reg
Definition: i386-dis.c:1290
#define iswspace(_c)
Definition: ctype.h:669
#define iswxdigit(_c)
Definition: ctype.h:668
_Check_return_ _CRTIMP FILE *__cdecl _wfopen(_In_z_ const wchar_t *_Filename, _In_z_ const wchar_t *_Mode)
_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)
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
_Check_return_ unsigned long __cdecl wcstoul(_In_z_ const wchar_t *_Str, _Out_opt_ _Deref_post_z_ wchar_t **_EndPtr, _In_ int _Radix)
REFIID LPVOID DWORD_PTR dw
Definition: atlbase.h:40
parser_state
Definition: infcore.c:26
const char * filename
Definition: ioapi.h:137
#define d
Definition: ke_i.h:81
#define REG_SZ
Definition: layer.c:22
int WINAPI lstrcmpiW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:194
int WINAPI lstrcmpW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:170
#define error(str)
Definition: mkdosfs.c:1605
#define memmove(s1, s2, n)
Definition: mkisofs.h:881
static PVOID ptr
Definition: dispmode.c:27
static const WCHAR invalid[]
Definition: assoc.c:39
WCHAR strW[12]
Definition: clipboard.c:2029
char strA[12]
Definition: clipboard.c:2028
#define REG_BINARY
Definition: nt_native.h:1496
#define KEY_ALL_ACCESS
Definition: nt_native.h:1041
#define REG_OPTION_NON_VOLATILE
Definition: nt_native.h:1057
#define REG_MULTI_SZ
Definition: nt_native.h:1501
#define DWORD
Definition: nt_native.h:44
#define REG_EXPAND_SZ
Definition: nt_native.h:1494
#define L(x)
Definition: ntvdm.h:50
long LONG
Definition: pedump.c:60
static unsigned __int64 next
Definition: rand_nt.c:6
#define open_key(r, p, s, k)
Definition: reg_test.h:49
#define close_key(k)
Definition: reg_test.h:52
const WCHAR * str
#define REG_DWORD
Definition: sdbapi.c:596
#define errno
Definition: errno.h:18
_Check_return_ _CRTIMP _CONST_RETURN wchar_t *__cdecl wcspbrk(_In_z_ const wchar_t *_Str, _In_z_ const wchar_t *_Control)
_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)
_CRTIMP wchar_t *__cdecl _wcsupr(_Inout_z_ wchar_t *_String)
int parse_type(Type t, const vector< string > &tokens, int off, vector< string > &names, vector< string > &dependencies)
Definition: sdkparse.cpp:653
Definition: parser.c:49
Definition: import.c:81
BOOL is_unicode
Definition: import.c:84
BOOL backslash
Definition: import.c:94
enum parser_state state
Definition: import.c:95
WCHAR * value_name
Definition: import.c:89
REGSAM sam
Definition: import.c:86
WCHAR two_wchars[2]
Definition: import.c:83
short int reg_version
Definition: import.c:85
DWORD data_size
Definition: import.c:93
void * data
Definition: import.c:92
HKEY hkey
Definition: import.c:87
DWORD data_type
Definition: import.c:91
DWORD parse_type
Definition: import.c:90
WCHAR * key_name
Definition: import.c:88
FILE * file
Definition: import.c:82
Definition: ecma_167.h:138
#define towlower(c)
Definition: wctype.h:97
Definition: pdh_main.c:94
int ret
ACCESS_MASK REGSAM
Definition: winreg.h:69
#define KEY_WOW64_32KEY
Definition: cmtypes.h:45
#define KEY_WOW64_64KEY
Definition: cmtypes.h:46
__wchar_t WCHAR
Definition: xmlstorage.h:180
unsigned char BYTE
Definition: xxhash.c:193