/amanda/tags/amanda261p2/restore-src/restore.c

Large files files are truncated, but you can click here to view the full file

/*
 * Amanda, The Advanced Maryland Automatic Network Disk Archiver
 * Copyright (c) 1991-1998 University of Maryland at College Park
 * All Rights Reserved.
 *
 * Permission to use, copy, modify, distribute, and sell this software and its
 * documentation for any purpose is hereby granted without fee, provided that
 * the above copyright notice appear in all copies and that both that
 * copyright notice and this permission notice appear in supporting
 * documentation, and that the name of U.M. not be used in advertising or
 * publicity pertaining to distribution of the software without specific,
 * written prior permission.  U.M. makes no representations about the
 * suitability of this software for any purpose.  It is provided "as is"
 * without express or implied warranty.
 *
 * U.M. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL U.M.
 * BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
 * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
 * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 * Authors: the Amanda Development Team.  Its members are listed in a
 * file named AUTHORS, in the root directory of this distribution.
 */
/*
 * $Id: restore.c 6512 2007-05-24 17:00:24Z ian $
 *
 * retrieves files from an amanda tape
 */

#include "amanda.h"
#include "util.h"
#include "restore.h"
#include "find.h"
#include "changer.h"
#include "logfile.h"
#include "fileheader.h"
#include "arglist.h"
#include "cmdline.h"
#include "server_util.h"
#include <signal.h>
#include <timestamp.h>

#include <device.h>
#include <queueing.h>
#include <glib.h>

typedef enum {
    LOAD_NEXT = 1,     /* An unknown new slot has been loaded. */
    LOAD_CHANGER = -2, /* The requested slot has been loaded. */
    LOAD_STOP = -1,    /* The search is complete. */
} LoadStatus;

typedef enum {
    RESTORE_STATUS_NEXT_FILE,
    RESTORE_STATUS_NEXT_TAPE,
    RESTORE_STATUS_STOP
} RestoreFileStatus;

int file_number;

/* stuff we're stuck having global */
static int backwards;
static int exitassemble = 0;

char *rst_conf_logdir = NULL;
char *rst_conf_logfile = NULL;
static char *curslot = NULL;

typedef struct open_output_s {
    struct open_output_s *next;
    dumpfile_t *file;
    int lastpartnum;
    pid_t comp_enc_pid;
    int outfd;
} open_output_t;

typedef struct dumplist_s {
    struct dumplist_s *next;
    dumpfile_t *file;
} dumplist_t;

struct seentapes_s {
    struct seentapes_s *next;
    char *slotstr;
    char *label;
    dumplist_t *files;
};

static open_output_t *open_outputs = NULL;
static dumplist_t *alldumps_list = NULL;

/* local functions */

static void append_file_to_fd(char *filename, int fd);
static int headers_equal(dumpfile_t *file1, dumpfile_t *file2, int ignore_partnums);
static int already_have_dump(dumpfile_t *file);
static void handle_sigint(int sig);
static int scan_init(void *ud, int rc, int ns, int bk, int s);
static Device * conditional_device_open(char * tapedev, FILE * orompt_out,
                                        rst_flags_t * flags,
                                        am_feature_t * their_features,
                                        tapelist_t * desired_tape);
int loadlabel_slot(void *ud, int rc, char *slotstr, char *device);
char *label_of_current_slot(char *cur_tapedev, FILE *prompt_out,
			    int *tapefd, dumpfile_t *file, rst_flags_t *flags,
			    am_feature_t *their_features,
			    ssize_t *read_result, tapelist_t *desired_tape);

LoadStatus load_next_tape(char **cur_tapedev, FILE *prompt_out, int backwards,
		   rst_flags_t *flags, am_feature_t *their_features,
		   tapelist_t *desired_tape);
LoadStatus load_manual_tape(char **cur_tapedev, FILE *prompt_out, FILE *prompt_in,
		     rst_flags_t *flags, am_feature_t *their_features,
		     tapelist_t *desired_tape);

/*
 * We might want to flush any open dumps and unmerged splits before exiting
 * on SIGINT, so do so.
 */
static void
handle_sigint(
    int		sig)
{
    (void)sig;	/* Quiet unused parameter warning */

    flush_open_outputs(exitassemble, NULL);
    if (rst_conf_logfile) {
	unlink(rst_conf_logfile);
	log_add(L_INFO, "pid-done %ld\n", (long)getpid());
    }
    exit(0);
}

int
lock_logfile(void)
{
    rst_conf_logdir = config_dir_relative(getconf_str(CNF_LOGDIR));
    rst_conf_logfile = vstralloc(rst_conf_logdir, "/log", NULL);
    if (access(rst_conf_logfile, F_OK) == 0) {
	run_amcleanup(get_config_name());
    }
    if (access(rst_conf_logfile, F_OK) == 0) {
	char *process_name = get_master_process(rst_conf_logfile);
	dbprintf(_("%s exists: %s is already running, "
		  "or you must run amcleanup\n"), rst_conf_logfile,
		 process_name);
	amfree(process_name);
	return 0;
    }
    log_add(L_INFO, "%s", get_pname());
    return 1;
}

/*
 * Return 1 if the two fileheaders match in name, disk, type, split chunk part
 * number, and datestamp, and 0 if not.  The part number can be optionally
 * ignored.
 */
int
headers_equal(
    dumpfile_t *file1,
    dumpfile_t *file2,
    int		ignore_partnums)
{
    if(!file1 || !file2) return(0);
    
    if(file1->dumplevel == file2->dumplevel &&
	   file1->type == file2->type &&
	   !strcmp(file1->datestamp, file2->datestamp) &&
	   !strcmp(file1->name, file2->name) &&
	   !strcmp(file1->disk, file2->disk) &&
	   (ignore_partnums || file1->partnum == file2->partnum)){
	return(1);
    }
    return(0);
}


/*
 * See whether we're already pulled an exact copy of the given file (chunk
 * number and all).  Returns 0 if not, 1 if so.
 */
int
already_have_dump(
    dumpfile_t *file)
{
    dumplist_t *fileentry = NULL;

    if(!file) return(0);
    for(fileentry=alldumps_list;fileentry;fileentry=fileentry->next){
	if(headers_equal(file, fileentry->file, 0)) return(1);
    }
    return(0);
}

/*
 * Open the named file and append its contents to the (hopefully open) file
 * descriptor supplies.
 */
