Ensure convert_string_XXX is always called with a valid converted_size pointer.
[samba.git] / source4 / lib / registry / patchfile_dotreg.c
1 /*
2    Unix SMB/CIFS implementation.
3    Reading .REG files
4
5    Copyright (C) Jelmer Vernooij 2004-2007
6    Copyright (C) Wilco Baan Hofman 2006-2010
7
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 3 of the License, or
11    (at your option) any later version.
12
13    This program 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
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 /* FIXME:
24  * - Newer .REG files, created by Windows XP and above use unicode UCS-2
25  * - @="" constructions should write value with empty name.
26 */
27
28 #include "includes.h"
29 #include "lib/registry/registry.h"
30 #include "system/filesys.h"
31
32 /**
33  * @file
34  * @brief Registry patch files
35  */
36
37 #define HEADER_STRING "REGEDIT4"
38
39 struct dotreg_data {
40         int fd;
41 };
42
43 /* 
44  * This is basically a copy of data_blob_hex_string_upper, but with comma's 
45  * between the bytes in hex.
46  */
47 static char *dotreg_data_blob_hex_string(TALLOC_CTX *mem_ctx, const DATA_BLOB *blob)
48 {
49         size_t i;
50         char *hex_string;
51
52         hex_string = talloc_array(mem_ctx, char, (blob->length*3)+1);
53         if (!hex_string) {
54                 return NULL;
55         }
56
57         for (i = 0; i < blob->length; i++)
58                 slprintf(&hex_string[i*3], 4, "%02X,", blob->data[i]);
59
60         /* Remove last comma and NULL-terminate the string */
61         hex_string[(blob->length*3)-1] = '\0';
62         return hex_string;
63 }
64
65 /* 
66  * This is basically a copy of reg_val_data_string, except that this function
67  * has no 0x for dwords, everything else is regarded as binary, and binary 
68  * strings are represented with bytes comma-separated.
69  */
70 static char *reg_val_dotreg_string(TALLOC_CTX *mem_ctx, uint32_t type,
71                                    const DATA_BLOB data)
72 {
73         size_t converted_size = 0;
74         char *ret = NULL;
75
76         if (data.length == 0)
77                 return talloc_strdup(mem_ctx, "");
78
79         switch (type) {
80                 case REG_EXPAND_SZ:
81                 case REG_SZ:
82                         convert_string_talloc(mem_ctx,
83                                               CH_UTF16, CH_UNIX, data.data, data.length,
84                                               (void **)&ret, &converted_size);
85                         break;
86                 case REG_DWORD:
87                 case REG_DWORD_BIG_ENDIAN:
88                         SMB_ASSERT(data.length == sizeof(uint32_t));
89                         ret = talloc_asprintf(mem_ctx, "%08x",
90                                               IVAL(data.data, 0));
91                         break;
92                 default: /* default means treat as binary */
93                 case REG_BINARY:
94                         ret = dotreg_data_blob_hex_string(mem_ctx, &data);
95                         break;
96         }
97
98         return ret;
99 }
100
101 static WERROR reg_dotreg_diff_add_key(void *_data, const char *key_name)
102 {
103         struct dotreg_data *data = (struct dotreg_data *)_data;
104
105         fdprintf(data->fd, "\n[%s]\n", key_name);
106
107         return WERR_OK;
108 }
109
110 static WERROR reg_dotreg_diff_del_key(void *_data, const char *key_name)
111 {
112         struct dotreg_data *data = (struct dotreg_data *)_data;
113
114         fdprintf(data->fd, "\n[-%s]\n", key_name);
115
116         return WERR_OK;
117 }
118
119 static WERROR reg_dotreg_diff_set_value(void *_data, const char *path,
120                                         const char *value_name,
121                                         uint32_t value_type, DATA_BLOB value)
122 {
123         struct dotreg_data *data = (struct dotreg_data *)_data;
124         char *data_string = reg_val_dotreg_string(NULL, 
125                                                 value_type, value);
126         char *data_incl_type;
127
128         W_ERROR_HAVE_NO_MEMORY(data_string);
129
130         switch (value_type) {
131                 case REG_SZ:
132                         data_incl_type = talloc_asprintf(data_string, "\"%s\"", 
133                                         data_string);
134                         break;
135                 case REG_DWORD:
136                         data_incl_type = talloc_asprintf(data_string, 
137                                         "dword:%s", data_string);
138                         break;
139                 case REG_BINARY:
140                         data_incl_type = talloc_asprintf(data_string, "hex:%s",
141                                         data_string);
142                         break;
143                 default:
144                         data_incl_type = talloc_asprintf(data_string, "hex(%x):%s", 
145                                         value_type, data_string);
146                         break;
147         }
148
149         if (value_name[0] == '\0') {
150                 fdprintf(data->fd, "@=%s\n", data_incl_type);
151         } else {
152                 fdprintf(data->fd, "\"%s\"=%s\n",
153                          value_name, data_incl_type);
154         }
155
156         talloc_free(data_string);
157
158         return WERR_OK;
159 }
160
161 static WERROR reg_dotreg_diff_del_value(void *_data, const char *path,
162                                         const char *value_name)
163 {
164         struct dotreg_data *data = (struct dotreg_data *)_data;
165
166         fdprintf(data->fd, "\"%s\"=-\n", value_name);
167
168         return WERR_OK;
169 }
170
171 static WERROR reg_dotreg_diff_done(void *_data)
172 {
173         struct dotreg_data *data = (struct dotreg_data *)_data;
174
175         close(data->fd);
176         talloc_free(data);
177
178         return WERR_OK;
179 }
180
181 static WERROR reg_dotreg_diff_del_all_values(void *callback_data,
182                                              const char *key_name)
183 {
184         return WERR_NOT_SUPPORTED;
185 }
186
187 /**
188  * Save registry diff
189  */
190 _PUBLIC_ WERROR reg_dotreg_diff_save(TALLOC_CTX *ctx, const char *filename,
191                                      struct reg_diff_callbacks **callbacks,
192                                      void **callback_data)
193 {
194         struct dotreg_data *data;
195
196         data = talloc_zero(ctx, struct dotreg_data);
197         *callback_data = data;
198
199         if (filename) {
200                 data->fd = open(filename, O_CREAT|O_WRONLY, 0755);
201                 if (data->fd < 0) {
202                         DEBUG(0, ("Unable to open %s\n", filename));
203                         return WERR_BADFILE;
204                 }
205         } else {
206                 data->fd = STDOUT_FILENO;
207         }
208
209         fdprintf(data->fd, "%s\n\n", HEADER_STRING);
210
211         *callbacks = talloc(ctx, struct reg_diff_callbacks);
212
213         (*callbacks)->add_key = reg_dotreg_diff_add_key;
214         (*callbacks)->del_key = reg_dotreg_diff_del_key;
215         (*callbacks)->set_value = reg_dotreg_diff_set_value;
216         (*callbacks)->del_value = reg_dotreg_diff_del_value;
217         (*callbacks)->del_all_values = reg_dotreg_diff_del_all_values;
218         (*callbacks)->done = reg_dotreg_diff_done;
219
220         return WERR_OK;
221 }
222
223 /**
224  * Load diff file
225  */
226 _PUBLIC_ WERROR reg_dotreg_diff_load(int fd,
227                                      const struct reg_diff_callbacks *callbacks,
228                                      void *callback_data)
229 {
230         char *line, *p, *q;
231         char *curkey = NULL;
232         TALLOC_CTX *mem_ctx = talloc_init("reg_dotreg_diff_load");
233         WERROR error;
234         uint32_t value_type;
235         DATA_BLOB data;
236         bool result;
237         char *type_str = NULL;
238         char *data_str;
239         char *value;
240         bool continue_next_line = 0;
241
242         line = afdgets(fd, mem_ctx, 0);
243         if (!line) {
244                 DEBUG(0, ("Can't read from file.\n"));
245                 talloc_free(mem_ctx);
246                 close(fd);
247                 return WERR_GENERAL_FAILURE;
248         }
249
250         while ((line = afdgets(fd, mem_ctx, 0))) {
251                 /* Remove '\r' if it's a Windows text file */
252                 if (line[strlen(line)-1] == '\r') {
253                         line[strlen(line)-1] = '\0';
254                 }
255
256                 /* Ignore comments and empty lines */
257                 if (strlen(line) == 0 || line[0] == ';') {
258                         talloc_free(line);
259
260                         if (curkey) {
261                                 talloc_free(curkey);
262                         }
263                         curkey = NULL;
264                         continue;
265                 }
266
267                 /* Start of key */
268                 if (line[0] == '[') {
269                         if (line[strlen(line)-1] != ']') {
270                                 DEBUG(0, ("Missing ']' on line: %s\n", line));
271                                 talloc_free(line);
272                                 continue;
273                         }
274
275                         /* Deleting key */
276                         if (line[1] == '-') {
277                                 curkey = talloc_strndup(line, line+2, strlen(line)-3);
278                                 W_ERROR_HAVE_NO_MEMORY(curkey);
279
280                                 error = callbacks->del_key(callback_data,
281                                                            curkey);
282
283                                 if (!W_ERROR_IS_OK(error)) {
284                                         DEBUG(0,("Error deleting key %s\n",
285                                                 curkey));
286                                         talloc_free(mem_ctx);
287                                         return error;
288                                 }
289
290                                 talloc_free(line);
291                                 curkey = NULL;
292                                 continue;
293                         }
294                         curkey = talloc_strndup(mem_ctx, line+1, strlen(line)-2);
295                         W_ERROR_HAVE_NO_MEMORY(curkey);
296
297                         error = callbacks->add_key(callback_data, curkey);
298                         if (!W_ERROR_IS_OK(error)) {
299                                 DEBUG(0,("Error adding key %s\n", curkey));
300                                 talloc_free(mem_ctx);
301                                 return error;
302                         }
303
304                         talloc_free(line);
305                         continue;
306                 }
307
308                 /* Deleting/Changing value */
309                 if (continue_next_line) {
310                         continue_next_line = 0;
311
312                         /* Continued data start with two whitespaces */
313                         if (line[0] != ' ' || line[1] != ' ') {
314                                 DEBUG(0, ("Malformed line: %s\n", line));
315                                 talloc_free(line);
316                                 continue;
317                         }
318                         p = line + 2;
319
320                         /* Continue again if line ends with a backslash */
321                         if (line[strlen(line)-1] == '\\') {
322                                 line[strlen(line)-1] = '\0';
323                                 continue_next_line = 1;
324                                 data_str = talloc_strdup_append(data_str, p);
325                                 talloc_free(line);
326                                 continue;
327                         }
328                         data_str = talloc_strdup_append(data_str, p);
329                 } else {
330                         p = strchr_m(line, '=');
331                         if (p == NULL) {
332                                 DEBUG(0, ("Malformed line: %s\n", line));
333                                 talloc_free(line);
334                                 continue;
335                         }
336
337                         *p = '\0'; p++;
338
339
340                         if (curkey == NULL) {
341                                 DEBUG(0, ("Value change without key\n"));
342                                 talloc_free(line);
343                                 continue;
344                         }
345
346                         /* Values should be double-quoted */
347                         if (line[0] != '"') {
348                                 DEBUG(0, ("Malformed line\n"));
349                                 talloc_free(line);
350                                 continue;
351                         }
352
353                         /* Chop of the quotes and store as value */
354                         value = talloc_strndup(mem_ctx, line+1,strlen(line)-2);
355
356                         /* Delete value */
357                         if (p[0] == '-') {
358                                 error = callbacks->del_value(callback_data,
359                                                      curkey, value);
360
361                                 /* Ignore if key does not exist (WERR_BADFILE)
362                                  * Consistent with Windows behaviour */
363                                 if (!W_ERROR_IS_OK(error) &&
364                                     !W_ERROR_EQUAL(error, WERR_BADFILE)) {
365                                         DEBUG(0, ("Error deleting value %s in key %s\n",
366                                                 value, curkey));
367                                         talloc_free(mem_ctx);
368                                         return error;
369                                 }
370
371                                 talloc_free(line);
372                                 talloc_free(value);
373                                 continue;
374                         }
375
376                         /* Do not look for colons in strings */
377                         if (p[0] == '"') {
378                                 q = NULL;
379                                 data_str = talloc_strndup(mem_ctx, p+1,strlen(p)-2);
380                         } else {
381                                 /* Split the value type from the data */
382                                 q = strchr_m(p, ':');
383                                 if (q) {
384                                         *q = '\0';
385                                         q++;
386                                         type_str = talloc_strdup(mem_ctx, p);
387                                         data_str = talloc_strdup(mem_ctx, q);
388                                 } else {
389                                         data_str = talloc_strdup(mem_ctx, p);
390                                 }
391                         }
392
393                         /* Backslash before the CRLF means continue on next line */
394                         if (data_str[strlen(data_str)-1] == '\\') {
395                                 data_str[strlen(data_str)-1] = '\0';
396                                 talloc_free(line);
397                                 continue_next_line = 1;
398                                 continue;
399                         }
400                 }
401                 DEBUG(9, ("About to write %s with type %s, length %ld: %s\n", value, type_str, (long) strlen(data_str), data_str));
402                 result = reg_string_to_val(value,
403                                   type_str?type_str:"REG_SZ", data_str,
404                                   &value_type, &data);
405                 if (!result) {
406                         DEBUG(0, ("Error converting string to value for line:\n%s\n",
407                                         line));
408                         return WERR_GENERAL_FAILURE;
409                 }
410
411                 error = callbacks->set_value(callback_data, curkey, value,
412                                              value_type, data);
413                 if (!W_ERROR_IS_OK(error)) {
414                         DEBUG(0, ("Error setting value for %s in %s\n",
415                                 value, curkey));
416                         talloc_free(mem_ctx);
417                         return error;
418                 }
419
420                 /* Clean up buffers */
421                 if (type_str != NULL) {
422                         talloc_free(type_str);
423                         type_str = NULL;
424                 }
425                 talloc_free(data_str);
426                 talloc_free(value);
427                 talloc_free(line);
428         }
429
430         close(fd);
431
432         talloc_free(mem_ctx);
433
434         return WERR_OK;
435 }