git.gag.com Git - debian/amanda/blob - restore-src/restore.c

   1 /*
   2  * Amanda, The Advanced Maryland Automatic Network Disk Archiver
   3  * Copyright (c) 1991-1998 University of Maryland at College Park
   4  * All Rights Reserved.
   5  *
   6  * Permission to use, copy, modify, distribute, and sell this software and its
   7  * documentation for any purpose is hereby granted without fee, provided that
   8  * the above copyright notice appear in all copies and that both that
   9  * copyright notice and this permission notice appear in supporting
  10  * documentation, and that the name of U.M. not be used in advertising or
  11  * publicity pertaining to distribution of the software without specific,
  12  * written prior permission.  U.M. makes no representations about the
  13  * suitability of this software for any purpose.  It is provided "as is"
  14  * without express or implied warranty.
  15  *
  16  * U.M. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL U.M.
  18  * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  19  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  20  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  21  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  22  *
  23  * Authors: the Amanda Development Team.  Its members are listed in a
  24  * file named AUTHORS, in the root directory of this distribution.
  25  */
  26 /*
  27  * $Id: restore.c,v 1.52.2.2 2006/09/27 14:04:27 martinea Exp $
  28  *
  29  * retrieves files from an amanda tape
  30  */
  31
  32 #include "amanda.h"
  33 #include "tapeio.h"
  34 #include "util.h"
  35 #include "restore.h"
  36 #include "find.h"
  37 #include "changer.h"
  38 #include "logfile.h"
  39 #include "fileheader.h"
  40 #include "arglist.h"
  41 #include <signal.h>
  42
  43 #define LOAD_STOP    -1
  44 #define LOAD_CHANGER -2
  45
  46 int file_number;
  47
  48 /* stuff we're stuck having global */
  49 static size_t blocksize = (size_t)SSIZE_MAX;
  50 static char *cur_tapedev = NULL;
  51 static char *searchlabel = NULL;
  52 static int backwards;
  53 static int exitassemble = 0;
  54 static int tapefd;
  55
  56 char *rst_conf_logdir = NULL;
  57 char *rst_conf_logfile = NULL;
  58 char *curslot = NULL;
  59
  60 typedef struct open_output_s {
  61     struct open_output_s *next;
  62     dumpfile_t *file;
  63     int lastpartnum;
  64     pid_t comp_enc_pid;
  65     int outfd;
  66 } open_output_t;
  67
  68 typedef struct dumplist_s {
  69     struct dumplist_s *next;
  70     dumpfile_t *file;
  71 } dumplist_t;
  72
  73 typedef struct seentapes_s {
  74     struct seentapes_s *next;
  75     char *slotstr;
  76     char *label;
  77     dumplist_t *files;
  78 } seentapes_t;
  79
  80 static open_output_t *open_outputs = NULL;
  81 static dumplist_t *alldumps_list = NULL;
  82
  83 /* local functions */
  84
  85 static ssize_t get_block(int tapefd, char *buffer, int isafile);
  86 static void append_file_to_fd(char *filename, int fd);
  87 static int headers_equal(dumpfile_t *file1, dumpfile_t *file2, int ignore_partnums);
  88 static int already_have_dump(dumpfile_t *file);
  89 static void handle_sigint(int sig);
  90 static int scan_init(void *ud, int rc, int ns, int bk, int s);
  91 int loadlabel_slot(void *ud, int rc, char *slotstr, char *device);
  92 void drain_file(int tapefd, rst_flags_t *flags);
  93 char *label_of_current_slot(char *cur_tapedev, FILE *prompt_out,
  94                             int *tapefd, dumpfile_t *file, rst_flags_t *flags,
  95                             am_feature_t *their_features,
  96                             ssize_t *read_result, tapelist_t *desired_tape);
  97
  98 int load_next_tape(char **cur_tapedev, FILE *prompt_out, int backwards,
  99                    rst_flags_t *flags, am_feature_t *their_features,
 100                    tapelist_t *desired_tape);
 101 int load_manual_tape(char **cur_tapedev, FILE *prompt_out, FILE *prompt_in,
 102                      rst_flags_t *flags, am_feature_t *their_features,
 103                      tapelist_t *desired_tape);
 104 void search_a_tape(char *cur_tapedev, FILE *prompt_out, rst_flags_t *flags,
 105                    am_feature_t *their_features, tapelist_t *desired_tape,
 106                    int isafile, match_list_t *match_list,
 107                    seentapes_t *tape_seen, dumpfile_t *file,
 108                    dumpfile_t *prev_rst_file, dumpfile_t *tapestart,
 109                    int slot_num, ssize_t *read_result);
 110
 111 /*
 112  * We might want to flush any open dumps and unmerged splits before exiting
 113  * on SIGINT, so do so.
 114  */
 115 static void
 116 handle_sigint(
 117     int         sig)
 118 {
 119     (void)sig;  /* Quiet unused parameter warning */
 120
 121     flush_open_outputs(exitassemble, NULL);
 122     if(rst_conf_logfile) unlink(rst_conf_logfile);
 123     exit(0);
 124 }
 125
 126 int
 127 lock_logfile(void)
 128 {
 129     rst_conf_logdir = getconf_str(CNF_LOGDIR);
 130     if (*rst_conf_logdir == '/') {
 131         rst_conf_logdir = stralloc(rst_conf_logdir);
 132     } else {
 133         rst_conf_logdir = stralloc2(config_dir, rst_conf_logdir);
 134     }
 135     rst_conf_logfile = vstralloc(rst_conf_logdir, "/log", NULL);
 136     if (access(rst_conf_logfile, F_OK) == 0) {
 137         dbprintf(("%s exists: amdump or amflush is already running, "
 138                   "or you must run amcleanup\n", rst_conf_logfile));
 139         return 0;
 140     }
 141     log_add(L_INFO, get_pname());
 142     return 1;
 143 }
 144
 145 /*
 146  * Return 1 if the two fileheaders match in name, disk, type, split chunk part
 147  * number, and datestamp, and 0 if not.  The part number can be optionally
 148  * ignored.
 149  */
 150 int
 151 headers_equal(
 152     dumpfile_t *file1,
 153     dumpfile_t *file2,
 154     int         ignore_partnums)
 155 {
 156     if(!file1 || !file2) return(0);
 157
 158     if(file1->dumplevel == file2->dumplevel &&
 159            file1->type == file2->type &&
 160            !strcmp(file1->datestamp, file2->datestamp) &&
 161            !strcmp(file1->name, file2->name) &&
 162            !strcmp(file1->disk, file2->disk) &&
 163            (ignore_partnums || file1->partnum == file2->partnum)){
 164         return(1);
 165     }
 166     return(0);
 167 }
 168
 169
 170 /*
 171  * See whether we're already pulled an exact copy of the given file (chunk
 172  * number and all).  Returns 0 if not, 1 if so.
 173  */
 174 int
 175 already_have_dump(
 176     dumpfile_t *file)
 177 {
 178     dumplist_t *fileentry = NULL;
 179
 180     if(!file) return(0);
 181     for(fileentry=alldumps_list;fileentry;fileentry=fileentry->next){
 182         if(headers_equal(file, fileentry->file, 0)) return(1);
 183     }
 184     return(0);
 185 }
 186
 187 /*
 188  * Open the named file and append its contents to the (hopefully open) file
 189  * descriptor supplies.
 190  */
 191 static void
 192 append_file_to_fd(
 193     char *      filename,
 194     int         fd)
 195 {
 196     ssize_t bytes_read;
 197     ssize_t s;
 198     off_t wc = (off_t)0;
 199     char *buffer;
 200
 201     if(blocksize == SIZE_MAX)
 202         blocksize = DISK_BLOCK_BYTES;
 203     buffer = alloc(blocksize);
 204
 205     if((tapefd = open(filename, O_RDONLY)) == -1) {
 206         error("can't open %s: %s", filename, strerror(errno));
 207         /*NOTREACHED*/
 208     }
 209
 210     for (;;) {
 211         bytes_read = get_block(tapefd, buffer, 1); /* same as isafile = 1 */
 212         if(bytes_read < 0) {
 213             error("read error: %s", strerror(errno));
 214             /*NOTREACHED*/
 215         }
 216
 217         if (bytes_read == 0)
 218                 break;
 219
 220         s = fullwrite(fd, buffer, (size_t)bytes_read);
 221         if (s < bytes_read) {
 222             fprintf(stderr,"Error (%s) offset " OFF_T_FMT "+" OFF_T_FMT ", wrote " OFF_T_FMT "\n",
 223                     strerror(errno), (OFF_T_FMT_TYPE)wc,
 224                     (OFF_T_FMT_TYPE)bytes_read, (OFF_T_FMT_TYPE)s);
 225             if (s < 0) {
 226                 if((errno == EPIPE) || (errno == ECONNRESET)) {
 227                     error("%s: pipe reader has quit in middle of file.",
 228                         get_pname());
 229                     /*NOTREACHED*/
 230                 }
 231                 error("restore: write error = %s", strerror(errno));
 232                 /*NOTREACHED*/
 233             }
 234             error("Short write: wrote %d bytes expected %d.", s, bytes_read);
 235             /*NOTREACHCED*/
 236         }
 237         wc += (off_t)bytes_read;
 238     }
 239
 240     amfree(buffer);
 241     aclose(tapefd);
 242 }
 243
 244 /*
 245  * Tape changer support routines, stolen brazenly from amtape
 246  */
 247 static int
 248 scan_init(
 249      void *     ud,
 250      int        rc,
 251      int        ns,
 252      int        bk,
 253      int        s)
 254 {
 255     (void)ud;   /* Quiet unused parameter warning */
 256     (void)ns;   /* Quiet unused parameter warning */
 257     (void)s;    /* Quiet unused parameter warning */
 258
 259     if(rc) {
 260         error("could not get changer info: %s", changer_resultstr);
 261         /*NOTREACHED*/
 262     }
 263     backwards = bk;
 264
 265     return 0;
 266 }
 267
 268 int
 269 loadlabel_slot(
 270      void *     ud,
 271      int        rc,
 272      char *     slotstr,
 273      char *     device)
 274 {
 275     char *errstr;
 276     char *datestamp = NULL;
 277     char *label = NULL;
 278
 279     (void)ud;   /* Quiet unused parameter warning */
 280
 281     if(rc > 1) {
 282         error("could not load slot %s: %s", slotstr, changer_resultstr);
 283         /*NOTREACHED*/
 284     } else if(rc == 1) {
 285         fprintf(stderr, "%s: slot %s: %s\n",
 286                 get_pname(), slotstr, changer_resultstr);
 287     } else if((errstr = tape_rdlabel(device, &datestamp, &label)) != NULL) {
 288         fprintf(stderr, "%s: slot %s: %s\n", get_pname(), slotstr, errstr);
 289     } else {
 290         if(strlen(datestamp)>8)
 291             fprintf(stderr, "%s: slot %s: date %-14s label %s",
 292                     get_pname(), slotstr, datestamp, label);
 293         else
 294             fprintf(stderr, "%s: slot %s: date %-8s label %s",
 295                     get_pname(), slotstr, datestamp, label);
 296         if(strcmp(label, FAKE_LABEL) != 0
 297            && strcmp(label, searchlabel) != 0)
 298             fprintf(stderr, " (wrong tape)\n");
 299         else {
 300             fprintf(stderr, " (exact label match)\n");
 301             if((errstr = tape_rewind(device)) != NULL) {
 302                 fprintf(stderr,
 303                         "%s: could not rewind %s: %s",
 304                         get_pname(), device, errstr);
 305                 amfree(errstr);
 306             }
 307             amfree(cur_tapedev);
 308             curslot = newstralloc(curslot, slotstr);
 309             amfree(datestamp);
 310             amfree(label);
 311             if(device)
 312                 cur_tapedev = stralloc(device);
 313             return 1;
 314         }
 315     }
 316     amfree(datestamp);
 317     amfree(label);
 318
 319     amfree(cur_tapedev);
 320     curslot = newstralloc(curslot, slotstr);
 321     if(!device) return(1);
 322     cur_tapedev = stralloc(device);
 323
 324     return 0;
 325 }
 326
 327
 328 /* non-local functions follow */
 329
 330
 331
 332 /*
 333  * Check whether we've read all of the preceding parts of a given split dump,
 334  * generally used to see if we're done and can close the thing.
 335  */
 336 int
 337 have_all_parts (
 338     dumpfile_t *file,
 339     int         upto)
 340 {
 341     int c;
 342     int *foundparts = NULL;
 343     dumplist_t *fileentry = NULL;
 344
 345     if(!file || file->partnum < 1) return(0);
 346
 347     if(upto < 1) upto = file->totalparts;
 348
 349     foundparts = alloc(SIZEOF(*foundparts) * upto);
 350     for(c = 0 ; c< upto; c++) foundparts[c] = 0;
 351
 352     for(fileentry=alldumps_list;fileentry; fileentry=fileentry->next){
 353         dumpfile_t *cur_file = fileentry->file;
 354         if(headers_equal(file, cur_file, 1)){
 355             if(cur_file->partnum > upto){
 356                 amfree(foundparts);
 357                 return(0);
 358             }
 359
 360             foundparts[cur_file->partnum - 1] = 1;
 361         }
 362     }
 363
 364     for(c = 0 ; c< upto; c++){
 365         if(!foundparts[c]){
 366             amfree(foundparts);
 367             return(0);
 368         }
 369     }
 370
 371     amfree(foundparts);
 372     return(1);
 373 }
 374
 375 /*
 376  * Free up the open filehandles and memory we were using to track in-progress
 377  * dumpfiles (generally for split ones we're putting back together).  If
 378  * applicable, also find the ones that are continuations of one another and
 379  * string them together.  If given an optional file header argument, flush
 380  * only that dump and do not flush/free any others.
 381  */
 382 void
 383 flush_open_outputs(
 384     int         reassemble,
 385     dumpfile_t *only_file)
 386 {
 387     open_output_t *cur_out = NULL, *prev = NULL;
 388     find_result_t *sorted_files = NULL;
 389     amwait_t compress_status;
 390
 391     if(!only_file){
 392         fprintf(stderr, "\n");
 393     }
 394
 395     /*
 396      * Deal with any split dumps we've been working on, appending pieces
 397      * that haven't yet been appended and closing filehandles we've been
 398      * holding onto.
 399      */
 400     if(reassemble){
 401         find_result_t *cur_find_res = NULL;
 402         int outfd = -1, lastpartnum = -1;
 403         dumpfile_t *main_file = NULL;
 404         cur_out = open_outputs;
 405
 406         /* stick the dumpfile_t's into a list find_result_t's so that we can
 407            abuse existing sort functionality */
 408         for(cur_out=open_outputs; cur_out; cur_out=cur_out->next){
 409             find_result_t *cur_find_res = NULL;
 410             dumpfile_t *cur_file = cur_out->file;
 411             /* if we requested a particular file, do only that one */
 412             if(only_file && !headers_equal(cur_file, only_file, 1)){
 413                 continue;
 414             }
 415             cur_find_res = alloc(SIZEOF(find_result_t));
 416             memset(cur_find_res, '\0', SIZEOF(find_result_t));
 417             cur_find_res->timestamp = stralloc(cur_file->datestamp);
 418             cur_find_res->hostname = stralloc(cur_file->name);
 419             cur_find_res->diskname = stralloc(cur_file->disk);
 420             cur_find_res->level = cur_file->dumplevel;
 421             if(cur_file->partnum < 1) cur_find_res->partnum = stralloc("--");
 422             else{
 423                 char part_str[NUM_STR_SIZE];
 424                 snprintf(part_str, SIZEOF(part_str), "%d", cur_file->partnum);
 425                 cur_find_res->partnum = stralloc(part_str);
 426             }
 427             cur_find_res->user_ptr = (void*)cur_out;
 428
 429             cur_find_res->next = sorted_files;
 430             sorted_files = cur_find_res;
 431         }
 432         sort_find_result("hkdlp", &sorted_files);
 433
 434         /* now we have an in-order list of the files we need to concatenate */
 435         cur_find_res = sorted_files;
 436         for(cur_find_res=sorted_files;
 437                 cur_find_res;
 438                 cur_find_res=cur_find_res->next){
 439             dumpfile_t *cur_file = NULL;
 440             cur_out = (open_output_t*)cur_find_res->user_ptr;
 441             cur_file = cur_out->file;
 442
 443             /* if we requested a particular file, do only that one */
 444             if(only_file && !headers_equal(cur_file, only_file, 1)){
 445                 continue;
 446             }
 447
 448             if(cur_file->type == F_SPLIT_DUMPFILE) {
 449                 /* is it a continuation of one we've been writing? */
 450                 if(main_file && cur_file->partnum > lastpartnum &&
 451                         headers_equal(cur_file, main_file, 1)){
 452                     char *cur_filename;
 453                     char *main_filename;
 454
 455                     /* effectively changing filehandles */
 456                     aclose(cur_out->outfd);
 457                     cur_out->outfd = outfd;
 458
 459                     cur_filename  = make_filename(cur_file);
 460                     main_filename = make_filename(main_file);
 461                     fprintf(stderr, "Merging %s with %s\n",
 462                             cur_filename, main_filename);
 463                     append_file_to_fd(cur_filename, outfd);
 464                     if(unlink(cur_filename) < 0){
 465                         fprintf(stderr, "Failed to unlink %s: %s\n",
 466                                      cur_filename, strerror(errno));
 467                     }
 468                     amfree(cur_filename);
 469                     amfree(main_filename);
 470                 }
 471                 /* or a new file? */
 472                 else {
 473                     if(outfd >= 0) aclose(outfd);
 474                     amfree(main_file);
 475                     main_file = alloc(SIZEOF(dumpfile_t));
 476                     memcpy(main_file, cur_file, SIZEOF(dumpfile_t));
 477                     outfd = cur_out->outfd;
 478                     if(outfd < 0) {
 479                         char *cur_filename = make_filename(cur_file);
 480                         open(cur_filename, O_RDWR|O_APPEND);
 481                         if (outfd < 0) {
 482                           error("Couldn't open %s for appending: %s",
 483                                 cur_filename, strerror(errno));
 484                           /*NOTREACHED*/
 485                         }
 486                         amfree(cur_filename);
 487                     }
 488                 }
 489                 lastpartnum = cur_file->partnum;
 490             }
 491             else {
 492                 aclose(cur_out->outfd);
 493             }
 494         }
 495         if(outfd >= 0) {
 496             aclose(outfd);
 497         }
 498
 499         amfree(main_file);
 500         free_find_result(&sorted_files);
 501     }
 502
 503     /*
 504      * Now that the split dump closure is done, free up resources we don't
 505      * need anymore.
 506      */
 507     for(cur_out=open_outputs; cur_out; cur_out=cur_out->next){
 508         dumpfile_t *cur_file = NULL;
 509         amfree(prev);
 510         cur_file = cur_out->file;
 511         /* if we requested a particular file, do only that one */
 512         if(only_file && !headers_equal(cur_file, only_file, 1)){
 513             continue;
 514         }
 515         if(!reassemble) {
 516             aclose(cur_out->outfd);
 517         }
 518
 519         if(cur_out->comp_enc_pid > 0){
 520             waitpid(cur_out->comp_enc_pid, &compress_status, 0);
 521         }
 522         amfree(cur_out->file);
 523         prev = cur_out;
 524     }
 525
 526     open_outputs = NULL;
 527 }
 528
 529 /*
 530  * Turn a fileheader into a string suited for use on the filesystem.
 531  */
 532 char *
 533 make_filename(
 534     dumpfile_t *file)
 535 {
 536     char number[NUM_STR_SIZE];
 537     char part[NUM_STR_SIZE];
 538     char totalparts[NUM_STR_SIZE];
 539     char *sfn = NULL;
 540     char *fn = NULL;
 541     char *pad = NULL;
 542     size_t padlen = 0;
 543
 544     snprintf(number, SIZEOF(number), "%d", file->dumplevel);
 545     snprintf(part, SIZEOF(part), "%d", file->partnum);
 546
 547     if(file->totalparts < 0) {
 548         snprintf(totalparts, SIZEOF(totalparts), "UNKNOWN");
 549     }
 550     else {
 551         snprintf(totalparts, SIZEOF(totalparts), "%d", file->totalparts);
 552     }
 553     padlen = strlen(totalparts) + 1 - strlen(part);
 554     pad = alloc(padlen);
 555     memset(pad, '0', padlen);
 556     pad[padlen - 1] = '\0';
 557
 558     snprintf(part, SIZEOF(part), "%s%d", pad, file->partnum);
 559
 560     sfn = sanitise_filename(file->disk);
 561     fn = vstralloc(file->name,
 562                    ".",
 563                    sfn,
 564                    ".",
 565                    file->datestamp,
 566                    ".",
 567                    number,
 568                    NULL);
 569     if (file->partnum > 0) {
 570         vstrextend(&fn, ".", part, NULL);
 571     }
 572     amfree(sfn);
 573     amfree(pad);
 574     return fn;
 575 }
 576
 577
 578 /*
 579  * XXX Making this thing a lib functiong broke a lot of assumptions everywhere,
 580  * but I think I've found them all.  Maybe.  Damn globals all over the place.
 581  */
 582
 583 static ssize_t
 584 get_block(
 585     int         tapefd,
 586     char *      buffer,
 587     int         isafile)
 588 {
 589     if(isafile)
 590         return (fullread(tapefd, buffer, blocksize));
 591
 592     return(tapefd_read(tapefd, buffer, blocksize));
 593 }
 594
 595 /*
 596  * Returns 1 if the current dump file matches the hostname and diskname
 597  * regular expressions given on the command line, 0 otherwise.  As a
 598  * special case, empty regexs are considered equivalent to ".*": they
 599  * match everything.
 600  */
 601
 602 int
 603 disk_match(
 604     dumpfile_t *file,
 605     char *      datestamp,
 606     char *      hostname,
 607     char *      diskname,
 608     char *      level)
 609 {
 610     char level_str[NUM_STR_SIZE];
 611     snprintf(level_str, SIZEOF(level_str), "%d", file->dumplevel);
 612
 613     if(file->type != F_DUMPFILE && file->type != F_SPLIT_DUMPFILE) return 0;
 614
 615     if((*hostname == '\0' || match_host(hostname, file->name)) &&
 616        (*diskname == '\0' || match_disk(diskname, file->disk)) &&
 617        (*datestamp == '\0' || match_datestamp(datestamp, file->datestamp)) &&
 618        (*level == '\0' || match_level(level, level_str)))
 619         return 1;
 620     else
 621         return 0;
 622 }
 623
 624
 625 /*
 626  * Reads the first block of a tape file.
 627  */
 628
 629 ssize_t
 630 read_file_header(
 631     dumpfile_t *        file,
 632     int                 tapefd,
 633     int                 isafile,
 634     rst_flags_t *       flags)
 635 {
 636     ssize_t bytes_read;
 637     char *buffer;
 638
 639     if(flags->blocksize > 0)
 640         blocksize = (size_t)flags->blocksize;
 641     else if(blocksize == (size_t)SSIZE_MAX)
 642         blocksize = DISK_BLOCK_BYTES;
 643     buffer = alloc(blocksize);
 644
 645     bytes_read = get_block(tapefd, buffer, isafile);
 646     if(bytes_read < 0) {
 647         fprintf(stderr, "%s: error reading file header: %s\n",
 648                 get_pname(), strerror(errno));
 649         file->type = F_UNKNOWN;
 650     } else if((size_t)bytes_read < blocksize) {
 651         if(bytes_read == 0) {
 652             fprintf(stderr, "%s: missing file header block\n", get_pname());
 653         } else {
 654             fprintf(stderr, "%s: short file header block: " OFF_T_FMT " byte%s\n",
 655                     get_pname(), (OFF_T_FMT_TYPE)bytes_read, (bytes_read == 1) ? "" : "s");
 656         }
 657         file->type = F_UNKNOWN;
 658     } else {
 659         parse_file_header(buffer, file, (size_t)bytes_read);
 660     }
 661     amfree(buffer);
 662     return bytes_read;
 663 }
 664
 665
 666 void
 667 drain_file(
 668     int                 tapefd,
 669     rst_flags_t *       flags)
 670 {
 671     ssize_t bytes_read;
 672     char *buffer;
 673
 674     if(flags->blocksize)
 675         blocksize = (size_t)flags->blocksize;
 676     else if(blocksize == (size_t)SSIZE_MAX)
 677         blocksize = DISK_BLOCK_BYTES;
 678     buffer = alloc(blocksize);
 679
 680     do {
 681        bytes_read = get_block(tapefd, buffer, 0);
 682        if(bytes_read < 0) {
 683            error("drain read error: %s", strerror(errno));
 684            /*NOTREACHED*/
 685        }
 686     } while (bytes_read > 0);
 687
 688     amfree(buffer);
 689 }
 690
 691 /*
 692  * Restore the current file from tape.  Depending on the settings of
 693  * the command line flags, the file might need to be compressed or
 694  * uncompressed.  If so, a pipe through compress or uncompress is set
 695  * up.  The final output usually goes to a file named host.disk.date.lev,
 696  * but with the -p flag the output goes to stdout (and presumably is
 697  * piped to restore).
 698  */
 699
 700 ssize_t
 701 restore(
 702     dumpfile_t *        file,
 703     char *              filename,
 704     int                 tapefd,
 705     int                 isafile,
 706     rst_flags_t *       flags)
 707 {
 708     int dest = -1, out;
 709     ssize_t s;
 710     int file_is_compressed;
 711     int is_continuation = 0;
 712     int check_for_aborted = 0;
 713     char *tmp_filename = NULL, *final_filename = NULL;
 714     struct stat statinfo;
 715     open_output_t *myout = NULL, *oldout = NULL;
 716     dumplist_t *tempdump = NULL, *fileentry = NULL;
 717     char *buffer;
 718     int need_compress=0, need_uncompress=0, need_decrypt=0;
 719     int stage=0;
 720     ssize_t bytes_read;
 721     struct pipeline {
 722         int     pipe[2];
 723     } pipes[3];
 724
 725     memset(pipes, -1, SIZEOF(pipes));
 726     if(flags->blocksize)
 727         blocksize = (size_t)flags->blocksize;
 728     else if(blocksize == (size_t)SSIZE_MAX)
 729         blocksize = DISK_BLOCK_BYTES;
 730
 731     if(already_have_dump(file)){
 732         char *filename = make_filename(file);
 733         fprintf(stderr, " *** Duplicate file %s, one is probably an aborted write\n", filename);
 734         amfree(filename);
 735         check_for_aborted = 1;
 736     }
 737
 738     /* store a shorthand record of this dump */
 739     tempdump = alloc(SIZEOF(dumplist_t));
 740     tempdump->file = alloc(SIZEOF(dumpfile_t));
 741     tempdump->next = NULL;
 742     memcpy(tempdump->file, file, SIZEOF(dumpfile_t));
 743
 744     /*
 745      * If we're appending chunked files to one another, and if this is a
 746      * continuation of a file we just restored, and we've still got the
 747      * output handle from that previous restore, we're golden.  Phew.
 748      */
 749     if(flags->inline_assemble && file->type == F_SPLIT_DUMPFILE){
 750         myout = open_outputs;
 751         while(myout != NULL){
 752             if(myout->file->type == F_SPLIT_DUMPFILE &&
 753                     headers_equal(file, myout->file, 1)){
 754                 if(file->partnum == myout->lastpartnum + 1){
 755                     is_continuation = 1;
 756                     break;
 757                 }
 758             }
 759             myout = myout->next;
 760         }
 761         if(myout != NULL) myout->lastpartnum = file->partnum;
 762         else if(file->partnum != 1){
 763             fprintf(stderr, "%s:      Chunk out of order, will save to disk and append to output.\n", get_pname());
 764             flags->pipe_to_fd = -1;
 765             flags->compress = 0;
 766             flags->leave_comp = 1;
 767         }
 768         if(myout == NULL){
 769             myout = alloc(SIZEOF(open_output_t));
 770             memset(myout, 0, SIZEOF(open_output_t));
 771         }
 772     }
 773     else{
 774       myout = alloc(SIZEOF(open_output_t));
 775       memset(myout, 0, SIZEOF(open_output_t));
 776     }
 777
 778
 779     if(is_continuation && flags->pipe_to_fd == -1){
 780         char *filename;
 781         filename = make_filename(myout->file);
 782         fprintf(stderr, "%s:      appending to %s\n", get_pname(),
 783                 filename);
 784         amfree(filename);
 785     }
 786
 787     /* adjust compression flag */
 788     file_is_compressed = file->compressed;
 789     if(!flags->compress && file_is_compressed && !known_compress_type(file)) {
 790         fprintf(stderr,
 791                 "%s: unknown compression suffix %s, can't uncompress\n",
 792                 get_pname(), file->comp_suffix);
 793         flags->compress = 1;
 794     }
 795
 796     /* set up final destination file */
 797
 798     if(is_continuation && myout != NULL) {
 799       out = myout->outfd;
 800     } else {
 801       if(flags->pipe_to_fd != -1) {
 802           dest = flags->pipe_to_fd;     /* standard output */
 803       } else {
 804           char *filename_ext = NULL;
 805
 806           if(flags->compress) {
 807               filename_ext = file_is_compressed ? file->comp_suffix
 808                                               : COMPRESS_SUFFIX;
 809           } else if(flags->raw) {
 810               filename_ext = ".RAW";
 811           } else {
 812               filename_ext = "";
 813           }
 814           filename_ext = stralloc2(filename, filename_ext);
 815           tmp_filename = stralloc(filename_ext);
 816           if(flags->restore_dir != NULL) {
 817               char *tmpstr = vstralloc(flags->restore_dir, "/",
 818                                        tmp_filename, NULL);
 819               amfree(tmp_filename);
 820               tmp_filename = tmpstr;
 821           }
 822           final_filename = stralloc(tmp_filename);
 823           tmp_filename = newvstralloc(tmp_filename, ".tmp", NULL);
 824           if((dest = open(tmp_filename, (O_CREAT | O_RDWR | O_TRUNC),
 825                           CREAT_MODE)) < 0) {
 826               error("could not create output file %s: %s",
 827                     tmp_filename, strerror(errno));
 828               /*NOTREACHED*/
 829           }
 830           amfree(filename_ext);
 831       }
 832
 833       out = dest;
 834     }
 835
 836     /*
 837      * If -r or -h, write the header before compress or uncompress pipe.
 838      * Only write DISK_BLOCK_BYTES, regardless of how much was read.
 839      * This makes the output look like a holding disk image, and also
 840      * makes it easier to remove the header (e.g. in amrecover) since
 841      * it has a fixed size.
 842      */
 843     if(flags->raw || (flags->headers && !is_continuation)) {
 844         ssize_t w;
 845         dumpfile_t tmp_hdr;
 846
 847         if(flags->compress && !file_is_compressed) {
 848             file->compressed = 1;
 849             snprintf(file->uncompress_cmd, SIZEOF(file->uncompress_cmd),
 850                         " %s %s |", UNCOMPRESS_PATH,
 851 #ifdef UNCOMPRESS_OPT
 852                         UNCOMPRESS_OPT
 853 #else
 854                         ""
 855 #endif
 856                         );
 857             strncpy(file->comp_suffix,
 858                     COMPRESS_SUFFIX,
 859                     SIZEOF(file->comp_suffix)-1);
 860             file->comp_suffix[SIZEOF(file->comp_suffix)-1] = '\0';
 861         }
 862
 863         memcpy(&tmp_hdr, file, SIZEOF(dumpfile_t));
 864
 865         /* remove CONT_FILENAME from header */
 866         memset(file->cont_filename,'\0',SIZEOF(file->cont_filename));
 867         file->blocksize = DISK_BLOCK_BYTES;
 868
 869         /*
 870          * Dumb down split file headers as well, so that older versions of
 871          * things like amrecover won't gag on them.
 872          */
 873         if(file->type == F_SPLIT_DUMPFILE && flags->mask_splits){
 874             file->type = F_DUMPFILE;
 875         }
 876
 877         buffer = alloc(DISK_BLOCK_BYTES);
 878         build_header(buffer, file, DISK_BLOCK_BYTES);
 879
 880         if((w = fullwrite(out, buffer, DISK_BLOCK_BYTES)) != DISK_BLOCK_BYTES) {
 881             if(w < 0) {
 882                 error("write error: %s", strerror(errno));
 883                 /*NOTREACHED*/
 884             } else {
 885                 error("write error: %d instead of %d", w, DISK_BLOCK_BYTES);
 886                 /*NOTREACHED*/
 887             }
 888         }
 889         amfree(buffer);
 890
 891         memcpy(file, &tmp_hdr, SIZEOF(dumpfile_t));
 892     }
 893
 894     /* find out if compression or uncompression is needed here */
 895     if(flags->compress && !file_is_compressed && !is_continuation
 896           && !flags->leave_comp
 897           && (flags->inline_assemble || file->type != F_SPLIT_DUMPFILE))
 898        need_compress=1;
 899
 900     if(!flags->raw && !flags->compress && file_is_compressed
 901           && !is_continuation && !flags->leave_comp && (flags->inline_assemble
 902           || file->type != F_SPLIT_DUMPFILE))
 903        need_uncompress=1;
 904
 905     if(!flags->raw && file->encrypted)
 906        need_decrypt=1;
 907
 908     /* Setup pipes for decryption / compression / uncompression  */
 909     stage = 0;
 910     if (need_decrypt) {
 911       if (pipe(&pipes[stage].pipe[0]) < 0) {
 912         error("error [pipe[%d]: %s]", stage, strerror(errno));
 913         /*NOTREACHED*/
 914       }
 915       stage++;
 916     }
 917
 918     if (need_compress || need_uncompress) {
 919       if (pipe(&pipes[stage].pipe[0]) < 0) {
 920         error("error [pipe[%d]: %s]", stage, strerror(errno));
 921         /*NOTREACHED*/
 922       }
 923       stage++;
 924     }
 925     pipes[stage].pipe[0] = -1;
 926     pipes[stage].pipe[1] = out;
 927
 928     stage = 0;
 929
 930     /* decrypt first if it's encrypted and no -r */
 931     if(need_decrypt) {
 932       switch(myout->comp_enc_pid = fork()) {
 933       case -1:
 934         error("could not fork for decrypt: %s", strerror(errno));
 935         /*NOTREACHED*/
 936
 937       default:
 938         aclose(pipes[stage].pipe[0]);
 939         aclose(pipes[stage+1].pipe[1]);
 940         stage++;
 941         break;
 942
 943       case 0:
 944         if(dup2(pipes[stage].pipe[0], 0) == -1) {
 945             error("error decrypt stdin [dup2 %d %d: %s]", stage,
 946                 pipes[stage].pipe[0], strerror(errno));
 947                 /*NOTREACHED*/
 948         }
 949
 950         if(dup2(pipes[stage+1].pipe[1], 1) == -1) {
 951             error("error decrypt stdout [dup2 %d %d: %s]", stage + 1,
 952                 pipes[stage+1].pipe[1], strerror(errno));
 953                 /*NOTREACHED*/
 954         }
 955
 956         safe_fd(-1, 0);
 957         if (*file->srv_encrypt) {
 958           (void) execlp(file->srv_encrypt, file->srv_encrypt,
 959                         file->srv_decrypt_opt, (char *)NULL);
 960           error("could not exec %s: %s", file->srv_encrypt, strerror(errno));
 961           /*NOTREACHED*/
 962         }  else if (*file->clnt_encrypt) {
 963           (void) execlp(file->clnt_encrypt, file->clnt_encrypt,
 964                         file->clnt_decrypt_opt, (char *)NULL);
 965           error("could not exec %s: %s", file->clnt_encrypt, strerror(errno));
 966           /*NOTREACHED*/
 967         }
 968       }
 969     }
 970
 971     if (need_compress) {
 972         /*
 973          * Insert a compress pipe
 974          */
 975         switch(myout->comp_enc_pid = fork()) {
 976         case -1:
 977             error("could not fork for %s: %s", COMPRESS_PATH, strerror(errno));
 978             /*NOTREACHED*/
 979
 980         default:
 981             aclose(pipes[stage].pipe[0]);
 982             aclose(pipes[stage+1].pipe[1]);
 983             stage++;
 984             break;
 985
 986         case 0:
 987             if(dup2(pipes[stage].pipe[0], 0) == -1) {
 988                 error("error compress stdin [dup2 %d %d: %s]", stage,
 989                   pipes[stage].pipe[0], strerror(errno));
 990                 /*NOTREACHED*/
 991             }
 992
 993             if(dup2(pipes[stage+1].pipe[1], 1) == -1) {
 994                 error("error compress stdout [dup2 %d %d: %s]", stage + 1,
 995                   pipes[stage+1].pipe[1], strerror(errno));
 996                   /*NOTREACHED*/
 997             }
 998             if (*flags->comp_type == '\0') {
 999                 flags->comp_type = NULL;
1000             }
1001
1002             safe_fd(-1, 0);
1003             (void) execlp(COMPRESS_PATH, COMPRESS_PATH, flags->comp_type, (char *)0);
1004             error("could not exec %s: %s", COMPRESS_PATH, strerror(errno));
1005             /*NOTREACHED*/
1006         }
1007     } else if(need_uncompress) {
1008         /*
1009          * If not -r, -c, -l, and file is compressed, and split reassembly
1010          * options are sane, insert uncompress pipe
1011          */
1012
1013         /*
1014          * XXX for now we know that for the two compression types we
1015          * understand, .Z and optionally .gz, UNCOMPRESS_PATH will take
1016          * care of both.  Later, we may need to reference a table of
1017          * possible uncompress programs.
1018          */
1019         switch(myout->comp_enc_pid = fork()) {
1020         case -1:
1021             error("could not fork for %s: %s",
1022                   UNCOMPRESS_PATH, strerror(errno));
1023             /*NOTREACHED*/
1024
1025         default:
1026             aclose(pipes[stage].pipe[0]);
1027             aclose(pipes[stage+1].pipe[1]);
1028             stage++;
1029             break;
1030
1031         case 0:
1032             if(dup2(pipes[stage].pipe[0], 0) == -1) {
1033                 error("error uncompress stdin [dup2 %d %d: %s]", stage,
1034                   pipes[stage].pipe[0], strerror(errno));
1035                 /*NOTREACHED*/
1036             }
1037
1038             if(dup2(pipes[stage+1].pipe[1], 1) == -1) {
1039                 error("error uncompress stdout [dup2 %d %d: %s]", stage + 1,
1040                   pipes[stage+1].pipe[1], strerror(errno));
1041                 /*NOTREACHED*/
1042             }
1043
1044             safe_fd(-1, 0);
1045             if (*file->srvcompprog) {
1046               (void) execlp(file->srvcompprog, file->srvcompprog, "-d",
1047                             (char *)NULL);
1048               error("could not exec %s: %s", file->srvcompprog,
1049                     strerror(errno));
1050               /*NOTREACHED*/
1051             } else if (*file->clntcompprog) {
1052               (void) execlp(file->clntcompprog, file->clntcompprog, "-d",
1053                             (char *)NULL);
1054               error("could not exec %s: %s", file->clntcompprog,
1055                     strerror(errno));
1056               /*NOTREACHED*/
1057             } else {
1058               (void) execlp(UNCOMPRESS_PATH, UNCOMPRESS_PATH,
1059 #ifdef UNCOMPRESS_OPT
1060                           UNCOMPRESS_OPT,
1061 #endif
1062                           (char *)NULL);
1063               error("could not exec %s: %s", UNCOMPRESS_PATH, strerror(errno));
1064               /*NOTREACHED*/
1065             }
1066         }
1067     }
1068
1069     /* copy the rest of the file from tape to the output */
1070     if(flags->blocksize > 0)
1071         blocksize = (size_t)flags->blocksize;
1072     else if(blocksize == SIZE_MAX)
1073         blocksize = DISK_BLOCK_BYTES;
1074     buffer = alloc(blocksize);
1075
1076     do {
1077         bytes_read = get_block(tapefd, buffer, isafile);
1078         if(bytes_read < 0) {
1079             error("restore read error: %s", strerror(errno));
1080             /*NOTREACHED*/
1081         }
1082
1083         if(bytes_read > 0) {
1084             if((s = fullwrite(pipes[0].pipe[1], buffer, (size_t)bytes_read)) < 0) {
1085                 if ((errno == EPIPE) || (errno == ECONNRESET)) {
1086                     /*
1087                      * reading program has ended early
1088                      * e.g: bzip2 closes pipe when it
1089                      * trailing garbage after EOF
1090                      */
1091                     break;
1092                 }
1093                 error("restore: write error: %s", strerror(errno));
1094                 /* NOTREACHED */
1095             } else if (s < bytes_read) {
1096                 error("restore: wrote %d of %d bytes: %s",
1097                     s, bytes_read, strerror(errno));
1098                 /* NOTREACHED */
1099             }
1100         }
1101         else if(isafile) {
1102             /*
1103              * See if we need to switch to the next file in a holding restore
1104              */
1105             if(file->cont_filename[0] == '\0') {
1106                 break;                          /* no more files */
1107             }
1108             aclose(tapefd);
1109             if((tapefd = open(file->cont_filename, O_RDONLY)) == -1) {
1110                 char *cont_filename = strrchr(file->cont_filename,'/');
1111                 if(cont_filename) {
1112                     cont_filename++;
1113                     if((tapefd = open(cont_filename,O_RDONLY)) == -1) {
1114                         error("can't open %s: %s", file->cont_filename,
1115                               strerror(errno));
1116                         /*NOTREACHED*/
1117                     }
1118                     else {
1119                         fprintf(stderr, "cannot open %s: %s\n",
1120                                 file->cont_filename, strerror(errno));
1121                         fprintf(stderr, "using %s\n",
1122                                 cont_filename);
1123                     }
1124                 }
1125                 else {
1126                     error("can't open %s: %s", file->cont_filename,
1127                           strerror(errno));
1128                     /*NOTREACHED*/
1129                 }
1130             }
1131             bytes_read = read_file_header(file, tapefd, isafile, flags);
1132             if(file->type != F_DUMPFILE && file->type != F_CONT_DUMPFILE
1133                     && file->type != F_SPLIT_DUMPFILE) {
1134                 fprintf(stderr, "unexpected header type: ");
1135                 print_header(stderr, file);
1136                 exit(2);
1137             }
1138         }
1139     } while (bytes_read > 0);
1140
1141     amfree(buffer);
1142
1143     if(!flags->inline_assemble) {
1144         if(out != dest)
1145             aclose(out);
1146     }
1147     if(!is_continuation){
1148         if(tmp_filename && stat(tmp_filename, &statinfo) < 0){
1149             error("Can't stat the file I just created (%s)!", tmp_filename);
1150             /*NOTREACHED*/
1151         } else {
1152             statinfo.st_size = (off_t)0;
1153         }
1154         if (check_for_aborted && final_filename) {
1155             char *old_dump = final_filename;
1156             struct stat oldstat;
1157             if(stat(old_dump, &oldstat) >= 0){
1158                 if(oldstat.st_size <= statinfo.st_size){
1159                     dumplist_t *prev_fileentry = NULL;
1160                     open_output_t *prev_out = NULL;
1161                     fprintf(stderr, "Newer restore is larger, using that\n");
1162                     /* nuke the old dump's entry in alldump_list */
1163                     for(fileentry=alldumps_list;
1164                             fileentry->next;
1165                             fileentry=fileentry->next){
1166                         if(headers_equal(file, fileentry->file, 0)){
1167                             if(prev_fileentry){
1168                                 prev_fileentry->next = fileentry->next;
1169                             }
1170                             else {
1171                                 alldumps_list = fileentry->next;
1172                             }
1173                             amfree(fileentry);
1174                             break;
1175                         }
1176                         prev_fileentry = fileentry;
1177                     }
1178                     myout = open_outputs;
1179                     while(myout != NULL){
1180                         if(headers_equal(file, myout->file, 0)){
1181                             if(myout->outfd >= 0)
1182                                 aclose(myout->outfd);
1183                             if(prev_out){
1184                                 prev_out->next = myout->next;
1185                             }
1186                             else open_outputs = myout->next;
1187                             amfree(myout);
1188                             break;
1189                         }
1190                         prev_out = myout;
1191                         myout = myout->next;
1192                     }
1193                 }
1194                 else{
1195                     fprintf(stderr, "Older restore is larger, using that\n");
1196                     if (tmp_filename)
1197                         unlink(tmp_filename);
1198                     amfree(tempdump->file);
1199                     amfree(tempdump);
1200                     amfree(tmp_filename);
1201                     amfree(final_filename);
1202                     return (bytes_read);
1203                 }
1204             }
1205         }
1206         if(tmp_filename && final_filename &&
1207                 rename(tmp_filename, final_filename) < 0) {
1208             error("Can't rename %s to %s: %s",
1209                    tmp_filename, final_filename, strerror(errno));
1210             /*NOTREACHED*/
1211         }
1212     }
1213     amfree(tmp_filename);
1214     amfree(final_filename);
1215
1216
1217     /*
1218      * actually insert tracking data for this file into our various
1219      * structures (we waited in case we needed to give up)
1220      */
1221     if(!is_continuation){
1222         oldout = alloc(SIZEOF(open_output_t));
1223         oldout->file = alloc(SIZEOF(dumpfile_t));
1224         memcpy(oldout->file, file, SIZEOF(dumpfile_t));
1225         if(flags->inline_assemble) oldout->outfd = pipes[0].pipe[1];
1226         else oldout->outfd = -1;
1227         oldout->comp_enc_pid = -1;
1228         oldout->lastpartnum = file->partnum;
1229         oldout->next = open_outputs;
1230         open_outputs = oldout;
1231     }
1232     if(alldumps_list){
1233         fileentry = alldumps_list;
1234         while (fileentry->next != NULL)
1235             fileentry=fileentry->next;
1236         fileentry->next = tempdump;
1237     }
1238     else {
1239         alldumps_list = tempdump;
1240     }
1241
1242     return (bytes_read);
1243 }
1244
1245 /* return NULL if the label is not the expected one                     */
1246 /* return the label if it is the expected one, and set *tapefd to a     */
1247 /* file descriptor to the tapedev                                       */
1248 char *
1249 label_of_current_slot(
1250     char         *cur_tapedev,
1251     FILE         *prompt_out,
1252     int          *tapefd,
1253     dumpfile_t   *file,
1254     rst_flags_t  *flags,
1255     am_feature_t *their_features,
1256     ssize_t      *read_result,
1257     tapelist_t   *desired_tape)
1258 {
1259     struct stat stat_tape;
1260     char *label = NULL;
1261     int wrongtape = 0;
1262     char *err;
1263
1264     if (!cur_tapedev) {
1265         send_message(prompt_out, flags, their_features,
1266                      "no tapedev specified");
1267     } else if (tape_stat(cur_tapedev, &stat_tape) !=0 ) {
1268         send_message(prompt_out, flags, their_features,
1269                      "could not stat '%s': %s",
1270                      cur_tapedev, strerror(errno));
1271         wrongtape = 1;
1272     } else if((err = tape_rewind(cur_tapedev)) != NULL) {
1273         send_message(prompt_out, flags, their_features,
1274                          "Could not rewind device '%s': %s",
1275                          cur_tapedev, err);
1276         wrongtape = 1;
1277         /* err should not be freed */
1278     } else if((*tapefd = tape_open(cur_tapedev, 0)) < 0){
1279         send_message(prompt_out, flags, their_features,
1280                          "could not open tape device %s: %s",
1281                          cur_tapedev, strerror(errno));
1282         wrongtape = 1;
1283     }
1284
1285     if (!wrongtape) {
1286         *read_result = read_file_header(file, *tapefd, 0, flags);
1287         if (file->type != F_TAPESTART) {
1288             send_message(prompt_out, flags, their_features,
1289                              "Not an amanda tape");
1290             tapefd_close(*tapefd);
1291         } else {
1292             if (flags->check_labels && desired_tape &&
1293                          strcmp(file->name, desired_tape->label) != 0) {
1294                 send_message(prompt_out, flags, their_features,
1295                                  "Label mismatch, got %s and expected %s",
1296                                  file->name, desired_tape->label);
1297                 tapefd_close(*tapefd);
1298             }
1299             else {
1300                 label = stralloc(file->name);
1301             }
1302         }
1303     }
1304     return label;
1305 }
1306
1307 /* return >0            the number of slot move            */
1308 /* return LOAD_STOP     if the search must be stopped      */
1309 /* return LOAD_CHANGER  if the changer search the library  */
1310 int
1311 load_next_tape(
1312     char         **cur_tapedev,
1313     FILE          *prompt_out,
1314     int            backwards,
1315     rst_flags_t   *flags,
1316     am_feature_t  *their_features,
1317     tapelist_t    *desired_tape)
1318 {
1319     int ret = -1;
1320
1321     if (desired_tape) {
1322         send_message(prompt_out, flags, their_features,
1323                      "Looking for tape %s...",
1324                      desired_tape->label);
1325         if (backwards) {
1326             searchlabel = desired_tape->label;
1327             changer_find(NULL, scan_init, loadlabel_slot,
1328                          desired_tape->label);
1329             ret = LOAD_CHANGER;
1330         } else {
1331             amfree(curslot);
1332             changer_loadslot("next", &curslot,
1333                              cur_tapedev);
1334             ret = 1;
1335         }
1336     } else {
1337         assert(!flags->amidxtaped);
1338         amfree(curslot);
1339         changer_loadslot("next", &curslot, cur_tapedev);
1340         ret = 1;
1341     }
1342     return ret;
1343 }
1344
1345
1346 /* return  0     a new tape is loaded       */
1347 /* return -1     no new tape                */
1348 int
1349 load_manual_tape(
1350     char         **cur_tapedev,
1351     FILE          *prompt_out,
1352     FILE          *prompt_in,
1353     rst_flags_t   *flags,
1354     am_feature_t  *their_features,
1355     tapelist_t    *desired_tape)
1356 {
1357     int ret = 0;
1358     char *input = NULL;
1359
1360     if (flags->amidxtaped) {
1361         if (their_features &&
1362             am_has_feature(their_features,
1363                            fe_amrecover_FEEDME)) {
1364             fprintf(prompt_out, "FEEDME %s\r\n",
1365                     desired_tape->label);
1366             fflush(prompt_out);
1367             input = agets(prompt_in);/* Strips \n but not \r */
1368             if(!input) {
1369                 error("Connection lost with amrecover");
1370                 /*NOTREACHED*/
1371             } else if (strcmp("OK\r", input) == 0) {
1372             } else if (strncmp("TAPE ", input, 5) == 0) {
1373                 amfree(*cur_tapedev);
1374                 *cur_tapedev = alloc(1025);
1375                 if (sscanf(input, "TAPE %1024s\r", *cur_tapedev) != 1) {
1376                     error("Got bad response from amrecover: %s", input);
1377                     /*NOTREACHED*/
1378                 }
1379             } else {
1380                 send_message(prompt_out, flags, their_features,
1381                              "Got bad response from amrecover: %s", input);
1382                 error("Got bad response from amrecover: %s", input);
1383                 /*NOTREACHED*/
1384             }
1385         } else {
1386             send_message(prompt_out, flags, their_features,
1387                          "Client doesn't support fe_amrecover_FEEDME");
1388             error("Client doesn't support fe_amrecover_FEEDME");
1389             /*NOTREACHED*/
1390         }
1391     }
1392     else {
1393         if (desired_tape) {
1394             fprintf(prompt_out,
1395                     "Insert tape labeled %s in device %s \n"
1396                     "and press enter, ^D to finish reading tapes\n",
1397                     desired_tape->label, *cur_tapedev);
1398         } else {
1399             fprintf(prompt_out,"Insert a tape to search and press "
1400                     "enter, ^D to finish reading tapes\n");
1401         }
1402         fflush(prompt_out);
1403         if((input = agets(stdin)) == NULL)
1404             ret = -1;
1405     }
1406
1407     amfree(input);
1408     return ret;
1409 }
1410
1411
1412 void
1413 search_a_tape(
1414     char         *cur_tapedev,
1415     FILE         *prompt_out,
1416     rst_flags_t  *flags,
1417     am_feature_t *their_features,
1418     tapelist_t   *desired_tape,
1419     int           isafile,
1420     match_list_t *match_list,
1421     seentapes_t  *tape_seen,
1422     dumpfile_t   *file,
1423     dumpfile_t   *prev_rst_file,
1424     dumpfile_t   *tapestart,
1425     int           slot_num,
1426     ssize_t      *read_result)
1427 {
1428     off_t       filenum;
1429     dumplist_t *fileentry = NULL;
1430     int         tapefile_idx = -1;
1431     int         i;
1432     char       *logline = NULL;
1433     FILE       *logstream = NULL;
1434     off_t       fsf_by;
1435
1436     filenum = (off_t)0;
1437     if(desired_tape && desired_tape->numfiles > 0)
1438         tapefile_idx = 0;
1439
1440     if (desired_tape) {
1441         dbprintf(("search_a_tape: desired_tape=%p label=%s\n",
1442                   desired_tape, desired_tape->label));
1443         dbprintf(("tape:   numfiles = %d\n", desired_tape->numfiles));
1444         for (i=0; i < desired_tape->numfiles; i++) {
1445             dbprintf(("tape:   files[%d] = " OFF_T_FMT "\n",
1446                       i, (OFF_T_FMT_TYPE)desired_tape->files[i]));
1447         }
1448     } else {
1449         dbprintf(("search_a_tape: no desired_tape\n"));
1450     }
1451     dbprintf(("current tapefile_idx = %d\n", tapefile_idx));
1452
1453     /* if we know where we're going, fastforward there */
1454     if(flags->fsf && !isafile){
1455         /* If we have a tapelist entry, filenums will be store there */
1456         if(tapefile_idx >= 0) {
1457             fsf_by = desired_tape->files[tapefile_idx];
1458         } else {
1459             /*
1460              * older semantics assume we're restoring one file, with the fsf
1461              * flag being the filenum on tape for said file
1462              */
1463             fsf_by = (flags->fsf == 0) ? (off_t)0 : (off_t)1;
1464         }
1465         if(fsf_by > (off_t)0){
1466             if(tapefd_rewind(tapefd) < 0) {
1467                 send_message(prompt_out, flags, their_features,
1468                              "Could not rewind device %s: %s",
1469                              cur_tapedev, strerror(errno));
1470                 error("Could not rewind device %s: %s",
1471                       cur_tapedev, strerror(errno));
1472                 /*NOTREACHED*/
1473             }
1474
1475             if(tapefd_fsf(tapefd, fsf_by) < 0) {
1476                 send_message(prompt_out, flags, their_features,
1477                              "Could not fsf device %s by " OFF_T_FMT ": %s",
1478                              cur_tapedev, (OFF_T_FMT_TYPE)fsf_by,
1479                              strerror(errno));
1480                 error("Could not fsf device %s by " OFF_T_FMT ": %s",
1481                       cur_tapedev, (OFF_T_FMT_TYPE)fsf_by,
1482                       strerror(errno));
1483                 /*NOTREACHED*/
1484             }
1485             else {
1486                 filenum = fsf_by;
1487             }
1488             *read_result = read_file_header(file, tapefd, isafile, flags);
1489         }
1490     }
1491
1492     while((file->type == F_TAPESTART || file->type == F_DUMPFILE ||
1493            file->type == F_SPLIT_DUMPFILE) &&
1494           (tapefile_idx < 0 || tapefile_idx < desired_tape->numfiles)) {
1495         int found_match = 0;
1496         match_list_t *me;
1497         dumplist_t *tempdump = NULL;
1498
1499         /* store record of this dump for inventorying purposes */
1500         tempdump = alloc(SIZEOF(dumplist_t));
1501         tempdump->file = alloc(SIZEOF(dumpfile_t));
1502         tempdump->next = NULL;
1503         memcpy(tempdump->file, &file, SIZEOF(dumpfile_t));
1504         if(tape_seen->files){
1505             fileentry = tape_seen->files;
1506             while (fileentry->next != NULL)
1507                    fileentry = fileentry->next;
1508             fileentry->next = tempdump;
1509         }
1510         else {
1511             tape_seen->files = tempdump;
1512         }
1513
1514         /* see if we need to restore the thing */
1515         if(isafile)
1516             found_match = 1;
1517         else if(tapefile_idx >= 0){ /* do it by explicit file #s */
1518             if(filenum == desired_tape->files[tapefile_idx]){
1519                 found_match = 1;
1520                 tapefile_idx++;
1521             }
1522         }
1523         else{ /* search and match headers */
1524             for(me = match_list; me; me = me->next) {
1525                 if(disk_match(file, me->datestamp, me->hostname,
1526                               me->diskname, me->level) != 0){
1527                     found_match = 1;
1528                     break;
1529                 }
1530             }
1531         }
1532
1533         if(found_match){
1534             char *filename = make_filename(file);
1535
1536             fprintf(stderr, "%s: " OFF_T_FMT ": restoring ",
1537                     get_pname(), (OFF_T_FMT_TYPE)filenum);
1538             print_header(stderr, file);
1539             *read_result = restore(file, filename, tapefd, isafile, flags);
1540             filenum++;
1541             amfree(filename);
1542         }
1543
1544         /* advance to the next file, fast-forwarding where reasonable */
1545         if (!isafile) {
1546             if (*read_result == 0) {
1547                 tapefd_close(tapefd);
1548                 if((tapefd = tape_open(cur_tapedev, 0)) < 0) {
1549                     send_message(prompt_out, flags, their_features,
1550                                  "could not open %s: %s",
1551                                  cur_tapedev, strerror(errno));
1552                     error("could not open %s: %s",
1553                           cur_tapedev, strerror(errno));
1554                     /*NOTREACHED*/
1555                 }
1556             /* if the file is not what we're looking for fsf to next one */
1557             }
1558             else if (!found_match) {
1559                 if (tapefd_fsf(tapefd, (off_t)1) < 0) {
1560                     send_message(prompt_out, flags, their_features,
1561                                  "Could not fsf device %s: %s",
1562                                  cur_tapedev, strerror(errno));
1563                     error("Could not fsf device %s: %s",
1564                           cur_tapedev, strerror(errno));
1565                     /*NOTREACHED*/
1566                 }
1567                 filenum ++;
1568             }
1569             else if (flags->fsf && (tapefile_idx >= 0) &&
1570                      (tapefile_idx < desired_tape->numfiles)) {
1571                 fsf_by = desired_tape->files[tapefile_idx] - filenum;
1572                 if (fsf_by > (off_t)0) {
1573                     if(tapefd_fsf(tapefd, fsf_by) < 0) {
1574                         send_message(prompt_out, flags, their_features,
1575                                      "Could not fsf device %s by "
1576                                      OFF_T_FMT ": %s",
1577                                      cur_tapedev, (OFF_T_FMT_TYPE)fsf_by,
1578                                      strerror(errno));
1579                         error("Could not fsf device %s by " OFF_T_FMT ": %s",
1580                               cur_tapedev, (OFF_T_FMT_TYPE)fsf_by,
1581                               strerror(errno));
1582                         /*NOTREACHED*/
1583                     }
1584                     filenum = desired_tape->files[tapefile_idx];
1585                 }
1586             }
1587         } /* !isafile */
1588
1589         memcpy(prev_rst_file, file, SIZEOF(dumpfile_t));
1590
1591         if(isafile)
1592             break;
1593         *read_result = read_file_header(file, tapefd, isafile, flags);
1594
1595         /* only restore a single dump, if piping to stdout */
1596         if (!headers_equal(prev_rst_file, file, 1) &&
1597             (flags->pipe_to_fd == fileno(stdout)) && found_match) {
1598             break;
1599         }
1600     } /* while we keep seeing headers */
1601
1602     if (!isafile) {
1603         if (file->type == F_EMPTY) {
1604             aclose(tapefd);
1605             if((tapefd = tape_open(cur_tapedev, 0)) < 0) {
1606                 send_message(prompt_out, flags, their_features,
1607                              "could not open %s: %s",
1608                              cur_tapedev, strerror(errno));
1609                 error("could not open %s: %s",
1610                       cur_tapedev, strerror(errno));
1611                 /*NOTREACHED*/
1612             }
1613         } else {
1614             if (tapefd_fsf(tapefd, (off_t)1) < 0) {
1615                 send_message(prompt_out, flags, their_features,
1616                              "could not fsf %s: %s",
1617                              cur_tapedev, strerror(errno));;
1618                 error("could not fsf %s: %s",
1619                       cur_tapedev, strerror(errno));
1620                 /*NOTREACHED*/
1621             }
1622         }
1623     }
1624     tapefd_close(tapefd);
1625
1626     /* spit out our accumulated list of dumps, if we're inventorying */
1627     if (logstream) {
1628         logline = log_genstring(L_START, "taper",
1629                                     "datestamp %s label %s tape %d",
1630                                     tapestart->datestamp, tapestart->name,
1631                                     slot_num);
1632         fprintf(logstream, "%s", logline);
1633         for(fileentry=tape_seen->files; fileentry; fileentry=fileentry->next){
1634             logline = NULL;
1635             switch (fileentry->file->type) {
1636                 case F_DUMPFILE:
1637                     logline = log_genstring(L_SUCCESS, "taper",
1638                                        "%s %s %s %d [faked log entry]",
1639                                        fileentry->file->name,
1640                                        fileentry->file->disk,
1641                                        fileentry->file->datestamp,
1642                                        fileentry->file->dumplevel);
1643                     break;
1644                 case F_SPLIT_DUMPFILE:
1645                     logline = log_genstring(L_CHUNK, "taper",
1646                                        "%s %s %s %d %d [faked log entry]",
1647                                        fileentry->file->name,
1648                                        fileentry->file->disk,
1649                                        fileentry->file->datestamp,
1650                                        fileentry->file->partnum,
1651                                        fileentry->file->dumplevel);
1652                     break;
1653                 default:
1654                     break;
1655             }
1656             if(logline){
1657                 fprintf(logstream, "%s", logline);
1658                 amfree(logline);
1659                 fflush(logstream);
1660             }
1661         }
1662     }
1663 }
1664
1665 /*
1666  * Take a pattern of dumps and restore it blind, a la amrestore.  In addition,
1667  * be smart enough to change tapes and continue with minimal operator
1668  * intervention, and write out a record of what was found on tapes in the
1669  * the regular logging format.  Can take a tapelist with a specific set of
1670  * tapes to search (rather than "everything I can find"), which in turn can
1671  * optionally list specific files to restore.
1672  */
1673 void
1674 search_tapes(
1675     FILE *              prompt_out,
1676     FILE               *prompt_in,
1677     int                 use_changer,
1678     tapelist_t *        tapelist,
1679     match_list_t *      match_list,
1680     rst_flags_t *       flags,
1681     am_feature_t *      their_features)
1682 {
1683     int have_changer = 1;
1684     int slot_num = -1;
1685     int slots = -1;
1686     FILE *logstream = NULL;
1687     tapelist_t *desired_tape = NULL;
1688     struct sigaction act, oact;
1689     ssize_t read_result;
1690     int slot;
1691     char *label = NULL;
1692     seentapes_t *seentapes = NULL;
1693     int ret;
1694
1695     dbprintf(("search_tapes(prompt_out=%d, prompt_in=%d,  use_changer=%d, "
1696               "tapelist=%p, "
1697               "match_list=%p, flags=%p, features=%p)\n",
1698               fileno(prompt_out), fileno(prompt_in), use_changer, tapelist,
1699               match_list, flags, their_features));
1700
1701     if(!prompt_out) prompt_out = stderr;
1702
1703     if(flags->blocksize)
1704         blocksize = (size_t)flags->blocksize;
1705     else if(blocksize == (size_t)SSIZE_MAX)
1706         blocksize = DISK_BLOCK_BYTES;
1707
1708     /* Don't die when child closes pipe */
1709     signal(SIGPIPE, SIG_IGN);
1710
1711     /* catch SIGINT with something that'll flush unmerged splits */
1712     act.sa_handler = handle_sigint;
1713     sigemptyset(&act.sa_mask);
1714     act.sa_flags = 0;
1715     if(sigaction(SIGINT, &act, &oact) != 0){
1716         error("error setting SIGINT handler: %s", strerror(errno));
1717         /*NOTREACHED*/
1718     }
1719     if(flags->delay_assemble || flags->inline_assemble) exitassemble = 1;
1720     else exitassemble = 0;
1721
1722     /* if given a log file, print an inventory of stuff found */
1723     if(flags->inventory_log) {
1724         if(!strcmp(flags->inventory_log, "-")) logstream = stdout;
1725         else if((logstream = fopen(flags->inventory_log, "w+")) == NULL) {
1726             error("Couldn't open log file %s for writing: %s",
1727                   flags->inventory_log, strerror(errno));
1728             /*NOTREACHED*/
1729         }
1730     }
1731
1732     /* Suss what tape device we're using, whether there's a changer, etc. */
1733     if(!use_changer || (have_changer = changer_init()) == 0) {
1734         if(flags->alt_tapedev) cur_tapedev = stralloc(flags->alt_tapedev);
1735         else if(!cur_tapedev) cur_tapedev = getconf_str(CNF_TAPEDEV);
1736         /* XXX oughta complain if no config is loaded */
1737         fprintf(stderr, "%s: Using tapedev %s\n", get_pname(), cur_tapedev);
1738         have_changer = 0;
1739     } else if (have_changer != 1) {
1740         error("changer initialization failed: %s", strerror(errno));
1741         /*NOTREACHED*/
1742     }
1743     else{ /* good, the changer works, see what it can do */
1744         amfree(curslot);
1745         changer_info(&slots, &curslot, &backwards);
1746     }
1747
1748     if(tapelist && !flags->amidxtaped){
1749       slots = num_entries(tapelist);
1750       /*
1751         Spit out a list of expected tapes, so people with manual changers know
1752         what to load
1753       */
1754       fprintf(prompt_out, "The following tapes are needed:");
1755       for(desired_tape = tapelist; desired_tape != NULL;
1756           desired_tape = desired_tape->next){
1757         fprintf(prompt_out, " %s", desired_tape->label);
1758       }
1759       fprintf(prompt_out, "\n");
1760       fflush(prompt_out);
1761       if(flags->wait_tape_prompt){
1762         char *input = NULL;
1763         fprintf(prompt_out,"Press enter when ready\n");
1764         fflush(prompt_out);
1765         input = agets(prompt_in);
1766         amfree(input);
1767         fprintf(prompt_out, "\n");
1768         fflush(prompt_out);
1769       }
1770     }
1771     desired_tape = tapelist;
1772
1773     if(use_changer && !cur_tapedev) { /* load current slot */
1774         amfree(curslot);
1775         changer_loadslot("current", &curslot, &cur_tapedev);
1776     }
1777
1778     /*
1779      * If we're not given a tapelist, iterate over everything our changer can
1780      * find.  If there's no changer, we'll prompt to be handfed tapes.
1781      *
1782      * If we *are* given a tapelist, restore from those tapes in the order in
1783      * which they're listed.  Unless the changer (if we have one) can't go
1784      * backwards, in which case check every tape we see and restore from it if
1785      * appropriate.
1786      *
1787      * (obnoxious, isn't this?)
1788      */
1789
1790     do { /* all desired tape */
1791         seentapes_t *tape_seen = NULL;
1792         dumpfile_t file, tapestart, prev_rst_file;
1793         int isafile = 0;
1794         read_result = 0;
1795
1796         slot_num = 0;
1797
1798         memset(&file, 0, SIZEOF(file));
1799
1800         if (desired_tape && desired_tape->isafile) {
1801             isafile = 1;
1802             if ((tapefd = open(desired_tape->label, 0)) == -1) {
1803                 send_message(prompt_out, flags, their_features,
1804                              "could not open %s: %s",
1805                              desired_tape->label, strerror(errno));
1806                 continue;
1807             }
1808             fprintf(stderr, "Reading %s to fd %d\n",
1809                             desired_tape->label, tapefd);
1810
1811             read_result = read_file_header(&file, tapefd, 1, flags);
1812             label = stralloc(desired_tape->label);
1813         } else {
1814             /* check current_slot */
1815             label = label_of_current_slot(cur_tapedev, prompt_out,
1816                                           &tapefd, &file, flags,
1817                                           their_features, &read_result,
1818                                           desired_tape);
1819             while (label==NULL && slot_num < slots &&
1820                    use_changer) {
1821                 /*
1822                  * If we have an incorrect tape loaded, go try to find
1823                  * the right one
1824                  * (or just see what the next available one is).
1825                  */
1826                 slot = load_next_tape(&cur_tapedev, prompt_out,
1827                                       backwards, flags,
1828                                       their_features, desired_tape);
1829                 if(slot == LOAD_STOP) {
1830                     slot_num = slots;
1831                     amfree(label);
1832                 } else {
1833                     if (slot == LOAD_CHANGER)
1834                         slot_num = slots;
1835                     else /* slot > 0 */
1836                         slot_num += slot;
1837
1838                     /* check current_slot */
1839                     label = label_of_current_slot(cur_tapedev, prompt_out,
1840                                                   &tapefd, &file, flags,
1841                                                   their_features, &read_result,
1842                                                   desired_tape);
1843                 }
1844             }
1845
1846             if (label == NULL) {
1847                 ret = load_manual_tape(&cur_tapedev, prompt_out, prompt_in,
1848                                        flags,
1849                                        their_features, desired_tape);
1850                 if (ret == 0) {
1851                     label = label_of_current_slot(cur_tapedev, prompt_out,
1852                                                   &tapefd, &file, flags,
1853                                                   their_features, &read_result,
1854                                                   desired_tape);
1855                 }
1856             }
1857
1858             if (label)
1859                 memcpy(&tapestart, &file, SIZEOF(dumpfile_t));
1860         }
1861
1862         if (!label)
1863             continue;
1864
1865         /*
1866          * Skip this tape if we did it already.  Note that this would let
1867          * duplicate labels through, so long as they were in the same slot.
1868          * I'm over it, are you?
1869          */
1870         if (!isafile) {
1871             for (tape_seen = seentapes; tape_seen;
1872                  tape_seen = tape_seen->next) {
1873                 if (!strcmp(tape_seen->label, label) &&
1874                     !strcmp(tape_seen->slotstr, curslot)){
1875                     send_message(prompt_out, flags, their_features,
1876                                  "Saw repeat tape %s in slot %s",
1877                                  label, curslot);
1878                     amfree(label);
1879                     break;
1880                 }
1881             }
1882         }
1883
1884         if(!label)
1885             continue;
1886
1887         if(!curslot)
1888             curslot = stralloc("<none>");
1889
1890         if(!isafile){
1891             fprintf(stderr, "Scanning %s (slot %s)\n", label, curslot);
1892             fflush(stderr);
1893         }
1894
1895         tape_seen = alloc(SIZEOF(seentapes_t));
1896         memset(tape_seen, '\0', SIZEOF(seentapes_t));
1897
1898         tape_seen->label = label;
1899         tape_seen->slotstr = stralloc(curslot);
1900         tape_seen->next = seentapes;
1901         tape_seen->files = NULL;
1902         seentapes = tape_seen;
1903
1904         /*
1905          * Start slogging through the tape itself.  If our tapelist (if we
1906          * have one) contains a list of files to restore, obey that instead
1907          * of checking for matching headers on all files.
1908          */
1909
1910         search_a_tape(cur_tapedev, prompt_out, flags, their_features,
1911                       desired_tape, isafile, match_list, tape_seen,
1912                       &file, &prev_rst_file, &tapestart, slot_num,
1913                       &read_result);
1914
1915         fprintf(stderr, "%s: Search of %s complete\n",
1916                         get_pname(), tape_seen->label);
1917         if (desired_tape) desired_tape = desired_tape->next;
1918
1919         /* only restore a single dump, if piping to stdout */
1920         if (!headers_equal(&prev_rst_file, &file, 1) &&
1921             flags->pipe_to_fd == fileno(stdout))
1922                 break;
1923
1924     } while (desired_tape);
1925
1926     while (seentapes != NULL) {
1927         seentapes_t *tape_seen = seentapes;
1928         seentapes = seentapes->next;
1929         while(tape_seen->files != NULL) {
1930             dumplist_t *temp_dump = tape_seen->files;
1931             tape_seen->files = temp_dump->next;
1932             amfree(temp_dump->file);
1933             amfree(temp_dump);
1934         }
1935         amfree(tape_seen->label);
1936         amfree(tape_seen->slotstr);
1937         amfree(tape_seen);
1938
1939     }
1940
1941     if(logstream && logstream != stderr && logstream != stdout){
1942         fclose(logstream);
1943     }
1944     if(flags->delay_assemble || flags->inline_assemble){
1945         flush_open_outputs(1, NULL);
1946     }
1947     else flush_open_outputs(0, NULL);
1948 }
1949
1950 /*
1951  * Create a new, clean set of restore flags with some sane default values.
1952  */
1953 rst_flags_t *
1954 new_rst_flags(void)
1955 {
1956     rst_flags_t *flags = alloc(SIZEOF(rst_flags_t));
1957
1958     memset(flags, 0, SIZEOF(rst_flags_t));
1959
1960     flags->fsf = 1;
1961     flags->comp_type = COMPRESS_FAST_OPT;
1962     flags->inline_assemble = 1;
1963     flags->pipe_to_fd = -1;
1964     flags->check_labels = 1;
1965
1966     return(flags);
1967 }
1968
1969 /*
1970  * Make sure the set of restore options given is sane.  Print errors for
1971  * things that're odd, and return -1 for fatal errors.
1972  */
1973 int
1974 check_rst_flags(
1975     rst_flags_t *       flags)
1976 {
1977     int ret = 0;
1978
1979     if(!flags) return(-1);
1980
1981     if(flags->compress && flags->leave_comp){
1982         fprintf(stderr, "Cannot specify 'compress output' and 'leave compression alone' together\n");
1983         ret = -1;
1984     }
1985
1986     if(flags->restore_dir != NULL){
1987         struct stat statinfo;
1988
1989         if(flags->pipe_to_fd != -1){
1990             fprintf(stderr, "Specifying output directory and piping output are mutually exclusive\n");
1991             ret = -1;
1992         }
1993         if(stat(flags->restore_dir, &statinfo) < 0){
1994             fprintf(stderr, "Cannot stat restore target dir '%s': %s\n",
1995                       flags->restore_dir, strerror(errno));
1996             ret = -1;
1997         }
1998         if((statinfo.st_mode & S_IFMT) != S_IFDIR){
1999             fprintf(stderr, "'%s' is not a directory\n", flags->restore_dir);
2000             ret = -1;
2001         }
2002     }
2003
2004     if((flags->pipe_to_fd != -1 || flags->compress) &&
2005             (flags->delay_assemble || !flags->inline_assemble)){
2006         fprintf(stderr, "Split dumps *must* be automatically reassembled when piping output or compressing/uncompressing\n");
2007         ret = -1;
2008     }
2009
2010     if(flags->delay_assemble && flags->inline_assemble){
2011         fprintf(stderr, "Inline split assembling and delayed assembling are mutually exclusive\n");
2012         ret = -1;
2013     }
2014
2015     return(ret);
2016 }
2017
2018 /*
2019  * Clean up after a rst_flags_t
2020  */
2021 void
2022 free_rst_flags(
2023     rst_flags_t *       flags)
2024 {
2025     if(!flags) return;
2026
2027     amfree(flags->restore_dir);
2028     amfree(flags->alt_tapedev);
2029     amfree(flags->inventory_log);
2030
2031     amfree(flags);
2032 }
2033
2034
2035 /*
2036  * Clean up after a match_list_t
2037  */
2038 void
2039 free_match_list(
2040     match_list_t *      match_list)
2041 {
2042     match_list_t *me;
2043     match_list_t *prev = NULL;
2044
2045     for(me = match_list; me; me = me->next){
2046         /* XXX freeing these is broken? can't work out why */
2047 /*      amfree(me->hostname);
2048         amfree(me->diskname);
2049         amfree(me->datestamp);
2050         amfree(me->level); */
2051         amfree(prev);
2052         prev = me;
2053     }
2054     amfree(prev);
2055 }
2056
2057
2058 printf_arglist_function3(
2059     void send_message,
2060     FILE *, prompt_out,
2061     rst_flags_t *, flags,
2062     am_feature_t *, their_features,
2063     char *, format)
2064 {
2065     va_list argp;
2066     char linebuf[STR_SIZE];
2067
2068     arglist_start(argp, format);
2069     vsnprintf(linebuf, SIZEOF(linebuf)-1, format, argp);
2070     arglist_end(argp);
2071
2072     fprintf(stderr,"%s\n", linebuf);
2073     if (flags->amidxtaped && their_features &&
2074         am_has_feature(their_features, fe_amrecover_message)) {
2075         fprintf(prompt_out, "MESSAGE %s\r\n", linebuf);
2076         fflush(prompt_out);
2077     }
2078 }
2079