source3/utils/net_registry_check.c

   1 /*
   2  * Samba Unix/Linux SMB client library
   3  *
   4  * Copyright (C) Gregor Beck 2011
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 /**
  21  * @brief  Check the registry database.
  22  * @author Gregor Beck <gb@sernet.de>
  23  * @date   Mar 2011
  24  */
  25
  26 #include "net_registry_check.h"
  27
  28 #include "includes.h"
  29 #include "system/filesys.h"
  30 #include "lib/dbwrap/dbwrap.h"
  31 #include "lib/dbwrap/dbwrap_open.h"
  32 #include "lib/dbwrap/dbwrap_rbt.h"
  33 #include "net.h"
  34 #include "libcli/security/dom_sid.h"
  35 #include "libcli/security/secdesc.h"
  36 #include "cbuf.h"
  37 #include "srprs.h"
  38 #include <termios.h>
  39 #include "util_tdb.h"
  40 #include "registry/reg_db.h"
  41 #include "libcli/registry/util_reg.h"
  42 #include "registry/reg_parse_internal.h"
  43 #include "interact.h"
  44
  45 /*
  46   check tree:
  47   + every key has a subkeylist
  48   + every key is referenced by the subkeylist of its parent
  49   check path:
  50   + starts with valid hive
  51   + UTF-8 (option to convert ???)
  52   + only uppercase
  53   + separator ???
  54   check value:
  55   + REG_DWORD has size 4
  56   + REG_QWORD has size 8
  57   + STRINGS are zero terminated UTF-16
  58 */
  59
  60 struct regval {
  61         char *name;
  62         uint32_t type;
  63         DATA_BLOB data;
  64 };
  65
  66 struct regkey {
  67         char *name;
  68         char *path;
  69         bool has_subkeylist;
  70         bool needs_update;
  71         struct regkey *parent;
  72         size_t nsubkeys;
  73         struct regkey **subkeys;
  74         size_t nvalues;
  75         struct regval **values;
  76         struct security_descriptor *sd;
  77 };
  78
  79 struct check_ctx {
  80         char *fname;
  81         struct check_options opt;
  82
  83         uint32_t version;
  84         char sep;
  85         struct db_context *idb;
  86         struct db_context *odb;
  87
  88         struct regkey *root; /*dummy key to hold all basekeys*/
  89         struct db_context *reg;
  90         struct db_context *del;
  91
  92         bool transaction;
  93         char auto_action;
  94         char default_action;
  95 };
  96
  97 static void* talloc_array_append(void *mem_ctx, void* array[], void *ptr)
  98 {
  99         size_t size = array ? talloc_array_length(array) : 1;
 100         void **tmp = talloc_realloc(mem_ctx, array, void*, size + 1);
 101         if (tmp == NULL) {
 102                 talloc_free(array);
 103                 return NULL;
 104         }
 105         tmp[size-1] = ptr;
 106         tmp[size] = NULL;
 107         return tmp;
 108 }
 109
 110 static void regkey_add_subkey(struct regkey *key, struct regkey *subkey)
 111 {
 112         key->subkeys = (struct regkey**)
 113                 talloc_array_append(key, (void**)key->subkeys, subkey);
 114         if (key->subkeys != NULL) {
 115                 key->nsubkeys++;
 116         }
 117 }
 118
 119 static struct regval* regval_copy(TALLOC_CTX *mem_ctx, const struct regval *val)
 120 {
 121         struct regval *ret = talloc_zero(mem_ctx, struct regval);
 122         if (ret == NULL) {
 123                 goto fail;
 124         }
 125
 126         ret->name = talloc_strdup(ret, val->name);
 127         if (ret->name == NULL) {
 128                 goto fail;
 129         }
 130
 131         ret->data = data_blob_dup_talloc(ret, val->data);
 132         if (ret->data.data == NULL) {
 133                 goto fail;
 134         }
 135
 136         ret->type = val->type;
 137
 138         return ret;
 139 fail:
 140         talloc_free(ret);
 141         return NULL;
 142 }
 143
 144 static void regkey_add_regval(struct regkey *key, struct regval *val)
 145 {
 146         key->values = (struct regval**)
 147                 talloc_array_append(key, (void**)key->values, val);
 148         if (key->values != NULL) {
 149                 key->nvalues++;
 150         }
 151 }
 152
 153 static bool tdb_data_read_uint32(TDB_DATA *buf, uint32_t *result)
 154 {
 155         const size_t len = sizeof(uint32_t);
 156         if (buf->dsize >= len) {
 157                 *result = IVAL(buf->dptr, 0);
 158                 buf->dptr += len;
 159                 buf->dsize -= len;
 160                 return true;
 161         }
 162         return false;
 163 }
 164
 165 static bool tdb_data_read_cstr(TDB_DATA *buf, char **result)
 166 {
 167         const size_t len = strnlen((char*)buf->dptr, buf->dsize) + 1;
 168         if (buf->dsize >= len) {
 169                 *result = (char*)buf->dptr;
 170                 buf->dptr += len;
 171                 buf->dsize -= len;
 172                 return true;
 173         }
 174         return false;
 175 }
 176
 177 static bool tdb_data_read_blob(TDB_DATA *buf, DATA_BLOB *result)
 178 {
 179         TDB_DATA tmp = *buf;
 180         uint32_t len;
 181         if (!tdb_data_read_uint32(&tmp, &len)) {
 182                 return false;
 183         }
 184         if (tmp.dsize >= len) {
 185                 *buf = tmp;
 186                 result->data   = tmp.dptr;
 187                 result->length = len;
 188                 buf->dptr += len;
 189                 buf->dsize -= len;
 190                 return true;
 191         }
 192         return false;
 193 }
 194
 195 static bool tdb_data_read_regval(TDB_DATA *buf, struct regval *result)
 196 {
 197         TDB_DATA tmp = *buf;
 198         struct regval value;
 199         if (!tdb_data_read_cstr(&tmp, &value.name)
 200             || !tdb_data_read_uint32(&tmp, &value.type)
 201             || !tdb_data_read_blob(&tmp, &value.data))
 202         {
 203                 return false;
 204         }
 205         *buf = tmp;
 206         *result = value;
 207         return true;
 208 }
 209
 210 static bool tdb_data_is_cstr(TDB_DATA d) {
 211         if (tdb_data_is_empty(d) || (d.dptr[d.dsize-1] != '\0')) {
 212                 return false;
 213         }
 214         return strlen((char *)d.dptr) == d.dsize-1;
 215 }
 216
 217 static char* tdb_data_print(TALLOC_CTX *mem_ctx, TDB_DATA d)
 218 {
 219         if (!tdb_data_is_empty(d)) {
 220                 char *ret = NULL;
 221                 cbuf *ost = cbuf_new(mem_ctx);
 222                 int len = cbuf_print_quoted(ost, (const char*)d.dptr, d.dsize);
 223                 if (len != -1) {
 224                         cbuf_swapptr(ost, &ret, 0);
 225                         talloc_steal(mem_ctx, ret);
 226                 }
 227                 talloc_free(ost);
 228                 return ret;
 229         }
 230         return talloc_strdup(mem_ctx, "<NULL>");
 231 }
 232
 233
 234 static TDB_DATA cbuf_make_tdb_data(cbuf *b)
 235 {
 236         return make_tdb_data((void*)cbuf_gets(b, 0), cbuf_getpos(b));
 237 }
 238
 239 static void remove_all(char *str, char c)
 240 {
 241         char *out=str;
 242         while (*str) {
 243                 if (*str != c) {
 244                         *out = *str;
 245                         out++;
 246                 }
 247                 str++;
 248         }
 249         *out = '\0';
 250 }
 251
 252 static char* parent_path(const char *path, char sep)
 253 {
 254         const char *p = strrchr(path, sep);
 255         return p ? talloc_strndup(talloc_tos(), path, p-path) : NULL;
 256 }
 257
 258 /* return the regkey corresponding to path, create if not yet existing */
 259 static struct regkey*
 260 check_ctx_lookup_key(struct check_ctx *ctx, const char *path) {
 261         struct regkey *ret = NULL;
 262         NTSTATUS status;
 263         TDB_DATA val = tdb_null;
 264
 265         if ( path == NULL) {
 266                 return ctx->root;
 267         }
 268
 269         status = dbwrap_fetch(ctx->reg, ctx, string_term_tdb_data(path), &val);
 270         if (NT_STATUS_IS_OK(status)) {
 271                 if (ctx->opt.verbose) {
 272                         printf("Open: %s\n", path);
 273                 }
 274                 ret = *(struct regkey**)val.dptr;
 275         } else if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
 276                 /* not yet existing, create */
 277                 char *pp;
 278                 if (ctx->opt.verbose) {
 279                         printf("New: %s\n", path);
 280                 }
 281                 ret = talloc_zero(ctx, struct regkey);
 282                 if (ret == NULL) {
 283                         DEBUG(0, ("Out of memory!\n"));
 284                         goto done;
 285                 }
 286                 ret->path = talloc_strdup(ret, path);
 287
 288                 pp = parent_path(path, ctx->sep);
 289                 ret->parent = check_ctx_lookup_key(ctx, pp);
 290                 regkey_add_subkey(ret->parent, ret);
 291                 TALLOC_FREE(pp);
 292
 293                 /* the dummy root key has no subkeylist so set the name */
 294                 if (ret->parent == ctx->root) {
 295                         ret->name = talloc_strdup(ret, path);
 296                 }
 297
 298                 dbwrap_store(ctx->reg, string_term_tdb_data(path),
 299                              make_tdb_data((void*)&ret, sizeof(ret)), 0);
 300         } else {
 301                 DEBUG(0, ("lookup key: failed to fetch %s: %s\n", path,
 302                           nt_errstr(status)));
 303         }
 304 done:
 305         talloc_free(val.dptr);
 306         return ret;
 307 }
 308
 309 static struct check_ctx* check_ctx_create(TALLOC_CTX *mem_ctx, const char *db,
 310                                           const struct check_options *opt)
 311 {
 312         struct check_ctx *ctx = talloc_zero(mem_ctx, struct check_ctx);
 313
 314         ctx->opt = *opt;
 315         ctx->reg = db_open_rbt(ctx);
 316         ctx->del = db_open_rbt(ctx);
 317         ctx->root = talloc_zero(ctx, struct regkey);
 318         ctx->fname = talloc_strdup(ctx, db);
 319
 320         if (opt->automatic && (opt->output == NULL)) {
 321                 ctx->opt.repair = true;
 322                 ctx->opt.output = ctx->fname;
 323         }
 324
 325         if (opt->repair) {
 326                 if (opt->output) {
 327                         d_fprintf(stderr, "You can not specify --output "
 328                                   "with --repair\n");
 329                         goto fail;
 330                 } else {
 331                         ctx->opt.output = ctx->fname;
 332                 }
 333         }
 334
 335         ctx->default_action = 'r';
 336         return ctx;
 337 fail:
 338         talloc_free(ctx);
 339         return NULL;
 340 }
 341
 342 static bool check_ctx_open_output(struct check_ctx *ctx)
 343 {
 344         int oflags = O_RDWR | O_CREAT ;
 345
 346         if (ctx->opt.output == NULL) {
 347                 return true;
 348         }
 349
 350         if (!ctx->opt.repair) {
 351                 if (!ctx->opt.wipe) {
 352                         oflags |= O_EXCL;
 353                 }
 354                 ctx->opt.wipe = true;
 355         }
 356
 357         ctx->odb = db_open(ctx, ctx->opt.output, 0, TDB_DEFAULT, oflags, 0644,
 358                            DBWRAP_LOCK_ORDER_1);
 359         if (ctx->odb == NULL) {
 360                 d_fprintf(stderr,
 361                           _("Could not open db (%s) for writing: %s\n"),
 362                           ctx->opt.output, strerror(errno));
 363                 return false;
 364         }
 365         return true;
 366 }
 367
 368
 369 static bool check_ctx_open_input(struct check_ctx *ctx) {
 370         ctx->idb = db_open(ctx, ctx->fname, 0, TDB_DEFAULT, O_RDONLY, 0,
 371                            DBWRAP_LOCK_ORDER_1);
 372         if (ctx->idb == NULL) {
 373                 d_fprintf(stderr,
 374                           _("Could not open db (%s) for reading: %s\n"),
 375                           ctx->fname, strerror(errno));
 376                 return false;
 377         }
 378         return true;
 379 }
 380
 381 static bool check_ctx_transaction_start(struct check_ctx *ctx) {
 382         if (ctx->odb == NULL) {
 383                 return true;
 384         }
 385         if (dbwrap_transaction_start(ctx->odb) != 0) {
 386                 DEBUG(0, ("transaction_start failed\n"));
 387                 return false;
 388         }
 389         ctx->transaction = true;
 390         return true;
 391 }
 392
 393 static void check_ctx_transaction_stop(struct check_ctx *ctx, bool ok) {
 394         if (!ctx->transaction) {
 395                 return;
 396         }
 397         if (!ctx->opt.test && ok) {
 398                 d_printf("Commiting changes\n");
 399                 if (dbwrap_transaction_commit(ctx->odb) != 0) {
 400                         DEBUG(0, ("transaction_commit failed\n"));
 401                 }
 402         } else {
 403                 d_printf("Discarding changes\n");
 404                 dbwrap_transaction_cancel(ctx->odb);
 405         }
 406 }
 407
 408 static bool read_info(struct check_ctx *ctx, const char *key, TDB_DATA val)
 409 {
 410         if (val.dsize==sizeof(uint32_t) && strcmp(key, "version")==0) {
 411                 uint32_t v = IVAL(val.dptr, 0);
 412                 printf("INFO: %s = %d\n", key, v);
 413                 return true;
 414         }
 415         printf("INFO: %s = <invalid>\n", key);
 416         return false;
 417 }
 418
 419 static bool is_all_upper(const char *str) {
 420         bool ret;
 421         char *tmp = talloc_strdup(talloc_tos(), str);
 422         strupper_m(tmp);
 423         ret = (strcmp(tmp, str) == 0);
 424         talloc_free(tmp);
 425         return ret;
 426 }
 427
 428 static void move_to_back(struct regkey *key, struct regkey *subkey)
 429 {
 430         struct regkey **ptr;
 431         size_t nidx;
 432
 433         DEBUG(5, ("Move to back subkey \"%s\" of \"%s\"\n",
 434                   subkey->path, key->path));
 435
 436         for (ptr=key->subkeys; *ptr != subkey; ptr++)
 437                 ;
 438
 439         nidx = ptr + 1 - key->subkeys;
 440         memmove(ptr, ptr+1, (key->nsubkeys - nidx) * sizeof(*ptr));
 441
 442         key->subkeys[key->nsubkeys-1] = subkey;
 443 }
 444
 445 static void set_subkey_name(struct check_ctx *ctx, struct regkey *key,
 446                             const char *name, int nlen)
 447 {
 448         char *path = key->path;
 449         TALLOC_CTX *mem_ctx = talloc_new(talloc_tos());
 450         char *p;
 451         struct regkey *subkey;
 452         char *nname = talloc_strndup(mem_ctx, name, nlen);
 453         remove_all(nname, ctx->sep);
 454
 455         if (strncmp(name, nname, nlen) != 0) {
 456                 /* XXX interaction: delete/edit */
 457                 printf("Warning: invalid name: \"%s\" replace with \"%s\"\n",
 458                        name, nname);
 459                 key->needs_update = true;
 460         }
 461         p = talloc_asprintf_strupper_m(mem_ctx, "%s%c%s",
 462                                        path, ctx->sep, nname);
 463         subkey = check_ctx_lookup_key(ctx, p);
 464         if (subkey->name) {
 465                 bool do_replace = false;
 466
 467                 if (strcmp(subkey->name, nname) != 0) {
 468                         int action;
 469                         char default_action;
 470
 471                         if (is_all_upper(nname)) {
 472                                 default_action = 'o';
 473                         } else {
 474                                 default_action = 'n';
 475                         }
 476
 477                         printf("Conflicting subkey names of [%s]: "
 478                                "old: \"%s\", new: \"%s\"\n",
 479                                key->path, subkey->name, nname);
 480
 481                         if (ctx->opt.output == NULL || ctx->opt.automatic) {
 482                                 action = default_action;
 483                         } else {
 484                                 do {
 485                                         action = interact_prompt(
 486                                                 "choose spelling [o]ld, [n]ew,"
 487                                                 "or [e]dit", "one",
 488                                                 default_action);
 489                                         if (action == 'e') {
 490                                                 printf("Sorry, edit is not yet "
 491                                                        "implemented here...\n");
 492                                         }
 493                                 } while (action == 'e');
 494                         }
 495
 496                         if (action == 'n') {
 497                                 do_replace = true;
 498                         }
 499                 }
 500
 501                 if (do_replace) {
 502                         if (ctx->opt.verbose) {
 503                                 printf("Replacing name: %s: \"%s\""
 504                                        " -> \"%s\"\n", path,
 505                                        subkey->name, nname);
 506                         }
 507                         TALLOC_FREE(subkey->name);
 508                         subkey->name = talloc_steal(subkey, nname);
 509                         key->needs_update = true;
 510                 }
 511         } else {
 512                 if (ctx->opt.verbose) {
 513                         printf("Set name: %s: \"%s\"\n", path, nname);
 514                 }
 515                 subkey->name = talloc_steal(subkey, nname);
 516         }
 517
 518         move_to_back(key, subkey);
 519         TALLOC_FREE(mem_ctx);
 520 }
 521
 522 static void
 523 read_subkeys(struct check_ctx *ctx, const char *path, TDB_DATA val, bool update)
 524 {
 525         uint32_t num_items, found_items = 0;
 526         char *subkey;
 527         struct regkey *key = check_ctx_lookup_key(ctx, path);
 528
 529         key->needs_update |= update;
 530
 531         /* printf("SUBKEYS: %s\n", path); */
 532         if (key->has_subkeylist) {
 533                 printf("Duplicate subkeylist \"%s\"\n",
 534                        path);
 535                 found_items = key->nsubkeys;
 536         }
 537
 538         /* exists as defined by regdb_key_exists() */
 539         key->has_subkeylist = true;
 540
 541         /* name is set if a key is referenced by the */
 542         /* subkeylist of its parent. */
 543
 544         if (!tdb_data_read_uint32(&val, &num_items) ) {
 545                 printf("Invalid subkeylist: \"%s\"\n", path);
 546                 return;
 547         }
 548
 549         while (tdb_data_read_cstr(&val, &subkey)) {
 550                 /* printf(" SUBKEY: %s\n", subkey); */
 551                 set_subkey_name(ctx, key, subkey, strlen(subkey));
 552                 found_items++;
 553         }
 554
 555         if (val.dsize != 0) {
 556                 printf("Subkeylist of \"%s\": trailing: \"%.*s\"\n",
 557                        path, (int)val.dsize, val.dptr);
 558                 /* ask: best effort, delete or edit?*/
 559                 set_subkey_name(ctx, key, (char*)val.dptr, val.dsize);
 560                 found_items++;
 561                 key->needs_update = true;
 562         }
 563
 564         if (num_items != found_items) {
 565                 printf("Subkeylist of \"%s\": invalid number of subkeys, "
 566                        "expected: %d got: %d\n", path, num_items, found_items);
 567                 key->needs_update = true;
 568         }
 569
 570 }
 571
 572 static void read_values(struct check_ctx *ctx, const char *path, TDB_DATA val)
 573 {
 574         struct regkey *key = check_ctx_lookup_key(ctx, path);
 575         uint32_t num_items, found_items;
 576         struct regval value;
 577
 578         /* printf("VALUES: %s\n", path); */
 579
 580         if (!tdb_data_read_uint32(&val, &num_items) ) {
 581                 printf("Invalid valuelist: \"%s\"\n", path);
 582                 return;
 583         }
 584
 585         found_items=0;
 586         while (tdb_data_read_regval(&val, &value)) {
 587                 /* printf(" VAL: %s type: %s(%d) length: %d\n", value.name, */
 588                 /*        str_regtype(value.type), value.type, */
 589                 /*        (int)value.data.length); */
 590                 regkey_add_regval(key, regval_copy(key, &value));
 591                 found_items++;
 592         }
 593
 594         if (num_items != found_items) {
 595                 printf("Valuelist of \"%s\": invalid number of values, "
 596                        "expected: %d got: %d\n", path, num_items, found_items);
 597                 key->needs_update = true;
 598         }
 599
 600         if (val.dsize != 0) {
 601                 printf("Valuelist of \"%s\": trailing: \"%*s\"\n", path,
 602                        (int)val.dsize, val.dptr);
 603                 key->needs_update = true;
 604                 /* XXX best effort ??? */
 605                 /* ZERO_STRUCT(value); */
 606                 /* if (tdb_data_read_cstr(&val, &value.name) */
 607                 /*     && tdb_data_read_uint32(&val, &value.type)) */
 608                 /* { */
 609                 /*      uint32_t len = -1; */
 610                 /*      tdb_data_read_uint32(&val, &len); */
 611                 /*      ... */
 612                 /*      found_items ++; */
 613                 /*      regkey_add_regval(key, regval_copy(key, value)); */
 614                 /* } */
 615         }
 616         if (found_items == 0) {
 617                 printf("Valuelist of \"%s\" empty\n", path);
 618                 key->needs_update = true;
 619         }
 620 }
 621
 622 static bool read_sorted(struct check_ctx *ctx, const char *path, TDB_DATA val)
 623 {
 624         if (ctx->version >= 3) {
 625                 return false;
 626         }
 627
 628         if ((val.dptr == NULL) || (val.dsize<4)) {
 629                 return false;
 630         }
 631
 632         /* ToDo: check */
 633         /* struct regkey *key = check_ctx_lookup_key(ctx, path); */
 634         /* printf("SORTED: %s\n", path); */
 635         return true;
 636 }
 637
 638 static bool read_sd(struct check_ctx *ctx, const char *path, TDB_DATA val)
 639 {
 640         NTSTATUS status;
 641         struct regkey *key = check_ctx_lookup_key(ctx, path);
 642         /* printf("SD: %s\n", path); */
 643
 644         status = unmarshall_sec_desc(key, val.dptr, val.dsize, &key->sd);
 645         if (!NT_STATUS_IS_OK(status)) {
 646                 DEBUG(0, ("Failed to read SD of %s: %s\n",
 647                           path, nt_errstr(status)));
 648         }
 649         return true;
 650 }
 651
 652 static bool srprs_path(const char **ptr, const char* prefix, char sep,
 653                        const char **ppath)
 654 {
 655         const char *path, *pos = *ptr;
 656         if (prefix != NULL) {
 657                 if (!srprs_str(&pos, prefix, -1) || !srprs_char(&pos, sep) ) {
 658                         return false;
 659                 }
 660         }
 661         path = pos;
 662         if ( !srprs_hive(&pos, NULL) ) {
 663                 return false;
 664         }
 665         if ( !srprs_eos(&pos) && !srprs_char(&pos, sep) ) {
 666                 return false;
 667         }
 668         *ppath = path;
 669         *ptr = strchr(pos, '\0');
 670         return true;
 671 }
 672
 673 /* Fixme: this dosn't work in the general multibyte char case.
 674    see string_replace()
 675 */
 676 static bool normalize_path_internal(char* path, char sep) {
 677         size_t len = strlen(path);
 678         const char *orig = talloc_strndup(talloc_tos(), path, len);
 679         char *optr = path, *iptr = path;
 680         bool changed;
 681
 682         while (*iptr == sep ) {
 683                 iptr++;
 684         }
 685         while (*iptr) {
 686                 *optr = *iptr;
 687                 if (*iptr == sep) {
 688                         while (*iptr == sep) {
 689                                 iptr++;
 690                         }
 691                         if (*iptr) {
 692                                 optr++;
 693                         }
 694                 } else {
 695                         iptr++;
 696                         optr++;
 697                 }
 698         }
 699         *optr = '\0';
 700
 701         strupper_m(path);
 702         changed = (strcmp(orig, path) != 0);
 703         talloc_free(discard_const(orig));
 704         return changed;
 705 }
 706
 707 static bool normalize_path(char* path, char sep) {
 708         static const char* SEPS = "\\/";
 709         char* firstsep = strpbrk(path, SEPS);
 710         bool wrong_sep = (firstsep && (*firstsep != sep));
 711
 712         assert (strchr(SEPS, sep));
 713
 714         if (wrong_sep) {
 715                 string_replace(path, *firstsep, sep);
 716         }
 717         return normalize_path_internal(path, sep) || wrong_sep;
 718 }
 719
 720 static int check_tdb_action(struct db_record *rec, void *check_ctx)
 721 {
 722         struct check_ctx *ctx = (struct check_ctx*)check_ctx;
 723         TALLOC_CTX *frame = talloc_stackframe();
 724         TDB_DATA val = dbwrap_record_get_value(rec);
 725         TDB_DATA rec_key = dbwrap_record_get_key(rec);
 726         char *key;
 727         bool invalid_path = false;
 728         bool once_more;
 729         bool first_iter = true;
 730
 731         if (!tdb_data_is_cstr(rec_key)) {
 732                 printf("Key is not zero terminated: \"%.*s\"\ntry to go on.\n",
 733                        (int)rec_key.dsize, rec_key.dptr);
 734                 invalid_path = true;
 735         }
 736         key = talloc_strndup(frame, (char*)rec_key.dptr, rec_key.dsize);
 737
 738         do {
 739                 const char *path, *pos = key;
 740                 once_more = false;
 741
 742                 if (srprs_str(&pos, "INFO/", -1)) {
 743                         if ( read_info(ctx, pos, val) ) {
 744                                 break;
 745                         }
 746                         invalid_path = true;
 747                         /* ask: mark invalid */
 748                 } else if (srprs_str(&pos, "__db_sequence_number__", -1)) {
 749                         printf("Skip key: \"%.*s\"\n",
 750                                (int)rec_key.dsize, rec_key.dptr);
 751                         /* skip: do nothing + break */
 752                         break;
 753
 754                 } else if (normalize_path(key, ctx->sep)) {
 755                         printf("Unnormal key: \"%.*s\"\n",
 756                                (int)rec_key.dsize, rec_key.dptr);
 757                         printf("Normalize to: \"%s\"\n", key);
 758                         invalid_path = true;
 759                 } else if (srprs_path(&pos, NULL,
 760                                       ctx->sep, &path))
 761                 {
 762                         read_subkeys(ctx, path, val, invalid_path);
 763                         break;
 764                 } else if (srprs_path(&pos, REG_VALUE_PREFIX,
 765                                       ctx->sep, &path))
 766                 {
 767                         read_values(ctx, path, val);
 768                         break;
 769                 } else if (srprs_path(&pos, REG_SECDESC_PREFIX,
 770                                       ctx->sep, &path))
 771                 {
 772                         read_sd(ctx, path, val);
 773                         break;
 774                 } else if (srprs_path(&pos, REG_SORTED_SUBKEYS_PREFIX,
 775                                       ctx->sep, &path))
 776                 {
 777                         if (!read_sorted(ctx, path, val)) {
 778                                 /* delete: mark invalid + break */
 779                                 printf("Invalid sorted subkeys for: \"%s\"\n", path);
 780                                 invalid_path = true;
 781                                 key = NULL;
 782                         }
 783                         break;
 784                 } else {
 785                         printf("Unrecognized key: \"%.*s\"\n",
 786                                (int)rec_key.dsize, rec_key.dptr);
 787                         invalid_path = true;
 788                 }
 789
 790                 if (invalid_path) {
 791                         unsigned char action;
 792                         if (ctx->opt.output == NULL) {
 793                                 action = first_iter ? 'r' : 's';
 794                         } else if (ctx->opt.automatic) {
 795                                 action = first_iter ? 'r' : 'd';
 796                         } else if (ctx->auto_action != '\0') {
 797                                 action = ctx->auto_action;
 798                         } else {
 799                                 action = interact_prompt("[s]kip,[S]kip all,"
 800                                                          "[d]elete,[D]elete all"
 801                                                          ",[e]dit,[r]etry"
 802                                                          , "sder",
 803                                                          ctx->default_action);
 804                         }
 805                         if (isupper(action)) {
 806                                 action = tolower(action);
 807                                 ctx->auto_action = action;
 808                         }
 809                         ctx->default_action = action;
 810                         switch (action) {
 811                         case 's': /* skip */
 812                                 invalid_path = false;
 813                                 break;
 814                         case 'd': /* delete */
 815                                 invalid_path = true;
 816                                 key = NULL;
 817                                 break;
 818                         case 'e': /* edit */ {
 819                                 char *p = interact_edit(frame, key);
 820                                 if (p) {
 821                                         talloc_free(key);
 822                                         key = p;
 823                                 }
 824                         } /* fall through */
 825                         case 'r': /* retry */
 826                                 once_more = true;
 827                                 break;
 828                         }
 829                 }
 830                 first_iter = false;
 831         } while (once_more);
 832
 833         if (invalid_path) {
 834                 dbwrap_store(ctx->del, rec_key, string_term_tdb_data(key), 0);
 835         }
 836
 837         talloc_free(frame);
 838         return 0;
 839 }
 840
 841 static bool get_version(struct check_ctx *ctx) {
 842         static const uint32_t curr_version = REGDB_CODE_VERSION;
 843         uint32_t version = ctx->opt.version ? ctx->opt.version : curr_version;
 844         uint32_t info_version = 0;
 845         NTSTATUS status;
 846
 847         status = dbwrap_fetch_uint32_bystring(ctx->idb, "INFO/version",
 848                                               &info_version);
 849         if (!NT_STATUS_IS_OK(status)) {
 850                 printf("Warning: no INFO/version found!\n");
 851                 /* info_version = guess_version(ctx); */
 852         }
 853
 854         if (ctx->opt.version) {
 855                 version = ctx->opt.version;
 856         } else if (ctx->opt.implicit_db) {
 857                 version = curr_version;
 858         } else {
 859                 version = info_version;
 860         }
 861
 862         if (!version) {
 863                 printf("Couldn't determine registry format version, "
 864                        "specify with --reg-version\n");
 865                 return false;
 866         }
 867
 868
 869         if ( version != info_version ) {
 870                 if (ctx->opt.force || !ctx->opt.repair) {
 871                         printf("Warning: overwrite registry format "
 872                                "version %d with %d\n", info_version, version);
 873                 } else {
 874                         printf("Warning: found registry format version %d but "
 875                                "expected %d, use --force to proceed.\n", info_version, version);
 876                         return false;
 877                 }
 878         }
 879
 880         ctx->version = version;
 881         ctx->sep = (version > 1) ? '\\' : '/';
 882
 883         return true;
 884 }
 885
 886 static bool
 887 dbwrap_store_verbose(struct db_context *db, const char *key, TDB_DATA nval)
 888 {
 889         TALLOC_CTX *mem_ctx = talloc_new(talloc_tos());
 890         TDB_DATA oval;
 891         NTSTATUS status;
 892
 893         status = dbwrap_fetch_bystring(db, mem_ctx, key, &oval);
 894         if (NT_STATUS_IS_OK(status)) {
 895                 if (tdb_data_equal(nval, oval)) {
 896                         goto done;
 897                 }
 898                 printf("store %s:\n  overwrite: %s\n  with:      %s\n", key,
 899                        tdb_data_print(mem_ctx, oval),
 900                        tdb_data_print(mem_ctx, nval));
 901
 902         } else if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
 903                 printf("store %s:\n  write: %s\n", key,
 904                        tdb_data_print(mem_ctx, nval));
 905         } else {
 906                 printf ("store %s:\n  failed to fetch old value: %s\n", key,
 907                         nt_errstr(status));
 908                 goto done;
 909         }
 910
 911         status = dbwrap_store_bystring(db, key, nval, 0);
 912         if (!NT_STATUS_IS_OK(status)) {
 913                 printf ("store %s failed: %s\n", key, nt_errstr(status));
 914         }
 915
 916 done:
 917         talloc_free(mem_ctx);
 918         return NT_STATUS_IS_OK(status);
 919 }
 920
 921 static bool
 922 dbwrap_store_uint32_verbose(struct db_context *db, const char *key, uint32_t nval)
 923 {
 924         uint32_t oval;
 925         NTSTATUS status;
 926
 927         status = dbwrap_fetch_uint32_bystring(db, key, &oval);
 928         if (NT_STATUS_IS_OK(status)) {
 929                 if (nval == oval) {
 930                         goto done;
 931                 }
 932                 printf("store %s:\n overwrite: %d\n with:      %d\n", key,
 933                        (int)oval, (int)nval);
 934
 935         } else if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
 936                 printf("store %s:\n write: %d\n", key, (int)nval);
 937         } else {
 938                 printf ("store %s:\n  failed to fetch old value: %s\n", key,
 939                         nt_errstr(status));
 940                 goto done;
 941         }
 942
 943         status = dbwrap_store_uint32(db, key, nval);
 944         if (!NT_STATUS_IS_OK(status)) {
 945                 printf ("store %s failed: %s\n", key, nt_errstr(status));
 946         }
 947
 948 done:
 949         return NT_STATUS_IS_OK(status);
 950 }
 951
 952 static int cmp_keynames(char **p1, char **p2)
 953 {
 954         return strcasecmp_m(*p1, *p2);
 955 }
 956
 957 static bool
 958 write_subkeylist(struct db_context *db, struct regkey *key, char sep)
 959 {
 960         cbuf *buf = cbuf_new(talloc_tos());
 961         int i;
 962         bool ret;
 963
 964         cbuf_putdw(buf, key->nsubkeys);
 965
 966         for (i=0; i < key->nsubkeys; i++) {
 967                 struct regkey *subkey = key->subkeys[i];
 968                 const char *name = subkey->name;
 969                 if (name == NULL) {
 970                         printf("Warning: no explicite name for key %s\n",
 971                                subkey->path);
 972                         name = strrchr_m(subkey->path, sep);
 973                         assert(name);
 974                         name ++;
 975                 }
 976                 cbuf_puts(buf, name, -1);
 977                 cbuf_putc(buf, '\0');
 978         }
 979
 980         ret = dbwrap_store_verbose(db, key->path, cbuf_make_tdb_data(buf));
 981
 982         talloc_free(buf);
 983         return ret;
 984 }
 985
 986 static bool write_sorted(struct db_context *db, struct regkey *key, char sep)
 987 {
 988         cbuf *buf = cbuf_new(talloc_tos());
 989         char *path;
 990         int i;
 991         bool ret = false;
 992         char **sorted = talloc_zero_array(buf, char*, key->nsubkeys);
 993         int offset =  (1 + key->nsubkeys) * sizeof(uint32_t);
 994
 995         for (i=0; i < key->nsubkeys; i++) {
 996                 sorted[i] = talloc_strdup_upper(sorted, key->subkeys[i]->name);
 997         }
 998         TYPESAFE_QSORT(sorted, key->nsubkeys, cmp_keynames);
 999
1000         cbuf_putdw(buf, key->nsubkeys);
1001         for (i=0; i < key->nsubkeys; i++) {
1002                 cbuf_putdw(buf, offset);
1003                 offset += strlen(sorted[i]) + 1;
1004         }
1005         for (i=0; i < key->nsubkeys; i++) {
1006                 cbuf_puts(buf, sorted[i], -1);
1007                 cbuf_putc(buf, '\0');
1008         }
1009
1010         path = talloc_asprintf(buf, "%s%c%s", REG_SORTED_SUBKEYS_PREFIX, sep,
1011                                key->path);
1012         if (path == NULL) {
1013                 DEBUG(0, ("Out of memory!\n"));
1014                 goto done;
1015         }
1016
1017         ret = dbwrap_store_verbose(db, path, cbuf_make_tdb_data(buf));
1018 done:
1019         talloc_free(buf);
1020         return ret;
1021 }
1022
1023 static bool write_values(struct db_context *db, struct regkey *key, char sep)
1024 {
1025         cbuf *buf = cbuf_new(talloc_tos());
1026         char *path;
1027         int i;
1028         bool ret = false;
1029
1030         cbuf_putdw(buf, key->nvalues);
1031         for (i=0; i < key->nvalues; i++) {
1032                 struct regval *val = key->values[i];
1033                 cbuf_puts(buf, val->name, -1);
1034                 cbuf_putc(buf, '\0');
1035                 cbuf_putdw(buf, val->type);
1036                 cbuf_putdw(buf, val->data.length);
1037                 cbuf_puts(buf, (void*)val->data.data, val->data.length);
1038         }
1039
1040         path = talloc_asprintf(buf, "%s%c%s", REG_VALUE_PREFIX, sep, key->path);
1041         if (path == NULL) {
1042                 DEBUG(0, ("Out of memory!\n"));
1043                 goto done;
1044         }
1045
1046         ret = dbwrap_store_verbose(db, path, cbuf_make_tdb_data(buf));
1047 done:
1048         talloc_free(buf);
1049         return ret;
1050 }
1051
1052 static bool write_sd(struct db_context *db, struct regkey *key, char sep)
1053 {
1054         TDB_DATA sd;
1055         NTSTATUS status;
1056         char *path;
1057         bool ret = false;
1058         TALLOC_CTX *mem_ctx = talloc_new(talloc_tos());
1059
1060         status = marshall_sec_desc(mem_ctx, key->sd, &sd.dptr, &sd.dsize);
1061         if (!NT_STATUS_IS_OK(status)) {
1062                 printf("marshall sec desc %s failed: %s\n",
1063                        key->path, nt_errstr(status));
1064                 goto done;
1065         }
1066         path = talloc_asprintf(mem_ctx, "%s%c%s", REG_SECDESC_PREFIX,
1067                                sep, key->path);
1068         if (path == NULL) {
1069                 DEBUG(0, ("Out of memory!\n"));
1070                 goto done;
1071         }
1072
1073         ret = dbwrap_store_verbose(db, path, sd);
1074 done:
1075         talloc_free(mem_ctx);
1076         return ret;
1077 }
1078
1079
1080 static int check_write_db_action(struct db_record *rec, void *check_ctx)
1081 {
1082         struct check_ctx *ctx = (struct check_ctx*)check_ctx;
1083         TDB_DATA rec_val = dbwrap_record_get_value(rec);
1084         struct regkey *key = *(struct regkey**)rec_val.dptr;
1085         TALLOC_CTX *frame = talloc_stackframe();
1086
1087         /* write subkeylist */
1088         if ((ctx->version > 2) || (key->nsubkeys > 0) || (key->has_subkeylist)) {
1089                 write_subkeylist(ctx->odb, key, ctx->sep);
1090         }
1091
1092         /* write sorted subkeys */
1093         if ((ctx->version < 3) && (key->nsubkeys > 0)) {
1094                 write_sorted(ctx->odb, key, ctx->sep);
1095         }
1096
1097         /* write value list */
1098         if (key->nvalues > 0) {
1099                 write_values(ctx->odb, key, ctx->sep);
1100         }
1101
1102         /* write sd */
1103         if (key->sd) {
1104                 write_sd(ctx->odb, key, ctx->sep);
1105         }
1106
1107         talloc_free(frame);
1108         return 0;
1109 }
1110
1111 static int fix_tree_action(struct db_record *rec, void *check_ctx)
1112 {
1113         struct check_ctx *ctx = (struct check_ctx*)check_ctx;
1114         TDB_DATA rec_key = dbwrap_record_get_key(rec);
1115         TDB_DATA rec_val = dbwrap_record_get_value(rec);
1116         struct regkey* key = *(struct regkey**)rec_val.dptr;
1117         if (ctx->opt.verbose) {
1118                 printf("Check Tree: %s\n", key->path);
1119         }
1120
1121         assert (strncmp(key->path, (char*)rec_key.dptr, rec_key.dsize) == 0);
1122
1123         /* assert(dbwrap_exists(ctx->db, string_term_tdb_data(key->path)) */
1124         /*        == key->exists); */
1125
1126         if (key->needs_update) {
1127                 printf("Update key: \"%s\"\n", key->path);
1128                 if ((ctx->version > 2) || (key->nsubkeys > 0)) {
1129                         write_subkeylist(ctx->odb, key, ctx->sep);
1130                 }
1131                 if ((ctx->version <= 2) && (key->nsubkeys > 0)) {
1132                         write_sorted(ctx->odb, key, ctx->sep);
1133                 }
1134                 if (key->nvalues > 0) {
1135                         write_values(ctx->odb, key, ctx->sep);
1136                 }
1137                 if (key->sd) {
1138                         write_sd(ctx->odb, key, ctx->sep);
1139                 }
1140         } else if (!key->has_subkeylist) {
1141                 if ((ctx->version > 2) || (key->nsubkeys > 0)) {
1142                         printf("Missing subkeylist: %s\n", key->path);
1143                         write_subkeylist(ctx->odb, key, ctx->sep);
1144                 }
1145         }
1146
1147         if (key->name == NULL && key->parent->has_subkeylist) {
1148                 printf("Key not referenced by the its parents subkeylist: %s\n",
1149                        key->path);
1150                 write_subkeylist(ctx->odb, key->parent, ctx->sep);
1151         }
1152
1153 /* XXX check that upcase(name) matches last part of path ??? */
1154
1155         return 0;
1156 }
1157
1158
1159 /* give the same warnings as fix_tree_action */
1160 static int check_tree_action(struct db_record *rec, void *check_ctx)
1161 {
1162         struct check_ctx *ctx = (struct check_ctx*)check_ctx;
1163         TDB_DATA rec_key = dbwrap_record_get_key(rec);
1164         TDB_DATA rec_val = dbwrap_record_get_value(rec);
1165         struct regkey* key = *(struct regkey**)rec_val.dptr;
1166         if (ctx->opt.verbose) {
1167                 printf("Check Tree: %s\n", key->path);
1168         }
1169
1170         assert (strncmp(key->path, (char*)rec_key.dptr, rec_key.dsize) == 0);
1171
1172         if (!key->has_subkeylist) {
1173                 if ((ctx->version > 2) || (key->nsubkeys > 0)) {
1174                         printf("Missing subkeylist: %s\n", key->path);
1175                 }
1176         }
1177
1178         if (key->name == NULL && key->parent->has_subkeylist) {
1179                 printf("Key not referenced by the its parents subkeylist: %s\n",
1180                        key->path);
1181         }
1182
1183         return 0;
1184 }
1185
1186 static int delete_invalid_action(struct db_record *rec, void* check_ctx)
1187 {
1188         NTSTATUS status;
1189         struct check_ctx *ctx = (struct check_ctx*)check_ctx;
1190         TDB_DATA rec_key = dbwrap_record_get_key(rec);
1191         TDB_DATA rec_val = dbwrap_record_get_value(rec);
1192
1193
1194         printf("Delete key: \"%.*s\"",(int)rec_key.dsize, rec_key.dptr);
1195         if (rec_val.dsize > 0) {
1196                 printf(" in favour of \"%s\"\n", rec_val.dptr);
1197         } else {
1198                 putc('\n', stdout);
1199         }
1200
1201         status = dbwrap_delete(ctx->odb, rec_key);
1202         if (!NT_STATUS_IS_OK(status)) {
1203                 d_printf("delete key \"%.*s\" failed!\n",
1204                          (int)rec_key.dsize, rec_key.dptr);
1205                 return -1;
1206         }
1207         return 0;
1208 }
1209
1210 static bool check_ctx_check_tree(struct check_ctx *ctx) {
1211         NTSTATUS status;
1212
1213         status = dbwrap_traverse(ctx->reg, check_tree_action, ctx, NULL);
1214         if (!NT_STATUS_IS_OK(status)) {
1215                 DEBUG(0, ("check traverse failed: %s\n",
1216                           nt_errstr(status)));
1217                 return false;
1218         }
1219         return true;
1220 }
1221 static bool check_ctx_fix_inplace(struct check_ctx *ctx) {
1222         NTSTATUS status;
1223         status = dbwrap_traverse(ctx->reg, fix_tree_action, ctx, NULL);
1224         if (!NT_STATUS_IS_OK(status)) {
1225                 DEBUG(0, ("fix traverse failed: %s\n", nt_errstr(status)));
1226                 return false;
1227         }
1228
1229         status = dbwrap_traverse(ctx->del, delete_invalid_action, ctx, NULL);
1230         if (!NT_STATUS_IS_OK(status)) {
1231                 DEBUG(0, ("delete traverse failed: %s\n", nt_errstr(status)));
1232                 return false;
1233         }
1234
1235         if (!dbwrap_store_uint32_verbose(ctx->odb, "INFO/version", ctx->version)) {
1236                 DEBUG(0, ("storing version failed: %s\n", nt_errstr(status)));
1237                 return false;
1238         }
1239
1240         return true;
1241 }
1242
1243 static bool check_ctx_write_new_db(struct check_ctx *ctx) {
1244         NTSTATUS status;
1245
1246         assert(ctx->odb);
1247
1248         if (ctx->opt.wipe) {
1249                 int ret = dbwrap_wipe(ctx->odb);
1250                 if (ret != 0) {
1251                         DEBUG(0, ("wiping %s failed\n", ctx->opt.output));
1252                         return false;
1253                 }
1254         }
1255
1256         status = dbwrap_traverse(ctx->reg, check_write_db_action, ctx, NULL);
1257         if (!NT_STATUS_IS_OK(status)) {
1258                 DEBUG(0, ("traverse2 failed: %s\n", nt_errstr(status)));
1259                 return false;
1260         }
1261
1262         status = dbwrap_store_uint32(ctx->odb,
1263                                      "INFO/version", ctx->version);
1264         if (!NT_STATUS_IS_OK(status)) {
1265                 DEBUG(0, ("write version failed: %s\n", nt_errstr(status)));
1266                 return false;
1267         }
1268         return true;
1269 }
1270
1271 int net_registry_check_db(const char *name, const struct check_options *opt)
1272 {
1273         NTSTATUS status;
1274         int ret = -1;
1275         struct check_ctx *ctx = check_ctx_create(talloc_tos(), name, opt);
1276         if (ctx==NULL) {
1277                 goto done;
1278         }
1279
1280         d_printf("Check database: %s\n", name);
1281
1282         /* 1. open output RW */
1283         if (!check_ctx_open_output(ctx)) {
1284                 goto done;
1285         }
1286
1287         /* 2. open input RO */
1288         if (!check_ctx_open_input(ctx)) {
1289                 goto done;
1290         }
1291
1292         if (opt->lock && !check_ctx_transaction_start(ctx)) {
1293                 goto done;
1294         }
1295
1296         if (!get_version(ctx)) {
1297                 goto done;
1298         }
1299
1300         status = dbwrap_traverse_read(ctx->idb, check_tdb_action, ctx, NULL);
1301         if (!NT_STATUS_IS_OK(status)) {
1302                 DEBUG(0, ("check traverse failed: %s\n", nt_errstr(status)));
1303                 goto done;
1304         }
1305
1306         if (!opt->lock && !check_ctx_transaction_start(ctx)) {
1307                 goto done;
1308         }
1309
1310         if (ctx->opt.repair && !ctx->opt.wipe) {
1311                 if (!check_ctx_fix_inplace(ctx)) {
1312                         goto done;
1313                 }
1314         } else {
1315                 if (!check_ctx_check_tree(ctx)) {
1316                         goto done;
1317                 }
1318                 if (ctx->odb) {
1319                         if (!check_ctx_write_new_db(ctx)) {
1320                                 goto done;
1321                         }
1322                 }
1323         }
1324         ret = 0;
1325 done:
1326         check_ctx_transaction_stop(ctx, ret == 0);
1327
1328         talloc_free(ctx);
1329         return ret;
1330 }
1331
1332 /*Local Variables:*/
1333 /*mode: c*/
1334 /*End:*/