static void
append_file_to_fd(
    char *	filename,
    int		write_fd)
{
    queue_fd_t queue_fd_write = {write_fd, NULL};
    queue_fd_t queue_fd_read = {0, NULL};
    

    queue_fd_read.fd = robust_open(filename, O_RDONLY, 0);
    if (queue_fd_read.fd < 0) {
	error(_("can't open %s: %s"), filename, strerror(errno));
	/*NOTREACHED*/
    }

    if (!do_consumer_producer_queue(fd_read_producer, &queue_fd_read,
                                    fd_write_consumer, &queue_fd_write)) {
	if (queue_fd_read.errmsg && queue_fd_write.errmsg) {
	    error("Error copying data from file \"%s\" to fd %d: %s: %s.\n",
		  filename, queue_fd_write.fd, queue_fd_read.errmsg,
		  queue_fd_write.errmsg);
	} else if (queue_fd_read.errmsg) {
	    error("Error copying data from file \"%s\" to fd %d: %s.\n",
		  filename, queue_fd_write.fd, queue_fd_read.errmsg);
	} else if (queue_fd_write.errmsg) {
	    error("Error copying data from file \"%s\" to fd %d: %s.\n",
		  filename, queue_fd_write.fd, queue_fd_write.errmsg);
	} else {
	    error("Error copying data from file \"%s\" to fd %d.\n",
		  filename, queue_fd_write.fd);
	}
        g_assert_not_reached();
    }

    aclose(queue_fd_read.fd);
}

/* A user_init function for changer_find(). See changer.h for
   documentation. */
static int 
scan_init(G_GNUC_UNUSED void *	ud, int	rc, G_GNUC_UNUSED int ns,
          int bk, G_GNUC_UNUSED int s) {
    if(rc) {
        error(_("could not get changer info: %s"), changer_resultstr);
	/*NOTREACHED*/
    }
    backwards = bk;

    return 0;
}

typedef struct {
    char ** cur_tapedev;
    char * searchlabel;
    rst_flags_t *flags;
} loadlabel_data;

/* DANGER WILL ROBINSON: This function references globals:
          char * curslot;
 */
int
loadlabel_slot(void *	datap,
               int	rc,
               char *	slotstr,
               char *	device_name)
{
    loadlabel_data * data = (loadlabel_data*)datap;
    Device * device;
    DeviceStatusFlags device_status;

    g_return_val_if_fail(rc > 1 || device_name != NULL, 0);
    g_return_val_if_fail(slotstr != NULL, 0);

    amfree(curslot);

    if(rc > 1) {
        error(_("could not load slot %s: %s"), slotstr, changer_resultstr);
        g_assert_not_reached();
    }

    if(rc == 1) {
        g_fprintf(stderr, _("%s: slot %s: %s\n"),
                get_pname(), slotstr, changer_resultstr);
        return 0;
    } 
    
    device = device_open(device_name);
    g_assert(device != NULL);
    if (device->status != DEVICE_STATUS_SUCCESS) {
        g_fprintf(stderr, "%s: slot %s: Could not open device: %s.\n",
                get_pname(), slotstr, device_error(device));
        return 0;
    }

    if (!device_configure(device, TRUE)) {
        g_fprintf(stderr, "%s: slot %s: Error configuring device:\n"
                "%s: slot %s: %s\n",
                get_pname(), slotstr, get_pname(), slotstr, device_error_or_status(device));
        g_object_unref(device);
        return 0;
    }

    if (!set_restore_device_read_buffer_size(device, data->flags)) {
        g_fprintf(stderr, "%s: slot %s: Error setting read block size:\n"
                "%s: slot %s: %s\n",
                get_pname(), slotstr, get_pname(), slotstr, device_error_or_status(device));
        g_object_unref(device);
        return 0;
    }
    device_status = device_read_label(device);
    if (device_status != DEVICE_STATUS_SUCCESS) {
        g_fprintf(stderr, "%s: slot %s: Error reading tape label:\n"
                "%s: slot %s: %s\n",
                get_pname(), slotstr, get_pname(), slotstr, device_error_or_status(device));
        g_object_unref(device);
        return 0;
    }

    g_assert(device->volume_label != NULL);
    if (device->volume_label == NULL) {
        g_fprintf(stderr, "%s: slot %s: Could not read tape label.\n",
                get_pname(), slotstr);
        g_object_unref(device);
        return 0;
    }

    if (!device_start(device, ACCESS_READ, NULL, NULL)) {
        g_fprintf(stderr, "%s: slot %s: Could not open device for reading: %s.\n",
                get_pname(), slotstr, device_error(device));
        return 0;
    }

    g_fprintf(stderr, "%s: slot %s: time %-14s label %s",
            get_pname(), slotstr, device->volume_time, device->volume_label);

    if(strcmp(device->volume_label, data->searchlabel) != 0) {
        g_fprintf(stderr, " (wrong tape)\n");
        g_object_unref(device);
        return 0;
    }

    g_fprintf(stderr, " (exact label match)\n");

    g_object_unref(device);
    curslot = newstralloc(curslot, slotstr);
    amfree(*(data->cur_tapedev));
    *(data->cur_tapedev) = stralloc(device_name);
    return 1;
}


/* non-local functions follow */



/*
 * Check whether we've read all of the preceding parts of a given split dump,
 * generally used to see if we're done and can close the thing.
 */
int
have_all_parts (
    dumpfile_t *file,
    int		upto)
{
    int c;
    int *foundparts = NULL;
    dumplist_t *fileentry = NULL;

    if(!file || file->partnum < 1) return(0);

    if(upto < 1) upto = file->totalparts;

    foundparts = alloc(SIZEOF(*foundparts) * upto); 
    for(c = 0 ; c< upto; c++) foundparts[c] = 0;
    
    for(fileentry=alldumps_list;fileentry; fileentry=fileentry->next){
	dumpfile_t *cur_file = fileentry->file;
	if(headers_equal(file, cur_file, 1)){
	    if(cur_file->partnum > upto){
		amfree(foundparts);
		return(0);
	    }

	    foundparts[cur_file->partnum - 1] = 1;
	}
    }

    for(c = 0 ; c< upto; c++){
	if(!foundparts[c]){
	    amfree(foundparts);
	    return(0);
	}
    }
    
    amfree(foundparts);
    return(1);
}

/*
 * Free up the open filehandles and memory we were using to track in-progress
 * dumpfiles (generally for split ones we're putting back together).  If
 * applicable, also find the ones that are continuations of one another and
 * string them together.  If given an optional file header argument, flush
 * only that dump and do not flush/free any others.
 */
