git.sur5r.net Git - bacula/bacula/blob - bacula/src/stored/bscan.c

   1 /*
   2    Bacula® - The Network Backup Solution
   3
   4    Copyright (C) 2001-2011 Free Software Foundation Europe e.V.
   5
   6    The main author of Bacula is Kern Sibbald, with contributions from
   7    many others, a complete list can be found in the file AUTHORS.
   8    This program is Free Software; you can redistribute it and/or
   9    modify it under the terms of version three of the GNU Affero General Public
  10    License as published by the Free Software Foundation and included
  11    in the file LICENSE.
  12
  13    This program is distributed in the hope that it will be useful, but
  14    WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16    General Public License for more details.
  17
  18    You should have received a copy of the GNU Affero General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21    02110-1301, USA.
  22
  23    Bacula® is a registered trademark of Kern Sibbald.
  24    The licensor of Bacula is the Free Software Foundation Europe
  25    (FSFE), Fiduciary Program, Sumatrastrasse 25, 8006 Zürich,
  26    Switzerland, email:ftf@fsfeurope.org.
  27 */
  28 /*
  29  *
  30  *  Program to scan a Bacula Volume and compare it with
  31  *    the catalog and optionally synchronize the catalog
  32  *    with the tape.
  33  *
  34  *   Kern E. Sibbald, December 2001
  35  *
  36  */
  37
  38 #include "bacula.h"
  39 #include "stored.h"
  40 #include "findlib/find.h"
  41 #include "cats/cats.h"
  42 #include "cats/sql_glue.h"
  43
  44 /* Dummy functions */
  45 int generate_daemon_event(JCR *jcr, const char *event) { return 1; }
  46 extern bool parse_sd_config(CONFIG *config, const char *configfile, int exit_code);
  47
  48 /* Forward referenced functions */
  49 static void do_scan(void);
  50 static bool record_cb(DCR *dcr, DEV_RECORD *rec);
  51 static int  create_file_attributes_record(B_DB *db, JCR *mjcr,
  52                                char *fname, char *lname, int type,
  53                                char *ap, DEV_RECORD *rec);
  54 static int  create_media_record(B_DB *db, MEDIA_DBR *mr, VOLUME_LABEL *vl);
  55 static bool update_media_record(B_DB *db, MEDIA_DBR *mr);
  56 static int  create_pool_record(B_DB *db, POOL_DBR *pr);
  57 static JCR *create_job_record(B_DB *db, JOB_DBR *mr, SESSION_LABEL *label, DEV_RECORD *rec);
  58 static int  update_job_record(B_DB *db, JOB_DBR *mr, SESSION_LABEL *elabel,
  59                               DEV_RECORD *rec);
  60 static int  create_client_record(B_DB *db, CLIENT_DBR *cr);
  61 static int  create_fileset_record(B_DB *db, FILESET_DBR *fsr);
  62 static int  create_jobmedia_record(B_DB *db, JCR *jcr);
  63 static JCR *create_jcr(JOB_DBR *jr, DEV_RECORD *rec, uint32_t JobId);
  64 static int update_digest_record(B_DB *db, char *digest, DEV_RECORD *rec, int type);
  65
  66
  67 /* Local variables */
  68 static DEVICE *dev = NULL;
  69 static B_DB *db;
  70 static JCR *bjcr;                     /* jcr for bscan */
  71 static BSR *bsr = NULL;
  72 static MEDIA_DBR mr;
  73 static POOL_DBR pr;
  74 static JOB_DBR jr;
  75 static CLIENT_DBR cr;
  76 static FILESET_DBR fsr;
  77 static ATTR_DBR ar;
  78 static FILE_DBR fr;
  79 static SESSION_LABEL label;
  80 static SESSION_LABEL elabel;
  81 static ATTR *attr;
  82
  83 static time_t lasttime = 0;
  84
  85 static const char *db_driver = "NULL";
  86 static const char *db_name = "bacula";
  87 static const char *db_user = "bacula";
  88 static const char *db_password = "";
  89 static const char *db_host = NULL;
  90 static int db_port = 0;
  91 static const char *wd = NULL;
  92 static bool update_db = false;
  93 static bool update_vol_info = false;
  94 static bool list_records = false;
  95 static int ignored_msgs = 0;
  96
  97 static uint64_t currentVolumeSize;
  98 static int last_pct = -1;
  99 static bool showProgress = false;
 100 static int num_jobs = 0;
 101 static int num_pools = 0;
 102 static int num_media = 0;
 103 static int num_files = 0;
 104
 105 static CONFIG *config;
 106 #define CONFIG_FILE "bacula-sd.conf"
 107 char *configfile = NULL;
 108 STORES *me = NULL;                    /* our Global resource */
 109 bool forge_on = false;                /* proceed inspite of I/O errors */
 110 pthread_mutex_t device_release_mutex = PTHREAD_MUTEX_INITIALIZER;
 111 pthread_cond_t wait_device_release = PTHREAD_COND_INITIALIZER;
 112
 113
 114 static void usage()
 115 {
 116    fprintf(stderr, _(
 117 PROG_COPYRIGHT
 118 "\nVersion: %s (%s)\n\n"
 119 "Usage: bscan [ options ] <bacula-archive>\n"
 120 "       -b bootstrap      specify a bootstrap file\n"
 121 "       -c <file>         specify configuration file\n"
 122 "       -d <nn>           set debug level to <nn>\n"
 123 "       -dt               print timestamp in debug output\n"
 124 "       -m                update media info in database\n"
 125 "       -D <driver name>  specify the driver database name (default NULL)\n"
 126 "       -n <name>         specify the database name (default bacula)\n"
 127 "       -u <user>         specify database user name (default bacula)\n"
 128 "       -P <password>     specify database password (default none)\n"
 129 "       -h <host>         specify database host (default NULL)\n"
 130 "       -t <port>         specify database port (default 0)\n"
 131 "       -p                proceed inspite of I/O errors\n"
 132 "       -r                list records\n"
 133 "       -s                synchronize or store in database\n"
 134 "       -S                show scan progress periodically\n"
 135 "       -v                verbose\n"
 136 "       -V <Volumes>      specify Volume names (separated by |)\n"
 137 "       -w <dir>          specify working directory (default from conf file)\n"
 138 "       -?                print this message\n\n"), 2001, VERSION, BDATE);
 139    exit(1);
 140 }
 141
 142 int main (int argc, char *argv[])
 143 {
 144    int ch;
 145    struct stat stat_buf;
 146    char *VolumeName = NULL;
 147
 148    setlocale(LC_ALL, "");
 149    bindtextdomain("bacula", LOCALEDIR);
 150    textdomain("bacula");
 151    init_stack_dump();
 152    lmgr_init_thread();
 153
 154    my_name_is(argc, argv, "bscan");
 155    init_msg(NULL, NULL);
 156
 157    OSDependentInit();
 158
 159    while ((ch = getopt(argc, argv, "b:c:d:D:h:p:mn:pP:rsSt:u:vV:w:?")) != -1) {
 160       switch (ch) {
 161       case 'S' :
 162          showProgress = true;
 163          break;
 164       case 'b':
 165          bsr = parse_bsr(NULL, optarg);
 166          break;
 167
 168       case 'c':                    /* specify config file */
 169          if (configfile != NULL) {
 170             free(configfile);
 171          }
 172          configfile = bstrdup(optarg);
 173          break;
 174
 175       case 'D':
 176          db_driver = optarg;
 177          break;
 178
 179       case 'd':                    /* debug level */
 180          if (*optarg == 't') {
 181             dbg_timestamp = true;
 182          } else {
 183             debug_level = atoi(optarg);
 184             if (debug_level <= 0) {
 185                debug_level = 1;
 186             }
 187          }
 188          break;
 189
 190       case 'h':
 191          db_host = optarg;
 192          break;
 193
 194       case 't':
 195          db_port = atoi(optarg);
 196          break;
 197
 198       case 'm':
 199          update_vol_info = true;
 200          break;
 201
 202       case 'n':
 203          db_name = optarg;
 204          break;
 205
 206       case 'u':
 207          db_user = optarg;
 208          break;
 209
 210       case 'P':
 211          db_password = optarg;
 212          break;
 213
 214       case 'p':
 215          forge_on = true;
 216          break;
 217
 218       case 'r':
 219          list_records = true;
 220          break;
 221
 222       case 's':
 223          update_db = true;
 224          break;
 225
 226       case 'v':
 227          verbose++;
 228          break;
 229
 230       case 'V':                    /* Volume name */
 231          VolumeName = optarg;
 232          break;
 233
 234       case 'w':
 235          wd = optarg;
 236          break;
 237
 238       case '?':
 239       default:
 240          usage();
 241
 242       }
 243    }
 244    argc -= optind;
 245    argv += optind;
 246
 247    if (argc != 1) {
 248       Pmsg0(0, _("Wrong number of arguments: \n"));
 249       usage();
 250    }
 251
 252    if (configfile == NULL) {
 253       configfile = bstrdup(CONFIG_FILE);
 254    }
 255
 256    config = new_config_parser();
 257    parse_sd_config(config, configfile, M_ERROR_TERM);
 258    LockRes();
 259    me = (STORES *)GetNextRes(R_STORAGE, NULL);
 260    if (!me) {
 261       UnlockRes();
 262       Emsg1(M_ERROR_TERM, 0, _("No Storage resource defined in %s. Cannot continue.\n"),
 263          configfile);
 264    }
 265    UnlockRes();
 266    /* Check if -w option given, otherwise use resource for working directory */
 267    if (wd) {
 268       working_directory = wd;
 269    } else if (!me->working_directory) {
 270       Emsg1(M_ERROR_TERM, 0, _("No Working Directory defined in %s. Cannot continue.\n"),
 271          configfile);
 272    } else {
 273       working_directory = me->working_directory;
 274    }
 275
 276    /* Check that working directory is good */
 277    if (stat(working_directory, &stat_buf) != 0) {
 278       Emsg1(M_ERROR_TERM, 0, _("Working Directory: %s not found. Cannot continue.\n"),
 279          working_directory);
 280    }
 281    if (!S_ISDIR(stat_buf.st_mode)) {
 282       Emsg1(M_ERROR_TERM, 0, _("Working Directory: %s is not a directory. Cannot continue.\n"),
 283          working_directory);
 284    }
 285
 286    bjcr = setup_jcr("bscan", argv[0], bsr, VolumeName, 1); /* read device */
 287    if (!bjcr) {
 288       exit(1);
 289    }
 290    dev = bjcr->read_dcr->dev;
 291    if (showProgress) {
 292       char ed1[50];
 293       struct stat sb;
 294       fstat(dev->fd(), &sb);
 295       currentVolumeSize = sb.st_size;
 296       Pmsg1(000, _("First Volume Size = %s\n"),
 297          edit_uint64(currentVolumeSize, ed1));
 298    }
 299
 300    if ((db = db_init_database(NULL, db_driver, db_name, db_user, db_password,
 301                               db_host, db_port, NULL, false, false)) == NULL) {
 302       Emsg0(M_ERROR_TERM, 0, _("Could not init Bacula database\n"));
 303    }
 304    if (!db_open_database(NULL, db)) {
 305       Emsg0(M_ERROR_TERM, 0, db_strerror(db));
 306    }
 307    Dmsg0(200, "Database opened\n");
 308    if (verbose) {
 309       Pmsg2(000, _("Using Database: %s, User: %s\n"), db_name, db_user);
 310    }
 311
 312    do_scan();
 313    if (update_db) {
 314       printf("Records added or updated in the catalog:\n%7d Media\n%7d Pool\n%7d Job\n%7d File\n",
 315          num_media, num_pools, num_jobs, num_files);
 316    } else {
 317       printf("Records would have been added or updated in the catalog:\n%7d Media\n%7d Pool\n%7d Job\n%7d File\n",
 318          num_media, num_pools, num_jobs, num_files);
 319    }
 320
 321    free_jcr(bjcr);
 322    dev->term();
 323    return 0;
 324 }
 325
 326 /*
 327  * We are at the end of reading a tape. Now, we simulate handling
 328  *   the end of writing a tape by wiffling through the attached
 329  *   jcrs creating jobmedia records.
 330  */
 331 static bool bscan_mount_next_read_volume(DCR *dcr)
 332 {
 333    DEVICE *dev = dcr->dev;
 334    DCR *mdcr;
 335    Dmsg1(100, "Walk attached jcrs. Volume=%s\n", dev->getVolCatName());
 336    foreach_dlist(mdcr, dev->attached_dcrs) {
 337       JCR *mjcr = mdcr->jcr;
 338       Dmsg1(000, "========== JobId=%u ========\n", mjcr->JobId);
 339       if (mjcr->JobId == 0) {
 340          continue;
 341       }
 342       if (verbose) {
 343          Pmsg1(000, _("Create JobMedia for Job %s\n"), mjcr->Job);
 344       }
 345       mdcr->StartBlock = dcr->StartBlock;
 346       mdcr->StartFile = dcr->StartFile;
 347       mdcr->EndBlock = dcr->EndBlock;
 348       mdcr->EndFile = dcr->EndFile;
 349       mdcr->VolMediaId = dcr->VolMediaId;
 350       mjcr->read_dcr->VolLastIndex = dcr->VolLastIndex;
 351       if( mjcr->bscan_insert_jobmedia_records ) {
 352          if (!create_jobmedia_record(db, mjcr)) {
 353             Pmsg2(000, _("Could not create JobMedia record for Volume=%s Job=%s\n"),
 354                dev->getVolCatName(), mjcr->Job);
 355          }
 356       }
 357    }
 358
 359    update_media_record(db, &mr);
 360
 361    /* Now let common read routine get up next tape. Note,
 362     * we call mount_next... with bscan's jcr because that is where we
 363     * have the Volume list, but we get attached.
 364     */
 365    bool stat = mount_next_read_volume(dcr);
 366
 367    if (showProgress) {
 368       char ed1[50];
 369       struct stat sb;
 370       fstat(dev->fd(), &sb);
 371       currentVolumeSize = sb.st_size;
 372       Pmsg1(000, _("First Volume Size = %s\n"),
 373          edit_uint64(currentVolumeSize, ed1));
 374    }
 375    return stat;
 376 }
 377
 378 static void do_scan()
 379 {
 380    attr = new_attr(bjcr);
 381
 382    memset(&ar, 0, sizeof(ar));
 383    memset(&pr, 0, sizeof(pr));
 384    memset(&jr, 0, sizeof(jr));
 385    memset(&cr, 0, sizeof(cr));
 386    memset(&fsr, 0, sizeof(fsr));
 387    memset(&fr, 0, sizeof(fr));
 388
 389    /* Detach bscan's jcr as we are not a real Job on the tape */
 390
 391    read_records(bjcr->read_dcr, record_cb, bscan_mount_next_read_volume);
 392
 393    if (update_db) {
 394       db_write_batch_file_records(bjcr); /* used by bulk batch file insert */
 395    }
 396    free_attr(attr);
 397 }
 398
 399 /*
 400  * Returns: true  if OK
 401  *          false if error
 402  */
 403 static bool record_cb(DCR *dcr, DEV_RECORD *rec)
 404 {
 405    JCR *mjcr;
 406    char ec1[30];
 407    DEVICE *dev = dcr->dev;
 408    JCR *bjcr = dcr->jcr;
 409    DEV_BLOCK *block = dcr->block;
 410    POOL_MEM sql_buffer;
 411    db_int64_ctx jmr_count;
 412
 413    char digest[BASE64_SIZE(CRYPTO_DIGEST_MAX_SIZE)];
 414
 415    if (rec->data_len > 0) {
 416       mr.VolBytes += rec->data_len + WRITE_RECHDR_LENGTH; /* Accumulate Volume bytes */
 417       if (showProgress && currentVolumeSize > 0) {
 418          int pct = (mr.VolBytes * 100) / currentVolumeSize;
 419          if (pct != last_pct) {
 420             fprintf(stdout, _("done: %d%%\n"), pct);
 421             fflush(stdout);
 422             last_pct = pct;
 423          }
 424       }
 425    }
 426
 427    if (list_records) {
 428       Pmsg5(000, _("Record: SessId=%u SessTim=%u FileIndex=%d Stream=%d len=%u\n"),
 429             rec->VolSessionId, rec->VolSessionTime, rec->FileIndex,
 430             rec->Stream, rec->data_len);
 431    }
 432    /*
 433     * Check for Start or End of Session Record
 434     *
 435     */
 436    if (rec->FileIndex < 0) {
 437       bool save_update_db = update_db;
 438
 439       if (verbose > 1) {
 440          dump_label_record(dev, rec, 1);
 441       }
 442       switch (rec->FileIndex) {
 443       case PRE_LABEL:
 444          Pmsg0(000, _("Volume is prelabeled. This tape cannot be scanned.\n"));
 445          return false;
 446          break;
 447
 448       case VOL_LABEL:
 449          unser_volume_label(dev, rec);
 450          /* Check Pool info */
 451          bstrncpy(pr.Name, dev->VolHdr.PoolName, sizeof(pr.Name));
 452          bstrncpy(pr.PoolType, dev->VolHdr.PoolType, sizeof(pr.PoolType));
 453          num_pools++;
 454          if (db_get_pool_record(bjcr, db, &pr)) {
 455             if (verbose) {
 456                Pmsg1(000, _("Pool record for %s found in DB.\n"), pr.Name);
 457             }
 458          } else {
 459             if (!update_db) {
 460                Pmsg1(000, _("VOL_LABEL: Pool record not found for Pool: %s\n"),
 461                   pr.Name);
 462             }
 463             create_pool_record(db, &pr);
 464          }
 465          if (strcmp(pr.PoolType, dev->VolHdr.PoolType) != 0) {
 466             Pmsg2(000, _("VOL_LABEL: PoolType mismatch. DB=%s Vol=%s\n"),
 467                pr.PoolType, dev->VolHdr.PoolType);
 468             return true;
 469          } else if (verbose) {
 470             Pmsg1(000, _("Pool type \"%s\" is OK.\n"), pr.PoolType);
 471          }
 472
 473          /* Check Media Info */
 474          memset(&mr, 0, sizeof(mr));
 475          bstrncpy(mr.VolumeName, dev->VolHdr.VolumeName, sizeof(mr.VolumeName));
 476          mr.PoolId = pr.PoolId;
 477          num_media++;
 478          if (db_get_media_record(bjcr, db, &mr)) {
 479             if (verbose) {
 480                Pmsg1(000, _("Media record for %s found in DB.\n"), mr.VolumeName);
 481             }
 482             /* Clear out some volume statistics that will be updated */
 483             mr.VolJobs = mr.VolFiles = mr.VolBlocks = 0;
 484             mr.VolBytes = rec->data_len + 20;
 485          } else {
 486             if (!update_db) {
 487                Pmsg1(000, _("VOL_LABEL: Media record not found for Volume: %s\n"),
 488                   mr.VolumeName);
 489             }
 490             bstrncpy(mr.MediaType, dev->VolHdr.MediaType, sizeof(mr.MediaType));
 491             create_media_record(db, &mr, &dev->VolHdr);
 492          }
 493          if (strcmp(mr.MediaType, dev->VolHdr.MediaType) != 0) {
 494             Pmsg2(000, _("VOL_LABEL: MediaType mismatch. DB=%s Vol=%s\n"),
 495                mr.MediaType, dev->VolHdr.MediaType);
 496             return true;              /* ignore error */
 497          } else if (verbose) {
 498             Pmsg1(000, _("Media type \"%s\" is OK.\n"), mr.MediaType);
 499          }
 500          /* Reset some DCR variables */
 501          foreach_dlist(dcr, dev->attached_dcrs) {
 502             dcr->VolFirstIndex = dcr->FileIndex = 0;
 503             dcr->StartBlock = dcr->EndBlock = 0;
 504             dcr->StartFile = dcr->EndFile = 0;
 505             dcr->VolMediaId = 0;
 506          }
 507
 508          Pmsg1(000, _("VOL_LABEL: OK for Volume: %s\n"), mr.VolumeName);
 509          break;
 510
 511       case SOS_LABEL:
 512          mr.VolJobs++;
 513          num_jobs++;
 514          if (ignored_msgs > 0) {
 515             Pmsg1(000, _("%d \"errors\" ignored before first Start of Session record.\n"),
 516                   ignored_msgs);
 517             ignored_msgs = 0;
 518          }
 519          unser_session_label(&label, rec);
 520          memset(&jr, 0, sizeof(jr));
 521          bstrncpy(jr.Job, label.Job, sizeof(jr.Job));
 522          if (db_get_job_record(bjcr, db, &jr)) {
 523             /* Job record already exists in DB */
 524             update_db = false;  /* don't change db in create_job_record */
 525             if (verbose) {
 526                Pmsg1(000, _("SOS_LABEL: Found Job record for JobId: %d\n"), jr.JobId);
 527             }
 528          } else {
 529             /* Must create a Job record in DB */
 530             if (!update_db) {
 531                Pmsg1(000, _("SOS_LABEL: Job record not found for JobId: %d\n"),
 532                   jr.JobId);
 533             }
 534          }
 535
 536          /* Create Client record if not already there */
 537          bstrncpy(cr.Name, label.ClientName, sizeof(cr.Name));
 538          create_client_record(db, &cr);
 539          jr.ClientId = cr.ClientId;
 540
 541          /* process label, if Job record exists don't update db */
 542          mjcr = create_job_record(db, &jr, &label, rec);
 543          dcr = mjcr->read_dcr;
 544          update_db = save_update_db;
 545
 546          jr.PoolId = pr.PoolId;
 547          mjcr->start_time = jr.StartTime;
 548          mjcr->setJobLevel(jr.JobLevel);
 549
 550          mjcr->client_name = get_pool_memory(PM_FNAME);
 551          pm_strcpy(mjcr->client_name, label.ClientName);
 552          mjcr->fileset_name = get_pool_memory(PM_FNAME);
 553          pm_strcpy(mjcr->fileset_name, label.FileSetName);
 554          bstrncpy(dcr->pool_type, label.PoolType, sizeof(dcr->pool_type));
 555          bstrncpy(dcr->pool_name, label.PoolName, sizeof(dcr->pool_name));
 556
 557          /* Look for existing Job Media records for this job.  If there are
 558             any, no new ones need be created.  This may occur if File
 559             Retention has expired before Job Retention, or if the volume
 560             has already been bscan'd */
 561          Mmsg(sql_buffer, "SELECT count(*) from JobMedia where JobId=%d", jr.JobId);
 562          db_sql_query(db, sql_buffer.c_str(), db_int64_handler, &jmr_count);
 563          if( jmr_count.value > 0 ) {
 564             //FIELD NAME TO BE DEFINED/CONFIRMED (maybe a struct?)
 565             mjcr->bscan_insert_jobmedia_records = false;
 566          } else {
 567             mjcr->bscan_insert_jobmedia_records = true;
 568          }
 569
 570          if (rec->VolSessionId != jr.VolSessionId) {
 571             Pmsg3(000, _("SOS_LABEL: VolSessId mismatch for JobId=%u. DB=%d Vol=%d\n"),
 572                jr.JobId,
 573                jr.VolSessionId, rec->VolSessionId);
 574             return true;              /* ignore error */
 575          }
 576          if (rec->VolSessionTime != jr.VolSessionTime) {
 577             Pmsg3(000, _("SOS_LABEL: VolSessTime mismatch for JobId=%u. DB=%d Vol=%d\n"),
 578                jr.JobId,
 579                jr.VolSessionTime, rec->VolSessionTime);
 580             return true;              /* ignore error */
 581          }
 582          if (jr.PoolId != pr.PoolId) {
 583             Pmsg3(000, _("SOS_LABEL: PoolId mismatch for JobId=%u. DB=%d Vol=%d\n"),
 584                jr.JobId,
 585                jr.PoolId, pr.PoolId);
 586             return true;              /* ignore error */
 587          }
 588          break;
 589
 590       case EOS_LABEL:
 591          unser_session_label(&elabel, rec);
 592
 593          /* Create FileSet record */
 594          bstrncpy(fsr.FileSet, label.FileSetName, sizeof(fsr.FileSet));
 595          bstrncpy(fsr.MD5, label.FileSetMD5, sizeof(fsr.MD5));
 596          create_fileset_record(db, &fsr);
 597          jr.FileSetId = fsr.FileSetId;
 598
 599          mjcr = get_jcr_by_session(rec->VolSessionId, rec->VolSessionTime);
 600          if (!mjcr) {
 601             Pmsg2(000, _("Could not find SessId=%d SessTime=%d for EOS record.\n"),
 602                   rec->VolSessionId, rec->VolSessionTime);
 603             break;
 604          }
 605
 606          /* Do the final update to the Job record */
 607          update_job_record(db, &jr, &elabel, rec);
 608
 609          mjcr->end_time = jr.EndTime;
 610          mjcr->JobStatus = JS_Terminated;
 611
 612          /* Create JobMedia record */
 613          mjcr->read_dcr->VolLastIndex = dcr->VolLastIndex;
 614          if( mjcr->bscan_insert_jobmedia_records ) {
 615             create_jobmedia_record(db, mjcr);
 616          }
 617          free_dcr(mjcr->read_dcr);
 618          free_jcr(mjcr);
 619
 620          break;
 621
 622       case EOM_LABEL:
 623          break;
 624
 625       case EOT_LABEL:              /* end of all tapes */
 626          /*
 627           * Wiffle through all jobs still open and close
 628           *   them.
 629           */
 630          if (update_db) {
 631             DCR *mdcr;
 632             foreach_dlist(mdcr, dev->attached_dcrs) {
 633                JCR *mjcr = mdcr->jcr;
 634                if (!mjcr || mjcr->JobId == 0) {
 635                   continue;
 636                }
 637                jr.JobId = mjcr->JobId;
 638                /* Mark Job as Error Terimined */
 639                jr.JobStatus = JS_ErrorTerminated;
 640                jr.JobFiles = mjcr->JobFiles;
 641                jr.JobBytes = mjcr->JobBytes;
 642                jr.VolSessionId = mjcr->VolSessionId;
 643                jr.VolSessionTime = mjcr->VolSessionTime;
 644                jr.JobTDate = (utime_t)mjcr->start_time;
 645                jr.ClientId = mjcr->ClientId;
 646                if (!db_update_job_end_record(bjcr, db, &jr)) {
 647                   Pmsg1(0, _("Could not update job record. ERR=%s\n"), db_strerror(db));
 648                }
 649                mjcr->read_dcr = NULL;
 650                free_jcr(mjcr);
 651             }
 652          }
 653          mr.VolFiles = rec->File;
 654          mr.VolBlocks = rec->Block;
 655          mr.VolBytes += mr.VolBlocks * WRITE_BLKHDR_LENGTH; /* approx. */
 656          mr.VolMounts++;
 657          update_media_record(db, &mr);
 658          Pmsg3(0, _("End of all Volumes. VolFiles=%u VolBlocks=%u VolBytes=%s\n"), mr.VolFiles,
 659                     mr.VolBlocks, edit_uint64_with_commas(mr.VolBytes, ec1));
 660          break;
 661       default:
 662          break;
 663       } /* end switch */
 664       return true;
 665    }
 666
 667    mjcr = get_jcr_by_session(rec->VolSessionId, rec->VolSessionTime);
 668    if (!mjcr) {
 669       if (mr.VolJobs > 0) {
 670          Pmsg2(000, _("Could not find Job for SessId=%d SessTime=%d record.\n"),
 671                       rec->VolSessionId, rec->VolSessionTime);
 672       } else {
 673          ignored_msgs++;
 674       }
 675       return true;
 676    }
 677    dcr = mjcr->read_dcr;
 678    if (dcr->VolFirstIndex == 0) {
 679       dcr->VolFirstIndex = block->FirstIndex;
 680    }
 681
 682    /* File Attributes stream */
 683    switch (rec->maskedStream) {
 684    case STREAM_UNIX_ATTRIBUTES:
 685    case STREAM_UNIX_ATTRIBUTES_EX:
 686
 687       if (!unpack_attributes_record(bjcr, rec->Stream, rec->data, rec->data_len, attr)) {
 688          Emsg0(M_ERROR_TERM, 0, _("Cannot continue.\n"));
 689       }
 690
 691       if (verbose > 1) {
 692          decode_stat(attr->attr, &attr->statp, sizeof(attr->statp), &attr->LinkFI);
 693          build_attr_output_fnames(bjcr, attr);
 694          print_ls_output(bjcr, attr);
 695       }
 696       fr.JobId = mjcr->JobId;
 697       fr.FileId = 0;
 698       num_files++;
 699       if (verbose && (num_files & 0x7FFF) == 0) {
 700          char ed1[30], ed2[30], ed3[30], ed4[30];
 701          Pmsg4(000, _("%s file records. At file:blk=%s:%s bytes=%s\n"),
 702                      edit_uint64_with_commas(num_files, ed1),
 703                      edit_uint64_with_commas(rec->File, ed2),
 704                      edit_uint64_with_commas(rec->Block, ed3),
 705                      edit_uint64_with_commas(mr.VolBytes, ed4));
 706       }
 707       create_file_attributes_record(db, mjcr, attr->fname, attr->lname,
 708             attr->type, attr->attr, rec);
 709       free_jcr(mjcr);
 710       break;
 711
 712    case STREAM_RESTORE_OBJECT:
 713    /* ****FIXME*****/
 714       /* Implement putting into catalog */
 715       break;
 716
 717    /* Data stream */
 718    case STREAM_WIN32_DATA:
 719    case STREAM_FILE_DATA:
 720    case STREAM_SPARSE_DATA:
 721    case STREAM_MACOS_FORK_DATA:
 722    case STREAM_ENCRYPTED_FILE_DATA:
 723    case STREAM_ENCRYPTED_WIN32_DATA:
 724    case STREAM_ENCRYPTED_MACOS_FORK_DATA:
 725       /*
 726        * For encrypted stream, this is an approximation.
 727        * The data must be decrypted to know the correct length.
 728        */
 729       mjcr->JobBytes += rec->data_len;
 730       if (rec->maskedStream == STREAM_SPARSE_DATA) {
 731          mjcr->JobBytes -= sizeof(uint64_t);
 732       }
 733
 734       free_jcr(mjcr);                 /* done using JCR */
 735       break;
 736
 737    case STREAM_GZIP_DATA:
 738    case STREAM_COMPRESSED_DATA:
 739    case STREAM_ENCRYPTED_FILE_GZIP_DATA:
 740    case STREAM_ENCRYPTED_FILE_COMPRESSED_DATA:
 741    case STREAM_ENCRYPTED_WIN32_GZIP_DATA:
 742    case STREAM_ENCRYPTED_WIN32_COMPRESSED_DATA:
 743       /* No correct, we should (decrypt and) expand it
 744          done using JCR
 745       */
 746       mjcr->JobBytes += rec->data_len;
 747       free_jcr(mjcr);
 748       break;
 749
 750    case STREAM_SPARSE_GZIP_DATA:
 751    case STREAM_SPARSE_COMPRESSED_DATA:
 752       mjcr->JobBytes += rec->data_len - sizeof(uint64_t); /* No correct, we should expand it */
 753       free_jcr(mjcr);                 /* done using JCR */
 754       break;
 755
 756    /* Win32 GZIP stream */
 757    case STREAM_WIN32_GZIP_DATA:
 758    case STREAM_WIN32_COMPRESSED_DATA:
 759       mjcr->JobBytes += rec->data_len;
 760       free_jcr(mjcr);                 /* done using JCR */
 761       break;
 762
 763    case STREAM_MD5_DIGEST:
 764       bin_to_base64(digest, sizeof(digest), (char *)rec->data, CRYPTO_DIGEST_MD5_SIZE, true);
 765       if (verbose > 1) {
 766          Pmsg1(000, _("Got MD5 record: %s\n"), digest);
 767       }
 768       update_digest_record(db, digest, rec, CRYPTO_DIGEST_MD5);
 769       break;
 770
 771    case STREAM_SHA1_DIGEST:
 772       bin_to_base64(digest, sizeof(digest), (char *)rec->data, CRYPTO_DIGEST_SHA1_SIZE, true);
 773       if (verbose > 1) {
 774          Pmsg1(000, _("Got SHA1 record: %s\n"), digest);
 775       }
 776       update_digest_record(db, digest, rec, CRYPTO_DIGEST_SHA1);
 777       break;
 778
 779    case STREAM_SHA256_DIGEST:
 780       bin_to_base64(digest, sizeof(digest), (char *)rec->data, CRYPTO_DIGEST_SHA256_SIZE, true);
 781       if (verbose > 1) {
 782          Pmsg1(000, _("Got SHA256 record: %s\n"), digest);
 783       }
 784       update_digest_record(db, digest, rec, CRYPTO_DIGEST_SHA256);
 785       break;
 786
 787    case STREAM_SHA512_DIGEST:
 788       bin_to_base64(digest, sizeof(digest), (char *)rec->data, CRYPTO_DIGEST_SHA512_SIZE, true);
 789       if (verbose > 1) {
 790          Pmsg1(000, _("Got SHA512 record: %s\n"), digest);
 791       }
 792       update_digest_record(db, digest, rec, CRYPTO_DIGEST_SHA512);
 793       break;
 794
 795    case STREAM_ENCRYPTED_SESSION_DATA:
 796       // TODO landonf: Investigate crypto support in bscan
 797       if (verbose > 1) {
 798          Pmsg0(000, _("Got signed digest record\n"));
 799       }
 800       break;
 801
 802    case STREAM_SIGNED_DIGEST:
 803       // TODO landonf: Investigate crypto support in bscan
 804       if (verbose > 1) {
 805          Pmsg0(000, _("Got signed digest record\n"));
 806       }
 807       break;
 808
 809    case STREAM_PROGRAM_NAMES:
 810       if (verbose) {
 811          Pmsg1(000, _("Got Prog Names Stream: %s\n"), rec->data);
 812       }
 813       break;
 814
 815    case STREAM_PROGRAM_DATA:
 816       if (verbose > 1) {
 817          Pmsg0(000, _("Got Prog Data Stream record.\n"));
 818       }
 819       break;
 820
 821    case STREAM_UNIX_ACCESS_ACL:          /* Deprecated Standard ACL attributes on UNIX */
 822    case STREAM_UNIX_DEFAULT_ACL:         /* Deprecated Default ACL attributes on UNIX */
 823    case STREAM_HFSPLUS_ATTRIBUTES:
 824    case STREAM_ACL_AIX_TEXT:
 825    case STREAM_ACL_DARWIN_ACCESS_ACL:
 826    case STREAM_ACL_FREEBSD_DEFAULT_ACL:
 827    case STREAM_ACL_FREEBSD_ACCESS_ACL:
 828    case STREAM_ACL_HPUX_ACL_ENTRY:
 829    case STREAM_ACL_IRIX_DEFAULT_ACL:
 830    case STREAM_ACL_IRIX_ACCESS_ACL:
 831    case STREAM_ACL_LINUX_DEFAULT_ACL:
 832    case STREAM_ACL_LINUX_ACCESS_ACL:
 833    case STREAM_ACL_TRU64_DEFAULT_ACL:
 834    case STREAM_ACL_TRU64_DEFAULT_DIR_ACL:
 835    case STREAM_ACL_TRU64_ACCESS_ACL:
 836    case STREAM_ACL_SOLARIS_ACLENT:
 837    case STREAM_ACL_SOLARIS_ACE:
 838    case STREAM_ACL_AFS_TEXT:
 839    case STREAM_ACL_AIX_AIXC:
 840    case STREAM_ACL_AIX_NFS4:
 841    case STREAM_ACL_FREEBSD_NFS4_ACL:
 842    case STREAM_ACL_HURD_DEFAULT_ACL:
 843    case STREAM_ACL_HURD_ACCESS_ACL:
 844       /* Ignore Unix ACL attributes */
 845       break;
 846
 847    case STREAM_XATTR_TRU64:
 848    case STREAM_XATTR_AIX:
 849    case STREAM_XATTR_OPENBSD:
 850    case STREAM_XATTR_SOLARIS_SYS:
 851    case STREAM_XATTR_SOLARIS:
 852    case STREAM_XATTR_DARWIN:
 853    case STREAM_XATTR_FREEBSD:
 854    case STREAM_XATTR_LINUX:
 855    case STREAM_XATTR_NETBSD:
 856       /* Ignore Unix Extended attributes */
 857       break;
 858
 859    default:
 860       Pmsg2(0, _("Unknown stream type!!! stream=%d len=%i\n"), rec->Stream, rec->data_len);
 861       break;
 862    }
 863    return true;
 864 }
 865
 866 /*
 867  * Free the Job Control Record if no one is still using it.
 868  *  Called from main free_jcr() routine in src/lib/jcr.c so
 869  *  that we can do our Director specific cleanup of the jcr.
 870  */
 871 static void bscan_free_jcr(JCR *jcr)
 872 {
 873    Dmsg0(200, "Start bscan free_jcr\n");
 874
 875    if (jcr->file_bsock) {
 876       Dmsg0(200, "Close File bsock\n");
 877       jcr->file_bsock->close();
 878    }
 879    if (jcr->store_bsock) {
 880       Dmsg0(200, "Close Store bsock\n");
 881       jcr->store_bsock->close();
 882    }
 883    if (jcr->RestoreBootstrap) {
 884       free(jcr->RestoreBootstrap);
 885    }
 886    if (jcr->dcr) {
 887       free_dcr(jcr->dcr);
 888       jcr->dcr = NULL;
 889    }
 890    if (jcr->read_dcr) {
 891       free_dcr(jcr->read_dcr);
 892       jcr->read_dcr = NULL;
 893    }
 894    Dmsg0(200, "End bscan free_jcr\n");
 895 }
 896
 897 /*
 898  * We got a File Attributes record on the tape.  Now, lookup the Job
 899  *   record, and then create the attributes record.
 900  */
 901 static int create_file_attributes_record(B_DB *db, JCR *mjcr,
 902                                char *fname, char *lname, int type,
 903                                char *ap, DEV_RECORD *rec)
 904 {
 905    DCR *dcr = mjcr->read_dcr;
 906    ar.fname = fname;
 907    ar.link = lname;
 908    ar.ClientId = mjcr->ClientId;
 909    ar.JobId = mjcr->JobId;
 910    ar.Stream = rec->Stream;
 911    if (type == FT_DELETED) {
 912       ar.FileIndex = 0;
 913    } else {
 914       ar.FileIndex = rec->FileIndex;
 915    }
 916    ar.attr = ap;
 917    if (dcr->VolFirstIndex == 0) {
 918       dcr->VolFirstIndex = rec->FileIndex;
 919    }
 920    dcr->FileIndex = rec->FileIndex;
 921    mjcr->JobFiles++;
 922
 923    if (!update_db) {
 924       return 1;
 925    }
 926
 927    if (!db_create_file_attributes_record(bjcr, db, &ar)) {
 928       Pmsg1(0, _("Could not create File Attributes record. ERR=%s\n"), db_strerror(db));
 929       return 0;
 930    }
 931    mjcr->FileId = ar.FileId;
 932
 933    if (verbose > 1) {
 934       Pmsg1(000, _("Created File record: %s\n"), fname);
 935    }
 936    return 1;
 937 }
 938
 939 /*
 940  * For each Volume we see, we create a Medium record
 941  */
 942 static int create_media_record(B_DB *db, MEDIA_DBR *mr, VOLUME_LABEL *vl)
 943 {
 944    struct date_time dt;
 945    struct tm tm;
 946
 947    /* We mark Vols as Archive to keep them from being re-written */
 948    bstrncpy(mr->VolStatus, "Archive", sizeof(mr->VolStatus));
 949    mr->VolRetention = 365 * 3600 * 24; /* 1 year */
 950    mr->Enabled = 1;
 951    if (vl->VerNum >= 11) {
 952       mr->set_first_written = true; /* Save FirstWritten during update_media */
 953       mr->FirstWritten = btime_to_utime(vl->write_btime);
 954       mr->LabelDate    = btime_to_utime(vl->label_btime);
 955    } else {
 956       /* DEPRECATED DO NOT USE */
 957       dt.julian_day_number = vl->write_date;
 958       dt.julian_day_fraction = vl->write_time;
 959       tm_decode(&dt, &tm);
 960       mr->FirstWritten = mktime(&tm);
 961       dt.julian_day_number = vl->label_date;
 962       dt.julian_day_fraction = vl->label_time;
 963       tm_decode(&dt, &tm);
 964       mr->LabelDate = mktime(&tm);
 965    }
 966    lasttime = mr->LabelDate;
 967    if (mr->VolJobs == 0) {
 968       mr->VolJobs = 1;
 969    }
 970    if (mr->VolMounts == 0) {
 971       mr->VolMounts = 1;
 972    }
 973
 974    if (!update_db) {
 975       return 1;
 976    }
 977
 978    if (!db_create_media_record(bjcr, db, mr)) {
 979       Pmsg1(0, _("Could not create media record. ERR=%s\n"), db_strerror(db));
 980       return 0;
 981    }
 982    if (!db_update_media_record(bjcr, db, mr)) {
 983       Pmsg1(0, _("Could not update media record. ERR=%s\n"), db_strerror(db));
 984       return 0;
 985    }
 986    if (verbose) {
 987       Pmsg1(000, _("Created Media record for Volume: %s\n"), mr->VolumeName);
 988    }
 989    return 1;
 990
 991 }
 992
 993 /*
 994  * Called at end of media to update it
 995  */
 996 static bool update_media_record(B_DB *db, MEDIA_DBR *mr)
 997 {
 998    if (!update_db && !update_vol_info) {
 999       return true;
1000    }
1001
1002    mr->LastWritten = lasttime;
1003    if (!db_update_media_record(bjcr, db, mr)) {
1004       Pmsg1(0, _("Could not update media record. ERR=%s\n"), db_strerror(db));
1005       return false;;
1006    }
1007    if (verbose) {
1008       Pmsg1(000, _("Updated Media record at end of Volume: %s\n"), mr->VolumeName);
1009    }
1010    return true;
1011
1012 }
1013
1014
1015 static int create_pool_record(B_DB *db, POOL_DBR *pr)
1016 {
1017    pr->NumVols++;
1018    pr->UseCatalog = 1;
1019    pr->VolRetention = 355 * 3600 * 24; /* 1 year */
1020
1021    if (!update_db) {
1022       return 1;
1023    }
1024    if (!db_create_pool_record(bjcr, db, pr)) {
1025       Pmsg1(0, _("Could not create pool record. ERR=%s\n"), db_strerror(db));
1026       return 0;
1027    }
1028    if (verbose) {
1029       Pmsg1(000, _("Created Pool record for Pool: %s\n"), pr->Name);
1030    }
1031    return 1;
1032
1033 }
1034
1035
1036 /*
1037  * Called from SOS to create a client for the current Job
1038  */
1039 static int create_client_record(B_DB *db, CLIENT_DBR *cr)
1040 {
1041    /*
1042     * Note, update_db can temporarily be set false while
1043     * updating the database, so we must ensure that ClientId is non-zero.
1044     */
1045    if (!update_db) {
1046       cr->ClientId = 0;
1047       if (!db_get_client_record(bjcr, db, cr)) {
1048         Pmsg1(0, _("Could not get Client record. ERR=%s\n"), db_strerror(db));
1049         return 0;
1050       }
1051       return 1;
1052    }
1053    if (!db_create_client_record(bjcr, db, cr)) {
1054       Pmsg1(0, _("Could not create Client record. ERR=%s\n"), db_strerror(db));
1055       return 0;
1056    }
1057    if (verbose) {
1058       Pmsg1(000, _("Created Client record for Client: %s\n"), cr->Name);
1059    }
1060    return 1;
1061 }
1062
1063 static int create_fileset_record(B_DB *db, FILESET_DBR *fsr)
1064 {
1065    if (!update_db) {
1066       return 1;
1067    }
1068    fsr->FileSetId = 0;
1069    if (fsr->MD5[0] == 0) {
1070       fsr->MD5[0] = ' ';              /* Equivalent to nothing */
1071       fsr->MD5[1] = 0;
1072    }
1073    if (db_get_fileset_record(bjcr, db, fsr)) {
1074       if (verbose) {
1075          Pmsg1(000, _("Fileset \"%s\" already exists.\n"), fsr->FileSet);
1076       }
1077    } else {
1078       if (!db_create_fileset_record(bjcr, db, fsr)) {
1079          Pmsg2(0, _("Could not create FileSet record \"%s\". ERR=%s\n"),
1080             fsr->FileSet, db_strerror(db));
1081          return 0;
1082       }
1083       if (verbose) {
1084          Pmsg1(000, _("Created FileSet record \"%s\"\n"), fsr->FileSet);
1085       }
1086    }
1087    return 1;
1088 }
1089
1090 /*
1091  * Simulate the two calls on the database to create
1092  *  the Job record and to update it when the Job actually
1093  *  begins running.
1094  */
1095 static JCR *create_job_record(B_DB *db, JOB_DBR *jr, SESSION_LABEL *label,
1096                              DEV_RECORD *rec)
1097 {
1098    JCR *mjcr;
1099    struct date_time dt;
1100    struct tm tm;
1101
1102    jr->JobId = label->JobId;
1103    jr->JobType = label->JobType;
1104    jr->JobLevel = label->JobLevel;
1105    jr->JobStatus = JS_Created;
1106    bstrncpy(jr->Name, label->JobName, sizeof(jr->Name));
1107    bstrncpy(jr->Job, label->Job, sizeof(jr->Job));
1108    if (label->VerNum >= 11) {
1109       jr->SchedTime = btime_to_unix(label->write_btime);
1110    } else {
1111       dt.julian_day_number = label->write_date;
1112       dt.julian_day_fraction = label->write_time;
1113       tm_decode(&dt, &tm);
1114       jr->SchedTime = mktime(&tm);
1115    }
1116
1117    jr->StartTime = jr->SchedTime;
1118    jr->JobTDate = (utime_t)jr->SchedTime;
1119    jr->VolSessionId = rec->VolSessionId;
1120    jr->VolSessionTime = rec->VolSessionTime;
1121
1122    /* Now create a JCR as if starting the Job */
1123    mjcr = create_jcr(jr, rec, label->JobId);
1124
1125    if (!update_db) {
1126       return mjcr;
1127    }
1128
1129    /* This creates the bare essentials */
1130    if (!db_create_job_record(bjcr, db, jr)) {
1131       Pmsg1(0, _("Could not create JobId record. ERR=%s\n"), db_strerror(db));
1132       return mjcr;
1133    }
1134
1135    /* This adds the client, StartTime, JobTDate, ... */
1136    if (!db_update_job_start_record(bjcr, db, jr)) {
1137       Pmsg1(0, _("Could not update job start record. ERR=%s\n"), db_strerror(db));
1138       return mjcr;
1139    }
1140    Pmsg2(000, _("Created new JobId=%u record for original JobId=%u\n"), jr->JobId,
1141          label->JobId);
1142    mjcr->JobId = jr->JobId;           /* set new JobId */
1143    return mjcr;
1144 }
1145
1146 /*
1147  * Simulate the database call that updates the Job
1148  *  at Job termination time.
1149  */
1150 static int update_job_record(B_DB *db, JOB_DBR *jr, SESSION_LABEL *elabel,
1151                               DEV_RECORD *rec)
1152 {
1153    struct date_time dt;
1154    struct tm tm;
1155    JCR *mjcr;
1156
1157    mjcr = get_jcr_by_session(rec->VolSessionId, rec->VolSessionTime);
1158    if (!mjcr) {
1159       Pmsg2(000, _("Could not find SessId=%d SessTime=%d for EOS record.\n"),
1160                    rec->VolSessionId, rec->VolSessionTime);
1161       return 0;
1162    }
1163    if (elabel->VerNum >= 11) {
1164       jr->EndTime = btime_to_unix(elabel->write_btime);
1165    } else {
1166       dt.julian_day_number = elabel->write_date;
1167       dt.julian_day_fraction = elabel->write_time;
1168       tm_decode(&dt, &tm);
1169       jr->EndTime = mktime(&tm);
1170    }
1171    lasttime = jr->EndTime;
1172    mjcr->end_time = jr->EndTime;
1173
1174    jr->JobId = mjcr->JobId;
1175    jr->JobStatus = elabel->JobStatus;
1176    mjcr->JobStatus = elabel->JobStatus;
1177    jr->JobFiles = elabel->JobFiles;
1178    if (jr->JobFiles > 0) {  /* If we found files, force PurgedFiles */
1179       jr->PurgedFiles = 0;
1180    }
1181    jr->JobBytes = elabel->JobBytes;
1182    jr->VolSessionId = rec->VolSessionId;
1183    jr->VolSessionTime = rec->VolSessionTime;
1184    jr->JobTDate = (utime_t)mjcr->start_time;
1185    jr->ClientId = mjcr->ClientId;
1186
1187    if (!update_db) {
1188       free_jcr(mjcr);
1189       return 1;
1190    }
1191
1192    if (!db_update_job_end_record(bjcr, db, jr)) {
1193       Pmsg2(0, _("Could not update JobId=%u record. ERR=%s\n"), jr->JobId,  db_strerror(db));
1194       free_jcr(mjcr);
1195       return 0;
1196    }
1197    if (verbose) {
1198       Pmsg3(000, _("Updated Job termination record for JobId=%u Level=%s TermStat=%c\n"),
1199          jr->JobId, job_level_to_str(mjcr->getJobLevel()), jr->JobStatus);
1200    }
1201    if (verbose > 1) {
1202       const char *term_msg;
1203       static char term_code[70];
1204       char sdt[50], edt[50];
1205       char ec1[30], ec2[30], ec3[30];
1206
1207       switch (mjcr->JobStatus) {
1208       case JS_Terminated:
1209          term_msg = _("Backup OK");
1210          break;
1211       case JS_Warnings:
1212          term_msg = _("Backup OK -- with warnings");
1213          break;
1214       case JS_FatalError:
1215       case JS_ErrorTerminated:
1216          term_msg = _("*** Backup Error ***");
1217          break;
1218       case JS_Canceled:
1219          term_msg = _("Backup Canceled");
1220          break;
1221       default:
1222          term_msg = term_code;
1223          sprintf(term_code, _("Job Termination code: %d"), mjcr->JobStatus);
1224          break;
1225       }
1226       bstrftime(sdt, sizeof(sdt), mjcr->start_time);
1227       bstrftime(edt, sizeof(edt), mjcr->end_time);
1228       Pmsg14(000,  _("%s\n"
1229 "JobId:                  %d\n"
1230 "Job:                    %s\n"
1231 "FileSet:                %s\n"
1232 "Backup Level:           %s\n"
1233 "Client:                 %s\n"
1234 "Start time:             %s\n"
1235 "End time:               %s\n"
1236 "Files Written:          %s\n"
1237 "Bytes Written:          %s\n"
1238 "Volume Session Id:      %d\n"
1239 "Volume Session Time:    %d\n"
1240 "Last Volume Bytes:      %s\n"
1241 "Termination:            %s\n\n"),
1242         edt,
1243         mjcr->JobId,
1244         mjcr->Job,
1245         mjcr->fileset_name,
1246         job_level_to_str(mjcr->getJobLevel()),
1247         mjcr->client_name,
1248         sdt,
1249         edt,
1250         edit_uint64_with_commas(mjcr->JobFiles, ec1),
1251         edit_uint64_with_commas(mjcr->JobBytes, ec2),
1252         mjcr->VolSessionId,
1253         mjcr->VolSessionTime,
1254         edit_uint64_with_commas(mr.VolBytes, ec3),
1255         term_msg);
1256    }
1257    free_jcr(mjcr);
1258    return 1;
1259 }
1260
1261 static int create_jobmedia_record(B_DB *db, JCR *mjcr)
1262 {
1263    JOBMEDIA_DBR jmr;
1264    DCR *dcr = mjcr->read_dcr;
1265
1266    dcr->EndBlock = dev->EndBlock;
1267    dcr->EndFile  = dev->EndFile;
1268    dcr->VolMediaId = dev->VolCatInfo.VolMediaId;
1269
1270    memset(&jmr, 0, sizeof(jmr));
1271    jmr.JobId = mjcr->JobId;
1272    jmr.MediaId = mr.MediaId;
1273    jmr.FirstIndex = dcr->VolFirstIndex;
1274    jmr.LastIndex = dcr->VolLastIndex;
1275    jmr.StartFile = dcr->StartFile;
1276    jmr.EndFile = dcr->EndFile;
1277    jmr.StartBlock = dcr->StartBlock;
1278    jmr.EndBlock = dcr->EndBlock;
1279
1280
1281    if (!update_db) {
1282       return 1;
1283    }
1284
1285    if (!db_create_jobmedia_record(bjcr, db, &jmr)) {
1286       Pmsg1(0, _("Could not create JobMedia record. ERR=%s\n"), db_strerror(db));
1287       return 0;
1288    }
1289    if (verbose) {
1290       Pmsg2(000, _("Created JobMedia record JobId %d, MediaId %d\n"),
1291                 jmr.JobId, jmr.MediaId);
1292    }
1293    return 1;
1294 }
1295
1296 /*
1297  * Simulate the database call that updates the MD5/SHA1 record
1298  */
1299 static int update_digest_record(B_DB *db, char *digest, DEV_RECORD *rec, int type)
1300 {
1301    JCR *mjcr;
1302
1303    mjcr = get_jcr_by_session(rec->VolSessionId, rec->VolSessionTime);
1304    if (!mjcr) {
1305       if (mr.VolJobs > 0) {
1306          Pmsg2(000, _("Could not find SessId=%d SessTime=%d for MD5/SHA1 record.\n"),
1307                       rec->VolSessionId, rec->VolSessionTime);
1308       } else {
1309          ignored_msgs++;
1310       }
1311       return 0;
1312    }
1313
1314    if (!update_db || mjcr->FileId == 0) {
1315       free_jcr(mjcr);
1316       return 1;
1317    }
1318
1319    if (!db_add_digest_to_file_record(bjcr, db, mjcr->FileId, digest, type)) {
1320       Pmsg1(0, _("Could not add MD5/SHA1 to File record. ERR=%s\n"), db_strerror(db));
1321       free_jcr(mjcr);
1322       return 0;
1323    }
1324    if (verbose > 1) {
1325       Pmsg0(000, _("Updated MD5/SHA1 record\n"));
1326    }
1327    free_jcr(mjcr);
1328    return 1;
1329 }
1330
1331
1332 /*
1333  * Create a JCR as if we are really starting the job
1334  */
1335 static JCR *create_jcr(JOB_DBR *jr, DEV_RECORD *rec, uint32_t JobId)
1336 {
1337    JCR *jobjcr;
1338    /*
1339     * Transfer as much as possible to the Job JCR. Most important is
1340     *   the JobId and the ClientId.
1341     */
1342    jobjcr = new_jcr(sizeof(JCR), bscan_free_jcr);
1343    jobjcr->setJobType(jr->JobType);
1344    jobjcr->setJobLevel(jr->JobLevel);
1345    jobjcr->JobStatus = jr->JobStatus;
1346    bstrncpy(jobjcr->Job, jr->Job, sizeof(jobjcr->Job));
1347    jobjcr->JobId = JobId;      /* this is JobId on tape */
1348    jobjcr->sched_time = jr->SchedTime;
1349    jobjcr->start_time = jr->StartTime;
1350    jobjcr->VolSessionId = rec->VolSessionId;
1351    jobjcr->VolSessionTime = rec->VolSessionTime;
1352    jobjcr->ClientId = jr->ClientId;
1353    jobjcr->dcr = jobjcr->read_dcr = new_dcr(jobjcr, NULL, dev);
1354
1355    return jobjcr;
1356 }
1357
1358 /* Dummies to replace askdir.c */
1359 bool    dir_find_next_appendable_volume(DCR *dcr) { return 1;}
1360 bool    dir_update_volume_info(DCR *dcr, bool relabel, bool update_LastWritten) { return 1; }
1361 bool    dir_create_jobmedia_record(DCR *dcr, bool zero) { return 1; }
1362 bool    dir_ask_sysop_to_create_appendable_volume(DCR *dcr) { return 1; }
1363 bool    dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
1364 bool    dir_send_job_status(JCR *jcr) {return 1;}
1365 int     generate_job_event(JCR *jcr, const char *event) { return 1; }
1366
1367 bool dir_ask_sysop_to_mount_volume(DCR *dcr, int /*mode*/)
1368 {
1369    DEVICE *dev = dcr->dev;
1370    Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
1371    /* Close device so user can use autochanger if desired */
1372    fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
1373          dcr->VolumeName, dev->print_name());
1374    dev->close();
1375    getchar();
1376    return true;
1377 }
1378
1379 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw  writing)
1380 {
1381    Dmsg0(100, "Fake dir_get_volume_info\n");
1382    dcr->setVolCatName(dcr->VolumeName);
1383    dcr->VolCatInfo.VolCatParts = find_num_dvd_parts(dcr);
1384    Dmsg2(500, "Vol=%s num_parts=%d\n", dcr->getVolCatName(), dcr->VolCatInfo.VolCatParts);
1385    return 1;
1386 }