X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=server-src%2Fdumper.c;h=1e008601cf65cfa5fc137bc1baa6741087f29ccf;hb=refs%2Ftags%2Fupstream%2F2.5.0;hp=6afc7c052b0f6b10025c166aefce79b5e193572f;hpb=2df780bff19c457b0debb7adc29972a0bc2a5dc2;p=debian%2Famanda diff --git a/server-src/dumper.c b/server-src/dumper.c index 6afc7c0..1e00860 100644 --- a/server-src/dumper.c +++ b/server-src/dumper.c @@ -1,6 +1,6 @@ /* * Amanda, The Advanced Maryland Automatic Network Disk Archiver - * Copyright (c) 1991-1998 University of Maryland at College Park + * Copyright (c) 1991-1999 University of Maryland at College Park * All Rights Reserved. * * Permission to use, copy, modify, distribute, and sell this software and its @@ -23,7 +23,7 @@ * Authors: the Amanda Development Team. Its members are listed in a * file named AUTHORS, in the root directory of this distribution. */ -/* $Id: dumper.c,v 1.75.2.14.2.7.2.17.2.4 2005/09/20 21:31:52 jrjackson Exp $ +/* $Id: dumper.c,v 1.170 2006/03/22 15:10:52 martinea Exp $ * * requests remote amandad processes to dump filesystems */ @@ -32,23 +32,18 @@ #include "arglist.h" #include "clock.h" #include "conffile.h" +#include "event.h" #include "logfile.h" +#include "packet.h" #include "protocol.h" +#include "security.h" #include "stream.h" #include "token.h" #include "version.h" #include "fileheader.h" #include "amfeatures.h" #include "server_util.h" -#include "holding.h" - -#ifdef KRB4_SECURITY -#include "dumper-krb4.c" -#else -#define NAUGHTY_BITS_INITIALIZE /* I'd tell you what these do */ -#define NAUGHTY_BITS /* but then I'd have to kill you */ -#endif - +#include "util.h" #ifndef SEEK_SET #define SEEK_SET 0 @@ -59,133 +54,195 @@ #endif #define CONNECT_TIMEOUT 5*60 -#define MESGBUF_SIZE 4*1024 #define STARTUP_TIMEOUT 60 -int interactive; -char *handle = NULL; - -char databuf[DISK_BLOCK_BYTES]; -char mesgbuf[MESGBUF_SIZE+1]; -char *errstr = NULL; -char *datain; /* where to read in data */ -char *dataout; /* where to write out data */ -char *datalimit; /* end of the data area */ -int abort_pending; -long dumpsize; /* total size of dump */ -long dumpbytes; -long origsize; -long filesize; /* size of current holding disk file */ -int nb_header_block; -static enum { srvcomp_none, srvcomp_fast, srvcomp_best } srvcompress; +struct databuf { + int fd; /* file to flush to */ + char *buf; + char *datain; /* data buffer markers */ + char *dataout; + char *datalimit; + pid_t compresspid; /* valid if fd is pipe to compress */ + pid_t encryptpid; /* valid if fd is pipe to encrypt */ +}; + +static char *handle = NULL; + +static char *errstr = NULL; +static long dumpbytes; +static long dumpsize, headersize, origsize; + +static comp_t srvcompress = COMP_NONE; +char *srvcompprog = NULL; +char *clntcompprog = NULL; + +static encrypt_t srvencrypt = ENCRYPT_NONE; +char *srv_encrypt = NULL; +char *clnt_encrypt = NULL; +char *srv_decrypt_opt = NULL; +char *clnt_decrypt_opt = NULL; static FILE *errf = NULL; -char *filename = NULL; /* holding disk base file name */ -string_t cont_filename; -char *hostname = NULL; +static char *hostname = NULL; am_feature_t *their_features = NULL; -char *diskname = NULL; -char *device = NULL; -char *options = NULL; -char *progname = NULL; -int level; -char *dumpdate = NULL; -long chunksize; -long use; /* space remaining in this hold disk */ -char *datestamp; -char *backup_name = NULL; -char *recover_cmd = NULL; -char *compress_suffix = NULL; -int conf_dtimeout; - -dumpfile_t file; -int filename_seq; -long split_size; /* next dumpsize we will split at */ - -int datafd = -1; -int mesgfd = -1; -int indexfd = -1; -int amanda_port; +static char *diskname = NULL; +static char *device = NULL; +static char *options = NULL; +static char *progname = NULL; +static int level; +static char *dumpdate = NULL; +static char *datestamp; +static int conf_dtimeout; +static int indexfderror; + +static dumpfile_t file; + +static struct { + const char *name; + security_stream_t *fd; +} streams[] = { +#define DATAFD 0 + { "DATA", NULL }, +#define MESGFD 1 + { "MESG", NULL }, +#define INDEXFD 2 + { "INDEX", NULL }, +}; +#define NSTREAMS (sizeof(streams) / sizeof(streams[0])) static am_feature_t *our_features = NULL; static char *our_feature_string = NULL; /* local functions */ -int main P((int main_argc, char **main_argv)); -int do_dump P((int mesgfd, int datafd, int indexfd, int outfd)); -void check_options P((char *options)); -void service_ports_init P((void)); -int write_tapeheader P((int outfd, dumpfile_t *type)); -int write_dataptr P((int outf)); -int update_dataptr P((int *outf, int size)); +int main P((int, char **)); +static int do_dump P((struct databuf *)); +static void check_options P((char *)); +static void finish_tapeheader P((dumpfile_t *)); +static int write_tapeheader P((int, dumpfile_t *)); +static void databuf_init P((struct databuf *, int)); +static int databuf_write P((struct databuf *, const void *, int)); +static int databuf_flush P((struct databuf *)); static void process_dumpeof P((void)); -static void process_dumpline P((char *str)); -static void add_msg_data P((char *str, int len)); -static void log_msgout P((logtype_t typ)); -void sendbackup_response P((proto_t *p, pkt_t *pkt)); -int startup_dump P((char *hostname, char *disk, char *device, int level, - char *dumpdate, char *progname, char *options)); - - -void check_options(options) -char *options; -{ -#ifdef KRB4_SECURITY - krb4_auth = strstr(options, "krb4-auth;") != NULL; - kencrypt = strstr(options, "kencrypt;") != NULL; -#endif - if (strstr(options, "srvcomp-best;") != NULL) - srvcompress = srvcomp_best; +static void process_dumpline P((const char *)); +static void add_msg_data P((const char *, size_t)); +static void parse_info_line P((char *)); +static void log_msgout P((logtype_t)); + +static int runcompress P((int, pid_t *, comp_t)); +static int runencrypt P((int, pid_t *, encrypt_t)); + +static void sendbackup_response P((void *, pkt_t *, security_handle_t *)); +static int startup_dump P((const char *, const char *, const char *, int, + const char *, const char *, const char *)); +static void stop_dump P((void)); + +static void read_indexfd P((void *, void *, ssize_t)); +static void read_datafd P((void *, void *, ssize_t)); +static void read_mesgfd P((void *, void *, ssize_t)); +static void timeout P((int)); +static void timeout_callback P((void *)); + +static void +check_options(options) + char *options; +{ + char *compmode = NULL; + char *compend = NULL; + char *encryptmode = NULL; + char *encryptend = NULL; + char *decryptmode = NULL; + char *decryptend = NULL; + + /* parse the compression option */ + if (strstr(options, "srvcomp-best;") != NULL) + srvcompress = COMP_BEST; else if (strstr(options, "srvcomp-fast;") != NULL) - srvcompress = srvcomp_fast; - else - srvcompress = srvcomp_none; -} - -void service_ports_init() -{ - struct servent *amandad; - - if((amandad = getservbyname(AMANDA_SERVICE_NAME, "udp")) == NULL) { - amanda_port = AMANDA_SERVICE_DEFAULT; - log_add(L_WARNING, "no %s/udp service, using default port %d", - AMANDA_SERVICE_NAME, AMANDA_SERVICE_DEFAULT); + srvcompress = COMP_FAST; + else if ((compmode = strstr(options, "srvcomp-cust=")) != NULL) { + compend = strchr(compmode, ';'); + if (compend ) { + srvcompress = COMP_SERV_CUST; + *compend = '\0'; + srvcompprog = stralloc(compmode + strlen("srvcomp-cust=")); + *compend = ';'; + } + } else if ((compmode = strstr(options, "comp-cust=")) != NULL) { + compend = strchr(compmode, ';'); + if (compend) { + srvcompress = COMP_CUST; + *compend = '\0'; + clntcompprog = stralloc(compmode + strlen("comp-cust=")); + *compend = ';'; + } } - else - amanda_port = ntohs(amandad->s_port); - -#ifdef KRB4_SECURITY - if((amandad = getservbyname(KAMANDA_SERVICE_NAME, "udp")) == NULL) { - kamanda_port = KAMANDA_SERVICE_DEFAULT; - log_add(L_WARNING, "no %s/udp service, using default port %d", - KAMANDA_SERVICE_NAME, KAMANDA_SERVICE_DEFAULT); + else { + srvcompress = COMP_NONE; + } + + + /* now parse the encryption option */ + if ((encryptmode = strstr(options, "encrypt-serv-cust=")) != NULL) { + encryptend = strchr(encryptmode, ';'); + if (encryptend) { + srvencrypt = ENCRYPT_SERV_CUST; + *encryptend = '\0'; + srv_encrypt = stralloc(encryptmode + strlen("encrypt-serv-cust=")); + *encryptend = ';'; + } + } else if ((encryptmode = strstr(options, "encrypt-cust=")) != NULL) { + encryptend = strchr(encryptmode, ';'); + if (encryptend) { + srvencrypt = ENCRYPT_CUST; + *encryptend = '\0'; + clnt_encrypt = stralloc(encryptmode + strlen("encrypt-cust=")); + *encryptend = ';'; + } + } else { + srvencrypt = ENCRYPT_NONE; + } + /* get the decryption option parameter */ + if ((decryptmode = strstr(options, "server-decrypt-option=")) != NULL) { + decryptend = strchr(decryptmode, ';'); + if (decryptend) { + *decryptend = '\0'; + srv_decrypt_opt = stralloc(decryptmode + strlen("server-decrypt-option=")); + *decryptend = ';'; + } + } else if ((decryptmode = strstr(options, "client-decrypt-option=")) != NULL) { + decryptend = strchr(decryptmode, ';'); + if (decryptend) { + *decryptend = '\0'; + clnt_decrypt_opt = stralloc(decryptmode + strlen("client-decrypt-option=")); + *decryptend = ';'; + } } - else - kamanda_port = ntohs(amandad->s_port); -#endif } -int main(main_argc, main_argv) -int main_argc; -char **main_argv; +int +main(main_argc, main_argv) + int main_argc; + char **main_argv; { + static struct databuf db; struct cmdargs cmdargs; cmd_t cmd; - int outfd, protocol_port, taper_port, rc; - dgram_t *msg; + int outfd = -1; + int taper_port, rc; unsigned long malloc_hist_1, malloc_size_1; unsigned long malloc_hist_2, malloc_size_2; char *conffile; char *q = NULL; - char *tmp_filename = NULL, *pc; int a; safe_fd(-1, 0); set_pname("dumper"); + /* Don't die when child closes pipe */ + signal(SIGPIPE, SIG_IGN); + malloc_size_1 = malloc_inuse(&malloc_hist_1); erroutput_type = (ERR_AMANDALOG|ERR_INTERACTIVE); @@ -217,42 +274,37 @@ char **main_argv; } amfree(conffile); - /* set up dgram port first thing */ - - msg = dgram_alloc(); - if(dgram_bind(msg, &protocol_port) == -1) - error("could not bind result datagram port: %s", strerror(errno)); - + /* + * Make our effective uid nonprivlidged, but keep our real uid as root + * in case we need to get back (to bind privlidged ports, etc). + */ if(geteuid() == 0) { - /* set both real and effective uid's to real uid, likewise for gid */ + uid_t ruid = getuid(); + setuid(0); + seteuid(ruid); setgid(getgid()); - setuid(getuid()); } -#ifdef BSD_SECURITY +#if defined BSD_SECURITY && !defined SSH_SECURITY else error("must be run setuid root to communicate correctly"); #endif fprintf(stderr, - "%s: pid %ld executable %s version %s, using port %d\n", + "%s: pid %ld executable %s version %s\n", get_pname(), (long) getpid(), - main_argv[0], version(), protocol_port); + main_argv[0], version()); fflush(stderr); /* now, make sure we are a valid user */ - if(getpwuid(getuid()) == NULL) + if (getpwuid(getuid()) == NULL) error("can't get login name for my uid %ld", (long)getuid()); signal(SIGPIPE, SIG_IGN); - interactive = isatty(0); - - amfree(datestamp); datestamp = construct_datestamp(NULL); conf_dtimeout = getconf_int(CNF_DTIMEOUT); - service_ports_init(); - proto_init(msg->socket, time(0), 16); + protocol_init(); do { cmd = getcmd(&cmdargs); @@ -260,158 +312,6 @@ char **main_argv; switch(cmd) { case QUIT: break; - case FILE_DUMP: - /* - * FILE-DUMP - * handle - * filename - * host - * features - * disk - * device - * level - * dumpdate - * chunksize - * progname - * use - * options - */ - cmdargs.argc++; /* true count of args */ - a = 2; - - if(a >= cmdargs.argc) { - error("error [dumper FILE-DUMP: not enough args: handle]"); - } - handle = newstralloc(handle, cmdargs.argv[a++]); - - if(a >= cmdargs.argc) { - error("error [dumper FILE-DUMP: not enough args: filename]"); - } - filename = newstralloc(filename, cmdargs.argv[a++]); - - if(a >= cmdargs.argc) { - error("error [dumper FILE-DUMP: not enough args: hostname]"); - } - hostname = newstralloc(hostname, cmdargs.argv[a++]); - - if(a >= cmdargs.argc) { - error("error [dumper FILE-DUMP: not enough args: features]"); - } - am_release_feature_set(their_features); - their_features = am_string_to_feature(cmdargs.argv[a++]); - - if(a >= cmdargs.argc) { - error("error [dumper FILE-DUMP: not enough args: diskname]"); - } - diskname = newstralloc(diskname, cmdargs.argv[a++]); - - if(a >= cmdargs.argc) { - error("error [dumper FILE-DUMP: not enough args: device]"); - } - device = newstralloc(device, cmdargs.argv[a++]); - if(strcmp(device, "NODEVICE") == 0) amfree(device); - - if(a >= cmdargs.argc) { - error("error [dumper FILE-DUMP: not enough args: level]"); - } - level = atoi(cmdargs.argv[a++]); - - if(a >= cmdargs.argc) { - error("error [dumper FILE-DUMP: not enough args: dumpdate]"); - } - dumpdate = newstralloc(dumpdate, cmdargs.argv[a++]); - - if(a >= cmdargs.argc) { - error("error [dumper FILE-DUMP: not enough args: chunksize]"); - } - chunksize = am_floor(atoi(cmdargs.argv[a++]), DISK_BLOCK_KB); - - if(a >= cmdargs.argc) { - error("error [dumper FILE-DUMP: not enough args: progname]"); - } - progname = newstralloc(progname, cmdargs.argv[a++]); - - if(a >= cmdargs.argc) { - error("error [dumper FILE-DUMP: not enough args: use]"); - } - use = am_floor(atoi(cmdargs.argv[a++]), DISK_BLOCK_KB); - - if(a >= cmdargs.argc) { - error("error [dumper FILE-DUMP: not enough args: options]"); - } - options = newstralloc(options, cmdargs.argv[a++]); - - if(a != cmdargs.argc) { - error("error [dumper FILE-DUMP: too many args: %d != %d]", - cmdargs.argc, a); - } - - cont_filename[0] = '\0'; - - tmp_filename = newvstralloc(tmp_filename, filename, ".tmp", NULL); - pc = strrchr(tmp_filename, '/'); - *pc = '\0'; - mkholdingdir(tmp_filename); - *pc = '/'; - outfd = open(tmp_filename, O_RDWR|O_CREAT|O_TRUNC, 0600); - if(outfd == -1) { - int save_errno = errno; - q = squotef("[main holding file \"%s\": %s]", - tmp_filename, strerror(errno)); - if(save_errno == ENOSPC) { - putresult(NO_ROOM, "%s %lu\n", handle, use); - putresult(TRYAGAIN, "%s %s\n", handle, q); - } - else { - putresult(FAILED, "%s %s\n", handle, q); - } - amfree(q); - break; - } - filename_seq = 1; - - check_options(options); - - rc = startup_dump(hostname, - diskname, - device, - level, - dumpdate, - progname, - options); - if(rc) { - q = squote(errstr); - putresult(rc == 2? FAILED : TRYAGAIN, "%s %s\n", - handle, q); - if(rc == 2) { - log_add(L_FAIL, "%s %s %s %d [%s]", hostname, diskname, - datestamp, level, errstr); - } - amfree(q); - /* do need to close if TRY-AGAIN, doesn't hurt otherwise */ - if (mesgfd != -1) - aclose(mesgfd); - if (datafd != -1) - aclose(datafd); - if (indexfd != -1) - aclose(indexfd); - if (outfd != -1) - aclose(outfd); - break; - } - - abort_pending = 0; - split_size = (chunksize>use)?use:chunksize; - use -= split_size; - if(do_dump(mesgfd, datafd, indexfd, outfd)) { - } - aclose(mesgfd); - aclose(datafd); - if (indexfd != -1) - aclose(indexfd); - aclose(outfd); - if(abort_pending) putresult(ABORT_FINISHED, "%s\n", handle); - break; case PORT_DUMP: /* @@ -436,12 +336,12 @@ char **main_argv; handle = newstralloc(handle, cmdargs.argv[a++]); if(a >= cmdargs.argc) { - error("error [dumper PORT-DUMP: not enough args: port]"); + error("error [dumper PORT-DUMP: not enough args: handle]"); } taper_port = atoi(cmdargs.argv[a++]); if(a >= cmdargs.argc) { - error("error [dumper PORT-DUMP: not enough args: hostname]"); + error("error [dumper PORT-DUMP: not enough args: handle]"); } hostname = newstralloc(hostname, cmdargs.argv[a++]); @@ -452,33 +352,33 @@ char **main_argv; their_features = am_string_to_feature(cmdargs.argv[a++]); if(a >= cmdargs.argc) { - error("error [dumper PORT-DUMP: not enough args: diskname]"); + error("error [dumper PORT-DUMP: not enough args: handle]"); } diskname = newstralloc(diskname, cmdargs.argv[a++]); if(a >= cmdargs.argc) { - error("error [dumper PORT-DUMP: not enough args: device]"); + error("error [dumper PORT-DUMP: not enough args: handle]"); } device = newstralloc(device, cmdargs.argv[a++]); if(strcmp(device,"NODEVICE") == 0) amfree(device); if(a >= cmdargs.argc) { - error("error [dumper PORT-DUMP: not enough args: level]"); + error("error [dumper PORT-DUMP: not enough args: handle]"); } level = atoi(cmdargs.argv[a++]); if(a >= cmdargs.argc) { - error("error [dumper PORT-DUMP: not enough args: dumpdate]"); + error("error [dumper PORT-DUMP: not enough args: handle]"); } dumpdate = newstralloc(dumpdate, cmdargs.argv[a++]); if(a >= cmdargs.argc) { - error("error [dumper PORT-DUMP: not enough args: progname]"); + error("error [dumper PORT-DUMP: not enough args: handle]"); } progname = newstralloc(progname, cmdargs.argv[a++]); if(a >= cmdargs.argc) { - error("error [dumper PORT-DUMP: not enough args: options]"); + error("error [dumper PORT-DUMP: not enough args: handle]"); } options = newstralloc(options, cmdargs.argv[a++]); @@ -487,20 +387,17 @@ char **main_argv; cmdargs.argc, a); } - filename = newstralloc(filename, ""); - cont_filename[0] = '\0'; - /* connect outf to taper port */ outfd = stream_client("localhost", taper_port, - STREAM_BUFSIZE, -1, NULL); - if(outfd == -1) { + STREAM_BUFSIZE, -1, NULL, 0); + if (outfd == -1) { q = squotef("[taper port open: %s]", strerror(errno)); putresult(FAILED, "%s %s\n", handle, q); amfree(q); break; } - filename_seq = 1; + databuf_init(&db, outfd); check_options(options); @@ -511,37 +408,18 @@ char **main_argv; dumpdate, progname, options); - if(rc) { + if (rc != 0) { q = squote(errstr); putresult(rc == 2? FAILED : TRYAGAIN, "%s %s\n", - handle, q); - if(rc == 2) { + handle, q); + if (rc == 2) log_add(L_FAIL, "%s %s %s %d [%s]", hostname, diskname, - datestamp, level, errstr); - } + datestamp, level, errstr); amfree(q); - /* do need to close if TRY-AGAIN, doesn't hurt otherwise */ - if (mesgfd != -1) - aclose(mesgfd); - if (datafd != -1) - aclose(datafd); - if (indexfd != -1) - aclose(indexfd); - if (outfd != -1) - aclose(outfd); - break; - } - - abort_pending = 0; - split_size = -1; - if(do_dump(mesgfd, datafd, indexfd, outfd)) { + } else { + if (do_dump(&db)) { + } } - aclose(mesgfd); - aclose(datafd); - if (indexfd != -1) - aclose(indexfd); - aclose(outfd); - if(abort_pending) putresult(ABORT_FINISHED, "%s\n", handle); break; default: @@ -554,372 +432,202 @@ char **main_argv; } putresult(BAD_COMMAND, "%s\n", q); amfree(q); + break; } - while(wait(NULL) != -1); + + if (outfd != -1) + aclose(outfd); } while(cmd != QUIT); - amfree(tmp_filename); amfree(errstr); - amfree(msg); amfree(datestamp); - amfree(backup_name); - amfree(recover_cmd); - amfree(compress_suffix); amfree(handle); - amfree(filename); amfree(hostname); amfree(diskname); amfree(device); amfree(dumpdate); amfree(progname); + amfree(srvcompprog); + amfree(clntcompprog); + amfree(srv_encrypt); + amfree(clnt_encrypt); + amfree(srv_decrypt_opt); + amfree(clnt_decrypt_opt); amfree(options); amfree(config_dir); amfree(config_name); - amfree(our_feature_string); - am_release_feature_set(our_features); - our_features = NULL; - am_release_feature_set(their_features); - their_features = NULL; malloc_size_2 = malloc_inuse(&malloc_hist_2); - if(malloc_size_1 != malloc_size_2) { + if (malloc_size_1 != malloc_size_2) malloc_list(fileno(stderr), malloc_hist_1, malloc_hist_2); - } - return 0; + exit(0); } -int write_dataptr(outf) -int outf; +/* + * Initialize a databuf. Takes a writeable file descriptor. + */ +static void +databuf_init(db, fd) + struct databuf *db; + int fd; { - int w; - int written; - written = w = 0; - while(dataout < datain) { - if((w = write(outf, dataout, datain - dataout)) < 0) { - break; - } - dataout += w; - written += w; - } - dumpbytes += written; - dumpsize += (dumpbytes / 1024); - filesize += (dumpbytes / 1024); - dumpbytes %= 1024; - if(w < 0) { - if(errno != ENOSPC) { - errstr = squotef("data write: %s", strerror(errno)); - return 1; - } - /* - * NO-ROOM is informational only. Later, RQ_MORE_DISK will be - * issued to use another holding disk. - */ - putresult(NO_ROOM, "%s %lu\n", handle, use+split_size-dumpsize); - use = 0; /* force RQ_MORE_DISK */ - split_size = dumpsize; - } - if(dataout == datain) { - /* - * We flushed the whole buffer so reset to use it all. - */ - dataout = datain = databuf; - } - return 0; + db->fd = fd; + db->datain = db->dataout = db->datalimit = NULL; + db->compresspid = -1; + db->encryptpid = -1; } -int update_dataptr(p_outfd, size) -int *p_outfd, size; + /* * Updates the buffer pointer for the input data buffer. The buffer is - * written if it is full or we are at EOF. + * written regardless of how much data is present, since we know we + * are writing to a socket (to chunker) and there is no need to maintain + * any boundaries. */ +static int +databuf_write(db, buf, size) + struct databuf *db; + const void *buf; + int size; { - int outfd = *p_outfd; - int rc = 0; - char *arg_filename = NULL; - char *new_filename = NULL; - char *tmp_filename = NULL; - char *pc; - char sequence[NUM_STR_SIZE]; - int new_outfd = -1; - struct cmdargs cmdargs; - cmd_t cmd; - filetype_t save_type; - long left_in_chunk; - int a; - char *q; - - datain += size; - - while(rc == 0 && ((size == 0 && dataout < datain) || datain >= datalimit)) { - - NAUGHTY_BITS; - - /* We open a new chunkfile if */ - /* We have something to write (dataout < datain) */ - /* We have a split_size defined (split_size > 0) */ - /* The current file is already filled (dumpsize >= split_size) */ - - while(dataout < datain && split_size > 0 && dumpsize >= split_size) { - amfree(new_filename); - if(use == 0) { - /* - * Probably no more space on this disk. Request more. - */ - putresult(RQ_MORE_DISK, "%s\n", handle); - cmd = getcmd(&cmdargs); - if(cmd == CONTINUE) { - /* - * CONTINUE - * serial - * filename - * chunksize - * use - */ - cmdargs.argc++; /* true count of args */ - a = 3; - - if(a >= cmdargs.argc) { - error("error [dumper CONTINUE: not enough args: filename]"); - } - arg_filename = newstralloc(arg_filename, cmdargs.argv[a++]); - - if(a >= cmdargs.argc) { - error("error [dumper CONTINUE: not enough args: chunksize]"); - } - chunksize = atoi(cmdargs.argv[a++]); - chunksize = am_floor(chunksize, DISK_BLOCK_KB); - - if(a >= cmdargs.argc) { - error("error [dumper CONTINUE: not enough args: use]"); - } - use = atoi(cmdargs.argv[a++]); - - if(a != cmdargs.argc) { - error("error [dumper CONTINUE: too many args: %d != %d]", - cmdargs.argc, a); - } - - if(strcmp(filename, arg_filename) == 0) { - /* - * Same disk, so use what room is left up to the - * next chunk boundary or the amount we were given, - * whichever is less. - */ - left_in_chunk = chunksize - filesize; - if(left_in_chunk > use) { - split_size += use; - use = 0; - } else { - split_size += left_in_chunk; - use -= left_in_chunk; - } - if(left_in_chunk > 0) { - /* - * We still have space in this chunk. - */ - break; - } - } else { - /* - * Different disk, so use new file. - */ - filename = newstralloc(filename, arg_filename); - } - } else if(cmd == ABORT) { - abort_pending = 1; - errstr = newstralloc(errstr, "ERROR"); - rc = 1; - goto common_exit; - } else { - if(cmdargs.argc >= 1) { - q = squote(cmdargs.argv[1]); - } else if(cmdargs.argc >= 0) { - q = squote(cmdargs.argv[0]); - } else { - q = stralloc("(no input?)"); - } - error("error [bad command after RQ-MORE-DISK: \"%s\"]", q); - } - } + db->buf = (char *)buf; + db->datain = db->datalimit = db->buf + size; + db->dataout = db->buf; + return databuf_flush(db); +} - ap_snprintf(sequence, sizeof(sequence), "%d", filename_seq); - new_filename = newvstralloc(new_filename, - filename, - ".", - sequence, - NULL); - tmp_filename = newvstralloc(tmp_filename, - new_filename, - ".tmp", - NULL); - pc = strrchr(tmp_filename, '/'); - *pc = '\0'; - mkholdingdir(tmp_filename); - *pc = '/'; - new_outfd = open(tmp_filename, O_RDWR|O_CREAT|O_TRUNC, 0600); - if(new_outfd == -1) { - int save_errno = errno; - - errstr = squotef("creating chunk holding file \"%s\": %s", - tmp_filename, - strerror(save_errno)); - if(save_errno == ENOSPC) { - putresult(NO_ROOM, "%s %lu\n", - handle, - use + split_size - dumpsize); - use = 0; /* force RQ_MORE_DISK */ - split_size = dumpsize; - continue; - } - aclose(outfd); - rc = 1; - goto common_exit; - } - save_type = file.type; - file.type = F_CONT_DUMPFILE; - file.cont_filename[0] = '\0'; - if(write_tapeheader(new_outfd, &file)) { - int save_errno = errno; - - aclose(new_outfd); - unlink(tmp_filename); - if(save_errno == ENOSPC) { - putresult(NO_ROOM, "%s %lu\n", - handle, - use + split_size - dumpsize); - use = 0; /* force RQ_MORE_DISK */ - split_size = dumpsize; - continue; - } - errstr = squotef("write_tapeheader file \"%s\": %s", - tmp_filename, strerror(errno)); - rc = 1; - goto common_exit; - } - if(lseek(outfd, (off_t)0, SEEK_SET) != 0) { - errstr = squotef("cannot lseek: %s", strerror(errno)); - aclose(new_outfd); - unlink(tmp_filename); - rc = 1; - goto common_exit; - } - strncpy(file.cont_filename, new_filename, - sizeof(file.cont_filename)); - file.cont_filename[sizeof(file.cont_filename)-1] = '\0'; - file.type = save_type; - if(write_tapeheader(outfd, &file)) { - errstr = squotef("write_tapeheader file linked to \"%s\": %s", - tmp_filename, strerror(errno)); - aclose(new_outfd); - unlink(tmp_filename); - rc = 1; - goto common_exit; - } - file.type = F_CONT_DUMPFILE; - strncpy(cont_filename, new_filename, sizeof(cont_filename)); - cont_filename[sizeof(cont_filename)-1] = '\0'; +/* + * Write out the buffer to chunker. + */ +static int +databuf_flush(db) + struct databuf *db; +{ + int written; - aclose(outfd); - *p_outfd = outfd = new_outfd; - new_outfd = -1; - - dumpsize += DISK_BLOCK_KB; - filesize = DISK_BLOCK_KB; - split_size += (chunksize>use)?use:chunksize; - use = (chunksize>use)?0:use-chunksize; - nb_header_block++; - filename_seq++; - } - rc = write_dataptr(outfd); + /* + * If there's no data, do nothing. + */ + if (db->dataout >= db->datain) { + return 0; } -common_exit: - - amfree(new_filename); - amfree(tmp_filename); - amfree(arg_filename); - return rc; + /* + * Write out the buffer + */ + written = fullwrite(db->fd, db->dataout, db->datain - db->dataout); + if (written > 0) { + db->dataout += written; + dumpbytes += written; + } + if (dumpbytes >= 1024) { + dumpsize += (dumpbytes / 1024); + dumpbytes %= 1024; + } + if (written < 0) { + errstr = squotef("data write: %s", strerror(errno)); + return -1; + } + db->datain = db->dataout = db->buf; + return 0; } +static int dump_result; +static int status; +#define GOT_INFO_ENDLINE (1 << 0) +#define GOT_SIZELINE (1 << 1) +#define GOT_ENDLINE (1 << 2) +#define HEADER_DONE (1 << 3) -static char *msgbuf = NULL; -int got_info_endline; -int got_sizeline; -int got_endline; -int dump_result; -static void process_dumpeof() +static void +process_dumpeof() { /* process any partial line in msgbuf? !!! */ - if(msgbuf != NULL) { - fprintf(errf,"? %s: error [partial line in msgbuf: %ld bytes]\n", - get_pname(), (long) strlen(msgbuf)); - fprintf(errf,"? %s: error [partial line in msgbuf: \"%s\"]\n", - get_pname(), msgbuf); - } - if(!got_sizeline && dump_result < 2) { + add_msg_data(NULL, 0); + if(!ISSET(status, GOT_SIZELINE) && dump_result < 2) { /* make a note if there isn't already a failure */ - fprintf(errf,"? %s: strange [missing size line from sendbackup]\n", + fprintf(errf, + "? %s: strange [missing size line from sendbackup]\n", get_pname()); + if(errstr == NULL) { + errstr = stralloc("missing size line from sendbackup"); + } dump_result = max(dump_result, 2); } - if(!got_endline && dump_result < 2) { - fprintf(errf,"? %s: strange [missing end line from sendbackup]\n", + if(!ISSET(status, GOT_ENDLINE) && dump_result < 2) { + fprintf(errf, + "? %s: strange [missing end line from sendbackup]\n", get_pname()); + if(errstr == NULL) { + errstr = stralloc("missing end line from sendbackup"); + } dump_result = max(dump_result, 2); } } -/* Parse an information line from the client. -** We ignore unknown parameters and only remember the last -** of any duplicates. -*/ -static void parse_info_line(str) -char *str; +/* + * Parse an information line from the client. + * We ignore unknown parameters and only remember the last + * of any duplicates. + */ +static void +parse_info_line(str) + char *str; { - if(strcmp(str, "end") == 0) { - got_info_endline = 1; + static const struct { + const char *name; + char *value; + size_t len; + } fields[] = { + { "BACKUP", file.program, sizeof(file.program) }, + { "RECOVER_CMD", file.recover_cmd, sizeof(file.recover_cmd) }, + { "COMPRESS_SUFFIX", file.comp_suffix, sizeof(file.comp_suffix) }, + { "SERVER_CUSTOM_COMPRESS", file.srvcompprog, sizeof(file.srvcompprog) }, + { "CLIENT_CUSTOM_COMPRESS", file.clntcompprog, sizeof(file.clntcompprog) }, + { "SERVER_ENCRYPT", file.srv_encrypt, sizeof(file.srv_encrypt) }, + { "CLIENT_ENCRYPT", file.clnt_encrypt, sizeof(file.clnt_encrypt) }, + { "SERVER_DECRYPT_OPTION", file.srv_decrypt_opt, sizeof(file.srv_decrypt_opt) }, + { "CLIENT_DECRYPT_OPTION", file.clnt_decrypt_opt, sizeof(file.clnt_decrypt_opt) } + }; + char *name, *value; + int i; + + if (strcmp(str, "end") == 0) { + SET(status, GOT_INFO_ENDLINE); return; } -#define sc "BACKUP=" - if(strncmp(str, sc, sizeof(sc)-1) == 0) { - backup_name = newstralloc(backup_name, str + sizeof(sc)-1); + name = strtok(str, "="); + if (name == NULL) return; - } -#undef sc - -#define sc "RECOVER_CMD=" - if(strncmp(str, sc, sizeof(sc)-1) == 0) { - recover_cmd = newstralloc(recover_cmd, str + sizeof(sc)-1); + value = strtok(NULL, ""); + if (value == NULL) return; - } -#undef sc -#define sc "COMPRESS_SUFFIX=" - if(strncmp(str, sc, sizeof(sc)-1) == 0) { - compress_suffix = newstralloc(compress_suffix, str + sizeof(sc)-1); - return; + for (i = 0; i < sizeof(fields) / sizeof(fields[0]); i++) { + if (strcmp(name, fields[i].name) == 0) { + strncpy(fields[i].value, value, fields[i].len - 1); + fields[i].value[fields[i].len - 1] = '\0'; + break; + } } -#undef sc } -static void process_dumpline(str) -char *str; +static void +process_dumpline(str) + const char *str; { - char *s, *fp; - int ch; + char *buf, *tok; - s = str; - ch = *s++; + buf = stralloc(str); - switch(ch) { + switch (*buf) { case '|': /* normal backup output line */ break; @@ -929,241 +637,303 @@ char *str; break; case 's': /* a sendbackup line, just check them all since there are only 5 */ -#define sc "sendbackup: start" - if(strncmp(str, sc, sizeof(sc)-1) == 0) { + tok = strtok(buf, " "); + if (tok == NULL || strcmp(tok, "sendbackup:") != 0) + goto bad_line; + + tok = strtok(NULL, " "); + if (tok == NULL) + goto bad_line; + + if (strcmp(tok, "start") == 0) break; - } -#undef sc -#define sc "sendbackup: size" - if(strncmp(str, sc, sizeof(sc)-1) == 0) { - s += sizeof(sc)-1; - ch = s[-1]; - skip_whitespace(s, ch); - if(ch) { - origsize = (long)atof(str + sizeof(sc)-1); - got_sizeline = 1; - break; + + if (strcmp(tok, "size") == 0) { + tok = strtok(NULL, ""); + if (tok != NULL) { + origsize = (long)atof(tok); + SET(status, GOT_SIZELINE); } + break; } -#undef sc -#define sc "sendbackup: end" - if(strncmp(str, sc, sizeof(sc)-1) == 0) { - got_endline = 1; + + if (strcmp(tok, "end") == 0) { + SET(status, GOT_ENDLINE); break; } -#undef sc -#define sc "sendbackup: warning" - if(strncmp(str, sc, sizeof(sc)-1) == 0) { + + if (strcmp(tok, "warning") == 0) { dump_result = max(dump_result, 1); break; } -#undef sc -#define sc "sendbackup: error" - if(strncmp(str, sc, sizeof(sc)-1) == 0) { - s += sizeof(sc)-1; - ch = s[-1]; -#undef sc - got_endline = 1; + + if (strcmp(tok, "error") == 0) { + SET(status, GOT_ENDLINE); dump_result = max(dump_result, 2); - skip_whitespace(s, ch); - if(ch == '\0' || ch != '[') { - errstr = newvstralloc(errstr, - "bad remote error: ", str, - NULL); + + tok = strtok(NULL, ""); + if (tok == NULL || *tok != '[') { + errstr = newvstralloc(errstr, "bad remote error: ", str, NULL); } else { - ch = *s++; - fp = s - 1; - while(ch && ch != ']') ch = *s++; - s[-1] = '\0'; - errstr = newstralloc(errstr, fp); - s[-1] = ch; + char *enderr; + + tok++; /* skip over '[' */ + if ((enderr = strchr(tok, ']')) != NULL) + *enderr = '\0'; + errstr = newstralloc(errstr, tok); } break; } -#define sc "sendbackup: info" - if(strncmp(str, sc, sizeof(sc)-1) == 0) { - s += sizeof(sc)-1; - ch = s[-1]; - skip_whitespace(s, ch); - parse_info_line(s - 1); + + if (strcmp(tok, "info") == 0) { + tok = strtok(NULL, ""); + if (tok != NULL) + parse_info_line(tok); break; } -#undef sc /* else we fall through to bad line */ default: - fprintf(errf, "??%s", str); +bad_line: + /* prefix with ?? */ + fprintf(errf, "??"); dump_result = max(dump_result, 1); - return; + break; } fprintf(errf, "%s\n", str); + amfree(buf); } -static void add_msg_data(str, len) -char *str; -int len; +static void +add_msg_data(str, len) + const char *str; + size_t len; { - char *t; - char *nl; + static struct { + char *buf; /* buffer holding msg data */ + size_t size; /* size of alloced buffer */ + } msg = { NULL, 0 }; + char *line, *nl; + size_t buflen; + + if (msg.buf != NULL) + buflen = strlen(msg.buf); + else + buflen = 0; + + /* + * If our argument is NULL, then we need to flush out any remaining + * bits and return. + */ + if (str == NULL) { + if (buflen == 0) + return; + fprintf(errf,"? %s: error [partial line in msgbuf: %ld bytes]\n", + get_pname(), (long)buflen); + fprintf(errf,"? %s: error [partial line in msgbuf: \"%s\"]\n", + get_pname(), msg.buf); + msg.buf[0] = '\0'; + return; + } - while(len > 0) { - if((nl = strchr(str, '\n')) != NULL) { - *nl = '\0'; - } - if(msgbuf) { - t = stralloc2(msgbuf, str); - amfree(msgbuf); - msgbuf = t; - } else if(nl == NULL) { - msgbuf = stralloc(str); - } else { - msgbuf = str; - } - if(nl == NULL) break; - process_dumpline(msgbuf); - if(msgbuf != str) free(msgbuf); - msgbuf = NULL; - len -= nl + 1 - str; - str = nl + 1; + /* + * Expand the buffer if it can't hold the new contents. + */ + if (buflen + len + 1 > msg.size) { + char *newbuf; + size_t newsize; + +/* round up to next y, where y is a power of 2 */ +#define ROUND(x, y) (((x) + (y) - 1) & ~((y) - 1)) + + newsize = ROUND(buflen + len + 1, 256); + newbuf = alloc(newsize); + + if (msg.buf != NULL) { + strcpy(newbuf, msg.buf); + amfree(msg.buf); + } else + newbuf[0] = '\0'; + msg.buf = newbuf; + msg.size = newsize; + } + + /* + * If there was a partial line from the last call, then + * append the new data to the end. + */ + strncat(msg.buf, str, len); + + /* + * Process all lines in the buffer + */ + for (line = msg.buf;;) { + /* + * If there's no newline, then we've only got a partial line. + * We go back for more. + */ + if ((nl = strchr(line, '\n')) == NULL) + break; + *nl = '\0'; + process_dumpline(line); + line = nl + 1; + } + + /* + * If we did not process all of the data, move it to the front + * of the buffer so it is there next time. + */ + if (*line != '\0') { + buflen = strlen(line); + memmove(msg.buf, line, buflen + 1); + } else { + msg.buf[0] = '\0'; } } -static void log_msgout(typ) -logtype_t typ; +static void +log_msgout(typ) + logtype_t typ; { - char *line = NULL; + char *line; fflush(errf); (void) fseek(errf, 0L, SEEK_SET); - for(; (line = agets(errf)) != NULL; free(line)) { + while ((line = agets(errf)) != NULL) { log_add(typ, "%s", line); + amfree(line); } + afclose(errf); } /* ------------- */ -void make_tapeheader(file, type) -dumpfile_t *file; -filetype_t type; +/* + * Fill in the rest of the tape header + */ +static void +finish_tapeheader(file) + dumpfile_t *file; { - fh_init(file); - file->type = type; - strncpy(file->datestamp , datestamp , sizeof(file->datestamp)-1); - file->datestamp[sizeof(file->datestamp)-1] = '\0'; - strncpy(file->name , hostname , sizeof(file->name)-1); - file->name[sizeof(file->name)-1] = '\0'; - strncpy(file->disk , diskname , sizeof(file->disk)-1); - file->disk[sizeof(file->disk)-1] = '\0'; + + assert(ISSET(status, HEADER_DONE)); + + file->type = F_DUMPFILE; + strncpy(file->datestamp, datestamp, sizeof(file->datestamp) - 1); + strncpy(file->name, hostname, sizeof(file->name) - 1); + strncpy(file->disk, diskname, sizeof(file->disk) - 1); file->dumplevel = level; - strncpy(file->program , backup_name, sizeof(file->program)-1); - file->program[sizeof(file->program)-1] = '\0'; - strncpy(file->recover_cmd, recover_cmd, sizeof(file->recover_cmd)-1); - file->recover_cmd[sizeof(file->recover_cmd)-1] = '\0'; - file->blocksize = DISK_BLOCK_BYTES; - - if (srvcompress) { - file->compressed=1; - ap_snprintf(file->uncompress_cmd, sizeof(file->uncompress_cmd), - " %s %s |", UNCOMPRESS_PATH, -#ifdef UNCOMPRESS_OPT - UNCOMPRESS_OPT -#else - "" + + /* + * If we're doing the compression here, we need to override what + * sendbackup told us the compression was. + */ + if (srvcompress != COMP_NONE) { + file->compressed = 1; +#ifndef UNCOMPRESS_OPT +#define UNCOMPRESS_OPT "" #endif - ); - strncpy(file->comp_suffix, COMPRESS_SUFFIX,sizeof(file->comp_suffix)-1); - file->comp_suffix[sizeof(file->comp_suffix)-1] = '\0'; - } - else { - file->uncompress_cmd[0] = '\0'; - file->compressed=compress_suffix!=NULL; - if(compress_suffix) { - strncpy(file->comp_suffix, compress_suffix, - sizeof(file->comp_suffix)-1); - file->comp_suffix[sizeof(file->comp_suffix)-1] = '\0'; + if (srvcompress == COMP_SERV_CUST) { + snprintf(file->uncompress_cmd, sizeof(file->uncompress_cmd), + " %s %s |", srvcompprog, "-d"); + strcpy(file->comp_suffix, "cust"); + strncpy(file->srvcompprog, srvcompprog, sizeof(file->srvcompprog)); + file->srvcompprog[sizeof(file->srvcompprog)-1] = '\0'; + } else if ( srvcompress == COMP_CUST ) { + snprintf(file->uncompress_cmd, sizeof(file->uncompress_cmd), + " %s %s |", clntcompprog, "-d"); + strcpy(file->comp_suffix, "cust"); + strncpy(file->clntcompprog, clntcompprog, sizeof(file->clntcompprog)); + file->clntcompprog[sizeof(file->clntcompprog)-1] = '\0'; } else { - strncpy(file->comp_suffix, "N", sizeof(file->comp_suffix)-1); + snprintf(file->uncompress_cmd, sizeof(file->uncompress_cmd), + " %s %s |", UNCOMPRESS_PATH, UNCOMPRESS_OPT); + strncpy(file->comp_suffix, COMPRESS_SUFFIX,sizeof(file->comp_suffix)-1); file->comp_suffix[sizeof(file->comp_suffix)-1] = '\0'; } + } else { + if (file->comp_suffix[0] == '\0') { + file->compressed = 0; + assert(sizeof(file->comp_suffix) >= 2); + strcpy(file->comp_suffix, "N"); + } else { + file->compressed = 1; + } + } + /* take care of the encryption header here */ + if (srvencrypt != ENCRYPT_NONE) { + file->encrypted= 1; + if (srvencrypt == ENCRYPT_SERV_CUST) { + snprintf(file->decrypt_cmd, sizeof(file->decrypt_cmd), + " %s %s |", srv_encrypt, srv_decrypt_opt); + strcpy(file->encrypt_suffix, "enc"); + strncpy(file->srv_encrypt, srv_encrypt, sizeof(file->srv_encrypt)); + file->srv_encrypt[sizeof(file->srv_encrypt)-1] = '\0'; + strncpy(file->srv_decrypt_opt, srv_decrypt_opt, sizeof(file->srv_decrypt_opt)); + file->srv_decrypt_opt[sizeof(file->srv_decrypt_opt)-1] = '\0'; + } else if ( srvencrypt == ENCRYPT_CUST ) { + snprintf(file->decrypt_cmd, sizeof(file->decrypt_cmd), + " %s %s |", clnt_encrypt, clnt_decrypt_opt); + strcpy(file->encrypt_suffix, "enc"); + strncpy(file->clnt_encrypt, clnt_encrypt, sizeof(file->clnt_encrypt)); + file->clnt_encrypt[sizeof(file->clnt_encrypt)-1] = '\0'; + strncpy(file->clnt_decrypt_opt, clnt_decrypt_opt, sizeof(file->clnt_decrypt_opt)); + file->clnt_decrypt_opt[sizeof(file->clnt_decrypt_opt)-1] = '\0'; + } + } else { + if (file->encrypt_suffix[0] == '\0') { + file->encrypted = 0; + assert(sizeof(file->encrypt_suffix) >= 2); + strcpy(file->encrypt_suffix, "N"); + } else { + file->encrypted= 1; + } } - strncpy(file->cont_filename, cont_filename, sizeof(file->cont_filename)-1); - file->cont_filename[sizeof(file->cont_filename)-1] = '\0'; } -/* Send an Amanda dump header to the output file. - * returns true if an error occured, false on success +/* + * Send an Amanda dump header to the output file. */ - -int write_tapeheader(outfd, file) -int outfd; -dumpfile_t *file; +static int +write_tapeheader(outfd, file) + int outfd; + dumpfile_t *file; { char buffer[DISK_BLOCK_BYTES]; - int written; + int written; build_header(buffer, file, sizeof(buffer)); - written = fullwrite(outfd, buffer, sizeof(buffer)); + written = write(outfd, buffer, sizeof(buffer)); if(written == sizeof(buffer)) return 0; if(written < 0) return written; errno = ENOSPC; return -1; } - -int do_dump(mesgfd, datafd, indexfd, outfd) -int mesgfd, datafd, indexfd, outfd; +static int +do_dump(db) + struct databuf *db; { - int maxfd, nfound, size1, size2, eof1, eof2; - int rc; - fd_set readset, selectset; - struct timeval timeout; - int outpipe[2]; - int header_done; /* flag - header has been written */ char *indexfile_tmp = NULL; char *indexfile_real = NULL; char level_str[NUM_STR_SIZE]; - char kb_str[NUM_STR_SIZE]; - char kps_str[NUM_STR_SIZE]; - char orig_kb_str[NUM_STR_SIZE]; char *fn; char *q; times_t runtime; double dumptime; /* Time dump took in secs */ - int compresspid = -1, indexpid = -1, killerr; char *errfname = NULL; - -#ifndef DUMPER_SOCKET_BUFFERING -#define DUMPER_SOCKET_BUFFERING 0 -#endif - -#if !defined(SO_RCVBUF) || !defined(SO_RCVLOWAT) -#undef DUMPER_SOCKET_BUFFERING -#define DUMPER_SOCKET_BUFFERING 0 -#endif - -#if DUMPER_SOCKET_BUFFERING - int lowat = NETWORK_BLOCK_BYTES; - int recbuf = 0; - int sizeof_recbuf = sizeof(recbuf); - int lowwatset = 0; - int lowwatset_count = 0; -#endif + int indexout; + pid_t indexpid = -1; startclock(); - datain = dataout = databuf; - datalimit = databuf + sizeof(databuf); - dumpsize = dumpbytes = origsize = filesize = dump_result = 0; - nb_header_block = 0; - got_info_endline = got_sizeline = got_endline = 0; - header_done = 0; - amfree(backup_name); - amfree(recover_cmd); - amfree(compress_suffix); - - ap_snprintf(level_str, sizeof(level_str), "%d", level); + dumpbytes = dumpsize = headersize = origsize = dump_result = 0; + status = 0; + fh_init(&file); + + snprintf(level_str, sizeof(level_str), "%d", level); fn = sanitise_filename(diskname); errfname = newvstralloc(errfname, AMANDA_TMPDIR, @@ -1179,58 +949,13 @@ int mesgfd, datafd, indexfd, outfd; strerror(errno), NULL); amfree(errfname); - rc = 2; goto failed; } unlink(errfname); /* so it goes away on close */ amfree(errfname); - /* insert pipe in the *READ* side, if server-side compression is desired */ - compresspid = -1; - if (srvcompress) { - int tmpfd; - - tmpfd = datafd; - pipe(outpipe); /* outpipe[0] is pipe's stdin, outpipe[1] is stdout. */ - datafd = outpipe[0]; - if(datafd < 0 || datafd >= FD_SETSIZE) { - aclose(outpipe[0]); - aclose(outpipe[1]); - errstr = newstralloc(errstr, "descriptor out of range"); - errno = EMFILE; - rc = 2; - goto failed; - } - switch(compresspid=fork()) { - case -1: - errstr = newstralloc2(errstr, "couldn't fork: ", strerror(errno)); - rc = 2; - goto failed; - default: - aclose(outpipe[1]); - aclose(tmpfd); - break; - case 0: - aclose(outpipe[0]); - /* child acts on stdin/stdout */ - if (dup2(outpipe[1],1) == -1) - fprintf(stderr, "err dup2 out: %s\n", strerror(errno)); - if (dup2(tmpfd, 0) == -1) - fprintf(stderr, "err dup2 in: %s\n", strerror(errno)); - safe_fd(-1, 0); - /* now spawn gzip -1 to take care of the rest */ - execlp(COMPRESS_PATH, COMPRESS_PATH, - (srvcompress == srvcomp_best ? COMPRESS_BEST_OPT - : COMPRESS_FAST_OPT), - (char *)0); - error("error: couldn't exec %s.\n", COMPRESS_PATH); - } - /* Now the pipe has been inserted. */ - } - - indexpid = -1; - if (indexfd != -1) { - indexfile_real = getindexfname(hostname, diskname, datestamp, level), + if (streams[INDEXFD].fd != NULL) { + indexfile_real = getindexfname(hostname, diskname, datestamp, level); indexfile_tmp = stralloc2(indexfile_real, ".tmp"); if (mkpdir(indexfile_tmp, 02755, (uid_t)-1, (gid_t)-1) == -1) { @@ -1242,240 +967,57 @@ int mesgfd, datafd, indexfd, outfd; NULL); amfree(indexfile_real); amfree(indexfile_tmp); - rc = 2; goto failed; } - - switch(indexpid=fork()) { - case -1: - errstr = newstralloc2(errstr, "couldn't fork: ", strerror(errno)); - rc = 2; - goto failed; - default: - aclose(indexfd); - indexfd = -1; /* redundant */ - break; - case 0: - if (dup2(indexfd, 0) == -1) { - error("err dup2 in: %s", strerror(errno)); - } - indexfd = open(indexfile_tmp, O_WRONLY | O_CREAT | O_TRUNC, 0600); - if (indexfd == -1) - error("err open %s: %s", indexfile_tmp, strerror(errno)); - if (dup2(indexfd,1) == -1) - error("err dup2 out: %s", strerror(errno)); - safe_fd(-1, 0); - execlp(COMPRESS_PATH, COMPRESS_PATH, COMPRESS_BEST_OPT, (char *)0); - error("error: couldn't exec %s.", COMPRESS_PATH); - } - } - - NAUGHTY_BITS_INITIALIZE; - - maxfd = max(mesgfd, datafd) + 1; - eof1 = eof2 = 0; - - FD_ZERO(&readset); - - /* Just process messages for now. Once we have done the header - ** we will start processing data too. - */ - FD_SET(mesgfd, &readset); - - if(datafd == -1) eof1 = 1; /* fake eof on data */ - -#if DUMPER_SOCKET_BUFFERING - -#ifndef EST_PACKET_SIZE -#define EST_PACKET_SIZE 512 -#endif -#ifndef EST_MIN_WINDOW -#define EST_MIN_WINDOW EST_PACKET_SIZE*4 /* leave room for 2k in transit */ -#endif - - else { - recbuf = STREAM_BUFSIZE; - if (setsockopt(datafd, SOL_SOCKET, SO_RCVBUF, - (void *) &recbuf, sizeof_recbuf)) { - const int errornumber = errno; - fprintf(stderr, "%s: pid %ld setsockopt(SO_RCVBUF): %s\n", - get_pname(), (long) getpid(), strerror(errornumber)); - } - if (getsockopt(datafd, SOL_SOCKET, SO_RCVBUF, - (void *) &recbuf, (void *)&sizeof_recbuf)) { - const int errornumber = errno; - fprintf(stderr, "%s: pid %ld getsockopt(SO_RCVBUF): %s\n", - get_pname(), (long) getpid(), strerror(errornumber)); - recbuf = 0; - } - - /* leave at least EST_MIN_WINDOW between lowwat and recbuf */ - if (recbuf-lowat < EST_MIN_WINDOW) - lowat = recbuf-EST_MIN_WINDOW; - - /* if lowwat < ~512, don't bother */ - if (lowat < EST_PACKET_SIZE) - recbuf = 0; - fprintf(stderr, "%s: pid %ld receive size is %d, low water is %d\n", - get_pname(), (long) getpid(), recbuf, lowat); - } -#endif - - while(!(eof1 && eof2)) { - -#if DUMPER_SOCKET_BUFFERING - /* Set socket buffering */ - if (recbuf>0 && !lowwatset) { - if (setsockopt(datafd, SOL_SOCKET, SO_RCVLOWAT, - (void *) &lowat, sizeof(lowat))) { - const int errornumber = errno; - fprintf(stderr, - "%s: pid %ld setsockopt(SO_RCVLOWAT): %s\n", - get_pname(), (long) getpid(), strerror(errornumber)); - } - lowwatset = 1; - lowwatset_count++; - } -#endif - - timeout.tv_sec = conf_dtimeout; - timeout.tv_usec = 0; - memcpy(&selectset, &readset, sizeof(fd_set)); - - nfound = select(maxfd, (SELECT_ARG_TYPE *)(&selectset), NULL, NULL, &timeout); - - /* check for errors or timeout */ - -#if DUMPER_SOCKET_BUFFERING - if (nfound==0 && lowwatset) { - const int zero = 0; - /* Disable socket buffering and ... */ - if (setsockopt(datafd, SOL_SOCKET, SO_RCVLOWAT, - (void *) &zero, sizeof(zero))) { - const int errornumber = errno; - fprintf(stderr, - "%s: pid %ld setsockopt(SO_RCVLOWAT): %s\n", - get_pname(), (long) getpid(), strerror(errornumber)); - } - lowwatset = 0; - - /* ... try once more */ - timeout.tv_sec = conf_dtimeout; - timeout.tv_usec = 0; - memcpy(&selectset, &readset, sizeof(fd_set)); - nfound = select(maxfd, (SELECT_ARG_TYPE *)(&selectset), NULL, NULL, &timeout); - } -#endif - - if(nfound == 0) { - errstr = newstralloc(errstr, "data timeout"); - rc = 2; - goto failed; - } - if(nfound == -1) { - errstr = newstralloc2(errstr, "select: ", strerror(errno)); - rc = 2; + indexout = open(indexfile_tmp, O_WRONLY | O_CREAT | O_TRUNC, 0600); + if (indexout == -1) { + errstr = newvstralloc(errstr, "err open ", indexfile_tmp, ": ", + strerror(errno), NULL); goto failed; - } - - /* read/write any data */ - - if(datafd >= 0 && FD_ISSET(datafd, &selectset)) { - size1 = read(datafd, datain, datalimit - datain); - if(size1 < 0) { - errstr = newstralloc2(errstr, "data read: ", strerror(errno)); - rc = 2; - goto failed; - } - if(update_dataptr(&outfd, size1)) { - rc = 2; + } else { + if (runcompress(indexout, &indexpid, COMP_BEST) < 0) { + aclose(indexout); goto failed; } - if(size1 == 0) { - eof1 = 1; - FD_CLR(datafd, &readset); - aclose(datafd); - } } + indexfderror = 0; + /* + * Schedule the indexfd for relaying to the index file + */ + security_stream_read(streams[INDEXFD].fd, read_indexfd, &indexout); + } - if(mesgfd >= 0 && FD_ISSET(mesgfd, &selectset)) { - size2 = read(mesgfd, mesgbuf, sizeof(mesgbuf)-1); - switch(size2) { - case -1: - errstr = newstralloc2(errstr, "mesg read: ", strerror(errno)); - rc = 2; - goto failed; - case 0: - eof2 = 1; - process_dumpeof(); - FD_CLR(mesgfd, &readset); - aclose(mesgfd); - break; - default: - mesgbuf[size2] = '\0'; - add_msg_data(mesgbuf, size2); - } + /* + * We only need to process messages initially. Once we have done + * the header, we will start processing data too. + */ + security_stream_read(streams[MESGFD].fd, read_mesgfd, db); - if (got_info_endline && !header_done) { /* time to do the header */ - make_tapeheader(&file, F_DUMPFILE); - if (write_tapeheader(outfd, &file)) { - int save_errno = errno; - errstr = newstralloc2(errstr, "write_tapeheader: ", - strerror(errno)); - if(save_errno == ENOSPC) { - putresult(NO_ROOM, "%s %lu\n", handle, - use+split_size-dumpsize); - use = 0; /* force RQ_MORE_DISK */ - split_size = dumpsize; - rc = 1; - } - else { - rc = 2; - } - goto failed; - } - dumpsize += DISK_BLOCK_KB; - filesize += DISK_BLOCK_KB; - nb_header_block++; - header_done = 1; - strncat(cont_filename,filename,sizeof(cont_filename)); - cont_filename[sizeof(cont_filename)-1] = '\0'; - - if (datafd != -1) - FD_SET(datafd, &readset); /* now we can read the data */ - } - } - } /* end while */ + /* + * Setup a read timeout + */ + timeout(conf_dtimeout); -#if DUMPER_SOCKET_BUFFERING - if(lowwatset_count > 1) { - fprintf(stderr, "%s: pid %ld low water set %d times\n", - get_pname(), (long) getpid(), lowwatset_count); - } -#endif + /* + * Start the event loop. This will exit when all three events + * (read the mesgfd, read the datafd, and timeout) are removed. + */ + event_loop(0); - if(dump_result > 1) { - rc = 2; + if (dump_result > 1) goto failed; - } runtime = stopclock(); dumptime = runtime.r.tv_sec + runtime.r.tv_usec/1000000.0; - dumpsize -= (nb_header_block * DISK_BLOCK_KB);/* don't count the header */ + dumpsize -= headersize; /* don't count the header */ if (dumpsize < 0) dumpsize = 0; /* XXX - maybe this should be fatal? */ - ap_snprintf(kb_str, sizeof(kb_str), "%ld", dumpsize); - ap_snprintf(kps_str, sizeof(kps_str), - "%3.1f", - dumptime ? dumpsize / dumptime : 0.0); - ap_snprintf(orig_kb_str, sizeof(orig_kb_str), "%ld", origsize); - errstr = newvstralloc(errstr, - "sec ", walltime_str(runtime), - " ", "kb ", kb_str, - " ", "kps ", kps_str, - " ", "orig-kb ", orig_kb_str, - NULL); + amfree(errstr); + errstr = alloc(128); + snprintf(errstr, 128, "sec %s kb %ld kps %3.1f orig-kb %ld", + walltime_str(runtime), dumpsize, + dumptime ? dumpsize / dumptime : 0.0, origsize); q = squotef("[%s]", errstr); putresult(DONE, "%s %ld %ld %ld %s\n", handle, origsize, dumpsize, (long)(dumptime+0.5), q); @@ -1496,11 +1038,15 @@ int mesgfd, datafd, indexfd, outfd; break; } - if(errf) afclose(errf); + if (errf) afclose(errf); + aclose(db->fd); if (indexfile_tmp) { - waitpid(indexpid,NULL,0); - if(rename(indexfile_tmp, indexfile_real) != 0) { + amwait_t index_status; + + aclose(indexout); + waitpid(indexpid,&index_status,0); + if (rename(indexfile_tmp, indexfile_real) != 0) { log_add(L_WARNING, "could not rename \"%s\" to \"%s\": %s", indexfile_tmp, indexfile_real, strerror(errno)); } @@ -1508,62 +1054,69 @@ int mesgfd, datafd, indexfd, outfd; amfree(indexfile_real); } - return 0; + if(db->compresspid != -1) { + waitpid(db->compresspid,NULL,0); + } + if(db->encryptpid != -1) { + waitpid(db->encryptpid,NULL,0); + } - failed: + amfree(errstr); -#if DUMPER_SOCKET_BUFFERING - if(lowwatset_count > 1) { - fprintf(stderr, "%s: pid %ld low water set %d times\n", - get_pname(), (long) getpid(), lowwatset_count); - } -#endif + return 1; - if(!abort_pending) { - q = squotef("[%s]", errstr); - if(rc==2) - putresult(FAILED, "%s %s\n", handle, q); - else - putresult(TRYAGAIN, "%s %s\n", handle, q); - amfree(q); - } +failed: + q = squotef("[%s]", errstr); + putresult(FAILED, "%s %s\n", handle, q); + amfree(q); + aclose(db->fd); /* kill all child process */ - if(compresspid != -1) { - killerr = kill(compresspid,SIGTERM); - if(killerr == 0) { - fprintf(stderr,"%s: kill compress command\n",get_pname()); - } - else if ( killerr == -1 ) { - if(errno != ESRCH) + if (db->compresspid != -1) { + fprintf(stderr,"%s: kill compress command\n",get_pname()); + if (kill(db->compresspid, SIGTERM) < 0) { + if (errno != ESRCH) fprintf(stderr,"%s: can't kill compress command: %s\n", - get_pname(), strerror(errno)); + get_pname(), strerror(errno)); + } + else { + waitpid(db->compresspid,NULL,0); } } - if(indexpid != -1) { - killerr = kill(indexpid,SIGTERM); - if(killerr == 0) { - fprintf(stderr,"%s: kill index command\n",get_pname()); + if (db->encryptpid != -1) { + fprintf(stderr,"%s: kill encrypt command\n",get_pname()); + if (kill(db->encryptpid, SIGTERM) < 0) { + if (errno != ESRCH) + fprintf(stderr,"%s: can't kill encrypt command: %s\n", + get_pname(), strerror(errno)); } - else if ( killerr == -1 ) { - if(errno != ESRCH) - fprintf(stderr,"%s: can't kill index command: %s\n", - get_pname(),strerror(errno)); + else { + waitpid(db->encryptpid,NULL,0); } } - if(!abort_pending) { - log_start_multiline(); - log_add(L_FAIL, "%s %s %s %d [%s]", hostname, diskname, - datestamp, level, errstr); - if (errf) { - log_msgout(L_FAIL); + if (indexpid != -1) { + fprintf(stderr,"%s: kill index command\n",get_pname()); + if (kill(indexpid, SIGTERM) < 0) { + if (errno != ESRCH) + fprintf(stderr,"%s: can't kill index command: %s\n", + get_pname(),strerror(errno)); + } + else { + waitpid(indexpid,NULL,0); } - log_end_multiline(); } - if(errf) afclose(errf); + log_start_multiline(); + log_add(L_FAIL, "%s %s %s %d [%s]", hostname, diskname, datestamp, + level, errstr); + if (errf) { + log_msgout(L_FAIL); + } + log_end_multiline(); + + if (errf) afclose(errf); if (indexfile_tmp) { unlink(indexfile_tmp); @@ -1571,224 +1124,623 @@ int mesgfd, datafd, indexfd, outfd; amfree(indexfile_real); } - return rc; + return 0; } -/* -------------------- */ +/* + * Callback for reads on the mesgfd stream + */ +static void +read_mesgfd(cookie, buf, size) + void *cookie, *buf; + ssize_t size; +{ + struct databuf *db = cookie; -char *hostname, *disk; -int response_error; + assert(db != NULL); -void sendbackup_response(p, pkt) -proto_t *p; -pkt_t *pkt; -{ - int data_port = -1; - int mesg_port = -1; - int index_port = -1; - char *line; - char *fp; - char *s; - char *t; - int ch; - int tch; - - am_release_feature_set(their_features); - their_features = NULL; - - if(p->state == S_FAILED) { - if(pkt == NULL) { - if(p->prevstate == S_REPWAIT) { - errstr = newstralloc(errstr, "[reply timeout]"); + switch (size) { + case -1: + errstr = newstralloc2(errstr, "mesg read: ", + security_stream_geterror(streams[MESGFD].fd)); + dump_result = 2; + stop_dump(); + return; + case 0: + /* + * EOF. Just shut down the mesg stream. + */ + process_dumpeof(); + security_stream_close(streams[MESGFD].fd); + streams[MESGFD].fd = NULL; + /* + * If the data fd and index fd has also shut down, then we're done. + */ + if (streams[DATAFD].fd == NULL && streams[INDEXFD].fd == NULL) + stop_dump(); + return; + default: + assert(buf != NULL); + add_msg_data(buf, size); + security_stream_read(streams[MESGFD].fd, read_mesgfd, cookie); + break; + } + + /* + * Reset the timeout for future reads + */ + timeout(conf_dtimeout); + + if (ISSET(status, GOT_INFO_ENDLINE) && !ISSET(status, HEADER_DONE)) { + SET(status, HEADER_DONE); + /* time to do the header */ + finish_tapeheader(&file); + if (write_tapeheader(db->fd, &file)) { + errstr = newstralloc2(errstr, "write_tapeheader: ", + strerror(errno)); + dump_result = 2; + stop_dump(); + return; + } + dumpsize += DISK_BLOCK_KB; + headersize += DISK_BLOCK_KB; + + if (srvencrypt == ENCRYPT_SERV_CUST) { + if (runencrypt(db->fd, &db->encryptpid, srvencrypt) < 0) { + dump_result = 2; + stop_dump(); + return; } - else { - errstr = newstralloc(errstr, "[request timeout]"); + } + /* + * Now, setup the compress for the data output, and start + * reading the datafd. + */ + if ((srvcompress != COMP_NONE) && (srvcompress != COMP_CUST)) { + if (runcompress(db->fd, &db->compresspid, srvcompress) < 0) { + dump_result = 2; + stop_dump(); + return; } - response_error = 1; - return; } + security_stream_read(streams[DATAFD].fd, read_datafd, db); } +} -#if 0 - fprintf(stderr, "got %sresponse:\n----\n%s----\n\n", - (p->state == S_FAILED) ? "NAK " : "", pkt->body); -#endif +/* + * Callback for reads on the datafd stream + */ +static void +read_datafd(cookie, buf, size) + void *cookie, *buf; + ssize_t size; +{ + struct databuf *db = cookie; + + assert(db != NULL); + + /* + * The read failed. Error out + */ + if (size < 0) { + errstr = newstralloc2(errstr, "data read: ", + security_stream_geterror(streams[DATAFD].fd)); + dump_result = 2; + stop_dump(); + return; + } -#ifdef KRB4_SECURITY - if(krb4_auth && !check_mutual_authenticator(&cred.session, pkt, p)) { - errstr = newstralloc(errstr, "mutual-authentication failed"); - response_error = 2; + /* + * Reset the timeout for future reads + */ + timeout(conf_dtimeout); + + /* The header had better be written at this point */ + assert(ISSET(status, HEADER_DONE)); + + /* + * EOF. Stop and return. + */ + if (size == 0) { + databuf_flush(db); + if (dumpbytes) { + dumpsize++; + } + security_stream_close(streams[DATAFD].fd); + streams[DATAFD].fd = NULL; + /* + * If the mesg fd and index fd has also shut down, then we're done. + */ + if (streams[MESGFD].fd == NULL && streams[INDEXFD].fd == NULL) + stop_dump(); return; } -#endif - s = pkt->body; - ch = *s++; - while(ch) { - line = s - 1; - skip_line(s, ch); - if (s[-2] == '\n') { - s[-2] = '\0'; + /* + * We read something. Add it to the databuf and reschedule for + * more data. + */ + assert(buf != NULL); + if (databuf_write(db, buf, size) < 0) { + errstr = newstralloc2(errstr, "data write: ", strerror(errno)); + dump_result = 2; + stop_dump(); + return; + } + security_stream_read(streams[DATAFD].fd, read_datafd, cookie); +} + +/* + * Callback for reads on the index stream + */ +static void +read_indexfd(cookie, buf, size) + void *cookie, *buf; + ssize_t size; +{ + int fd; + + assert(cookie != NULL); + fd = *(int *)cookie; + + if (size < 0) { + errstr = newstralloc2(errstr, "index read: ", + security_stream_geterror(streams[INDEXFD].fd)); + dump_result = 2; + stop_dump(); + return; + } + + /* + * EOF. Stop and return. + */ + if (size == 0) { + security_stream_close(streams[INDEXFD].fd); + streams[INDEXFD].fd = NULL; + /* + * If the mesg fd has also shut down, then we're done. + */ + if (streams[DATAFD].fd == NULL && streams[MESGFD].fd == NULL) + stop_dump(); + return; + } + + assert(buf != NULL); + + /* + * We ignore error while writing to the index file. + */ + if (fullwrite(fd, buf, size) < 0) { + /* Ignore error, but schedule another read. */ + if(indexfderror == 0) { + indexfderror = 1; + log_add(L_INFO, "Index corrupted for %s:%s", hostname, diskname); } + } + security_stream_read(streams[INDEXFD].fd, read_indexfd, cookie); +} -#define sc "OPTIONS " - if(strncmp(line, sc, sizeof(sc)-1) == 0) { -#undef sc +/* + * Startup a timeout in the event handler. If the arg is 0, + * then remove the timeout. + */ +static void +timeout(seconds) + int seconds; +{ + static event_handle_t *ev_timeout = NULL; + + /* + * First, remove a timeout if one is active. + */ + if (ev_timeout != NULL) { + event_release(ev_timeout); + ev_timeout = NULL; + } -#define sc "features=" - t = strstr(line, sc); - if(t != NULL && (isspace((int)t[-1]) || t[-1] == ';')) { - t += sizeof(sc)-1; -#undef sc - am_release_feature_set(their_features); - if((their_features = am_string_to_feature(t)) == NULL) { - errstr = newvstralloc(errstr, - "bad features value: ", - line, - NULL); - } - } + /* + * Now, schedule a new one if 'seconds' is greater than 0 + */ + if (seconds > 0) + ev_timeout = event_register(seconds, EV_TIME, timeout_callback, NULL); +} - continue; +/* + * This is the callback for timeout(). If this is reached, then we + * have a data timeout. + */ +static void +timeout_callback(unused) + void *unused; +{ + assert(unused == NULL); + errstr = newstralloc(errstr, "data timeout"); + dump_result = 2; + stop_dump(); +} + +/* + * This is called when everything needs to shut down so event_loop() + * will exit. + */ +static void +stop_dump() +{ + int i; + + for (i = 0; i < NSTREAMS; i++) { + if (streams[i].fd != NULL) { + security_stream_close(streams[i].fd); + streams[i].fd = NULL; } + } + timeout(0); +} -#define sc "ERROR " - if(strncmp(line, sc, sizeof(sc)-1) == 0) { - t = line + sizeof(sc)-1; - tch = t[-1]; -#undef sc - fp = t - 1; - skip_whitespace(t, tch); - errstr = newvstralloc(errstr, - (p->state == S_FAILED) ? "nak error: " : "", - fp, - NULL); - response_error = ((p->state == S_FAILED) ? 1 : 2); - return; +/* + * Runs compress with the first arg as its stdout. Returns + * 0 on success or negative if error, and it's pid via the second + * argument. The outfd arg is dup2'd to the pipe to the compress + * process. + */ +static int +runcompress(outfd, pid, comptype) + int outfd; + pid_t *pid; + comp_t comptype; +{ + int outpipe[2], rval; + + assert(outfd >= 0); + assert(pid != NULL); + + /* outpipe[0] is pipe's stdin, outpipe[1] is stdout. */ + if (pipe(outpipe) < 0) { + errstr = newstralloc2(errstr, "pipe: ", strerror(errno)); + return (-1); + } + + switch (*pid = fork()) { + case -1: + errstr = newstralloc2(errstr, "couldn't fork: ", strerror(errno)); + aclose(outpipe[0]); + aclose(outpipe[1]); + return (-1); + default: + rval = dup2(outpipe[1], outfd); + if (rval < 0) + errstr = newstralloc2(errstr, "couldn't dup2: ", strerror(errno)); + aclose(outpipe[1]); + aclose(outpipe[0]); + return (rval); + case 0: + if (dup2(outpipe[0], 0) < 0) + error("err dup2 in: %s", strerror(errno)); + if (dup2(outfd, 1) == -1) + error("err dup2 out: %s", strerror(errno)); + safe_fd(-1, 0); + if (comptype != COMP_SERV_CUST) { + execlp(COMPRESS_PATH, COMPRESS_PATH, ( comptype == COMP_BEST ? + COMPRESS_BEST_OPT : COMPRESS_FAST_OPT), NULL); + error("error: couldn't exec %s: %s", COMPRESS_PATH, strerror(errno)); + } else if (*srvcompprog) { + execlp(srvcompprog, srvcompprog, (char *)0); + error("error: couldn't exec server custom filter%s.\n", srvcompprog); } + } + /* NOTREACHED */ + return (-1); +} -#define sc "CONNECT " - if(strncmp(line, sc, sizeof(sc)-1) == 0) { -#undef sc +/* + * Runs encrypt with the first arg as its stdout. Returns + * 0 on success or negative if error, and it's pid via the second + * argument. The outfd arg is dup2'd to the pipe to the encrypt + * process. + */ +static int +runencrypt(outfd, pid, encrypttype) + int outfd; + pid_t *pid; + encrypt_t encrypttype; +{ + int outpipe[2], rval; -#define sc "DATA " - t = strstr(line, sc); - if(t != NULL && isspace((int)t[-1])) { - t += sizeof(sc)-1; -#undef sc - data_port = atoi(t); - } + assert(outfd >= 0); + assert(pid != NULL); -#define sc "MESG " - t = strstr(line, sc); - if(t != NULL && isspace((int)t[-1])) { - t += sizeof(sc)-1; -#undef sc - mesg_port = atoi(t); - } + /* outpipe[0] is pipe's stdin, outpipe[1] is stdout. */ + if (pipe(outpipe) < 0) { + errstr = newstralloc2(errstr, "pipe: ", strerror(errno)); + return (-1); + } -#define sc "INDEX " - t = strstr(line, sc); - if(t != NULL && isspace((int)t[-1])) { - t += sizeof(sc)-1; -#undef sc - index_port = atoi(t); - } - continue; + switch (*pid = fork()) { + case -1: + errstr = newstralloc2(errstr, "couldn't fork: ", strerror(errno)); + aclose(outpipe[0]); + aclose(outpipe[1]); + return (-1); + default: + rval = dup2(outpipe[1], outfd); + if (rval < 0) + errstr = newstralloc2(errstr, "couldn't dup2: ", strerror(errno)); + aclose(outpipe[1]); + aclose(outpipe[0]); + return (rval); + case 0: + if (dup2(outpipe[0], 0) < 0) + error("err dup2 in: %s", strerror(errno)); + if (dup2(outfd, 1) < 0 ) + error("err dup2 out: %s", strerror(errno)); + safe_fd(-1, 0); + if ((encrypttype == ENCRYPT_SERV_CUST) && *srv_encrypt) { + execlp(srv_encrypt, srv_encrypt, (char *)0); + error("error: couldn't exec server encryption%s.\n", srv_encrypt); } + } + /* NOTREACHED */ + return (-1); +} - errstr = newvstralloc(errstr, - "unknown response: ", - line, - NULL); - response_error = 2; + +/* -------------------- */ + +static void +sendbackup_response(datap, pkt, sech) + void *datap; + pkt_t *pkt; + security_handle_t *sech; +{ + int ports[NSTREAMS], *response_error = datap, i; + char *p; + char *tok; + char *tok_end; + char *extra = NULL; + + assert(response_error != NULL); + assert(sech != NULL); + + if (pkt == NULL) { + errstr = newvstralloc(errstr, "[request failed: ", + security_geterror(sech), "]", NULL); + *response_error = 1; return; } - if (data_port == -1 || mesg_port == -1) { - errstr = newvstralloc(errstr, "bad CONNECT response", NULL); - response_error = 2; + if (pkt->type == P_NAK) { +#if defined(PACKET_DEBUG) + fprintf(stderr, "got nak response:\n----\n%s\n----\n\n", pkt->body); +#endif + + tok = strtok(pkt->body, " "); + if (tok == NULL || strcmp(tok, "ERROR") != 0) + goto bad_nak; + + tok = strtok(NULL, "\n"); + if (tok != NULL) { + errstr = newvstralloc(errstr, "NAK: ", tok, NULL); + *response_error = 1; + } else { +bad_nak: + errstr = newstralloc(errstr, "request NAK"); + *response_error = 2; + } return; } - datafd = stream_client(hostname, data_port, -1, -1, NULL); - if(datafd == -1) { - errstr = newvstralloc(errstr, - "could not connect to data port: ", - strerror(errno), - NULL); - response_error = 1; + if (pkt->type != P_REP) { + errstr = newvstralloc(errstr, "received strange packet type ", + pkt_type2str(pkt->type), ": ", pkt->body, NULL); + *response_error = 1; return; } - mesgfd = stream_client(hostname, mesg_port, -1, -1, NULL); - if(mesgfd == -1) { - errstr = newvstralloc(errstr, - "could not connect to mesg port: ", - strerror(errno), - NULL); - aclose(datafd); - datafd = -1; /* redundant */ - response_error = 1; - return; + +#if defined(PACKET_DEBUG) + fprintf(stderr, "got response:\n----\n%s\n----\n\n", pkt->body); +#endif + + for(i = 0; i < NSTREAMS; i++) { + ports[i] = -1; + streams[i].fd = NULL; } - if (index_port != -1) { - indexfd = stream_client(hostname, index_port, -1, -1, NULL); - if (indexfd == -1) { - errstr = newvstralloc(errstr, - "could not connect to index port: ", - strerror(errno), - NULL); - aclose(datafd); - aclose(mesgfd); - datafd = mesgfd = -1; /* redundant */ - response_error = 1; + p = pkt->body; + while((tok = strtok(p, " \n")) != NULL) { + p = NULL; + + /* + * Error response packets have "ERROR" followed by the error message + * followed by a newline. + */ + if (strcmp(tok, "ERROR") == 0) { + tok = strtok(NULL, "\n"); + if (tok == NULL) + tok = "[bogus error packet]"; + errstr = newstralloc(errstr, tok); + *response_error = 2; return; } + + /* + * Regular packets have CONNECT followed by three streams + */ + if (strcmp(tok, "CONNECT") == 0) { + + /* + * Parse the three stream specifiers out of the packet. + */ + for (i = 0; i < NSTREAMS; i++) { + tok = strtok(NULL, " "); + if (tok == NULL || strcmp(tok, streams[i].name) != 0) { + extra = vstralloc("CONNECT token is \"", + tok ? tok : "(null)", + "\": expected \"", + streams[i].name, + "\"", + NULL); + goto parse_error; + } + tok = strtok(NULL, " \n"); + if (tok == NULL || sscanf(tok, "%d", &ports[i]) != 1) { + extra = vstralloc("CONNECT ", + streams[i].name, + " token is \"", + tok ? tok : "(null)", + "\": expected a port number", + NULL); + goto parse_error; + } + } + continue; + } + + /* + * OPTIONS [options string] '\n' + */ + if (strcmp(tok, "OPTIONS") == 0) { + tok = strtok(NULL, "\n"); + if (tok == NULL) { + extra = stralloc("OPTIONS token is missing"); + goto parse_error; + } + tok_end = tok + strlen(tok); + + while((p = strchr(tok, ';')) != NULL) { + *p++ = '\0'; +#define sc "features=" + if(strncmp(tok, sc, sizeof(sc)-1) == 0) { + tok += sizeof(sc) - 1; +#undef sc + am_release_feature_set(their_features); + if((their_features = am_string_to_feature(tok)) == NULL) { + errstr = newvstralloc(errstr, + "OPTIONS: bad features value: ", + tok, + NULL); + goto parse_error; + } + } + tok = p; + } + continue; + } + + extra = vstralloc("next token is \"", + tok ? tok : "(null)", + "\": expected \"CONNECT\", \"ERROR\" or \"OPTIONS\"", + NULL); + goto parse_error; } - /* everything worked */ + /* + * Connect the streams to their remote ports + */ + for (i = 0; i < NSTREAMS; i++) { + if (ports[i] == -1) + continue; + streams[i].fd = security_stream_client(sech, ports[i]); + if (streams[i].fd == NULL) { + errstr = newvstralloc(errstr, + "[could not connect ", streams[i].name, " stream: ", + security_geterror(sech), "]", NULL); + goto connect_error; + } + } + /* + * Authenticate the streams + */ + for (i = 0; i < NSTREAMS; i++) { + if (streams[i].fd == NULL) + continue; #ifdef KRB4_SECURITY - if(krb4_auth && kerberos_handshake(datafd, cred.session) == 0) { - errstr = newstralloc(errstr, - "mutual authentication in data stream failed"); - aclose(datafd); - aclose(mesgfd); - if (indexfd != -1) - aclose(indexfd); - response_error = 1; - return; + /* + * XXX krb4 historically never authenticated the index stream! + * We need to reproduce this lossage here to preserve compatibility + * with old clients. + * It is wrong to delve into sech, but we have no choice here. + */ + if (strcasecmp(sech->driver->name, "krb4") != 0 && i == INDEXFD) + continue; +#endif + if (security_stream_auth(streams[i].fd) < 0) { + errstr = newvstralloc(errstr, + "[could not authenticate ", streams[i].name, " stream: ", + security_stream_geterror(streams[i].fd), "]", NULL); + goto connect_error; + } } - if(krb4_auth && kerberos_handshake(mesgfd, cred.session) == 0) { - errstr = newstralloc(errstr, - "mutual authentication in mesg stream failed"); - aclose(datafd); - if (indexfd != -1) - aclose(indexfd); - aclose(mesgfd); - response_error = 1; - return; + + /* + * The MESGFD and DATAFD streams are mandatory. If we didn't get + * them, complain. + */ + if (streams[MESGFD].fd == NULL || streams[DATAFD].fd == NULL) { + errstr = newstralloc(errstr, "[couldn't open MESG or INDEX streams]"); + goto connect_error; } -#endif - response_error = 0; + + /* everything worked */ + *response_error = 0; + return; + +parse_error: + errstr = newvstralloc(errstr, + "[parse of reply message failed: ", + extra ? extra : "(no additional information)", + "]", + NULL); + amfree(extra); + *response_error = 2; return; + +connect_error: + stop_dump(); + *response_error = 1; } -int startup_dump(hostname, disk, device, level, dumpdate, progname, options) -char *hostname, *disk, *device, *dumpdate, *progname, *options; -int level; +static int +startup_dump(hostname, disk, device, level, dumpdate, progname, options) + const char *hostname, *disk, *device, *dumpdate, *progname, *options; + int level; { char level_string[NUM_STR_SIZE]; char *req = NULL; - int rc; + char *authopt, *endauthopt, authoptbuf[64]; + int response_error; + const security_driver_t *secdrv; + char *dumper_api; int has_features = am_has_feature(their_features, fe_req_options_features); int has_hostname = am_has_feature(their_features, fe_req_options_hostname); int has_device = am_has_feature(their_features, fe_sendbackup_req_device); - ap_snprintf(level_string, sizeof(level_string), "%d", level); + /* + * Default to bsd authentication if none specified. This is gross. + * + * Options really need to be pre-parsed into some sort of structure + * much earlier, and then flattened out again before transmission. + */ + if ((authopt = strstr(options, "auth=")) == NULL + || (endauthopt = strchr(authopt, ';')) == NULL + || (sizeof(authoptbuf) - 1 < endauthopt - authopt)) { + authopt = "BSD"; + } else { + authopt += strlen("auth="); + strncpy(authoptbuf, authopt, endauthopt - authopt); + authoptbuf[endauthopt - authopt] = '\0'; + authopt = authoptbuf; + } + + snprintf(level_string, sizeof(level_string), "%d", level); + if(strncmp(progname, "DUMP", 4) == 0 + || strncmp(progname, "GNUTAR", 6) == 0) { + dumper_api = ""; + } else { + dumper_api = "DUMPER "; + } req = vstralloc("SERVICE sendbackup\n", "OPTIONS ", has_features ? "features=" : "", @@ -1798,74 +1750,28 @@ int level; has_hostname ? hostname : "", has_hostname ? ";" : "", "\n", - progname, + dumper_api, progname, " ", disk, " ", device && has_device ? device : "", " ", level_string, " ", dumpdate, - " ", "OPTIONS ", options, + " OPTIONS ", options, + /* compat: if auth=krb4, send krb4-auth */ + (strcasecmp(authopt, "krb4") ? "" : "krb4-auth"), "\n", NULL); - datafd = mesgfd = indexfd = -1; + secdrv = security_getdriver(authopt); + if (secdrv == NULL) { + error("no '%s' security driver available for host '%s'", + authopt, hostname); + } -#ifdef KRB4_SECURITY - if(krb4_auth) { - char rc_str[NUM_STR_SIZE]; - - rc = make_krb_request(hostname, kamanda_port, req, NULL, - STARTUP_TIMEOUT, sendbackup_response); - if(!rc) { - char inst[256], realm[256]; -#define HOSTNAME_INSTANCE inst - /* - * This repeats a lot of work with make_krb_request, but it's - * ultimately the kerberos library's fault: krb_mk_req calls - * krb_get_cred, but doesn't make the session key available! - * XXX: But admittedly, we could restructure a bit here and - * at least eliminate the duplicate gethostbyname(). - */ - if(host2krbname(hostname, inst, realm) == 0) - rc = -1; - else - rc = krb_get_cred(CLIENT_HOST_PRINCIPLE, CLIENT_HOST_INSTANCE, - realm, &cred); - if(rc > 0 ) { - ap_snprintf(rc_str, sizeof(rc_str), "%d", rc); - errstr = newvstralloc(errstr, - "[host ", hostname, - ": krb4 error (krb_get_cred) ", - rc_str, - ": ", krb_err_txt[rc], - NULL); - amfree(req); - return 2; - } - } - if(rc > 0) { - ap_snprintf(rc_str, sizeof(rc_str), "%d", rc); - errstr = newvstralloc(errstr, - "[host ", hostname, - ": krb4 error (make_krb_req) ", - rc_str, - ": ", krb_err_txt[rc], - NULL); - amfree(req); - return 2; - } - } else -#endif - rc = make_request(hostname, amanda_port, req, NULL, - STARTUP_TIMEOUT, sendbackup_response); + protocol_sendreq(hostname, secdrv, generic_get_security_conf, req, + STARTUP_TIMEOUT, sendbackup_response, &response_error); - req = NULL; /* do not own this any more */ + amfree(req); - if(rc) { - errstr = newvstralloc(errstr, - "[could not resolve name \"", hostname, "\"]", - NULL); - return 2; - } - run_protocol(); - return response_error; + protocol_run(); + return (response_error); }