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