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