void
flush_open_outputs(
    int		reassemble,
    dumpfile_t *only_file)
{
    open_output_t *cur_out = NULL, *prev = NULL;
    find_result_t *sorted_files = NULL;
    amwait_t compress_status;

    if(!only_file){
	g_fprintf(stderr, "\n");
    }

    /*
     * Deal with any split dumps we've been working on, appending pieces
     * that haven't yet been appended and closing filehandles we've been
     * holding onto.
     */
    if(reassemble){
	find_result_t *cur_find_res = NULL;
	int outfd = -1, lastpartnum = -1;
	dumpfile_t *main_file = NULL;
	cur_out = open_outputs;
	
	/* stick the dumpfile_t's into a list find_result_t's so that we can
	   abuse existing sort functionality */
	for(cur_out=open_outputs; cur_out; cur_out=cur_out->next){
	    find_result_t *cur_find_res = NULL;
	    dumpfile_t *cur_file = cur_out->file;
	    /* if we requested a particular file, do only that one */
	    if(only_file && !headers_equal(cur_file, only_file, 1)){
		continue;
	    }
	    cur_find_res = alloc(SIZEOF(find_result_t));
	    memset(cur_find_res, '\0', SIZEOF(find_result_t));
	    cur_find_res->timestamp = stralloc(cur_file->datestamp);
	    cur_find_res->hostname = stralloc(cur_file->name);
	    cur_find_res->diskname = stralloc(cur_file->disk);
	    cur_find_res->level = cur_file->dumplevel;
	    if(cur_file->partnum < 1) cur_find_res->partnum = stralloc("--");
	    else{
		char part_str[NUM_STR_SIZE];
		g_snprintf(part_str, SIZEOF(part_str), "%d", cur_file->partnum);
		cur_find_res->partnum = stralloc(part_str);
	    }
	    cur_find_res->user_ptr = (void*)cur_out;

	    cur_find_res->next = sorted_files;
	    sorted_files = cur_find_res;
	}
	sort_find_result("hkdlp", &sorted_files);

	/* now we have an in-order list of the files we need to concatenate */
	cur_find_res = sorted_files;
	for(cur_find_res=sorted_files;
		cur_find_res;
		cur_find_res=cur_find_res->next){
	    dumpfile_t *cur_file = NULL;
	    cur_out = (open_output_t*)cur_find_res->user_ptr;
	    cur_file = cur_out->file;

	    /* if we requested a particular file, do only that one */
	    if(only_file && !headers_equal(cur_file, only_file, 1)){
		continue;
	    }

	    if(cur_file->type == F_SPLIT_DUMPFILE) {
		/* is it a continuation of one we've been writing? */
		if(main_file && cur_file->partnum > lastpartnum &&
			headers_equal(cur_file, main_file, 1)){
		    char *cur_filename;
		    char *main_filename;

		    /* effectively changing filehandles */
		    aclose(cur_out->outfd);
		    cur_out->outfd = outfd;

		    cur_filename  = make_filename(cur_file);
		    main_filename = make_filename(main_file);
		    g_fprintf(stderr, _("Merging %s with %s\n"),
		            cur_filename, main_filename);
		    append_file_to_fd(cur_filename, outfd);
		    if(unlink(cur_filename) < 0){
			g_fprintf(stderr, _("Failed to unlink %s: %s\n"),
			             cur_filename, strerror(errno));
		    }
		    amfree(cur_filename);
		    amfree(main_filename);
		}
		/* or a new file? */
		else {
		    if(outfd >= 0) aclose(outfd);
		    amfree(main_file);
		    main_file = alloc(SIZEOF(dumpfile_t));
		    memcpy(main_file, cur_file, SIZEOF(dumpfile_t));
		    outfd = cur_out->outfd;
		    if(outfd < 0) {
			char *cur_filename = make_filename(cur_file);
			open(cur_filename, O_RDWR|O_APPEND);
			if (outfd < 0) {
			  error(_("Couldn't open %s for appending: %s"),
			        cur_filename, strerror(errno));
			  /*NOTREACHED*/
			}
			amfree(cur_filename);
		    }
		}
		lastpartnum = cur_file->partnum;
	    }
	    else {
		aclose(cur_out->outfd);
	    }
	}
	if(outfd >= 0) {
	    aclose(outfd);
	}

	amfree(main_file);
	free_find_result(&sorted_files);
    }

    /*
     * Now that the split dump closure is done, free up resources we don't
     * need anymore.
     */
    for(cur_out=open_outputs; cur_out; cur_out=cur_out->next){
	dumpfile_t *cur_file = NULL;
	amfree(prev);
	cur_file = cur_out->file;
	/* if we requested a particular file, do only that one */
	if(only_file && !headers_equal(cur_file, only_file, 1)){
	    continue;
	}
	if(!reassemble) {
	    aclose(cur_out->outfd);
	}

	if(cur_out->comp_enc_pid > 0){
	    waitpid(cur_out->comp_enc_pid, &compress_status, 0);
	}
	amfree(cur_out->file);
	prev = cur_out;
    }

    open_outputs = NULL;
}

/*
 * Turn a fileheader into a string suited for use on the filesystem.
 */
char *
make_filename(
    dumpfile_t *file)
{
    char number[NUM_STR_SIZE];
    char part[NUM_STR_SIZE];
    char totalparts[NUM_STR_SIZE];
    char *sfn = NULL;
    char *fn = NULL;
    char *pad = NULL;
    size_t padlen = 0;

    g_snprintf(number, SIZEOF(number), "%d", file->dumplevel);
    g_snprintf(part, SIZEOF(part), "%d", file->partnum);

    if(file->totalparts < 0) {
	g_snprintf(totalparts, SIZEOF(totalparts), "UNKNOWN");
    }
    else {
	g_snprintf(totalparts, SIZEOF(totalparts), "%d", file->totalparts);
    }
    padlen = strlen(totalparts) + 1 - strlen(part);
    pad = alloc(padlen);
    memset(pad, '0', padlen);
    pad[padlen - 1] = '\0';

    g_snprintf(part, SIZEOF(part), "%s%d", pad, file->partnum);

    sfn = sanitise_filename(file->disk);
    fn = vstralloc(file->name,
		   ".",
		   sfn, 
		   ".",
		   file->datestamp,
		   ".",
		   number,
		   NULL);
    if (file->partnum > 0) {
	vstrextend(&fn, ".", part, NULL);
    }
    amfree(sfn);
    amfree(pad);
    return fn;
}

/* Returns 1 if the dump file matches the hostname and diskname
 * regular expressions given on the command line, 0 otherwise.  As a 
 * special case, empty regexs and NULLs are considered equivalent to 
 * ".*": they match everything.
 *
 * @param file: the file to examine
 * @param datestamp: the datestamp regex, or NULL for any
 * @param hostname: the hostname regex, or NULL for any
 * @param diskname: the diskname regex, or NULL for any
 * @param level: the level regex, or NULL for any
 * @returns: 1 if the dump file matches
 */
static int
disk_match(
    dumpfile_t *file,
    char *	datestamp,
    char *	hostname,
    char *	diskname,
    char *	level)
{
    char level_str[NUM_STR_SIZE];
    g_snprintf(level_str, SIZEOF(level_str), "%d", file->dumplevel);

    if(file->type != F_DUMPFILE && file->type != F_SPLIT_DUMPFILE) return 0;

    if((!hostname || *hostname == '\0' || match_host(hostname, file->name)) &&
       (!diskname || *diskname == '\0' || match_disk(diskname, file->disk)) &&
       (!datestamp || *datestamp == '\0' || match_datestamp(datestamp, file->datestamp)) &&
       (!level || *level == '\0' || match_level(level, level_str)))
	return 1;
    else
	return 0;
}

