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