source3/registry/reg_backend_db.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  Virtual Windows Registry Layer
   4  *  Copyright (C) Gerald Carter                     2002-2005
   5  *  Copyright (C) Michael Adam                      2007-2011
   6  *  Copyright (C) Gregor Beck                       2011
   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, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 /* Implementation of internal registry database functions. */
  23
  24 #include "includes.h"
  25 #include "system/filesys.h"
  26 #include "registry.h"
  27 #include "reg_db.h"
  28 #include "reg_util_internal.h"
  29 #include "reg_parse_internal.h"
  30 #include "reg_backend_db.h"
  31 #include "reg_objects.h"
  32 #include "nt_printing.h"
  33 #include "util_tdb.h"
  34 #include "dbwrap/dbwrap.h"
  35 #include "dbwrap/dbwrap_open.h"
  36 #include "../libcli/security/secdesc.h"
  37
  38 #undef DBGC_CLASS
  39 #define DBGC_CLASS DBGC_REGISTRY
  40
  41 #define REGDB_VERSION_KEYNAME "INFO/version"
  42
  43 static struct db_context *regdb = NULL;
  44 static int regdb_refcount;
  45
  46 static bool regdb_key_exists(struct db_context *db, const char *key);
  47 static WERROR regdb_fetch_keys_internal(struct db_context *db, const char *key,
  48                                         struct regsubkey_ctr *ctr);
  49 static bool regdb_store_keys_internal(struct db_context *db, const char *key,
  50                                       struct regsubkey_ctr *ctr);
  51 static int regdb_fetch_values_internal(struct db_context *db, const char* key,
  52                                        struct regval_ctr *values);
  53 static NTSTATUS regdb_store_values_internal(struct db_context *db, const char *key,
  54                                             struct regval_ctr *values);
  55 static WERROR regdb_store_subkey_list(struct db_context *db, const char *parent,
  56                                       const char *key);
  57
  58 static WERROR regdb_create_basekey(struct db_context *db, const char *key);
  59 static WERROR regdb_create_subkey_internal(struct db_context *db,
  60                                            const char *key,
  61                                            const char *subkey);
  62
  63
  64 struct regdb_trans_ctx {
  65         NTSTATUS (*action)(struct db_context *, void *);
  66         void *private_data;
  67 };
  68
  69 static NTSTATUS regdb_trans_do_action(struct db_context *db, void *private_data)
  70 {
  71         NTSTATUS status;
  72         int32_t version_id;
  73         struct regdb_trans_ctx *ctx = (struct regdb_trans_ctx *)private_data;
  74
  75         status = dbwrap_fetch_int32_bystring(db, REGDB_VERSION_KEYNAME,
  76                                              &version_id);
  77
  78         if (!NT_STATUS_IS_OK(status)) {
  79                 DEBUG(0, ("ERROR: could not fetch registry db version: %s. "
  80                           "Denying access.\n", nt_errstr(status)));
  81                 return NT_STATUS_ACCESS_DENIED;
  82         }
  83
  84         if (version_id != REGDB_CODE_VERSION) {
  85                 DEBUG(0, ("ERROR: changed registry version %d found while "
  86                           "trying to write to the registry. Version %d "
  87                           "expected.  Denying access.\n",
  88                           version_id, REGDB_CODE_VERSION));
  89                 return NT_STATUS_ACCESS_DENIED;
  90         }
  91
  92         status = ctx->action(db,  ctx->private_data);
  93         return status;
  94 }
  95
  96 static WERROR regdb_trans_do(struct db_context *db,
  97                              NTSTATUS (*action)(struct db_context *, void *),
  98                              void *private_data)
  99 {
 100         NTSTATUS status;
 101         struct regdb_trans_ctx ctx;
 102
 103
 104         ctx.action = action;
 105         ctx.private_data = private_data;
 106
 107         status = dbwrap_trans_do(db, regdb_trans_do_action, &ctx);
 108
 109         return ntstatus_to_werror(status);
 110 }
 111
 112 /* List the deepest path into the registry.  All part components will be created.*/
 113
 114 /* If you want to have a part of the path controlled by the tdb and part by
 115    a virtual registry db (e.g. printing), then you have to list the deepest path.
 116    For example,"HKLM/SOFTWARE/Microsoft/Windows NT/CurrentVersion/Print"
 117    allows the reg_db backend to handle everything up to
 118    "HKLM/SOFTWARE/Microsoft/Windows NT/CurrentVersion" and then we'll hook
 119    the reg_printing backend onto the last component of the path (see
 120    KEY_PRINTING_2K in include/rpc_reg.h)   --jerry */
 121
 122 static const char *builtin_registry_paths[] = {
 123         KEY_PRINTING_2K,
 124         KEY_PRINTING_PORTS,
 125         KEY_PRINTING,
 126         KEY_PRINTING "\\Forms",
 127         KEY_PRINTING "\\Printers",
 128         KEY_PRINTING "\\Environments\\Windows NT x86\\Print Processors\\winprint",
 129         KEY_SHARES,
 130         KEY_EVENTLOG,
 131         KEY_SMBCONF,
 132         KEY_PERFLIB,
 133         KEY_PERFLIB_009,
 134         KEY_GROUP_POLICY,
 135         KEY_SAMBA_GROUP_POLICY,
 136         KEY_GP_MACHINE_POLICY,
 137         KEY_GP_MACHINE_WIN_POLICY,
 138         KEY_HKCU,
 139         KEY_GP_USER_POLICY,
 140         KEY_GP_USER_WIN_POLICY,
 141         "HKLM\\Software\\Microsoft\\Windows NT\\CurrentVersion\\Winlogon\\GPExtensions",
 142         "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Print\\Monitors",
 143         KEY_PROD_OPTIONS,
 144         "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Terminal Server\\DefaultUserConfiguration",
 145         KEY_TCPIP_PARAMS,
 146         KEY_NETLOGON_PARAMS,
 147         KEY_HKU,
 148         KEY_HKCR,
 149         KEY_HKPD,
 150         KEY_HKPT,
 151          NULL };
 152
 153 struct builtin_regkey_value {
 154         const char *path;
 155         const char *valuename;
 156         uint32 type;
 157         union {
 158                 const char *string;
 159                 uint32 dw_value;
 160         } data;
 161 };
 162
 163 static struct builtin_regkey_value builtin_registry_values[] = {
 164         { KEY_PRINTING_PORTS,
 165                 SAMBA_PRINTER_PORT_NAME, REG_SZ, { "" } },
 166         { KEY_PRINTING_2K,
 167                 "DefaultSpoolDirectory", REG_SZ, { "C:\\Windows\\System32\\Spool\\Printers" } },
 168         { KEY_EVENTLOG,
 169                 "DisplayName", REG_SZ, { "Event Log" } },
 170         { KEY_EVENTLOG,
 171                 "ErrorControl", REG_DWORD, { (char*)0x00000001 } },
 172         { NULL, NULL, 0, { NULL } }
 173 };
 174
 175 static WERROR create_key_recursive(struct db_context *db,
 176                                    char *path,
 177                                    const char *subkey)
 178 {
 179         WERROR werr;
 180         char *p;
 181
 182         if (subkey == NULL) {
 183                 return WERR_INVALID_PARAM;
 184         }
 185
 186         if (path == NULL) {
 187                 return regdb_create_basekey(db, subkey);
 188         }
 189
 190         p = strrchr_m(path, '\\');
 191
 192         if (p == NULL) {
 193                 werr = create_key_recursive(db, NULL, path);
 194         } else {
 195                 *p = '\0';
 196                 werr = create_key_recursive(db, path, p+1);
 197                 *p = '\\';
 198         }
 199
 200         if (!W_ERROR_IS_OK(werr)) {
 201                 goto done;
 202         }
 203
 204         werr = regdb_create_subkey_internal(db, path, subkey);
 205
 206 done:
 207         return werr;
 208 }
 209
 210 /**
 211  * Initialize a key in the registry:
 212  * create each component key of the specified path.
 213  */
 214 static WERROR init_registry_key_internal(struct db_context *db,
 215                                          const char *add_path)
 216 {
 217         char *subkey, *key;
 218         WERROR werr;
 219         TALLOC_CTX *frame = talloc_stackframe();
 220
 221         if (add_path == NULL) {
 222                 werr = WERR_INVALID_PARAM;
 223                 goto done;
 224         }
 225
 226         key = talloc_strdup(frame, add_path);
 227
 228         subkey = strrchr_m(key, '\\');
 229         if (subkey == NULL) {
 230                 subkey = key;
 231                 key = NULL;
 232         } else {
 233                 *subkey = '\0';
 234                 subkey++;
 235         }
 236
 237         werr = create_key_recursive(db, key, subkey);
 238
 239 done:
 240         talloc_free(frame);
 241         return werr;
 242 }
 243
 244 struct init_registry_key_context {
 245         const char *add_path;
 246 };
 247
 248 static NTSTATUS init_registry_key_action(struct db_context *db,
 249                                          void *private_data)
 250 {
 251         struct init_registry_key_context *init_ctx =
 252                 (struct init_registry_key_context *)private_data;
 253
 254         return werror_to_ntstatus(init_registry_key_internal(
 255                                         db, init_ctx->add_path));
 256 }
 257
 258 /**
 259  * Initialize a key in the registry:
 260  * create each component key of the specified path,
 261  * wrapped in one db transaction.
 262  */
 263 WERROR init_registry_key(const char *add_path)
 264 {
 265         struct init_registry_key_context init_ctx;
 266
 267         if (regdb_key_exists(regdb, add_path)) {
 268                 return WERR_OK;
 269         }
 270
 271         init_ctx.add_path = add_path;
 272
 273         return regdb_trans_do(regdb,
 274                               init_registry_key_action,
 275                               &init_ctx);
 276 }
 277
 278 /***********************************************************************
 279  Open the registry data in the tdb
 280  ***********************************************************************/
 281
 282 static void regdb_ctr_add_value(struct regval_ctr *ctr,
 283                                 struct builtin_regkey_value *value)
 284 {
 285         switch(value->type) {
 286         case REG_DWORD:
 287                 regval_ctr_addvalue(ctr, value->valuename, REG_DWORD,
 288                                     (uint8_t *)&value->data.dw_value,
 289                                     sizeof(uint32));
 290                 break;
 291
 292         case REG_SZ:
 293                 regval_ctr_addvalue_sz(ctr, value->valuename,
 294                                        value->data.string);
 295                 break;
 296
 297         default:
 298                 DEBUG(0, ("regdb_ctr_add_value: invalid value type in "
 299                           "registry values [%d]\n", value->type));
 300         }
 301 }
 302
 303 static NTSTATUS init_registry_data_action(struct db_context *db,
 304                                           void *private_data)
 305 {
 306         NTSTATUS status;
 307         TALLOC_CTX *frame = talloc_stackframe();
 308         struct regval_ctr *values;
 309         int i;
 310
 311         /* loop over all of the predefined paths and add each component */
 312
 313         for (i=0; builtin_registry_paths[i] != NULL; i++) {
 314                 if (regdb_key_exists(db, builtin_registry_paths[i])) {
 315                         continue;
 316                 }
 317                 status = werror_to_ntstatus(init_registry_key_internal(db,
 318                                                   builtin_registry_paths[i]));
 319                 if (!NT_STATUS_IS_OK(status)) {
 320                         goto done;
 321                 }
 322         }
 323
 324         /* loop over all of the predefined values and add each component */
 325
 326         for (i=0; builtin_registry_values[i].path != NULL; i++) {
 327                 WERROR werr;
 328
 329                 werr = regval_ctr_init(frame, &values);
 330                 if (!W_ERROR_IS_OK(werr)) {
 331                         status = werror_to_ntstatus(werr);
 332                         goto done;
 333                 }
 334
 335                 regdb_fetch_values_internal(db,
 336                                             builtin_registry_values[i].path,
 337                                             values);
 338
 339                 /* preserve existing values across restarts. Only add new ones */
 340
 341                 if (!regval_ctr_value_exists(values,
 342                                         builtin_registry_values[i].valuename))
 343                 {
 344                         regdb_ctr_add_value(values,
 345                                             &builtin_registry_values[i]);
 346                         status = regdb_store_values_internal(db,
 347                                         builtin_registry_values[i].path,
 348                                         values);
 349                         if (!NT_STATUS_IS_OK(status)) {
 350                                 goto done;
 351                         }
 352                 }
 353                 TALLOC_FREE(values);
 354         }
 355
 356         status = NT_STATUS_OK;
 357
 358 done:
 359
 360         TALLOC_FREE(frame);
 361         return status;
 362 }
 363
 364 WERROR init_registry_data(void)
 365 {
 366         WERROR werr;
 367         TALLOC_CTX *frame = talloc_stackframe();
 368         struct regval_ctr *values;
 369         int i;
 370
 371         /*
 372          * First, check for the existence of the needed keys and values.
 373          * If all do already exist, we can save the writes.
 374          */
 375         for (i=0; builtin_registry_paths[i] != NULL; i++) {
 376                 if (!regdb_key_exists(regdb, builtin_registry_paths[i])) {
 377                         goto do_init;
 378                 }
 379         }
 380
 381         for (i=0; builtin_registry_values[i].path != NULL; i++) {
 382                 werr = regval_ctr_init(frame, &values);
 383                 W_ERROR_NOT_OK_GOTO_DONE(werr);
 384
 385                 regdb_fetch_values_internal(regdb,
 386                                             builtin_registry_values[i].path,
 387                                             values);
 388                 if (!regval_ctr_value_exists(values,
 389                                         builtin_registry_values[i].valuename))
 390                 {
 391                         TALLOC_FREE(values);
 392                         goto do_init;
 393                 }
 394
 395                 TALLOC_FREE(values);
 396         }
 397
 398         werr = WERR_OK;
 399         goto done;
 400
 401 do_init:
 402
 403         /*
 404          * There are potentially quite a few store operations which are all
 405          * indiviually wrapped in tdb transactions. Wrapping them in a single
 406          * transaction gives just a single transaction_commit() to actually do
 407          * its fsync()s. See tdb/common/transaction.c for info about nested
 408          * transaction behaviour.
 409          */
 410
 411         werr = regdb_trans_do(regdb,
 412                               init_registry_data_action,
 413                               NULL);
 414
 415 done:
 416         TALLOC_FREE(frame);
 417         return werr;
 418 }
 419
 420 static int regdb_normalize_keynames_fn(struct db_record *rec,
 421                                        void *private_data)
 422 {
 423         TALLOC_CTX *mem_ctx = talloc_tos();
 424         const char *keyname;
 425         NTSTATUS status;
 426         TDB_DATA key;
 427         TDB_DATA value;
 428         struct db_context *db = (struct db_context *)private_data;
 429
 430         key = dbwrap_record_get_key(rec);
 431         if (key.dptr == NULL || key.dsize == 0) {
 432                 return 0;
 433         }
 434
 435         value = dbwrap_record_get_value(rec);
 436
 437         if (db == NULL) {
 438                 DEBUG(0, ("regdb_normalize_keynames_fn: ERROR: "
 439                           "NULL db context handed in via private_data\n"));
 440                 return 1;
 441         }
 442
 443         if (strncmp((const char *)key.dptr, REGDB_VERSION_KEYNAME,
 444             strlen(REGDB_VERSION_KEYNAME)) == 0)
 445         {
 446                 return 0;
 447         }
 448
 449         keyname = strchr((const char *)key.dptr, '/');
 450         if (keyname) {
 451                 keyname = talloc_string_sub(mem_ctx,
 452                                             (const char *)key.dptr,
 453                                             "/",
 454                                             "\\");
 455
 456                 DEBUG(2, ("regdb_normalize_keynames_fn: Convert %s to %s\n",
 457                           (const char *)key.dptr,
 458                           keyname));
 459
 460                 /* Delete the original record and store the normalized key */
 461                 status = dbwrap_record_delete(rec);
 462                 if (!NT_STATUS_IS_OK(status)) {
 463                         DEBUG(0,("regdb_normalize_keynames_fn: "
 464                                  "tdb_delete for [%s] failed!\n",
 465                                  (const char *)key.dptr));
 466                         return 1;
 467                 }
 468
 469                 status = dbwrap_store_bystring(db, keyname, value, TDB_REPLACE);
 470                 if (!NT_STATUS_IS_OK(status)) {
 471                         DEBUG(0,("regdb_normalize_keynames_fn: "
 472                                  "failed to store new record for [%s]!\n",
 473                                  keyname));
 474                         return 1;
 475                 }
 476         }
 477
 478         return 0;
 479 }
 480
 481 static WERROR regdb_store_regdb_version(struct db_context *db, uint32_t version)
 482 {
 483         NTSTATUS status;
 484         if (db == NULL) {
 485                 return WERR_CAN_NOT_COMPLETE;
 486         }
 487
 488         status = dbwrap_trans_store_int32_bystring(db, REGDB_VERSION_KEYNAME,
 489                                                    version);
 490         if (!NT_STATUS_IS_OK(status)) {
 491                 DEBUG(1, ("regdb_store_regdb_version: error storing %s = %d: %s\n",
 492                           REGDB_VERSION_KEYNAME, version, nt_errstr(status)));
 493                 return ntstatus_to_werror(status);
 494         } else {
 495                 DEBUG(10, ("regdb_store_regdb_version: stored %s = %d\n",
 496                           REGDB_VERSION_KEYNAME, version));
 497                 return WERR_OK;
 498         }
 499 }
 500
 501 static WERROR regdb_upgrade_v1_to_v2(struct db_context *db)
 502 {
 503         TALLOC_CTX *mem_ctx;
 504         NTSTATUS status;
 505         WERROR werr;
 506
 507         mem_ctx = talloc_stackframe();
 508
 509         status = dbwrap_traverse(db, regdb_normalize_keynames_fn, db, NULL);
 510         if (!NT_STATUS_IS_OK(status)) {
 511                 werr = WERR_REG_IO_FAILURE;
 512                 goto done;
 513         }
 514
 515         werr = regdb_store_regdb_version(db, REGDB_VERSION_V2);
 516
 517 done:
 518         talloc_free(mem_ctx);
 519         return werr;
 520 }
 521
 522 static bool tdb_data_read_uint32(TDB_DATA *buf, uint32_t *result)
 523 {
 524         const size_t len = sizeof(uint32_t);
 525         if (buf->dsize >= len) {
 526                 *result = IVAL(buf->dptr, 0);
 527                 buf->dptr += len;
 528                 buf->dsize -= len;
 529                 return true;
 530         }
 531         return false;
 532 }
 533
 534 static bool tdb_data_read_cstr(TDB_DATA *buf, char **result)
 535 {
 536         const size_t len = strnlen((char*)buf->dptr, buf->dsize) + 1;
 537         if (buf->dsize >= len) {
 538                 *result = (char*)buf->dptr;
 539                 buf->dptr += len;
 540                 buf->dsize -= len;
 541                 return true;
 542         }
 543         return false;
 544 }
 545
 546 static bool tdb_data_is_cstr(TDB_DATA d) {
 547         if (tdb_data_is_empty(d) || (d.dptr[d.dsize-1] != '\0')) {
 548                 return false;
 549         }
 550         return strchr((char *)d.dptr, '\0') == (char *)&d.dptr[d.dsize-1];
 551 }
 552
 553 static bool upgrade_v2_to_v3_check_subkeylist(struct db_context *db,
 554                                               const char *key,
 555                                               const char *subkey)
 556 {
 557         static uint32_t zero = 0;
 558         static TDB_DATA empty_subkey_list = {
 559                 .dptr = (unsigned char*)&zero,
 560                 .dsize = sizeof(uint32_t),
 561         };
 562         bool success = false;
 563         char *path = talloc_asprintf(talloc_tos(), "%s\\%s", key, subkey);
 564         if (!strupper_m(path)) {
 565                 goto done;
 566         }
 567
 568         if (!dbwrap_exists(db, string_term_tdb_data(path))) {
 569                 NTSTATUS status;
 570
 571                 DEBUG(10, ("regdb_upgrade_v2_to_v3: writing subkey list [%s]\n",
 572                            path));
 573
 574                 status = dbwrap_store_bystring(db, path, empty_subkey_list,
 575                                                TDB_INSERT);
 576                 if (!NT_STATUS_IS_OK(status)) {
 577                         DEBUG(0, ("regdb_upgrade_v2_to_v3: writing subkey list "
 578                                   "[%s] failed\n", path));
 579                         goto done;
 580                 }
 581         }
 582         success = true;
 583 done:
 584         talloc_free(path);
 585         return success;
 586 }
 587
 588 static bool upgrade_v2_to_v3_check_parent(struct db_context *db,
 589                                           const char *key)
 590 {
 591         const char *sep = strrchr_m(key, '\\');
 592         if (sep != NULL) {
 593                 char *pkey = talloc_strndup(talloc_tos(), key, sep-key);
 594                 if (!dbwrap_exists(db, string_term_tdb_data(pkey))) {
 595                         DEBUG(0, ("regdb_upgrade_v2_to_v3: missing subkey list "
 596                                   "[%s]\nrun \"net registry check\"\n", pkey));
 597                 }
 598                 talloc_free(pkey);
 599         }
 600         return true;
 601 }
 602
 603
 604 #define IS_EQUAL(d,s) (((d).dsize == strlen(s)+1) &&    \
 605                        (strcmp((char*)(d).dptr, (s)) == 0))
 606 #define STARTS_WITH(d,s) (((d).dsize > strlen(s)) &&                    \
 607                           (strncmp((char*)(d).dptr, (s), strlen(s)) == 0))
 608 #define SSTR(d) (int)(d).dsize , (char*)(d).dptr
 609
 610
 611 static int regdb_upgrade_v2_to_v3_fn(struct db_record *rec, void *private_data)
 612 {
 613         struct db_context *db = (struct db_context *)private_data;
 614         TDB_DATA key = dbwrap_record_get_key(rec);
 615         TDB_DATA val = dbwrap_record_get_value(rec);
 616
 617         if (tdb_data_is_empty(key)) {
 618                 return 0;
 619         }
 620
 621         if (db == NULL) {
 622                 DEBUG(0, ("regdb_upgrade_v2_to_v3_fn: ERROR: "
 623                           "NULL db context handed in via private_data\n"));
 624                 return 1;
 625         }
 626
 627         if (IS_EQUAL(key, REGDB_VERSION_KEYNAME) ||
 628             STARTS_WITH(key, REG_VALUE_PREFIX) ||
 629             STARTS_WITH(key, REG_SECDESC_PREFIX))
 630         {
 631                 DEBUG(10, ("regdb_upgrade_v2_to_v3: skipping [%.*s]\n",
 632                            SSTR(key)));
 633                 return 0;
 634         }
 635
 636         if (STARTS_WITH(key, REG_SORTED_SUBKEYS_PREFIX)) {
 637                 NTSTATUS status;
 638                 /* Delete the deprecated sorted subkeys cache. */
 639
 640                 DEBUG(10, ("regdb_upgrade_v2_to_v3: deleting [%.*s]\n",
 641                            SSTR(key)));
 642
 643                 status = dbwrap_record_delete(rec);
 644                 if (!NT_STATUS_IS_OK(status)) {
 645                         DEBUG(0, ("regdb_upgrade_v2_to_v3: deleting [%.*s] "
 646                                   "failed!\n", SSTR(key)));
 647                         return 1;
 648                 }
 649
 650                 return 0;
 651         }
 652
 653         if ( tdb_data_is_cstr(key) &&
 654              hive_info((char*)key.dptr) != NULL )
 655         {
 656                 /*
 657                  * Found a regular subkey list record.
 658                  * Walk the list and create the list record for those
 659                  * subkeys that don't already have one.
 660                  */
 661                 TDB_DATA pos = val;
 662                 char *subkey, *path = (char*)key.dptr;
 663                 uint32_t num_items, found_items = 0;
 664
 665
 666                 DEBUG(10, ("regdb_upgrade_v2_to_v3: scanning subkeylist of "
 667                            "[%s]\n", path));
 668
 669                 if (!tdb_data_read_uint32(&pos, &num_items)) {
 670                         /* invalid or empty - skip */
 671                         return 0;
 672                 }
 673
 674                 while (tdb_data_read_cstr(&pos, &subkey)) {
 675                         found_items++;
 676
 677                         if (!upgrade_v2_to_v3_check_subkeylist(db, path, subkey))
 678                         {
 679                                 return 1;
 680                         }
 681
 682                         if (!upgrade_v2_to_v3_check_parent(db, path)) {
 683                                 return 1;
 684                         }
 685                 }
 686                 if (found_items != num_items) {
 687                         DEBUG(0, ("regdb_upgrade_v2_to_v3: inconsistent subkey "
 688                                   "list [%s]\nrun \"net registry check\"\n",
 689                                   path));
 690                 }
 691         } else {
 692                 DEBUG(10, ("regdb_upgrade_v2_to_v3: skipping invalid [%.*s]\n"
 693                            "run \"net registry check\"\n", SSTR(key)));
 694         }
 695
 696         return 0;
 697 }
 698
 699 static WERROR regdb_upgrade_v2_to_v3(struct db_context *db)
 700 {
 701         NTSTATUS status;
 702         WERROR werr;
 703
 704         status = dbwrap_traverse(db, regdb_upgrade_v2_to_v3_fn, db, NULL);
 705         if (!NT_STATUS_IS_OK(status)) {
 706                 werr = WERR_REG_IO_FAILURE;
 707                 goto done;
 708         }
 709
 710         werr = regdb_store_regdb_version(db, REGDB_VERSION_V3);
 711
 712 done:
 713         return werr;
 714 }
 715
 716 /***********************************************************************
 717  Open the registry database
 718  ***********************************************************************/
 719
 720 WERROR regdb_init(void)
 721 {
 722         int32_t vers_id;
 723         WERROR werr;
 724         NTSTATUS status;
 725
 726         if (regdb) {
 727                 DEBUG(10, ("regdb_init: incrementing refcount (%d->%d)\n",
 728                            regdb_refcount, regdb_refcount+1));
 729                 regdb_refcount++;
 730                 return WERR_OK;
 731         }
 732
 733         regdb = db_open(NULL, state_path("registry.tdb"), 0,
 734                         REG_TDB_FLAGS, O_RDWR, 0600,
 735                         DBWRAP_LOCK_ORDER_1);
 736         if (!regdb) {
 737                 regdb = db_open(NULL, state_path("registry.tdb"), 0,
 738                                 REG_TDB_FLAGS, O_RDWR|O_CREAT, 0600,
 739                                 DBWRAP_LOCK_ORDER_1);
 740                 if (!regdb) {
 741                         werr = ntstatus_to_werror(map_nt_error_from_unix(errno));
 742                         DEBUG(1,("regdb_init: Failed to open registry %s (%s)\n",
 743                                 state_path("registry.tdb"), strerror(errno) ));
 744                         return werr;
 745                 }
 746
 747                 werr = regdb_store_regdb_version(regdb, REGDB_CODE_VERSION);
 748                 if (!W_ERROR_IS_OK(werr)) {
 749                         DEBUG(1, ("regdb_init: Failed to store version: %s\n",
 750                                   win_errstr(werr)));
 751                         return werr;
 752                 }
 753
 754                 DEBUG(10,("regdb_init: Successfully created registry tdb\n"));
 755         }
 756
 757         regdb_refcount = 1;
 758         DEBUG(10, ("regdb_init: registry db openend. refcount reset (%d)\n",
 759                    regdb_refcount));
 760
 761         status = dbwrap_fetch_int32_bystring(regdb, REGDB_VERSION_KEYNAME,
 762                                              &vers_id);
 763         if (!NT_STATUS_IS_OK(status)) {
 764                 DEBUG(10, ("regdb_init: registry version uninitialized "
 765                            "(got %d), initializing to version %d\n",
 766                            vers_id, REGDB_VERSION_V1));
 767
 768                 /*
 769                  * There was a regdb format version prior to version 1
 770                  * which did not store a INFO/version key. The format
 771                  * of this version was identical to version 1 except for
 772                  * the lack of the sorted subkey cache records.
 773                  * Since these are disposable, we can safely assume version
 774                  * 1 if no INFO/version key is found and run the db through
 775                  * the whole chain of upgrade. If the database was not
 776                  * initialized, this does not harm. If it was the unversioned
 777                  * version ("0"), then it do the right thing with the records.
 778                  */
 779                 werr = regdb_store_regdb_version(regdb, REGDB_VERSION_V1);
 780                 if (!W_ERROR_IS_OK(werr)) {
 781                         return werr;
 782                 }
 783                 vers_id = REGDB_VERSION_V1;
 784         }
 785
 786         if (vers_id == REGDB_CODE_VERSION) {
 787                 return WERR_OK;
 788         }
 789
 790         if (vers_id > REGDB_CODE_VERSION || vers_id == 0) {
 791                 DEBUG(0, ("regdb_init: unknown registry version %d "
 792                           "(code version = %d), refusing initialization\n",
 793                           vers_id, REGDB_CODE_VERSION));
 794                 return WERR_CAN_NOT_COMPLETE;
 795         }
 796
 797         if (dbwrap_transaction_start(regdb) != 0) {
 798                 return WERR_REG_IO_FAILURE;
 799         }
 800
 801         if (vers_id == REGDB_VERSION_V1) {
 802                 DEBUG(10, ("regdb_init: upgrading registry from version %d "
 803                            "to %d\n", REGDB_VERSION_V1, REGDB_VERSION_V2));
 804
 805                 werr = regdb_upgrade_v1_to_v2(regdb);
 806                 if (!W_ERROR_IS_OK(werr)) {
 807                         dbwrap_transaction_cancel(regdb);
 808                         return werr;
 809                 }
 810
 811                 vers_id = REGDB_VERSION_V2;
 812         }
 813
 814         if (vers_id == REGDB_VERSION_V2) {
 815                 DEBUG(10, ("regdb_init: upgrading registry from version %d "
 816                            "to %d\n", REGDB_VERSION_V2, REGDB_VERSION_V3));
 817
 818                 werr = regdb_upgrade_v2_to_v3(regdb);
 819                 if (!W_ERROR_IS_OK(werr)) {
 820                         dbwrap_transaction_cancel(regdb);
 821                         return werr;
 822                 }
 823
 824                 vers_id = REGDB_VERSION_V3;
 825         }
 826
 827         /* future upgrade code should go here */
 828
 829         if (dbwrap_transaction_commit(regdb) != 0) {
 830                 return WERR_REG_IO_FAILURE;
 831         }
 832
 833         return WERR_OK;
 834 }
 835
 836 /***********************************************************************
 837  Open the registry.  Must already have been initialized by regdb_init()
 838  ***********************************************************************/
 839
 840 WERROR regdb_open( void )
 841 {
 842         WERROR result = WERR_OK;
 843
 844         if ( regdb ) {
 845                 DEBUG(10, ("regdb_open: incrementing refcount (%d->%d)\n",
 846                            regdb_refcount, regdb_refcount+1));
 847                 regdb_refcount++;
 848                 return WERR_OK;
 849         }
 850
 851         become_root();
 852
 853         regdb = db_open(NULL, state_path("registry.tdb"), 0,
 854                         REG_TDB_FLAGS, O_RDWR, 0600,
 855                         DBWRAP_LOCK_ORDER_1);
 856         if ( !regdb ) {
 857                 result = ntstatus_to_werror( map_nt_error_from_unix( errno ) );
 858                 DEBUG(0,("regdb_open: Failed to open %s! (%s)\n",
 859                         state_path("registry.tdb"), strerror(errno) ));
 860         }
 861
 862         unbecome_root();
 863
 864         regdb_refcount = 1;
 865         DEBUG(10, ("regdb_open: registry db opened. refcount reset (%d)\n",
 866                    regdb_refcount));
 867
 868         return result;
 869 }
 870
 871 /***********************************************************************
 872  ***********************************************************************/
 873
 874 int regdb_close( void )
 875 {
 876         if (regdb_refcount == 0) {
 877                 return 0;
 878         }
 879
 880         regdb_refcount--;
 881
 882         DEBUG(10, ("regdb_close: decrementing refcount (%d->%d)\n",
 883                    regdb_refcount+1, regdb_refcount));
 884
 885         if ( regdb_refcount > 0 )
 886                 return 0;
 887
 888         SMB_ASSERT( regdb_refcount >= 0 );
 889
 890         TALLOC_FREE(regdb);
 891         return 0;
 892 }
 893
 894 WERROR regdb_transaction_start(void)
 895 {
 896         return (dbwrap_transaction_start(regdb) == 0) ?
 897                 WERR_OK : WERR_REG_IO_FAILURE;
 898 }
 899
 900 WERROR regdb_transaction_commit(void)
 901 {
 902         return (dbwrap_transaction_commit(regdb) == 0) ?
 903                 WERR_OK : WERR_REG_IO_FAILURE;
 904 }
 905
 906 WERROR regdb_transaction_cancel(void)
 907 {
 908         return (dbwrap_transaction_cancel(regdb) == 0) ?
 909                 WERR_OK : WERR_REG_IO_FAILURE;
 910 }
 911
 912 /***********************************************************************
 913  return the tdb sequence number of the registry tdb.
 914  this is an indicator for the content of the registry
 915  having changed. it will change upon regdb_init, too, though.
 916  ***********************************************************************/
 917 int regdb_get_seqnum(void)
 918 {
 919         return dbwrap_get_seqnum(regdb);
 920 }
 921
 922
 923 static WERROR regdb_delete_key_with_prefix(struct db_context *db,
 924                                            const char *keyname,
 925                                            const char *prefix)
 926 {
 927         char *path;
 928         WERROR werr = WERR_NOMEM;
 929         TALLOC_CTX *mem_ctx = talloc_stackframe();
 930
 931         if (keyname == NULL) {
 932                 werr = WERR_INVALID_PARAM;
 933                 goto done;
 934         }
 935
 936         if (prefix == NULL) {
 937                 path = discard_const_p(char, keyname);
 938         } else {
 939                 path = talloc_asprintf(mem_ctx, "%s\\%s", prefix, keyname);
 940                 if (path == NULL) {
 941                         goto done;
 942                 }
 943         }
 944
 945         path = normalize_reg_path(mem_ctx, path);
 946         if (path == NULL) {
 947                 goto done;
 948         }
 949
 950         werr = ntstatus_to_werror(dbwrap_delete_bystring(db, path));
 951
 952         /* treat "not found" as ok */
 953         if (W_ERROR_EQUAL(werr, WERR_NOT_FOUND)) {
 954                 werr = WERR_OK;
 955         }
 956
 957 done:
 958         talloc_free(mem_ctx);
 959         return werr;
 960 }
 961
 962
 963 static WERROR regdb_delete_values(struct db_context *db, const char *keyname)
 964 {
 965         return regdb_delete_key_with_prefix(db, keyname, REG_VALUE_PREFIX);
 966 }
 967
 968 static WERROR regdb_delete_secdesc(struct db_context *db, const char *keyname)
 969 {
 970         return regdb_delete_key_with_prefix(db, keyname, REG_SECDESC_PREFIX);
 971 }
 972
 973 static WERROR regdb_delete_subkeylist(struct db_context *db, const char *keyname)
 974 {
 975         return regdb_delete_key_with_prefix(db, keyname, NULL);
 976 }
 977
 978
 979 static WERROR regdb_delete_key_lists(struct db_context *db, const char *keyname)
 980 {
 981         WERROR werr;
 982
 983         werr = regdb_delete_values(db, keyname);
 984         if (!W_ERROR_IS_OK(werr)) {
 985                 DEBUG(1, (__location__ " Deleting %s\\%s failed: %s\n",
 986                           REG_VALUE_PREFIX, keyname, win_errstr(werr)));
 987                 goto done;
 988         }
 989
 990         werr = regdb_delete_secdesc(db, keyname);
 991         if (!W_ERROR_IS_OK(werr)) {
 992                 DEBUG(1, (__location__ " Deleting %s\\%s failed: %s\n",
 993                           REG_SECDESC_PREFIX, keyname, win_errstr(werr)));
 994                 goto done;
 995         }
 996
 997         werr = regdb_delete_subkeylist(db, keyname);
 998         if (!W_ERROR_IS_OK(werr)) {
 999                 DEBUG(1, (__location__ " Deleting %s failed: %s\n",
1000                           keyname, win_errstr(werr)));
1001                 goto done;
1002         }
1003
1004 done:
1005         return werr;
1006 }
1007
1008 /***********************************************************************
1009  Add subkey strings to the registry tdb under a defined key
1010  fmt is the same format as tdb_pack except this function only supports
1011  fstrings
1012  ***********************************************************************/
1013
1014 static WERROR regdb_store_keys_internal2(struct db_context *db,
1015                                          const char *key,
1016                                          struct regsubkey_ctr *ctr)
1017 {
1018         TDB_DATA dbuf;
1019         uint8 *buffer = NULL;
1020         int i = 0;
1021         uint32 len, buflen;
1022         uint32 num_subkeys = regsubkey_ctr_numkeys(ctr);
1023         char *keyname = NULL;
1024         TALLOC_CTX *ctx = talloc_stackframe();
1025         WERROR werr;
1026
1027         if (!key) {
1028                 werr = WERR_INVALID_PARAM;
1029                 goto done;
1030         }
1031
1032         keyname = talloc_strdup(ctx, key);
1033         if (!keyname) {
1034                 werr = WERR_NOMEM;
1035                 goto done;
1036         }
1037
1038         keyname = normalize_reg_path(ctx, keyname);
1039         if (!keyname) {
1040                 werr = WERR_NOMEM;
1041                 goto done;
1042         }
1043
1044         /* allocate some initial memory */
1045
1046         buffer = (uint8 *)SMB_MALLOC(1024);
1047         if (buffer == NULL) {
1048                 werr = WERR_NOMEM;
1049                 goto done;
1050         }
1051         buflen = 1024;
1052         len = 0;
1053
1054         /* store the number of subkeys */
1055
1056         len += tdb_pack(buffer+len, buflen-len, "d", num_subkeys);
1057
1058         /* pack all the strings */
1059
1060         for (i=0; i<num_subkeys; i++) {
1061                 size_t thistime;
1062
1063                 thistime = tdb_pack(buffer+len, buflen-len, "f",
1064                                     regsubkey_ctr_specific_key(ctr, i));
1065                 if (len+thistime > buflen) {
1066                         size_t thistime2;
1067                         /*
1068                          * tdb_pack hasn't done anything because of the short
1069                          * buffer, allocate extra space.
1070                          */
1071                         buffer = SMB_REALLOC_ARRAY(buffer, uint8_t,
1072                                                    (len+thistime)*2);
1073                         if(buffer == NULL) {
1074                                 DEBUG(0, ("regdb_store_keys: Failed to realloc "
1075                                           "memory of size [%u]\n",
1076                                           (unsigned int)(len+thistime)*2));
1077                                 werr = WERR_NOMEM;
1078                                 goto done;
1079                         }
1080                         buflen = (len+thistime)*2;
1081                         thistime2 = tdb_pack(
1082                                 buffer+len, buflen-len, "f",
1083                                 regsubkey_ctr_specific_key(ctr, i));
1084                         if (thistime2 != thistime) {
1085                                 DEBUG(0, ("tdb_pack failed\n"));
1086                                 werr = WERR_CAN_NOT_COMPLETE;
1087                                 goto done;
1088                         }
1089                 }
1090                 len += thistime;
1091         }
1092
1093         /* finally write out the data */
1094
1095         dbuf.dptr = buffer;
1096         dbuf.dsize = len;
1097         werr = ntstatus_to_werror(dbwrap_store_bystring(db, keyname, dbuf,
1098                                                         TDB_REPLACE));
1099
1100 done:
1101         TALLOC_FREE(ctx);
1102         SAFE_FREE(buffer);
1103         return werr;
1104 }
1105
1106 /**
1107  * Utility function to store a new empty list of
1108  * subkeys of given key specified as parent and subkey name
1109  * (thereby creating the key).
1110  * If the parent keyname is NULL, then the "subkey" is
1111  * interpreted as a base key.
1112  * If the subkey list does already exist, it is not modified.
1113  *
1114  * Must be called from within a transaction.
1115  */
1116 static WERROR regdb_store_subkey_list(struct db_context *db, const char *parent,
1117                                       const char *key)
1118 {
1119         WERROR werr;
1120         char *path = NULL;
1121         struct regsubkey_ctr *subkeys = NULL;
1122         TALLOC_CTX *frame = talloc_stackframe();
1123
1124         if (parent == NULL) {
1125                 path = talloc_strdup(frame, key);
1126         } else {
1127                 path = talloc_asprintf(frame, "%s\\%s", parent, key);
1128         }
1129         if (!path) {
1130                 werr = WERR_NOMEM;
1131                 goto done;
1132         }
1133
1134         werr = regsubkey_ctr_init(frame, &subkeys);
1135         W_ERROR_NOT_OK_GOTO_DONE(werr);
1136
1137         werr = regdb_fetch_keys_internal(db, path, subkeys);
1138         if (W_ERROR_IS_OK(werr)) {
1139                 /* subkey list exists already - don't modify */
1140                 goto done;
1141         }
1142
1143         werr = regsubkey_ctr_reinit(subkeys);
1144         W_ERROR_NOT_OK_GOTO_DONE(werr);
1145
1146         /* create a record with 0 subkeys */
1147         werr = regdb_store_keys_internal2(db, path, subkeys);
1148         if (!W_ERROR_IS_OK(werr)) {
1149                 DEBUG(0, ("regdb_store_keys: Failed to store new record for "
1150                           "key [%s]: %s\n", path, win_errstr(werr)));
1151                 goto done;
1152         }
1153
1154 done:
1155         talloc_free(frame);
1156         return werr;
1157 }
1158
1159 /***********************************************************************
1160  Store the new subkey record and create any child key records that
1161  do not currently exist
1162  ***********************************************************************/
1163
1164 struct regdb_store_keys_context {
1165         const char *key;
1166         struct regsubkey_ctr *ctr;
1167 };
1168
1169 static NTSTATUS regdb_store_keys_action(struct db_context *db,
1170                                         void *private_data)
1171 {
1172         struct regdb_store_keys_context *store_ctx;
1173         WERROR werr;
1174         int num_subkeys, i;
1175         char *path = NULL;
1176         struct regsubkey_ctr *old_subkeys = NULL;
1177         char *oldkeyname = NULL;
1178         TALLOC_CTX *mem_ctx = talloc_stackframe();
1179
1180         store_ctx = (struct regdb_store_keys_context *)private_data;
1181
1182         /*
1183          * Re-fetch the old keys inside the transaction
1184          */
1185
1186         werr = regsubkey_ctr_init(mem_ctx, &old_subkeys);
1187         W_ERROR_NOT_OK_GOTO_DONE(werr);
1188
1189         werr = regdb_fetch_keys_internal(db, store_ctx->key, old_subkeys);
1190         if (!W_ERROR_IS_OK(werr) &&
1191             !W_ERROR_EQUAL(werr, WERR_NOT_FOUND))
1192         {
1193                 goto done;
1194         }
1195
1196         /*
1197          * Make the store operation as safe as possible without transactions:
1198          *
1199          * (1) For each subkey removed from ctr compared with old_subkeys:
1200          *
1201          *     (a) First delete the value db entry.
1202          *
1203          *     (b) Next delete the secdesc db record.
1204          *
1205          *     (c) Then delete the subkey list entry.
1206          *
1207          * (2) Now write the list of subkeys of the parent key,
1208          *     deleting removed entries and adding new ones.
1209          *
1210          * (3) Finally create the subkey list entries for the added keys.
1211          *
1212          * This way if we crash half-way in between deleting the subkeys
1213          * and storing the parent's list of subkeys, no old data can pop up
1214          * out of the blue when re-adding keys later on.
1215          */
1216
1217         /* (1) delete removed keys' lists (values/secdesc/subkeys) */
1218
1219         num_subkeys = regsubkey_ctr_numkeys(old_subkeys);
1220         for (i=0; i<num_subkeys; i++) {
1221                 oldkeyname = regsubkey_ctr_specific_key(old_subkeys, i);
1222
1223                 if (regsubkey_ctr_key_exists(store_ctx->ctr, oldkeyname)) {
1224                         /*
1225                          * It's still around, don't delete
1226                          */
1227                         continue;
1228                 }
1229
1230                 path = talloc_asprintf(mem_ctx, "%s\\%s", store_ctx->key,
1231                                        oldkeyname);
1232                 if (!path) {
1233                         werr = WERR_NOMEM;
1234                         goto done;
1235                 }
1236
1237                 werr = regdb_delete_key_lists(db, path);
1238                 W_ERROR_NOT_OK_GOTO_DONE(werr);
1239
1240                 TALLOC_FREE(path);
1241         }
1242
1243         TALLOC_FREE(old_subkeys);
1244
1245         /* (2) store the subkey list for the parent */
1246
1247         werr = regdb_store_keys_internal2(db, store_ctx->key, store_ctx->ctr);
1248         if (!W_ERROR_IS_OK(werr)) {
1249                 DEBUG(0,("regdb_store_keys: Failed to store new subkey list "
1250                          "for parent [%s]: %s\n", store_ctx->key,
1251                          win_errstr(werr)));
1252                 goto done;
1253         }
1254
1255         /* (3) now create records for any subkeys that don't already exist */
1256
1257         num_subkeys = regsubkey_ctr_numkeys(store_ctx->ctr);
1258
1259         for (i=0; i<num_subkeys; i++) {
1260                 const char *subkey;
1261
1262                 subkey = regsubkey_ctr_specific_key(store_ctx->ctr, i);
1263
1264                 werr = regdb_store_subkey_list(db, store_ctx->key, subkey);
1265                 W_ERROR_NOT_OK_GOTO_DONE(werr);
1266         }
1267
1268         /*
1269          * Update the seqnum in the container to possibly
1270          * prevent next read from going to disk
1271          */
1272         werr = regsubkey_ctr_set_seqnum(store_ctx->ctr, dbwrap_get_seqnum(db));
1273
1274 done:
1275         talloc_free(mem_ctx);
1276         return werror_to_ntstatus(werr);
1277 }
1278
1279 static bool regdb_store_keys_internal(struct db_context *db, const char *key,
1280                                       struct regsubkey_ctr *ctr)
1281 {
1282         int num_subkeys, old_num_subkeys, i;
1283         struct regsubkey_ctr *old_subkeys = NULL;
1284         TALLOC_CTX *ctx = talloc_stackframe();
1285         WERROR werr;
1286         bool ret = false;
1287         struct regdb_store_keys_context store_ctx;
1288
1289         if (!regdb_key_exists(db, key)) {
1290                 goto done;
1291         }
1292
1293         /*
1294          * fetch a list of the old subkeys so we can determine if anything has
1295          * changed
1296          */
1297
1298         werr = regsubkey_ctr_init(ctx, &old_subkeys);
1299         if (!W_ERROR_IS_OK(werr)) {
1300                 DEBUG(0,("regdb_store_keys: talloc() failure!\n"));
1301                 goto done;
1302         }
1303
1304         werr = regdb_fetch_keys_internal(db, key, old_subkeys);
1305         if (!W_ERROR_IS_OK(werr) &&
1306             !W_ERROR_EQUAL(werr, WERR_NOT_FOUND))
1307         {
1308                 goto done;
1309         }
1310
1311         num_subkeys = regsubkey_ctr_numkeys(ctr);
1312         old_num_subkeys = regsubkey_ctr_numkeys(old_subkeys);
1313         if ((num_subkeys && old_num_subkeys) &&
1314             (num_subkeys == old_num_subkeys)) {
1315
1316                 for (i = 0; i < num_subkeys; i++) {
1317                         if (strcmp(regsubkey_ctr_specific_key(ctr, i),
1318                                    regsubkey_ctr_specific_key(old_subkeys, i))
1319                             != 0)
1320                         {
1321                                 break;
1322                         }
1323                 }
1324                 if (i == num_subkeys) {
1325                         /*
1326                          * Nothing changed, no point to even start a tdb
1327                          * transaction
1328                          */
1329
1330                         ret = true;
1331                         goto done;
1332                 }
1333         }
1334
1335         TALLOC_FREE(old_subkeys);
1336
1337         store_ctx.key = key;
1338         store_ctx.ctr = ctr;
1339
1340         werr = regdb_trans_do(db,
1341                               regdb_store_keys_action,
1342                               &store_ctx);
1343
1344         ret = W_ERROR_IS_OK(werr);
1345
1346 done:
1347         TALLOC_FREE(ctx);
1348
1349         return ret;
1350 }
1351
1352 static bool regdb_store_keys(const char *key, struct regsubkey_ctr *ctr)
1353 {
1354         return regdb_store_keys_internal(regdb, key, ctr);
1355 }
1356
1357 /**
1358  * create a subkey of a given key
1359  */
1360
1361 struct regdb_create_subkey_context {
1362         const char *key;
1363         const char *subkey;
1364 };
1365
1366 static NTSTATUS regdb_create_subkey_action(struct db_context *db,
1367                                            void *private_data)
1368 {
1369         WERROR werr;
1370         struct regdb_create_subkey_context *create_ctx;
1371         struct regsubkey_ctr *subkeys;
1372         TALLOC_CTX *mem_ctx = talloc_stackframe();
1373
1374         create_ctx = (struct regdb_create_subkey_context *)private_data;
1375
1376         werr = regsubkey_ctr_init(mem_ctx, &subkeys);
1377         W_ERROR_NOT_OK_GOTO_DONE(werr);
1378
1379         werr = regdb_fetch_keys_internal(db, create_ctx->key, subkeys);
1380         W_ERROR_NOT_OK_GOTO_DONE(werr);
1381
1382         werr = regsubkey_ctr_addkey(subkeys, create_ctx->subkey);
1383         W_ERROR_NOT_OK_GOTO_DONE(werr);
1384
1385         werr = regdb_store_keys_internal2(db, create_ctx->key, subkeys);
1386         if (!W_ERROR_IS_OK(werr)) {
1387                 DEBUG(0, (__location__ " failed to store new subkey list for "
1388                          "parent key %s: %s\n", create_ctx->key,
1389                          win_errstr(werr)));
1390         }
1391
1392         werr = regdb_store_subkey_list(db, create_ctx->key, create_ctx->subkey);
1393
1394 done:
1395         talloc_free(mem_ctx);
1396         return werror_to_ntstatus(werr);
1397 }
1398
1399 static WERROR regdb_create_subkey_internal(struct db_context *db,
1400                                            const char *key,
1401                                            const char *subkey)
1402 {
1403         WERROR werr;
1404         struct regsubkey_ctr *subkeys;
1405         TALLOC_CTX *mem_ctx = talloc_stackframe();
1406         struct regdb_create_subkey_context create_ctx;
1407
1408         if (!regdb_key_exists(db, key)) {
1409                 werr = WERR_NOT_FOUND;
1410                 goto done;
1411         }
1412
1413         werr = regsubkey_ctr_init(mem_ctx, &subkeys);
1414         W_ERROR_NOT_OK_GOTO_DONE(werr);
1415
1416         werr = regdb_fetch_keys_internal(db, key, subkeys);
1417         W_ERROR_NOT_OK_GOTO_DONE(werr);
1418
1419         if (regsubkey_ctr_key_exists(subkeys, subkey)) {
1420                 char *newkey;
1421
1422                 newkey = talloc_asprintf(mem_ctx, "%s\\%s", key, subkey);
1423                 if (newkey == NULL) {
1424                         werr = WERR_NOMEM;
1425                         goto done;
1426                 }
1427
1428                 if (regdb_key_exists(db, newkey)) {
1429                         werr = WERR_OK;
1430                         goto done;
1431                 }
1432         }
1433
1434         talloc_free(subkeys);
1435
1436         create_ctx.key = key;
1437         create_ctx.subkey = subkey;
1438
1439         werr = regdb_trans_do(db,
1440                               regdb_create_subkey_action,
1441                               &create_ctx);
1442
1443 done:
1444         talloc_free(mem_ctx);
1445         return werr;
1446 }
1447
1448 static WERROR regdb_create_subkey(const char *key, const char *subkey)
1449 {
1450         return regdb_create_subkey_internal(regdb, key, subkey);
1451 }
1452
1453 /**
1454  * create a base key
1455  */
1456
1457 struct regdb_create_basekey_context {
1458         const char *key;
1459 };
1460
1461 static NTSTATUS regdb_create_basekey_action(struct db_context *db,
1462                                             void *private_data)
1463 {
1464         WERROR werr;
1465         struct regdb_create_basekey_context *create_ctx;
1466
1467         create_ctx = (struct regdb_create_basekey_context *)private_data;
1468
1469         werr = regdb_store_subkey_list(db, NULL, create_ctx->key);
1470
1471         return werror_to_ntstatus(werr);
1472 }
1473
1474 static WERROR regdb_create_basekey(struct db_context *db, const char *key)
1475 {
1476         WERROR werr;
1477         struct regdb_create_subkey_context create_ctx;
1478
1479         create_ctx.key = key;
1480
1481         werr = regdb_trans_do(db,
1482                               regdb_create_basekey_action,
1483                               &create_ctx);
1484
1485         return werr;
1486 }
1487
1488 /**
1489  * create a subkey of a given key
1490  */
1491
1492 struct regdb_delete_subkey_context {
1493         const char *key;
1494         const char *subkey;
1495         const char *path;
1496         bool lazy;
1497 };
1498
1499 static NTSTATUS regdb_delete_subkey_action(struct db_context *db,
1500                                            void *private_data)
1501 {
1502         WERROR werr;
1503         struct regdb_delete_subkey_context *delete_ctx;
1504         struct regsubkey_ctr *subkeys;
1505         TALLOC_CTX *mem_ctx = talloc_stackframe();
1506
1507         delete_ctx = (struct regdb_delete_subkey_context *)private_data;
1508
1509         werr = regdb_delete_key_lists(db, delete_ctx->path);
1510         W_ERROR_NOT_OK_GOTO_DONE(werr);
1511
1512         if (delete_ctx->lazy) {
1513                 goto done;
1514         }
1515
1516         werr = regsubkey_ctr_init(mem_ctx, &subkeys);
1517         W_ERROR_NOT_OK_GOTO_DONE(werr);
1518
1519         werr = regdb_fetch_keys_internal(db, delete_ctx->key, subkeys);
1520         W_ERROR_NOT_OK_GOTO_DONE(werr);
1521
1522         werr = regsubkey_ctr_delkey(subkeys, delete_ctx->subkey);
1523         W_ERROR_NOT_OK_GOTO_DONE(werr);
1524
1525         werr = regdb_store_keys_internal2(db, delete_ctx->key, subkeys);
1526         if (!W_ERROR_IS_OK(werr)) {
1527                 DEBUG(0, (__location__ " failed to store new subkey_list for "
1528                          "parent key %s: %s\n", delete_ctx->key,
1529                          win_errstr(werr)));
1530         }
1531
1532 done:
1533         talloc_free(mem_ctx);
1534         return werror_to_ntstatus(werr);
1535 }
1536
1537 static WERROR regdb_delete_subkey(const char *key, const char *subkey, bool lazy)
1538 {
1539         WERROR werr;
1540         char *path;
1541         struct regdb_delete_subkey_context delete_ctx;
1542         TALLOC_CTX *mem_ctx = talloc_stackframe();
1543
1544         if (!regdb_key_exists(regdb, key)) {
1545                 werr = WERR_NOT_FOUND;
1546                 goto done;
1547         }
1548
1549         path = talloc_asprintf(mem_ctx, "%s\\%s", key, subkey);
1550         if (path == NULL) {
1551                 werr = WERR_NOMEM;
1552                 goto done;
1553         }
1554
1555         if (!regdb_key_exists(regdb, path)) {
1556                 werr = WERR_OK;
1557                 goto done;
1558         }
1559
1560         delete_ctx.key = key;
1561         delete_ctx.subkey = subkey;
1562         delete_ctx.path = path;
1563         delete_ctx.lazy = lazy;
1564
1565         werr = regdb_trans_do(regdb,
1566                               regdb_delete_subkey_action,
1567                               &delete_ctx);
1568
1569 done:
1570         talloc_free(mem_ctx);
1571         return werr;
1572 }
1573
1574 static TDB_DATA regdb_fetch_key_internal(struct db_context *db,
1575                                          TALLOC_CTX *mem_ctx, const char *key)
1576 {
1577         char *path = NULL;
1578         TDB_DATA data;
1579         NTSTATUS status;
1580
1581         path = normalize_reg_path(mem_ctx, key);
1582         if (!path) {
1583                 return make_tdb_data(NULL, 0);
1584         }
1585
1586         status = dbwrap_fetch_bystring(db, mem_ctx, path, &data);
1587         if (!NT_STATUS_IS_OK(status)) {
1588                 data = tdb_null;
1589         }
1590
1591         TALLOC_FREE(path);
1592         return data;
1593 }
1594
1595
1596 /**
1597  * Check for the existence of a key.
1598  *
1599  * Existence of a key is authoritatively defined by
1600  * the existence of the record that contains the list
1601  * of its subkeys.
1602  *
1603  * Return false, if the record does not match the correct
1604  * structure of an initial 4-byte counter and then a
1605  * list of the corresponding number of zero-terminated
1606  * strings.
1607  */
1608 static bool regdb_key_exists(struct db_context *db, const char *key)
1609 {
1610         TALLOC_CTX *mem_ctx = talloc_stackframe();
1611         TDB_DATA value;
1612         bool ret = false;
1613         char *path;
1614         uint32_t buflen;
1615         const char *buf;
1616         uint32_t num_items, i;
1617         int32_t len;
1618
1619         if (key == NULL) {
1620                 goto done;
1621         }
1622
1623         path = normalize_reg_path(mem_ctx, key);
1624         if (path == NULL) {
1625                 DEBUG(0, ("out of memory! (talloc failed)\n"));
1626                 goto done;
1627         }
1628
1629         if (*path == '\0') {
1630                 goto done;
1631         }
1632
1633         value = regdb_fetch_key_internal(db, mem_ctx, path);
1634         if (value.dptr == NULL) {
1635                 goto done;
1636         }
1637
1638         if (value.dsize == 0) {
1639                 DEBUG(10, ("regdb_key_exists: subkeylist-record for key "
1640                           "[%s] is empty: Could be a deleted record in a "
1641                           "clustered (ctdb) environment?\n",
1642                           path));
1643                 goto done;
1644         }
1645
1646         len = tdb_unpack(value.dptr, value.dsize, "d", &num_items);
1647         if (len == (int32_t)-1) {
1648                 DEBUG(1, ("regdb_key_exists: ERROR: subkeylist-record for key "
1649                           "[%s] is invalid: Could not parse initial 4-byte "
1650                           "counter. record data length is %u.\n",
1651                           path, (unsigned int)value.dsize));
1652                 goto done;
1653         }
1654
1655         /*
1656          * Note: the tdb_unpack check above implies that len <= value.dsize
1657          */
1658         buflen = value.dsize - len;
1659         buf = (const char *)value.dptr + len;
1660
1661         len = 0;
1662
1663         for (i = 0; i < num_items; i++) {
1664                 if (buflen == 0) {
1665                         break;
1666                 }
1667                 len = strnlen(buf, buflen) + 1;
1668                 if (buflen < len) {
1669                         DEBUG(1, ("regdb_key_exists: ERROR: subkeylist-record "
1670                                   "for key [%s] is corrupt: %u items expected, "
1671                                   "item number %u is not zero terminated.\n",
1672                                   path, num_items, i+1));
1673                         goto done;
1674                 }
1675
1676                 buf += len;
1677                 buflen -= len;
1678         }
1679
1680         if (buflen > 0) {
1681                 DEBUG(1, ("regdb_key_exists: ERROR: subkeylist-record for key "
1682                           "[%s] is corrupt: %u items expected and found, but "
1683                           "the record contains additional %u bytes\n",
1684                           path, num_items, buflen));
1685                 goto done;
1686         }
1687
1688         if (i < num_items) {
1689                 DEBUG(1, ("regdb_key_exists: ERROR: subkeylist-record for key "
1690                           "[%s] is corrupt: %u items expected, but only %u "
1691                           "items found.\n",
1692                           path, num_items, i+1));
1693                 goto done;
1694         }
1695
1696         ret = true;
1697
1698 done:
1699         TALLOC_FREE(mem_ctx);
1700         return ret;
1701 }
1702
1703
1704 /***********************************************************************
1705  Retrieve an array of strings containing subkeys.  Memory should be
1706  released by the caller.
1707  ***********************************************************************/
1708
1709 static WERROR regdb_fetch_keys_internal(struct db_context *db, const char *key,
1710                                         struct regsubkey_ctr *ctr)
1711 {
1712         WERROR werr;
1713         uint32_t num_items;
1714         uint8 *buf;
1715         uint32 buflen, len;
1716         int i;
1717         fstring subkeyname;
1718         TALLOC_CTX *frame = talloc_stackframe();
1719         TDB_DATA value;
1720         int seqnum[2], count;
1721
1722         DEBUG(11,("regdb_fetch_keys: Enter key => [%s]\n", key ? key : "NULL"));
1723
1724         if (!regdb_key_exists(db, key)) {
1725                 DEBUG(10, ("key [%s] not found\n", key));
1726                 werr = WERR_NOT_FOUND;
1727                 goto done;
1728         }
1729
1730         werr = regsubkey_ctr_reinit(ctr);
1731         W_ERROR_NOT_OK_GOTO_DONE(werr);
1732
1733         count = 0;
1734         ZERO_STRUCT(value);
1735         seqnum[0] = dbwrap_get_seqnum(db);
1736
1737         do {
1738                 count++;
1739                 TALLOC_FREE(value.dptr);
1740                 value = regdb_fetch_key_internal(db, frame, key);
1741                 seqnum[count % 2] = dbwrap_get_seqnum(db);
1742
1743         } while (seqnum[0] != seqnum[1]);
1744
1745         if (count > 1) {
1746                 DEBUG(5, ("regdb_fetch_keys_internal: it took %d attempts to "
1747                           "fetch key '%s' with constant seqnum\n",
1748                           count, key));
1749         }
1750
1751         werr = regsubkey_ctr_set_seqnum(ctr, seqnum[0]);
1752         if (!W_ERROR_IS_OK(werr)) {
1753                 goto done;
1754         }
1755
1756         if (value.dsize == 0 || value.dptr == NULL) {
1757                 DEBUG(10, ("regdb_fetch_keys: no subkeys found for key [%s]\n",
1758                            key));
1759                 goto done;
1760         }
1761
1762         buf = value.dptr;
1763         buflen = value.dsize;
1764         len = tdb_unpack( buf, buflen, "d", &num_items);
1765         if (len == (uint32_t)-1) {
1766                 werr = WERR_NOT_FOUND;
1767                 goto done;
1768         }
1769
1770         for (i=0; i<num_items; i++) {
1771                 len += tdb_unpack(buf+len, buflen-len, "f", subkeyname);
1772                 werr = regsubkey_ctr_addkey(ctr, subkeyname);
1773                 if (!W_ERROR_IS_OK(werr)) {
1774                         DEBUG(5, ("regdb_fetch_keys: regsubkey_ctr_addkey "
1775                                   "failed: %s\n", win_errstr(werr)));
1776                         num_items = 0;
1777                         goto done;
1778                 }
1779         }
1780
1781         DEBUG(11,("regdb_fetch_keys: Exit [%d] items\n", num_items));
1782
1783 done:
1784         TALLOC_FREE(frame);
1785         return werr;
1786 }
1787
1788 static int regdb_fetch_keys(const char *key, struct regsubkey_ctr *ctr)
1789 {
1790         WERROR werr;
1791
1792         werr = regdb_fetch_keys_internal(regdb, key, ctr);
1793         if (!W_ERROR_IS_OK(werr)) {
1794                 return -1;
1795         }
1796
1797         return regsubkey_ctr_numkeys(ctr);
1798 }
1799
1800 /****************************************************************************
1801  Unpack a list of registry values frem the TDB
1802  ***************************************************************************/
1803
1804 static int regdb_unpack_values(struct regval_ctr *values, uint8 *buf, int buflen)
1805 {
1806         int             len = 0;
1807         uint32          type;
1808         fstring valuename;
1809         uint32          size;
1810         uint8           *data_p;
1811         uint32          num_values = 0;
1812         int             i;
1813
1814         /* loop and unpack the rest of the registry values */
1815
1816         len += tdb_unpack(buf+len, buflen-len, "d", &num_values);
1817
1818         for ( i=0; i<num_values; i++ ) {
1819                 /* unpack the next regval */
1820
1821                 type = REG_NONE;
1822                 size = 0;
1823                 data_p = NULL;
1824                 valuename[0] = '\0';
1825                 len += tdb_unpack(buf+len, buflen-len, "fdB",
1826                                   valuename,
1827                                   &type,
1828                                   &size,
1829                                   &data_p);
1830
1831                 regval_ctr_addvalue(values, valuename, type,
1832                                 (uint8_t *)data_p, size);
1833                 SAFE_FREE(data_p); /* 'B' option to tdb_unpack does a malloc() */
1834
1835                 DEBUG(10, ("regdb_unpack_values: value[%d]: name[%s] len[%d]\n",
1836                            i, valuename, size));
1837         }
1838
1839         return len;
1840 }
1841
1842 /****************************************************************************
1843  Pack all values in all printer keys
1844  ***************************************************************************/
1845
1846 static int regdb_pack_values(struct regval_ctr *values, uint8 *buf, int buflen)
1847 {
1848         int             len = 0;
1849         int             i;
1850         struct regval_blob      *val;
1851         int             num_values;
1852
1853         if ( !values )
1854                 return 0;
1855
1856         num_values = regval_ctr_numvals( values );
1857
1858         /* pack the number of values first */
1859
1860         len += tdb_pack( buf+len, buflen-len, "d", num_values );
1861
1862         /* loop over all values */
1863
1864         for ( i=0; i<num_values; i++ ) {
1865                 val = regval_ctr_specific_value( values, i );
1866                 len += tdb_pack(buf+len, buflen-len, "fdB",
1867                                 regval_name(val),
1868                                 regval_type(val),
1869                                 regval_size(val),
1870                                 regval_data_p(val) );
1871         }
1872
1873         return len;
1874 }
1875
1876 /***********************************************************************
1877  Retrieve an array of strings containing subkeys.  Memory should be
1878  released by the caller.
1879  ***********************************************************************/
1880
1881 static int regdb_fetch_values_internal(struct db_context *db, const char* key,
1882                                        struct regval_ctr *values)
1883 {
1884         char *keystr = NULL;
1885         TALLOC_CTX *ctx = talloc_stackframe();
1886         int ret = 0;
1887         TDB_DATA value;
1888         WERROR werr;
1889         int seqnum[2], count;
1890
1891         DEBUG(10,("regdb_fetch_values: Looking for values of key [%s]\n", key));
1892
1893         if (!regdb_key_exists(db, key)) {
1894                 DEBUG(10, ("regb_fetch_values: key [%s] does not exist\n",
1895                            key));
1896                 ret = -1;
1897                 goto done;
1898         }
1899
1900         keystr = talloc_asprintf(ctx, "%s\\%s", REG_VALUE_PREFIX, key);
1901         if (!keystr) {
1902                 goto done;
1903         }
1904
1905         ZERO_STRUCT(value);
1906         count = 0;
1907         seqnum[0] = dbwrap_get_seqnum(db);
1908
1909         do {
1910                 count++;
1911                 TALLOC_FREE(value.dptr);
1912                 value = regdb_fetch_key_internal(db, ctx, keystr);
1913                 seqnum[count % 2] = dbwrap_get_seqnum(db);
1914         } while (seqnum[0] != seqnum[1]);
1915
1916         if (count > 1) {
1917                 DEBUG(5, ("regdb_fetch_values_internal: it took %d attempts "
1918                           "to fetch key '%s' with constant seqnum\n",
1919                           count, key));
1920         }
1921
1922         werr = regval_ctr_set_seqnum(values, seqnum[0]);
1923         if (!W_ERROR_IS_OK(werr)) {
1924                 goto done;
1925         }
1926
1927         if (!value.dptr) {
1928                 /* all keys have zero values by default */
1929                 goto done;
1930         }
1931
1932         regdb_unpack_values(values, value.dptr, value.dsize);
1933         ret = regval_ctr_numvals(values);
1934
1935 done:
1936         TALLOC_FREE(ctx);
1937         return ret;
1938 }
1939
1940 static int regdb_fetch_values(const char* key, struct regval_ctr *values)
1941 {
1942         return regdb_fetch_values_internal(regdb, key, values);
1943 }
1944
1945 static NTSTATUS regdb_store_values_internal(struct db_context *db,
1946                                             const char *key,
1947                                             struct regval_ctr *values)
1948 {
1949         TDB_DATA old_data, data;
1950         char *keystr = NULL;
1951         TALLOC_CTX *ctx = talloc_stackframe();
1952         int len;
1953         NTSTATUS status;
1954         WERROR werr;
1955
1956         DEBUG(10,("regdb_store_values: Looking for values of key [%s]\n", key));
1957
1958         if (!regdb_key_exists(db, key)) {
1959                 status = NT_STATUS_NOT_FOUND;
1960                 goto done;
1961         }
1962
1963         if (regval_ctr_numvals(values) == 0) {
1964                 werr = regdb_delete_values(db, key);
1965                 if (!W_ERROR_IS_OK(werr)) {
1966                         status = werror_to_ntstatus(werr);
1967                         goto done;
1968                 }
1969
1970                 /*
1971                  * update the seqnum in the cache to prevent the next read
1972                  * from going to disk
1973                  */
1974                 werr = regval_ctr_set_seqnum(values, dbwrap_get_seqnum(db));
1975                 status = werror_to_ntstatus(werr);
1976                 goto done;
1977         }
1978
1979         ZERO_STRUCT(data);
1980
1981         len = regdb_pack_values(values, data.dptr, data.dsize);
1982         if (len <= 0) {
1983                 DEBUG(0,("regdb_store_values: unable to pack values. len <= 0\n"));
1984                 status = NT_STATUS_UNSUCCESSFUL;
1985                 goto done;
1986         }
1987
1988         data.dptr = talloc_array(ctx, uint8, len);
1989         data.dsize = len;
1990
1991         len = regdb_pack_values(values, data.dptr, data.dsize);
1992
1993         SMB_ASSERT( len == data.dsize );
1994
1995         keystr = talloc_asprintf(ctx, "%s\\%s", REG_VALUE_PREFIX, key );
1996         if (!keystr) {
1997                 status = NT_STATUS_NO_MEMORY;
1998                 goto done;
1999         }
2000         keystr = normalize_reg_path(ctx, keystr);
2001         if (!keystr) {
2002                 status = NT_STATUS_NO_MEMORY;
2003                 goto done;
2004         }
2005
2006         status = dbwrap_fetch_bystring(db, ctx, keystr, &old_data);
2007
2008         if (NT_STATUS_IS_OK(status)
2009             && (old_data.dptr != NULL)
2010             && (old_data.dsize == data.dsize)
2011             && (memcmp(old_data.dptr, data.dptr, data.dsize) == 0))
2012         {
2013                 status = NT_STATUS_OK;
2014                 goto done;
2015         }
2016
2017         status = dbwrap_trans_store_bystring(db, keystr, data, TDB_REPLACE);
2018         if (!NT_STATUS_IS_OK(status)) {
2019                 DEBUG(0, ("regdb_store_values_internal: error storing: %s\n", nt_errstr(status)));
2020                 goto done;
2021         }
2022
2023         /*
2024          * update the seqnum in the cache to prevent the next read
2025          * from going to disk
2026          */
2027         werr = regval_ctr_set_seqnum(values, dbwrap_get_seqnum(db));
2028         status = werror_to_ntstatus(werr);
2029
2030 done:
2031         TALLOC_FREE(ctx);
2032         return status;
2033 }
2034
2035 struct regdb_store_values_ctx {
2036         const char *key;
2037         struct regval_ctr *values;
2038 };
2039
2040 static NTSTATUS regdb_store_values_action(struct db_context *db,
2041                                           void *private_data)
2042 {
2043         NTSTATUS status;
2044         struct regdb_store_values_ctx *ctx =
2045                 (struct regdb_store_values_ctx *)private_data;
2046
2047         status = regdb_store_values_internal(db, ctx->key, ctx->values);
2048
2049         return status;
2050 }
2051
2052 static bool regdb_store_values(const char *key, struct regval_ctr *values)
2053 {
2054         WERROR werr;
2055         struct regdb_store_values_ctx ctx;
2056
2057         ctx.key = key;
2058         ctx.values = values;
2059
2060         werr = regdb_trans_do(regdb, regdb_store_values_action, &ctx);
2061
2062         return W_ERROR_IS_OK(werr);
2063 }
2064
2065 static WERROR regdb_get_secdesc(TALLOC_CTX *mem_ctx, const char *key,
2066                                 struct security_descriptor **psecdesc)
2067 {
2068         char *tdbkey;
2069         TDB_DATA data;
2070         NTSTATUS status;
2071         TALLOC_CTX *tmp_ctx = talloc_stackframe();
2072         WERROR err = WERR_OK;
2073
2074         DEBUG(10, ("regdb_get_secdesc: Getting secdesc of key [%s]\n", key));
2075
2076         if (!regdb_key_exists(regdb, key)) {
2077                 err = WERR_BADFILE;
2078                 goto done;
2079         }
2080
2081         tdbkey = talloc_asprintf(tmp_ctx, "%s\\%s", REG_SECDESC_PREFIX, key);
2082         if (tdbkey == NULL) {
2083                 err = WERR_NOMEM;
2084                 goto done;
2085         }
2086
2087         tdbkey = normalize_reg_path(tmp_ctx, tdbkey);
2088         if (tdbkey == NULL) {
2089                 err = WERR_NOMEM;
2090                 goto done;
2091         }
2092
2093         status = dbwrap_fetch_bystring(regdb, tmp_ctx, tdbkey, &data);
2094         if (!NT_STATUS_IS_OK(status)) {
2095                 err = WERR_BADFILE;
2096                 goto done;
2097         }
2098
2099         status = unmarshall_sec_desc(mem_ctx, (uint8 *)data.dptr, data.dsize,
2100                                      psecdesc);
2101
2102         if (NT_STATUS_EQUAL(status, NT_STATUS_NO_MEMORY)) {
2103                 err = WERR_NOMEM;
2104         } else if (!NT_STATUS_IS_OK(status)) {
2105                 err = WERR_REG_CORRUPT;
2106         }
2107
2108 done:
2109         TALLOC_FREE(tmp_ctx);
2110         return err;
2111 }
2112
2113 struct regdb_set_secdesc_ctx {
2114         const char *key;
2115         struct security_descriptor *secdesc;
2116 };
2117
2118 static NTSTATUS regdb_set_secdesc_action(struct db_context *db,
2119                                          void *private_data)
2120 {
2121         char *tdbkey;
2122         NTSTATUS status;
2123         TDB_DATA tdbdata;
2124         struct regdb_set_secdesc_ctx *ctx =
2125                 (struct regdb_set_secdesc_ctx *)private_data;
2126         TALLOC_CTX *frame = talloc_stackframe();
2127
2128         tdbkey = talloc_asprintf(frame, "%s\\%s", REG_SECDESC_PREFIX, ctx->key);
2129         if (tdbkey == NULL) {
2130                 status = NT_STATUS_NO_MEMORY;
2131                 goto done;
2132         }
2133
2134         tdbkey = normalize_reg_path(frame, tdbkey);
2135         if (tdbkey == NULL) {
2136                 status = NT_STATUS_NO_MEMORY;
2137                 goto done;
2138         }
2139
2140         if (ctx->secdesc == NULL) {
2141                 /* assuming a delete */
2142                 status = dbwrap_delete_bystring(db, tdbkey);
2143                 goto done;
2144         }
2145
2146         status = marshall_sec_desc(frame, ctx->secdesc, &tdbdata.dptr,
2147                                    &tdbdata.dsize);
2148         if (!NT_STATUS_IS_OK(status)) {
2149                 goto done;
2150         }
2151
2152         status = dbwrap_store_bystring(db, tdbkey, tdbdata, 0);
2153
2154 done:
2155         TALLOC_FREE(frame);
2156         return status;
2157 }
2158
2159 static WERROR regdb_set_secdesc(const char *key,
2160                                 struct security_descriptor *secdesc)
2161 {
2162         WERROR err;
2163         struct regdb_set_secdesc_ctx ctx;
2164
2165         if (!regdb_key_exists(regdb, key)) {
2166                 err = WERR_BADFILE;
2167                 goto done;
2168         }
2169
2170         ctx.key = key;
2171         ctx.secdesc = secdesc;
2172
2173         err = regdb_trans_do(regdb, regdb_set_secdesc_action, &ctx);
2174
2175 done:
2176         return err;
2177 }
2178
2179 static bool regdb_subkeys_need_update(struct regsubkey_ctr *subkeys)
2180 {
2181         return (regdb_get_seqnum() != regsubkey_ctr_get_seqnum(subkeys));
2182 }
2183
2184 static bool regdb_values_need_update(struct regval_ctr *values)
2185 {
2186         return (regdb_get_seqnum() != regval_ctr_get_seqnum(values));
2187 }
2188
2189 /*
2190  * Table of function pointers for default access
2191  */
2192
2193 struct registry_ops regdb_ops = {
2194         .fetch_subkeys = regdb_fetch_keys,
2195         .fetch_values = regdb_fetch_values,
2196         .store_subkeys = regdb_store_keys,
2197         .store_values = regdb_store_values,
2198         .create_subkey = regdb_create_subkey,
2199         .delete_subkey = regdb_delete_subkey,
2200         .get_secdesc = regdb_get_secdesc,
2201         .set_secdesc = regdb_set_secdesc,
2202         .subkeys_need_update = regdb_subkeys_need_update,
2203         .values_need_update = regdb_values_need_update
2204 };