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