/*
 * Reads the first block of a holding disk file.
 */

static gboolean
read_holding_disk_header(
    dumpfile_t *       file,
    int                        tapefd,
    rst_flags_t *      flags)
{
    size_t bytes_read;
    char *buffer;
    size_t blocksize;

    if(flags->blocksize > 0)
        blocksize = (size_t)flags->blocksize;
    else
        blocksize = DISK_BLOCK_BYTES;
    buffer = alloc(blocksize);

    bytes_read = full_read(tapefd, buffer, blocksize);
    if(bytes_read < blocksize) {
	const char *errtxt;
	if(errno == 0)
	    errtxt = "Unexpected EOF";
	else
	    errtxt = strerror(errno);

	if (bytes_read == 0) {
	    g_fprintf(stderr, _("%s: missing file header block: %s\n"), 
		get_pname(), errtxt);
	} else {
	    g_fprintf(stderr,
		    plural(_("%s: short file header block: %zd byte: %s"),
	    		   _("%s: short file header block: %zd bytes: %s\n"),
			   bytes_read),
		    get_pname(), bytes_read, errtxt);
	}
	file->type = F_UNKNOWN;
    } else {
        parse_file_header(buffer, file, bytes_read);
    }
    amfree(buffer);
    return (file->type != F_UNKNOWN &&
            file->type != F_EMPTY &&
            file->type != F_WEIRD);
}

/*
 * Restore the current file from tape.  Depending on the settings of
 * the command line flags, the file might need to be compressed or
 * uncompressed.  If so, a pipe through compress or uncompress is set
 * up.  The final output usually goes to a file named host.disk.date.lev,
 * but with the -p flag the output goes to stdout (and presumably is
 * piped to restore).
 */


