fileheader.c

开源备份软件源码 AMANDA, the Advanced Maryland Automatic Network Disk Archiver, is a backup system that a

	    if ( cmd3 == NULL) {
	      if (cmd2 == NULL) {
		strncpy(file->recover_cmd, cmd1,
			SIZEOF(file->recover_cmd) - 1);
	      } else {
		g_snprintf(file->uncompress_cmd,
			 SIZEOF(file->uncompress_cmd), "%s|", cmd1);
		strncpy(file->recover_cmd, cmd2,
			SIZEOF(file->recover_cmd) - 1);
	      }
	    } else {    /* cmd3 presents:  decrypt | uncompress | recover */
	      g_snprintf(file->decrypt_cmd,
		       SIZEOF(file->decrypt_cmd), "%s|", cmd1);
	      g_snprintf(file->uncompress_cmd,
		       SIZEOF(file->uncompress_cmd), "%s|", cmd2);
	      strncpy(file->recover_cmd, cmd3,
		      SIZEOF(file->recover_cmd) - 1);
	    }
	    continue;
	}
#undef SC
	/* XXX complain about weird lines? */
    }

out:
    amfree(buf);
    amfree(line1);
}

void
dump_dumpfile_t(
    const dumpfile_t *file)
{
	dbprintf(_("Contents of *(dumpfile_t *)%p:\n"), file);
	dbprintf(_("    type             = %d (%s)\n"),
			file->type, filetype2str(file->type));
	dbprintf(_("    datestamp        = '%s'\n"), file->datestamp);
	dbprintf(_("    dumplevel        = %d\n"), file->dumplevel);
	dbprintf(_("    compressed       = %d\n"), file->compressed);
	dbprintf(_("    encrypted        = %d\n"), file->encrypted);
	dbprintf(_("    comp_suffix      = '%s'\n"), file->comp_suffix);
	dbprintf(_("    encrypt_suffix   = '%s'\n"), file->encrypt_suffix);
	dbprintf(_("    name             = '%s'\n"), file->name);
	dbprintf(_("    disk             = '%s'\n"), file->disk);
	dbprintf(_("    program          = '%s'\n"), file->program);
	dbprintf(_("    dumper           = '%s'\n"), file->dumper);
	dbprintf(_("    srvcompprog      = '%s'\n"), file->srvcompprog);
	dbprintf(_("    clntcompprog     = '%s'\n"), file->clntcompprog);
	dbprintf(_("    srv_encrypt      = '%s'\n"), file->srv_encrypt);
	dbprintf(_("    clnt_encrypt     = '%s'\n"), file->clnt_encrypt);
	dbprintf(_("    recover_cmd      = '%s'\n"), file->recover_cmd);
	dbprintf(_("    uncompress_cmd   = '%s'\n"), file->uncompress_cmd);
	dbprintf(_("    encrypt_cmd      = '%s'\n"), file->encrypt_cmd);
	dbprintf(_("    decrypt_cmd      = '%s'\n"), file->decrypt_cmd);
	dbprintf(_("    srv_decrypt_opt  = '%s'\n"), file->srv_decrypt_opt);
	dbprintf(_("    clnt_decrypt_opt = '%s'\n"), file->clnt_decrypt_opt);
	dbprintf(_("    cont_filename    = '%s'\n"), file->cont_filename);
	dbprintf(_("    is_partial       = %d\n"), file->is_partial);
	dbprintf(_("    partnum          = %d\n"), file->partnum);
	dbprintf(_("    totalparts       = %d\n"), file->totalparts);
	dbprintf(_("    blocksize        = %zu\n"), file->blocksize);
}

static void
validate_name(
    const char *name)
{
	if (strlen(name) == 0) {
	    error(_("Invalid name '%s'\n"), name);
	    /*NOTREACHED*/
	}
}

