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-2005 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       term_dev(dev);
 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"), strerror_dev(dev));
 367       }
 368    }
 369    rewind_dev(dev);
 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"), strerror_dev(dev));
 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"), strerror_dev(dev));
 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"), strerror_dev(dev));
 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 (!rewind_dev(dev)) {
 435       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), strerror_dev(dev));
 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, strerror_dev(dev));
 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 (!eod_dev(dev)) {
 487       Pmsg1(0, "%s", strerror_dev(dev));
 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 (!bsf_dev(dev, num)) {
 517       Pmsg1(0, _("Bad status from bsf. ERR=%s\n"), strerror_dev(dev));
 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 (!bsr_dev(dev, num)) {
 536       Pmsg1(0, _("Bad status from bsr. ERR=%s\n"), strerror_dev(dev));
 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 (!bsf_dev(dev, 1)) {
 703       Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror_dev(dev));
 704       goto bail_out;
 705    }
 706    if (dev_cap(dev, CAP_TWOEOF)) {
 707       if (!bsf_dev(dev, 1)) {
 708          Pmsg1(0, _("Backspace file failed! ERR=%s\n"), strerror_dev(dev));
 709          goto bail_out;
 710       }
 711    }
 712    Pmsg0(0, _("Backspaced over EOF OK.\n"));
 713    if (!bsr_dev(dev, 1)) {
 714       Pmsg1(0, _("Backspace record failed! ERR=%s\n"), strerror_dev(dev));
 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 (!rewind_dev(dev)) {
 775       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), strerror_dev(dev));
 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 (!rewind_dev(dev)) {
 817       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), strerror_dev(dev));
 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 (!rewind_dev(dev)) {
 887       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), strerror_dev(dev));
 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 (!rewind_dev(dev)) {
 929       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), strerror_dev(dev));
 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 (!reposition_dev(dev, 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    force_close_device(dev);              /* 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       offline_or_rewind_dev(dev);
1151       /* We are going to load a new tape, so close the device */
1152       force_close_device(dev);
1153       Pmsg2(-1, _("3302 Issuing autochanger \"unload %d %d\" command.\n"),
1154          loaded, dev->drive_index);
1155       changer = edit_device_codes(dcr, changer,
1156                    dcr->device->changer_command, "unload");
1157       status = run_program(changer, timeout, results);
1158       Pmsg2(-1, _("unload status=%s %d\n"), status==0?_("OK"):_("Bad"), status);
1159       if (status != 0) {
1160          berrno be;
1161          Pmsg1(-1, _("3992 Bad autochanger command: %s\n"), changer);
1162          Pmsg2(-1, _("3992 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1163       }
1164    }
1165
1166    /*
1167     * Load the Slot 1
1168     */
1169
1170    slot = 1;
1171    dcr->VolCatInfo.Slot = slot;
1172    Pmsg2(-1, _("3303 Issuing autochanger \"load %d %d\" command.\n"),
1173       slot, dev->drive_index);
1174    changer = edit_device_codes(dcr, changer,
1175                 dcr->device->changer_command, "load");
1176    Dmsg1(100, "Changer=%s\n", changer);
1177    force_close_device(dev);
1178    status = run_program(changer, timeout, results);
1179    if (status == 0) {
1180       Pmsg2(-1,  _("3303 Autochanger \"load %d %d\" status is OK.\n"),
1181          slot, dev->drive_index);
1182    } else {
1183       berrno be;
1184       Pmsg1(-1, _("3993 Bad autochanger command: %s\n"), changer);
1185       Pmsg2(-1, _("3993 result=\"%s\": ERR=%s\n"), results, be.strerror(status));
1186       goto bail_out;
1187    }
1188
1189    if (!open_the_device()) {
1190       goto bail_out;
1191    }
1192    /*
1193     * Start with sleep_time 0 then increment by 30 seconds if we get
1194     * a failure.
1195     */
1196    bmicrosleep(sleep_time, 0);
1197    if (!rewind_dev(dev) || weof_dev(dev,1) < 0) {
1198       Pmsg1(0, _("Bad status from rewind. ERR=%s\n"), strerror_dev(dev));
1199       clrerror_dev(dev, -1);
1200       Pmsg0(-1, _("\nThe test failed, probably because you need to put\n"
1201                 "a longer sleep time in the mtx-script in the load) case.\n"
1202                 "Adding a 30 second sleep and trying again ...\n"));
1203       sleep_time += 30;
1204       goto try_again;
1205    } else {
1206       Pmsg1(0, _("Rewound %s\n"), dev->print_name());
1207    }
1208
1209    if ((status = weof_dev(dev, 1)) < 0) {
1210       Pmsg2(0, _("Bad status from weof %d. ERR=%s\n"), status, strerror_dev(dev));
1211       goto bail_out;
1212    } else {
1213       Pmsg1(0, _("Wrote EOF to %s\n"), dev->print_name());
1214    }
1215
1216    if (sleep_time) {
1217       Pmsg1(-1, _("\nThe test worked this time. Please add:\n\n"
1218                 "   sleep %d\n\n"
1219                 "to your mtx-changer script in the load) case.\n\n"),
1220                 sleep_time);
1221    } else {
1222       Pmsg0(-1, _("\nThe test autochanger worked!!\n\n"));
1223    }
1224
1225    free_pool_memory(changer);
1226    free_pool_memory(results);
1227    return 1;
1228
1229
1230 bail_out:
1231    free_pool_memory(changer);
1232    free_pool_memory(results);
1233    Pmsg0(-1, _("You must correct this error or the Autochanger will not work.\n"));
1234    return -2;
1235 }
1236
1237 static void autochangercmd()
1238 {
1239    autochanger_test();
1240 }
1241
1242
1243 /*
1244  * This test assumes that the append test has been done,
1245  *   then it tests the fsf function.
1246  */
1247 static int fsf_test()
1248 {
1249    bool set_off = false;
1250
1251    Pmsg0(-1, _("\n\n=== Forward space files test ===\n\n"
1252                "This test is essential to Bacula.\n\n"
1253                "I'm going to write five files then test forward spacing\n\n"));
1254    argc = 1;
1255    rewindcmd();
1256    wrcmd();
1257    weofcmd();      /* end file 0 */
1258    wrcmd();
1259    wrcmd();
1260    weofcmd();      /* end file 1 */
1261    wrcmd();
1262    wrcmd();
1263    wrcmd();
1264    weofcmd();     /* end file 2 */
1265    wrcmd();
1266    wrcmd();
1267    weofcmd();     /* end file 3 */
1268    wrcmd();
1269    weofcmd();     /* end file 4 */
1270    if (dev_cap(dev, CAP_TWOEOF)) {
1271       weofcmd();
1272    }
1273
1274 test_again:
1275    rewindcmd();
1276    Pmsg0(0, _("Now forward spacing 1 file.\n"));
1277    if (!dev->fsf(1)) {
1278       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), strerror_dev(dev));
1279       goto bail_out;
1280    }
1281    Pmsg2(-1, _("We should be in file 1. I am at file %d. %s\n"),
1282       dev->file, dev->file == 1 ? _("This is correct!") : _("This is NOT correct!!!!"));
1283
1284    if (dev->file != 1) {
1285       goto bail_out;
1286    }
1287
1288    Pmsg0(0, _("Now forward spacing 2 files.\n"));
1289    if (!dev->fsf(2)) {
1290       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), strerror_dev(dev));
1291       goto bail_out;
1292    }
1293    Pmsg2(-1, _("We should be in file 3. I am at file %d. %s\n"),
1294       dev->file, dev->file == 3 ? _("This is correct!") : _("This is NOT correct!!!!"));
1295
1296    if (dev->file != 3) {
1297       goto bail_out;
1298    }
1299
1300    rewindcmd();
1301    Pmsg0(0, _("Now forward spacing 4 files.\n"));
1302    if (!dev->fsf(4)) {
1303       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), strerror_dev(dev));
1304       goto bail_out;
1305    }
1306    Pmsg2(-1, _("We should be in file 4. I am at file %d. %s\n"),
1307       dev->file, dev->file == 4 ? _("This is correct!") : _("This is NOT correct!!!!"));
1308
1309    if (dev->file != 4) {
1310       goto bail_out;
1311    }
1312    if (set_off) {
1313       Pmsg0(-1, _("The test worked this time. Please add:\n\n"
1314                 "   Fast Forward Space File = no\n\n"
1315                 "to your Device resource for this drive.\n"));
1316    }
1317
1318    Pmsg0(-1, "\n");
1319    Pmsg0(0, _("Now forward spacing 1 more file.\n"));
1320    if (!dev->fsf(1)) {
1321       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), strerror_dev(dev));
1322    }
1323    Pmsg2(-1, _("We should be in file 5. I am at file %d. %s\n"),
1324       dev->file, dev->file == 5 ? _("This is correct!") : _("This is NOT correct!!!!"));
1325    if (dev->file != 5) {
1326       goto bail_out;
1327    }
1328    Pmsg0(-1, _("\n=== End Forward space files test ===\n\n"));
1329    return 1;
1330
1331 bail_out:
1332    Pmsg0(-1, _("\nThe forward space file test failed.\n"));
1333    if (dev_cap(dev, CAP_FASTFSF)) {
1334       Pmsg0(-1, _("You have Fast Forward Space File enabled.\n"
1335               "I am turning it off then retrying the test.\n"));
1336       dev->capabilities &= ~CAP_FASTFSF;
1337       set_off = true;
1338       goto test_again;
1339    }
1340    Pmsg0(-1, _("You must correct this error or Bacula will not work.\n"
1341             "Some systems, e.g. OpenBSD, require you to set\n"
1342             "   Use MTIOCGET= no\n"
1343             "in your device resource. Use with caution.\n"));
1344    return -2;
1345 }
1346
1347
1348
1349
1350
1351 /*
1352  * This is a general test of Bacula's functions
1353  *   needed to read and write the tape.
1354  */
1355 static void testcmd()
1356 {
1357    int stat;
1358
1359    if (!write_read_test()) {
1360       return;
1361    }
1362    if (!position_test()) {
1363       return;
1364    }
1365
1366    stat = append_test();
1367    if (stat == 1) {                   /* OK get out */
1368       goto all_done;
1369    }
1370    if (stat == -1) {                  /* first test failed */
1371       if (dev_cap(dev, CAP_EOM) || dev_cap(dev, CAP_FASTFSF)) {
1372          Pmsg0(-1, _("\nAppend test failed. Attempting again.\n"
1373                    "Setting \"Hardware End of Medium = no\n"
1374                    "    and \"Fast Forward Space File = no\n"
1375                    "and retrying append test.\n\n"));
1376          dev->capabilities &= ~CAP_EOM; /* turn off eom */
1377          dev->capabilities &= ~CAP_FASTFSF; /* turn off fast fsf */
1378          stat = append_test();
1379          if (stat == 1) {
1380             Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1381                      "    Hardware End of Medium = No\n\n"
1382                      "    Fast Forward Space File = No\n"
1383                      "to your Device resource in the Storage conf file.\n"));
1384             goto all_done;
1385          }
1386          if (stat == -1) {
1387             Pmsg0(-1, _("\n\nThat appears *NOT* to have corrected the problem.\n"));
1388             goto failed;
1389          }
1390          /* Wrong count after append */
1391          if (stat == -2) {
1392             Pmsg0(-1, _("\n\nIt looks like the append failed. Attempting again.\n"
1393                      "Setting \"BSF at EOM = yes\" and retrying append test.\n"));
1394             dev->capabilities |= CAP_BSFATEOM; /* backspace on eom */
1395             stat = append_test();
1396             if (stat == 1) {
1397                Pmsg0(-1, _("\n\nIt looks like the test worked this time, please add:\n\n"
1398                      "    Hardware End of Medium = No\n"
1399                      "    Fast Forward Space File = No\n"
1400                      "    BSF at EOM = yes\n\n"
1401                      "to your Device resource in the Storage conf file.\n"));
1402                goto all_done;
1403             }
1404          }
1405
1406       }
1407 failed:
1408       Pmsg0(-1, _("\nAppend test failed.\n\n"
1409             "\n!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
1410             "Unable to correct the problem. You MUST fix this\n"
1411              "problem before Bacula can use your tape drive correctly\n"
1412             "\nPerhaps running Bacula in fixed block mode will work.\n"
1413             "Do so by setting:\n\n"
1414             "Minimum Block Size = nnn\n"
1415             "Maximum Block Size = nnn\n\n"
1416             "in your Storage daemon's Device definition.\n"
1417             "nnn must match your tape driver's block size, which\n"
1418             "can be determined by reading your tape manufacturers\n"
1419             "information, and the information on your kernel dirver.\n"
1420             "Fixed block sizes, however, are not normally an ideal solution.\n"
1421             "\n"
1422             "Some systems, e.g. OpenBSD, require you to set\n"
1423             "   Use MTIOCGET= no\n"
1424             "in your device resource. Use with caution.\n"));
1425        return;
1426    }
1427
1428 all_done:
1429    Pmsg0(-1, _("\nThe above Bacula scan should have output identical to what follows.\n"
1430         "Please double check it ...\n"
1431         "=== Sample correct output ===\n"
1432         "1 block of 64448 bytes in file 1\n"
1433         "End of File mark.\n"
1434         "2 blocks of 64448 bytes in file 2\n"
1435         "End of File mark.\n"
1436         "3 blocks of 64448 bytes in file 3\n"
1437         "End of File mark.\n"
1438         "1 block of 64448 bytes in file 4\n"
1439         "End of File mark.\n"
1440         "Total files=4, blocks=7, bytes = 451,136\n"
1441         "=== End sample correct output ===\n\n"
1442         "If the above scan output is not identical to the\n"
1443         "sample output, you MUST correct the problem\n"
1444         "or Bacula will not be able to write multiple Jobs to \n"
1445         "the tape.\n\n"));
1446
1447    if (stat == 1) {
1448       re_read_block_test();
1449    }
1450
1451    fsf_test();                        /* do fast forward space file test */
1452
1453    autochanger_test();                /* do autochanger test */
1454
1455 }
1456
1457 /* Forward space a file */
1458 static void fsfcmd()
1459 {
1460    int num = 1;
1461    if (argc > 1) {
1462       num = atoi(argk[1]);
1463    }
1464    if (num <= 0) {
1465       num = 1;
1466    }
1467    if (!dev->fsf(num)) {
1468       Pmsg1(0, _("Bad status from fsf. ERR=%s\n"), strerror_dev(dev));
1469       return;
1470    }
1471    if (num == 1) {
1472       Pmsg0(0, _("Forward spaced 1 file.\n"));
1473    }
1474    else {
1475       Pmsg1(0, _("Forward spaced %d files.\n"), num);
1476    }
1477 }
1478
1479 /* Forward space a record */
1480 static void fsrcmd()
1481 {
1482    int num = 1;
1483    if (argc > 1) {
1484       num = atoi(argk[1]);
1485    }
1486    if (num <= 0) {
1487       num = 1;
1488    }
1489    if (!dev->fsr(num)) {
1490       Pmsg1(0, _("Bad status from fsr. ERR=%s\n"), strerror_dev(dev));
1491       return;
1492    }
1493    if (num == 1) {
1494       Pmsg0(0, _("Forward spaced 1 record.\n"));
1495    }
1496    else {
1497       Pmsg1(0, _("Forward spaced %d records.\n"), num);
1498    }
1499 }
1500
1501
1502 /*
1503  * Write a Bacula block to the tape
1504  */
1505 static void wrcmd()
1506 {
1507    DEV_BLOCK *block = dcr->block;
1508    DEV_RECORD *rec = dcr->rec;
1509    int i;
1510
1511    sm_check(__FILE__, __LINE__, false);
1512    empty_block(block);
1513    if (verbose > 1) {
1514       dump_block(block, "test");
1515    }
1516
1517    i = block->buf_len - 100;
1518    ASSERT (i > 0);
1519    rec->data = check_pool_memory_size(rec->data, i);
1520    memset(rec->data, i & 0xFF, i);
1521    rec->data_len = i;
1522    sm_check(__FILE__, __LINE__, false);
1523    if (!write_record_to_block(block, rec)) {
1524       Pmsg0(0, _("Error writing record to block.\n"));
1525       goto bail_out;
1526    }
1527    if (!write_block_to_dev(dcr)) {
1528       Pmsg0(0, _("Error writing block to device.\n"));
1529       goto bail_out;
1530    } else {
1531       Pmsg1(0, _("Wrote one record of %d bytes.\n"), i);
1532    }
1533    Pmsg0(0, _("Wrote block to device.\n"));
1534
1535 bail_out:
1536    sm_check(__FILE__, __LINE__, false);
1537    sm_check(__FILE__, __LINE__, false);
1538 }
1539
1540 /*
1541  * Read a record from the tape
1542  */
1543 static void rrcmd()
1544 {
1545    char *buf;
1546    int stat, len;
1547
1548    if (!get_cmd(_("Enter length to read: "))) {
1549       return;
1550    }
1551    len = atoi(cmd);
1552    if (len < 0 || len > 1000000) {
1553       Pmsg0(0, _("Bad length entered, using default of 1024 bytes.\n"));
1554       len = 1024;
1555    }
1556    buf = (char *)malloc(len);
1557    stat = read(dev->fd, buf, len);
1558    if (stat > 0 && stat <= len) {
1559       errno = 0;
1560    }
1561    berrno be;
1562    Pmsg3(0, _("Read of %d bytes gives stat=%d. ERR=%s\n"),
1563       len, stat, be.strerror());
1564    free(buf);
1565 }
1566
1567
1568 /*
1569  * Scan tape by reading block by block. Report what is
1570  * on the tape.  Note, this command does raw reads, and as such
1571  * will not work with fixed block size devices.
1572  */
1573 static void scancmd()
1574 {
1575    int stat;
1576    int blocks, tot_blocks, tot_files;
1577    int block_size;
1578    uint64_t bytes;
1579    char ec1[50];
1580
1581
1582    blocks = block_size = tot_blocks = 0;
1583    bytes = 0;
1584    if (dev->state & ST_EOT) {
1585       Pmsg0(0, _("End of tape\n"));
1586       return;
1587    }
1588    update_pos_dev(dev);
1589    tot_files = dev->file;
1590    Pmsg1(0, _("Starting scan at file %u\n"), dev->file);
1591    for (;;) {
1592       if ((stat = read(dev->fd, buf, sizeof(buf))) < 0) {
1593          berrno be;
1594          clrerror_dev(dev, -1);
1595          Mmsg2(dev->errmsg, _("read error on %s. ERR=%s.\n"),
1596             dev->dev_name, be.strerror());
1597          Pmsg2(0, _("Bad status from read %d. ERR=%s\n"), stat, strerror_dev(dev));
1598          if (blocks > 0) {
1599             if (blocks==1) {
1600                printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1601             }
1602             else {
1603                printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1604             }
1605          }
1606          return;
1607       }
1608       Dmsg1(200, "read status = %d\n", stat);
1609 /*    sleep(1); */
1610       if (stat != block_size) {
1611          update_pos_dev(dev);
1612          if (blocks > 0) {
1613             if (blocks==1) {
1614                printf(_("1 block of %d bytes in file %d\n"), block_size, dev->file);
1615             }
1616             else {
1617                printf(_("%d blocks of %d bytes in file %d\n"), blocks, block_size, dev->file);
1618             }
1619             blocks = 0;
1620          }
1621          block_size = stat;
1622       }
1623       if (stat == 0) {                /* EOF */
1624          update_pos_dev(dev);
1625          printf(_("End of File mark.\n"));
1626          /* Two reads of zero means end of tape */
1627          if (dev->state & ST_EOF)
1628             dev->state |= ST_EOT;
1629          else {
1630             dev->state |= ST_EOF;
1631             dev->file++;
1632          }
1633          if (dev->state & ST_EOT) {
1634             printf(_("End of tape\n"));
1635             break;
1636          }
1637       } else {                        /* Got data */
1638          dev->state &= ~ST_EOF;
1639          blocks++;
1640          tot_blocks++;
1641          bytes += stat;
1642       }
1643    }
1644    update_pos_dev(dev);
1645    tot_files = dev->file - tot_files;
1646    printf(_("Total files=%d, blocks=%d, bytes = %s\n"), tot_files, tot_blocks,
1647       edit_uint64_with_commas(bytes, ec1));
1648 }
1649
1650
1651 /*
1652  * Scan tape by reading Bacula block by block. Report what is
1653  * on the tape.  This function reads Bacula blocks, so if your
1654  * Device resource is correctly defined, it should work with
1655  * either variable or fixed block sizes.
1656  */
1657 static void scan_blocks()
1658 {
1659    int blocks, tot_blocks, tot_files;
1660    uint32_t block_size;
1661    uint64_t bytes;
1662    DEV_BLOCK *block = dcr->block;
1663    char ec1[50];
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", strerror_dev(dev));
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"), strerror_dev(dev));
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(rec->FileIndex), rec->VolSessionId, rec->VolSessionTime,
1739               stream_to_ascii(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), strerror_dev(dev));
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    int fd;
1776    uint32_t i;
1777    uint32_t min_block_size;
1778
1779    ok = true;
1780    stop = 0;
1781    vol_num = 0;
1782    last_file = 0;
1783    last_block_num = 0;
1784    BlockNumber = 0;
1785
1786    Pmsg0(-1, _("\n"
1787 "This command simulates Bacula writing to a tape.\n"
1788 "It requires either one or two blank tapes, which it\n"
1789 "will label and write.\n\n"
1790 "If you have an autochanger configured, it will use\n"
1791 "the tapes that are in slots 1 and 2, otherwise, you will\n"
1792 "be prompted to insert the tapes when necessary.\n\n"
1793 "It will print a status approximately\n"
1794 "every 322 MB, and write an EOF every 3.2 GB.  If you have\n"
1795 "selected the simple test option, after writing the first tape\n"
1796 "it will rewind it and re-read the last block written.\n\n"
1797 "If you have selected the multiple tape test, when the first tape\n"
1798 "fills, it will ask for a second, and after writing a few more \n"
1799 "blocks, it will stop.  Then it will begin re-reading the\n"
1800 "two tapes.\n\n"
1801 "This may take a long time -- hours! ...\n\n"));
1802
1803    get_cmd(_("Do you want to run the simplified test (s) with one tape\n"
1804            "or the complete multiple tape (m) test: (s/m) "));
1805    if (cmd[0] == 's') {
1806       Pmsg0(-1, _("Simple test (single tape) selected.\n"));
1807       simple = true;
1808    } else if (cmd[0] == 'm') {
1809       Pmsg0(-1, _("Multiple tape test selected.\n"));
1810       simple = false;
1811    } else {
1812       Pmsg0(000, _("Command aborted.\n"));
1813       return;
1814    }
1815
1816    Dmsg1(20, "Begin append device=%s\n", dev->print_name());
1817    Dmsg1(20, "MaxVolSize=%s\n", edit_uint64(dev->max_volume_size, ec1));
1818
1819    /* Use fixed block size to simplify read back */
1820    min_block_size = dev->min_block_size;
1821    dev->min_block_size = dev->max_block_size;
1822    set_volume_name("TestVolume1", 1);
1823
1824    if (!dev->rewind()) {
1825       Pmsg0(000, _("Rewind failed.\n"));
1826    }
1827    if (!dev->weof()) {
1828       Pmsg0(000, _("Write EOF failed.\n"));
1829    }
1830    labelcmd();
1831    dev->set_append();                 /* force volume to be relabeled */
1832
1833    /*
1834     * Acquire output device for writing.  Note, after acquiring a
1835     *   device, we MUST release it, which is done at the end of this
1836     *   subroutine.
1837     */
1838    Dmsg0(100, "just before acquire_device\n");
1839    if (!acquire_device_for_append(dcr)) {
1840       set_jcr_job_status(jcr, JS_ErrorTerminated);
1841       return;
1842    }
1843    block = jcr->dcr->block;
1844
1845    Dmsg0(100, "Just after acquire_device_for_append\n");
1846    /*
1847     * Write Begin Session Record
1848     */
1849    if (!write_session_label(dcr, SOS_LABEL)) {
1850       set_jcr_job_status(jcr, JS_ErrorTerminated);
1851       Jmsg1(jcr, M_FATAL, 0, _("Write session label failed. ERR=%s\n"),
1852          strerror_dev(dev));
1853       ok = false;
1854    }
1855    Pmsg0(-1, _("Wrote Start of Session label.\n"));
1856
1857    memset(&rec, 0, sizeof(rec));
1858    rec.data = get_memory(100000);     /* max record size */
1859
1860 #define REC_SIZE 32768
1861    rec.data_len = REC_SIZE;
1862
1863    /*
1864     * Put some random data in the record
1865     */
1866    fd = open("/dev/urandom", O_RDONLY);
1867    if (fd) {
1868       read(fd, rec.data, rec.data_len);
1869       close(fd);
1870    } else {
1871       uint32_t *p = (uint32_t *)rec.data;
1872       srandom(time(NULL));
1873       for (i=0; i<rec.data_len/sizeof(uint32_t); i++) {
1874          p[i] = random();
1875       }
1876    }
1877
1878    /*
1879     * Generate data as if from File daemon, write to device
1880     */
1881    jcr->dcr->VolFirstIndex = 0;
1882    time(&jcr->run_time);              /* start counting time for rates */
1883    if (simple) {
1884       Pmsg0(-1, _("Begin writing Bacula records to tape ...\n"));
1885    } else {
1886       Pmsg0(-1, _("Begin writing Bacula records to first tape ...\n"));
1887    }
1888    for (file_index = 0; ok && !job_canceled(jcr); ) {
1889       rec.VolSessionId = jcr->VolSessionId;
1890       rec.VolSessionTime = jcr->VolSessionTime;
1891       rec.FileIndex = ++file_index;
1892       rec.Stream = STREAM_FILE_DATA;
1893
1894       /* Mix up the data just a bit */
1895       uint32_t *lp = (uint32_t *)rec.data;
1896       lp[0] += lp[13];
1897       for (i=1; i < (rec.data_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
1898          lp[i] += lp[i-1];
1899       }
1900
1901       Dmsg4(250, "before write_rec FI=%d SessId=%d Strm=%s len=%d\n",
1902          rec.FileIndex, rec.VolSessionId, stream_to_ascii(rec.Stream, rec.FileIndex),
1903          rec.data_len);
1904
1905       while (!write_record_to_block(block, &rec)) {
1906          /*
1907           * When we get here we have just filled a block
1908           */
1909          Dmsg2(150, "!write_record_to_block data_len=%d rem=%d\n", rec.data_len,
1910                     rec.remainder);
1911
1912          /* Write block to tape */
1913          if (!flush_block(block, 1)) {
1914             break;
1915          }
1916
1917          /* Every 5000 blocks (approx 322MB) report where we are.
1918           */
1919          if ((block->BlockNumber % 5000) == 0) {
1920             now = time(NULL);
1921             now -= jcr->run_time;
1922             if (now <= 0) {
1923                now = 1;          /* prevent divide error */
1924             }
1925             kbs = (double)dev->VolCatInfo.VolCatBytes / (1000.0 * (double)now);
1926             Pmsg4(-1, _("Wrote blk_block=%u, dev_blk_num=%u VolBytes=%s rate=%.1f KB/s\n"),
1927                block->BlockNumber, dev->block_num,
1928                edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), (float)kbs);
1929          }
1930          /* Every 15000 blocks (approx 1GB) write an EOF.
1931           */
1932          if ((block->BlockNumber % 15000) == 0) {
1933             Pmsg0(-1, _("Flush block, write EOF\n"));
1934             flush_block(block, 0);
1935             weof_dev(dev, 1);
1936          }
1937
1938          /* Get out after writing 10 blocks to the second tape */
1939          if (++BlockNumber > 10 && stop != 0) {      /* get out */
1940             break;
1941          }
1942       }
1943       if (!ok) {
1944          Pmsg0(000, _("Not OK\n"));
1945          break;
1946       }
1947       jcr->JobBytes += rec.data_len;   /* increment bytes this job */
1948       Dmsg4(190, "write_record FI=%s SessId=%d Strm=%s len=%d\n",
1949          FI_to_ascii(rec.FileIndex), rec.VolSessionId,
1950          stream_to_ascii(rec.Stream, rec.FileIndex), rec.data_len);
1951
1952       /* Get out after writing 10 blocks to the second tape */
1953       if (BlockNumber > 10 && stop != 0) {      /* get out */
1954          Pmsg0(-1, "Done writing ...\n");
1955          break;
1956       }
1957    }
1958    if (vol_num > 1) {
1959       Dmsg0(100, "Write_end_session_label()\n");
1960       /* Create Job status for end of session label */
1961       if (!job_canceled(jcr) && ok) {
1962          set_jcr_job_status(jcr, JS_Terminated);
1963       } else if (!ok) {
1964          set_jcr_job_status(jcr, JS_ErrorTerminated);
1965       }
1966       if (!write_session_label(dcr, EOS_LABEL)) {
1967          Pmsg1(000, _("Error writting end session label. ERR=%s\n"), strerror_dev(dev));
1968          ok = false;
1969       }
1970       /* Write out final block of this session */
1971       if (!write_block_to_device(dcr)) {
1972          Pmsg0(-1, _("Set ok=false after write_block_to_device.\n"));
1973          ok = false;
1974       }
1975       Pmsg0(-1, _("Wrote End of Session label.\n"));
1976
1977       /* Save last block info for second tape */
1978       last_block_num2 = last_block_num;
1979       last_file2 = last_file;
1980       if (last_block2) {
1981          free_block(last_block2);
1982       }
1983       last_block2 = dup_block(last_block);
1984    }
1985
1986    sprintf(buf, "%s/btape.state", working_directory);
1987    fd = open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0640);
1988    if (fd >= 0) {
1989       write(fd, &btape_state_level, sizeof(btape_state_level));
1990       write(fd, &simple, sizeof(simple));
1991       write(fd, &last_block_num1, sizeof(last_block_num1));
1992       write(fd, &last_block_num2, sizeof(last_block_num2));
1993       write(fd, &last_file1, sizeof(last_file1));
1994       write(fd, &last_file2, sizeof(last_file2));
1995       write(fd, last_block1->buf, last_block1->buf_len);
1996       write(fd, last_block2->buf, last_block2->buf_len);
1997       write(fd, first_block->buf, first_block->buf_len);
1998       close(fd);
1999       Pmsg2(-1, _("Wrote state file last_block_num1=%d last_block_num2=%d\n"),
2000          last_block_num1, last_block_num2);
2001    } else {
2002       berrno be;
2003       Pmsg2(-1, _("Could not create state file: %s ERR=%s\n"), buf,
2004                  be.strerror());
2005    }
2006
2007    if (simple) {
2008       Pmsg2(-1, _("\n\nDone filling tape at %d:%d. Now beginning re-read of tape ...\n"),
2009          jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2010    }
2011    else {
2012       Pmsg2(-1, _("\n\nDone filling tapes at %d:%d. Now beginning re-read of first tape ...\n"),
2013          jcr->dcr->dev->file, jcr->dcr->dev->block_num);
2014    }
2015
2016    jcr->dcr->block = block;
2017    do_unfill();
2018
2019    dev->min_block_size = min_block_size;
2020    free_memory(rec.data);
2021 }
2022
2023 /*
2024  * Read two tapes written by the "fill" command and ensure
2025  *  that the data is valid.  If stop==1 we simulate full read back
2026  *  of two tapes.  If stop==-1 we simply read the last block and
2027  *  verify that it is correct.
2028  */
2029 static void unfillcmd()
2030 {
2031    int fd;
2032
2033    last_block1 = new_block(dev);
2034    last_block2 = new_block(dev);
2035    first_block = new_block(dev);
2036    sprintf(buf, "%s/btape.state", working_directory);
2037    fd = open(buf, O_RDONLY);
2038    if (fd >= 0) {
2039       uint32_t state_level;
2040       read(fd, &state_level, sizeof(btape_state_level));
2041       read(fd, &simple, sizeof(simple));
2042       read(fd, &last_block_num1, sizeof(last_block_num1));
2043       read(fd, &last_block_num2, sizeof(last_block_num2));
2044       read(fd, &last_file1, sizeof(last_file1));
2045       read(fd, &last_file2, sizeof(last_file2));
2046       read(fd, last_block1->buf, last_block1->buf_len);
2047       read(fd, last_block2->buf, last_block2->buf_len);
2048       read(fd, first_block->buf, first_block->buf_len);
2049       close(fd);
2050       if (state_level != btape_state_level) {
2051           Pmsg0(-1, _("\nThe state file level has changed. You must redo\n"
2052                   "the fill command.\n"));
2053           return;
2054        }
2055    } else {
2056       berrno be;
2057       Pmsg2(-1, _("\nCould not find the state file: %s ERR=%s\n"
2058              "You must redo the fill command.\n"), buf, be.strerror());
2059       return;
2060    }
2061    do_unfill();
2062    this_block = NULL;
2063 }
2064
2065 static void do_unfill()
2066 {
2067    DEV_BLOCK *block = dcr->block;
2068    bool autochanger;
2069
2070    dumped = 0;
2071    VolBytes = 0;
2072    LastBlock = 0;
2073
2074    Dmsg0(20, "Enter do_unfill\n");
2075    dev->capabilities |= CAP_ANONVOLS; /* allow reading any volume */
2076    dev->capabilities &= ~CAP_LABEL;   /* don't label anything here */
2077
2078    end_of_tape = 0;
2079
2080    time(&jcr->run_time);              /* start counting time for rates */
2081    stop = 0;
2082    file_index = 0;
2083    if (last_block) {
2084       free_block(last_block);
2085    }
2086    last_block_num = last_block_num1;
2087    last_file = last_file1;
2088    last_block = last_block1;
2089
2090    if (!simple) {
2091       /* Multiple Volume tape */
2092       /* Close device so user can use autochanger if desired */
2093       if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2094          offline_dev(dev);
2095       }
2096       autochanger = autoload_device(dcr, 1, NULL);
2097       if (!autochanger) {
2098          force_close_device(dev);
2099          get_cmd(_("Mount first tape. Press enter when ready: "));
2100       }
2101       free_restore_volume_list(jcr);
2102       jcr->dcr = new_dcr(jcr, dev);
2103       set_volume_name("TestVolume1", 1);
2104       jcr->bsr = NULL;
2105       create_restore_volume_list(jcr);
2106       close_device(dev);
2107       dev->state &= ~(ST_READ|ST_APPEND);
2108       dev->num_writers = 0;
2109       if (!acquire_device_for_read(dcr)) {
2110          Pmsg1(-1, "%s", dev->errmsg);
2111          goto bail_out;
2112       }
2113    }
2114    /*
2115     * We now have the first tape mounted.
2116     * Note, re-reading last block may have caused us to
2117     *   loose track of where we are (block number unknown).
2118     */
2119    if (!rewind_dev(dev)) {                /* get to a known place on tape */
2120       goto bail_out;
2121    }
2122    /* Read the first 10000 records */
2123    Pmsg0(-1, _("Reading the first 10000 records.\n"));
2124    quickie_count = 0;
2125    read_records(dcr, quickie_cb, my_mount_next_read_volume);
2126    Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2127          last_file, last_block_num);
2128    if (!reposition_dev(dev, last_file, last_block_num)) {
2129       Pmsg1(-1, _("Reposition error. ERR=%s\n"), strerror_dev(dev));
2130       goto bail_out;
2131    }
2132    Pmsg1(-1, _("Reading block %u.\n"), last_block_num);
2133    if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2134       Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2135       goto bail_out;
2136    }
2137    if (compare_blocks(last_block, block)) {
2138       if (simple) {
2139          Pmsg0(-1, _("\nThe last block on the tape matches. Test succeeded.\n\n"));
2140       } else {
2141          Pmsg0(-1, _("\nThe last block of the first tape matches.\n\n"));
2142       }
2143    }
2144    if (simple) {
2145       goto bail_out;
2146    }
2147
2148    /* restore info for last block on second Volume */
2149    last_block_num = last_block_num2;
2150    last_file = last_file2;
2151    last_block = last_block2;
2152
2153    /* Multiple Volume tape */
2154    /* Close device so user can use autochanger if desired */
2155    if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2156       offline_dev(dev);
2157    }
2158
2159    free_restore_volume_list(jcr);
2160    set_volume_name("TestVolume2", 2);
2161    jcr->bsr = NULL;
2162    create_restore_volume_list(jcr);
2163    autochanger = autoload_device(dcr, 1, NULL);
2164    if (!autochanger) {
2165       force_close_device(dev);
2166       get_cmd(_("Mount second tape. Press enter when ready: "));
2167    }
2168
2169    dev->clear_read();
2170    if (!acquire_device_for_read(dcr)) {
2171       Pmsg1(-1, "%s", dev->errmsg);
2172       goto bail_out;
2173    }
2174
2175    /* Space to "first" block which is last block not written
2176     * on the previous tape.
2177     */
2178    Pmsg2(-1, _("Reposition from %u:%u to 0:1\n"), dev->file, dev->block_num);
2179    if (!reposition_dev(dev, 0, 1)) {
2180       Pmsg1(-1, _("Reposition error. ERR=%s\n"), strerror_dev(dev));
2181       goto bail_out;
2182    }
2183    Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2184    if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2185       Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2186       goto bail_out;
2187    }
2188    if (compare_blocks(first_block, block)) {
2189       Pmsg0(-1, _("\nThe first block on the second tape matches.\n\n"));
2190    }
2191
2192    /* Now find and compare the last block */
2193    Pmsg4(-1, _("Reposition from %u:%u to %u:%u\n"), dev->file, dev->block_num,
2194          last_file, last_block_num);
2195    if (!reposition_dev(dev, last_file, last_block_num)) {
2196       Pmsg1(-1, _("Reposition error. ERR=%s\n"), strerror_dev(dev));
2197       goto bail_out;
2198    }
2199    Pmsg1(-1, _("Reading block %d.\n"), dev->block_num);
2200    if (!read_block_from_device(dcr, NO_BLOCK_NUMBER_CHECK)) {
2201       Pmsg1(-1, _("Error reading block: ERR=%s\n"), strerror_dev(dev));
2202       goto bail_out;
2203    }
2204    if (compare_blocks(last_block, block)) {
2205       Pmsg0(-1, _("\nThe last block on the second tape matches. Test succeeded.\n\n"));
2206    }
2207
2208 bail_out:
2209    free_block(last_block1);
2210    free_block(last_block2);
2211    free_block(first_block);
2212 }
2213
2214 /* Read 10000 records then stop */
2215 static bool quickie_cb(DCR *dcr, DEV_RECORD *rec)
2216 {
2217    DEVICE *dev = dcr->dev;
2218    if (dev->file != 0) {
2219       Pmsg3(-1, _("ERROR! device at %d:%d count=%d\n"), dev->file, dev->block_num,
2220          quickie_count);
2221       return false;
2222    }
2223    quickie_count++;
2224    if (quickie_count == 10000) {
2225       Pmsg2(-1, _("1000 records read now at %d:%d\n"), dev->file, dev->block_num);
2226    }
2227    return quickie_count < 10000;
2228 }
2229
2230 static bool compare_blocks(DEV_BLOCK *last_block, DEV_BLOCK *block)
2231 {
2232    char *p, *q;
2233    uint32_t CheckSum, block_len;
2234    ser_declare;
2235
2236    p = last_block->buf;
2237    q = block->buf;
2238    unser_begin(q, BLKHDR2_LENGTH);
2239    unser_uint32(CheckSum);
2240    unser_uint32(block_len);
2241    while (q < (block->buf+block_len)) {
2242       if (*p == *q) {
2243          p++;
2244          q++;
2245          continue;
2246       }
2247       Pmsg0(-1, "\n");
2248       dump_block(last_block, _("Last block written"));
2249       Pmsg0(-1, "\n");
2250       dump_block(block, _("Block read back"));
2251       Pmsg1(-1, _("\n\nThe blocks differ at byte %u\n"), p - last_block->buf);
2252       Pmsg0(-1, _("\n\n!!!! The last block written and the block\n"
2253                 "that was read back differ. The test FAILED !!!!\n"
2254                 "This must be corrected before you use Bacula\n"
2255                 "to write multi-tape Volumes.!!!!\n"));
2256       return false;
2257    }
2258    if (verbose) {
2259       dump_block(last_block, _("Last block written"));
2260       dump_block(block, _("Block read back"));
2261    }
2262    return true;
2263 }
2264
2265
2266
2267
2268
2269 /*
2270  * Write current block to tape regardless of whether or
2271  *   not it is full. If the tape fills, attempt to
2272  *   acquire another tape.
2273  */
2274 static int flush_block(DEV_BLOCK *block, int dump)
2275 {
2276    char ec1[50];
2277    DEV_BLOCK *tblock;
2278    uint32_t this_file, this_block_num;
2279
2280    lock_device(dev);
2281    if (!this_block) {
2282       this_block = new_block(dev);
2283    }
2284    if (!last_block) {
2285       last_block = new_block(dev);
2286    }
2287    /* Copy block */
2288    this_file = dev->file;
2289    this_block_num = dev->block_num;
2290    if (!write_block_to_dev(dcr)) {
2291       Pmsg3(000, _("Last block at: %u:%u this_dev_block_num=%d\n"),
2292                   last_file, last_block_num, this_block_num);
2293       if (vol_num == 1) {
2294          /*
2295           * This is 1st tape, so save first tape info separate
2296           *  from second tape info
2297           */
2298          last_block_num1 = last_block_num;
2299          last_file1 = last_file;
2300          last_block1 = dup_block(last_block);
2301          last_block2 = dup_block(last_block);
2302          first_block = dup_block(block); /* first block second tape */
2303       }
2304       if (verbose) {
2305          Pmsg3(000, _("Block not written: FileIndex=%u blk_block=%u Size=%u\n"),
2306             (unsigned)file_index, block->BlockNumber, block->block_len);
2307          dump_block(last_block, _("Last block written"));
2308          Pmsg0(-1, "\n");
2309          dump_block(block, _("Block not written"));
2310       }
2311       if (stop == 0) {
2312          eot_block = block->BlockNumber;
2313          eot_block_len = block->block_len;
2314          eot_FileIndex = file_index;
2315          stop = 1;
2316       }
2317       now = time(NULL);
2318       now -= jcr->run_time;
2319       if (now <= 0) {
2320          now = 1;                     /* don't divide by zero */
2321       }
2322       kbs = (double)dev->VolCatInfo.VolCatBytes / (1000 * now);
2323       vol_size = dev->VolCatInfo.VolCatBytes;
2324       Pmsg4(000, _("End of tape %d:%d. VolumeCapacity=%s. Write rate = %.1f KB/s\n"),
2325          dev->file, dev->block_num,
2326          edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, ec1), kbs);
2327
2328       if (simple) {
2329          stop = -1;                   /* stop, but do simplified test */
2330       } else {
2331          /* Full test in progress */
2332          if (!fixup_device_block_write_error(jcr->dcr)) {
2333             Pmsg1(000, _("Cannot fixup device error. %s\n"), strerror_dev(dev));
2334             ok = false;
2335             unlock_device(dev);
2336             return 0;
2337          }
2338          BlockNumber = 0;             /* start counting for second tape */
2339       }
2340       unlock_device(dev);
2341       return 1;                       /* end of tape reached */
2342    }
2343
2344    /* Save contents after write so that the header is serialized */
2345    memcpy(this_block->buf, block->buf, this_block->buf_len);
2346
2347    /*
2348     * Note, we always read/write to block, but we toggle
2349     *  copying it to one or another of two allocated blocks.
2350     * Switch blocks so that the block just successfully written is
2351     *  always in last_block.
2352     */
2353    tblock = last_block;
2354    last_block = this_block;
2355    this_block = tblock;
2356    last_file = this_file;
2357    last_block_num = this_block_num;
2358
2359    unlock_device(dev);
2360    return 1;
2361 }
2362
2363
2364 /*
2365  * First we label the tape, then we fill
2366  *  it with data get a new tape and write a few blocks.
2367  */
2368 static void qfillcmd()
2369 {
2370    DEV_BLOCK *block = dcr->block;
2371    DEV_RECORD *rec = dcr->rec;
2372    int i, count;
2373
2374    Pmsg0(0, _("Test writing blocks of 64512 bytes to tape.\n"));
2375
2376    get_cmd(_("How many blocks do you want to write? (1000): "));
2377
2378    count = atoi(cmd);
2379    if (count <= 0) {
2380       count = 1000;
2381    }
2382
2383    sm_check(__FILE__, __LINE__, false);
2384
2385    i = block->buf_len - 100;
2386    ASSERT (i > 0);
2387    rec->data = check_pool_memory_size(rec->data, i);
2388    memset(rec->data, i & 0xFF, i);
2389    rec->data_len = i;
2390    rewindcmd();
2391    Pmsg1(0, _("Begin writing %d Bacula blocks to tape ...\n"), count);
2392    for (i=0; i < count; i++) {
2393       if (i % 100 == 0) {
2394          printf("+");
2395          fflush(stdout);
2396       }
2397       if (!write_record_to_block(block, rec)) {
2398          Pmsg0(0, _("Error writing record to block.\n"));
2399          goto bail_out;
2400       }
2401       if (!write_block_to_dev(dcr)) {
2402          Pmsg0(0, _("Error writing block to device.\n"));
2403          goto bail_out;
2404       }
2405    }
2406    printf("\n");
2407    weofcmd();
2408    if (dev_cap(dev, CAP_TWOEOF)) {
2409       weofcmd();
2410    }
2411    rewindcmd();
2412    scan_blocks();
2413
2414 bail_out:
2415    sm_check(__FILE__, __LINE__, false);
2416 }
2417
2418 /*
2419  * Fill a tape using raw write() command
2420  */
2421 static void rawfill_cmd()
2422 {
2423    DEV_BLOCK *block = dcr->block;
2424    int stat;
2425    int fd;
2426    uint32_t block_num = 0;
2427    uint32_t *p;
2428    int my_errno;
2429    uint32_t i;
2430
2431    fd = open("/dev/urandom", O_RDONLY);
2432    if (fd) {
2433       read(fd, block->buf, block->buf_len);
2434       close(fd);
2435    } else {
2436       uint32_t *p = (uint32_t *)block->buf;
2437       srandom(time(NULL));
2438       for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2439          p[i] = random();
2440       }
2441    }
2442    p = (uint32_t *)block->buf;
2443    Pmsg1(0, _("Begin writing raw blocks of %u bytes.\n"), block->buf_len);
2444    for ( ;; ) {
2445       *p = block_num;
2446       stat = write(dev->fd, block->buf, block->buf_len);
2447       if (stat == (int)block->buf_len) {
2448          if ((block_num++ % 100) == 0) {
2449             printf("+");
2450             fflush(stdout);
2451          }
2452          p[0] += p[13];
2453          for (i=1; i<(block->buf_len-sizeof(uint32_t))/sizeof(uint32_t)-1; i++) {
2454             p[i] += p[i-1];
2455          }
2456          continue;
2457       }
2458       break;
2459    }
2460    my_errno = errno;
2461    printf("\n");
2462    berrno be;
2463    printf(_("Write failed at block %u. stat=%d ERR=%s\n"), block_num, stat,
2464       be.strerror(my_errno));
2465    weofcmd();
2466 }
2467
2468
2469 /*
2470  * Fill a tape using Bacula block writes
2471  */
2472 static void bfill_cmd()
2473 {
2474    DEV_BLOCK *block = dcr->block;
2475    uint32_t block_num = 0;
2476    uint32_t *p;
2477    int my_errno;
2478    int fd;
2479    uint32_t i;
2480
2481    fd = open("/dev/urandom", O_RDONLY);
2482    if (fd) {
2483       read(fd, block->buf, block->buf_len);
2484       close(fd);
2485    } else {
2486       uint32_t *p = (uint32_t *)block->buf;
2487       srandom(time(NULL));
2488       for (i=0; i<block->buf_len/sizeof(uint32_t); i++) {
2489          p[i] = random();
2490       }
2491    }
2492    p = (uint32_t *)block->buf;
2493    Pmsg1(0, _("Begin writing Bacula blocks of %u bytes.\n"), block->buf_len);
2494    for ( ;; ) {
2495       *p = block_num;
2496       block->binbuf = block->buf_len;
2497       block->bufp = block->buf + block->binbuf;
2498       if (!write_block_to_dev(dcr)) {
2499          break;
2500       }
2501       if ((block_num++ % 100) == 0) {
2502          printf("+");
2503          fflush(stdout);
2504       }
2505       p[0] += p[13];
2506       for (i=1; i<(block->buf_len/sizeof(uint32_t)-1); i++) {
2507          p[i] += p[i-1];
2508       }
2509    }
2510    my_errno = errno;
2511    printf("\n");
2512    printf(_("Write failed at block %u.\n"), block_num);
2513    weofcmd();
2514 }
2515
2516
2517 struct cmdstruct { const char *key; void (*func)(); const char *help; };
2518 static struct cmdstruct commands[] = {
2519  {N_("autochanger"),autochangercmd, _("test autochanger")},
2520  {N_("bsf"),       bsfcmd,       _("backspace file")},
2521  {N_("bsr"),       bsrcmd,       _("backspace record")},
2522  {N_("bfill"),     bfill_cmd,    _("fill tape using Bacula writes")},
2523  {N_("cap"),       capcmd,       _("list device capabilities")},
2524  {N_("clear"),     clearcmd,     _("clear tape errors")},
2525  {N_("eod"),       eodcmd,       _("go to end of Bacula data for append")},
2526  {N_("eom"),       eomcmd,       _("go to the physical end of medium")},
2527  {N_("fill"),      fillcmd,      _("fill tape, write onto second volume")},
2528  {N_("unfill"),    unfillcmd,    _("read filled tape")},
2529  {N_("fsf"),       fsfcmd,       _("forward space a file")},
2530  {N_("fsr"),       fsrcmd,       _("forward space a record")},
2531  {N_("help"),      helpcmd,      _("print this command")},
2532  {N_("label"),     labelcmd,     _("write a Bacula label to the tape")},
2533  {N_("load"),      loadcmd,      _("load a tape")},
2534  {N_("quit"),      quitcmd,      _("quit btape")},
2535  {N_("rawfill"),   rawfill_cmd,  _("use write() to fill tape")},
2536  {N_("readlabel"), readlabelcmd, _("read and print the Bacula tape label")},
2537  {N_("rectest"),   rectestcmd,   _("test record handling functions")},
2538  {N_("rewind"),    rewindcmd,    _("rewind the tape")},
2539  {N_("scan"),      scancmd,      _("read() tape block by block to EOT and report")},
2540  {N_("scanblocks"),scan_blocks,  _("Bacula read block by block to EOT and report")},
2541  {N_("status"),    statcmd,      _("print tape status")},
2542  {N_("test"),      testcmd,      _("General test Bacula tape functions")},
2543  {N_("weof"),      weofcmd,      _("write an EOF on the tape")},
2544  {N_("wr"),        wrcmd,        _("write a single Bacula block")},
2545  {N_("rr"),        rrcmd,        _("read a single record")},
2546  {N_("qfill"),     qfillcmd,     _("quick fill command")}
2547              };
2548 #define comsize (sizeof(commands)/sizeof(struct cmdstruct))
2549
2550 static void
2551 do_tape_cmds()
2552 {
2553    unsigned int i;
2554    bool found;
2555
2556    while (get_cmd("*")) {
2557       sm_check(__FILE__, __LINE__, false);
2558       found = false;
2559       parse_args(cmd, &args, &argc, argk, argv, MAX_CMD_ARGS);
2560       for (i=0; i<comsize; i++)       /* search for command */
2561          if (argc > 0 && fstrsch(argk[0],  commands[i].key)) {
2562             (*commands[i].func)();    /* go execute command */
2563             found = true;
2564             break;
2565          }
2566       if (!found)
2567          Pmsg1(0, _("%s is an illegal command\n"), cmd);
2568       if (quit)
2569          break;
2570    }
2571 }
2572
2573 static void helpcmd()
2574 {
2575    unsigned int i;
2576    usage();
2577    printf(_("Interactive commands:\n"));
2578    printf(_("  Command    Description\n  =======    ===========\n"));
2579    for (i=0; i<comsize; i++)
2580       printf("  %-10s %s\n", commands[i].key, commands[i].help);
2581    printf("\n");
2582 }
2583
2584 static void usage()
2585 {
2586    fprintf(stderr, _(
2587 "Copyright (C) 2000-2005 Kern Sibbald.\n"
2588 "\nVersion: %s (%s)\n\n"
2589 "Usage: btape <options> <device_name>\n"
2590 "       -b <file>   specify bootstrap file\n"
2591 "       -c <file>   set configuration file to file\n"
2592 "       -d <nn>     set debug level to nn\n"
2593 "       -p          proceed inspite of I/O errors\n"
2594 "       -s          turn off signals\n"
2595 "       -v          be verbose\n"
2596 "       -?          print this message.\n"
2597 "\n"), VERSION, BDATE);
2598
2599 }
2600
2601 /*
2602  * Get next input command from terminal.  This
2603  * routine is REALLY primitive, and should be enhanced
2604  * to have correct backspacing, etc.
2605  */
2606 int
2607 get_cmd(const char *prompt)
2608 {
2609    int i = 0;
2610    int ch;
2611    fprintf(stdout, prompt);
2612
2613    /* We really should turn off echoing and pretty this
2614     * up a bit.
2615     */
2616    cmd[i] = 0;
2617    while ((ch = fgetc(stdin)) != EOF) {
2618       if (ch == '\n') {
2619          strip_trailing_junk(cmd);
2620          return 1;
2621       } else if (ch == 4 || ch == 0xd3 || ch == 0x8) {
2622          if (i > 0)
2623             cmd[--i] = 0;
2624          continue;
2625       }
2626
2627       cmd[i++] = ch;
2628       cmd[i] = 0;
2629    }
2630    quit = 1;
2631    return 0;
2632 }
2633
2634 /* Dummies to replace askdir.c */
2635 bool    dir_update_file_attributes(DCR *dcr, DEV_RECORD *rec) { return 1;}
2636 bool    dir_send_job_status(JCR *jcr) {return 1;}
2637
2638 bool dir_update_volume_info(DCR *dcr, bool relabel)
2639 {
2640    return 1;
2641 }
2642
2643
2644 bool dir_get_volume_info(DCR *dcr, enum get_vol_info_rw  writing)
2645 {
2646    Dmsg0(20, "Enter dir_get_volume_info\n");
2647    bstrncpy(dcr->VolCatInfo.VolCatName, dcr->VolumeName, sizeof(dcr->VolCatInfo.VolCatName));
2648    return 1;
2649 }
2650
2651 bool dir_create_jobmedia_record(DCR *dcr)
2652 {
2653    dcr->WroteVol = false;
2654    return 1;
2655 }
2656
2657
2658 bool dir_find_next_appendable_volume(DCR *dcr)
2659 {
2660    Dmsg1(20, "Enter dir_find_next_appendable_volume. stop=%d\n", stop);
2661    return dcr->VolumeName[0] != 0;
2662 }
2663
2664 bool dir_ask_sysop_to_mount_volume(DCR *dcr)
2665 {
2666    DEVICE *dev = dcr->dev;
2667    Dmsg0(20, "Enter dir_ask_sysop_to_mount_volume\n");
2668    if (dcr->VolumeName[0] == 0) {
2669       return dir_ask_sysop_to_create_appendable_volume(dcr);
2670    }
2671    /* Close device so user can use autochanger if desired */
2672    if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2673       offline_dev(dev);
2674    }
2675    force_close_device(dev);
2676    Pmsg1(-1, "%s", dev->errmsg);           /* print reason */
2677    if (dcr->VolumeName[0] == 0 || strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2678       fprintf(stderr, _("Mount second Volume on device %s and press return when ready: "),
2679          dev->print_name());
2680    } else {
2681       fprintf(stderr, _("Mount Volume \"%s\" on device %s and press return when ready: "),
2682          dcr->VolumeName, dev->print_name());
2683    }
2684    getchar();
2685    return true;
2686 }
2687
2688 bool dir_ask_sysop_to_create_appendable_volume(DCR *dcr)
2689 {
2690    bool autochanger;
2691    DEVICE *dev = dcr->dev;
2692    Dmsg0(20, "Enter dir_ask_sysop_to_create_appendable_volume\n");
2693    if (stop == 0) {
2694       set_volume_name("TestVolume1", 1);
2695    } else {
2696       set_volume_name("TestVolume2", 2);
2697    }
2698    /* Close device so user can use autochanger if desired */
2699    if (dev_cap(dev, CAP_OFFLINEUNMOUNT)) {
2700       offline_dev(dev);
2701    }
2702    autochanger = autoload_device(dcr, 1, NULL);
2703    if (!autochanger) {
2704       force_close_device(dev);
2705       fprintf(stderr, _("Mount blank Volume on device %s and press return when ready: "),
2706          dev->print_name());
2707       getchar();
2708    }
2709    open_device(dcr);
2710    labelcmd();
2711    VolumeName = NULL;
2712    BlockNumber = 0;
2713    return true;
2714 }
2715
2716 static bool my_mount_next_read_volume(DCR *dcr)
2717 {
2718    char ec1[50];
2719    JCR *jcr = dcr->jcr;
2720    DEV_BLOCK *block = dcr->block;
2721
2722    Dmsg0(20, "Enter my_mount_next_read_volume\n");
2723    Pmsg1(000, _("End of Volume \"%s\"\n"), dcr->VolumeName);
2724
2725    if (LastBlock != block->BlockNumber) {
2726       VolBytes += block->block_len;
2727    }
2728    LastBlock = block->BlockNumber;
2729    now = time(NULL);
2730    now -= jcr->run_time;
2731    if (now <= 0) {
2732       now = 1;
2733    }
2734    kbs = (double)VolBytes / (1000.0 * (double)now);
2735    Pmsg3(-1, _("Read block=%u, VolBytes=%s rate=%.1f KB/s\n"), block->BlockNumber,
2736             edit_uint64_with_commas(VolBytes, ec1), (float)kbs);
2737
2738    if (strcmp(dcr->VolumeName, "TestVolume2") == 0) {
2739       end_of_tape = 1;
2740       return false;
2741    }
2742
2743    free_restore_volume_list(jcr);
2744    set_volume_name("TestVolume2", 2);
2745    jcr->bsr = NULL;
2746    create_restore_volume_list(jcr);
2747    close_device(dev);
2748    dev->clear_read();
2749    if (!acquire_device_for_read(dcr)) {
2750       Pmsg2(0, _("Cannot open Dev=%s, Vol=%s\n"), dev->print_name(), dcr->VolumeName);
2751       return false;
2752    }
2753    return true;                    /* next volume mounted */
2754 }
2755
2756 static void set_volume_name(const char *VolName, int volnum)
2757 {
2758    DCR *dcr = jcr->dcr;
2759    VolumeName = VolName;
2760    vol_num = volnum;
2761    bstrncpy(dev->VolCatInfo.VolCatName, VolName, sizeof(dev->VolCatInfo.VolCatName));
2762    bstrncpy(dcr->VolCatInfo.VolCatName, VolName, sizeof(dcr->VolCatInfo.VolCatName));
2763    bstrncpy(dcr->VolumeName, VolName, sizeof(dcr->VolumeName));
2764    dcr->VolCatInfo.Slot = volnum;
2765 }
2766
2767 VOLRES *new_volume(DCR *dcr, const char *VolumeName) { return NULL; }
2768 bool    free_volume(DEVICE *dev) { return true; }
2769 void    free_unused_volume(DCR *dcr) { }