/* FIXME: Mondo function that needs refactoring. */
void restore(RestoreSource * source,
             rst_flags_t *	flags)
{
    int dest = -1, out;
    int file_is_compressed;
    int is_continuation = 0;
    int check_for_aborted = 0;
    char *tmp_filename = NULL, *final_filename = NULL;
    struct stat statinfo;
    open_output_t *free_myout = NULL, *myout = NULL, *oldout = NULL;
    dumplist_t *tempdump = NULL, *fileentry = NULL;
    char *buffer;
    int need_compress=0, need_uncompress=0, need_decrypt=0;
    int stage=0;
    struct pipeline {
        int	pipe[2];
    } pipes[3];
    char * filename;

    filename = make_filename(source->header);

    memset(pipes, -1, SIZEOF(pipes));

    if(already_have_dump(source->header)){
	g_fprintf(stderr, _(" *** Duplicate file %s, one is probably an aborted write\n"), filename);
	check_for_aborted = 1;
    }

    /* store a shorthand record of this dump */
    tempdump = malloc(SIZEOF(dumplist_t));
    tempdump->file = malloc(SIZEOF(dumpfile_t));
    tempdump->next = NULL;
    memcpy(tempdump->file, source->header, SIZEOF(dumpfile_t));

    /*
     * If we're appending chunked files to one another, and if this is a
     * continuation of a file we just restored, and we've still got the
     * output handle from that previous restore, we're golden.  Phew.
     */
    if(flags->inline_assemble && source->header->type == F_SPLIT_DUMPFILE){
	myout = open_outputs;
	while(myout != NULL){
	    if(myout->file->type == F_SPLIT_DUMPFILE &&
               headers_equal(source->header, myout->file, 1)){
		if(source->header->partnum == myout->lastpartnum + 1){
		    is_continuation = 1;
		    break;
		}
	    }
	    myout = myout->next;
	}
	if(myout != NULL) myout->lastpartnum = source->header->partnum;
	else if(source->header->partnum != 1){
	    g_fprintf(stderr, _("%s:      Chunk out of order, will save to disk and append to output.\n"), get_pname());
	    flags->pipe_to_fd = -1;
	    flags->compress = 0;
	    flags->leave_comp = 1;
	}
	if(myout == NULL){
	    free_myout = myout = alloc(SIZEOF(open_output_t));
	    memset(myout, 0, SIZEOF(open_output_t));
	}
    }
    else{
      free_myout = myout = alloc(SIZEOF(open_output_t));
      memset(myout, 0, SIZEOF(open_output_t));
    }


    if(is_continuation && flags->pipe_to_fd == -1){
	char *filename;
	filename = make_filename(myout->file);
	g_fprintf(stderr, _("%s:      appending to %s\n"), get_pname(),
		filename);
	amfree(filename);
    }

    /* adjust compression flag */
    file_is_compressed = source->header->compressed;
    if(!flags->compress && file_is_compressed &&
       !known_compress_type(source->header)) {
	g_fprintf(stderr, 
		_("%s: unknown compression suffix %s, can't uncompress\n"),
		get_pname(), source->header->comp_suffix);
	flags->compress = 1;
    }

    /* set up final destination file */

    if(is_continuation && myout != NULL) {
      out = myout->outfd;
    } else {
      if(flags->pipe_to_fd != -1) {
  	  dest = flags->pipe_to_fd;
      } else {
  	  char *filename_ext = NULL;
  
  	  if(flags->compress) {
  	      filename_ext = file_is_compressed ? source->header->comp_suffix
  	  				      : COMPRESS_SUFFIX;
  	  } else if(flags->raw) {
  	      filename_ext = ".RAW";
  	  } else {
  	      filename_ext = "";
  	  }
  	  filename_ext = stralloc2(filename, filename_ext);
	  tmp_filename = stralloc(filename_ext); 
	  if(flags->restore_dir != NULL) {
	      char *tmpstr = vstralloc(flags->restore_dir, "/",
	                               tmp_filename, NULL);
	      amfree(tmp_filename);
	      tmp_filename = tmpstr;
	  } 
	  final_filename = tmp_filename; 
	  tmp_filename = vstralloc(final_filename, ".tmp", NULL);
  	  if((dest = open(tmp_filename, (O_CREAT | O_RDWR | O_TRUNC),
			  CREAT_MODE)) < 0) {
  	      error(_("could not create output file %s: %s"),
	      	    tmp_filename, strerror(errno));
              /*NOTREACHED*/
	  }
  	  amfree(filename_ext);
      }
  
      out = dest;
    }

    /*
     * If -r or -h, write the header before compress or uncompress pipe.
     * Only write DISK_BLOCK_BYTES, regardless of how much was read.
     * This makes the output look like a holding disk image, and also
     * makes it easier to remove the header (e.g. in amrecover) since
     * it has a fixed size.
     */
    if(flags->raw || (flags->headers && !is_continuation)) {
	ssize_t     w;
	dumpfile_t  tmp_hdr;
	char       *dle_str;

	if(flags->compress && !file_is_compressed) {
	    source->header->compressed = 1;
	    g_snprintf(source->header->uncompress_cmd,
                     SIZEOF(source->header->uncompress_cmd),
		        " %s %s |", UNCOMPRESS_PATH,
#ifdef UNCOMPRESS_OPT
		        UNCOMPRESS_OPT
#else
		        ""
#endif
		        );
	    strncpy(source->header->comp_suffix,
		    COMPRESS_SUFFIX,
		    SIZEOF(source->header->comp_suffix)-1);
	    source->header->comp_suffix[SIZEOF(source->header->comp_suffix)-1]
                = '\0';
	}

	memcpy(&tmp_hdr, source->header, SIZEOF(dumpfile_t));

	/* remove CONT_FILENAME from header */
	memset(source->header->cont_filename, '\0',
               SIZEOF(source->header->cont_filename));
	dle_str = clean_dle_str_for_client(source->header->dle_str);
	source->header->dle_str = dle_str;
	source->header->blocksize = DISK_BLOCK_BYTES;

	/*
	 * Dumb down split file headers as well, so that older versions of
	 * things like amrecover won't gag on them.
	 */
	if(source->header->type == F_SPLIT_DUMPFILE && flags->mask_splits){
	    source->header->type = F_DUMPFILE;
	}

	buffer = alloc(DISK_BLOCK_BYTES);
	buffer = build_header(source->header, DISK_BLOCK_BYTES);

	if((w = full_write(out, buffer,
                          DISK_BLOCK_BYTES)) != DISK_BLOCK_BYTES) {
	    if(errno != 0) {
		error(_("write error: %s"), strerror(errno));
		/*NOTREACHED*/
	    } else {
		error(_("write error: %zd instead of %d"), w, DISK_BLOCK_BYTES);
		/*NOTREACHED*/
	    }
	}
	amfree(buffer);
	memcpy(source->header, &tmp_hdr, SIZEOF(dumpfile_t));
    }
 
    /* find out if compression or uncompression is needed here */
    if(flags->compress && !file_is_compressed && !is_continuation
	  && !flags->leave_comp
	  && (flags->inline_assemble ||
              source->header->type != F_SPLIT_DUMPFILE))
       need_compress=1;
       
    if(!flags->raw && !flags->compress && file_is_compressed
	  && !is_continuation && !flags->leave_comp && (flags->inline_assemble
	  || source->header->type != F_SPLIT_DUMPFILE))
       need_uncompress=1;   

    if(!flags->raw && source->header->encrypted && !is_continuation &&
       (flags->inline_assemble || source->header->type != F_SPLIT_DUMPFILE)) {
       need_decrypt=1;
    }
   
    /* Setup pipes for decryption / compression / uncompression  */
    stage = 0;
    if (need_decrypt) {
      if (pipe(&pipes[stage].pipe[0]) < 0) {
        error(_("error [pipe[%d]: %s]"), stage, strerror(errno));
	/*NOTREACHED*/
      }
      stage++;
    }

    if (need_compress || need_uncompress) {
      if (pipe(&pipes[stage].pipe[0]) < 0) {
        error(_("error [pipe[%d]: %s]"), stage, strerror(errno));
	/*NOTREACHED*/
      }
      stage++;
    }
    pipes[stage].pipe[0] = -1; 
    pipes[stage].pipe[1] = out; 

    stage = 0;

    /* decrypt first if it's encrypted and no -r */
    if(need_decrypt) {
      switch(myout->comp_enc_pid = fork()) {
      case -1:
	error(_("could not fork for decrypt: %s"), strerror(errno));
	/*NOTREACHED*/

      default:
	aclose(pipes[stage].pipe[0]);
	aclose(pipes[stage+1].pipe[1]);
        stage++;
	break;

      case 0:
	if(dup2(pipes[stage].pipe[0], 0) == -1) {
	    error(_("error decrypt stdin [dup2 %d %d: %s]"), stage,
	        pipes[stage].pipe[0], strerror(errno));
		/*NOTREACHED*/
	}

	if(dup2(pipes[stage+1].pipe[1], 1) == -1) {
	    error(_("error decrypt stdout [dup2 %d %d: %s]"), stage + 1,
	        pipes[stage+1].pipe[1], strerror(errno));
		/*NOTREACHED*/
	}

	safe_fd(-1, 0);
	if (source->header->srv_encrypt[0] != '\0') {
	  (void) execlp(source->header->srv_encrypt,
                        source->header->srv_encrypt,
			source->header->srv_decrypt_opt, NULL);
	  error("could not exec %s: %s",
                source->header->srv_encrypt, strerror(errno));
          g_assert_not_reached();
	}  else if (source->header->clnt_encrypt[0] != '\0') {
	  (void) execlp(source->header->clnt_encrypt,
                        source->header->clnt_encrypt,
			source->header->clnt_decrypt_opt, NULL);
	  error("could not exec %s: %s",
                source->header->clnt_encrypt, strerror(errno));
          g_assert_not_reached();
	}
      }
    }

    if (need_compress) {
        /*
         * Insert a compress pipe
         */
	switch(myout->comp_enc_pid = fork()) {
	case -1:
	    error(_("could not fork for %s: %s"), COMPRESS_PATH, strerror(errno));
	    /*NOTREACHED*/

	default:
	    aclose(pipes[stage].pipe[0]);
	    aclose(pipes[stage+1].pipe[1]);
            stage++;
	    break;

	case 0:
	    if(dup2(pipes[stage].pipe[0], 0) == -1) {
		error(_("error compress stdin [dup2 %d %d: %s]"), stage,
		  pipes[stage].pipe[0], strerror(errno));
	        /*NOTREACHED*/
	    }

	    if(dup2(pipes[stage+1].pipe[1], 1) == -1) {
		error(_("error compress stdout [dup2 %d %d: %s]"), stage + 1,
		  pipes[stage+1].pipe[1], strerror(errno));
		  /*NOTREACHED*/
	    }
	    if (*flags->comp_type == '\0') {
		flags->comp_type = NULL;
	    }

	    safe_fd(-1, 0);
	    (void) execlp(COMPRESS_PATH, COMPRESS_PATH, flags->comp_type, (char *)0);
	    error(_("could not exec %s: %s"), COMPRESS_PATH, strerror(errno));
	    /*NOTREACHED*/
	}
    } else if(need_uncompress) {
        /*
         * If not -r, -c, -l, and file is compressed, and split reassembly 
         * options are sane, insert uncompress pipe
         */

	/* 
	 * XXX for now we know that for the two compression types we
	 * understand, .Z and optionally .gz, UNCOMPRESS_PATH will take
	 * care of both.  Later, we may need to reference a table of
	 * possible uncompress programs.
	 */ 
	switch(myout->comp_enc_pid = fork()) {
	case -1: 
	    error(_("could not fork for %s: %s"),
		  UNCOMPRESS_PATH, strerror(errno));
	    /*NOTREACHED*/

	default:
	    aclose(pipes[stage].pipe[0]);
	    aclose(pipes[stage+1].pipe[1]);
            stage++;
	    break;

	case 0:
	    if(dup2(pipes[stage].pipe[0], 0) == -1) {
		error(_("error uncompress stdin [dup2 %d %d: %s]"), stage,
		  pipes[stage].pipe[0], strerror(errno));
	        /*NOTREACHED*/
	    }

	    if(dup2(pipes[stage+1].pipe[1], 1) == -1) {
		error(_("error uncompress stdout [dup2 %d %d: %s]"), stage + 1,
		  pipes[stage+1].pipe[1], strerror(errno));
	        /*NOTREACHED*/
	    }

	    safe_fd(-1, 0);
	    if (source->header->srvcompprog[0] != '\0') {
	      (void) execlp(source->header->srvcompprog,
                            source->header->srvcompprog, "-d", NULL);
	      error("could not exec %s: %s", source->header->srvcompprog,
                    strerror(errno));
              g_assert_not_reached();
	    } else if (source->header->clntcompprog[0] != '\0') {
	      (void) execlp(source->header->clntcompprog,
                            source->header->clntcompprog, "-d", NULL);
	      error("could not exec %s: %s", source->header->clntcompprog,
                    strerror(errno));
              g_assert_not_reached();
	    } else {
	      (void) execlp(UNCOMPRESS_PATH, UNCOMPRESS_PATH,
#ifdef UNCOMPRESS_OPT
			  UNCOMPRESS_OPT,
#endif
			  (char *)NULL);
	      error(_("could not exec %s: %s"), UNCOMPRESS_PATH, strerror(errno));
	      /*NOTREACHED*/
	    }
	}
    }

    /* copy the rest of the file from tape to the output */
    if (source->restore_mode == HOLDING_MODE) {
        dumpfile_t file;
	queue_fd_t queue_read = {source->u.holding_fd, NULL};
	queue_fd_t queue_write = {pipes[0].pipe[1], NULL};
        memcpy(& file, source->header, sizeof(file));
        for (;;) {
            do_consumer_producer_queue(fd_read_producer,
                                       &queue_read,
                                       fd_write_consumer,
                                       &queue_write);
	    /* TODO: Check error */
	    /*
	     * See if we need to switch to the next file in a holding restore
	     */
	    if(file.cont_filename[0] == '\0') {
		break;				/* no more files */
	    }
	    aclose(queue_read.fd);
	    if((queue_read.fd = open(file.cont_filename, O_RDONLY)) == -1) {
		char *cont_filename =
                    strrchr(file.cont_filename,'/');
		if(cont_filename) {
		    cont_filename++;
		    if((queue_read.fd = open(cont_filename,O_RDONLY)) == -1) {
			error(_("can't open %s: %s"), file.cont_filename,
			      strerror(errno));
		        /*NOTREACHED*/
		    }
		    else {
			g_fprintf(stderr, _("cannot open %s: %s\n"),
				file.cont_filename, strerror(errno));
			g_fprintf(stderr, _("using %s\n"),
				cont_filename);
		    }
		}
		else {
		    error(_("can't open %s: %s"), file.cont_filename,
			  strerror(errno));
		    /*NOTREACHED*/
		}
	    }
	    read_holding_disk_header(&file, queue_read.fd, flags);
	    if(file.type != F_DUMPFILE && file.type != F_CONT_DUMPFILE
		    && file.type != F_SPLIT_DUMPFILE) {
		g_fprintf(stderr, _("unexpected header type: "));
		print_header(stderr, source->header);
		exit(2);
	    }
	}            
    } else {
	queue_fd_t queue_fd = {pipes[0].pipe[1], NULL};
        device_read_to_fd(source->u.device, &queue_fd);
	/* TODO: Check error */
    }

    amfree(free_myout);
    if(!flags->inline_assemble) {
        if(out != dest)
	    aclose(out);
    }
    if(!is_continuation){
	if(tmp_filename && stat(tmp_filename, &statinfo) < 0){
	    error(_("Can't stat the file I just created (%s)!"), tmp_filename);
	    /*NOTREACHED*/
	} else {
	    statinfo.st_size = (off_t)0;
	}
	if (check_for_aborted && final_filename) {
	    char *old_dump = final_filename;
	    struct stat oldstat;
	    if(stat(old_dump, &oldstat) >= 0){
		if(oldstat.st_size <= statinfo.st_size){
		    dumplist_t *prev_fileentry = NULL;
		    open_output_t *prev_out = NULL;
		    g_fprintf(stderr, _("Newer restore is larger, using that\n"));
		    /* nuke the old dump's entry in alldump_list */
		    for(fileentry=alldumps_list;
			    fileentry->next;
			    fileentry=fileentry->next){
			if(headers_equal(source->header,
                                         fileentry->file, 0)){
			    if(prev_fileentry){
				prev_fileentry->next = fileentry->next;
			    }
			    else {
				alldumps_list = fileentry->next;
			    }
			    amfree(fileentry);
			    break;
			}
			prev_fileentry = fileentry;
		    }
		    myout = open_outputs;
		    while(myout != NULL){
			if(headers_equal(source->header, myout->file, 0)){
			    if(myout->outfd >= 0)
				aclose(myout->outfd);
			    if(prev_out){
				prev_out->next = myout->next;
			    }
			    else open_outputs = myout->next;
			    amfree(myout);
			    break;
			}
			prev_out = myout;
			myout = myout->next;
		    }
		}
		else{
		    g_fprintf(stderr, _("Older restore is larger, using that\n"));
		    if (tmp_filename)
			unlink(tmp_filename);
		    amfree(tempdump->file);
		    amfree(tempdump);
		    amfree(tmp_filename);
		    amfree(final_filename);
                    amfree(filename);
                    return;
		}
	    }
	}
	if(tmp_filename && final_filename &&
           rename(tmp_filename, final_filename) < 0) {
	    error(_("Can't rename %s to %s: %s"),
	    	   tmp_filename, final_filename, strerror(errno));
	    /*NOTREACHED*/
	}
    }
    amfree(tmp_filename);
    amfree(final_filename);


    /*
     * actually insert tracking data for this file into our various
     * structures (we waited in case we needed to give up)
     */
    if(!is_continuation){
        oldout = alloc(SIZEOF(open_output_t));
        oldout->file = alloc(SIZEOF(dumpfile_t));
        memcpy(oldout->file, source->header, SIZEOF(dumpfile_t));
        if(flags->inline_assemble) oldout->outfd = pipes[0].pipe[1];
	else oldout->outfd = -1;
        oldout->comp_enc_pid = -1;
        oldout->lastpartnum = source->header->partnum;
        oldout->next = open_outputs;
        open_outputs = oldout;
    }
    if(alldumps_list){
	fileentry = alldumps_list;
	while (fileentry->next != NULL)
	    fileentry=fileentry->next;
	fileentry->next = tempdump;
    }
    else {
	alldumps_list = tempdump;
    }
}

