char *disk2serial(
disk_t *dp)
{
int s;
static char str[NUM_STR_SIZE];
for(s = 0; s < MAX_SERIAL; s++) {
if(stable[s].dp == dp) {
g_snprintf(str, sizeof(str), "%02d-%05ld", s, stable[s].gen);
return str;
}
}
/* find unused serial number */
for(s = 0; s < MAX_SERIAL; s++)
if(stable[s].gen == 0 && stable[s].dp == NULL)
break;
if(s >= MAX_SERIAL) {
g_printf(_("driver: error time %s bug: out of serial numbers\n"),
walltime_str(curclock()));
s = 0;
}
stable[s].gen = generation++;
stable[s].dp = dp;
g_snprintf(str, sizeof(str), "%02d-%05ld", s, stable[s].gen);
return str;
}
void
check_unfree_serial(void)
{
int s;
/* find used serial number */
for(s = 0; s < MAX_SERIAL; s++) {
if(stable[s].gen != 0 || stable[s].dp != NULL) {
g_printf(_("driver: error time %s bug: serial in use: %02d-%05ld\n"),
walltime_str(curclock()), s, stable[s].gen);
}
}
}
void
free_serial_dp(
disk_t *dp)
{
int s;
for(s = 0; s < MAX_SERIAL; s++) {
if(stable[s].dp == dp) {
stable[s].gen = 0;
stable[s].dp = NULL;
return;
}
}
g_printf(_("driver: error time %s serial not found for disk %s\n"),
walltime_str(curclock()), dp->name);
}
cmd_t
getresult(
int fd,
int show,
int *result_argc,
char ***result_argv)
{
cmd_t t;
char *line;
if((line = areads(fd)) == NULL) {
if(errno) {
error(_("reading result from %s: %s"), childstr(fd), strerror(errno));
/*NOTREACHED*/
}
*result_argv = NULL;
*result_argc = 0; /* EOF */
} else {
*result_argv = split_quoted_strings(line);
*result_argc = g_strv_length(*result_argv);
}
if(show) {
g_printf(_("driver: result time %s from %s:"),
walltime_str(curclock()),
childstr(fd));
if(line) {
g_printf(" %s", line);
putchar('\n');
} else {
g_printf(" (eof)\n");
}
fflush(stdout);
}
amfree(line);
if(*result_argc < 1) return BOGUS;
for(t = (cmd_t)(BOGUS+1); t < LAST_TOK; t++)
if(strcmp((*result_argv)[0], cmdstr[t]) == 0) return t;
return BOGUS;
}
disk_t *
serial2disk(
char *str)
{
int rc, s;
long gen;
rc = sscanf(str, "%d-%ld", &s, &gen);
if(rc != 2) {
error(_("error [serial2disk \"%s\" parse error]"), str);
/*NOTREACHED*/
} else if (s < 0 || s >= MAX_SERIAL) {
error(_("error [serial out of range 0..%d: %d]"), MAX_SERIAL, s);
/*NOTREACHED*/
}
if(gen != stable[s].gen)
g_printf(_("driver: serial2disk error time %s serial gen mismatch %s\n"),
walltime_str(curclock()), str);
return stable[s].dp;
}
void
free_serial(
char *str)
{
int rc, s;
long gen;
rc = sscanf(str, _("%d-%ld"), &s, &gen);
if(!(rc == 2 && s >= 0 && s < MAX_SERIAL)) {
/* nuke self to get core dump for Brett */
g_fprintf(stderr, _("driver: free_serial: str \"%s\" rc %d s %d\n"),
str, rc, s);
fflush(stderr);
abort();
}
if(gen != stable[s].gen)
g_printf(_("driver: free_serial error time %s serial gen mismatch %s\n"),
walltime_str(curclock()),str);
stable[s].gen = 0;
stable[s].dp = NULL;
}
int
chunker_cmd(
chunker_t *chunker,
cmd_t cmd,
disk_t *dp,
char *mesg)
{
char *cmdline = NULL;
char number[NUM_STR_SIZE];
char chunksize[NUM_STR_SIZE];
char use[NUM_STR_SIZE];
char *o;
int activehd=0;
assignedhd_t **h=NULL;
char *features;
char *qname;
char *qdest;
switch(cmd) {
case START:
cmdline = g_strjoin(NULL, cmdstr[cmd], " ", mesg, "\n", NULL);
break;
case PORT_WRITE:
if(dp && sched(dp) && sched(dp)->holdp) {
h = sched(dp)->holdp;
activehd = sched(dp)->activehd;
}
if (dp && h) {
qname = quote_string(dp->name);
qdest = quote_string(sched(dp)->destname);
h[activehd]->disk->allocated_dumpers++;
g_snprintf(number, sizeof(number), "%d", sched(dp)->level);
g_snprintf(chunksize, sizeof(chunksize), "%lld",
(long long)holdingdisk_get_chunksize(h[0]->disk->hdisk));
g_snprintf(use, sizeof(use), "%lld",
(long long)h[0]->reserved);
features = am_feature_to_string(dp->host->features);
o = optionstr(dp);
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", disk2serial(dp),
" ", qdest,
" ", dp->host->hostname,
" ", features,
" ", qname,
" ", number,
" ", mesg, /* datestamp */
" ", chunksize,
" ", dp->program,
" ", use,
" |", o,
"\n", NULL);
amfree(features);
amfree(o);
amfree(qdest);
amfree(qname);
} else {
error(_("%s command without disk and holding disk.\n"),
cmdstr[cmd]);
/*NOTREACHED*/
}
break;
case CONTINUE:
if(dp && sched(dp) && sched(dp)->holdp) {
h = sched(dp)->holdp;
activehd = sched(dp)->activehd;
}
if(dp && h) {
qname = quote_string(dp->name);
qdest = quote_string(h[activehd]->destname);
h[activehd]->disk->allocated_dumpers++;
g_snprintf(chunksize, sizeof(chunksize), "%lld",
(long long)holdingdisk_get_chunksize(h[activehd]->disk->hdisk));
g_snprintf(use, sizeof(use), "%lld",
(long long)(h[activehd]->reserved - h[activehd]->used));
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", disk2serial(dp),
" ", qdest,
" ", chunksize,
" ", use,
"\n", NULL );
amfree(qdest);
amfree(qname);
} else {
cmdline = g_strconcat(cmdstr[cmd], "\n", NULL);
}
break;
case QUIT:
cmdline = g_strjoin(NULL, cmdstr[cmd], "\n", NULL);
break;
case ABORT:
{
char *q = quote_string(mesg);
cmdline = g_strjoin(NULL, cmdstr[cmd], " ", q, "\n", NULL);
amfree(q);
}
break;
case DONE:
case FAILED:
if( dp ) {
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", disk2serial(dp),
"\n", NULL);
} else {
cmdline = g_strjoin(NULL, cmdstr[cmd], "\n", NULL);
}
break;
default:
error(_("Don't know how to send %s command to chunker"), cmdstr[cmd]);
/*NOTREACHED*/
}
/*
* Note: cmdline already has a '\n'.
*/
g_printf(_("driver: send-cmd time %s to %s: %s"),
walltime_str(curclock()), chunker->name, cmdline);
fflush(stdout);
if (full_write(chunker->fd, cmdline, strlen(cmdline)) < strlen(cmdline)) {
g_printf(_("writing %s command: %s\n"), chunker->name, strerror(errno));
fflush(stdout);
amfree(cmdline);
return 0;
}
if (cmd == QUIT) aclose(chunker->fd);
amfree(cmdline);
return 1;
}
int
dumper_cmd(
dumper_t *dumper,
cmd_t cmd,
disk_t *dp,
char *mesg)
{
char *cmdline;
char *qmesg;
switch(cmd) {
case START:
cmdline = g_strdup_printf("%s %s\n", cmdstr[cmd], mesg);
break;
case PORT_DUMP: {
application_t *application = NULL;
GPtrArray *array;
GString *strbuf;
gchar **args;
am_feature_t *features;
char *device, *plugin;
char *tmp;
if (!dp)
error("PORT-DUMP without disk pointer\n");
array = g_ptr_array_new();
features = dp->host->features;
device = (dp->device) ? dp->device : "NODEVICE";
if (dp->application != NULL) {
application = lookup_application(dp->application);
g_assert(application != NULL);
}
g_ptr_array_add(array, g_strdup(cmdstr[cmd]));
g_ptr_array_add(array, g_strdup(disk2serial(dp)));
g_ptr_array_add(array, g_strdup_printf("%d", dumper->output_port));
g_ptr_array_add(array, g_strdup(dp->host->hostname));
g_ptr_array_add(array, am_feature_to_string(features));
g_ptr_array_add(array, quote_string(dp->name));
g_ptr_array_add(array, quote_string(device));
g_ptr_array_add(array, g_strdup_printf("%d", sched(dp)->level));
g_ptr_array_add(array, g_strdup(sched(dp)->dumpdate));
/*
* Build the last argument
*/
strbuf = g_string_new("|");
if (am_has_feature(features, fe_req_xml)) {
char *qtmp;
tmp = xml_optionstr(dp, 1);
qtmp = quote_string(tmp);
g_free(tmp);
g_string_append(strbuf, qtmp);
g_free(qtmp);
tmp = xml_dumptype_properties(dp);
qtmp = quote_string(tmp);
g_free(tmp);
g_string_append(strbuf, qtmp);
g_free(qtmp);
if (application) {
tmp = xml_application(dp, application, features);
qtmp = quote_string(tmp);
g_free(tmp);
g_string_append(strbuf, qtmp);
g_free(qtmp);
}
} else {
tmp = optionstr(dp);
g_string_append(strbuf, tmp);
g_free(tmp);
}
g_string_append_c(strbuf, '\n');
g_assert(dp->program != NULL);
if (g_str_equal(dp->program, "APPLICATION")) {
g_assert(application != NULL);
plugin = application_get_plugin(application);
} else {
plugin = dp->program;
}
g_ptr_array_add(array, quote_string(plugin));
g_ptr_array_add(array, quote_string(dp->amandad_path));
g_ptr_array_add(array, quote_string(dp->client_username));
g_ptr_array_add(array, quote_string(dp->client_port));
g_ptr_array_add(array, quote_string(dp->ssh_keys));
g_ptr_array_add(array, g_strdup(dp->auth));
g_ptr_array_add(array, g_strdup(data_path_to_string(dp->data_path)));
g_ptr_array_add(array, g_strdup(dp->dataport_list));
g_ptr_array_add(array, g_strdup_printf("%d", dp->max_warnings));
g_ptr_array_add(array, g_string_free(strbuf, FALSE));
g_ptr_array_add(array, NULL);
args = (gchar **)g_ptr_array_free(array, FALSE);
cmdline = g_strjoinv(" ", args);
g_strfreev(args);
break;
}
case QUIT:
case ABORT:
qmesg = quote_string(mesg);
cmdline = g_strdup_printf("%s %s\n", cmdstr[cmd], qmesg);
amfree(qmesg);
break;
default:
error("Don't know how to send %s command to dumper", cmdstr[cmd]);
/*NOTREACHED*/
}
/*
* Note: cmdline already has a '\n'.
*/
if(dumper->down) {
g_printf(_("driver: send-cmd time %s ignored to down dumper %s: %s"),
walltime_str(curclock()), dumper->name, cmdline);
} else {
g_printf(_("driver: send-cmd time %s to %s: %s"),
walltime_str(curclock()), dumper->name, cmdline);
fflush(stdout);
if (full_write(dumper->fd, cmdline, strlen(cmdline)) < strlen(cmdline)) {
g_printf(_("writing %s command: %s\n"), dumper->name, strerror(errno));
fflush(stdout);
g_free(cmdline);
return 0;
}
if (cmd == QUIT) aclose(dumper->fd);
}
g_free(cmdline);
return 1;
}
int
taper_cmd(
cmd_t cmd,
void *ptr,
char *destname,
int level,
char *datestamp)
{
char *cmdline = NULL;
char number[NUM_STR_SIZE];
char orig_kb[NUM_STR_SIZE];
char *data_path;
disk_t *dp;
char *qname;
char *qdest;
char *q;
char *splitargs;
uintmax_t origsize;
switch(cmd) {
case START_TAPER:
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", destname,
" ", datestamp,
"\n", NULL);
break;
case CLOSE_VOLUME:
dp = (disk_t *) ptr;
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", sched(dp)->taper->name,
"\n", NULL);
break;
case FILE_WRITE:
dp = (disk_t *) ptr;
qname = quote_string(dp->name);
qdest = quote_string(destname);
g_snprintf(number, sizeof(number), "%d", level);
if (sched(dp)->origsize >= 0)
origsize = sched(dp)->origsize;
else
origsize = 0;
g_snprintf(orig_kb, sizeof(orig_kb), "%ju", origsize);
splitargs = taper_splitting_args(dp);
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", sched(dp)->taper->name,
" ", disk2serial(dp),
" ", qdest,
" ", dp->host->hostname,
" ", qname,
" ", number,
" ", datestamp,
" ", splitargs,
orig_kb,
"\n", NULL);
amfree(splitargs);
amfree(qdest);
amfree(qname);
break;
case PORT_WRITE:
dp = (disk_t *) ptr;
qname = quote_string(dp->name);
g_snprintf(number, sizeof(number), "%d", level);
data_path = data_path_to_string(dp->data_path);
/*
If we haven't been given a place to buffer split dumps to disk,
make the argument something besides and empty string so's taper
won't get confused
*/
splitargs = taper_splitting_args(dp);
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", sched(dp)->taper->name,
" ", disk2serial(dp),
" ", dp->host->hostname,
" ", qname,
" ", number,
" ", datestamp,
" ", splitargs,
data_path,
"\n", NULL);
amfree(splitargs);
amfree(qname);
break;
case DONE: /* handle */
dp = (disk_t *) ptr;
if (sched(dp)->origsize >= 0)
origsize = sched(dp)->origsize;
else
origsize = 0;
g_snprintf(number, sizeof(number), "%ju", origsize);
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", sched(dp)->taper->name,
" ", disk2serial(dp),
" ", number,
"\n", NULL);
break;
case FAILED: /* handle */
dp = (disk_t *) ptr;
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", sched(dp)->taper->name,
" ", disk2serial(dp),
"\n", NULL);
break;
case NO_NEW_TAPE:
dp = (disk_t *) ptr;
q = quote_string(destname); /* reason why no new tape */
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", sched(dp)->taper->name,
" ", disk2serial(dp),
" ", q,
"\n", NULL);
amfree(q);
break;
case NEW_TAPE:
dp = (disk_t *) ptr;
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", sched(dp)->taper->name,
" ", disk2serial(dp),
"\n", NULL);
break;
case START_SCAN:
dp = (disk_t *) ptr;
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", sched(dp)->taper->name,
" ", disk2serial(dp),
"\n", NULL);
break;
case TAKE_SCRIBE_FROM:
dp = (disk_t *) ptr;
cmdline = g_strjoin(NULL, cmdstr[cmd],
" ", sched(dp)->taper->name,
" ", disk2serial(dp),
" ", destname, /* name of worker */
"\n", NULL);
break;
case QUIT:
cmdline = g_strconcat(cmdstr[cmd], "\n", NULL);
break;
default:
error(_("Don't know how to send %s command to taper"), cmdstr[cmd]);
/*NOTREACHED*/
}
/*
* Note: cmdline already has a '\n'.
*/
g_printf(_("driver: send-cmd time %s to taper: %s"),
walltime_str(curclock()), cmdline);
fflush(stdout);
if ((full_write(taper_fd, cmdline, strlen(cmdline))) < strlen(cmdline)) {
g_printf(_("writing taper command '%s' failed: %s\n"),
cmdline, strerror(errno));
fflush(stdout);
amfree(cmdline);
return 0;
}
if(cmd == QUIT) aclose(taper_fd);
amfree(cmdline);
return 1;
}
static void
amgtar_estimate(
application_argument_t *argument)
{
char *incrname = NULL;
GPtrArray *argv_ptr;
char *cmd = NULL;
int nullfd = -1;
int pipefd = -1;
FILE *dumpout = NULL;
off_t size = -1;
char line[32768];
char *errmsg = NULL;
char *qerrmsg = NULL;
char *qdisk;
amwait_t wait_status;
int tarpid;
amregex_t *rp;
times_t start_time;
int level;
GSList *levels;
if (!argument->level) {
fprintf(stderr, "ERROR No level argument\n");
error(_("No level argument"));
}
if (!argument->dle.disk) {
fprintf(stderr, "ERROR No disk argument\n");
error(_("No disk argument"));
}
if (!argument->dle.device) {
fprintf(stderr, "ERROR No device argument\n");
error(_("No device argument"));
}
qdisk = quote_string(argument->dle.disk);
if (argument->calcsize) {
char *dirname;
char *file_exclude;
char *file_include;
int nb_exclude;
int nb_include;
if (gnutar_directory) {
dirname = gnutar_directory;
} else {
dirname = amname_to_dirname(argument->dle.device);
}
amgtar_build_exinclude(&argument->dle, 1,
&nb_exclude, &file_exclude,
&nb_include, &file_include);
run_calcsize(argument->config, "GNUTAR", argument->dle.disk, dirname,
argument->level, file_exclude, file_include);
return;
}
if (!gnutar_path) {
errmsg = vstrallocf(_("GNUTAR-PATH not defined"));
goto common_error;
}
if (!gnutar_listdir) {
errmsg = vstrallocf(_("GNUTAR-LISTDIR not defined"));
goto common_error;
}
for (levels = argument->level; levels != NULL; levels = levels->next) {
level = GPOINTER_TO_INT(levels->data);
incrname = amgtar_get_incrname(argument, level);
cmd = stralloc(gnutar_path);
argv_ptr = amgtar_build_argv(argument, incrname, CMD_ESTIMATE);
start_time = curclock();
if ((nullfd = open("/dev/null", O_RDWR)) == -1) {
errmsg = vstrallocf(_("Cannot access /dev/null : %s"),
strerror(errno));
goto common_exit;
}
tarpid = pipespawnv(cmd, STDERR_PIPE, 1,
&nullfd, &nullfd, &pipefd,
(char **)argv_ptr->pdata);
dumpout = fdopen(pipefd,"r");
if (!dumpout) {
error(_("Can't fdopen: %s"), strerror(errno));
/*NOTREACHED*/
}
size = (off_t)-1;
while (size < 0 && (fgets(line, sizeof(line), dumpout) != NULL)) {
if (line[strlen(line)-1] == '\n') /* remove trailling \n */
line[strlen(line)-1] = '\0';
if (line[0] == '\0')
continue;
dbprintf("%s\n", line);
/* check for size match */
/*@ignore@*/
for(rp = re_table; rp->regex != NULL; rp++) {
if(match(rp->regex, line)) {
if (rp->typ == DMP_SIZE) {
size = ((the_num(line, rp->field)*rp->scale+1023.0)/1024.0);
if(size < 0.0)
size = 1.0; /* found on NeXT -- sigh */
}
break;
}
}
/*@end@*/
}
while (fgets(line, sizeof(line), dumpout) != NULL) {
dbprintf("%s", line);
}
dbprintf(".....\n");
dbprintf(_("estimate time for %s level %d: %s\n"),
qdisk,
level,
walltime_str(timessub(curclock(), start_time)));
if(size == (off_t)-1) {
errmsg = vstrallocf(_("no size line match in %s output"), cmd);
dbprintf(_("%s for %s\n"), errmsg, qdisk);
dbprintf(".....\n");
} else if(size == (off_t)0 && argument->level == 0) {
dbprintf(_("possible %s problem -- is \"%s\" really empty?\n"),
cmd, argument->dle.disk);
dbprintf(".....\n");
}
dbprintf(_("estimate size for %s level %d: %lld KB\n"),
qdisk,
level,
(long long)size);
kill(-tarpid, SIGTERM);
dbprintf(_("waiting for %s \"%s\" child\n"), cmd, qdisk);
waitpid(tarpid, &wait_status, 0);
if (WIFSIGNALED(wait_status)) {
errmsg = vstrallocf(_("%s terminated with signal %d: see %s"),
cmd, WTERMSIG(wait_status), dbfn());
} else if (WIFEXITED(wait_status)) {
if (exit_value[WEXITSTATUS(wait_status)] == 1) {
errmsg = vstrallocf(_("%s exited with status %d: see %s"),
cmd, WEXITSTATUS(wait_status), dbfn());
} else {
/* Normal exit */
}
} else {
errmsg = vstrallocf(_("%s got bad exit: see %s"),
cmd, dbfn());
}
dbprintf(_("after %s %s wait\n"), cmd, qdisk);
common_exit:
if (errmsg) {
dbprintf("%s", errmsg);
fprintf(stdout, "ERROR %s\n", errmsg);
}
if (incrname) {
unlink(incrname);
}
g_ptr_array_free_full(argv_ptr);
amfree(cmd);
aclose(nullfd);
afclose(dumpout);
fprintf(stdout, "%d %lld 1\n", level, (long long)size);
}
amfree(qdisk);
return;
common_error:
qerrmsg = quote_string(errmsg);
amfree(qdisk);
dbprintf("%s", errmsg);
fprintf(stdout, "ERROR %s\n", qerrmsg);
amfree(errmsg);
amfree(qerrmsg);
return;
}
int
main(
int argc,
char ** argv)
{
static struct databuf db;
struct cmdargs *cmdargs;
int infd;
char *q = NULL;
char *filename = NULL;
off_t chunksize, use;
times_t runtime;
am_feature_t *their_features = NULL;
int a;
config_overrides_t *cfg_ovr = NULL;
char *cfg_opt = NULL;
char *m;
/*
* Configure program for internationalization:
* 1) Only set the message locale for now.
* 2) Set textdomain for all amanda related programs to "amanda"
* We don't want to be forced to support dozens of message catalogs.
*/
setlocale(LC_MESSAGES, "C");
textdomain("amanda");
safe_fd(-1, 0);
set_pname("chunker");
dbopen(DBG_SUBDIR_SERVER);
/* Don't die when child closes pipe */
signal(SIGPIPE, SIG_IGN);
add_amanda_log_handler(amanda_log_stderr);
add_amanda_log_handler(amanda_log_trace_log);
cfg_ovr = extract_commandline_config_overrides(&argc, &argv);
if (argc > 1)
cfg_opt = argv[1];
config_init(CONFIG_INIT_EXPLICIT_NAME | CONFIG_INIT_USE_CWD, cfg_opt);
apply_config_overrides(cfg_ovr);
if (config_errors(NULL) >= CFGERR_WARNINGS) {
config_print_errors();
if (config_errors(NULL) >= CFGERR_ERRORS) {
g_critical(_("errors processing config file"));
}
}
safe_cd(); /* do this *after* config_init() */
check_running_as(RUNNING_AS_DUMPUSER);
dbrename(get_config_name(), DBG_SUBDIR_SERVER);
log_add(L_INFO, "%s pid %ld", get_pname(), (long)getpid());
g_fprintf(stderr,
_("%s: pid %ld executable %s version %s\n"),
get_pname(), (long) getpid(),
argv[0], VERSION);
fflush(stderr);
/* now, make sure we are a valid user */
signal(SIGPIPE, SIG_IGN);
signal(SIGCHLD, SIG_IGN);
cmdargs = getcmd();
if(cmdargs->cmd == START) {
if(cmdargs->argc <= 1)
error(_("error [dumper START: not enough args: timestamp]"));
chunker_timestamp = newstralloc(chunker_timestamp, cmdargs->argv[1]);
}
else {
log_add(L_INFO, "%s pid %ld", get_pname(), (long)getpid());
error(_("Didn't get START command"));
}
/* do {*/
cmdargs = getcmd();
switch(cmdargs->cmd) {
case QUIT:
break;
case PORT_WRITE:
/*
* PORT-WRITE
* handle
* filename
* host
* features
* disk
* level
* dumpdate
* chunksize
* progname
* use
* options
*/
a = 1;
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: handle]"));
/*NOTREACHED*/
}
handle = newstralloc(handle, cmdargs->argv[a++]);
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: filename]"));
/*NOTREACHED*/
}
filename = newstralloc(filename, cmdargs->argv[a++]);
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: hostname]"));
/*NOTREACHED*/
}
hostname = newstralloc(hostname, cmdargs->argv[a++]);
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: features]"));
/*NOTREACHED*/
}
am_release_feature_set(their_features);
their_features = am_string_to_feature(cmdargs->argv[a++]);
if (!their_features) {
error(_("error [chunker PORT-WRITE: invalid feature string]"));
/*NOTREACHED*/
}
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: diskname]"));
/*NOTREACHED*/
}
diskname = newstralloc(diskname, cmdargs->argv[a++]);
if (qdiskname)
amfree(qdiskname);
qdiskname = quote_string(diskname); /* qdiskname is a global */
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: level]"));
/*NOTREACHED*/
}
level = atoi(cmdargs->argv[a++]);
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: dumpdate]"));
/*NOTREACHED*/
}
dumpdate = newstralloc(dumpdate, cmdargs->argv[a++]);
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: chunksize]"));
/*NOTREACHED*/
}
chunksize = OFF_T_ATOI(cmdargs->argv[a++]);
chunksize = am_floor(chunksize, (off_t)DISK_BLOCK_KB);
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: progname]"));
/*NOTREACHED*/
}
progname = newstralloc(progname, cmdargs->argv[a++]);
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: use]"));
/*NOTREACHED*/
}
use = am_floor(OFF_T_ATOI(cmdargs->argv[a++]), DISK_BLOCK_KB);
if(a >= cmdargs->argc) {
error(_("error [chunker PORT-WRITE: not enough args: options]"));
/*NOTREACHED*/
}
options = newstralloc(options, cmdargs->argv[a++]);
if(a != cmdargs->argc) {
error(_("error [chunker PORT-WRITE: too many args: %d != %d]"),
cmdargs->argc, a);
/*NOTREACHED*/
}
if((infd = startup_chunker(filename, use, chunksize, &db)) < 0) {
q = quote_string(vstrallocf(_("[chunker startup failed: %s]"), errstr));
putresult(TRYAGAIN, "%s %s\n", handle, q);
error("startup_chunker failed: %s", errstr);
}
command_in_transit = NULL;
if(infd >= 0 && do_chunk(infd, &db)) {
char kb_str[NUM_STR_SIZE];
char kps_str[NUM_STR_SIZE];
double rt;
runtime = stopclock();
rt = g_timeval_to_double(runtime);
g_snprintf(kb_str, SIZEOF(kb_str), "%lld",
(long long)(dumpsize - (off_t)headersize));
g_snprintf(kps_str, SIZEOF(kps_str), "%3.1lf",
isnormal(rt) ? (double)dumpsize / rt : 0.0);
errstr = newvstrallocf(errstr, "sec %s kb %s kps %s",
walltime_str(runtime), kb_str, kps_str);
m = vstrallocf("[%s]", errstr);
q = quote_string(m);
amfree(m);
if(command_in_transit != NULL) {
cmdargs = command_in_transit;
command_in_transit = NULL;
} else {
cmdargs = getcmd();
}
switch(cmdargs->cmd) {
case DONE:
putresult(DONE, "%s %lld %s\n", handle,
(long long)(dumpsize - (off_t)headersize), q);
log_add(L_SUCCESS, "%s %s %s %d [%s]",
hostname, qdiskname, chunker_timestamp, level, errstr);
break;
case BOGUS:
case TRYAGAIN:
case FAILED:
case ABORT_FINISHED:
if(dumpsize > (off_t)DISK_BLOCK_KB) {
putresult(PARTIAL, "%s %lld %s\n", handle,
(long long)(dumpsize - (off_t)headersize),
q);
log_add(L_PARTIAL, "%s %s %s %d [%s]",
hostname, qdiskname, chunker_timestamp, level, errstr);
}
else {
errstr = newvstrallocf(errstr,
_("dumper returned %s"), cmdstr[cmdargs->cmd]);
amfree(q);
m = vstrallocf("[%s]",errstr);
q = quote_string(m);
amfree(m);
putresult(FAILED, "%s %s\n", handle, q);
log_add(L_FAIL, "%s %s %s %d [%s]",
hostname, qdiskname, chunker_timestamp, level, errstr);
}
default:
break;
}
amfree(q);
} else if(infd != -2) {
if(q == NULL) {
m = vstrallocf("[%s]", errstr);
q = quote_string(m);
amfree(m);
}
if(!abort_pending) {
putresult(FAILED, "%s %s\n", handle, q);
}
log_add(L_FAIL, "%s %s %s %d [%s]",
hostname, qdiskname, chunker_timestamp, level, errstr);
amfree(q);
}
amfree(filename);
amfree(db.filename);
break;
default:
if(cmdargs->argc >= 1) {
q = quote_string(cmdargs->argv[0]);
} else {
q = stralloc(_("(no input?)"));
}
putresult(BAD_COMMAND, "%s\n", q);
amfree(q);
break;
}
/* } while(cmdargs->cmd != QUIT); */
log_add(L_INFO, "pid-done %ld", (long)getpid());
amfree(errstr);
amfree(chunker_timestamp);
amfree(handle);
amfree(hostname);
amfree(diskname);
amfree(qdiskname);
amfree(dumpdate);
amfree(progname);
amfree(options);
free_cmdargs(cmdargs);
if (command_in_transit)
free_cmdargs(command_in_transit);
am_release_feature_set(their_features);
their_features = NULL;
dbclose();
return (0); /* exit */
}
int
dumper_cmd(
dumper_t *dumper,
cmd_t cmd,
disk_t *dp,
char *mesg)
{
char *cmdline = NULL;
char number[NUM_STR_SIZE];
char numberport[NUM_STR_SIZE];
char *o;
char *device;
char *features;
char *qname;
char *qmesg;
switch(cmd) {
case START:
cmdline = vstralloc(cmdstr[cmd], " ", mesg, "\n", NULL);
break;
case PORT_DUMP:
if(dp && dp->device) {
device = dp->device;
}
else {
device = "NODEVICE";
}
if (dp != NULL) {
application_t *application = NULL;
char *plugin;
char *qplugin;
char *qamandad_path;
char *qclient_username;
char *qclient_port;
char *qssh_keys;
if (dp->application != NULL) {
application = lookup_application(dp->application);
g_assert(application != NULL);
}
device = quote_string((dp->device) ? dp->device : "NODEVICE");
qname = quote_string(dp->name);
g_snprintf(number, SIZEOF(number), "%d", sched(dp)->level);
g_snprintf(numberport, SIZEOF(numberport), "%d", dumper->output_port);
features = am_feature_to_string(dp->host->features);
if (am_has_feature(dp->host->features, fe_req_xml)) {
o = xml_optionstr(dp, dp->host->features, NULL, 1);
if (application) {
char *xml_app;
xml_app = xml_application(dp, application,
dp->host->features);
vstrextend(&o, xml_app, NULL);
amfree(xml_app);
}
o = quote_string(o);
} else {
o = optionstr(dp, dp->host->features, NULL);
}
if ( o == NULL ) {
error(_("problem with option string, check the dumptype definition.\n"));
}
g_assert(dp->program);
if (0 == strcmp(dp->program, "APPLICATION")) {
g_assert(application != NULL);
plugin = application_get_plugin(application);
} else {
plugin = dp->program;
}
qplugin = quote_string(plugin);
qamandad_path = quote_string(dp->amandad_path);
qclient_username = quote_string(dp->client_username);
qclient_port = quote_string(dp->client_port);
qssh_keys = quote_string(dp->ssh_keys);
dbprintf("security_driver %s\n", dp->auth);
cmdline = vstralloc(cmdstr[cmd],
" ", disk2serial(dp),
" ", numberport,
" ", dp->host->hostname,
" ", features,
" ", qname,
" ", device,
" ", number,
" ", sched(dp)->dumpdate,
" ", qplugin,
" ", qamandad_path,
" ", qclient_username,
" ", qclient_port,
" ", qssh_keys,
" ", dp->auth,
" ", data_path_to_string(dp->data_path),
" |", o,
"\n", NULL);
amfree(qplugin);
amfree(qamandad_path);
amfree(qclient_username);
amfree(qclient_port);
amfree(qssh_keys);
amfree(features);
amfree(o);
amfree(qname);
amfree(device);
} else {
error(_("PORT-DUMP without disk pointer\n"));
/*NOTREACHED*/
}
break;
case QUIT:
case ABORT:
qmesg = quote_string(mesg);
cmdline = vstralloc(cmdstr[cmd], " ", qmesg, "\n", NULL );
amfree(qmesg);
break;
default:
error(_("Don't know how to send %s command to dumper"), cmdstr[cmd]);
/*NOTREACHED*/
}
/*
* Note: cmdline already has a '\n'.
*/
if(dumper->down) {
g_printf(_("driver: send-cmd time %s ignored to down dumper %s: %s"),
walltime_str(curclock()), dumper->name, cmdline);
} else {
g_printf(_("driver: send-cmd time %s to %s: %s"),
walltime_str(curclock()), dumper->name, cmdline);
fflush(stdout);
if (full_write(dumper->fd, cmdline, strlen(cmdline)) < strlen(cmdline)) {
g_printf(_("writing %s command: %s\n"), dumper->name, strerror(errno));
fflush(stdout);
amfree(cmdline);
return 0;
}
if (cmd == QUIT) aclose(dumper->fd);
}
amfree(cmdline);
return 1;
}
int
taper_cmd(
cmd_t cmd,
void *ptr,
char *destname,
int level,
char *datestamp)
{
char *cmdline = NULL;
char number[NUM_STR_SIZE];
char splitsize[NUM_STR_SIZE];
char fallback_splitsize[NUM_STR_SIZE];
char *diskbuffer = NULL;
disk_t *dp;
char *qname;
char *qdest;
char *q;
switch(cmd) {
case START_TAPER:
cmdline = vstralloc(cmdstr[cmd], " ", (char *)ptr, "\n", NULL);
break;
case FILE_WRITE:
dp = (disk_t *) ptr;
qname = quote_string(dp->name);
qdest = quote_string(destname);
g_snprintf(number, SIZEOF(number), "%d", level);
g_snprintf(splitsize, SIZEOF(splitsize), "%lld",
(long long)dp->tape_splitsize * 1024);
cmdline = vstralloc(cmdstr[cmd],
" ", disk2serial(dp),
" ", qdest,
" ", dp->host->hostname,
" ", qname,
" ", number,
" ", datestamp,
" ", splitsize,
"\n", NULL);
amfree(qdest);
amfree(qname);
break;
case PORT_WRITE:
dp = (disk_t *) ptr;
qname = quote_string(dp->name);
g_snprintf(number, SIZEOF(number), "%d", level);
/*
If we haven't been given a place to buffer split dumps to disk,
make the argument something besides and empty string so's taper
won't get confused
*/
if(!dp->split_diskbuffer || dp->split_diskbuffer[0] == '\0'){
diskbuffer = "NULL";
} else {
diskbuffer = dp->split_diskbuffer;
}
g_snprintf(splitsize, SIZEOF(splitsize), "%lld",
(long long)dp->tape_splitsize * 1024);
g_snprintf(fallback_splitsize, SIZEOF(fallback_splitsize), "%lld",
(long long)dp->fallback_splitsize * 1024);
cmdline = vstralloc(cmdstr[cmd],
" ", disk2serial(dp),
" ", dp->host->hostname,
" ", qname,
" ", number,
" ", datestamp,
" ", splitsize,
" ", diskbuffer,
" ", fallback_splitsize,
" ", data_path_to_string(dp->data_path),
"\n", NULL);
amfree(qname);
break;
case DONE: /* handle */
case FAILED: /* handle */
dp = (disk_t *) ptr;
cmdline = vstralloc(cmdstr[cmd],
" ", disk2serial(dp),
"\n", NULL);
break;
case NO_NEW_TAPE:
q = quote_string((char *)ptr);
cmdline = vstralloc(cmdstr[cmd],
" ", q,
"\n", NULL);
amfree(q);
break;
case NEW_TAPE:
case QUIT:
cmdline = stralloc2(cmdstr[cmd], "\n");
break;
default:
error(_("Don't know how to send %s command to taper"), cmdstr[cmd]);
/*NOTREACHED*/
}
/*
* Note: cmdline already has a '\n'.
*/
g_printf(_("driver: send-cmd time %s to taper: %s"),
walltime_str(curclock()), cmdline);
fflush(stdout);
if ((full_write(taper, cmdline, strlen(cmdline))) < strlen(cmdline)) {
g_printf(_("writing taper command '%s' failed: %s\n"),
cmdline, strerror(errno));
fflush(stdout);
amfree(cmdline);
return 0;
}
if(cmd == QUIT) aclose(taper);
amfree(cmdline);
return 1;
}