static void
validate_datestamp(
    const char *datestamp)
{
	if (strcmp(datestamp, "X") == 0) {
	    return;
	}

	if ((strlen(datestamp) == 8) && match("^[0-9]{8}$", datestamp)) {
	    return;
	}
	if ((strlen(datestamp) == 14) && match("^[0-9]{14}$", datestamp)) {
	    return;
	}
	error(_("Invalid datestamp '%s'\n"), datestamp);
	/*NOTREACHED*/
}

static void
validate_parts(
    const int partnum,
    const int totalparts)
{
	if (partnum < 1) {
	    error(_("Invalid partnum (%d)\n"), partnum);
	    /*NOTREACHED*/
	}

	if (partnum > totalparts && totalparts >= 0) {
	    error(_("Invalid partnum (%d) > totalparts (%d)\n"),
			partnum, totalparts);
	    /*NOTREACHED*/
	}
}

char *
build_header(const dumpfile_t * file, size_t size)
{
    GString *rval, *split_data;
    char *qname;
    char *program;

    dbprintf(_("Building type %d (%s) header of size %zu using:\n"),
		file->type, filetype2str(file->type), size);
    dump_dumpfile_t(file);

    rval = g_string_sized_new(size);
    split_data = g_string_sized_new(10);
    
    switch (file->type) {
    case F_TAPESTART:
	validate_name(file->name);
	validate_datestamp(file->datestamp);
        g_string_printf(rval, 
                        "AMANDA: TAPESTART DATE %s TAPE %s\n014\n",
                        file->datestamp, file->name);
	break;
        
    case F_SPLIT_DUMPFILE:
	validate_parts(file->partnum, file->totalparts);
        g_string_printf(split_data,
                        " part %d/%d ", file->partnum, file->totalparts);
        /* FALLTHROUGH */
	

    case F_CONT_DUMPFILE:
    case F_DUMPFILE :
	validate_name(file->name);
	validate_datestamp(file->datestamp);
	qname = quote_string(file->disk);
	program = stralloc(file->program);
	if (match("^.*[.][Ee][Xx][Ee]$", program)) {
		/* Trim ".exe" from program name */
		program[strlen(program) - strlen(".exe")] = '\0';
	}
        g_string_printf(rval, 
                        "AMANDA: %s %s %s %s %s lev %d comp %s program %s",
                        filetype2str(file->type),
                        file->datestamp, file->name, qname,
                        split_data->str,
                        file->dumplevel, file->comp_suffix, program); 
	amfree(program);
	amfree(qname);

        /* only output crypt if it's enabled */
	if (strcmp(file->encrypt_suffix, "enc") == 0) {
            g_string_append_printf(rval, " crypt %s", file->encrypt_suffix);
	}

	if (*file->srvcompprog) {
            g_string_append_printf(rval, " server_custom_compress %s", 
                                   file->srvcompprog);
	} else if (*file->clntcompprog) {
            g_string_append_printf(rval, " client_custom_compress %s",
                                   file->clntcompprog);
	} 
        
	if (*file->srv_encrypt) {
            g_string_append_printf(rval, " server_encrypt %s",
                                   file->srv_encrypt);
	} else if (*file->clnt_encrypt) {
            g_string_append_printf(rval, " client_encrypt %s",
                                   file->clnt_encrypt);
	} 
        
	if (*file->srv_decrypt_opt) {
            g_string_append_printf(rval, " server_decrypt_option %s",
                                   file->srv_decrypt_opt);
        } else if (*file->clnt_decrypt_opt) {
            g_string_append_printf(rval, " client_decrypt_option %s",
                                   file->clnt_decrypt_opt);
	} 
        
        g_string_append_printf(rval, "\n");
        
	if (file->cont_filename[0] != '\0') {
            g_string_append_printf(rval, "CONT_FILENAME=%s\n",
                                   file->cont_filename);
	}
	if (file->dumper[0] != '\0') {
            g_string_append_printf(rval, "DUMPER=%s\n", file->dumper);
	}
	if (file->is_partial != 0) {
            g_string_append_printf(rval, "PARTIAL=YES\n");
	}
        
        g_string_append_printf(rval,
	    _("To restore, position tape at start of file and run:\n"));

	/* \014 == ^L == form feed */
        g_string_append_printf(rval,
                               "\tdd if=<tape> bs=%zuk skip=1 |%s %s %s\n\014\n",
                               file->blocksize / 1024,
                               file->decrypt_cmd, file->uncompress_cmd,
                               file->recover_cmd);
	break;

    case F_TAPEEND:
	validate_datestamp(file->datestamp);
        g_string_printf(rval, "AMANDA: TAPEEND DATE %s\n\014\n",
                        file->datestamp);
	break;

    case F_UNKNOWN:
    case F_EMPTY:
    case F_WEIRD:
    default:
	error(_("Invalid header type: %d (%s)"),
		file->type, filetype2str(file->type));
	/*NOTREACHED*/
    }
    
    g_string_free(split_data, TRUE);

    /* Since we don't return the length, it is an error for the header to be
     * more than 'size' bytes */
    assert(rval->len <= size);
    /* Clear extra bytes. */
    if (rval->len < size) {
        bzero(rval->str + rval->len, rval->allocated_len - rval->len);
    }
    return g_string_free(rval, FALSE);
}