gboolean
set_restore_device_read_buffer_size(
    Device *device,
    rst_flags_t *flags)
{
    /* if the user specified a blocksize, try to use it */
    if (flags->blocksize) {
	GValue val;
	gboolean success;

	bzero(&val, sizeof(GValue));

	g_value_init(&val, G_TYPE_UINT);
	g_value_set_uint(&val, flags->blocksize);
	success = device_property_set(device, PROPERTY_READ_BUFFER_SIZE, &val);
	g_value_unset(&val);
	if (!success) {
	    if (device->status == DEVICE_STATUS_SUCCESS) {
		/* device doesn't have this property, so quietly ignore it */
		g_warning(_("Device %s does not support PROPERTY_READ_BUFFER_SIZE; ignoring block size %zd"),
			device->device_name, flags->blocksize);
	    } else {
		/* it's a real error */
		return FALSE;
	    }
	}
    }

    return TRUE;
}

/* return NULL if the label is not the expected one                     */
/* returns a Device handle if it is the expected one. */
/* FIXME: Was label_of_current_slot */
static Device *
conditional_device_open(char         *tapedev,
                        FILE         *prompt_out,
                        rst_flags_t  *flags,
                        am_feature_t *their_features,
                        tapelist_t   *desired_tape)
{
    Device * rval;

    if (tapedev == NULL) {
	send_message(prompt_out, flags, their_features,
		     _("Volume labeled '%s' not found."), desired_tape->label);
        return NULL;
    }

    rval = device_open(tapedev);
    g_assert(rval != NULL);
    if (rval->status != DEVICE_STATUS_SUCCESS) {
	send_message(prompt_out, flags, their_features, 
		     "Error opening device '%s': %s.",
		     tapedev, device_error(rval));
        g_object_unref(rval);
        return NULL;
    }

    if (!device_configure(rval, TRUE)) {
        g_fprintf(stderr, "Error configuring device: %s\n", device_error_or_status(rval));
        g_object_unref(rval);
        return NULL;
    }

    if (!set_restore_device_read_buffer_size(rval, flags)) {
	send_message(prompt_out, flags, their_features,
		     "Error setting read block size on '%s': %s.",
		     tapedev, device_error(rval));
        g_object_unref(rval);
        return NULL;
    }
    device_read_label(rval);

    if (rval->volume_label == NULL) {
	char *errstr = stralloc2("Not an amanda tape: ",
				 device_error(rval));
        send_message(prompt_out, flags, their_features, "%s", errstr);
	amfree(errstr);
        g_object_unref(rval);
        return NULL;
    }

    if (!device_start(rval, ACCESS_READ, NULL, NULL)) {
        send_message(prompt_out, flags, their_features,
                     "Colud not open device %s for reading: %s.\n",
                     tapedev, device_error(rval));
        return NULL;
    }

    if (flags->check_labels && desired_tape &&
        strcmp(rval->volume_label, desired_tape->label) != 0) {
        send_message(prompt_out, flags, their_features,
                     "Label mismatch, got %s and expected %s",
                     rval->volume_label, desired_tape->label);
        g_object_unref(rval);
        return NULL;
    }

    return rval;
}

