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