git.sur5r.net Git - bacula/bacula/blob - bacula/src/tools/dbcheck.c

   1 /*
   2  *
   3  *  Program to check a Bacula database for consistency and to
   4  *   make repairs
   5  *
   6  *   Kern E. Sibbald, August 2002
   7  *
   8  *   Version $Id$
   9  *
  10  */
  11 /*
  12    Copyright (C) 2002-2004 Kern Sibbald and John Walker
  13
  14    This program is free software; you can redistribute it and/or
  15    modify it under the terms of the GNU General Public License as
  16    published by the Free Software Foundation; either version 2 of
  17    the License, or (at your option) any later version.
  18
  19    This program is distributed in the hope that it will be useful,
  20    but WITHOUT ANY WARRANTY; without even the implied warranty of
  21    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  22    General Public License for more details.
  23
  24    You should have received a copy of the GNU General Public
  25    License along with this program; if not, write to the Free
  26    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  27    MA 02111-1307, USA.
  28
  29  */
  30
  31 #include "bacula.h"
  32 #include "cats/cats.h"
  33 #include "dird/dird_conf.h"
  34
  35 typedef struct s_id_ctx {
  36    uint32_t *Id;                      /* ids to be modified */
  37    int num_ids;                       /* ids stored */
  38    int max_ids;                       /* size of array */
  39    int num_del;                       /* number deleted */
  40    int tot_ids;                       /* total to process */
  41 } ID_LIST;
  42
  43 typedef struct s_name_ctx {
  44    char **name;                       /* list of names */
  45    int num_ids;                       /* ids stored */
  46    int max_ids;                       /* size of array */
  47    int num_del;                       /* number deleted */
  48    int tot_ids;                       /* total to process */
  49 } NAME_LIST;
  50
  51
  52
  53 /* Global variables */
  54 static bool fix = false;
  55 static bool batch = false;
  56 static B_DB *db;
  57 static ID_LIST id_list;
  58 static NAME_LIST name_list;
  59 static char buf[2000];
  60
  61 #define MAX_ID_LIST_LEN 10000000
  62
  63 /* Forward referenced functions */
  64 static int make_id_list(const char *query, ID_LIST *id_list);
  65 static int delete_id_list(const char *query, ID_LIST *id_list);
  66 static int make_name_list(const char *query, NAME_LIST *name_list);
  67 static void print_name_list(NAME_LIST *name_list);
  68 static void free_name_list(NAME_LIST *name_list);
  69 static char *get_cmd(const char *prompt);
  70 static void eliminate_duplicate_filenames();
  71 static void eliminate_duplicate_paths();
  72 static void eliminate_orphaned_jobmedia_records();
  73 static void eliminate_orphaned_file_records();
  74 static void eliminate_orphaned_path_records();
  75 static void eliminate_orphaned_filename_records();
  76 static void eliminate_orphaned_fileset_records();
  77 static void eliminate_orphaned_client_records();
  78 static void eliminate_orphaned_job_records();
  79 static void eliminate_admin_records();
  80 static void eliminate_restore_records();
  81 static void repair_bad_paths();
  82 static void repair_bad_filenames();
  83 static void do_interactive_mode();
  84 static int yes_no(const char *prompt);
  85
  86
  87 static void usage()
  88 {
  89    fprintf(stderr,
  90 "Usage: dbcheck [-c config] [-C catalog name] [-d debug_level] <working-directory> <bacula-database> <user> <password> [<dbhost>]\n"
  91 "       -b              batch mode\n"
  92 "       -C              catalog name in the director conf file\n"
  93 "       -c              director conf filename\n"
  94 "       -dnn            set debug level to nn\n"
  95 "       -f              fix inconsistencies\n"
  96 "       -v              verbose\n"
  97 "       -?              print this message\n\n");
  98    exit(1);
  99 }
 100
 101 int main (int argc, char *argv[])
 102 {
 103    int ch;
 104    const char *user, *password, *db_name, *dbhost;
 105    char *configfile = NULL;
 106    char *catalogname = NULL;
 107
 108    my_name_is(argc, argv, "dbcheck");
 109    init_msg(NULL, NULL);              /* setup message handler */
 110
 111    memset(&id_list, 0, sizeof(id_list));
 112    memset(&name_list, 0, sizeof(name_list));
 113
 114
 115    while ((ch = getopt(argc, argv, "bc:C:d:fv?")) != -1) {
 116       switch (ch) {
 117       case 'b':                    /* batch */
 118          batch = true;
 119          break;
 120
 121       case 'C':                    /* CatalogName */
 122           catalogname = optarg;
 123          break;
 124
 125       case 'c':                    /* configfile */
 126           configfile = optarg;
 127          break;
 128
 129       case 'd':                    /* debug level */
 130          debug_level = atoi(optarg);
 131          if (debug_level <= 0)
 132             debug_level = 1;
 133          break;
 134
 135       case 'f':                    /* fix inconsistencies */
 136          fix = true;
 137          break;
 138
 139       case 'v':
 140          verbose++;
 141          break;
 142
 143       case '?':
 144       default:
 145          usage();
 146       }
 147    }
 148    argc -= optind;
 149    argv += optind;
 150
 151    if (configfile) {
 152       CAT *catalog = NULL;
 153       int found = 0;
 154       if (argc > 0) {
 155          Pmsg0(0, _("Warning skipping the additional parameters for working directory/dbname/user/password/host.\n"));
 156       }
 157       parse_config(configfile);
 158       LockRes();
 159       foreach_res(catalog, R_CATALOG) {
 160          if (catalogname && !strcmp(catalog->hdr.name, catalogname)) {
 161             ++found;
 162             break;
 163          } else if (!catalogname) { // stop on first if no catalogname is given
 164            ++found;
 165            break;
 166          }
 167       }
 168       UnlockRes();
 169       if (!found) {
 170          if (catalogname) {
 171             Pmsg2(0, "Error can not find the Catalog name[%s] in the given config file [%s]\n", catalogname, configfile);
 172          } else {
 173             Pmsg1(0, "Error there is no Catalog section in the given config file [%s]\n", configfile);
 174          }
 175          exit(1);
 176       } else {
 177          DIRRES *director;
 178          LockRes();
 179          director = (DIRRES *)GetNextRes(R_DIRECTOR, NULL);
 180          UnlockRes();
 181          if (!director) {
 182             Pmsg0(0, "Error no Director resource defined.\n");
 183             exit(1);
 184          }
 185          set_working_directory(director->working_directory);
 186          db_name = catalog->db_name;
 187          user = catalog->db_user;
 188          password = catalog->db_password;
 189          dbhost = catalog->db_address;
 190          if (dbhost && dbhost[0] == 0) {
 191             dbhost = NULL;
 192          }
 193       }
 194    } else {
 195       if (argc > 5) {
 196          Pmsg0(0, _("Wrong number of arguments.\n"));
 197          usage();
 198       }
 199
 200       if (argc < 1) {
 201          Pmsg0(0, _("Working directory not supplied.\n"));
 202          usage();
 203       }
 204
 205       /* This is needed by SQLite to find the db */
 206       working_directory = argv[0];
 207       db_name = "bacula";
 208       user = db_name;
 209       password = "";
 210       dbhost = NULL;
 211
 212       if (argc == 2) {
 213          db_name = argv[1];
 214          user = db_name;
 215       } else if (argc == 3) {
 216          db_name = argv[1];
 217          user = argv[2];
 218       } else if (argc == 4) {
 219          db_name = argv[1];
 220          user = argv[2];
 221          password = argv[3];
 222       } else if (argc == 5) {
 223          db_name = argv[1];
 224          user = argv[2];
 225          password = argv[3];
 226          dbhost = argv[4];
 227       }
 228    }
 229
 230    /* Open database */
 231    db = db_init_database(NULL, db_name, user, password, dbhost, 0, NULL, 0);
 232    if (!db_open_database(NULL, db)) {
 233       Emsg1(M_FATAL, 0, "%s", db_strerror(db));
 234           return 1;
 235    }
 236
 237    if (batch) {
 238       repair_bad_paths();
 239       repair_bad_filenames();
 240       eliminate_duplicate_filenames();
 241       eliminate_duplicate_paths();
 242       eliminate_orphaned_jobmedia_records();
 243       eliminate_orphaned_file_records();
 244       eliminate_orphaned_path_records();
 245       eliminate_orphaned_filename_records();
 246       eliminate_orphaned_fileset_records();
 247       eliminate_orphaned_client_records();
 248       eliminate_orphaned_job_records();
 249       eliminate_admin_records();
 250       eliminate_restore_records();
 251    } else {
 252       do_interactive_mode();
 253    }
 254
 255    db_close_database(NULL, db);
 256    close_msg(NULL);
 257    term_msg();
 258    return 0;
 259 }
 260
 261 static void do_interactive_mode()
 262 {
 263    bool quit = false;
 264    const char *cmd;
 265
 266    printf("Hello, this is the database check/correct program.\n\
 267 Modify database is %s. Verbose is %s.\n\
 268 Please select the fuction you want to perform.\n",
 269           fix?"On":"Off", verbose?"On":"Off");
 270
 271    while (!quit) {
 272       if (fix) {
 273          printf(_("\n\
 274      1) Toggle modify database flag\n\
 275      2) Toggle verbose flag\n\
 276      3) Repair bad Filename records\n\
 277      4) Repair bad Path records\n\
 278      5) Eliminate duplicate Filename records\n\
 279      6) Eliminate duplicate Path records\n\
 280      7) Eliminate orphaned Jobmedia records\n\
 281      8) Eliminate orphaned File records\n\
 282      9) Eliminate orphaned Path records\n\
 283     10) Eliminate orphaned Filename records\n\
 284     11) Eliminate orphaned FileSet records\n\
 285     12) Eliminate orphaned Client records\n\
 286     13) Eliminate orphaned Job records\n\
 287     14) Eliminate all Admin records\n\
 288     15) Eliminate all Restore records\n\
 289     16) All (3-15)\n\
 290     17) Quit\n"));
 291        } else {
 292          printf(_("\n\
 293      1) Toggle modify database flag\n\
 294      2) Toggle verbose flag\n\
 295      3) Check for bad Filename records\n\
 296      4) Check for bad Path records\n\
 297      5) Check for duplicate Filename records\n\
 298      6) Check for duplicate Path records\n\
 299      7) Check for orphaned Jobmedia records\n\
 300      8) Check for orphaned File records\n\
 301      9) Check for orphaned Path records\n\
 302     10) Check for orphaned Filename records\n\
 303     11) Check for orphaned FileSet records\n\
 304     12) Check for orphaned Client records\n\
 305     13) Check for orphaned Job records\n\
 306     14) Check for all Admin records\n\
 307     15) Check for all Restore records\n\
 308     16) All (3-15)\n\
 309     17) Quit\n"));
 310        }
 311
 312       cmd = get_cmd(_("Select function number: "));
 313       if (cmd) {
 314          int item = atoi(cmd);
 315          switch (item) {
 316          case 1:
 317             fix = !fix;
 318             printf(_("Database will %sbe modified.\n"), fix?"":_("NOT "));
 319             break;
 320          case 2:
 321             verbose = verbose?0:1;
 322             printf(_("Verbose is %s\n"), verbose?_("On"):_("Off"));
 323             break;
 324          case 3:
 325             repair_bad_filenames();
 326             break;
 327          case 4:
 328             repair_bad_paths();
 329             break;
 330          case 5:
 331             eliminate_duplicate_filenames();
 332             break;
 333          case 6:
 334             eliminate_duplicate_paths();
 335             break;
 336          case 7:
 337             eliminate_orphaned_jobmedia_records();
 338             break;
 339          case 8:
 340             eliminate_orphaned_file_records();
 341             break;
 342          case 9:
 343             eliminate_orphaned_path_records();
 344             break;
 345          case 10:
 346             eliminate_orphaned_filename_records();
 347             break;
 348          case 11:
 349             eliminate_orphaned_fileset_records();
 350             break;
 351          case 12:
 352             eliminate_orphaned_client_records();
 353             break;
 354          case 13:
 355             eliminate_orphaned_job_records();
 356             break;
 357          case 14:
 358             eliminate_admin_records();
 359             break;
 360          case 15:
 361             eliminate_restore_records();
 362             break;
 363          case 16:
 364             repair_bad_filenames();
 365             repair_bad_paths();
 366             eliminate_duplicate_filenames();
 367             eliminate_duplicate_paths();
 368             eliminate_orphaned_jobmedia_records();
 369             eliminate_orphaned_file_records();
 370             eliminate_orphaned_path_records();
 371             eliminate_orphaned_filename_records();
 372             eliminate_orphaned_fileset_records();
 373             eliminate_orphaned_client_records();
 374             eliminate_orphaned_job_records();
 375             eliminate_admin_records();
 376             eliminate_restore_records();
 377             break;
 378          case 17:
 379             quit = true;
 380             break;
 381          }
 382       }
 383    }
 384 }
 385
 386 static int print_name_handler(void *ctx, int num_fields, char **row)
 387 {
 388    if (row[0]) {
 389       printf("%s\n", row[0]);
 390    }
 391    return 0;
 392 }
 393
 394 static int get_name_handler(void *ctx, int num_fields, char **row)
 395 {
 396    POOLMEM *buf = (POOLMEM *)ctx;
 397    if (row[0]) {
 398       pm_strcpy(&buf, row[0]);
 399    }
 400    return 0;
 401 }
 402
 403 static int print_job_handler(void *ctx, int num_fields, char **row)
 404 {
 405    printf(_("JobId=%s Name=\"%s\" StartTime=%s\n"),
 406               NPRT(row[0]), NPRT(row[1]), NPRT(row[2]));
 407    return 0;
 408 }
 409
 410
 411 static int print_jobmedia_handler(void *ctx, int num_fields, char **row)
 412 {
 413    printf(_("Orphaned JobMediaId=%s JobId=%s Volume=\"%s\"\n"),
 414               NPRT(row[0]), NPRT(row[1]), NPRT(row[2]));
 415    return 0;
 416 }
 417
 418 static int print_file_handler(void *ctx, int num_fields, char **row)
 419 {
 420    printf(_("Orphaned FileId=%s JobId=%s Volume=\"%s\"\n"),
 421               NPRT(row[0]), NPRT(row[1]), NPRT(row[2]));
 422    return 0;
 423 }
 424
 425 static int print_fileset_handler(void *ctx, int num_fields, char **row)
 426 {
 427    printf(_("Orphaned FileSetId=%s FileSet=\"%s\" MD5=%s\n"),
 428               NPRT(row[0]), NPRT(row[1]), NPRT(row[2]));
 429    return 0;
 430 }
 431
 432 static int print_client_handler(void *ctx, int num_fields, char **row)
 433 {
 434    printf(_("Orphaned ClientId=%s Name=\"%s\"\n"),
 435               NPRT(row[0]), NPRT(row[1]));
 436    return 0;
 437 }
 438
 439
 440 /*
 441  * Called here with each id to be added to the list
 442  */
 443 static int id_list_handler(void *ctx, int num_fields, char **row)
 444 {
 445    ID_LIST *lst = (ID_LIST *)ctx;
 446
 447    if (lst->num_ids == MAX_ID_LIST_LEN) {
 448       return 1;
 449    }
 450    if (lst->num_ids == lst->max_ids) {
 451       if (lst->max_ids == 0) {
 452          lst->max_ids = 1000;
 453          lst->Id = (uint32_t *)bmalloc(sizeof(uint32_t) * lst->max_ids);
 454       } else {
 455          lst->max_ids = (lst->max_ids * 3) / 2;
 456          lst->Id = (uint32_t *)brealloc(lst->Id, sizeof(uint32_t) * lst->max_ids);
 457       }
 458    }
 459    lst->Id[lst->num_ids++] = (uint32_t)strtod(row[0], NULL);
 460    return 0;
 461 }
 462
 463 /*
 464  * Construct record id list
 465  */
 466 static int make_id_list(const char *query, ID_LIST *id_list)
 467 {
 468    id_list->num_ids = 0;
 469    id_list->num_del = 0;
 470    id_list->tot_ids = 0;
 471
 472    if (!db_sql_query(db, query, id_list_handler, (void *)id_list)) {
 473       printf("%s", db_strerror(db));
 474       return 0;
 475    }
 476    return 1;
 477 }
 478
 479 /*
 480  * Delete all entries in the list
 481  */
 482 static int delete_id_list(const char *query, ID_LIST *id_list)
 483 {
 484    for (int i=0; i < id_list->num_ids; i++) {
 485       bsnprintf(buf, sizeof(buf), query, id_list->Id[i]);
 486       if (verbose) {
 487          printf("Deleting: %s\n", buf);
 488       }
 489       db_sql_query(db, buf, NULL, NULL);
 490    }
 491    return 1;
 492 }
 493
 494 /*
 495  * Called here with each name to be added to the list
 496  */
 497 static int name_list_handler(void *ctx, int num_fields, char **row)
 498 {
 499    NAME_LIST *name = (NAME_LIST *)ctx;
 500
 501    if (name->num_ids == MAX_ID_LIST_LEN) {
 502       return 1;
 503    }
 504    if (name->num_ids == name->max_ids) {
 505       if (name->max_ids == 0) {
 506          name->max_ids = 1000;
 507          name->name = (char **)bmalloc(sizeof(char *) * name->max_ids);
 508       } else {
 509          name->max_ids = (name->max_ids * 3) / 2;
 510          name->name = (char **)brealloc(name->name, sizeof(char *) * name->max_ids);
 511       }
 512    }
 513    name->name[name->num_ids++] = bstrdup(row[0]);
 514    return 0;
 515 }
 516
 517
 518 /*
 519  * Construct name list
 520  */
 521 static int make_name_list(const char *query, NAME_LIST *name_list)
 522 {
 523    name_list->num_ids = 0;
 524    name_list->num_del = 0;
 525    name_list->tot_ids = 0;
 526
 527    if (!db_sql_query(db, query, name_list_handler, (void *)name_list)) {
 528       printf("%s", db_strerror(db));
 529       return 0;
 530    }
 531    return 1;
 532 }
 533
 534 /*
 535  * Print names in the list
 536  */
 537 static void print_name_list(NAME_LIST *name_list)
 538 {
 539    for (int i=0; i < name_list->num_ids; i++) {
 540       printf("%s\n", name_list->name[i]);
 541    }
 542 }
 543
 544
 545 /*
 546  * Free names in the list
 547  */
 548 static void free_name_list(NAME_LIST *name_list)
 549 {
 550    for (int i=0; i < name_list->num_ids; i++) {
 551       free(name_list->name[i]);
 552    }
 553    name_list->num_ids = 0;
 554 }
 555
 556 static void eliminate_duplicate_filenames()
 557 {
 558    const char *query;
 559    char esc_name[5000];
 560
 561    printf("Checking for duplicate Filename entries.\n");
 562
 563    /* Make list of duplicated names */
 564    query = "SELECT Name, count(Name) as Count FROM Filename GROUP BY  Name "
 565            "HAVING count(Name) > 1";
 566
 567    if (!make_name_list(query, &name_list)) {
 568       exit(1);
 569    }
 570    printf("Found %d duplicate Filename records.\n", name_list.num_ids);
 571    if (name_list.num_ids && verbose && yes_no("Print the list? (yes/no): ")) {
 572       print_name_list(&name_list);
 573    }
 574    if (fix) {
 575       /* Loop through list of duplicate names */
 576       for (int i=0; i<name_list.num_ids; i++) {
 577          /* Get all the Ids of each name */
 578          db_escape_string(esc_name, name_list.name[i], strlen(name_list.name[i]));
 579          bsnprintf(buf, sizeof(buf), "SELECT FilenameId FROM Filename WHERE Name='%s'", esc_name);
 580          if (verbose > 1) {
 581             printf("%s\n", buf);
 582          }
 583          if (!make_id_list(buf, &id_list)) {
 584             exit(1);
 585          }
 586          if (verbose) {
 587             printf("Found %d for: %s\n", id_list.num_ids, name_list.name[i]);
 588          }
 589          /* Force all records to use the first id then delete the other ids */
 590          for (int j=1; j<id_list.num_ids; j++) {
 591             bsnprintf(buf, sizeof(buf), "UPDATE File SET FilenameId=%u WHERE FilenameId=%u",
 592                id_list.Id[0], id_list.Id[j]);
 593             if (verbose > 1) {
 594                printf("%s\n", buf);
 595             }
 596             db_sql_query(db, buf, NULL, NULL);
 597             bsnprintf(buf, sizeof(buf), "DELETE FROM Filename WHERE FilenameId=%u",
 598                id_list.Id[j]);
 599             if (verbose > 2) {
 600                printf("%s\n", buf);
 601             }
 602             db_sql_query(db, buf, NULL, NULL);
 603          }
 604       }
 605    }
 606    free_name_list(&name_list);
 607 }
 608
 609 static void eliminate_duplicate_paths()
 610 {
 611    const char *query;
 612    char esc_name[5000];
 613
 614    printf(_("Checking for duplicate Path entries.\n"));
 615
 616    /* Make list of duplicated names */
 617
 618    query = "SELECT Path, count(Path) as Count FROM Path "
 619            "GROUP BY Path HAVING count(Path) > 1";
 620
 621    if (!make_name_list(query, &name_list)) {
 622       exit(1);
 623    }
 624    printf("Found %d duplicate Path records.\n", name_list.num_ids);
 625    if (name_list.num_ids && verbose && yes_no("Print them? (yes/no): ")) {
 626       print_name_list(&name_list);
 627    }
 628    if (fix) {
 629       /* Loop through list of duplicate names */
 630       for (int i=0; i<name_list.num_ids; i++) {
 631          /* Get all the Ids of each name */
 632          db_escape_string(esc_name, name_list.name[i], strlen(name_list.name[i]));
 633          bsnprintf(buf, sizeof(buf), "SELECT PathId FROM Path WHERE Path='%s'", esc_name);
 634          if (verbose > 1) {
 635             printf("%s\n", buf);
 636          }
 637          if (!make_id_list(buf, &id_list)) {
 638             exit(1);
 639          }
 640          if (verbose) {
 641             printf("Found %d for: %s\n", id_list.num_ids, name_list.name[i]);
 642          }
 643          /* Force all records to use the first id then delete the other ids */
 644          for (int j=1; j<id_list.num_ids; j++) {
 645             bsnprintf(buf, sizeof(buf), "UPDATE File SET PathId=%u WHERE PathId=%u",
 646                id_list.Id[0], id_list.Id[j]);
 647             if (verbose > 1) {
 648                printf("%s\n", buf);
 649             }
 650             db_sql_query(db, buf, NULL, NULL);
 651             bsnprintf(buf, sizeof(buf), "DELETE FROM Path WHERE PathId=%u",
 652                id_list.Id[j]);
 653             if (verbose > 2) {
 654                printf("%s\n", buf);
 655             }
 656             db_sql_query(db, buf, NULL, NULL);
 657          }
 658       }
 659    }
 660    free_name_list(&name_list);
 661 }
 662
 663 static void eliminate_orphaned_jobmedia_records()
 664 {
 665    const char *query;
 666
 667    printf("Checking for orphaned JobMedia entries.\n");
 668    query = "SELECT JobMedia.JobMediaId,Job.JobId FROM JobMedia "
 669            "LEFT OUTER JOIN Job ON (JobMedia.JobId=Job.JobId) "
 670            "WHERE Job.JobId IS NULL";
 671    if (!make_id_list(query, &id_list)) {
 672       exit(1);
 673    }
 674    printf("Found %d orphaned JobMedia records.\n", id_list.num_ids);
 675    if (id_list.num_ids && verbose && yes_no("Print them? (yes/no): ")) {
 676       for (int i=0; i < id_list.num_ids; i++) {
 677          bsnprintf(buf, sizeof(buf),
 678 "SELECT JobMedia.JobMediaId,JobMedia.JobId,Media.VolumeName FROM JobMedia,Media "
 679 "WHERE JobMedia.JobMediaId=%u AND Media.MediaId=JobMedia.MediaId", id_list.Id[i]);
 680          if (!db_sql_query(db, buf, print_jobmedia_handler, NULL)) {
 681             printf("%s\n", db_strerror(db));
 682          }
 683       }
 684    }
 685
 686    if (fix && id_list.num_ids > 0) {
 687       printf("Deleting %d orphaned JobMedia records.\n", id_list.num_ids);
 688       delete_id_list("DELETE FROM JobMedia WHERE JobMediaId=%u", &id_list);
 689    }
 690 }
 691
 692 static void eliminate_orphaned_file_records()
 693 {
 694    const char *query;
 695
 696    printf("Checking for orphaned File entries. This may take some time!\n");
 697    query = "SELECT File.FileId,Job.JobId FROM File "
 698            "LEFT OUTER JOIN Job ON (File.JobId=Job.JobId) "
 699            "WHERE Job.JobId IS NULL";
 700    if (verbose > 1) {
 701       printf("%s\n", query);
 702    }
 703    if (!make_id_list(query, &id_list)) {
 704       exit(1);
 705    }
 706    printf("Found %d orphaned File records.\n", id_list.num_ids);
 707    if (name_list.num_ids && verbose && yes_no("Print them? (yes/no): ")) {
 708       for (int i=0; i < id_list.num_ids; i++) {
 709          bsnprintf(buf, sizeof(buf),
 710 "SELECT File.FileId,File.JobId,Filename.Name FROM File,Filename "
 711 "WHERE File.FileId=%u AND File.FilenameId=Filename.FilenameId", id_list.Id[i]);
 712          if (!db_sql_query(db, buf, print_file_handler, NULL)) {
 713             printf("%s\n", db_strerror(db));
 714          }
 715       }
 716    }
 717
 718    if (fix && id_list.num_ids > 0) {
 719       printf("Deleting %d orphaned File records.\n", id_list.num_ids);
 720       delete_id_list("DELETE FROM File WHERE FileId=%u", &id_list);
 721    }
 722 }
 723
 724 static void eliminate_orphaned_path_records()
 725 {
 726    const char *query;
 727
 728    printf("Checking for orphaned Path entries. This may take some time!\n");
 729    query = "SELECT DISTINCT Path.PathId,File.PathId FROM Path "
 730            "LEFT OUTER JOIN File ON (Path.PathId=File.PathId) "
 731            "WHERE File.PathId IS NULL";
 732    if (verbose > 1) {
 733       printf("%s\n", query);
 734    }
 735    if (!make_id_list(query, &id_list)) {
 736       exit(1);
 737    }
 738    printf("Found %d orphaned Path records.\n", id_list.num_ids);
 739    if (id_list.num_ids && verbose && yes_no("Print them? (yes/no): ")) {
 740       for (int i=0; i < id_list.num_ids; i++) {
 741          bsnprintf(buf, sizeof(buf), "SELECT Path FROM Path WHERE PathId=%u", id_list.Id[i]);
 742          db_sql_query(db, buf, print_name_handler, NULL);
 743       }
 744    }
 745
 746    if (fix && id_list.num_ids > 0) {
 747       printf("Deleting %d orphaned Path records.\n", id_list.num_ids);
 748       delete_id_list("DELETE FROM Path WHERE PathId=%u", &id_list);
 749    }
 750 }
 751
 752 static void eliminate_orphaned_filename_records()
 753 {
 754    const char *query;
 755
 756    printf("Checking for orphaned Filename entries. This may take some time!\n");
 757    query = "SELECT Filename.FilenameId,File.FilenameId FROM Filename "
 758            "LEFT OUTER JOIN File ON (Filename.FilenameId=File.FilenameId) "
 759            "WHERE File.FilenameId IS NULL";
 760    if (verbose > 1) {
 761       printf("%s\n", query);
 762    }
 763    if (!make_id_list(query, &id_list)) {
 764       exit(1);
 765    }
 766    printf("Found %d orphaned Filename records.\n", id_list.num_ids);
 767    if (id_list.num_ids && verbose && yes_no("Print them? (yes/no): ")) {
 768       for (int i=0; i < id_list.num_ids; i++) {
 769          bsnprintf(buf, sizeof(buf), "SELECT Name FROM Filename WHERE FilenameId=%u", id_list.Id[i]);
 770          db_sql_query(db, buf, print_name_handler, NULL);
 771       }
 772    }
 773
 774    if (fix && id_list.num_ids > 0) {
 775       printf("Deleting %d orphaned Filename records.\n", id_list.num_ids);
 776       delete_id_list("DELETE FROM Filename WHERE FilenameId=%u", &id_list);
 777    }
 778 }
 779
 780 static void eliminate_orphaned_fileset_records()
 781 {
 782    const char *query;
 783
 784    printf("Checking for orphaned FileSet entries. This takes some time!\n");
 785    query = "SELECT FileSet.FileSetId,Job.FileSetId FROM FileSet "
 786            "LEFT OUTER JOIN Job ON (FileSet.FileSetId=Job.FileSetId) "
 787            "WHERE Job.FileSetId IS NULL";
 788    if (verbose > 1) {
 789       printf("%s\n", query);
 790    }
 791    if (!make_id_list(query, &id_list)) {
 792       exit(1);
 793    }
 794    printf("Found %d orphaned FileSet records.\n", id_list.num_ids);
 795    if (id_list.num_ids && verbose && yes_no("Print them? (yes/no): ")) {
 796       for (int i=0; i < id_list.num_ids; i++) {
 797          bsnprintf(buf, sizeof(buf), "SELECT FileSetId,FileSet,MD5 FROM FileSet "
 798                       "WHERE FileSetId=%u", id_list.Id[i]);
 799          if (!db_sql_query(db, buf, print_fileset_handler, NULL)) {
 800             printf("%s\n", db_strerror(db));
 801          }
 802       }
 803    }
 804
 805    if (fix && id_list.num_ids > 0) {
 806       printf("Deleting %d orphaned FileSet records.\n", id_list.num_ids);
 807       delete_id_list("DELETE FROM FileSet WHERE FileSetId=%u", &id_list);
 808    }
 809 }
 810
 811 static void eliminate_orphaned_client_records()
 812 {
 813    const char *query;
 814
 815    printf("Checking for orphaned Client entries.\n");
 816    /* In English:
 817     *   Wiffle through Client for every Client
 818     *   joining with the Job table including every Client even if
 819     *   there is not a match in Job (left outer join), then
 820     *   filter out only those where no Job points to a Client
 821     *   i.e. Job.Client is NULL
 822     */
 823    query = "SELECT Client.ClientId,Client.Name FROM Client "
 824            "LEFT OUTER JOIN Job ON (Client.ClientId=Job.ClientId) "
 825            "WHERE Job.ClientId IS NULL";
 826    if (verbose > 1) {
 827       printf("%s\n", query);
 828    }
 829    if (!make_id_list(query, &id_list)) {
 830       exit(1);
 831    }
 832    printf("Found %d orphaned Client records.\n", id_list.num_ids);
 833    if (id_list.num_ids && verbose && yes_no("Print them? (yes/no): ")) {
 834       for (int i=0; i < id_list.num_ids; i++) {
 835          bsnprintf(buf, sizeof(buf), "SELECT ClientId,Name FROM Client "
 836                       "WHERE ClientId=%u", id_list.Id[i]);
 837          if (!db_sql_query(db, buf, print_client_handler, NULL)) {
 838             printf("%s\n", db_strerror(db));
 839          }
 840       }
 841    }
 842
 843    if (fix && id_list.num_ids > 0) {
 844       printf("Deleting %d orphaned Client records.\n", id_list.num_ids);
 845       delete_id_list("DELETE FROM Client WHERE ClientId=%u", &id_list);
 846    }
 847 }
 848
 849 static void eliminate_orphaned_job_records()
 850 {
 851    const char *query;
 852
 853    printf("Checking for orphaned Job entries.\n");
 854    /* In English:
 855     *   Wiffle through Job for every Job
 856     *   joining with the Client table including every Job even if
 857     *   there is not a match in Client (left outer join), then
 858     *   filter out only those where no Client exists
 859     *   i.e. Client.Name is NULL
 860     */
 861    query = "SELECT Job.JobId,Job.Name FROM Job "
 862            "LEFT OUTER JOIN Client ON (Job.ClientId=Client.ClientId) "
 863            "WHERE Client.Name IS NULL";
 864    if (verbose > 1) {
 865       printf("%s\n", query);
 866    }
 867    if (!make_id_list(query, &id_list)) {
 868       exit(1);
 869    }
 870    printf("Found %d orphaned Job records.\n", id_list.num_ids);
 871    if (id_list.num_ids && verbose && yes_no("Print them? (yes/no): ")) {
 872       for (int i=0; i < id_list.num_ids; i++) {
 873          bsnprintf(buf, sizeof(buf), "SELECT JobId,Name,StartTime FROM Job "
 874                       "WHERE JobId=%u", id_list.Id[i]);
 875          if (!db_sql_query(db, buf, print_job_handler, NULL)) {
 876             printf("%s\n", db_strerror(db));
 877          }
 878       }
 879    }
 880
 881    if (fix && id_list.num_ids > 0) {
 882       printf("Deleting %d orphaned Job records.\n", id_list.num_ids);
 883       delete_id_list("DELETE FROM Job WHERE JobId=%u", &id_list);
 884    }
 885 }
 886
 887
 888 static void eliminate_admin_records()
 889 {
 890    const char *query;
 891
 892    printf("Checking for Admin Job entries.\n");
 893    query = "SELECT Job.JobId FROM Job "
 894            "WHERE Job.Type='D'";
 895    if (verbose > 1) {
 896       printf("%s\n", query);
 897    }
 898    if (!make_id_list(query, &id_list)) {
 899       exit(1);
 900    }
 901    printf("Found %d Admin Job records.\n", id_list.num_ids);
 902    if (id_list.num_ids && verbose && yes_no("Print them? (yes/no): ")) {
 903       for (int i=0; i < id_list.num_ids; i++) {
 904          bsnprintf(buf, sizeof(buf), "SELECT JobId,Name,StartTime FROM Job "
 905                       "WHERE JobId=%u", id_list.Id[i]);
 906          if (!db_sql_query(db, buf, print_job_handler, NULL)) {
 907             printf("%s\n", db_strerror(db));
 908          }
 909       }
 910    }
 911
 912    if (fix && id_list.num_ids > 0) {
 913       printf("Deleting %d Admin Job records.\n", id_list.num_ids);
 914       delete_id_list("DELETE FROM Job WHERE JobId=%u", &id_list);
 915    }
 916 }
 917
 918 static void eliminate_restore_records()
 919 {
 920    const char *query;
 921
 922    printf("Checking for Restore Job entries.\n");
 923    query = "SELECT Job.JobId FROM Job "
 924            "WHERE Job.Type='R'";
 925    if (verbose > 1) {
 926       printf("%s\n", query);
 927    }
 928    if (!make_id_list(query, &id_list)) {
 929       exit(1);
 930    }
 931    printf("Found %d Restore Job records.\n", id_list.num_ids);
 932    if (id_list.num_ids && verbose && yes_no("Print them? (yes/no): ")) {
 933       for (int i=0; i < id_list.num_ids; i++) {
 934          bsnprintf(buf, sizeof(buf), "SELECT JobId,Name,StartTime FROM Job "
 935                       "WHERE JobId=%u", id_list.Id[i]);
 936          if (!db_sql_query(db, buf, print_job_handler, NULL)) {
 937             printf("%s\n", db_strerror(db));
 938          }
 939       }
 940    }
 941
 942    if (fix && id_list.num_ids > 0) {
 943       printf("Deleting %d Restore Job records.\n", id_list.num_ids);
 944       delete_id_list("DELETE FROM Job WHERE JobId=%u", &id_list);
 945    }
 946 }
 947
 948
 949
 950
 951 static void repair_bad_filenames()
 952 {
 953    const char *query;
 954    int i;
 955
 956    printf("Checking for Filenames with a trailing slash\n");
 957    query = "SELECT FilenameId,Name from Filename "
 958            "WHERE Name LIKE '%/'";
 959    if (verbose > 1) {
 960       printf("%s\n", query);
 961    }
 962    if (!make_id_list(query, &id_list)) {
 963       exit(1);
 964    }
 965    printf("Found %d bad Filename records.\n", id_list.num_ids);
 966    if (id_list.num_ids && verbose && yes_no("Print them? (yes/no): ")) {
 967       for (i=0; i < id_list.num_ids; i++) {
 968          bsnprintf(buf, sizeof(buf),
 969             "SELECT Name FROM Filename WHERE FilenameId=%u", id_list.Id[i]);
 970          if (!db_sql_query(db, buf, print_name_handler, NULL)) {
 971             printf("%s\n", db_strerror(db));
 972          }
 973       }
 974    }
 975
 976    if (fix && id_list.num_ids > 0) {
 977       POOLMEM *name = get_pool_memory(PM_FNAME);
 978       char esc_name[5000];
 979       printf("Reparing %d bad Filename records.\n", id_list.num_ids);
 980       for (i=0; i < id_list.num_ids; i++) {
 981          int len;
 982          bsnprintf(buf, sizeof(buf),
 983             "SELECT Name FROM Filename WHERE FilenameId=%u", id_list.Id[i]);
 984          if (!db_sql_query(db, buf, get_name_handler, name)) {
 985             printf("%s\n", db_strerror(db));
 986          }
 987          /* Strip trailing slash(es) */
 988          for (len=strlen(name); len > 0 && name[len-1]=='/'; len--)
 989             {  }
 990          if (len == 0) {
 991             len = 1;
 992             esc_name[0] = ' ';
 993             esc_name[1] = 0;
 994          } else {
 995             name[len-1] = 0;
 996             db_escape_string(esc_name, name, len);
 997          }
 998          bsnprintf(buf, sizeof(buf),
 999             "UPDATE Filename SET Name='%s' WHERE FilenameId=%u",
1000             esc_name, id_list.Id[i]);
1001          if (verbose > 1) {
1002             printf("%s\n", buf);
1003          }
1004          db_sql_query(db, buf, NULL, NULL);
1005       }
1006    }
1007 }
1008
1009 static void repair_bad_paths()
1010 {
1011    const char *query;
1012    int i;
1013
1014    printf("Checking for Paths without a trailing slash\n");
1015    query = "SELECT PathId,Path from Path "
1016            "WHERE Path NOT LIKE '%/'";
1017    if (verbose > 1) {
1018       printf("%s\n", query);
1019    }
1020    if (!make_id_list(query, &id_list)) {
1021       exit(1);
1022    }
1023    printf("Found %d bad Path records.\n", id_list.num_ids);
1024    if (id_list.num_ids && verbose && yes_no("Print them? (yes/no): ")) {
1025       for (i=0; i < id_list.num_ids; i++) {
1026          bsnprintf(buf, sizeof(buf),
1027             "SELECT Path FROM Path WHERE PathId=%u", id_list.Id[i]);
1028          if (!db_sql_query(db, buf, print_name_handler, NULL)) {
1029             printf("%s\n", db_strerror(db));
1030          }
1031       }
1032    }
1033
1034    if (fix && id_list.num_ids > 0) {
1035       POOLMEM *name = get_pool_memory(PM_FNAME);
1036       char esc_name[5000];
1037       printf("Reparing %d bad Filename records.\n", id_list.num_ids);
1038       for (i=0; i < id_list.num_ids; i++) {
1039          int len;
1040          bsnprintf(buf, sizeof(buf),
1041             "SELECT Path FROM Path WHERE PathId=%u", id_list.Id[i]);
1042          if (!db_sql_query(db, buf, get_name_handler, name)) {
1043             printf("%s\n", db_strerror(db));
1044          }
1045          /* Strip trailing blanks */
1046          for (len=strlen(name); len > 0 && name[len-1]==' '; len--) {
1047             name[len-1] = 0;
1048          }
1049          /* Add trailing slash */
1050          len = pm_strcat(&name, "/");
1051          db_escape_string(esc_name, name, len);
1052          bsnprintf(buf, sizeof(buf), "UPDATE Path SET Path='%s' WHERE PathId=%u",
1053             esc_name, id_list.Id[i]);
1054          if (verbose > 1) {
1055             printf("%s\n", buf);
1056          }
1057          db_sql_query(db, buf, NULL, NULL);
1058       }
1059    }
1060 }
1061
1062
1063
1064
1065 /*
1066  * Gen next input command from the terminal
1067  */
1068 static char *get_cmd(const char *prompt)
1069 {
1070    static char cmd[1000];
1071
1072    printf("%s", prompt);
1073    if (fgets(cmd, sizeof(cmd), stdin) == NULL)
1074       return NULL;
1075    printf("\n");
1076    strip_trailing_junk(cmd);
1077    return cmd;
1078 }
1079
1080 static int yes_no(const char *prompt)
1081 {
1082    char *cmd;
1083    cmd = get_cmd(prompt);
1084    return strcasecmp(cmd, "yes") == 0;
1085 }