git.sur5r.net Git - bacula/bacula/blob - bacula/src/dird/verify.c

   1 /*
   2  *
   3  *   Bacula Director -- verify.c -- responsible for running file verification
   4  *
   5  *     Kern Sibbald, October MM
   6  *
   7  *  Basic tasks done here:
   8  *     Open DB
   9  *     Open connection with File daemon and pass him commands
  10  *       to do the verify.
  11  *     When the File daemon sends the attributes, compare them to
  12  *       what is in the DB.
  13  *
  14  *   Version $Id$
  15  */
  16
  17 /*
  18    Copyright (C) 2000-2003 Kern Sibbald and John Walker
  19
  20    This program is free software; you can redistribute it and/or
  21    modify it under the terms of the GNU General Public License as
  22    published by the Free Software Foundation; either version 2 of
  23    the License, or (at your option) any later version.
  24
  25    This program is distributed in the hope that it will be useful,
  26    but WITHOUT ANY WARRANTY; without even the implied warranty of
  27    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  28    General Public License for more details.
  29
  30    You should have received a copy of the GNU General Public
  31    License along with this program; if not, write to the Free
  32    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  33    MA 02111-1307, USA.
  34
  35  */
  36
  37 #include "bacula.h"
  38 #include "dird.h"
  39 #include "findlib/find.h"
  40
  41 /* Imported Global Variables */
  42 extern int debug_level;
  43
  44 /* Commands sent to File daemon */
  45 static char verifycmd[]    = "verify level=%s\n";
  46 static char storaddr[]     = "storage address=%s port=%d ssl=0\n";
  47 static char sessioncmd[]   = "session %s %ld %ld %ld %ld %ld %ld\n";
  48
  49 /* Responses received from File daemon */
  50 static char OKverify[]    = "2000 OK verify\n";
  51 static char OKstore[]     = "2000 OK storage\n";
  52 static char OKsession[]   = "2000 OK session\n";
  53
  54 /* Forward referenced functions */
  55 static void verify_cleanup(JCR *jcr, int TermCode);
  56 static void prt_fname(JCR *jcr);
  57 static int missing_handler(void *ctx, int num_fields, char **row);
  58
  59 /*
  60  * Do a verification of the specified files against the Catlaog
  61  *
  62  *  Returns:  0 on failure
  63  *            1 on success
  64  */
  65 int do_verify(JCR *jcr)
  66 {
  67    char *level, *Name;
  68    BSOCK   *fd;
  69    JOB_DBR jr, verify_jr;
  70    JobId_t JobId = 0;
  71    int stat;
  72
  73    if (!get_or_create_client_record(jcr)) {
  74       goto bail_out;
  75    }
  76
  77    Dmsg1(9, "bdird: created client %s record\n", jcr->client->hdr.name);
  78
  79    /*
  80     * Find JobId of last job that ran.  E.g.
  81     *   for VERIFY_CATALOG we want the JobId of the last INIT.
  82     *   for VERIFY_VOLUME_TO_CATALOG, we want the JobId of the
  83     *       last backup Job.
  84     */
  85    if (jcr->JobLevel == L_VERIFY_CATALOG ||
  86        jcr->JobLevel == L_VERIFY_VOLUME_TO_CATALOG) {
  87       memcpy(&jr, &jcr->jr, sizeof(jr));
  88       if (jcr->JobLevel == L_VERIFY_VOLUME_TO_CATALOG &&
  89           jcr->job->verify_job) {
  90          Name = jcr->job->verify_job->hdr.name;
  91       } else {
  92          Name = NULL;
  93       }
  94       Dmsg1(100, "find last jobid for: %s\n", NPRT(Name));
  95       if (!db_find_last_jobid(jcr, jcr->db, Name, &jr)) {
  96          if (jcr->JobLevel == L_VERIFY_CATALOG) {
  97             Jmsg(jcr, M_FATAL, 0, _(
  98                  "Unable to find JobId of previous InitCatalog Job.\n"
  99                  "Please run a Verify with Level=InitCatalog before\n"
 100                  "running the current Job.\n"));
 101           } else {
 102             Jmsg(jcr, M_FATAL, 0, _(
 103                  "Unable to find JobId of previous Job for this client.\n"));
 104          }
 105          goto bail_out;
 106       }
 107       JobId = jr.JobId;
 108       Dmsg1(100, "Last full Jobid=%d\n", JobId);
 109    }
 110
 111    jcr->jr.JobId = jcr->JobId;
 112    jcr->jr.StartTime = jcr->start_time;
 113    jcr->jr.Level = jcr->JobLevel;
 114    if (!db_update_job_start_record(jcr, jcr->db, &jcr->jr)) {
 115       Jmsg(jcr, M_FATAL, 0, "%s", db_strerror(jcr->db));
 116       goto bail_out;
 117    }
 118
 119    if (!jcr->fname) {
 120       jcr->fname = get_pool_memory(PM_FNAME);
 121    }
 122
 123    /* Print Job Start message */
 124    Jmsg(jcr, M_INFO, 0, _("Start Verify JobId %d Job=%s\n"),
 125       jcr->JobId, jcr->Job);
 126
 127    /*
 128     * Now get the job record for the previous backup that interests
 129     *   us. We use the JobId that we found above.
 130     */
 131    if (jcr->JobLevel == L_VERIFY_CATALOG ||
 132        jcr->JobLevel == L_VERIFY_VOLUME_TO_CATALOG ||
 133        jcr->JobLevel == L_VERIFY_DISK_TO_CATALOG) {
 134       memset(&verify_jr, 0, sizeof(verify_jr));
 135       verify_jr.JobId = JobId;
 136       if (!db_get_job_record(jcr, jcr->db, &verify_jr)) {
 137          Jmsg(jcr, M_FATAL, 0, _("Could not get job record for previous Job. ERR=%s"),
 138               db_strerror(jcr->db));
 139          goto bail_out;
 140       }
 141       if (verify_jr.JobStatus != 'T') {
 142          Jmsg(jcr, M_FATAL, 0, _("Last Job %d did not terminate normally. JobStatus=%c\n"),
 143             JobId, verify_jr.JobStatus);
 144          goto bail_out;
 145       }
 146       Jmsg(jcr, M_INFO, 0, _("Verifying against JobId=%d Job=%s\n"),
 147          verify_jr.JobId, verify_jr.Job);
 148    }
 149
 150    /*
 151     * If we are verifying a Volume, we need the Storage
 152     *   daemon, so open a connection, otherwise, just
 153     *   create a dummy authorization key (passed to
 154     *   File daemon but not used).
 155     */
 156    if (jcr->JobLevel == L_VERIFY_VOLUME_TO_CATALOG) {
 157       RBSR *bsr = new_bsr();
 158       UAContext *ua;
 159       bsr->JobId = verify_jr.JobId;
 160       ua = new_ua_context(jcr);
 161       complete_bsr(ua, bsr);
 162       bsr->fi = new_findex();
 163       bsr->fi->findex = 1;
 164       bsr->fi->findex2 = verify_jr.JobFiles;
 165       if (!write_bsr_file(ua, bsr)) {
 166          free_ua_context(ua);
 167          free_bsr(bsr);
 168          goto bail_out;
 169       }
 170       free_ua_context(ua);
 171       free_bsr(bsr);
 172       if (jcr->RestoreBootstrap) {
 173          free(jcr->RestoreBootstrap);
 174       }
 175       POOLMEM *fname = get_pool_memory(PM_MESSAGE);
 176       Mmsg(&fname, "%s/restore.bsr", working_directory);
 177       jcr->RestoreBootstrap = bstrdup(fname);
 178       free_pool_memory(fname);
 179
 180       /*
 181        * Start conversation with Storage daemon
 182        */
 183       set_jcr_job_status(jcr, JS_Blocked);
 184       if (!connect_to_storage_daemon(jcr, 10, SDConnectTimeout, 1)) {
 185          goto bail_out;
 186       }
 187       /*
 188        * Now start a job with the Storage daemon
 189        */
 190       if (!start_storage_daemon_job(jcr)) {
 191          goto bail_out;
 192       }
 193       /*
 194        * Now start a Storage daemon message thread
 195        */
 196       if (!start_storage_daemon_message_thread(jcr)) {
 197          goto bail_out;
 198       }
 199       Dmsg0(50, "Storage daemon connection OK\n");
 200    } else {
 201       jcr->sd_auth_key = bstrdup("dummy");    /* dummy Storage daemon key */
 202    }
 203
 204    if (jcr->JobLevel == L_VERIFY_DISK_TO_CATALOG &&
 205        jcr->job->verify_job) {
 206        jcr->fileset = jcr->job->verify_job->fileset;
 207    }
 208    jcr->verify_jr = &verify_jr;
 209
 210    /*
 211     * OK, now connect to the File daemon
 212     *  and ask him for the files.
 213     */
 214    set_jcr_job_status(jcr, JS_Blocked);
 215    if (!connect_to_file_daemon(jcr, 10, FDConnectTimeout, 1)) {
 216       goto bail_out;
 217    }
 218
 219    set_jcr_job_status(jcr, JS_Running);
 220    fd = jcr->file_bsock;
 221
 222
 223    Dmsg0(30, ">filed: Send include list\n");
 224    if (!send_include_list(jcr)) {
 225       goto bail_out;
 226    }
 227
 228    Dmsg0(30, ">filed: Send exclude list\n");
 229    if (!send_exclude_list(jcr)) {
 230       goto bail_out;
 231    }
 232
 233    /*
 234     * Send Level command to File daemon, as well
 235     *   as the Storage address if appropriate.
 236     */
 237    switch (jcr->JobLevel) {
 238    case L_VERIFY_INIT:
 239       level = "init";
 240       break;
 241    case L_VERIFY_CATALOG:
 242       level = "catalog";
 243       break;
 244    case L_VERIFY_VOLUME_TO_CATALOG:
 245       /*
 246        * send Storage daemon address to the File daemon
 247        */
 248       if (jcr->store->SDDport == 0) {
 249          jcr->store->SDDport = jcr->store->SDport;
 250       }
 251       bnet_fsend(fd, storaddr, jcr->store->address, jcr->store->SDDport);
 252       if (!response(jcr, fd, OKstore, "Storage", DISPLAY_ERROR)) {
 253          goto bail_out;
 254       }
 255
 256       /*
 257        * Send the bootstrap file -- what Volumes/files to restore
 258        */
 259       if (!send_bootstrap_file(jcr)) {
 260          goto bail_out;
 261       }
 262
 263       /*
 264        * The following code is deprecated
 265        */
 266       if (!jcr->RestoreBootstrap) {
 267          /*
 268           * Pass the VolSessionId, VolSessionTime, Start and
 269           * end File and Blocks on the session command.
 270           */
 271          bnet_fsend(fd, sessioncmd,
 272                    jcr->VolumeName,
 273                    jr.VolSessionId, jr.VolSessionTime,
 274                    jr.StartFile, jr.EndFile, jr.StartBlock,
 275                    jr.EndBlock);
 276          if (!response(jcr, fd, OKsession, "Session", DISPLAY_ERROR)) {
 277             goto bail_out;
 278          }
 279       }
 280       level = "volume";
 281       break;
 282    case L_VERIFY_DATA:
 283       level = "data";
 284       break;
 285    case L_VERIFY_DISK_TO_CATALOG:
 286       level="disk_to_catalog";
 287       break;
 288    default:
 289       Jmsg1(jcr, M_FATAL, 0, _("Unimplemented save level %d\n"), jcr->JobLevel);
 290       goto bail_out;
 291    }
 292
 293    if (!send_run_before_and_after_commands(jcr)) {
 294       goto bail_out;
 295    }
 296
 297    /*
 298     * Send verify command/level to File daemon
 299     */
 300    bnet_fsend(fd, verifycmd, level);
 301    if (!response(jcr, fd, OKverify, "Verify", DISPLAY_ERROR)) {
 302       goto bail_out;
 303    }
 304
 305    /*
 306     * Now get data back from File daemon and
 307     *  compare it to the catalog or store it in the
 308     *  catalog depending on the run type.
 309     */
 310    /* Compare to catalog */
 311    switch (jcr->JobLevel) {
 312    case L_VERIFY_CATALOG:
 313       Dmsg0(10, "Verify level=catalog\n");
 314       jcr->sd_msg_thread_done = true;   /* no SD msg thread, so it is done */
 315       jcr->SDJobStatus = JS_Terminated;
 316       get_attributes_and_compare_to_catalog(jcr, JobId);
 317       break;
 318
 319    case L_VERIFY_VOLUME_TO_CATALOG:
 320       Dmsg0(10, "Verify level=volume\n");
 321       get_attributes_and_compare_to_catalog(jcr, JobId);
 322       break;
 323
 324    case L_VERIFY_DISK_TO_CATALOG:
 325       Dmsg0(10, "Verify level=disk_to_catalog\n");
 326       get_attributes_and_compare_to_catalog(jcr, JobId);
 327       break;
 328
 329    case L_VERIFY_INIT:
 330       /* Build catalog */
 331       Dmsg0(10, "Verify level=init\n");
 332       jcr->sd_msg_thread_done = true;   /* no SD msg thread, so it is done */
 333       jcr->SDJobStatus = JS_Terminated;
 334       get_attributes_and_put_in_catalog(jcr);
 335       break;
 336
 337    default:
 338       Jmsg1(jcr, M_FATAL, 0, _("Unimplemented verify level %d\n"), jcr->JobLevel);
 339       goto bail_out;
 340    }
 341
 342    stat = wait_for_job_termination(jcr);
 343
 344    verify_cleanup(jcr, stat);
 345    return 1;
 346
 347 bail_out:
 348    verify_cleanup(jcr, JS_ErrorTerminated);
 349    return 0;
 350 }
 351
 352 /*
 353  * Release resources allocated during backup.
 354  *
 355  */
 356 static void verify_cleanup(JCR *jcr, int TermCode)
 357 {
 358    char sdt[50], edt[50];
 359    char ec1[30];
 360    char term_code[100], fd_term_msg[100], sd_term_msg[100];
 361    char *term_msg;
 362    int msg_type;
 363    JobId_t JobId;
 364
 365 // Dmsg1(000, "Enter verify_cleanup() TermCod=%d\n", TermCode);
 366
 367    JobId = jcr->jr.JobId;
 368    set_jcr_job_status(jcr, TermCode);
 369
 370    update_job_end_record(jcr);
 371
 372    msg_type = M_INFO;                 /* by default INFO message */
 373    switch (TermCode) {
 374    case JS_Terminated:
 375       term_msg = _("Verify OK");
 376       break;
 377    case JS_ErrorTerminated:
 378       term_msg = _("*** Verify Error ***");
 379       msg_type = M_ERROR;          /* Generate error message */
 380       break;
 381    case JS_Canceled:
 382       term_msg = _("Verify Canceled");
 383       break;
 384    case JS_Differences:
 385       term_msg = _("Verify Differences");
 386       break;
 387    default:
 388       term_msg = term_code;
 389       sprintf(term_code, _("Inappropriate term code: %c\n"), TermCode);
 390       break;
 391    }
 392    bstrftime(sdt, sizeof(sdt), jcr->jr.StartTime);
 393    bstrftime(edt, sizeof(edt), jcr->jr.EndTime);
 394
 395    jobstatus_to_ascii(jcr->FDJobStatus, fd_term_msg, sizeof(fd_term_msg));
 396    if (jcr->JobLevel == L_VERIFY_VOLUME_TO_CATALOG) {
 397        jobstatus_to_ascii(jcr->SDJobStatus, sd_term_msg, sizeof(sd_term_msg));
 398       Jmsg(jcr, msg_type, 0, _("Bacula " VERSION " (" LSMDATE "): %s\n\
 399 JobId:                  %d\n\
 400 Job:                    %s\n\
 401 FileSet:                %s\n\
 402 Verify Level:           %s\n\
 403 Client:                 %s\n\
 404 Start time:             %s\n\
 405 End time:               %s\n\
 406 Files Examined:         %s\n\
 407 Non-fatal FD errors:    %d\n\
 408 FD termination status:  %s\n\
 409 SD termination status:  %s\n\
 410 Termination:            %s\n\n"),
 411          edt,
 412          jcr->jr.JobId,
 413          jcr->jr.Job,
 414          jcr->fileset->hdr.name,
 415          level_to_str(jcr->JobLevel),
 416          jcr->client->hdr.name,
 417          sdt,
 418          edt,
 419          edit_uint64_with_commas(jcr->JobFiles, ec1),
 420          jcr->Errors,
 421          fd_term_msg,
 422          sd_term_msg,
 423          term_msg);
 424    } else {
 425       Jmsg(jcr, msg_type, 0, _("Bacula " VERSION " (" LSMDATE "): %s\n\
 426 JobId:                  %d\n\
 427 Job:                    %s\n\
 428 FileSet:                %s\n\
 429 Verify Level:           %s\n\
 430 Client:                 %s\n\
 431 Start time:             %s\n\
 432 End time:               %s\n\
 433 Files Examined:         %s\n\
 434 Non-fatal FD errors:    %d\n\
 435 FD termination status:  %s\n\
 436 Termination:            %s\n\n"),
 437          edt,
 438          jcr->jr.JobId,
 439          jcr->jr.Job,
 440          jcr->fileset->hdr.name,
 441          level_to_str(jcr->JobLevel),
 442          jcr->client->hdr.name,
 443          sdt,
 444          edt,
 445          edit_uint64_with_commas(jcr->JobFiles, ec1),
 446          jcr->Errors,
 447          fd_term_msg,
 448          term_msg);
 449    }
 450    Dmsg0(100, "Leave verify_cleanup()\n");
 451    if (jcr->fname) {
 452       free_memory(jcr->fname);
 453       jcr->fname = NULL;
 454    }
 455 }
 456
 457 /*
 458  * This routine is called only during a Verify
 459  */
 460 int get_attributes_and_compare_to_catalog(JCR *jcr, JobId_t JobId)
 461 {
 462    BSOCK   *fd;
 463    int n, len;
 464    FILE_DBR fdbr;
 465    struct stat statf;                 /* file stat */
 466    struct stat statc;                 /* catalog stat */
 467    int stat = JS_Terminated;
 468    char buf[MAXSTRING];
 469    POOLMEM *fname = get_pool_memory(PM_MESSAGE);
 470    int do_SIG = NO_SIG;
 471    long file_index = 0;
 472
 473    memset(&fdbr, 0, sizeof(FILE_DBR));
 474    fd = jcr->file_bsock;
 475    fdbr.JobId = JobId;
 476    jcr->FileIndex = 0;
 477
 478    Dmsg0(20, "bdird: waiting to receive file attributes\n");
 479    /*
 480     * Get Attributes and Signature from File daemon
 481     * We expect:
 482     *   FileIndex
 483     *   Stream
 484     *   Options or SIG (MD5/SHA1)
 485     *   Filename
 486     *   Attributes
 487     *   Link name  ???
 488     */
 489    while ((n=bget_dirmsg(fd)) >= 0 && !job_canceled(jcr)) {
 490       int stream;
 491       char *attr, *p, *fn;
 492       char Opts_SIG[MAXSTRING];        /* Verify Opts or MD5/SHA1 signature */
 493
 494       fname = check_pool_memory_size(fname, fd->msglen);
 495       jcr->fname = check_pool_memory_size(jcr->fname, fd->msglen);
 496       Dmsg1(400, "Atts+SIG=%s\n", fd->msg);
 497       if ((len = sscanf(fd->msg, "%ld %d %100s", &file_index, &stream,
 498             fname)) != 3) {
 499          Jmsg3(jcr, M_FATAL, 0, _("bird<filed: bad attributes, expected 3 fields got %d\n\
 500  mslen=%d msg=%s\n"), len, fd->msglen, fd->msg);
 501          goto bail_out;
 502       }
 503       /*
 504        * We read the Options or Signature into fname
 505        *  to prevent overrun, now copy it to proper location.
 506        */
 507       bstrncpy(Opts_SIG, fname, sizeof(Opts_SIG));
 508       p = fd->msg;
 509       skip_nonspaces(&p);             /* skip FileIndex */
 510       skip_spaces(&p);
 511       skip_nonspaces(&p);             /* skip Stream */
 512       skip_spaces(&p);
 513       skip_nonspaces(&p);             /* skip Opts_SIG */
 514       p++;                            /* skip space */
 515       fn = fname;
 516       while (*p != 0) {
 517          *fn++ = *p++;                /* copy filename */
 518       }
 519       *fn = *p++;                     /* term filename and point to attribs */
 520       attr = p;
 521       /*
 522        * Got attributes stream, decode it
 523        */
 524       if (stream == STREAM_UNIX_ATTRIBUTES || stream == STREAM_UNIX_ATTRIBUTES_EX) {
 525          int32_t LinkFIf, LinkFIc;
 526          Dmsg2(400, "file_index=%d attr=%s\n", file_index, attr);
 527          jcr->JobFiles++;
 528          jcr->FileIndex = file_index;    /* remember attribute file_index */
 529          decode_stat(attr, &statf, &LinkFIf);  /* decode file stat packet */
 530          do_SIG = NO_SIG;
 531          jcr->fn_printed = FALSE;
 532          pm_strcpy(&jcr->fname, fname);  /* move filename into JCR */
 533
 534          Dmsg2(040, "dird<filed: stream=%d %s\n", stream, jcr->fname);
 535          Dmsg1(020, "dird<filed: attr=%s\n", attr);
 536
 537          /*
 538           * Find equivalent record in the database
 539           */
 540          fdbr.FileId = 0;
 541          if (!db_get_file_attributes_record(jcr, jcr->db, jcr->fname,
 542               jcr->verify_jr, &fdbr)) {
 543             Jmsg(jcr, M_INFO, 0, _("New file: %s\n"), jcr->fname);
 544             Dmsg1(020, _("File not in catalog: %s\n"), jcr->fname);
 545             stat = JS_Differences;
 546             continue;
 547          } else {
 548             /*
 549              * mark file record as visited by stuffing the
 550              * current JobId, which is unique, into the MarkId field.
 551              */
 552             db_mark_file_record(jcr, jcr->db, fdbr.FileId, jcr->JobId);
 553          }
 554
 555          Dmsg3(400, "Found %s in catalog. inx=%d Opts=%s\n", jcr->fname,
 556             file_index, Opts_SIG);
 557          decode_stat(fdbr.LStat, &statc, &LinkFIc); /* decode catalog stat */
 558          /*
 559           * Loop over options supplied by user and verify the
 560           * fields he requests.
 561           */
 562          for (p=Opts_SIG; *p; p++) {
 563             char ed1[30], ed2[30];
 564             switch (*p) {
 565             case 'i':                /* compare INODEs */
 566                if (statc.st_ino != statf.st_ino) {
 567                   prt_fname(jcr);
 568                   Jmsg(jcr, M_INFO, 0, _("      st_ino   differ. Cat: %s File: %s\n"),
 569                      edit_uint64((uint64_t)statc.st_ino, ed1),
 570                      edit_uint64((uint64_t)statf.st_ino, ed2));
 571                   stat = JS_Differences;
 572                }
 573                break;
 574             case 'p':                /* permissions bits */
 575                if (statc.st_mode != statf.st_mode) {
 576                   prt_fname(jcr);
 577                   Jmsg(jcr, M_INFO, 0, _("      st_mode  differ. Cat: %x File: %x\n"),
 578                      (uint32_t)statc.st_mode, (uint32_t)statf.st_mode);
 579                   stat = JS_Differences;
 580                }
 581                break;
 582             case 'n':                /* number of links */
 583                if (statc.st_nlink != statf.st_nlink) {
 584                   prt_fname(jcr);
 585                   Jmsg(jcr, M_INFO, 0, _("      st_nlink differ. Cat: %d File: %d\n"),
 586                      (uint32_t)statc.st_nlink, (uint32_t)statf.st_nlink);
 587                   stat = JS_Differences;
 588                }
 589                break;
 590             case 'u':                /* user id */
 591                if (statc.st_uid != statf.st_uid) {
 592                   prt_fname(jcr);
 593                   Jmsg(jcr, M_INFO, 0, _("      st_uid   differ. Cat: %u File: %u\n"),
 594                      (uint32_t)statc.st_uid, (uint32_t)statf.st_uid);
 595                   stat = JS_Differences;
 596                }
 597                break;
 598             case 'g':                /* group id */
 599                if (statc.st_gid != statf.st_gid) {
 600                   prt_fname(jcr);
 601                   Jmsg(jcr, M_INFO, 0, _("      st_gid   differ. Cat: %u File: %u\n"),
 602                      (uint32_t)statc.st_gid, (uint32_t)statf.st_gid);
 603                   stat = JS_Differences;
 604                }
 605                break;
 606             case 's':                /* size */
 607                if (statc.st_size != statf.st_size) {
 608                   prt_fname(jcr);
 609                   Jmsg(jcr, M_INFO, 0, _("      st_size  differ. Cat: %s File: %s\n"),
 610                      edit_uint64((uint64_t)statc.st_size, ed1),
 611                      edit_uint64((uint64_t)statf.st_size, ed2));
 612                   stat = JS_Differences;
 613                }
 614                break;
 615             case 'a':                /* access time */
 616                if (statc.st_atime != statf.st_atime) {
 617                   prt_fname(jcr);
 618                   Jmsg(jcr, M_INFO, 0, _("      st_atime differs\n"));
 619                   stat = JS_Differences;
 620                }
 621                break;
 622             case 'm':
 623                if (statc.st_mtime != statf.st_mtime) {
 624                   prt_fname(jcr);
 625                   Jmsg(jcr, M_INFO, 0, _("      st_mtime differs\n"));
 626                   stat = JS_Differences;
 627                }
 628                break;
 629             case 'c':                /* ctime */
 630                if (statc.st_ctime != statf.st_ctime) {
 631                   prt_fname(jcr);
 632                   Jmsg(jcr, M_INFO, 0, _("      st_ctime differs\n"));
 633                   stat = JS_Differences;
 634                }
 635                break;
 636             case 'd':                /* file size decrease */
 637                if (statc.st_size > statf.st_size) {
 638                   prt_fname(jcr);
 639                   Jmsg(jcr, M_INFO, 0, _("      st_size  decrease. Cat: %s File: %s\n"),
 640                      edit_uint64((uint64_t)statc.st_size, ed1),
 641                      edit_uint64((uint64_t)statf.st_size, ed2));
 642                   stat = JS_Differences;
 643                }
 644                break;
 645             case '5':                /* compare MD5 */
 646                Dmsg1(500, "set Do_MD5 for %s\n", jcr->fname);
 647                do_SIG = MD5_SIG;
 648                break;
 649             case '1':                 /* compare SHA1 */
 650                do_SIG = SHA1_SIG;
 651                break;
 652             case ':':
 653             case 'V':
 654             default:
 655                break;
 656             }
 657          }
 658       /*
 659        * Got SIG Signature from Storage daemon
 660        *  It came across in the Opts_SIG field.
 661        */
 662       } else if (stream == STREAM_MD5_SIGNATURE || stream == STREAM_SHA1_SIGNATURE) {
 663          Dmsg2(400, "stream=SIG inx=%d SIG=%s\n", file_index, Opts_SIG);
 664          /*
 665           * When ever we get a signature is MUST have been
 666           * preceded by an attributes record, which sets attr_file_index
 667           */
 668          if (jcr->FileIndex != (uint32_t)file_index) {
 669             Jmsg2(jcr, M_FATAL, 0, _("MD5/SHA1 index %d not same as attributes %d\n"),
 670                file_index, jcr->FileIndex);
 671             goto bail_out;
 672          }
 673          if (do_SIG) {
 674             db_escape_string(buf, Opts_SIG, strlen(Opts_SIG));
 675             if (strcmp(buf, fdbr.SIG) != 0) {
 676                prt_fname(jcr);
 677                if (debug_level >= 10) {
 678                   Jmsg(jcr, M_INFO, 0, _("      %s not same. File=%s Cat=%s\n"),
 679                        stream==STREAM_MD5_SIGNATURE?"MD5":"SHA1", buf, fdbr.SIG);
 680                } else {
 681                   Jmsg(jcr, M_INFO, 0, _("      %s differs.\n"),
 682                        stream==STREAM_MD5_SIGNATURE?"MD5":"SHA1");
 683                }
 684                stat = JS_Differences;
 685             }
 686             do_SIG = FALSE;
 687          }
 688       }
 689       jcr->JobFiles = file_index;
 690    }
 691    if (is_bnet_error(fd)) {
 692       Jmsg2(jcr, M_FATAL, 0, _("bdird<filed: bad attributes from filed n=%d : %s\n"),
 693                         n, strerror(errno));
 694       goto bail_out;
 695    }
 696
 697    /* Now find all the files that are missing -- i.e. all files in
 698     *  the database where the MarkedId != current JobId
 699     */
 700    jcr->fn_printed = FALSE;
 701    sprintf(buf,
 702 "SELECT Path.Path,Filename.Name FROM File,Path,Filename "
 703 "WHERE File.JobId=%d "
 704 "AND File.MarkedId!=%d AND File.PathId=Path.PathId "
 705 "AND File.FilenameId=Filename.FilenameId",
 706       JobId, jcr->JobId);
 707    /* missing_handler is called for each file found */
 708    db_sql_query(jcr->db, buf, missing_handler, (void *)jcr);
 709    if (jcr->fn_printed) {
 710       stat = JS_Differences;
 711    }
 712    free_pool_memory(fname);
 713    set_jcr_job_status(jcr, stat);
 714    return 1;
 715
 716 bail_out:
 717    free_pool_memory(fname);
 718    set_jcr_job_status(jcr, JS_ErrorTerminated);
 719    return 0;
 720 }
 721
 722 /*
 723  * We are called here for each record that matches the above
 724  *  SQL query -- that is for each file contained in the Catalog
 725  *  that was not marked earlier. This means that the file in
 726  *  question is a missing file (in the Catalog but on on Disk).
 727  */
 728 static int missing_handler(void *ctx, int num_fields, char **row)
 729 {
 730    JCR *jcr = (JCR *)ctx;
 731
 732    if (!jcr->fn_printed) {
 733       Jmsg(jcr, M_INFO, 0, "\n");
 734       Jmsg(jcr, M_INFO, 0, _("The following files are missing:\n"));
 735       jcr->fn_printed = TRUE;
 736    }
 737    Jmsg(jcr, M_INFO, 0, "      %s%s\n", row[0]?row[0]:"", row[1]?row[1]:"");
 738    return 0;
 739 }
 740
 741
 742 /*
 743  * Print filename for verify
 744  */
 745 static void prt_fname(JCR *jcr)
 746 {
 747    if (!jcr->fn_printed) {
 748       Jmsg(jcr, M_INFO, 0, _("File: %s\n"), jcr->fname);
 749       jcr->fn_printed = TRUE;
 750    }
 751 }