source3/utils/net_idmap_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 idmap database.
  22  * @author Gregor Beck <gb@sernet.de>
  23  * @date   Mar 2011
  24  */
  25
  26 #include "net_idmap_check.h"
  27 #include "includes.h"
  28 #include "system/filesys.h"
  29 #include "dbwrap/dbwrap.h"
  30 #include "dbwrap/dbwrap_open.h"
  31 #include "dbwrap/dbwrap_rbt.h"
  32 #include "net.h"
  33 #include "../libcli/security/dom_sid.h"
  34 #include "cbuf.h"
  35 #include "srprs.h"
  36 #include "util_tdb.h"
  37 #include "interact.h"
  38
  39 static int traverse_commit(struct db_record *diff_rec, void* data);
  40 static int traverse_check(struct db_record *rec, void* data);
  41
  42 /* TDB_DATA *******************************************************************/
  43 static char*    print_data(TALLOC_CTX* mem_ctx, TDB_DATA d);
  44 static TDB_DATA parse_data(TALLOC_CTX* mem_ctx, const char** ptr);
  45
  46 /* record *********************************************************************/
  47
  48 enum DT {
  49         DT_INV = 0,
  50         DT_SID, DT_UID, DT_GID,
  51         DT_HWM, DT_VER, DT_SEQ,
  52 };
  53
  54 struct record {
  55         enum DT key_type, val_type;
  56         TDB_DATA key, val;
  57         struct dom_sid sid;
  58         long unsigned  id;
  59 };
  60
  61 static struct record* parse_record(TALLOC_CTX* ctx, TDB_DATA key, TDB_DATA val);
  62 static struct record* reverse_record(struct record* rec);
  63
  64 static bool is_invalid(const struct record* r) {
  65         return (r->key_type == DT_INV) || (r->val_type == DT_INV);
  66 }
  67
  68 static bool is_map(const struct record* r) {
  69         return (r->key_type == DT_SID)
  70                 || (r->key_type == DT_UID) || (r->key_type == DT_GID);
  71 }
  72
  73 /* action *********************************************************************/
  74
  75 typedef struct check_action {
  76         const char* fmt;
  77         const char* name;
  78         const char* prompt;
  79         const char* answers;
  80         char auto_action;
  81         char default_action;
  82         bool verbose;
  83 } check_action;
  84
  85 struct check_actions {
  86         check_action invalid_record;
  87         check_action missing_reverse;
  88         check_action invalid_mapping;
  89         check_action invalid_edit;
  90         check_action record_exists;
  91         check_action no_version;
  92         check_action wrong_version;
  93         check_action invalid_hwm;
  94         check_action commit;
  95         check_action valid_mapping;
  96         check_action valid_other;
  97         check_action invalid_diff;
  98 };
  99
 100 static struct check_actions
 101 check_actions_init(const struct check_options* opts) {
 102         struct check_actions ret = {
 103                 .invalid_record = (check_action) {
 104                         .name = "Invalid record",
 105                         .prompt = "[e]dit/[d]elete/[D]elete all"
 106                         "/[s]kip/[S]kip all",
 107                         .answers = "eds",
 108                         .default_action = 'e',
 109                         .verbose = true,
 110                 },
 111                 .missing_reverse = (check_action) {
 112                         .name = "Missing reverse mapping for",
 113                         .prompt = "[f]ix/[F]ix all/[e]dit/[d]elete/[D]elete all"
 114                         "/[s]kip/[S]kip all",
 115                         .answers = "feds",
 116                         .default_action = 'f',
 117                         .verbose = true,
 118                 },
 119                 .invalid_mapping = (check_action) {
 120                         .fmt = "%1$s: %2$s -> %3$s\n(%4$s <- %3$s)\n",
 121                         .name = "Invalid mapping",
 122                         .prompt = "[e]dit/[d]elete/[D]elete all"
 123                         "/[s]kip/[S]kip all",
 124                         .answers = "eds",
 125                         .default_action = 'd',
 126                         .verbose = true,
 127                 },
 128                 .invalid_edit = (check_action) {
 129                         .name = "Invalid record",
 130                         .prompt = "[e]dit/[d]elete/[D]elete all"
 131                         "/[s]kip/[S]kip all",
 132                         .answers = "eds",
 133                         .default_action = 'e',
 134                         .verbose = true,
 135                 },
 136                 .record_exists = (check_action) {
 137                         .fmt = "%1$s: %2$s\n-%4$s\n+%3$s\n",
 138                         .name = "Record exists",
 139                         .prompt = "[o]verwrite/[O]verwrite all/[e]dit"
 140                         "/[d]elete/[D]elete all/[s]kip/[S]kip all",
 141                         .answers = "oeds",
 142                         .default_action = 'o',
 143                         .verbose = true,
 144                 },
 145                 .no_version = (check_action) {
 146                         .prompt = "[f]ix/[s]kip/[a]bort",
 147                         .answers = "fsa",
 148                         .default_action = 'f',
 149                 },
 150                 .wrong_version = (check_action) {
 151                         .prompt = "[f]ix/[s]kip/[a]bort",
 152                         .answers = "fsa",
 153                         .default_action = 'a',
 154                 },
 155                 .invalid_hwm = (check_action) {
 156                         .prompt = "[f]ix/[s]kip",
 157                         .answers = "fs",
 158                         .default_action = 'f',
 159                 },
 160                 .commit = (check_action) {
 161                         .prompt = "[c]ommit/[l]ist/[s]kip",
 162                         .answers = "cls",
 163                         .default_action = 'l',
 164                         .verbose = true,
 165                 },
 166                 .valid_mapping = (check_action) {
 167                         .fmt = "%1$s: %2$s <-> %3$s\n",
 168                         .name = "Mapping",
 169                         .auto_action = 's',
 170                         .verbose = opts->verbose,
 171                 },
 172                 .valid_other = (check_action) {
 173                         .name = "Other",
 174                         .auto_action = 's',
 175                         .verbose = opts->verbose,
 176                 },
 177                 .invalid_diff = (check_action) {
 178                         .prompt = "[s]kip/[S]kip all/[c]ommit/[C]ommit all"
 179                         "/[a]bort",
 180                         .answers = "sca",
 181                         .default_action = 's',
 182                 },
 183         };
 184
 185         if (!opts->repair) {
 186                 ret.invalid_record.auto_action  = 's';
 187                 ret.missing_reverse.auto_action = 's';
 188                 ret.invalid_mapping.auto_action = 's';
 189                 ret.no_version.auto_action      = 's';
 190                 ret.wrong_version.auto_action   = 's';
 191                 ret.invalid_hwm.auto_action     = 's';
 192                 ret.commit.auto_action          = 's';
 193         }
 194
 195         if (opts->automatic) {
 196                 ret.invalid_record.auto_action  = 'd'; /* delete */
 197                 ret.missing_reverse.auto_action = 'f'; /* fix */
 198                 ret.invalid_mapping.auto_action = 'd'; /* delete */
 199                 ret.no_version.auto_action      = 'f'; /* fix */
 200                 ret.wrong_version.auto_action   = 'a'; /* abort */
 201                 ret.invalid_hwm.auto_action     = 'f'; /* fix */
 202                 ret.commit.auto_action          = 'c'; /* commit */
 203                 ret.invalid_diff.auto_action    = 'a'; /* abort */
 204                 if (opts->force) {
 205                         ret.wrong_version.auto_action   = 'f'; /* fix */
 206                         ret.invalid_diff.auto_action    = 'c'; /* commit */
 207                 }
 208         }
 209         if (opts->test) {
 210                 ret.invalid_diff.auto_action    = 'c'; /* commit */
 211 /*              ret.commit.auto_action          = 'c';*/ /* commit */
 212         }
 213
 214         return ret;
 215 }
 216
 217 static char get_action(struct check_action* a, struct record* r, TDB_DATA* v) {
 218         char ret;
 219         if (a->verbose && (r != NULL)) {
 220                 if (!a->fmt) {
 221                         d_printf("%s: %s ", a->name, print_data(r, r->key));
 222                         if (is_map(r)) {
 223                                 d_printf("-> %s\n", print_data(r, r->val));
 224                         } else if (r->key_type == DT_HWM ||
 225                                    r->key_type == DT_VER ||
 226                                    r->key_type == DT_SEQ)
 227                         {
 228                                 d_printf(": %ld\n", r->id);
 229                         } else {
 230                                 d_printf("\n");
 231                         }
 232                 } else {
 233                         d_printf(a->fmt, a->name,
 234                                  print_data(r, r->key),
 235                                  print_data(r, r->val),
 236                                  (v ? print_data(r, *v) : ""));
 237                 }
 238         }
 239
 240         if (a->auto_action != '\0') {
 241                 return a->auto_action;
 242         }
 243
 244         ret = interact_prompt(a->prompt, a->answers, a->default_action);
 245
 246         if (isupper(ret)) {
 247                 ret = tolower(ret);
 248                 a->auto_action = ret;
 249         }
 250         a->default_action = ret;
 251         return ret;
 252 }
 253
 254 /*  *************************************************************************/
 255
 256 typedef struct {
 257         TDB_DATA oval, nval;
 258 } TDB_DATA_diff;
 259
 260 static TDB_DATA pack_diff(TDB_DATA_diff* diff) {
 261         return (TDB_DATA) {
 262                 .dptr = (uint8_t *)diff,
 263                 .dsize = sizeof(TDB_DATA_diff),
 264         };
 265 }
 266
 267 static TDB_DATA_diff unpack_diff(TDB_DATA data) {
 268         assert(data.dsize == sizeof(TDB_DATA_diff));
 269         return *(TDB_DATA_diff*)data.dptr;
 270 }
 271
 272 #define DEBUG_DIFF(LEV,MEM,MSG,KEY,OLD,NEW)                     \
 273         DEBUG(LEV, ("%s: %s\n", MSG, print_data(MEM, KEY)));    \
 274         if (!tdb_data_is_empty(OLD)) {                          \
 275                 DEBUGADD(LEV, ("-%s\n", print_data(MEM, OLD))); \
 276         }                                                       \
 277         if (!tdb_data_is_empty(NEW)) {                          \
 278                 DEBUGADD(LEV, ("+%s\n", print_data(MEM, NEW))); \
 279         }
 280
 281 struct check_ctx {
 282         int oflags;
 283         char* name;
 284         bool transaction;
 285         struct db_context *db;
 286         struct db_context *diff;
 287         struct check_actions action;
 288
 289         uint32_t uid_hwm;
 290         uint32_t gid_hwm;
 291
 292         unsigned n_invalid_record;
 293         unsigned n_missing_reverse;
 294         unsigned n_invalid_mappping;
 295         unsigned n_map;
 296         unsigned n_other;
 297         unsigned n_diff;
 298         struct check_options opts;
 299 };
 300
 301
 302 static void adjust_hwm(struct check_ctx* ctx, const struct record* r);
 303
 304 static int add_record(struct check_ctx* ctx, TDB_DATA key, TDB_DATA value)
 305 {
 306         NTSTATUS status;
 307         TDB_DATA_diff diff;
 308         TALLOC_CTX* mem = talloc_new(ctx->diff);
 309         TDB_DATA recvalue;
 310         struct db_record *rec = dbwrap_fetch_locked(ctx->diff, mem, key);
 311
 312         if (rec == NULL) {
 313                 return -1;
 314         }
 315
 316         recvalue = dbwrap_record_get_value(rec);
 317
 318         if (recvalue.dptr == 0) { /* first entry */
 319                 status = dbwrap_fetch(ctx->db, ctx->diff, key, &diff.oval);
 320                 if (!NT_STATUS_IS_OK(status)) {
 321                         diff.oval = tdb_null;
 322                 }
 323         } else {
 324                 diff = unpack_diff(recvalue);
 325                 talloc_free(diff.nval.dptr);
 326         }
 327         diff.nval = tdb_data_talloc_copy(ctx->diff, value);
 328
 329         DEBUG_DIFF(2, mem, "TDB DIFF", key, diff.oval, diff.nval);
 330
 331         status = dbwrap_record_store(rec, pack_diff(&diff), 0);
 332
 333         talloc_free(mem);
 334
 335         if (!NT_STATUS_IS_OK(status)) {
 336                 DEBUG(0, ("could not store record %s\n", nt_errstr(status)));
 337                 return -1;
 338         }
 339         ctx->n_diff ++;
 340         return 0;
 341 }
 342
 343 static int del_record(struct check_ctx* ctx, TDB_DATA key) {
 344         return add_record(ctx, key, tdb_null);
 345 }
 346
 347 static TDB_DATA
 348 fetch_record(struct check_ctx* ctx, TALLOC_CTX* mem_ctx, TDB_DATA key)
 349 {
 350         TDB_DATA tmp;
 351         NTSTATUS status;
 352
 353         status = dbwrap_fetch(ctx->diff, mem_ctx, key, &tmp);
 354
 355         if (NT_STATUS_IS_OK(status)) {
 356                 TDB_DATA_diff diff = unpack_diff(tmp);
 357                 TDB_DATA ret = tdb_data_talloc_copy(mem_ctx, diff.nval);
 358                 talloc_free(tmp.dptr);
 359                 return ret;
 360         }
 361
 362         status = dbwrap_fetch(ctx->db, mem_ctx, key, &tmp);
 363         if (!NT_STATUS_IS_OK(status)) {
 364                 return tdb_null;
 365         }
 366
 367         return tmp;
 368 }
 369
 370 static void edit_record(struct record* r) {
 371         TALLOC_CTX* mem = talloc_new(r);
 372         cbuf* ost = cbuf_new(mem);
 373         const char* str;
 374         struct record* nr;
 375         TDB_DATA key;
 376         TDB_DATA val;
 377         cbuf_printf(ost, "%s %s\n",
 378                     print_data(mem, r->key), print_data(mem, r->val));
 379         str = interact_edit(mem, cbuf_gets(ost, 0));
 380         key = parse_data(mem, &str);
 381         val = parse_data(mem, &str);
 382         nr = parse_record(talloc_parent(r), key, val);
 383         if (nr != NULL) {
 384                 *r = *nr;
 385         }
 386         talloc_free(mem);
 387 }
 388
 389 static bool check_version(struct check_ctx* ctx) {
 390         static const char* key = "IDMAP_VERSION";
 391         uint32_t version;
 392         NTSTATUS status;
 393         char action = 's';
 394         struct check_actions* act = &ctx->action;
 395
 396         status = dbwrap_fetch_uint32_bystring(ctx->db, key, &version);
 397         if (!NT_STATUS_IS_OK(status)) {
 398                 d_printf("No version number, assume 2\n");
 399                 action = get_action(&act->no_version, NULL, NULL);
 400         } else if (version != 2) {
 401                 d_printf("Wrong version number %d, should be 2\n", version);
 402                 action = get_action(&act->wrong_version, NULL, NULL);
 403         }
 404         switch (action) {
 405         case 's':
 406                 break;
 407         case 'f':
 408                 SIVAL(&version, 0, 2);
 409                 add_record(ctx, string_term_tdb_data(key),
 410                            make_tdb_data((uint8_t *)&version, sizeof(uint32_t)));
 411                 break;
 412         case 'a':
 413                 return false;
 414         default:
 415                 assert(false);
 416         }
 417         return true;
 418 }
 419
 420 static void check_hwm(struct check_ctx* ctx, const char* key, uint32_t target) {
 421         uint32_t hwm;
 422         char action = 's';
 423         NTSTATUS status;
 424         struct check_actions* act = &ctx->action;
 425
 426         status = dbwrap_fetch_uint32_bystring(ctx->db, key, &hwm);
 427         if (!NT_STATUS_IS_OK(status)) {
 428                 d_printf("No %s should be %d\n", key, target);
 429                 action = get_action(&act->invalid_hwm, NULL, NULL);
 430         } else if (target < hwm) {
 431                 d_printf("Invalid %s %d: should be %d\n", key, hwm, target);
 432                 action = get_action(&act->invalid_hwm, NULL, NULL);
 433         }
 434         if (action == 'f') {
 435                 SIVAL(&hwm, 0, target);
 436                 add_record(ctx, string_term_tdb_data(key),
 437                            make_tdb_data((uint8_t *)&hwm, sizeof(uint32_t)));
 438         }
 439 }
 440
 441 int traverse_check(struct db_record *rec, void* data) {
 442         struct check_ctx* ctx = (struct check_ctx*)data;
 443         struct check_actions* act = &ctx->action;
 444         TALLOC_CTX* mem = talloc_new(ctx->diff);
 445         TDB_DATA key;
 446         TDB_DATA value;
 447         struct record *r;
 448         char action = 's';
 449
 450         key = dbwrap_record_get_key(rec);
 451         value = dbwrap_record_get_value(rec);
 452
 453         r = parse_record(mem, key, value);
 454
 455         if (is_invalid(r)) {
 456                 action = get_action(&act->invalid_record, r, NULL);
 457                 ctx->n_invalid_record++;
 458         } else if (is_map(r)) {
 459                 TDB_DATA back = fetch_record(ctx, mem, r->val);
 460                 if (back.dptr == NULL) {
 461                         action = get_action(&act->missing_reverse, r, NULL);
 462                         ctx->n_missing_reverse++;
 463                 } else if (!tdb_data_equal(r->key, back)) {
 464                         action = get_action(&act->invalid_mapping, r, &back);
 465                         ctx->n_invalid_mappping++;
 466                 } else {
 467                         if (r->key_type == DT_SID) {
 468                                 action = get_action(&act->valid_mapping, r, NULL);
 469                                 ctx->n_map++;
 470                         } else {
 471                                 action = get_action(&act->valid_mapping, NULL,
 472                                                     NULL);
 473                         }
 474                 }
 475                 adjust_hwm(ctx, r);
 476         } else {
 477                 action = get_action(&act->valid_other, r, NULL);
 478                 ctx->n_other++;
 479         }
 480
 481         while (action) {
 482                 switch (action) {
 483                 case 's': /* skip */
 484                         break;
 485                 case 'd': /* delete */
 486                         del_record(ctx, key);
 487                         break;
 488                 case 'f': /* add reverse mapping */
 489                         add_record(ctx, value, key);
 490                         break;
 491                 case 'e': /* edit */
 492                         edit_record(r);
 493                         action = 'o';
 494                         if (is_invalid(r)) {
 495                                 action = get_action(&act->invalid_edit, r,NULL);
 496                                 continue;
 497                         }
 498                         if (!tdb_data_equal(key, r->key)) {
 499                                 TDB_DATA oval = fetch_record(ctx, mem, r->key);
 500                                 if (!tdb_data_is_empty(oval) &&
 501                                     !tdb_data_equal(oval, r->val))
 502                                 {
 503                                         action = get_action(&act->record_exists,
 504                                                             r, &oval);
 505                                         if (action != 'o') {
 506                                                 continue;
 507                                         }
 508                                 }
 509                         }
 510                         if (is_map(r)) {
 511                                 TDB_DATA okey = fetch_record(ctx, mem, r->val);
 512                                 if (!tdb_data_is_empty(okey) &&
 513                                     !tdb_data_equal(okey, r->key))
 514                                 {
 515                                         action = get_action(&act->record_exists,
 516                                                             reverse_record(r),
 517                                                             &okey);
 518                                 }
 519                         }
 520                         continue;
 521                 case 'o': /* overwrite */
 522                         adjust_hwm(ctx, r);
 523                         if (!tdb_data_equal(key, r->key)) {
 524                                 del_record(ctx, key);
 525                         }
 526                         add_record(ctx, r->key, r->val);
 527                         if (is_map(r)) {
 528                                 add_record(ctx, r->val, r->key);
 529                         }
 530                 }
 531                 action = '\0';
 532         };
 533
 534         talloc_free(mem);
 535
 536         return 0;
 537 }
 538
 539 /******************************************************************************/
 540
 541 void adjust_hwm(struct check_ctx* ctx, const struct record* r) {
 542         enum DT type = (r->key_type == DT_SID) ? r->val_type : r->key_type;
 543         if (type == DT_UID) {
 544                 ctx->uid_hwm = MAX(ctx->uid_hwm, r->id);
 545         } else if (type == DT_GID) {
 546                 ctx->gid_hwm = MAX(ctx->gid_hwm, r->id);
 547         }
 548 }
 549
 550 static bool is_cstr(TDB_DATA str) {
 551         return !tdb_data_is_empty(str) && str.dptr[str.dsize-1] == '\0';
 552 }
 553
 554 static bool parse_sid (TDB_DATA str, enum DT* type, struct dom_sid* sid) {
 555         struct dom_sid tmp;
 556         const char* s = (const char*)str.dptr;
 557         if ((s[0] == 'S') && string_to_sid(&tmp, s)) {
 558                 *sid = tmp;
 559                 *type = DT_SID;
 560                 return true;
 561         }
 562         return false;
 563 }
 564
 565 static bool parse_xid(TDB_DATA str, enum DT* type, unsigned long* id) {
 566         char c, t;
 567         unsigned long tmp;
 568         if (sscanf((const char*)str.dptr, "%cID %lu%c", &c, &tmp, &t) == 2) {
 569                 if (c == 'U') {
 570                         *id = tmp;
 571                         *type = DT_UID;
 572                         return true;
 573                 } else if (c == 'G') {
 574                         *id = tmp;
 575                         *type = DT_GID;
 576                         return true;
 577                 }
 578         }
 579         return false;
 580 }
 581
 582
 583 struct record*
 584 parse_record(TALLOC_CTX* mem_ctx, TDB_DATA key, TDB_DATA val)
 585 {
 586         struct record* ret = talloc_zero(mem_ctx, struct record);
 587         if (ret == NULL) {
 588                 DEBUG(0, ("Out of memory.\n"));
 589                 return NULL;
 590         }
 591         ret->key = tdb_data_talloc_copy(ret, key);
 592         ret->val = tdb_data_talloc_copy(ret, val);
 593         if ((ret->key.dptr == NULL && key.dptr != NULL) ||
 594             (ret->val.dptr == NULL && val.dptr != NULL))
 595         {
 596                 talloc_free(ret);
 597                 DEBUG(0, ("Out of memory.\n"));
 598                 return NULL;
 599         }
 600         assert((ret->key_type == DT_INV) && (ret->val_type == DT_INV));
 601
 602         if (!is_cstr(key)) {
 603                 return ret;
 604         }
 605         if (parse_sid(key, &ret->key_type, &ret->sid)) {
 606                 parse_xid(val, &ret->val_type, &ret->id);
 607         } else if (parse_xid(key, &ret->key_type, &ret->id)) {
 608                 if (is_cstr(val)) {
 609                         parse_sid(val, &ret->val_type, &ret->sid);
 610                 }
 611         } else if (strcmp((const char*)key.dptr, "USER HWM") == 0) {
 612                 ret->key_type = DT_HWM;
 613                 if (val.dsize == 4) {
 614                         ret->id = IVAL(val.dptr,0);
 615                         ret->val_type = DT_UID;
 616                 }
 617         } else if (strcmp((const char*)key.dptr, "GROUP HWM") == 0) {
 618                 ret->key_type = DT_HWM;
 619                 if (val.dsize == 4) {
 620                         ret->id = IVAL(val.dptr,0);
 621                         ret->val_type = DT_GID;
 622                 }
 623         } else if (strcmp((const char*)key.dptr, "IDMAP_VERSION") == 0) {
 624                 ret->key_type = DT_VER;
 625                 if (val.dsize == 4) {
 626                         ret->id = IVAL(val.dptr,0);
 627                         ret->val_type = DT_VER;
 628                 }
 629         } else if (strcmp((const char*)key.dptr, "__db_sequence_number__") == 0) {
 630                 ret->key_type = DT_SEQ;
 631                 if (val.dsize == 8) {
 632                         ret->id = *(uint64_t*)val.dptr;
 633                         ret->val_type = DT_SEQ;
 634                 }
 635         }
 636
 637         return ret;
 638 }
 639
 640 struct record* reverse_record(struct record* in)
 641 {
 642         return parse_record(talloc_parent(in), in->val, in->key);
 643 }
 644
 645
 646 /******************************************************************************/
 647
 648
 649 char* print_data(TALLOC_CTX* mem_ctx, TDB_DATA d)
 650 {
 651         if (!tdb_data_is_empty(d)) {
 652                 char* ret = NULL;
 653                 cbuf* ost = cbuf_new(mem_ctx);
 654                 int len = cbuf_print_quoted(ost, (const char*)d.dptr, d.dsize);
 655                 if (len != -1) {
 656                         cbuf_swapptr(ost, &ret, 0);
 657                         talloc_steal(mem_ctx, ret);
 658                 }
 659                 talloc_free(ost);
 660                 return ret;
 661         }
 662         return talloc_strdup(mem_ctx, "<NULL>");
 663 }
 664
 665
 666 TDB_DATA parse_data(TALLOC_CTX* mem_ctx, const char** ptr) {
 667         cbuf* ost = cbuf_new(mem_ctx);
 668         TDB_DATA ret = tdb_null;
 669         srprs_skipws(ptr);
 670         if (srprs_quoted(ptr, ost)) {
 671                 ret.dsize = cbuf_getpos(ost);
 672                 ret.dptr = (uint8_t *)talloc_steal(mem_ctx, cbuf_gets(ost,0));
 673         }
 674         talloc_free(ost);
 675         return ret;
 676 }
 677
 678 static int traverse_print_diff(struct db_record *rec, void* data) {
 679         struct check_ctx* ctx = (struct check_ctx*)data;
 680         TDB_DATA key;
 681         TDB_DATA value;
 682         TDB_DATA_diff diff;
 683         TALLOC_CTX* mem = talloc_new(ctx->diff);
 684
 685         key = dbwrap_record_get_key(rec);
 686         value = dbwrap_record_get_value(rec);
 687         diff = unpack_diff(value);
 688
 689         DEBUG_DIFF(0, mem, "DIFF", key, diff.oval, diff.nval);
 690
 691         talloc_free(mem);
 692         return 0;
 693 }
 694
 695
 696 static int traverse_commit(struct db_record *diff_rec, void* data) {
 697         struct check_ctx* ctx = (struct check_ctx*)data;
 698         TDB_DATA key;
 699         TDB_DATA diff_value;
 700         TDB_DATA_diff diff;
 701         TDB_DATA value;
 702         TALLOC_CTX* mem = talloc_new(ctx->diff);
 703         int ret = -1;
 704         NTSTATUS status;
 705         struct check_actions* act = &ctx->action;
 706         struct db_record* rec;
 707
 708         key = dbwrap_record_get_key(diff_rec);
 709         diff_value = dbwrap_record_get_value(diff_rec);
 710         diff = unpack_diff(diff_value);
 711
 712         rec = dbwrap_fetch_locked(ctx->db, mem, key);
 713         if (rec == NULL) {
 714                 goto done;
 715         }
 716
 717         value = dbwrap_record_get_value(rec);
 718
 719         if (!tdb_data_equal(value, diff.oval)) {
 720                 char action;
 721
 722                 d_printf("Warning: record has changed: %s\n"
 723                          "expected: %s got %s\n", print_data(mem, key),
 724                          print_data(mem, diff.oval),
 725                          print_data(mem, value));
 726
 727                 action = get_action(&act->invalid_diff, NULL, NULL);
 728                 if (action == 's') {
 729                         ret = 0;
 730                         goto done;
 731                 } else if (action == 'a') {
 732                         goto done;
 733                 }
 734         }
 735
 736         DEBUG_DIFF(0, mem, "Commit", key, diff.oval, diff.nval);
 737
 738         if (tdb_data_is_empty(diff.nval)) {
 739                 status = dbwrap_record_delete(rec);
 740         } else {
 741                 status = dbwrap_record_store(rec, diff.nval, 0);
 742         }
 743
 744         if (!NT_STATUS_IS_OK(status)) {
 745                 DEBUG(0, ("could not store record %s\n", nt_errstr(status)));
 746                 if (!ctx->opts.force) {
 747                         goto done;
 748                 }
 749         }
 750         ret = 0;
 751 done:
 752         talloc_free(mem);
 753         return  ret;
 754 }
 755
 756 static struct check_ctx*
 757 check_init(TALLOC_CTX* mem_ctx, const struct check_options* o)
 758 {
 759         struct check_ctx* ctx = talloc_zero(mem_ctx, struct check_ctx);
 760         if (ctx == NULL) {
 761                 DEBUG(0, (_("No memory\n")));
 762                 return NULL;
 763         }
 764
 765         ctx->diff = db_open_rbt(ctx);
 766         if (ctx->diff == NULL) {
 767                 talloc_free(ctx);
 768                 DEBUG(0, (_("No memory\n")));
 769                 return NULL;
 770         }
 771
 772         ctx->action = check_actions_init(o);
 773         ctx->opts = *o;
 774         return ctx;
 775 }
 776
 777 static bool check_open_db(struct check_ctx* ctx, const char* name, int oflags)
 778 {
 779         if (name == NULL) {
 780                 d_fprintf(stderr, _("Error: name == NULL in check_open_db().\n"));
 781                 return false;
 782         }
 783
 784         if (ctx->db != NULL) {
 785                 if ((ctx->oflags == oflags) && (strcmp(ctx->name, name))) {
 786                         return true;
 787                 } else {
 788                         TALLOC_FREE(ctx->db);
 789                 }
 790         }
 791
 792         ctx->db = db_open(ctx, name, 0, TDB_DEFAULT, oflags, 0,
 793                           DBWRAP_LOCK_ORDER_1);
 794         if (ctx->db == NULL) {
 795                 d_fprintf(stderr,
 796                           _("Could not open idmap db (%s) for writing: %s\n"),
 797                           name, strerror(errno));
 798                 return false;
 799         }
 800
 801         if (ctx->name != name) {
 802                 TALLOC_FREE(ctx->name);
 803                 ctx->name = talloc_strdup(ctx, name);
 804         }
 805
 806         ctx->oflags = oflags;
 807         return true;
 808 }
 809
 810 static bool check_do_checks(struct check_ctx* ctx)
 811 {
 812         NTSTATUS status;
 813
 814         if (!check_version(ctx)) {
 815                 return false;
 816         }
 817
 818         status = dbwrap_traverse(ctx->db, traverse_check, ctx, NULL);
 819
 820         if (!NT_STATUS_IS_OK(status)) {
 821                 DEBUG(0, ("failed to traverse %s\n", ctx->name));
 822                 return false;
 823         }
 824
 825         check_hwm(ctx, "USER HWM", ctx->uid_hwm + 1);
 826         check_hwm(ctx, "GROUP HWM", ctx->gid_hwm + 1);
 827
 828         return true;
 829 }
 830
 831 static void check_summary(const struct check_ctx* ctx)
 832 {
 833         d_printf("uid hwm: %d\ngid hwm: %d\n", ctx->uid_hwm, ctx->gid_hwm);
 834         d_printf("mappings: %d\nother: %d\n", ctx->n_map, ctx->n_other);
 835         d_printf("invalid records: %d\nmissing links: %d\ninvalid links: %d\n",
 836                  ctx->n_invalid_record, ctx->n_missing_reverse,
 837                  ctx->n_invalid_mappping);
 838         d_printf("%u changes:\n", ctx->n_diff);
 839 }
 840
 841 static bool check_transaction_start(struct check_ctx* ctx) {
 842         return (dbwrap_transaction_start(ctx->db) == 0);
 843 }
 844
 845 static bool check_transaction_commit(struct check_ctx* ctx) {
 846         return (dbwrap_transaction_commit(ctx->db) == 0);
 847 }
 848
 849 static bool check_transaction_cancel(struct check_ctx* ctx) {
 850         return (dbwrap_transaction_cancel(ctx->db) == 0);
 851 }
 852
 853
 854 static void check_diff_list(struct check_ctx* ctx) {
 855         NTSTATUS status = dbwrap_traverse(ctx->diff, traverse_print_diff, ctx, NULL);
 856
 857         if (!NT_STATUS_IS_OK(status)) {
 858                 DEBUG(0, ("failed to traverse diff\n"));
 859         }
 860
 861 }
 862
 863 static bool check_commit(struct check_ctx* ctx)
 864 {
 865         struct check_actions* act = &ctx->action;
 866         char action;
 867         NTSTATUS status = NT_STATUS_OK;
 868
 869         check_summary(ctx);
 870
 871         if (ctx->n_diff == 0) {
 872                 return true;
 873         }
 874
 875         while ((action = get_action(&act->commit, NULL, NULL)) == 'l') {
 876                 check_diff_list(ctx);
 877         }
 878         if (action == 's') {
 879                 return true;
 880         }
 881         assert(action == 'c');
 882
 883         if (!check_open_db(ctx, ctx->name, O_RDWR)) {
 884                 return false;
 885         }
 886
 887         if (!check_transaction_start(ctx)) {
 888                 return false;
 889         }
 890
 891         status = dbwrap_traverse(ctx->diff, traverse_commit, ctx, NULL);
 892
 893         if (!NT_STATUS_IS_OK(status)) {
 894                 check_transaction_cancel(ctx);
 895                 return false;
 896         }
 897         if (ctx->opts.test) { /*get_action? */
 898                 return check_transaction_cancel(ctx);
 899         } else {
 900                 return check_transaction_commit(ctx);
 901         }
 902 }
 903
 904 int net_idmap_check_db(const char* db, const struct check_options* o)
 905 {
 906         int ret = -1;
 907         TALLOC_CTX* mem_ctx = talloc_stackframe();
 908         struct check_ctx* ctx = check_init(mem_ctx, o);
 909
 910         if (!o->automatic && !isatty(STDIN_FILENO)) {
 911                 DEBUG(0, ("Interactive use needs tty, use --auto\n"));
 912                 goto done;
 913         }
 914         if (o->lock) {
 915                 if (check_open_db(ctx, db, O_RDWR)
 916                     && check_transaction_start(ctx))
 917                 {
 918                         if ( check_do_checks(ctx)
 919                              && check_commit(ctx)
 920                              && check_transaction_commit(ctx))
 921                         {
 922                                 ret = 0;
 923                         } else {
 924                                 check_transaction_cancel(ctx);
 925                         }
 926                 }
 927         } else {
 928                 if (check_open_db(ctx, db, O_RDONLY)
 929                     && check_do_checks(ctx)
 930                     && check_commit(ctx))
 931                 {
 932                         ret = 0;
 933                 }
 934         }
 935 done:
 936         talloc_free(mem_ctx);
 937         return ret;
 938 }
 939
 940
 941 /*Local Variables:*/
 942 /*mode: c*/
 943 /*End:*/