/* Do the right thing to try and load the next required tape. See
   LoadStatus above for return value meaning. */
LoadStatus
load_next_tape(
    char         **cur_tapedev,
    FILE          *prompt_out,
    int            backwards,
    rst_flags_t   *flags,
    am_feature_t  *their_features,
    tapelist_t    *desired_tape)
{
    if (desired_tape) {
	send_message(prompt_out, flags, their_features,
		     _("Looking for tape %s..."),
		     desired_tape->label);
	if (backwards) {
            loadlabel_data data;
            data.cur_tapedev = cur_tapedev;
            data.searchlabel = desired_tape->label;
	    data.flags = flags;
	    changer_find(&data, scan_init, loadlabel_slot,
			 desired_tape->label);
            return LOAD_CHANGER;
	} else {
	    amfree(curslot);
	    changer_loadslot("next", &curslot,
			     cur_tapedev);
            return LOAD_NEXT;
	}
    } else {
	assert(!flags->amidxtaped);
	amfree(curslot);
	changer_loadslot("next", &curslot, cur_tapedev);
        return LOAD_NEXT;
    }

    g_assert_not_reached();
}


/* will never return LOAD_CHANGER. */
LoadStatus
load_manual_tape(
    char         **tapedev_ptr,
    FILE          *prompt_out,
    FILE          *prompt_in,
    rst_flags_t   *flags,
    am_feature_t  *their_features,
    tapelist_t    *desired_tape)
{
    char *input = NULL;

    if (flags->amidxtaped) {
	if (their_features &&
	    am_has_feature(their_features,
			   fe_amrecover_FEEDME)) {
	    g_fprintf(prompt_out, "FEEDME %s\r\n",
		    desired_tape->label);
	    fflush(prompt_out);
	    input = agets(prompt_in);/* Strips \n but not \r */
	    if(!input) {
		error(_("Connection lost with amrecover"));
		/*NOTREACHED*/
	    } else if (strcmp("OK\r", input) == 0) {
	    } else if (strncmp("TAPE ", input, 5) == 0) {
		amfree(*tapedev_ptr);
		*tapedev_ptr = alloc(1025);
		if (sscanf(input, "TAPE %1024s\r", *tapedev_ptr) != 1) {
		    error(_("Got bad response from amrecover: %s"), input);
		    /*NOTREACHED*/
		}
	    } else {
		send_message(prompt_out, flags, their_features,
			     _("Got bad response from amrecover: %s"), input);
		error(_("Got bad response from amrecover: %s"), input);
		/*NOTREACHED*/
	    }
	} else {
	    send_message(prompt_out, flags, their_features,
			 _("Client doesn't support fe_amrecover_FEEDME"));
	    error(_("Client doesn't support fe_amrecover_FEEDME"));
	    /*NOTREACHED*/
	}
    }
    else {
	if (desired_tape) {
	    g_fprintf(prompt_out,
		    _("Insert tape labeled %s in device %s \n"
		    "and press enter, ^D to finish reading tapes\n"),
		    desired_tape->label, *tapedev_ptr);
	} else {
	    g_fprintf(prompt_out,_("Insert a tape to search and press "
		    "enter, ^D to finish reading tapes\n"));
	}
	fflush(prompt_out);
	if((input = agets(prompt_in)) == NULL)
            return LOAD_STOP;
    }

    amfree(input);
    return LOAD_NEXT;
}

/* Search a seen-tapes list for a particular name, to see if we've already
 * processed this tape. Returns TRUE if this label has already been seen. */