/*
 * Prints the contents of the file structure.
 */
void
print_header(
    FILE *		outf,
    const dumpfile_t *	file)
{
    char *qdisk;
    char number[NUM_STR_SIZE*2];

    switch(file->type) {
    case F_EMPTY:
	g_fprintf(outf, _("EMPTY file\n"));
	break;

    case F_UNKNOWN:
	g_fprintf(outf, _("UNKNOWN file\n"));
	break;

    case F_WEIRD:
	g_fprintf(outf, _("WEIRD file\n"));
	break;

    case F_TAPESTART:
	g_fprintf(outf, _("start of tape: date %s label %s\n"),
	       file->datestamp, file->name);
	break;

    case F_DUMPFILE:
    case F_CONT_DUMPFILE:
	qdisk = quote_string(file->disk);
	g_fprintf(outf, "%s: date %s host %s disk %s lev %d comp %s",
	    filetype2str(file->type), file->datestamp, file->name,
	    qdisk, file->dumplevel, file->comp_suffix);
	if (*file->program)
	    g_fprintf(outf, " program %s", file->program);
	if (strcmp(file->encrypt_suffix, "enc") == 0)
	    g_fprintf(outf, " crypt %s", file->encrypt_suffix);
	if (*file->srvcompprog)
	    g_fprintf(outf, " server_custom_compress %s", file->srvcompprog);
	if (*file->clntcompprog)
	    g_fprintf(outf, " client_custom_compress %s", file->clntcompprog);
	if (*file->srv_encrypt)
	    g_fprintf(outf, " server_encrypt %s", file->srv_encrypt);
	if (*file->clnt_encrypt)
	    g_fprintf(outf, " client_encrypt %s", file->clnt_encrypt);
	if (*file->srv_decrypt_opt)
	    g_fprintf(outf, " server_decrypt_option %s", file->srv_decrypt_opt);
	if (*file->clnt_decrypt_opt)
	    g_fprintf(outf, " client_decrypt_option %s", file->clnt_decrypt_opt);
	g_fprintf(outf, "\n");
	amfree(qdisk);
	break;

    case F_SPLIT_DUMPFILE:
        if(file->totalparts > 0){
            g_snprintf(number, SIZEOF(number), "%d", file->totalparts);
        }   
        else g_snprintf(number, SIZEOF(number), "UNKNOWN");
	qdisk = quote_string(file->disk);
        g_fprintf(outf, "split dumpfile: date %s host %s disk %s part %d/%s lev %d comp %s",
                      file->datestamp, file->name, qdisk, file->partnum,
                      number, file->dumplevel, file->comp_suffix);
        if (*file->program)
            g_fprintf(outf, " program %s",file->program);
	if (strcmp(file->encrypt_suffix, "enc") == 0)
	    g_fprintf(outf, " crypt %s", file->encrypt_suffix);
	if (*file->srvcompprog)
	    g_fprintf(outf, " server_custom_compress %s", file->srvcompprog);
	if (*file->clntcompprog)
	    g_fprintf(outf, " client_custom_compress %s", file->clntcompprog);
	if (*file->srv_encrypt)
	    g_fprintf(outf, " server_encrypt %s", file->srv_encrypt);
	if (*file->clnt_encrypt)
	    g_fprintf(outf, " client_encrypt %s", file->clnt_encrypt);
	if (*file->srv_decrypt_opt)
	    g_fprintf(outf, " server_decrypt_option %s", file->srv_decrypt_opt);
	if (*file->clnt_decrypt_opt)
	    g_fprintf(outf, " client_decrypt_option %s", file->clnt_decrypt_opt);
        g_fprintf(outf, "\n");
	amfree(qdisk);
        break;

    case F_TAPEEND:
	g_fprintf(outf, "end of tape: date %s\n", file->datestamp);
	break;
    }
}

