2 * Registry processing routines. Routines, common for registry
3 * processing frontends.
5 * Copyright 1999 Sylvain St-Germain
6 * Copyright 2002 Andriy Palamarchuk
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
31 #define REG_VAL_BUF_SIZE 4096
33 /* Delimiters used to parse the "value" to query queryValue*/
34 #define QUERY_VALUE_MAX_ARGS 1
36 /* maximal number of characters in hexadecimal data line,
37 not including '\' character */
38 #define REG_FILE_HEX_LINE_LEN 76
40 /* Globals used by the api setValue, queryValue */
41 static LPSTR currentKeyName
= NULL
;
42 static HKEY currentKeyClass
= 0;
43 static HKEY currentKeyHandle
= 0;
44 static BOOL bTheKeyIsOpen
= FALSE
;
46 static const CHAR
*app_name
= "UNKNOWN";
48 static const CHAR
*reg_class_names
[] = {
49 "HKEY_LOCAL_MACHINE", "HKEY_USERS", "HKEY_CLASSES_ROOT",
50 "HKEY_CURRENT_CONFIG", "HKEY_CURRENT_USER", "HKEY_DYN_DATA"
53 #define REG_CLASS_NUMBER (sizeof(reg_class_names) / sizeof(reg_class_names[0]))
55 static HKEY reg_class_keys
[REG_CLASS_NUMBER
] = {
56 HKEY_LOCAL_MACHINE
, HKEY_USERS
, HKEY_CLASSES_ROOT
,
57 HKEY_CURRENT_CONFIG
, HKEY_CURRENT_USER
, HKEY_DYN_DATA
61 #define NOT_ENOUGH_MEMORY 1
64 /* processing macros */
66 /* common check of memory allocation results */
67 #define CHECK_ENOUGH_MEMORY(p) \
70 fprintf(stderr,"%s: file %s, line %d: Not enough memory", \
71 getAppName(), __FILE__, __LINE__); \
72 exit(NOT_ENOUGH_MEMORY); \
75 /******************************************************************************
76 * This is a replacement for strsep which is not portable (missing on Solaris).
80 char* getToken(char** str
, const char* delims
)
91 if (strchr(delims
,**str
)!=NULL
) {
98 /* There is no other token */
104 /******************************************************************************
105 * Copies file name from command line string to the buffer.
106 * Rewinds the command line string pointer to the next non-space character
107 * after the file name.
108 * Buffer contains an empty string if no filename was found;
111 * command_line - command line current position pointer
112 * where *s[0] is the first symbol of the file name.
113 * file_name - buffer to write the file name to.
115 void get_file_name(CHAR
**command_line
, CHAR
*file_name
)
117 CHAR
*s
= *command_line
;
118 int pos
= 0; /* position of pointer "s" in *command_line */
130 fprintf(stderr
,"%s: Unexpected end of file name!\n",
138 while(s
[0] && !isspace(s
[0])) {
143 memcpy(file_name
, *command_line
, pos
* sizeof((*command_line
)[0]));
144 /* remove the last backslash */
145 if (file_name
[pos
- 1] == '\\') {
146 file_name
[pos
- 1] = '\0';
148 file_name
[pos
] = '\0';
155 while(s
[0] && isspace(s
[0])) {
159 (*command_line
) += pos
;
163 /******************************************************************************
164 * Converts a hex representation of a DWORD into a DWORD.
166 DWORD
convertHexToDWord(char *str
, BYTE
*buf
)
173 sscanf(xbuf
,"%08lx",&dw
);
174 memcpy(buf
,&dw
,sizeof(DWORD
));
175 return sizeof(DWORD
);
178 /******************************************************************************
179 * Converts a hex buffer into a hex comma separated values
181 char* convertHexToHexCSV(BYTE
*buf
, ULONG bufLen
)
189 str
= HeapAlloc(GetProcessHeap(), 0, (bufLen
+1)*2);
190 memset(str
, 0, (bufLen
+1)*2);
191 ptrStr
= str
; /* Pointer to result */
192 ptrBuf
= buf
; /* Pointer to current */
194 while (current
< bufLen
) {
195 BYTE bCur
= ptrBuf
[current
++];
198 sprintf(res
, "%02x", (unsigned int)*&bCur
);
203 /* Get rid of the last comma */
204 str
[strlen(str
)-1] = '\0';
208 /******************************************************************************
209 * Converts a hex buffer into a DWORD string
211 char* convertHexToDWORDStr(BYTE
*buf
, ULONG bufLen
)
216 if ( bufLen
!= sizeof(DWORD
) ) return NULL
;
218 str
= HeapAlloc(GetProcessHeap(), 0, (bufLen
*2)+1);
220 memcpy(&dw
,buf
,sizeof(DWORD
));
221 sprintf(str
, "%08lx", dw
);
223 /* Get rid of the last comma */
227 /******************************************************************************
228 * Converts a hex comma separated values list into a hex list.
229 * The Hex input string must be in exactly the correct form.
231 DWORD
convertHexCSVToHex(char *str
, BYTE
*buf
, ULONG bufLen
)
233 char *s
= str
; /* Pointer to current */
234 char *b
= (char*) buf
; /* Pointer to result */
236 ULONG strLen
= strlen(str
);
240 memset(buf
, 0, bufLen
);
243 * warn the user if we are here with a string longer than 2 bytes that does
244 * not contains ",". It is more likely because the data is invalid.
246 if ( ( strLen
> 2) && ( strchr(str
, ',') == NULL
) )
247 fprintf(stderr
,"%s: WARNING converting CSV hex stream with no comma, "
248 "input data seems invalid.\n", getAppName());
249 if (strLen
> 3*bufLen
)
250 fprintf(stderr
,"%s: ERROR converting CSV hex stream. Too long\n",
253 while (strPos
< strLen
) {
257 memcpy(xbuf
,s
,2); xbuf
[2]='\0';
258 sscanf(xbuf
,"%02x",&wc
);
259 if (byteCount
< bufLen
)
260 *b
++ =(unsigned char)wc
;
270 /******************************************************************************
271 * This function returns the HKEY associated with the data type encoded in the
272 * value. It modifies the input parameter (key value) in order to skip this
273 * "now useless" data type information.
275 * Note: Updated based on the algorithm used in 'server/registry.c'
277 DWORD
getDataType(LPSTR
*lpValue
, DWORD
* parse_type
)
279 struct data_type
{ const char *tag
; int len
; int type
; int parse_type
; };
281 static const struct data_type data_types
[] = { /* actual type */ /* type to assume for parsing */
282 { "\"", 1, REG_SZ
, REG_SZ
},
283 { "str:\"", 5, REG_SZ
, REG_SZ
},
284 { "str(2):\"", 8, REG_EXPAND_SZ
, REG_SZ
},
285 { "hex:", 4, REG_BINARY
, REG_BINARY
},
286 { "dword:", 6, REG_DWORD
, REG_DWORD
},
287 { "hex(", 4, -1, REG_BINARY
},
291 const struct data_type
*ptr
;
294 for (ptr
= data_types
; ptr
->tag
; ptr
++) {
295 if (memcmp( ptr
->tag
, *lpValue
, ptr
->len
))
299 *parse_type
= ptr
->parse_type
;
304 /* "hex(xx):" is special */
305 type
= (int)strtoul( *lpValue
, &end
, 16 );
306 if (**lpValue
=='\0' || *end
!=')' || *(end
+1)!=':') {
314 return (**lpValue
=='\0'?REG_SZ
:REG_NONE
);
317 /******************************************************************************
318 * Returns an allocated buffer with a cleaned copy (removed the surrounding
319 * dbl quotes) of the passed value.
321 LPSTR
getArg( LPSTR arg
)
330 * Get rid of surrounding quotes
334 if( arg
[len
-1] == '\"' ) arg
[len
-1] = '\0';
335 if( arg
[0] == '\"' ) arg
++;
337 tmp
= HeapAlloc(GetProcessHeap(), 0, strlen(arg
)+1);
343 /******************************************************************************
344 * Replaces escape sequences with the characters.
346 static void REGPROC_unescape_string(LPSTR str
)
348 int str_idx
= 0; /* current character under analysis */
349 int val_idx
= 0; /* the last character of the unescaped string */
350 int len
= strlen(str
);
351 for (str_idx
= 0; str_idx
< len
; str_idx
++, val_idx
++) {
352 if (str
[str_idx
] == '\\') {
354 switch (str
[str_idx
]) {
360 str
[val_idx
] = str
[str_idx
];
363 fprintf(stderr
,"Warning! Unrecognized escape sequence: \\%c'\n",
365 str
[val_idx
] = str
[str_idx
];
369 str
[val_idx
] = str
[str_idx
];
375 /******************************************************************************
376 * Sets the value with name val_name to the data in val_data for the currently
380 * val_name - name of the registry value
381 * val_data - registry value data
383 HRESULT
setValue(LPSTR val_name
, LPSTR val_data
)
386 DWORD dwDataType
, dwParseType
;
388 BYTE convert
[KEY_MAX_LEN
];
389 BYTE
*bBigBuffer
= 0;
392 if ( (val_name
== NULL
) || (val_data
== NULL
) )
393 return ERROR_INVALID_PARAMETER
;
395 /* Get the data type stored into the value field */
396 dwDataType
= getDataType(&val_data
, &dwParseType
);
398 if ( dwParseType
== REG_SZ
) /* no conversion for string */
400 REGPROC_unescape_string(val_data
);
401 /* Compute dwLen after REGPROC_unescape_string because it may
402 * have changed the string length and we don't want to store
403 * the extra garbage in the registry.
405 dwLen
= strlen(val_data
);
406 if (dwLen
>0 && val_data
[dwLen
-1]=='"')
409 val_data
[dwLen
]='\0';
411 lpbData
= (BYTE
*) val_data
;
412 } else if (dwParseType
== REG_DWORD
) /* Convert the dword types */
414 dwLen
= convertHexToDWord(val_data
, convert
);
416 } else /* Convert the hexadecimal types */
418 int b_len
= strlen (val_data
)+2/3;
419 if (b_len
> KEY_MAX_LEN
) {
420 bBigBuffer
= HeapAlloc (GetProcessHeap(), 0, b_len
);
421 CHECK_ENOUGH_MEMORY(bBigBuffer
);
422 dwLen
= convertHexCSVToHex(val_data
, bBigBuffer
, b_len
);
423 lpbData
= bBigBuffer
;
425 dwLen
= convertHexCSVToHex(val_data
, convert
, KEY_MAX_LEN
);
430 hRes
= RegSetValueEx(
438 HeapFree (GetProcessHeap(), 0, bBigBuffer
);
443 /******************************************************************************
446 HRESULT
openKey( LPSTR stdInput
)
452 if (stdInput
== NULL
)
453 return ERROR_INVALID_PARAMETER
;
455 /* Get the registry class */
456 currentKeyClass
= getRegClass(stdInput
); /* Sets global variable */
457 if (currentKeyClass
== (HKEY
)ERROR_INVALID_PARAMETER
)
458 return (HRESULT
)ERROR_INVALID_PARAMETER
;
460 /* Get the key name */
461 currentKeyName
= getRegKeyName(stdInput
); /* Sets global variable */
462 if (currentKeyName
== NULL
)
463 return ERROR_INVALID_PARAMETER
;
465 hRes
= RegCreateKeyEx(
466 currentKeyClass
, /* Class */
467 currentKeyName
, /* Sub Key */
469 NULL
, /* object type */
470 REG_OPTION_NON_VOLATILE
, /* option, REG_OPTION_NON_VOLATILE ... */
471 KEY_ALL_ACCESS
, /* access mask, KEY_ALL_ACCESS */
472 NULL
, /* security attribute */
473 ¤tKeyHandle
, /* result */
474 &dwDisp
); /* disposition, REG_CREATED_NEW_KEY or
475 REG_OPENED_EXISTING_KEY */
477 if (hRes
== ERROR_SUCCESS
)
478 bTheKeyIsOpen
= TRUE
;
484 /******************************************************************************
485 * Extracts from [HKEY\some\key\path] or HKEY\some\key\path types of line
486 * the key name (what starts after the first '\')
488 LPSTR
getRegKeyName(LPSTR lpLine
)
491 char lpLineCopy
[KEY_MAX_LEN
];
496 strcpy(lpLineCopy
, lpLine
);
498 keyNameBeg
= strchr(lpLineCopy
, '\\'); /* The key name start by '\' */
502 keyNameBeg
++; /* is not part of the name */
503 keyNameEnd
= strchr(lpLineCopy
, ']');
505 *keyNameEnd
= '\0'; /* remove ']' from the key name */
508 keyNameBeg
= lpLineCopy
+ strlen(lpLineCopy
); /* branch - empty string */
510 currentKeyName
= HeapAlloc(GetProcessHeap(), 0, strlen(keyNameBeg
) + 1);
511 CHECK_ENOUGH_MEMORY(currentKeyName
);
512 strcpy(currentKeyName
, keyNameBeg
);
513 return currentKeyName
;
516 /******************************************************************************
517 * Extracts from [HKEY\some\key\path] or HKEY\some\key\path types of line
518 * the key class (what ends before the first '\')
520 HKEY
getRegClass(LPSTR lpClass
)
526 char lpClassCopy
[KEY_MAX_LEN
];
529 return (HKEY
)ERROR_INVALID_PARAMETER
;
531 lstrcpynA(lpClassCopy
, lpClass
, KEY_MAX_LEN
);
533 classNameEnd
= strchr(lpClassCopy
, '\\'); /* The class name ends by '\' */
534 if (!classNameEnd
) /* or the whole string */
536 classNameEnd
= lpClassCopy
+ strlen(lpClassCopy
);
537 if (classNameEnd
[-1] == ']')
542 *classNameEnd
= '\0'; /* Isolate the class name */
543 if (lpClassCopy
[0] == '[') {
544 classNameBeg
= lpClassCopy
+ 1;
546 classNameBeg
= lpClassCopy
;
549 for (i
= 0; i
< REG_CLASS_NUMBER
; i
++) {
550 if (!strcmp(classNameBeg
, reg_class_names
[i
])) {
551 return reg_class_keys
[i
];
554 return (HKEY
)ERROR_INVALID_PARAMETER
;
557 /******************************************************************************
558 * Close the currently opened key.
562 RegCloseKey(currentKeyHandle
);
564 HeapFree(GetProcessHeap(), 0, currentKeyName
); /* Allocated by getKeyName */
566 bTheKeyIsOpen
= FALSE
;
568 currentKeyName
= NULL
;
570 currentKeyHandle
= 0;
573 /******************************************************************************
574 * This function is the main entry point to the setValue type of action. It
575 * receives the currently read line and dispatch the work depending on the
578 void doSetValue(LPSTR stdInput
)
581 * We encountered the end of the file, make sure we
582 * close the opened key and exit
584 if (stdInput
== NULL
) {
585 if (bTheKeyIsOpen
!= FALSE
)
591 if ( stdInput
[0] == '[') /* We are reading a new key */
593 if ( bTheKeyIsOpen
!= FALSE
)
594 closeKey(); /* Close the previous key before */
596 if ( openKey(stdInput
) != ERROR_SUCCESS
)
597 fprintf(stderr
,"%s: setValue failed to open key %s\n",
598 getAppName(), stdInput
);
599 } else if( ( bTheKeyIsOpen
) &&
600 (( stdInput
[0] == '@') || /* reading a default @=data pair */
601 ( stdInput
[0] == '\"'))) /* reading a new value=data pair */
603 processSetValue(stdInput
);
604 } else /* since we are assuming that the */
605 { /* file format is valid we must */
606 if ( bTheKeyIsOpen
) /* be reading a blank line which */
607 closeKey(); /* indicate end of this key processing */
611 /******************************************************************************
612 * This function is the main entry point to the queryValue type of action. It
613 * receives the currently read line and dispatch the work depending on the
616 void doQueryValue(LPSTR stdInput
)
619 * We encountered the end of the file, make sure we
620 * close the opened key and exit
622 if (stdInput
== NULL
) {
623 if (bTheKeyIsOpen
!= FALSE
)
629 if ( stdInput
[0] == '[') /* We are reading a new key */
631 if ( bTheKeyIsOpen
!= FALSE
)
632 closeKey(); /* Close the previous key before */
634 if ( openKey(stdInput
) != ERROR_SUCCESS
)
635 fprintf(stderr
,"%s: queryValue failed to open key %s\n",
636 getAppName(), stdInput
);
637 } else if( ( bTheKeyIsOpen
) &&
638 (( stdInput
[0] == '@') || /* reading a default @=data pair */
639 ( stdInput
[0] == '\"'))) /* reading a new value=data pair */
641 processQueryValue(stdInput
);
642 } else /* since we are assuming that the */
643 { /* file format is valid we must */
644 if ( bTheKeyIsOpen
) /* be reading a blank line which */
645 closeKey(); /* indicate end of this key processing */
649 /******************************************************************************
650 * This function is the main entry point to the deleteValue type of action. It
651 * receives the currently read line and dispatch the work depending on the
654 void doDeleteValue(LPSTR line
)
656 fprintf(stderr
,"%s: deleteValue not yet implemented\n", getAppName());
659 /******************************************************************************
660 * This function is the main entry point to the deleteKey type of action. It
661 * receives the currently read line and dispatch the work depending on the
664 void doDeleteKey(LPSTR line
)
666 fprintf(stderr
,"%s: deleteKey not yet implemented\n", getAppName());
669 /******************************************************************************
670 * This function is the main entry point to the createKey type of action. It
671 * receives the currently read line and dispatch the work depending on the
674 void doCreateKey(LPSTR line
)
676 fprintf(stderr
,"%s: createKey not yet implemented\n", getAppName());
679 /******************************************************************************
680 * This function is a wrapper for the setValue function. It prepares the
681 * land and clean the area once completed.
682 * Note: this function modifies the line parameter.
684 * line - registry file unwrapped line. Should have the registry value name and
685 * complete registry value data.
687 void processSetValue(LPSTR line
)
689 LPSTR val_name
; /* registry value name */
690 LPSTR val_data
; /* registry value data */
692 int line_idx
= 0; /* current character under analysis */
696 if (line
[line_idx
] == '@' && line
[line_idx
+ 1] == '=') {
697 line
[line_idx
] = '\0';
700 } else if (line
[line_idx
] == '\"') {
702 val_name
= line
+ line_idx
;
704 if (line
[line_idx
] == '\\') /* skip escaped character */
708 if (line
[line_idx
] == '\"') {
709 line
[line_idx
] = '\0';
717 if (line
[line_idx
] != '=') {
718 line
[line_idx
] = '\"';
719 fprintf(stderr
,"Warning! unrecognized line:\n%s\n", line
);
724 fprintf(stderr
,"Warning! unrecognized line:\n%s\n", line
);
727 line_idx
++; /* skip the '=' character */
728 val_data
= line
+ line_idx
;
730 REGPROC_unescape_string(val_name
);
731 hRes
= setValue(val_name
, val_data
);
732 if ( hRes
!= ERROR_SUCCESS
)
733 fprintf(stderr
,"%s: ERROR Key %s not created. Value: %s, Data: %s\n",
740 /******************************************************************************
741 * This function is a wrapper for the queryValue function. It prepares the
742 * land and clean the area once completed.
744 void processQueryValue(LPSTR cmdline
)
746 fprintf(stderr
,"ERROR!!! - temporary disabled");
749 LPSTR argv
[QUERY_VALUE_MAX_ARGS
];/* args storage */
750 LPSTR token
= NULL
; /* current token analyzed */
751 ULONG argCounter
= 0; /* counter of args */
754 LPSTR keyValue
= NULL
;
758 * Init storage and parse the line
760 for (counter
=0; counter
<QUERY_VALUE_MAX_ARGS
; counter
++)
763 while( (token
= getToken(&cmdline
, queryValueDelim
[argCounter
])) != NULL
) {
764 argv
[argCounter
++] = getArg(token
);
766 if (argCounter
== QUERY_VALUE_MAX_ARGS
)
767 break; /* Stop processing args no matter what */
770 /* The value we look for is the first token on the line */
771 if ( argv
[0] == NULL
)
772 return; /* SHOULD NOT HAPPEN */
776 if( (keyValue
[0] == '@') && (strlen(keyValue
) == 1) ) {
777 LONG lLen
= KEY_MAX_LEN
;
778 CHAR
* lpsData
=HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,KEY_MAX_LEN
);
780 * We need to query the key default value
782 hRes
= RegQueryValue(
788 if (hRes
==ERROR_MORE_DATA
) {
789 lpsData
=HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,lpsData
,lLen
);
790 hRes
= RegQueryValue(currentKeyHandle
,currentKeyName
,(LPBYTE
)lpsData
,&lLen
);
793 if (hRes
== ERROR_SUCCESS
) {
794 lpsRes
= HeapAlloc( GetProcessHeap(), 0, lLen
);
795 lstrcpynA(lpsRes
, lpsData
, lLen
);
798 DWORD dwLen
= KEY_MAX_LEN
;
799 BYTE
* lpbData
=HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,KEY_MAX_LEN
);
802 * We need to query a specific value for the key
804 hRes
= RegQueryValueEx(
812 if (hRes
==ERROR_MORE_DATA
) {
813 lpbData
=HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,lpbData
,dwLen
);
814 hRes
= RegQueryValueEx(currentKeyHandle
,keyValue
,NULL
,&dwType
,(LPBYTE
)lpbData
,&dwLen
);
817 if (hRes
== ERROR_SUCCESS
) {
819 * Convert the returned data to a displayable format
823 case REG_EXPAND_SZ
: {
824 lpsRes
= HeapAlloc( GetProcessHeap(), 0, dwLen
);
825 lstrcpynA(lpsRes
, lpbData
, dwLen
);
829 lpsRes
= convertHexToDWORDStr(lpbData
, dwLen
);
833 lpsRes
= convertHexToHexCSV(lpbData
, dwLen
);
839 HeapFree(GetProcessHeap(), 0, lpbData
);
843 if ( hRes
== ERROR_SUCCESS
)
845 "%s: Value \"%s\" = \"%s\" in key [%s]\n",
852 fprintf(stderr
,"%s: ERROR Value \"%s\" not found for key \"%s\".\n",
860 for (counter
=0; counter
<argCounter
; counter
++)
861 if (argv
[counter
] != NULL
)
862 HeapFree(GetProcessHeap(), 0, argv
[counter
]);
865 HeapFree(GetProcessHeap(), 0, lpsRes
);
869 /******************************************************************************
870 * Calls command for each line of a registry file.
871 * Correctly processes comments (in # form), line continuation.
874 * in - input stream to read from
875 * command - command to be called for each line
877 void processRegLines(FILE *in
, CommandAPI command
)
879 LPSTR line
= NULL
; /* line read from input stream */
880 ULONG lineSize
= REG_VAL_BUF_SIZE
;
882 line
= HeapAlloc(GetProcessHeap(), 0, lineSize
);
883 CHECK_ENOUGH_MEMORY(line
);
886 LPSTR s
; /* The pointer into line for where the current fgets should read */
889 size_t size_remaining
;
891 char *s_eol
; /* various local uses */
893 /* Do we need to expand the buffer ? */
894 assert (s
>= line
&& s
<= line
+ lineSize
);
895 size_remaining
= lineSize
- (s
-line
);
896 if (size_remaining
< 2) /* room for 1 character and the \0 */
899 size_t new_size
= lineSize
+ REG_VAL_BUF_SIZE
;
900 if (new_size
> lineSize
) /* no arithmetic overflow */
901 new_buffer
= HeapReAlloc (GetProcessHeap(), 0, line
, new_size
);
904 CHECK_ENOUGH_MEMORY(new_buffer
);
906 s
= line
+ lineSize
- size_remaining
;
908 size_remaining
= lineSize
- (s
-line
);
911 /* Get as much as possible into the buffer, terminated either by
912 * eof, error, eol or getting the maximum amount. Abort on error.
914 size_to_get
= (size_remaining
> INT_MAX
? INT_MAX
: size_remaining
);
915 if (NULL
== fgets (s
, size_to_get
, in
)) {
917 perror ("While reading input");
922 /* It is not clear to me from the definition that the
923 * contents of the buffer are well defined on detecting
924 * an eof without managing to read anything.
929 /* If we didn't read the eol nor the eof go around for the rest */
930 s_eol
= strchr (s
, '\n');
931 if (!feof (in
) && !s_eol
) {
932 s
= strchr (s
, '\0');
933 /* It should be s + size_to_get - 1 but this is safer */
937 /* If it is a comment line then discard it and go around again */
938 if (line
[0] == '#') {
943 /* Remove any line feed. Leave s_eol on the \0 */
946 if (s_eol
> line
&& *(s_eol
-1) == '\r')
949 s_eol
= strchr (s
, '\0');
951 /* If there is a concatenating \\ then go around again */
952 if (s_eol
> line
&& *(s_eol
-1) == '\\') {
955 /* The following error protection could be made more self-
956 * correcting but I thought it not worth trying.
958 if ((c
= fgetc (in
)) == EOF
|| c
!= ' ' ||
959 (c
= fgetc (in
)) == EOF
|| c
!= ' ')
960 fprintf(stderr
,"%s: ERROR - invalid continuation.\n",
965 break; /* That is the full virtual line */
972 HeapFree(GetProcessHeap(), 0, line
);
975 /******************************************************************************
976 * This function is the main entry point to the registerDLL action. It
977 * receives the currently read line, then loads and registers the requested DLLs
979 void doRegisterDLL(LPSTR stdInput
)
984 /* Check for valid input */
985 if (stdInput
== NULL
)
988 /* Load and register the library, then free it */
989 theLib
= LoadLibrary(stdInput
);
991 FARPROC lpfnDLLRegProc
= GetProcAddress(theLib
, "DllRegisterServer");
993 retVal
= (*lpfnDLLRegProc
)();
995 fprintf(stderr
,"%s: Couldn't find DllRegisterServer proc in '%s'.\n",
996 getAppName(), stdInput
);
999 fprintf(stderr
,"%s: DLLRegisterServer error 0x%x in '%s'.\n",
1000 getAppName(), retVal
, stdInput
);
1002 FreeLibrary(theLib
);
1004 fprintf(stderr
,"%s: Could not load DLL '%s'.\n", getAppName(), stdInput
);
1008 /******************************************************************************
1009 * This function is the main entry point to the unregisterDLL action. It
1010 * receives the currently read line, then loads and unregisters the requested DLLs
1012 void doUnregisterDLL(LPSTR stdInput
)
1017 /* Check for valid input */
1018 if (stdInput
== NULL
)
1021 /* Load and unregister the library, then free it */
1022 theLib
= LoadLibrary(stdInput
);
1024 FARPROC lpfnDLLRegProc
= GetProcAddress(theLib
, "DllUnregisterServer");
1026 retVal
= (*lpfnDLLRegProc
)();
1028 fprintf(stderr
,"%s: Couldn't find DllUnregisterServer proc in '%s'.\n",
1029 getAppName(), stdInput
);
1032 fprintf(stderr
,"%s: DLLUnregisterServer error 0x%x in '%s'.\n",
1033 getAppName(), retVal
, stdInput
);
1035 FreeLibrary(theLib
);
1037 fprintf(stderr
,"%s: Could not load DLL '%s'.\n", getAppName(), stdInput
);
1041 /****************************************************************************
1042 * REGPROC_print_error
1044 * Print the message for GetLastError
1047 static void REGPROC_print_error(void)
1053 error_code
= GetLastError ();
1054 status
= FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER
| FORMAT_MESSAGE_FROM_SYSTEM
,
1055 NULL
, error_code
, 0, (LPTSTR
) &lpMsgBuf
, 0, NULL
);
1057 fprintf(stderr
,"%s: Cannot display message for error %ld, status %ld\n",
1058 getAppName(), error_code
, GetLastError());
1062 LocalFree((HLOCAL
)lpMsgBuf
);
1066 /******************************************************************************
1067 * Checks whether the buffer has enough room for the string or required size.
1068 * Resizes the buffer if necessary.
1071 * buffer - pointer to a buffer for string
1072 * len - current length of the buffer in characters.
1073 * required_len - length of the string to place to the buffer in characters.
1074 * The length does not include the terminating null character.
1076 static void REGPROC_resize_char_buffer(CHAR
**buffer
, DWORD
*len
, DWORD required_len
)
1079 if (required_len
> *len
) {
1080 *len
= required_len
;
1082 *buffer
= HeapAlloc(GetProcessHeap(), 0, *len
* sizeof(**buffer
));
1084 *buffer
= HeapReAlloc(GetProcessHeap(), 0, *buffer
, *len
* sizeof(**buffer
));
1085 CHECK_ENOUGH_MEMORY(*buffer
);
1089 /******************************************************************************
1090 * Prints string str to file
1092 static void REGPROC_export_string(FILE *file
, CHAR
*str
)
1094 size_t len
= strlen(str
);
1097 /* escaping characters */
1098 for (i
= 0; i
< len
; i
++) {
1102 fputs("\\\\", file
);
1105 fputs("\\\"", file
);
1108 fputs("\\\n", file
);
1117 /******************************************************************************
1118 * Writes contents of the registry key to the specified file stream.
1121 * file - writable file stream to export registry branch to.
1122 * key - registry branch to export.
1123 * reg_key_name_buf - name of the key with registry class.
1124 * Is resized if necessary.
1125 * reg_key_name_len - length of the buffer for the registry class in characters.
1126 * val_name_buf - buffer for storing value name.
1127 * Is resized if necessary.
1128 * val_name_len - length of the buffer for storing value names in characters.
1129 * val_buf - buffer for storing values while extracting.
1130 * Is resized if necessary.
1131 * val_size - size of the buffer for storing values in bytes.
1133 static void export_hkey(FILE *file
, HKEY key
,
1134 CHAR
**reg_key_name_buf
, DWORD
*reg_key_name_len
,
1135 CHAR
**val_name_buf
, DWORD
*val_name_len
,
1136 BYTE
**val_buf
, DWORD
*val_size
)
1138 DWORD max_sub_key_len
;
1139 DWORD max_val_name_len
;
1146 /* get size information and resize the buffers if necessary */
1147 if (RegQueryInfoKey(key
, NULL
, NULL
, NULL
, NULL
,
1148 &max_sub_key_len
, NULL
,
1149 NULL
, &max_val_name_len
, &max_val_size
, NULL
, NULL
1150 ) != ERROR_SUCCESS
) {
1151 REGPROC_print_error();
1153 curr_len
= strlen(*reg_key_name_buf
);
1154 REGPROC_resize_char_buffer(reg_key_name_buf
, reg_key_name_len
,
1155 max_sub_key_len
+ curr_len
+ 1);
1156 REGPROC_resize_char_buffer(val_name_buf
, val_name_len
,
1158 if (max_val_size
> *val_size
) {
1159 *val_size
= max_val_size
;
1160 if (!*val_buf
) *val_buf
= HeapAlloc(GetProcessHeap(), 0, *val_size
);
1161 else *val_buf
= HeapReAlloc(GetProcessHeap(), 0, *val_buf
, *val_size
);
1162 CHECK_ENOUGH_MEMORY(val_buf
);
1165 /* output data for the current key */
1167 fputs(*reg_key_name_buf
, file
);
1169 /* print all the values */
1174 DWORD val_name_len1
= *val_name_len
;
1175 DWORD val_size1
= *val_size
;
1176 ret
= RegEnumValue(key
, i
, *val_name_buf
, &val_name_len1
, NULL
,
1177 &value_type
, *val_buf
, &val_size1
);
1178 if (ret
!= ERROR_SUCCESS
) {
1180 if (ret
!= ERROR_NO_MORE_ITEMS
) {
1181 REGPROC_print_error();
1186 if ((*val_name_buf
)[0]) {
1188 REGPROC_export_string(file
, *val_name_buf
);
1194 switch (value_type
) {
1198 REGPROC_export_string(file
, (char*) *val_buf
);
1199 fputs("\"\n", file
);
1203 fprintf(file
, "dword:%08lx\n", *((DWORD
*)*val_buf
));
1207 fprintf(stderr
,"%s: warning - unsupported registry format '%ld', "
1208 "treat as binary\n",
1209 getAppName(), value_type
);
1210 fprintf(stderr
,"key name: \"%s\"\n", *reg_key_name_buf
);
1211 fprintf(stderr
,"value name:\"%s\"\n\n", *val_name_buf
);
1217 const CHAR
*hex_prefix
;
1221 if (value_type
== REG_BINARY
) {
1222 hex_prefix
= "hex:";
1225 sprintf(buf
, "hex(%ld):", value_type
);
1228 /* position of where the next character will be printed */
1229 /* NOTE: yes, strlen("hex:") is used even for hex(x): */
1230 cur_pos
= strlen("\"\"=") + strlen("hex:") +
1231 strlen(*val_name_buf
);
1233 fputs(hex_prefix
, file
);
1234 for (i1
= 0; i1
< val_size1
; i1
++) {
1235 fprintf(file
, "%02x", (unsigned int)(*val_buf
)[i1
]);
1236 if (i1
+ 1 < val_size1
) {
1242 if (cur_pos
> REG_FILE_HEX_LINE_LEN
) {
1243 fputs("\\\n ", file
);
1256 (*reg_key_name_buf
)[curr_len
] = '\\';
1258 DWORD buf_len
= *reg_key_name_len
- curr_len
;
1260 ret
= RegEnumKeyEx(key
, i
, *reg_key_name_buf
+ curr_len
+ 1, &buf_len
,
1261 NULL
, NULL
, NULL
, NULL
);
1262 if (ret
!= ERROR_SUCCESS
&& ret
!= ERROR_MORE_DATA
) {
1264 if (ret
!= ERROR_NO_MORE_ITEMS
) {
1265 REGPROC_print_error();
1271 if (RegOpenKey(key
, *reg_key_name_buf
+ curr_len
+ 1,
1272 &subkey
) == ERROR_SUCCESS
) {
1273 export_hkey(file
, subkey
, reg_key_name_buf
, reg_key_name_len
,
1274 val_name_buf
, val_name_len
, val_buf
, val_size
);
1275 RegCloseKey(subkey
);
1277 REGPROC_print_error();
1281 (*reg_key_name_buf
)[curr_len
] = '\0';
1284 /******************************************************************************
1285 * Open file for export.
1287 static FILE *REGPROC_open_export_file(CHAR
*file_name
)
1289 FILE *file
= fopen(file_name
, "w");
1292 fprintf(stderr
,"%s: Can't open file \"%s\"\n", getAppName(), file_name
);
1295 fputs("REGEDIT4\n", file
);
1299 /******************************************************************************
1300 * Writes contents of the registry key to the specified file stream.
1303 * file_name - name of a file to export registry branch to.
1304 * reg_key_name - registry branch to export. The whole registry is exported if
1305 * reg_key_name is NULL or contains an empty string.
1307 BOOL
export_registry_key(CHAR
*file_name
, CHAR
*reg_key_name
)
1311 CHAR
*reg_key_name_buf
;
1314 DWORD reg_key_name_len
= KEY_MAX_LEN
;
1315 DWORD val_name_len
= KEY_MAX_LEN
;
1316 DWORD val_size
= REG_VAL_BUF_SIZE
;
1319 reg_key_name_buf
= HeapAlloc(GetProcessHeap(), 0,
1320 reg_key_name_len
* sizeof(*reg_key_name_buf
));
1321 val_name_buf
= HeapAlloc(GetProcessHeap(), 0,
1322 val_name_len
* sizeof(*val_name_buf
));
1323 val_buf
= HeapAlloc(GetProcessHeap(), 0, val_size
);
1324 CHECK_ENOUGH_MEMORY(reg_key_name_buf
&& val_name_buf
&& val_buf
);
1326 if (reg_key_name
&& reg_key_name
[0]) {
1330 REGPROC_resize_char_buffer(®_key_name_buf
, ®_key_name_len
,
1331 strlen(reg_key_name
));
1332 strcpy(reg_key_name_buf
, reg_key_name
);
1334 /* open the specified key */
1335 reg_key_class
= getRegClass(reg_key_name
);
1336 if (reg_key_class
== (HKEY
)ERROR_INVALID_PARAMETER
) {
1337 fprintf(stderr
,"%s: Incorrect registry class specification in '%s'\n",
1338 getAppName(), reg_key_name
);
1341 branch_name
= getRegKeyName(reg_key_name
);
1342 CHECK_ENOUGH_MEMORY(branch_name
);
1343 if (!branch_name
[0]) {
1344 /* no branch - registry class is specified */
1345 file
= REGPROC_open_export_file(file_name
);
1346 export_hkey(file
, reg_key_class
,
1347 ®_key_name_buf
, ®_key_name_len
,
1348 &val_name_buf
, &val_name_len
,
1349 &val_buf
, &val_size
);
1350 } else if (RegOpenKey(reg_key_class
, branch_name
, &key
) == ERROR_SUCCESS
) {
1351 file
= REGPROC_open_export_file(file_name
);
1352 export_hkey(file
, key
,
1353 ®_key_name_buf
, ®_key_name_len
,
1354 &val_name_buf
, &val_name_len
,
1355 &val_buf
, &val_size
);
1358 fprintf(stderr
,"%s: Can't export. Registry key '%s' does not exist!\n",
1359 getAppName(), reg_key_name
);
1360 REGPROC_print_error();
1362 HeapFree(GetProcessHeap(), 0, branch_name
);
1366 /* export all registry classes */
1367 file
= REGPROC_open_export_file(file_name
);
1368 for (i
= 0; i
< REG_CLASS_NUMBER
; i
++) {
1369 /* do not export HKEY_CLASSES_ROOT */
1370 if (reg_class_keys
[i
] != HKEY_CLASSES_ROOT
&&
1371 reg_class_keys
[i
] != HKEY_CURRENT_USER
&&
1372 reg_class_keys
[i
] != HKEY_CURRENT_CONFIG
&&
1373 reg_class_keys
[i
] != HKEY_DYN_DATA
) {
1374 strcpy(reg_key_name_buf
, reg_class_names
[i
]);
1375 export_hkey(file
, reg_class_keys
[i
],
1376 ®_key_name_buf
, ®_key_name_len
,
1377 &val_name_buf
, &val_name_len
,
1378 &val_buf
, &val_size
);
1386 HeapFree(GetProcessHeap(), 0, reg_key_name
);
1387 HeapFree(GetProcessHeap(), 0, val_buf
);
1391 /******************************************************************************
1392 * Reads contents of the specified file into the registry.
1394 BOOL
import_registry_file(LPTSTR filename
)
1396 FILE* reg_file
= fopen(filename
, "r");
1399 processRegLines(reg_file
, doSetValue
);
1405 /******************************************************************************
1406 * Recursive function which removes the registry key with all subkeys.
1408 static void delete_branch(HKEY key
,
1409 CHAR
**reg_key_name_buf
, DWORD
*reg_key_name_len
)
1412 DWORD max_sub_key_len
;
1418 if (RegOpenKey(key
, *reg_key_name_buf
, &branch_key
) != ERROR_SUCCESS
) {
1419 REGPROC_print_error();
1422 /* get size information and resize the buffers if necessary */
1423 if (RegQueryInfoKey(branch_key
, NULL
, NULL
, NULL
,
1424 &subkeys
, &max_sub_key_len
,
1425 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
1426 ) != ERROR_SUCCESS
) {
1427 REGPROC_print_error();
1429 curr_len
= strlen(*reg_key_name_buf
);
1430 REGPROC_resize_char_buffer(reg_key_name_buf
, reg_key_name_len
,
1431 max_sub_key_len
+ curr_len
+ 1);
1433 (*reg_key_name_buf
)[curr_len
] = '\\';
1434 for (i
= subkeys
- 1; i
>= 0; i
--) {
1435 DWORD buf_len
= *reg_key_name_len
- curr_len
;
1437 ret
= RegEnumKeyEx(branch_key
, i
, *reg_key_name_buf
+ curr_len
+ 1,
1438 &buf_len
, NULL
, NULL
, NULL
, NULL
);
1439 if (ret
!= ERROR_SUCCESS
&&
1440 ret
!= ERROR_MORE_DATA
&&
1441 ret
!= ERROR_NO_MORE_ITEMS
) {
1442 REGPROC_print_error();
1444 delete_branch(key
, reg_key_name_buf
, reg_key_name_len
);
1447 (*reg_key_name_buf
)[curr_len
] = '\0';
1448 RegCloseKey(branch_key
);
1449 RegDeleteKey(key
, *reg_key_name_buf
);
1452 /******************************************************************************
1453 * Removes the registry key with all subkeys. Parses full key name.
1456 * reg_key_name - full name of registry branch to delete. Ignored if is NULL,
1457 * empty, points to register key class, does not exist.
1459 void delete_registry_key(CHAR
*reg_key_name
)
1462 DWORD branch_name_len
;
1466 if (!reg_key_name
|| !reg_key_name
[0])
1468 /* open the specified key */
1469 reg_key_class
= getRegClass(reg_key_name
);
1470 if (reg_key_class
== (HKEY
)ERROR_INVALID_PARAMETER
) {
1471 fprintf(stderr
,"%s: Incorrect registry class specification in '%s'\n",
1472 getAppName(), reg_key_name
);
1475 branch_name
= getRegKeyName(reg_key_name
);
1476 CHECK_ENOUGH_MEMORY(branch_name
);
1477 branch_name_len
= strlen(branch_name
);
1478 if (!branch_name
[0]) {
1479 fprintf(stderr
,"%s: Can't delete registry class '%s'\n",
1480 getAppName(), reg_key_name
);
1483 if (RegOpenKey(reg_key_class
, branch_name
, &branch_key
) == ERROR_SUCCESS
) {
1484 /* check whether the key exists */
1485 RegCloseKey(branch_key
);
1486 delete_branch(reg_key_class
, &branch_name
, &branch_name_len
);
1488 HeapFree(GetProcessHeap(), 0, branch_name
);
1491 /******************************************************************************
1492 * Sets the application name. Then application name is used in the error
1495 void setAppName(const CHAR
*name
)
1500 const CHAR
*getAppName(void)