static gboolean check_volume_seen(seentapes_t * list, char * label) {
    seentapes_t * cur_tape;
    for (cur_tape = list; cur_tape != NULL; cur_tape = cur_tape->next) {
        if (strcmp(cur_tape->label, label) == 0) {
            return TRUE;
        }
    }
    return FALSE;
}

/* Add a volume to the seen tapes list. */
static void record_seen_volume(seentapes_t ** list, char * label,
                               char * slotstr) {
    seentapes_t * new_entry;

    if (list == NULL)
        return;

    new_entry = malloc(sizeof(seentapes_t));
    new_entry->label = stralloc(label);
    if (slotstr == NULL) {
        new_entry->slotstr = NULL;
    } else {
        new_entry->slotstr = stralloc(slotstr);
    }
    new_entry->files = NULL;
    new_entry->next = *list;
    *list = new_entry;
}

/* Record a specific dump on a volume. */
static void record_seen_dump(seentapes_t * volume, dumpfile_t * header) {
    dumplist_t * this_dump;

    if (volume == NULL)
        return;
    
    this_dump = malloc(sizeof(*this_dump));
    this_dump->file = g_memdup(header, sizeof(*header));
    this_dump->next = NULL;
    if (volume->files) {
        dumplist_t * tmp_dump = volume->files;
        while (tmp_dump->next != NULL) {
            tmp_dump = tmp_dump->next;
        }
        tmp_dump->next = this_dump;
    } else {
        volume->files = this_dump;
    }
}

static void print_tape_inventory(FILE * logstream, seentapes_t * tape_seen,
                                 char * timestamp, char * label,
                                 int tape_count) {
    char * logline;
    dumplist_t * fileentry;

    logline = log_genstring(L_START, "taper",
                            "datestamp %s label %s tape %d",
                            timestamp, label, tape_count);
    fputs(logline, logstream);
    amfree(logline);
    for(fileentry=tape_seen->files; fileentry; fileentry=fileentry->next){
        switch (fileentry->file->type) {
        case F_DUMPFILE:
            logline = log_genstring(L_SUCCESS, "taper",
                                    "%s %s %s %d [faked log entry]",
                                    fileentry->file->name,
                                    fileentry->file->disk,
                                    fileentry->file->datestamp,
                                    fileentry->file->dumplevel);
            break;
        case F_SPLIT_DUMPFILE:
            logline = log_genstring(L_CHUNK, "taper", 
                                    "%s %s %s %d %d [faked log entry]",
                                    fileentry->file->name,
                                    fileentry->file->disk,
                                    fileentry->file->datestamp,
                                    fileentry->file->partnum,
                                    fileentry->file->dumplevel);
            break;
        default:
            break;
        }
        if(logline != NULL){
            fputs(logline, logstream);
            amfree(logline);
            fflush(logstream);
        }
    }
}

/* Check if the given header matches the given dumpspecs. Returns
   TRUE if dumpspecs is NULL and false if the header is NULL. Returns
   true if the header matches the  match list. */
static gboolean run_dumpspecs(GSList * dumpspecs,
                               dumpfile_t * header) {
    dumpspec_t *ds;

    if (dumpspecs == NULL)
        return TRUE;
    if (header == NULL)
        return FALSE;

    while (dumpspecs) {
	ds = (dumpspec_t *)dumpspecs->data;
        if (disk_match(header, ds->datestamp, ds->host,
                       ds->disk, ds->level) != 0) {
            return TRUE;
        }
	dumpspecs = dumpspecs->next;
    }

    return FALSE;
}

/* A wrapper around restore() above. This function does some extra
   checking to seek to the file in question and ensure that we really,
   really want to use it.

   The next_file argument provides instruction on what to do if the
   requested file does not exist on the volume: If next_file is NULL
   then if the requested file is missing the function will return
   RESTORE_STATUS_NEXT_FILE. If next_file is not NULL then the first
   extant file whose number is equal to or greater than file_num will
   be attempted. *next_file will be filled in with the number of the
   file following the one that was attempted. */
static RestoreFileStatus
try_restore_single_file(Device * device, int file_num, int* next_file,
                        FILE * prompt_out,
                        rst_flags_t * flags,
                        am_feature_t * their_features,
                        dumpfile_t * first_restored_file,
                        GSList * dumpspecs,
                        seentapes_t * tape_seen) {
    RestoreSource source;
    source.u.device = device;
    source.restore_mode = DEVICE_MODE;

    source.header = device_seek_file(device, file_num);

    if (source.header == NULL) {
        /* This definitely indicates an error. */
        send_message(prompt_out, flags, their_features,
                     "Could not seek device %s to file %d: %s.",
                     device->device_name, file_num,
		     device_error(device));
        return RESTORE_STATUS_NEXT_TAPE;
    } else if (source.header->type == F_TAPEEND) {
        amfree(source.header);
        return RESTORE_STATUS_NEXT_TAPE;
    } else if (device->file != file_num) {
        if (next_file == NULL) {
            send_message(prompt_out, flags, their_features,
                         "Requested file %d does not exist.",
                         file_num);
            return RESTORE_STATUS_NEXT_FILE;
        } else {
            send_message(prompt_out, flags, their_features,
                         "Skipped from file %d to file %d.", 
                         file_num, device->file);
            file_num = device->file;
        }
    }
    if (!am_has_feature(their_features, fe_amrecover_dle_in_header)) {
	source.header->dle_str = NULL;
    }

    if (next_file != NULL) {
        *next_file = file_num + 1;
    }
    
    g_return_val_if_fail(source.header->type == F_DUMPFILE ||
                         source.header->type == F_CONT_DUMPFILE ||
                         source.header->type == F_SPLIT_DUMPFILE,
                         RESTORE_STATUS_NEXT_FILE);
    

    if (!run_dumpspecs(dumpspecs, source.header)) {
	if(!flags->amidxtaped) {
            g_fprintf(prompt_out, "%s: %d: skipping ",
		    get_pname(), file_num);
            print_header(prompt_out, source.header);
	}
        return RESTORE_STATUS_NEXT_FILE;
    }

    if (first_restored_file != NULL &&
        first_restored_file->type != F_UNKNOWN &&
	first_restored_file->type != F_EMPTY &&
        !headers_equal(first_restored_file, source.header, 1) &&
        (flags->pipe_to_fd == fileno(stdout))) {
        return RESTORE_STATUS_STOP;
    }

    if (!flags->amidxtaped) {
	g_fprintf(stderr, "%s: %d: restoring ",
		get_pname(), file_num);
	print_header(stderr, source.header);
    }
    record_seen_dump(tape_seen, source.header);
    restore(&source, flags);
    if (first_restored_file) {
	memcpy(first_restored_file, source.header, sizeof(dumpfile_t));
    }
    return RESTORE_STATUS_NEXT_FILE;
}

/* This function handles processing of a particular tape or holding
   disk file. It returns TRUE if it is useful to load another tape.*/

gboolean
search_a_tape(Device      * device,
              FILE         *prompt_out, /* …