/*
* Amanda, The Advanced Maryland Automatic Network Disk Archiver
* Copyright (c) 1991-1999 University of Maryland at College Park
+ * Copyright (c) 2007-2012 Zmanda, Inc. All Rights Reserved.
* All Rights Reserved.
*
* Permission to use, copy, modify, distribute, and sell this software and its
pid_t encryptpid; /* valid if fd is pipe to encrypt */
};
+struct databuf *g_databuf = NULL;
+
typedef struct filter_s {
int fd;
char *name;
static char *dle_str = NULL;
static char *errfname = NULL;
static int errf_lines = 0;
+static int max_warnings = 0;
static dumpfile_t file;
}
dataport_list = newstralloc(dataport_list, cmdargs->argv[a++]);
+ if(a >= cmdargs->argc) {
+ error(_("error [dumper PORT-DUMP: not enough args: max_warnings]"));
+ }
+ max_warnings = atoi(cmdargs->argv[a++]);
+
if(a >= cmdargs->argc) {
error(_("error [dumper PORT-DUMP: not enough args: options]"));
}
break;
}
databuf_init(&db, outfd);
+ g_databuf = &db;
if (am_has_feature(their_features, fe_req_xml))
xml_check_options(options); /* note: modifies globals */
{
char *line;
int count = 0;
+ int to_unlink = 1;
fflush(errf);
if (fseeko(errf, 0L, SEEK_SET) < 0) {
dbprintf(_("log_msgout: warning - seek failed: %s\n"), strerror(errno));
}
while ((line = agets(errf)) != NULL) {
- if (errf_lines >= 100 && count >= 20)
+ if (max_warnings > 0 && errf_lines >= max_warnings && count >= max_warnings) {
+ log_add(typ, "Look in the '%s' file for full error messages", errfname);
+ to_unlink = 0;
break;
+ }
if (line[0] != '\0') {
log_add(typ, "%s", line);
}
}
amfree(line);
- if (errf_lines >= 100) {
- log_add(typ, "Look in the '%s' file for full error messages", errfname);
- }
-
- return errf_lines < 100;
+ return to_unlink;
}
/* ------------- */
}
/* copy the header in a file on the index dir */
- {
+ if (ISSET(status, HEADER_DONE)) {
FILE *a;
char *s;
char *f = getheaderfname(hostname, diskname, dumper_timestamp, level);
default:
assert(buf != NULL);
add_msg_data(buf, (size_t)size);
- security_stream_read(streams[MESGFD].fd, read_mesgfd, cookie);
break;
}
* Reset the timeout for future reads
*/
timeout(conf_dtimeout);
-
- security_stream_read(streams[DATAFD].fd, read_datafd, cookie);
}
/*
log_add(L_INFO, _("Index corrupted for %s:%s"), hostname, qdiskname);
}
}
- security_stream_read(streams[INDEXFD].fd, read_indexfd, cookie);
}
static void
char *b, *p;
gint64 len;
- event_release(filter->event);
-
if (filter->buffer == NULL) {
/* allocate initial buffer */
filter->buffer = g_malloc(2048);
filter->allocated_size - filter->first - filter->size - 2);
if (nread <= 0) {
+ event_release(filter->event);
aclose(filter->fd);
if (filter->size > 0 && filter->buffer[filter->first + filter->size - 1] != '\n') {
/* Add a '\n' at end of buffer */
if (nread <= 0) {
g_free(filter->buffer);
g_free(filter);
- } else {
- filter->event = event_register((event_id_t)filter->fd, EV_READFD,
- handle_filter_stderr, filter);
}
}
* Startup a timeout in the event handler. If the arg is 0,
* then remove the timeout.
*/
+static event_handle_t *ev_timeout = NULL;
+static time_t timeout_time;
+
static void
timeout(
time_t seconds)
{
- static event_handle_t *ev_timeout = NULL;
+ timeout_time = time(NULL) + seconds;
/*
- * First, remove a timeout if one is active.
+ * remove a timeout if seconds is 0
*/
- if (ev_timeout != NULL) {
- event_release(ev_timeout);
- ev_timeout = NULL;
+ if (seconds == 0) {
+ if (ev_timeout != NULL) {
+ event_release(ev_timeout);
+ ev_timeout = NULL;
+ }
+ return;
}
/*
- * Now, schedule a new one if 'seconds' is greater than 0
+ * schedule a timeout if it not already scheduled
*/
- if (seconds > 0)
- ev_timeout = event_register((event_id_t)seconds, EV_TIME, timeout_callback, NULL);
+ if (ev_timeout == NULL) {
+ ev_timeout = event_register((event_id_t)seconds, EV_TIME,
+ timeout_callback, NULL);
+ }
}
/*
timeout_callback(
void * unused)
{
+ time_t now = time(NULL);
(void)unused; /* Quiet unused parameter warning */
+ if (ev_timeout != NULL) {
+ event_release(ev_timeout);
+ ev_timeout = NULL;
+ }
+
+ if (timeout_time > now) { /* not a data timeout yet */
+ ev_timeout = event_register((event_id_t)(timeout_time-now), EV_TIME,
+ timeout_callback, NULL);
+ return;
+ }
+
assert(unused == NULL);
errstr = newstralloc(errstr, _("data timeout"));
dump_result = 2;
}
}
aclose(indexout);
+ aclose(g_databuf->fd);
timeout(0);
}
return (-1);
}
+ if (comptype != COMP_SERVER_CUST) {
+ g_debug("execute: %s %s", COMPRESS_PATH,
+ comptype == COMP_BEST ? COMPRESS_BEST_OPT : COMPRESS_FAST_OPT);
+ } else {
+ g_debug("execute: %s", srvcompprog);
+ }
switch (*pid = fork()) {
case -1:
errstr = newvstrallocf(errstr, _("couldn't fork: %s"), strerror(errno));
filter->allocated_size = 0;
filter->event = event_register((event_id_t)filter->fd, EV_READFD,
handle_filter_stderr, filter);
-g_debug("event register %s %d", name, filter->fd);
return (rval);
case 0:
close(outpipe[1]);
return (-1);
}
+ g_debug("execute: %s", srv_encrypt);
switch (*pid = fork()) {
case -1:
errstr = newvstrallocf(errstr, _("couldn't fork: %s"), strerror(errno));
filter->allocated_size = 0;
filter->event = event_register((event_id_t)filter->fd, EV_READFD,
handle_filter_stderr, filter);
-g_debug("event register %s %d", "encrypt data", filter->fd);
return (rval);
}
case 0: {