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