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 = NULL;
 239         char *value = NULL;
 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 }