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

   1 /*
   2  *
   3  *   Bacula Tape manipulation program
   4  *
   5  *    Has various tape manipulation commands -- mostly for
   6  *    use in determining how tapes really work.
   7  *
   8  *     Kern Sibbald, April MM
   9  *
  10  *   Note, this program reads stored.conf, and will only
  11  *     talk to devices that are configured.
  12  *
  13  *   Version $Id$
  14  *
  15  */
  16 /*
  17    Copyright (C) 2000-2006 Kern Sibbald
  18
  19    This program is free software; you can redistribute it and/or
  20    modify it under the terms of the GNU General Public License
  21    version 2 as amended with additional clauses defined in the
  22    file LICENSE in the main source directory.
  23
  24    This program is distributed in the hope that it will be useful,
  25    but WITHOUT ANY WARRANTY; without even the implied warranty of
  26    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  27    the file LICENSE for additional details.
  28
  29  */
  30
  31 #include "bacula.h"
  32 #include "stored.h"
  33
  34 /* Dummy functions */
  35 int generate_daemon_event(JCR *jcr, const char *event) { return 1; }
  36
  37 /* External subroutines */
  38 extern void free_config_resources();
  39
  40 /* Exported variables */
  41 int quit = 0;
  42 char buf[100000];
  43 int bsize = TAPE_BSIZE;
  44 char VolName[MAX_NAME_LENGTH];
  45 STORES *me = NULL;                    /* our Global resource */
  46 bool forge_on = false;                /* proceed inspite of I/O errors */
  47 pthread_mutex_t device_release_mutex = PTHREAD_MUTEX_INITIALIZER;
  48 pthread_cond_t wait_device_release = PTHREAD_COND_INITIALIZER;
  49
  50 /*
  51  * If you change the format of the state file,
  52  *  increment this value
  53  */
  54 static uint32_t btape_state_level = 2;
  55
  56 DEVICE *dev = NULL;
  57 DCR *dcr;
  58 DEVRES *device = NULL;
  59
  60
  61 /* Forward referenced subroutines */
  62 static void do_tape_cmds();
  63 static void helpcmd();
  64 static void scancmd();
  65 static void rewindcmd();
  66 static void clearcmd();
  67 static void wrcmd();
  68 static void rrcmd();
  69 static void eodcmd();
  70 static void fillcmd();
  71 static void qfillcmd();
  72 static void statcmd();
  73 static void unfillcmd();
  74 static int flush_block(DEV_BLOCK *block, int dump);
  75 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec);
  76 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block);
  77 static bool my_mount_next_read_volume(DCR *dcr);
  78 static void scan_blocks();
  79 static void set_volume_name(const char *VolName, int volnum);
  80 static void rawfill_cmd();
  81 static void bfill_cmd();
  82 static bool open_the_device();
  83 static void autochangercmd();
  84 static void do_unfill();
  85
  86
  87 /* Static variables */
  88 #define CONFIG_FILE "bacula-sd.conf"
  89 char *configfile = NULL;
  90
  91 #define MAX_CMD_ARGS 30
  92 static POOLMEM *cmd;
  93 static POOLMEM *args;
  94 static char *argk[MAX_CMD_ARGS];
  95 static char *argv[MAX_CMD_ARGS];
  96 static int argc;
  97
  98 static int quickie_count = 0;
  99 static uint64_t write_count = 0;
 100 static BSR *bsr = NULL;
 101 static int signals = TRUE;
 102 static bool ok;
 103 static int stop = 0;
 104 static uint64_t vol_size;
 105 static uint64_t VolBytes;
 106 static time_t now;
 107 static double kbs;
 108 static int32_t file_index;
 109 static int end_of_tape = 0;
 110 static uint32_t LastBlock = 0;
 111 static uint32_t eot_block;
 112 static uint32_t eot_block_len;
 113 static uint32_t eot_FileIndex;
 114 static int dumped = 0;
 115 static DEV_BLOCK *last_block1 = NULL;
 116 static DEV_BLOCK *last_block2 = NULL;
 117 static DEV_BLOCK *last_block = NULL;
 118 static DEV_BLOCK *this_block = NULL;
 119 static DEV_BLOCK *first_block = NULL;
 120 static uint32_t last_file1 = 0;
 121 static uint32_t last_file2 = 0;
 122 static uint32_t last_file = 0;
 123 static uint32_t last_block_num1 = 0;
 124 static uint32_t last_block_num2 = 0;
 125 static uint32_t last_block_num = 0;
 126 static uint32_t BlockNumber = 0;
 127 static bool simple = true;
 128
 129 static const char *VolumeName = NULL;
 130 static int vol_num = 0;
 131
 132 static JCR *jcr = NULL;
 133
 134
 135 static void usage();
 136 static void terminate_btape(int sig);
 137 int get_cmd(const char *prompt);
 138
 139
 140 /*********************************************************************
 141  *
 142  *     Bacula tape testing program
 143  *
 144  */
 145 int main(int margc, char *margv[])
 146 {
 147    int ch, i;
 148    uint32_t x32, y32;
 149    uint64_t x64, y64;
 150    char buf[1000];
 151
 152    setlocale(LC_ALL, "");
 153    bindtextdomain("bacula", LOCALEDIR);
 154    textdomain("bacula");
 155
 156    /* Sanity checks */
 157    if (TAPE_BSIZE % B_DEV_BSIZE != 0 || TAPE_BSIZE / B_DEV_BSIZE == 0) {
 158       Emsg2(M_ABORT, 0, _("Tape block size (%d) not multiple of system size (%d)\n"),
 159          TAPE_BSIZE, B_DEV_BSIZE);
 160    }
 161    if (TAPE_BSIZE != (1 << (ffs(TAPE_BSIZE)-1))) {
 162       Emsg1(M_ABORT, 0, _("Tape block size (%d) is not a power of 2\n"), TAPE_BSIZE);
 163    }
 164    if (sizeof(off_t) < 8) {
 165       Pmsg1(-1, _("\n\n!!!! Warning large disk addressing disabled. off_t=%d should be 8 or more !!!!!\n\n\n"),
 166          sizeof(off_t));
 167    }
 168    x32 = 123456789;
 169    bsnprintf(buf, sizeof(buf), "%u", x32);
 170    i = bsscanf(buf, "%u", &y32);
 171    if (i != 1 || x32 != y32) {
 172       Pmsg3(-1, _("32 bit printf/scanf problem. i=%d x32=%u y32=%u\n"), i, x32, y32);
 173       exit(1);
 174    }
 175    x64 = 123456789;
 176    x64 = x64 << 32;
 177    x64 += 123456789;
 178    bsnprintf(buf, sizeof(buf), "%" llu, x64);
 179    i = bsscanf(buf, "%llu", &y64);
 180    if (i != 1 || x64 != y64) {
 181       Pmsg3(-1, _("64 bit printf/scanf problem. i=%d x64=%" llu " y64=%" llu "\n"), i, x64, y64);
 182       exit(1);
 183    }
 184
 185    printf(_("Tape block granularity is %d bytes.\n"), TAPE_BSIZE);
 186
 187    working_directory = "/tmp";
 188    my_name_is(margc, margv, "btape");
 189    init_msg(NULL, NULL);
 190
 191    OSDependentInit();
 192
 193    while ((ch = getopt(margc, margv, "b:c:d:psv?")) != -1) {
 194       switch (ch) {
 195       case 'b':                    /* bootstrap file */
 196          bsr = parse_bsr(NULL, optarg);
 197 //       dump_bsr(bsr, true);
 198          break;
 199
 200       case 'c':                    /* specify config file */
 201          if (configfile != NULL) {
 202             free(configfile);
 203          }
 204          configfile = bstrdup(optarg);
 205          break;
 206
 207       case 'd':                    /* set debug level */
 208          debug_level = atoi(optarg);
 209          if (debug_level <= 0) {
 210             debug_level = 1;
 211          }
 212          break;
 213
 214       case 'p':
 215          forge_on = true;
 216          break;
 217
 218       case 's':
 219          signals = false;
 220          break;
 221
 222       case 'v':
 223          verbose++;
 224          break;
 225
 226       case '?':
 227       default:
 228          helpcmd();
 229          exit(0);
 230
 231       }
 232    }
 233    margc -= optind;
 234    margv += optind;
 235
 236    cmd = get_pool_memory(PM_FNAME);
 237    args = get_pool_memory(PM_FNAME);
 238
 239    if (signals) {
 240       init_signals(terminate_btape);
 241    }
 242
 243    if (configfile == NULL) {
 244       configfile = bstrdup(CONFIG_FILE);
 245    }
 246
 247    daemon_start_time = time(NULL);
 248
 249    parse_config(configfile);
 250
 251
 252    /* See if we can open a device */
 253    if (margc == 0) {
 254       Pmsg0(000, _("No archive name specified.\n"));
 255       usage();
 256       exit(1);
 257    } else if (margc != 1) {
 258       Pmsg0(000, _("Improper number of arguments specified.\n"));
 259       usage();
 260       exit(1);
 261    }
 262
 263    jcr = setup_jcr("btape", margv[0], bsr, NULL, 0); /* write */
 264    if (!jcr) {
 265       exit(1);
 266    }
 267    dev = jcr->dcr->dev;
 268    if (!dev) {
 269       exit(1);
 270    }
 271    dcr = jcr->dcr;
 272    if (!open_the_device()) {
 273       goto terminate;
 274    }
 275
 276    Dmsg0(200, "Do tape commands\n");
 277    do_tape_cmds();
 278
 279 terminate:
 280    terminate_btape(0);
 281    return 0;
 282 }
 283
 284 static void terminate_btape(int stat)
 285 {
 286
 287    sm_check(__FILE__, __LINE__, false);
 288    if (configfile) {
 289       free(configfile);
 290    }
 291    free_config_resources();
 292    if (args) {
 293       free_pool_memory(args);
 294       args = NULL;
 295    }
 296    if (cmd) {
 297       free_pool_memory(cmd);
 298       cmd = NULL;
 299    }
 300
 301    if (bsr) {
 302       free_bsr(bsr);
 303    }
 304
 305    free_jcr(jcr);
 306    jcr = NULL;
 307
 308    if (dev) {
 309       dev->term();
 310    }
 311
 312    if (debug_level > 10)
 313       print_memory_pool_stats();
 314
 315    if (this_block) {
 316       free_block(this_block);
 317    }
 318
 319    stop_watchdog();
 320    term_msg();
 321    close_memory_pool();               /* free memory in pool */
 322    term_last_jobs_list();
 323
 324    sm_dump(false);
 325    exit(stat);
 326 }
 327
 328 static bool open_the_device()
 329 {
 330    DEV_BLOCK *block;
 331
 332    block = new_block(dev);
 333    lock_device(dev);
 334    Dmsg1(200, "Opening device %s\n", dcr->VolumeName);
 335    if (dev->open(dcr, OPEN_READ_WRITE) < 0) {
 336       Emsg1(M_FATAL, 0, _("dev open failed: %s\n"), dev->errmsg);
 337       unlock_device(dev);
 338       free_block(block);
 339       return false;
 340    }
 341    Pmsg1(000, _("open device %s: OK\n"), dev->print_name());
 342    dev->set_append();                 /* put volume in append mode */
 343    unlock_device(dev);
 344    free_block(block);
 345    return true;
 346 }
 347
 348
 349 void quitcmd()
 350 {
 351    quit = 1;
 352 }
 353
 354 /*
 355  * Write a label to the tape
 356  */
 357 static void labelcmd()
 358 {
 359    if (VolumeName) {
 360       pm_strcpy(cmd, VolumeName);
 361    } else {
 362       if (!get_cmd(_("Enter Volume Name: "))) {
 363          return;
 364       }
 365    }
 366
 367    if (!dev->is_open()) {
 368       if (!first_open_device(dcr)) {
 369          Pmsg1(0, _("Device open failed. ERR=%s\n"), dev->bstrerror());
 370       }
 371    }
 372    dev->rewind(dcr);
 373    write_new_volume_label_to_dev(dcr, cmd, "Default");
 374    Pmsg1(-1, _("Wrote Volume label for volume \"%s\".\n"), cmd);
 375 }
 376
 377 /*
 378  * Read the tape label
 379  */
 380 static void readlabelcmd()
 381 {
 382    int save_debug_level = debug_level;
 383    int stat;
 384
 385    stat = read_dev_volume_label(dcr);
 386    switch (stat) {
 387    case VOL_NO_LABEL:
 388       Pmsg0(0, _("Volume has no label.\n"));
 389       break;
 390    case VOL_OK:
 391       Pmsg0(0, _("Volume label read correctly.\n"));
 392       break;
 393    case VOL_IO_ERROR:
 394       Pmsg1(0, _("I/O error on device: ERR=%s"), dev->bstrerror());
 395       break;
 396    case VOL_NAME_ERROR:
 397       Pmsg0(0, _("Volume name error\n"));
 398       break;
 399    case VOL_CREATE_ERROR:
 400       Pmsg1(0, _("Error creating label. ERR=%s"), dev->bstrerror());
 401       break;
 402    case VOL_VERSION_ERROR:
 403       Pmsg0(0, _("Volume version error.\n"));
 404       break;
 405    case VOL_LABEL_ERROR:
 406       Pmsg0(0, _("Bad Volume label type.\n"));
 407       break;
 408    default:
 409       Pmsg0(0, _("Unknown error.\n"));
 410       break;
 411    }
 412
 413    debug_level = 20;
 414    dump_volume_label(dev);
 415    debug_level = save_debug_level;
 416 }
 417
 418
 419 /*
 420  * Load the tape should have prevously been taken
 421  * off line, otherwise this command is not necessary.
 422  */
 423 static void loadcmd()
 424 {
 425
 426    if (!load_dev(dev)) {
 427       Pmsg1(0, _("Bad status from load. ERR=%s\n"), dev->bstrerror());
 428    } else
 429       Pmsg1(0, _("Loaded %s\n"), dev->print_name());
 430 }
 431
 432 /*
 433  * Rewind the tape.
 434  */
 435 static void rewindcmd()
 436 {
 437    if (!dev->rewind(dcr)) {
 438       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
 439       dev->clrerror(-1);
 440    } else {
 441       Pmsg1(0, _("Rewound %s\n"), dev->print_name());
 442    }
 443 }
 444
 445 /*
 446  * Clear any tape error
 447  */
 448 static void clearcmd()
 449 {
 450    dev->clrerror(-1);
 451 }
 452
 453 /*
 454  * Write and end of file on the tape
 455  */
 456 static void weofcmd()
 457 {
 458    int num = 1;
 459    if (argc > 1) {
 460       num = atoi(argk[1]);
 461    }
 462    if (num <= 0) {
 463       num = 1;
 464    }
 465
 466    if (!dev->weof(num)) {
 467       Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
 468       return;
 469    } else {
 470       if (num==1) {
 471          Pmsg1(0, _("Wrote 1 EOF to %s\n"), dev->print_name());
 472       }
 473       else {
 474          Pmsg2(0, _("Wrote %d EOFs to %s\n"), num, dev->print_name());
 475       }
 476    }
 477 }
 478
 479
 480 /* Go to the end of the medium -- raw command
 481  * The idea was orginally that the end of the Bacula
 482  * medium would be flagged differently. This is not
 483  * currently the case. So, this is identical to the
 484  * eodcmd().
 485  */
 486 static void eomcmd()
 487 {
 488    if (!dev->eod()) {
 489       Pmsg1(0, "%s", dev->bstrerror());
 490       return;
 491    } else {
 492       Pmsg0(0, _("Moved to end of medium.\n"));
 493    }
 494 }
 495
 496 /*
 497  * Go to the end of the medium (either hardware determined
 498  *  or defined by two eofs.
 499  */
 500 static void eodcmd()
 501 {
 502    eomcmd();
 503 }
 504
 505 /*
 506  * Backspace file
 507  */
 508 static void bsfcmd()
 509 {
 510    int num = 1;
 511    if (argc > 1) {
 512       num = atoi(argk[1]);
 513    }
 514    if (num <= 0) {
 515       num = 1;
 516    }
 517
 518    if (!dev->bsf(num)) {
 519       Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), dev->bstrerror());
 520    } else {
 521       Pmsg2(0, _("Backspaced %d file%s.\n"), num, num==1?"":"s");
 522    }
 523 }
 524
 525 /*
 526  * Backspace record
 527  */
 528 static void bsrcmd()
 529 {
 530    int num = 1;
 531    if (argc > 1) {
 532       num = atoi(argk[1]);
 533    }
 534    if (num <= 0) {
 535       num = 1;
 536    }
 537    if (!dev->bsr(num)) {
 538       Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), dev->bstrerror());
 539    } else {
 540       Pmsg2(0, _("Backspaced %d record%s.\n"), num, num==1?"":"s");
 541    }
 542 }
 543
 544 /*
 545  * List device capabilities as defined in the
 546  *  stored.conf file.
 547  */
 548 static void capcmd()
 549 {
 550    printf(_("Configured device capabilities:\n"));
 551    printf("%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
 552    printf("%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
 553    printf("%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
 554    printf("%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
 555    printf("%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
 556    printf("%sFASTFSF ", dev->capabilities & CAP_FASTFSF ? "" : "!");
 557    printf("%sBSFATEOM ", dev->capabilities & CAP_BSFATEOM ? "" : "!");
 558    printf("%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
 559    printf("%sREM ", dev->capabilities & CAP_REM ? "" : "!");
 560    printf("%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
 561    printf("%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
 562    printf("%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
 563    printf("%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
 564    printf("%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
 565    printf("%sMTIOCGET ", dev->capabilities & CAP_MTIOCGET ? "" : "!");
 566    printf("\n");
 567
 568    printf(_("Device status:\n"));
 569    printf("%sOPENED ", dev->is_open() ? "" : "!");
 570    printf("%sTAPE ", dev->is_tape() ? "" : "!");
 571    printf("%sLABEL ", dev->is_labeled() ? "" : "!");
 572    printf("%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
 573    printf("%sAPPEND ", dev->can_append() ? "" : "!");
 574    printf("%sREAD ", dev->can_read() ? "" : "!");
 575    printf("%sEOT ", dev->at_eot() ? "" : "!");
 576    printf("%sWEOT ", dev->state & ST_WEOT ? "" : "!");
 577    printf("%sEOF ", dev->at_eof() ? "" : "!");
 578    printf("%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
 579    printf("%sSHORT ", dev->state & ST_SHORT ? "" : "!");
 580    printf("\n");
 581
 582    printf(_("Device parameters:\n"));
 583    printf("Device name: %s\n", dev->dev_name);
 584    printf("File=%u block=%u\n", dev->file, dev->block_num);
 585    printf("Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
 586
 587    printf(_("Status:\n"));
 588    statcmd();
 589
 590 }
 591
 592 /*
 593  * Test writting larger and larger records.
 594  * This is a torture test for records.
 595  */
 596 static void rectestcmd()
 597 {
 598    DEV_BLOCK *block;
 599    DEV_RECORD *rec;
 600    int i, blkno = 0;
 601
 602    Pmsg0(0, _("Test writting larger and larger records.\n"
 603 "This is a torture test for records.\nI am going to write\n"
 604 "larger and larger records. It will stop when the record size\n"
 605 "plus the header exceeds the block size (by default about 64K)\n"));
 606
 607
 608    get_cmd(_("Do you want to continue? (y/n): "));
 609    if (cmd[0] != 'y') {
 610       Pmsg0(000, _("Command aborted.\n"));
 611       return;
 612    }
 613
 614    sm_check(__FILE__, __LINE__, false);
 615    block = new_block(dev);
 616    rec = new_record();
 617
 618    for (i=1; i<500000; i++) {
 619       rec->data = check_pool_memory_size(rec->data, i);
 620       memset(rec->data, i & 0xFF, i);
 621       rec->data_len = i;
 622       sm_check(__FILE__, __LINE__, false);
 623       if (write_record_to_block(block, rec)) {
 624          empty_block(block);
 625          blkno++;
 626          Pmsg2(0, _("Block %d i=%d\n"), blkno, i);
 627       } else {
 628          break;
 629       }
 630       sm_check(__FILE__, __LINE__, false);
 631    }
 632    free_record(rec);
 633    free_block(block);
 634    sm_check(__FILE__, __LINE__, false);
 635 }
 636
 637 /*
 638  * This test attempts to re-read a block written by Bacula
 639  *   normally at the end of the tape. Bacula will then back up
 640  *   over the two eof marks, backup over the record and reread
 641  *   it to make sure it is valid.  Bacula can skip this validation
 642  *   if you set "Backward space record = no"
 643  */
 644 static int re_read_block_test()
 645 {
 646    DEV_BLOCK *block = dcr->block;
 647    DEV_RECORD *rec;
 648    int stat = 0;
 649    int len;
 650
 651    if (!(dev->capabilities & CAP_BSR)) {
 652       Pmsg0(-1, _("Skipping read backwards test because BSR turned off.\n"));
 653       return 0;
 654    }
 655
 656    Pmsg0(-1, _("\n=== Write, backup, and re-read test ===\n\n"
 657       "I'm going to write three records and an EOF\n"
 658       "then backup over the EOF and re-read the last record.\n"
 659       "Bacula does this after writing the last block on the\n"
 660       "tape to verify that the block was written correctly.\n\n"
 661       "This is not an *essential* feature ...\n\n"));
 662    rewindcmd();
 663    empty_block(block);
 664    rec = new_record();
 665    rec->data = check_pool_memory_size(rec->data, block->buf_len);
 666    len = rec->data_len = block->buf_len-100;
 667    memset(rec->data, 1, rec->data_len);
 668    if (!write_record_to_block(block, rec)) {
 669       Pmsg0(0, _("Error writing record to block.\n"));
 670       goto bail_out;
 671    }
 672    if (!write_block_to_dev(dcr)) {
 673       Pmsg0(0, _("Error writing block to device.\n"));
 674       goto bail_out;
 675    } else {
 676       Pmsg1(0, _("Wrote first record of %d bytes.\n"), rec->data_len);
 677    }
 678    memset(rec->data, 2, rec->data_len);
 679    if (!write_record_to_block(block, rec)) {
 680       Pmsg0(0, _("Error writing record to block.\n"));
 681       goto bail_out;
 682    }
 683    if (!write_block_to_dev(dcr)) {
 684       Pmsg0(0, _("Error writing block to device.\n"));
 685       goto bail_out;
 686    } else {
 687       Pmsg1(0, _("Wrote second record of %d bytes.\n"), rec->data_len);
 688    }
 689    memset(rec->data, 3, rec->data_len);
 690    if (!write_record_to_block(block, rec)) {
 691       Pmsg0(0, _("Error writing record to block.\n"));
 692       goto bail_out;
 693    }
 694    if (!write_block_to_dev(dcr)) {
 695       Pmsg0(0, _("Error writing block to device.\n"));
 696       goto bail_out;
 697    } else {
 698       Pmsg1(0, _("Wrote third record of %d bytes.\n"), rec->data_len);
 699    }
 700    weofcmd();
 701    if (dev_cap(dev, CAP_TWOEOF)) {
 702       weofcmd();
 703    }
 704    if (!dev->bsf(1)) {
 705       Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
 706       goto bail_out;
 707    }
 708    if (dev_cap(dev, CAP_TWOEOF)) {
 709       if (!dev->bsf(1)) {
 710          Pmsg1(0, _("Backspace file failed! ERR=%s\n"), dev->bstrerror());
 711          goto bail_out;
 712       }
 713    }
 714    Pmsg0(0, _("Backspaced over EOF OK.\n"));
 715    if (!dev->bsr(1)) {
 716       Pmsg1(0, _("Backspace record failed! ERR=%s\n"), dev->bstrerror());
 717       goto bail_out;
 718    }
 719    Pmsg0(0, _("Backspace record OK.\n"));
 720    if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
 721       berrno be;
 722       Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
 723       goto bail_out;
 724    }
 725    memset(rec->data, 0, rec->data_len);
 726    if (!read_record_from_block(block, rec)) {
 727       berrno be;
 728       Pmsg1(0, _("Read block failed! ERR=%s\n"), be.strerror(dev->dev_errno));
 729       goto bail_out;
 730    }
 731    for (int i=0; i<len; i++) {
 732       if (rec->data[i] != 3) {
 733          Pmsg0(0, _("Bad data in record. Test failed!\n"));
 734          goto bail_out;
 735       }
 736    }
 737    Pmsg0(0, _("\nBlock re-read correct. Test succeeded!\n"));
 738    Pmsg0(-1, _("=== End Write, backup, and re-read test ===\n\n"));
 739
 740    stat = 1;
 741
 742 bail_out:
 743    free_record(rec);
 744    if (stat == 0) {
 745       Pmsg0(0, _("This is not terribly serious since Bacula only uses\n"
 746                  "this function to verify the last block written to the\n"
 747                  "tape. Bacula will skip the last block verification\n"
 748                  "if you add:\n\n"
 749                   "Backward Space Record = No\n\n"
 750                   "to your Storage daemon's Device resource definition.\n"));
 751    }
 752    return stat;
 753 }
 754
 755
 756 /*
 757  * This test writes Bacula blocks to the tape in
 758  *   several files. It then rewinds the tape and attepts
 759  *   to read these blocks back checking the data.
 760  */
 761 static int write_read_test()
 762 {
 763    DEV_BLOCK *block;
 764    DEV_RECORD *rec;
 765    int stat = 0;
 766    int len, i, j;
 767    int *p;
 768
 769    Pmsg0(-1, _("\n=== Write, rewind, and re-read test ===\n\n"
 770       "I'm going to write 1000 records and an EOF\n"
 771       "then write 1000 records and an EOF, then rewind,\n"
 772       "and re-read the data to verify that it is correct.\n\n"
 773       "This is an *essential* feature ...\n\n"));
 774    block = dcr->block;
 775    rec = new_record();
 776    if (!dev->rewind(dcr)) {
 777       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
 778       goto bail_out;
 779    }
 780    rec->data = check_pool_memory_size(rec->data, block->buf_len);
 781    rec->data_len = block->buf_len-100;
 782    len = rec->data_len/sizeof(i);
 783    for (i=1; i<=1000; i++) {
 784       p = (int *)rec->data;
 785       for (j=0; j<len; j++) {
 786          *p++ = i;
 787       }
 788       if (!write_record_to_block(block, rec)) {
 789          Pmsg0(0, _("Error writing record to block.\n"));
 790          goto bail_out;
 791       }
 792       if (!write_block_to_dev(dcr)) {
 793          Pmsg0(0, _("Error writing block to device.\n"));
 794          goto bail_out;
 795       }
 796    }
 797    Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
 798    weofcmd();
 799    for (i=1001; i<=2000; i++) {
 800       p = (int *)rec->data;
 801       for (j=0; j<len; j++) {
 802          *p++ = i;
 803       }
 804       if (!write_record_to_block(block, rec)) {
 805          Pmsg0(0, _("Error writing record to block.\n"));
 806          goto bail_out;
 807       }
 808       if (!write_block_to_dev(dcr)) {
 809          Pmsg0(0, _("Error writing block to device.\n"));
 810          goto bail_out;
 811       }
 812    }
 813    Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
 814    weofcmd();
 815    if (dev_cap(dev, CAP_TWOEOF)) {
 816       weofcmd();
 817    }
 818    if (!dev->rewind(dcr)) {
 819       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
 820       goto bail_out;
 821    } else {
 822       Pmsg0(0, _("Rewind OK.\n"));
 823    }
 824    for (i=1; i<=2000; i++) {
 825 read_again:
 826       if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
 827          berrno be;
 828          if (dev_state(dev, ST_EOF)) {
 829             Pmsg0(-1, _("Got EOF on tape.\n"));
 830             if (i == 1001) {
 831                goto read_again;
 832             }
 833          }
 834          Pmsg2(0, _("Read block %d failed! ERR=%s\n"), i, be.strerror(dev->dev_errno));
 835          goto bail_out;
 836       }
 837       memset(rec->data, 0, rec->data_len);
 838       if (!read_record_from_block(block, rec)) {
 839          berrno be;
 840          Pmsg2(0, _("Read record failed. Block %d! ERR=%s\n"), i, be.strerror(dev->dev_errno));
 841          goto bail_out;
 842       }
 843       p = (int *)rec->data;
 844       for (j=0; j<len; j++) {
 845          if (*p != i) {
 846             Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
 847                i, *p, j);
 848             goto bail_out;
 849          }
 850          p++;
 851       }
 852       if (i == 1000 || i == 2000) {
 853          Pmsg0(-1, _("1000 blocks re-read correctly.\n"));
 854       }
 855    }
 856    Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
 857    stat = 1;
 858
 859 bail_out:
 860    free_record(rec);
 861    return stat;
 862 }
 863
 864 /*
 865  * This test writes Bacula blocks to the tape in
 866  *   several files. It then rewinds the tape and attepts
 867  *   to read these blocks back checking the data.
 868  */
 869 static int position_test()
 870 {
 871    DEV_BLOCK *block = dcr->block;
 872    DEV_RECORD *rec;
 873    int stat = 0;
 874    int len, i, j;
 875    bool ok = true;
 876    int recno = 0;
 877    int file = 0, blk = 0;
 878    int *p;
 879    bool got_eof = false;
 880
 881    Pmsg0(-1, _("\n=== Write, rewind, and position test ===\n\n"
 882       "I'm going to write 1000 records and an EOF\n"
 883       "then write 1000 records and an EOF, then rewind,\n"
 884       "and position to a few blocks and verify that it is correct.\n\n"
 885       "This is an *essential* feature ...\n\n"));
 886    empty_block(block);
 887    rec = new_record();
 888    if (!dev->rewind(dcr)) {
 889       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
 890       goto bail_out;
 891    }
 892    rec->data = check_pool_memory_size(rec->data, block->buf_len);
 893    rec->data_len = block->buf_len-100;
 894    len = rec->data_len/sizeof(i);
 895    for (i=1; i<=1000; i++) {
 896       p = (int *)rec->data;
 897       for (j=0; j<len; j++) {
 898          *p++ = i;
 899       }
 900       if (!write_record_to_block(block, rec)) {
 901          Pmsg0(0, _("Error writing record to block.\n"));
 902          goto bail_out;
 903       }
 904       if (!write_block_to_dev(dcr)) {
 905          Pmsg0(0, _("Error writing block to device.\n"));
 906          goto bail_out;
 907       }
 908    }
 909    Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
 910    weofcmd();
 911    for (i=1001; i<=2000; i++) {
 912       p = (int *)rec->data;
 913       for (j=0; j<len; j++) {
 914          *p++ = i;
 915       }
 916       if (!write_record_to_block(block, rec)) {
 917          Pmsg0(0, _("Error writing record to block.\n"));
 918          goto bail_out;
 919       }
 920       if (!write_block_to_dev(dcr)) {
 921          Pmsg0(0, _("Error writing block to device.\n"));
 922          goto bail_out;
 923       }
 924    }
 925    Pmsg1(0, _("Wrote 1000 blocks of %d bytes.\n"), rec->data_len);
 926    weofcmd();
 927    if (dev_cap(dev, CAP_TWOEOF)) {
 928       weofcmd();
 929    }
 930    if (!dev->rewind(dcr)) {
 931       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
 932       goto bail_out;
 933    } else {
 934       Pmsg0(0, _("Rewind OK.\n"));
 935    }
 936
 937    while(ok) {
 938       /* Set up next item to read based on where we are */
 939       switch (recno) {
 940       case 0:
 941          recno = 5;
 942          file = 0;
 943          blk = 4;
 944          break;
 945       case 5:
 946          recno = 201;
 947          file = 0;
 948          blk = 200;
 949          break;
 950       case 201:
 951          recno = 1000;
 952          file = 0;
 953          blk = 999;
 954          break;
 955       case 1000:
 956          recno = 1001;
 957          file = 1;
 958          blk = 0;
 959          break;
 960       case 1001:
 961          recno = 1601;
 962          file = 1;
 963          blk = 600;
 964          break;
 965       case 1601:
 966          recno = 2000;
 967          file = 1;
 968          blk = 999;
 969          break;
 970       case 2000:
 971          ok = false;
 972          continue;
 973       }
 974       Pmsg2(-1, _("Reposition to file:block %d:%d\n"), file, blk);
 975       if (!dev->reposition(file, blk)) {
 976          Pmsg0(0, _("Reposition error.\n"));
 977          goto bail_out;
 978       }
 979 read_again:
 980       if (!read_block_from_dev(dcr, NO_BLOCK_NUMBER_CHECK)) {
 981          berrno be;
 982          if (dev_state(dev, ST_EOF)) {
 983             Pmsg0(-1, _("Got EOF on tape.\n"));
 984             if (!got_eof) {
 985                got_eof = true;
 986                goto read_again;
 987             }
 988          }
 989          Pmsg4(0, _("Read block %d failed! file=%d blk=%d. ERR=%s\n\n"),
 990             recno, file, blk, be.strerror(dev->dev_errno));
 991          Pmsg0(0, _("This may be because the tape drive block size is not\n"
 992                     " set to variable blocking as normally used by Bacula.\n"
 993                     " Please see the Tape Testing chapter in the manual and \n"
 994                     " look for using mt with defblksize and setoptions\n"
 995                     "If your tape drive block size is correct, then perhaps\n"
 996                     " your SCSI driver is *really* stupid and does not\n"
 997                     " correctly report the file:block after a FSF. In this\n"
 998                     " case try setting:\n"
 999                     "    Fast Forward Space File = no\n"
1000                     " in your Device resource.\n"));
1001
1002          goto bail_out;
1003       }
1004       memset(rec->data, 0, rec->data_len);
1005       if (!read_record_from_block(block, rec)) {
1006          berrno be;
1007          Pmsg1(0, _("Read record failed! ERR=%s\n"), be.strerror(dev->dev_errno));
1008          goto bail_out;
1009       }
1010       p = (int *)rec->data;
1011       for (j=0; j<len; j++) {
1012          if (p[j] != recno) {
1013             Pmsg3(0, _("Bad data in record. Expected %d, got %d at byte %d. Test failed!\n"),
1014                recno, p[j], j);
1015             goto bail_out;
1016          }
1017       }
1018       Pmsg1(-1, _("Block %d re-read correctly.\n"), recno);
1019    }
1020    Pmsg0(-1, _("=== Test Succeeded. End Write, rewind, and re-read test ===\n\n"));
1021    stat = 1;
1022
1023 bail_out:
1024    free_record(rec);
1025    return stat;
1026 }
1027
1028
1029
1030
1031 /*
1032  * This test writes some records, then writes an end of file,
1033  *   rewinds the tape, moves to the end of the data and attepts
1034  *   to append to the tape.  This function is essential for
1035  *   Bacula to be able to write multiple jobs to the tape.
1036  */
1037 static int append_test()
1038 {
1039    Pmsg0(-1, _("\n\n=== Append files test ===\n\n"
1040                "This test is essential to Bacula.\n\n"
1041 "I'm going to write one record  in file 0,\n"
1042 "                   two records in file 1,\n"
1043 "             and three records in file 2\n\n"));
1044    argc = 1;
1045    rewindcmd();
1046    wrcmd();
1047    weofcmd();      /* end file 0 */
1048    wrcmd();
1049    wrcmd();
1050    weofcmd();      /* end file 1 */
1051    wrcmd();
1052    wrcmd();
1053    wrcmd();
1054    weofcmd();     /* end file 2 */
1055    if (dev_cap(dev, CAP_TWOEOF)) {
1056       weofcmd();
1057    }
1058    dev->close();              /* release device */
1059    if (!open_the_device()) {
1060       return -1;
1061    }
1062    rewindcmd();
1063    Pmsg0(0, _("Now moving to end of medium.\n"));
1064    eodcmd();
1065    Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1066       dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1067
1068    if (dev->file != 3) {
1069       return -1;
1070    }
1071
1072    Pmsg0(-1, _("\nNow the important part, I am going to attempt to append to the tape.\n\n"));
1073    wrcmd();
1074    weofcmd();
1075    if (dev_cap(dev, CAP_TWOEOF)) {
1076       weofcmd();
1077    }
1078    rewindcmd();
1079    Pmsg0(-1, _("Done appending, there should be no I/O errors\n\n"));
1080    Pmsg0(-1, _("Doing Bacula scan of blocks:\n"));
1081    scan_blocks();
1082    Pmsg0(-1, _("End scanning the tape.\n"));
1083    Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1084       dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1085
1086    if (dev->file != 4) {
1087       return -2;
1088    }
1089    return 1;
1090 }
1091
1092
1093 /*
1094  * This test exercises the autochanger
1095  */
1096 static int autochanger_test()
1097 {
1098    POOLMEM *results, *changer;
1099    int slot, status, loaded;
1100    int timeout = dcr->device->max_changer_wait;
1101    int sleep_time = 0;
1102
1103    Dmsg1(100, "Max changer wait = %d sec\n", timeout);
1104    if (!dev_cap(dev, CAP_AUTOCHANGER)) {
1105       return 1;
1106    }
1107    if (!(dcr->device && dcr->device->changer_name && dcr->device->changer_command)) {
1108       Pmsg0(-1, _("\nAutochanger enabled, but no name or no command device specified.\n"));
1109       return 1;
1110    }
1111
1112    Pmsg0(-1, _("\nAh, I see you have an autochanger configured.\n"
1113              "To test the autochanger you must have a blank tape\n"
1114              " that I can write on in Slot 1.\n"));
1115    if (!get_cmd(_("\nDo you wish to continue with the Autochanger test? (y/n): "))) {
1116       return 0;
1117    }
1118    if (cmd[0] != 'y' && cmd[0] != 'Y') {
1119       return 0;
1120    }
1121
1122    Pmsg0(-1, _("\n\n=== Autochanger test ===\n\n"));
1123
1124    results = get_pool_memory(PM_MESSAGE);
1125    changer = get_pool_memory(PM_FNAME);
1126
1127 try_again:
1128    slot = 1;
1129    dcr->VolCatInfo.Slot = slot;
1130    /* Find out what is loaded, zero means device is unloaded */
1131    Pmsg0(-1, _("3301 Issuing autochanger \"loaded\" command.\n"));
1132    changer = edit_device_codes(dcr, changer,
1133                 dcr->device->changer_command, "loaded");
1134    status = run_program(changer, timeout, results);
1135    Dmsg3(100, "run_prog: %s stat=%d result=\"%s\"\n", changer, status, results);
1136    if (status == 0) {
1137       loaded = atoi(results);
1138    } else {
1139       berrno be;
1140       Pmsg1(-1, _("3991 Bad autochanger command: %s\n"), changer);
1141       Pmsg2(-1, _("3991 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1142       goto bail_out;
1143    }
1144    if (loaded) {
1145       Pmsg1(-1, _("Slot %d loaded. I am going to unload it.\n"), loaded);
1146    } else {
1147       Pmsg0(-1, _("Nothing loaded in the drive. OK.\n"));
1148    }
1149    Dmsg1(100, "Results from loaded query=%s\n", results);
1150    if (loaded) {
1151       dcr->VolCatInfo.Slot = loaded;
1152       /* We are going to load a new tape, so close the device */
1153       dev->close();
1154       Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1155          loaded, dev->drive_index);
1156       changer = edit_device_codes(dcr, changer,
1157                    dcr->device->changer_command, "unload");
1158       status = run_program(changer, timeout, results);
1159       Pmsg2(-1, _("unload status=%s %d\n"), status==0?_("OK"):_("Bad"), status);
1160       if (status != 0) {
1161          berrno be;
1162          Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1163          Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1164       }
1165    }
1166
1167    /*
1168     * Load the Slot 1
1169     */
1170
1171    slot = 1;
1172    dcr->VolCatInfo.Slot = slot;
1173    Pmsg2(-1, _("3303 Issuing autochanger \"load %d %d\" command.\n"),
1174       slot, dev->drive_index);
1175    changer = edit_device_codes(dcr, changer,
1176                 dcr->device->changer_command, "load");
1177    Dmsg1(100, "Changer=%s\n", changer);
1178    dev->close();
1179    status = run_program(changer, timeout, results);
1180    if (status == 0) {
1181       Pmsg2(-1,  _("3303 Autochanger \"load %d %d\" status is OK.\n"),
1182          slot, dev->drive_index);
1183    } else {
1184       berrno be;
1185       Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1186       Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1187       goto bail_out;
1188    }
1189
1190    if (!open_the_device()) {
1191       goto bail_out;
1192    }
1193    /*
1194     * Start with sleep_time 0 then increment by 30 seconds if we get
1195     * a failure.
1196     */
1197    bmicrosleep(sleep_time, 0);
1198    if (!dev->rewind(dcr) || !dev->weof(1)) {
1199       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), dev->bstrerror());
1200       dev->clrerror(-1);
1201       Pmsg0(-1, _("\nThe test failed, probably because you need to put\n"
1202                 "a longer sleep time in the mtx-script in the load) case.\n"
1203                 "Adding a 30 second sleep and trying again ...\n"));
1204       sleep_time += 30;
1205       goto try_again;
1206    } else {
1207       Pmsg1(0, _("Rewound %s\n"), dev->print_name());
1208    }
1209
1210    if (!dev->weof(1)) {
1211       Pmsg1(0, _("Bad status from weof. ERR=%s\n"), dev->bstrerror());
1212       goto bail_out;
1213    } else {
1214       Pmsg1(0, _("Wrote EOF to %s\n"), dev->print_name());
1215    }
1216
1217    if (sleep_time) {
1218       Pmsg1(-1, _("\nThe test worked this time. Please add:\n\n"
1219                 "   sleep %d\n\n"
1220                 "to your mtx-changer script in the load) case.\n\n"),
1221                 sleep_time);
1222    } else {
1223       Pmsg0(-1, _("\nThe test autochanger worked!!\n\n"));
1224    }
1225
1226    free_pool_memory(changer);
1227    free_pool_memory(results);
1228    return 1;
1229
1230
1231 bail_out:
1232    free_pool_memory(changer);
1233    free_pool_memory(results);
1234    Pmsg0(-1, _("You must correct this error or the Autochanger will not work.\n"));
1235    return -2;
1236 }
1237
1238 static void autochangercmd()
1239 {
1240    autochanger_test();
1241 }
1242
1243
1244 /*
1245  * This test assumes that the append test has been done,
1246  *   then it tests the fsf function.
1247  */
1248 static int fsf_test()
1249 {
1250    bool set_off = false;
1251
1252    Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1253                "This test is essential to Bacula.\n\n"
1254                "I'm going to write five files then test forward spacing\n\n"));
1255    argc = 1;
1256    rewindcmd();
1257    wrcmd();
1258    weofcmd();      /* end file 0 */
1259    wrcmd();
1260    wrcmd();
1261    weofcmd();      /* end file 1 */
1262    wrcmd();
1263    wrcmd();
1264    wrcmd();
1265    weofcmd();     /* end file 2 */
1266    wrcmd();
1267    wrcmd();
1268    weofcmd();     /* end file 3 */
1269    wrcmd();
1270    weofcmd();     /* end file 4 */
1271    if (dev_cap(dev, CAP_TWOEOF)) {
1272       weofcmd();
1273    }
1274
1275 test_again:
1276    rewindcmd();
1277    Pmsg0(0, _("Now forward spacing 1 file.\n"));
1278    if (!dev->fsf(1)) {
1279       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1280       goto bail_out;
1281    }
1282    Pmsg2(-1, _("We should be in file 1. I am at file %d. %s\n"),
1283       dev->file, dev->file == 1 ? _("This is correct!") : _("This is NOT correct!!!!"));
1284
1285    if (dev->file != 1) {
1286       goto bail_out;
1287    }
1288
1289    Pmsg0(0, _("Now forward spacing 2 files.\n"));
1290    if (!dev->fsf(2)) {
1291       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1292       goto bail_out;
1293    }
1294    Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1295       dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1296
1297    if (dev->file != 3) {
1298       goto bail_out;
1299    }
1300
1301    rewindcmd();
1302    Pmsg0(0, _("Now forward spacing 4 files.\n"));
1303    if (!dev->fsf(4)) {
1304       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1305       goto bail_out;
1306    }
1307    Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1308       dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1309
1310    if (dev->file != 4) {
1311       goto bail_out;
1312    }
1313    if (set_off) {
1314       Pmsg0(-1, _("The test worked this time. Please add:\n\n"
1315                 "   Fast Forward Space File = no\n\n"
1316                 "to your Device resource for this drive.\n"));
1317    }
1318
1319    Pmsg0(-1, "\n");
1320    Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1321    if (!dev->fsf(1)) {
1322       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1323    }
1324    Pmsg2(-1, _("We should be in file 5. I am at file %d. %s\n"),
1325       dev->file, dev->file == 5 ? _("This is correct!") : _("This is NOT correct!!!!"));
1326    if (dev->file != 5) {
1327       goto bail_out;
1328    }
1329    Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1330    return 1;
1331
1332 bail_out:
1333    Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1334    if (dev_cap(dev, CAP_FASTFSF)) {
1335       Pmsg0(-1, _("You have Fast Forward Space File enabled.\n"
1336               "I am turning it off then retrying the test.\n"));
1337       dev->capabilities &= ~CAP_FASTFSF;
1338       set_off = true;
1339       goto test_again;
1340    }
1341    Pmsg0(-1, _("You must correct this error or Bacula will not work.\n"
1342             "Some systems, e.g. OpenBSD, require you to set\n"
1343             "   Use MTIOCGET= no\n"
1344             "in your device resource. Use with caution.\n"));
1345    return -2;
1346 }
1347
1348
1349
1350
1351
1352 /*
1353  * This is a general test of Bacula's functions
1354  *   needed to read and write the tape.
1355  */
1356 static void testcmd()
1357 {
1358    int stat;
1359
1360    if (!write_read_test()) {
1361       return;
1362    }
1363    if (!position_test()) {
1364       return;
1365    }
1366
1367    stat = append_test();
1368    if (stat == 1) {                   /* OK get out */
1369       goto all_done;
1370    }
1371    if (stat == -1) {                  /* first test failed */
1372       if (dev_cap(dev, CAP_EOM) || dev_cap(dev, CAP_FASTFSF)) {
1373          Pmsg0(-1, _("\nAppend test failed. Attempting again.\n"
1374                    "Setting \"Hardware End of Medium = no\n"
1375                    "    and \"Fast Forward Space File = no\n"
1376                    "and retrying append test.\n\n"));
1377          dev->capabilities &= ~CAP_EOM; /* turn off eom */
1378          dev->capabilities &= ~CAP_FASTFSF; /* turn off fast fsf */
1379          stat = append_test();
1380          if (stat == 1) {
1381             Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1382                      "    Hardware End of Medium = No\n\n"
1383                      "    Fast Forward Space File = No\n"
1384                      "to your Device resource in the Storage conf file.\n"));
1385             goto all_done;
1386          }
1387          if (stat == -1) {
1388             Pmsg0(-1, _("\n\nThat appears *NOT* to have corrected the problem.\n"));
1389             goto failed;
1390          }
1391          /* Wrong count after append */
1392          if (stat == -2) {
1393             Pmsg0(-1, _("\n\nIt looks like the append failed. Attempting again.\n"
1394                      "Setting \"BSF at EOM = yes\" and retrying append test.\n"));
1395             dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1396             stat = append_test();
1397             if (stat == 1) {
1398                Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1399                      "    Hardware End of Medium = No\n"
1400                      "    Fast Forward Space File = No\n"
1401                      "    BSF at EOM = yes\n\n"
1402                      "to your Device resource in the Storage conf file.\n"));
1403                goto all_done;
1404             }
1405          }
1406
1407       }
1408 failed:
1409       Pmsg0(-1, _("\nAppend test failed.\n\n"
1410             "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1411             "Unable to correct the problem. You MUST fix this\n"
1412              "problem before Bacula can use your tape drive correctly\n"
1413             "\nPerhaps running Bacula in fixed block mode will work.\n"
1414             "Do so by setting:\n\n"
1415             "Minimum Block Size = nnn\n"
1416             "Maximum Block Size = nnn\n\n"
1417             "in your Storage daemon's Device definition.\n"
1418             "nnn must match your tape driver's block size, which\n"
1419             "can be determined by reading your tape manufacturers\n"
1420             "information, and the information on your kernel dirver.\n"
1421             "Fixed block sizes, however, are not normally an ideal solution.\n"
1422             "\n"
1423             "Some systems, e.g. OpenBSD, require you to set\n"
1424             "   Use MTIOCGET= no\n"
1425             "in your device resource. Use with caution.\n"));
1426        return;
1427    }
1428
1429 all_done:
1430    Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1431         "Please double check it ...\n"
1432         "=== Sample correct output ===\n"
1433         "1 block of 64448 bytes in file 1\n"
1434         "End of File mark.\n"
1435         "2 blocks of 64448 bytes in file 2\n"
1436         "End of File mark.\n"
1437         "3 blocks of 64448 bytes in file 3\n"
1438         "End of File mark.\n"
1439         "1 block of 64448 bytes in file 4\n"
1440         "End of File mark.\n"
1441         "Total files=4, blocks=7, bytes = 451,136\n"
1442         "=== End sample correct output ===\n\n"
1443         "If the above scan output is not identical to the\n"
1444         "sample output, you MUST correct the problem\n"
1445         "or Bacula will not be able to write multiple Jobs to \n"
1446         "the tape.\n\n"));
1447
1448    if (stat == 1) {
1449       re_read_block_test();
1450    }
1451
1452    fsf_test();                        /* do fast forward space file test */
1453
1454    autochanger_test();                /* do autochanger test */
1455
1456 }
1457
1458 /* Forward space a file */
1459 static void fsfcmd()
1460 {
1461    int num = 1;
1462    if (argc > 1) {
1463       num = atoi(argk[1]);
1464    }
1465    if (num <= 0) {
1466       num = 1;
1467    }
1468    if (!dev->fsf(num)) {
1469       Pmsg1(0, _("Bad status from fsf. ERR=%s\n"), dev->bstrerror());
1470       return;
1471    }
1472    if (num == 1) {
1473       Pmsg0(0, _("Forward spaced 1 file.\n"));
1474    }
1475    else {
1476       Pmsg1(0, _("Forward spaced %d files.\n"), num);
1477    }
1478 }
1479
1480 /* Forward space a record */
1481 static void fsrcmd()
1482 {
1483    int num = 1;
1484    if (argc > 1) {
1485       num = atoi(argk[1]);
1486    }
1487    if (num <= 0) {
1488       num = 1;
1489    }
1490    if (!dev->fsr(num)) {
1491       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), dev->bstrerror());
1492       return;
1493    }
1494    if (num == 1) {
1495       Pmsg0(0, _("Forward spaced 1 record.\n"));
1496    }
1497    else {
1498       Pmsg1(0, _("Forward spaced %d records.\n"), num);
1499    }
1500 }
1501
1502
1503 /*
1504  * Write a Bacula block to the tape
1505  */
1506 static void wrcmd()
1507 {
1508    DEV_BLOCK *block = dcr->block;
1509    DEV_RECORD *rec = dcr->rec;
1510    int i;
1511
1512    sm_check(__FILE__, __LINE__, false);
1513    empty_block(block);
1514    if (verbose > 1) {
1515       dump_block(block, "test");
1516    }
1517
1518    i = block->buf_len - 100;
1519    ASSERT (i > 0);
1520    rec->data = check_pool_memory_size(rec->data, i);
1521    memset(rec->data, i & 0xFF, i);
1522    rec->data_len = i;
1523    sm_check(__FILE__, __LINE__, false);
1524    if (!write_record_to_block(block, rec)) {
1525       Pmsg0(0, _("Error writing record to block.\n"));
1526       goto bail_out;
1527    }
1528    if (!write_block_to_dev(dcr)) {
1529       Pmsg0(0, _("Error writing block to device.\n"));
1530       goto bail_out;
1531    } else {
1532       Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1533    }
1534    Pmsg0(0, _("Wrote block to device.\n"));
1535
1536 bail_out:
1537    sm_check(__FILE__, __LINE__, false);
1538    sm_check(__FILE__, __LINE__, false);
1539 }
1540
1541 /*
1542  * Read a record from the tape
1543  */
1544 static void rrcmd()
1545 {
1546    char *buf;
1547    int stat, len;
1548
1549    if (!get_cmd(_("Enter length to read: "))) {
1550       return;
1551    }
1552    len = atoi(cmd);
1553    if (len < 0 || len > 1000000) {
1554       Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1555       len = 1024;
1556    }
1557    buf = (char *)malloc(len);
1558    stat = read(dev->fd, buf, len);
1559    if (stat > 0 && stat <= len) {
1560       errno = 0;
1561    }
1562    berrno be;
1563    Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1564       len, stat, be.strerror());
1565    free(buf);
1566 }
1567
1568
1569 /*
1570  * Scan tape by reading block by block. Report what is
1571  * on the tape.  Note, this command does raw reads, and as such
1572  * will not work with fixed block size devices.
1573  */
1574 static void scancmd()
1575 {
1576    int stat;
1577    int blocks, tot_blocks, tot_files;
1578    int block_size;
1579    uint64_t bytes;
1580    char ec1[50];
1581
1582
1583    blocks = block_size = tot_blocks = 0;
1584    bytes = 0;
1585    if (dev->state & ST_EOT) {
1586       Pmsg0(0, _("End of tape\n"));
1587       return;
1588    }
1589    update_pos_dev(dev);
1590    tot_files = dev->file;
1591    Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1592    for (;;) {
1593       if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
1594          berrno be;
1595          dev->clrerror(-1);
1596          Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1597             dev->dev_name, be.strerror());
1598          Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, dev->bstrerror());
1599          if (blocks > 0) {
1600             if (blocks==1) {
1601                printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1602             }
1603             else {
1604                printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1605             }
1606          }
1607          return;
1608       }
1609       Dmsg1(200, "read status = %d\n", stat);
1610 /*    sleep(1); */
1611       if (stat != block_size) {
1612          update_pos_dev(dev);
1613          if (blocks > 0) {
1614             if (blocks==1) {
1615                printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1616             }
1617             else {
1618                printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1619             }
1620             blocks = 0;
1621          }
1622          block_size = stat;
1623       }
1624       if (stat == 0) {                /* EOF */
1625          update_pos_dev(dev);
1626          printf(_("End of File mark.\n"));
1627          /* Two reads of zero means end of tape */
1628          if (dev->state & ST_EOF)
1629             dev->state |= ST_EOT;
1630          else {
1631             dev->state |= ST_EOF;
1632             dev->file++;
1633          }
1634          if (dev->state & ST_EOT) {
1635             printf(_("End of tape\n"));
1636             break;
1637          }
1638       } else {                        /* Got data */
1639          dev->state &= ~ST_EOF;
1640          blocks++;
1641          tot_blocks++;
1642          bytes += stat;
1643       }
1644    }
1645    update_pos_dev(dev);
1646    tot_files = dev->file - tot_files;
1647    printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1648       edit_uint64_with_commas(bytes, ec1));
1649 }
1650
1651
1652 /*
1653  * Scan tape by reading Bacula block by block. Report what is
1654  * on the tape.  This function reads Bacula blocks, so if your
1655  * Device resource is correctly defined, it should work with
1656  * either variable or fixed block sizes.
1657  */
1658 static void scan_blocks()
1659 {
1660    int blocks, tot_blocks, tot_files;
1661    uint32_t block_size;
1662    uint64_t bytes;
1663    DEV_BLOCK *block = dcr->block;
1664    char ec1[50];
1665    char buf1[100], buf2[100];
1666
1667    blocks = block_size = tot_blocks = 0;
1668    bytes = 0;
1669
1670    empty_block(block);
1671    update_pos_dev(dev);
1672    tot_files = dev->file;
1673    for (;;) {
1674       if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
1675          Dmsg1(100, "!read_block(): ERR=%s\n", dev->bstrerror());
1676          if (dev->state & ST_EOT) {
1677             if (blocks > 0) {
1678                if (blocks==1) {
1679                   printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1680                }
1681                else {
1682                   printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1683                }
1684                blocks = 0;
1685             }
1686             goto bail_out;
1687          }
1688          if (dev->state & ST_EOF) {
1689             if (blocks > 0) {
1690                if (blocks==1) {
1691                   printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1692                }
1693                else {
1694                   printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1695                }
1696                blocks = 0;
1697             }
1698             printf(_("End of File mark.\n"));
1699             continue;
1700          }
1701          if (dev->state & ST_SHORT) {
1702             if (blocks > 0) {
1703                if (blocks==1) {
1704                   printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1705                }
1706                else {
1707                   printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1708                }
1709                blocks = 0;
1710             }
1711             printf(_("Short block read.\n"));
1712             continue;
1713          }
1714          printf(_("Error reading block. ERR=%s\n"), dev->bstrerror());
1715          goto bail_out;
1716       }
1717       if (block->block_len != block_size) {
1718          if (blocks > 0) {
1719             if (blocks==1) {
1720                printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1721             }
1722             else {
1723                printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1724             }
1725             blocks = 0;
1726          }
1727          block_size = block->block_len;
1728       }
1729       blocks++;
1730       tot_blocks++;
1731       bytes += block->block_len;
1732       Dmsg6(100, "Blk_blk=%u dev_blk=%u blen=%u bVer=%d SessId=%u SessTim=%u\n",
1733          block->BlockNumber, dev->block_num, block->block_len, block->BlockVer,
1734          block->VolSessionId, block->VolSessionTime);
1735       if (verbose == 1) {
1736          DEV_RECORD *rec = new_record();
1737          read_record_from_block(block, rec);
1738          Pmsg8(-1, _("Blk_block: %u dev_blk=%u blen=%u First rec FI=%s SessId=%u SessTim=%u Strm=%s rlen=%d\n"),
1739               block->BlockNumber, dev->block_num, block->block_len,
1740               FI_to_ascii(buf1, rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1741               stream_to_ascii(buf2, rec->Stream, rec->FileIndex), rec->data_len);
1742          rec->remainder = 0;
1743          free_record(rec);
1744       } else if (verbose > 1) {
1745          dump_block(block, "");
1746       }
1747
1748    }
1749 bail_out:
1750    tot_files = dev->file - tot_files;
1751    printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1752       edit_uint64_with_commas(bytes, ec1));
1753 }
1754
1755
1756 static void statcmd()
1757 {
1758    int debug = debug_level;
1759    debug_level = 30;
1760    Pmsg2(0, _("Device status: %u. ERR=%s\n"), status_dev(dev), dev->bstrerror());
1761 #ifdef xxxx
1762    dump_volume_label(dev);
1763 #endif
1764    debug_level = debug;
1765 }
1766
1767
1768 /*
1769  * First we label the tape, then we fill
1770  *  it with data get a new tape and write a few blocks.
1771  */
1772 static void fillcmd()
1773 {
1774    DEV_RECORD rec;
1775    DEV_BLOCK  *block = dcr->block;
1776    char ec1[50];
1777    char buf1[100], buf2[100];
1778    int fd;
1779    uint32_t i;
1780    uint32_t min_block_size;
1781    struct tm tm;
1782
1783    ok = true;
1784    stop = 0;
1785    vol_num = 0;
1786    last_file = 0;
1787    last_block_num = 0;
1788    BlockNumber = 0;
1789
1790    Pmsg0(-1, _("\n"
1791 "This command simulates Bacula writing to a tape.\n"
1792 "It requires either one or two blank tapes, which it\n"
1793 "will label and write.\n\n"
1794 "If you have an autochanger configured, it will use\n"
1795 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1796 "be prompted to insert the tapes when necessary.\n\n"
1797 "It will print a status approximately\n"
1798 "every 322 MB, and write an EOF every 3.2 GB.  If you have\n"
1799 "selected the simple test option, after writing the first tape\n"
1800 "it will rewind it and re-read the last block written.\n\n"
1801 "If you have selected the multiple tape test, when the first tape\n"
1802 "fills, it will ask for a second, and after writing a few more \n"
1803 "blocks, it will stop.  Then it will begin re-reading the\n"
1804 "two tapes.\n\n"
1805 "This may take a long time -- hours! ...\n\n"));
1806
1807    get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
1808            "or the complete multiple tape (m) test: (s/m) "));
1809    if (cmd[0] == 's') {
1810       Pmsg0(-1, _("Simple test (single tape) selected.\n"));
1811       simple = true;
1812    } else if (cmd[0] == 'm') {
1813       Pmsg0(-1, _("Multiple tape test selected.\n"));
1814       simple = false;
1815    } else {
1816       Pmsg0(000, _("Command aborted.\n"));
1817       return;
1818    }
1819
1820    Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1821    Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1822
1823    /* Use fixed block size to simplify read back */
1824    min_block_size = dev->min_block_size;
1825    dev->min_block_size = dev->max_block_size;
1826    set_volume_name("TestVolume1", 1);
1827
1828    if (!dev->rewind(dcr)) {
1829       Pmsg0(000, _("Rewind failed.\n"));
1830    }
1831    if (!dev->weof(1)) {
1832       Pmsg0(000, _("Write EOF failed.\n"));
1833    }
1834    labelcmd();
1835    dev->set_append();                 /* force volume to be relabeled */
1836
1837    /*
1838     * Acquire output device for writing.  Note, after acquiring a
1839     *   device, we MUST release it, which is done at the end of this
1840     *   subroutine.
1841     */
1842    Dmsg0(100, "just before acquire_device\n");
1843    if (!acquire_device_for_append(dcr)) {
1844       set_jcr_job_status(jcr, JS_ErrorTerminated);
1845       return;
1846    }
1847    block = jcr->dcr->block;
1848
1849    Dmsg0(100, "Just after acquire_device_for_append\n");
1850    /*
1851     * Write Begin Session Record
1852     */
1853    if (!write_session_label(dcr, SOS_LABEL)) {
1854       set_jcr_job_status(jcr, JS_ErrorTerminated);
1855       Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1856          dev->bstrerror());
1857       ok = false;
1858    }
1859    Pmsg0(-1, _("Wrote Start of Session label.\n"));
1860
1861    memset(&rec, 0, sizeof(rec));
1862    rec.data = get_memory(100000);     /* max record size */
1863
1864 #define REC_SIZE 32768
1865    rec.data_len = REC_SIZE;
1866
1867    /*
1868     * Put some random data in the record
1869     */
1870    fd = open("/dev/urandom", O_RDONLY);
1871    if (fd) {
1872       read(fd, rec.data, rec.data_len);
1873       close(fd);
1874    } else {
1875       uint32_t *p = (uint32_t *)rec.data;
1876       srandom(time(NULL));
1877       for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1878          p[i] = random();
1879       }
1880    }
1881
1882    /*
1883     * Generate data as if from File daemon, write to device
1884     */
1885    jcr->dcr->VolFirstIndex = 0;
1886    time(&jcr->run_time);              /* start counting time for rates */
1887    (void)localtime_r(&jcr->run_time, &tm);
1888    strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1889    if (simple) {
1890       Pmsg1(-1, _("%s Begin writing Bacula records to tape ...\n"), buf1);
1891    } else {
1892       Pmsg1(-1, _("%s Begin writing Bacula records to first tape ...\n"), buf1);
1893    }
1894    for (file_index = 0; ok && !job_canceled(jcr); ) {
1895       rec.VolSessionId = jcr->VolSessionId;
1896       rec.VolSessionTime = jcr->VolSessionTime;
1897       rec.FileIndex = ++file_index;
1898       rec.Stream = STREAM_FILE_DATA;
1899
1900       /* Mix up the data just a bit */
1901       uint32_t *lp = (uint32_t *)rec.data;
1902       lp[0] += lp[13];
1903       for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1904          lp[i] += lp[i-1];
1905       }
1906
1907       Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1908          rec.FileIndex, rec.VolSessionId,
1909          stream_to_ascii(buf1, rec.Stream, rec.FileIndex),
1910          rec.data_len);
1911
1912       while (!write_record_to_block(block, &rec)) {
1913          /*
1914           * When we get here we have just filled a block
1915           */
1916          Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1917                     rec.remainder);
1918
1919          /* Write block to tape */
1920          if (!flush_block(block, 1)) {
1921             break;
1922          }
1923
1924          /* Every 5000 blocks (approx 322MB) report where we are.
1925           */
1926          if ((block->BlockNumber % 5000) == 0) {
1927             now = time(NULL);
1928             now -= jcr->run_time;
1929             if (now <= 0) {
1930                now = 1;          /* prevent divide error */
1931             }
1932             kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1933             Pmsg4(-1, _("Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n"),
1934                block->BlockNumber, dev->block_num,
1935                edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1936          }
1937          /* Every 32000 blocks (approx 2GB) write an EOF.
1938           */
1939          if ((block->BlockNumber % 32000) == 0) {
1940             now = time(NULL);
1941             (void)localtime_r(&now, &tm);
1942             strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
1943             Pmsg1(-1, _("%s Flush block, write EOF\n"), buf1);
1944             flush_block(block, 0);
1945             dev->weof(1);
1946          }
1947
1948          /* Get out after writing 10 blocks to the second tape */
1949          if (++BlockNumber > 10 && stop != 0) {      /* get out */
1950             break;
1951          }
1952       }
1953       if (!ok) {
1954          Pmsg0(000, _("Not OK\n"));
1955          break;
1956       }
1957       jcr->JobBytes += rec.data_len;   /* increment bytes this job */
1958       Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1959          FI_to_ascii(buf1, rec.FileIndex), rec.VolSessionId,
1960          stream_to_ascii(buf2, rec.Stream, rec.FileIndex), rec.data_len);
1961
1962       /* Get out after writing 10 blocks to the second tape */
1963       if (BlockNumber > 10 && stop != 0) {      /* get out */
1964          char ed1[50];
1965          Pmsg1(-1, "Done writing %s records ...\n",
1966              edit_uint64_with_commas(write_count, ed1));
1967          break;
1968       }
1969    }
1970    if (vol_num > 1) {
1971       Dmsg0(100, "Write_end_session_label()\n");
1972       /* Create Job status for end of session label */
1973       if (!job_canceled(jcr) && ok) {
1974          set_jcr_job_status(jcr, JS_Terminated);
1975       } else if (!ok) {
1976          set_jcr_job_status(jcr, JS_ErrorTerminated);
1977       }
1978       if (!write_session_label(dcr, EOS_LABEL)) {
1979          Pmsg1(000, _("Error writting end session label. ERR=%s\n"), dev->bstrerror());
1980          ok = false;
1981       }
1982       /* Write out final block of this session */
1983       if (!write_block_to_device(dcr)) {
1984          Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
1985          ok = false;
1986       }
1987       Pmsg0(-1, _("Wrote End of Session label.\n"));
1988
1989       /* Save last block info for second tape */
1990       last_block_num2 = last_block_num;
1991       last_file2 = last_file;
1992       if (last_block2) {
1993          free_block(last_block2);
1994       }
1995       last_block2 = dup_block(last_block);
1996    }
1997
1998    sprintf(buf, "%s/btape.state", working_directory);
1999    fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
2000    if (fd >= 0) {
2001       write(fd, &btape_state_level, sizeof(btape_state_level));
2002       write(fd, &simple, sizeof(simple));
2003       write(fd, &last_block_num1, sizeof(last_block_num1));
2004       write(fd, &last_block_num2, sizeof(last_block_num2));
2005       write(fd, &last_file1, sizeof(last_file1));
2006       write(fd, &last_file2, sizeof(last_file2));
2007       write(fd, last_block1->buf, last_block1->buf_len);
2008       write(fd, last_block2->buf, last_block2->buf_len);
2009       write(fd, first_block->buf, first_block->buf_len);
2010       close(fd);
2011       Pmsg2(-1, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2012          last_block_num1, last_block_num2);
2013    } else {
2014       berrno be;
2015       Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
2016                  be.strerror());
2017    }
2018
2019    now = time(NULL);
2020    (void)localtime_r(&now, &tm);
2021    strftime(buf1, sizeof(buf1), "%H:%M:%S", &tm);
2022    if (simple) {
2023       Pmsg3(-1, _("\n\n%s Done filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2024          buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2025    }
2026    else {
2027       Pmsg3(-1, _("\n\n%s Done filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2028          buf1, jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2029    }
2030
2031    jcr->dcr->block = block;
2032    do_unfill();
2033
2034    dev->min_block_size = min_block_size;
2035    free_memory(rec.data);
2036 }
2037
2038 /*
2039  * Read two tapes written by the "fill" command and ensure
2040  *  that the data is valid.  If stop==1 we simulate full read back
2041  *  of two tapes.  If stop==-1 we simply read the last block and
2042  *  verify that it is correct.
2043  */
2044 static void unfillcmd()
2045 {
2046    int fd;
2047
2048    last_block1 = new_block(dev);
2049    last_block2 = new_block(dev);
2050    first_block = new_block(dev);
2051    sprintf(buf, "%s/btape.state", working_directory);
2052    fd = open(buf, O_RDONLY);
2053    if (fd >= 0) {
2054       uint32_t state_level;
2055       read(fd, &state_level, sizeof(btape_state_level));
2056       read(fd, &simple, sizeof(simple));
2057       read(fd, &last_block_num1, sizeof(last_block_num1));
2058       read(fd, &last_block_num2, sizeof(last_block_num2));
2059       read(fd, &last_file1, sizeof(last_file1));
2060       read(fd, &last_file2, sizeof(last_file2));
2061       read(fd, last_block1->buf, last_block1->buf_len);
2062       read(fd, last_block2->buf, last_block2->buf_len);
2063       read(fd, first_block->buf, first_block->buf_len);
2064       close(fd);
2065       if (state_level != btape_state_level) {
2066           Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2067                   "the fill command.\n"));
2068           return;
2069        }
2070    } else {
2071       berrno be;
2072       Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2073              "You must redo the fill command.\n"), buf, be.strerror());
2074       return;
2075    }
2076    do_unfill();
2077    this_block = NULL;
2078 }
2079
2080 static void do_unfill()
2081 {
2082    DEV_BLOCK *block = dcr->block;
2083    bool autochanger;
2084
2085    dumped = 0;
2086    VolBytes = 0;
2087    LastBlock = 0;
2088
2089    Dmsg0(20, "Enter do_unfill\n");
2090    dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
2091    dev->capabilities &= ~CAP_LABEL;   /* don't label anything here */
2092
2093    end_of_tape = 0;
2094
2095    time(&jcr->run_time);              /* start counting time for rates */
2096    stop = 0;
2097    file_index = 0;
2098    if (last_block) {
2099       free_block(last_block);
2100    }
2101    last_block_num = last_block_num1;
2102    last_file = last_file1;
2103    last_block = last_block1;
2104
2105    if (!simple) {
2106       /* Multiple Volume tape */
2107       /* Close device so user can use autochanger if desired */
2108       if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2109          dev->offline();
2110       }
2111       autochanger = autoload_device(dcr, 1, NULL);
2112       if (!autochanger) {
2113          dev->close();
2114          get_cmd(_("Mount first tape. Press enter when ready: "));
2115       }
2116    }
2117
2118    free_restore_volume_list(jcr);
2119    jcr->dcr = new_dcr(jcr, dev);
2120    set_volume_name("TestVolume1", 1);
2121    jcr->bsr = NULL;
2122    create_restore_volume_list(jcr);
2123    dev->close();
2124    dev->num_writers = 0;
2125    if (!acquire_device_for_read(dcr)) {
2126       Pmsg1(-1, "%s", dev->errmsg);
2127       goto bail_out;
2128    }
2129    /*
2130     * We now have the first tape mounted.
2131     * Note, re-reading last block may have caused us to
2132     *   loose track of where we are (block number unknown).
2133     */
2134    Pmsg0(-1, _("Rewinding.\n"));
2135    if (!dev->rewind(dcr)) {                /* get to a known place on tape */
2136       goto bail_out;
2137    }
2138    /* Read the first 10000 records */
2139    Pmsg2(-1, _("Reading the first 10000 records from %u:%u.\n"),
2140       dev->file, dev->block_num);
2141    quickie_count = 0;
2142    read_records(dcr, quickie_cb, my_mount_next_read_volume);
2143    Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2144          last_file, last_block_num);
2145    if (!dev->reposition(last_file, last_block_num)) {
2146       Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2147       goto bail_out;
2148    }
2149    Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2150    if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2151       Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2152       goto bail_out;
2153    }
2154    if (compare_blocks(last_block, block)) {
2155       if (simple) {
2156          Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2157       } else {
2158          Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2159       }
2160    }
2161    if (simple) {
2162       goto bail_out;
2163    }
2164
2165    /* restore info for last block on second Volume */
2166    last_block_num = last_block_num2;
2167    last_file = last_file2;
2168    last_block = last_block2;
2169
2170    /* Multiple Volume tape */
2171    /* Close device so user can use autochanger if desired */
2172    if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2173       dev->offline();
2174    }
2175
2176    free_restore_volume_list(jcr);
2177    set_volume_name("TestVolume2", 2);
2178    jcr->bsr = NULL;
2179    create_restore_volume_list(jcr);
2180    autochanger = autoload_device(dcr, 1, NULL);
2181    if (!autochanger) {
2182       dev->close();
2183       get_cmd(_("Mount second tape. Press enter when ready: "));
2184    }
2185
2186    dev->clear_read();
2187    if (!acquire_device_for_read(dcr)) {
2188       Pmsg1(-1, "%s", dev->errmsg);
2189       goto bail_out;
2190    }
2191
2192    /* Space to "first" block which is last block not written
2193     * on the previous tape.
2194     */
2195    Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2196    if (!dev->reposition(0, 1)) {
2197       Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2198       goto bail_out;
2199    }
2200    Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2201    if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2202       Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2203       goto bail_out;
2204    }
2205    if (compare_blocks(first_block, block)) {
2206       Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2207    }
2208
2209    /* Now find and compare the last block */
2210    Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2211          last_file, last_block_num);
2212    if (!dev->reposition(last_file, last_block_num)) {
2213       Pmsg1(-1, _("Reposition error. ERR=%s\n"), dev->bstrerror());
2214       goto bail_out;
2215    }
2216    Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2217    if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2218       Pmsg1(-1, _("Error reading block: ERR=%s\n"), dev->bstrerror());
2219       goto bail_out;
2220    }
2221    if (compare_blocks(last_block, block)) {
2222       Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2223    }
2224
2225 bail_out:
2226    free_block(last_block1);
2227    free_block(last_block2);
2228    free_block(first_block);
2229 }
2230
2231 /* Read 10000 records then stop */
2232 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2233 {
2234    DEVICE *dev = dcr->dev;
2235    quickie_count++;
2236    if (quickie_count == 10000) {
2237       Pmsg2(-1, _("10000 records read now at %d:%d\n"), dev->file, dev->block_num);
2238    }
2239    return quickie_count < 10000;
2240 }
2241
2242 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2243 {
2244    char *p, *q;
2245    uint32_t CheckSum, block_len;
2246    ser_declare;
2247
2248    p = last_block->buf;
2249    q = block->buf;
2250    unser_begin(q, BLKHDR2_LENGTH);
2251    unser_uint32(CheckSum);
2252    unser_uint32(block_len);
2253    while (q < (block->buf+block_len)) {
2254       if (*p == *q) {
2255          p++;
2256          q++;
2257          continue;
2258       }
2259       Pmsg0(-1, "\n");
2260       dump_block(last_block, _("Last block written"));
2261       Pmsg0(-1, "\n");
2262       dump_block(block, _("Block read back"));
2263       Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2264       Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2265                 "that was read back differ. The test FAILED !!!!\n"
2266                 "This must be corrected before you use Bacula\n"
2267                 "to write multi-tape Volumes.!!!!\n"));
2268       return false;
2269    }
2270    if (verbose) {
2271       dump_block(last_block, _("Last block written"));
2272       dump_block(block, _("Block read back"));
2273    }
2274    return true;
2275 }
2276
2277
2278
2279
2280
2281 /*
2282  * Write current block to tape regardless of whether or
2283  *   not it is full. If the tape fills, attempt to
2284  *   acquire another tape.
2285  */
2286 static int flush_block(DEV_BLOCK *block, int dump)
2287 {
2288    char ec1[50];
2289    DEV_BLOCK *tblock;
2290    uint32_t this_file, this_block_num;
2291
2292    lock_device(dev);
2293    if (!this_block) {
2294       this_block = new_block(dev);
2295    }
2296    if (!last_block) {
2297       last_block = new_block(dev);
2298    }
2299    /* Copy block */
2300    this_file = dev->file;
2301    this_block_num = dev->block_num;
2302    if (!write_block_to_dev(dcr)) {
2303       Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2304                   last_file, last_block_num, this_block_num);
2305       if (vol_num == 1) {
2306          /*
2307           * This is 1st tape, so save first tape info separate
2308           *  from second tape info
2309           */
2310          last_block_num1 = last_block_num;
2311          last_file1 = last_file;
2312          last_block1 = dup_block(last_block);
2313          last_block2 = dup_block(last_block);
2314          first_block = dup_block(block); /* first block second tape */
2315       }
2316       if (verbose) {
2317          Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2318             (unsigned)file_index, block->BlockNumber, block->block_len);
2319          dump_block(last_block, _("Last block written"));
2320          Pmsg0(-1, "\n");
2321          dump_block(block, _("Block not written"));
2322       }
2323       if (stop == 0) {
2324          eot_block = block->BlockNumber;
2325          eot_block_len = block->block_len;
2326          eot_FileIndex = file_index;
2327          stop = 1;
2328       }
2329       now = time(NULL);
2330       now -= jcr->run_time;
2331       if (now <= 0) {
2332          now = 1;                     /* don't divide by zero */
2333       }
2334       kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2335       vol_size = dev->VolCatInfo.VolCatBytes;
2336       Pmsg4(000, _("End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
2337          dev->file, dev->block_num,
2338          edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2339
2340       if (simple) {
2341          stop = -1;                   /* stop, but do simplified test */
2342       } else {
2343          /* Full test in progress */
2344          if (!fixup_device_block_write_error(jcr->dcr)) {
2345             Pmsg1(000, _("Cannot fixup device error. %s\n"), dev->bstrerror());
2346             ok = false;
2347             unlock_device(dev);
2348             return 0;
2349          }
2350          BlockNumber = 0;             /* start counting for second tape */
2351       }
2352       unlock_device(dev);
2353       return 1;                       /* end of tape reached */
2354    }
2355
2356    /* Save contents after write so that the header is serialized */
2357    memcpy(this_block->buf, block->buf, this_block->buf_len);
2358
2359    /*
2360     * Note, we always read/write to block, but we toggle
2361     *  copying it to one or another of two allocated blocks.
2362     * Switch blocks so that the block just successfully written is
2363     *  always in last_block.
2364     */
2365    tblock = last_block;
2366    last_block = this_block;
2367    this_block = tblock;
2368    last_file = this_file;
2369    last_block_num = this_block_num;
2370
2371    unlock_device(dev);
2372    return 1;
2373 }
2374
2375
2376 /*
2377  * First we label the tape, then we fill
2378  *  it with data get a new tape and write a few blocks.
2379  */
2380 static void qfillcmd()
2381 {
2382    DEV_BLOCK *block = dcr->block;
2383    DEV_RECORD *rec = dcr->rec;
2384    int i, count;
2385
2386    Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2387
2388    get_cmd(_("How many blocks do you want to write? (1000): "));
2389
2390    count = atoi(cmd);
2391    if (count <= 0) {
2392       count = 1000;
2393    }
2394
2395    sm_check(__FILE__, __LINE__, false);
2396
2397    i = block->buf_len - 100;
2398    ASSERT (i > 0);
2399    rec->data = check_pool_memory_size(rec->data, i);
2400    memset(rec->data, i & 0xFF, i);
2401    rec->data_len = i;
2402    rewindcmd();
2403    Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2404    for (i=0; i < count; i++) {
2405       if (i % 100 == 0) {
2406          printf("+");
2407          fflush(stdout);
2408       }
2409       if (!write_record_to_block(block, rec)) {
2410          Pmsg0(0, _("Error writing record to block.\n"));
2411          goto bail_out;
2412       }
2413       if (!write_block_to_dev(dcr)) {
2414          Pmsg0(0, _("Error writing block to device.\n"));
2415          goto bail_out;
2416       }
2417    }
2418    printf("\n");
2419    weofcmd();
2420    if (dev_cap(dev, CAP_TWOEOF)) {
2421       weofcmd();
2422    }
2423    rewindcmd();
2424    scan_blocks();
2425
2426 bail_out:
2427    sm_check(__FILE__, __LINE__, false);
2428 }
2429
2430 /*
2431  * Fill a tape using raw write() command
2432  */
2433 static void rawfill_cmd()
2434 {
2435    DEV_BLOCK *block = dcr->block;
2436    int stat;
2437    int fd;
2438    uint32_t block_num = 0;
2439    uint32_t *p;
2440    int my_errno;
2441    uint32_t i;
2442
2443    fd = open("/dev/urandom", O_RDONLY);
2444    if (fd) {
2445       read(fd, block->buf, block->buf_len);
2446       close(fd);
2447    } else {
2448       uint32_t *p = (uint32_t *)block->buf;
2449       srandom(time(NULL));
2450       for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2451          p[i] = random();
2452       }
2453    }
2454    p = (uint32_t *)block->buf;
2455    Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2456    for ( ;; ) {
2457       *p = block_num;
2458       stat = write(dev->fd, block->buf, block->buf_len);
2459       if (stat == (int)block->buf_len) {
2460          if ((block_num++ % 100) == 0) {
2461             printf("+");
2462             fflush(stdout);
2463          }
2464          p[0] += p[13];
2465          for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2466             p[i] += p[i-1];
2467          }
2468          continue;
2469       }
2470       break;
2471    }
2472    my_errno = errno;
2473    printf("\n");
2474    berrno be;
2475    printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2476       be.strerror(my_errno));
2477    weofcmd();
2478 }
2479
2480
2481 /*
2482  * Fill a tape using Bacula block writes
2483  */
2484 static void bfill_cmd()
2485 {
2486    DEV_BLOCK *block = dcr->block;
2487    uint32_t block_num = 0;
2488    uint32_t *p;
2489    int my_errno;
2490    int fd;
2491    uint32_t i;
2492
2493    fd = open("/dev/urandom", O_RDONLY);
2494    if (fd) {
2495       read(fd, block->buf, block->buf_len);
2496       close(fd);
2497    } else {
2498       uint32_t *p = (uint32_t *)block->buf;
2499       srandom(time(NULL));
2500       for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2501          p[i] = random();
2502       }
2503    }
2504    p = (uint32_t *)block->buf;
2505    Pmsg1(0, _("Begin writing Bacula blocks of %u bytes.\n"), block->buf_len);
2506    for ( ;; ) {
2507       *p = block_num;
2508       block->binbuf = block->buf_len;
2509       block->bufp = block->buf + block->binbuf;
2510       if (!write_block_to_dev(dcr)) {
2511          break;
2512       }
2513       if ((block_num++ % 100) == 0) {
2514          printf("+");
2515          fflush(stdout);
2516       }
2517       p[0] += p[13];
2518       for (i=1; i<(block->buf_len/sizeof(uint32_t)-1); i++) {
2519          p[i] += p[i-1];
2520       }
2521    }
2522    my_errno = errno;
2523    printf("\n");
2524    printf(_("Write failed at block %u.\n"), block_num);
2525    weofcmd();
2526 }
2527
2528
2529 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2530 static struct cmdstruct commands[] = {
2531  {NT_("autochanger"),autochangercmd, _("test autochanger")},
2532  {NT_("bsf"),       bsfcmd,       _("backspace file")},
2533  {NT_("bsr"),       bsrcmd,       _("backspace record")},
2534  {NT_("bfill"),     bfill_cmd,    _("fill tape using Bacula writes")},
2535  {NT_("cap"),       capcmd,       _("list device capabilities")},
2536  {NT_("clear"),     clearcmd,     _("clear tape errors")},
2537  {NT_("eod"),       eodcmd,       _("go to end of Bacula data for append")},
2538  {NT_("eom"),       eomcmd,       _("go to the physical end of medium")},
2539  {NT_("fill"),      fillcmd,      _("fill tape, write onto second volume")},
2540  {NT_("unfill"),    unfillcmd,    _("read filled tape")},
2541  {NT_("fsf"),       fsfcmd,       _("forward space a file")},
2542  {NT_("fsr"),       fsrcmd,       _("forward space a record")},
2543  {NT_("help"),      helpcmd,      _("print this command")},
2544  {NT_("label"),     labelcmd,     _("write a Bacula label to the tape")},
2545  {NT_("load"),      loadcmd,      _("load a tape")},
2546  {NT_("quit"),      quitcmd,      _("quit btape")},
2547  {NT_("rawfill"),   rawfill_cmd,  _("use write() to fill tape")},
2548  {NT_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2549  {NT_("rectest"),   rectestcmd,   _("test record handling functions")},
2550  {NT_("rewind"),    rewindcmd,    _("rewind the tape")},
2551  {NT_("scan"),      scancmd,      _("read() tape block by block to EOT and report")},
2552  {NT_("scanblocks"),scan_blocks,  _("Bacula read block by block to EOT and report")},
2553  {NT_("status"),    statcmd,      _("print tape status")},
2554  {NT_("test"),      testcmd,      _("General test Bacula tape functions")},
2555  {NT_("weof"),      weofcmd,      _("write an EOF on the tape")},
2556  {NT_("wr"),        wrcmd,        _("write a single Bacula block")},
2557  {NT_("rr"),        rrcmd,        _("read a single record")},
2558  {NT_("qfill"),     qfillcmd,     _("quick fill command")}
2559              };
2560 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2561
2562 static void
2563 do_tape_cmds()
2564 {
2565    unsigned int i;
2566    bool found;
2567
2568    while (get_cmd("*")) {
2569       sm_check(__FILE__, __LINE__, false);
2570       found = false;
2571       parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2572       for (i=0; i<comsize; i++)       /* search for command */
2573          if (argc > 0 && fstrsch(argk[0],  commands[i].key)) {
2574             (*commands[i].func)();    /* go execute command */
2575             found = true;
2576             break;
2577          }
2578       if (!found)
2579          Pmsg1(0, _("%s is an illegal command\n"), cmd);
2580       if (quit)
2581          break;
2582    }
2583 }
2584
2585 static void helpcmd()
2586 {
2587    unsigned int i;
2588    usage();
2589    printf(_("Interactive commands:\n"));
2590    printf(_("  Command    Description\n  =======    ===========\n"));
2591    for (i=0; i<comsize; i++)
2592       printf("  %-10s %s\n", commands[i].key, commands[i].help);
2593    printf("\n");
2594 }
2595
2596 static void usage()
2597 {
2598    fprintf(stderr, _(
2599 "Copyright (C) 2000-2005 Kern Sibbald.\n"
2600 "\nVersion: %s (%s)\n\n"
2601 "Usage: btape <options> <device_name>\n"
2602 "       -b <file>   specify bootstrap file\n"
2603 "       -c <file>   set configuration file to file\n"
2604 "       -d <nn>     set debug level to nn\n"
2605 "       -p          proceed inspite of I/O errors\n"
2606 "       -s          turn off signals\n"
2607 "       -v          be verbose\n"
2608 "       -?          print this message.\n"
2609 "\n"), VERSION, BDATE);
2610
2611 }
2612
2613 /*
2614  * Get next input command from terminal.  This
2615  * routine is REALLY primitive, and should be enhanced
2616  * to have correct backspacing, etc.
2617  */
2618 int
2619 get_cmd(const char *prompt)
2620 {
2621    int i = 0;
2622    int ch;
2623    fprintf(stdout, prompt);
2624
2625    /* We really should turn off echoing and pretty this
2626     * up a bit.
2627     */
2628    cmd[i] = 0;
2629    while ((ch = fgetc(stdin)) != EOF) {
2630       if (ch == '\n') {
2631          strip_trailing_junk(cmd);
2632          return 1;
2633       } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2634          if (i > 0)
2635             cmd[--i] = 0;
2636          continue;
2637       }
2638
2639       cmd[i++] = ch;
2640       cmd[i] = 0;
2641    }
2642    quit = 1;
2643    return 0;
2644 }
2645
2646 /* Dummies to replace askdir.c */
2647 bool    dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2648 bool    dir_send_job_status(JCR *jcr) {return 1;}
2649
2650 bool dir_update_volume_info(DCR *dcr, bool relabel)
2651 {
2652    return 1;
2653 }
2654
2655
2656 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw  writing)
2657 {
2658    Dmsg0(20, "Enter dir_get_volume_info\n");
2659    bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2660    return 1;
2661 }
2662
2663 bool dir_create_jobmedia_record(DCR *dcr)
2664 {
2665    dcr->WroteVol = false;
2666    return 1;
2667 }
2668
2669
2670 bool dir_find_next_appendable_volume(DCR *dcr)
2671 {
2672    Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2673    return dcr->VolumeName[0] != 0;
2674 }
2675
2676 bool dir_ask_sysop_to_mount_volume(DCR *dcr)
2677 {
2678    DEVICE *dev = dcr->dev;
2679    Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2680    if (dcr->VolumeName[0] == 0) {
2681       return dir_ask_sysop_to_create_appendable_volume(dcr);
2682    }
2683    dev->close();
2684    Pmsg1(-1, "%s", dev->errmsg);           /* print reason */
2685    if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2686       fprintf(stderr, _("Mount second Volume on device %s and press return when ready: "),
2687          dev->print_name());
2688    } else {
2689       fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
2690          dcr->VolumeName, dev->print_name());
2691    }
2692    getchar();
2693    return true;
2694 }
2695
2696 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2697 {
2698    bool autochanger;
2699    DEVICE *dev = dcr->dev;
2700    Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2701    if (stop == 0) {
2702       set_volume_name("TestVolume1", 1);
2703    } else {
2704       set_volume_name("TestVolume2", 2);
2705    }
2706    /* Close device so user can use autochanger if desired */
2707    if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2708       dev->offline();
2709    }
2710    autochanger = autoload_device(dcr, 1, NULL);
2711    if (!autochanger) {
2712       dev->close();
2713       fprintf(stderr, _("Mount blank Volume on device %s and press return when ready: "),
2714          dev->print_name());
2715       getchar();
2716    }
2717    open_device(dcr);
2718    labelcmd();
2719    VolumeName = NULL;
2720    BlockNumber = 0;
2721    return true;
2722 }
2723
2724 static bool my_mount_next_read_volume(DCR *dcr)
2725 {
2726    char ec1[50];
2727    JCR *jcr = dcr->jcr;
2728    DEV_BLOCK *block = dcr->block;
2729
2730    Dmsg0(20, "Enter my_mount_next_read_volume\n");
2731    Pmsg2(000, _("End of Volume \"%s\" %d records.\n"), dcr->VolumeName,
2732       quickie_count);
2733
2734    if (LastBlock != block->BlockNumber) {
2735       VolBytes += block->block_len;
2736    }
2737    LastBlock = block->BlockNumber;
2738    now = time(NULL);
2739    now -= jcr->run_time;
2740    if (now <= 0) {
2741       now = 1;
2742    }
2743    kbs = (double)VolBytes / (1000.0 * (double)now);
2744    Pmsg3(-1, _("Read block=%u, VolBytes=%s rate=%.1f KB/s\n"), block->BlockNumber,
2745             edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2746
2747    if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2748       end_of_tape = 1;
2749       return false;
2750    }
2751
2752    free_restore_volume_list(jcr);
2753    set_volume_name("TestVolume2", 2);
2754    jcr->bsr = NULL;
2755    create_restore_volume_list(jcr);
2756    dev->close();
2757    if (!acquire_device_for_read(dcr)) {
2758       Pmsg2(0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(), dcr->VolumeName);
2759       return false;
2760    }
2761    return true;                    /* next volume mounted */
2762 }
2763
2764 static void set_volume_name(const char *VolName, int volnum)
2765 {
2766    DCR *dcr = jcr->dcr;
2767    VolumeName = VolName;
2768    vol_num = volnum;
2769    bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2770    bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2771    bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2772    dcr->VolCatInfo.Slot = volnum;
2773 }