int
known_compress_type(
    const dumpfile_t *	file)
{
    if(strcmp(file->comp_suffix, ".Z") == 0)
	return 1;
#ifdef HAVE_GZIP
    if(strcmp(file->comp_suffix, ".gz") == 0)
	return 1;
#endif
    if(strcmp(file->comp_suffix, "cust") == 0)
	return 1;
    return 0;
}

static const struct {
    filetype_t type;
    const char *str;
} filetypetab[] = {
    { F_UNKNOWN, "UNKNOWN" },
    { F_WEIRD, "WEIRD" },
    { F_TAPESTART, "TAPESTART" },
    { F_TAPEEND,  "TAPEEND" },
    { F_DUMPFILE, "FILE" },
    { F_CONT_DUMPFILE, "CONT_FILE" },
    { F_SPLIT_DUMPFILE, "SPLIT_FILE" }
};
#define	NFILETYPES	(size_t)(sizeof(filetypetab) / sizeof(filetypetab[0]))

static const char *
filetype2str(
    filetype_t	type)
{
    int i;

    for (i = 0; i < (int)NFILETYPES; i++)
	if (filetypetab[i].type == type)
	    return (filetypetab[i].str);
    return ("UNKNOWN");
}

static filetype_t
str2filetype(
    const char *str)
{
    int i;

    for (i = 0; i < (int)NFILETYPES; i++)
	if (strcmp(filetypetab[i].str, str) == 0)
	    return (filetypetab[i].type);
    return (F_UNKNOWN);
}

gboolean headers_are_equal(dumpfile_t * a, dumpfile_t * b) {
    if (a == NULL && b == NULL)
        return TRUE;

    if (a == NULL || b == NULL)
        return FALSE;

    return 0 == memcmp(a, b, sizeof(*a));
}

dumpfile_t * dumpfile_copy(dumpfile_t* source) {
    gpointer rval = malloc(sizeof(dumpfile_t));
    memcpy(rval, source, sizeof(dumpfile_t));
    return rval;
}

/*
 * This function modify strtok context.
 */
static char *
strquotedstr(void)
{
    char *  tok = strtok(NULL, " ");
    size_t	len;

    len = strlen(tok);
    if ((tok != NULL) && (tok[0] == '"') &&
	(len > 1 && (tok[len - 1] != '"') && (tok[len - 2] != '\\'))) {
	char *	t;

	do {
	    t = strtok(NULL, " ");
	    tok[len] = ' ';
	    len = strlen(tok);
	} while ((t != NULL) &&
	         (tok[len - 1] != '"') && (tok[len - 2] != '\\'));
    }
    return tok;
}

static ssize_t
hexdump(
    const char *buffer,
    size_t	len)
{
    ssize_t rc = -1;

    FILE *stream = popen("od -c -x -", "w");
	
    if (stream != NULL) {
	fflush(stdout);
	rc = (ssize_t)fwrite(buffer, len, 1, stream);
	if (ferror(stream))
	    rc = -1;
	pclose(stream);
    }
    return rc;
}