static int
test_round_trip(void)
{
char **strp;
gboolean success = TRUE;
for (strp = quotable_strings; *strp; strp++) {
char *quoted, *unquoted;
quoted = quote_string(*strp);
unquoted = unquote_string(quoted);
/* if they're not the same, complain */
if (0 != strcmp(*strp, unquoted)) {
char *safe_orig = safestr(*strp);
char *safe_quoted = safestr(quoted);
char *safe_unquoted = safestr(unquoted);
printf(" bad round-trip: %s -quote_string-> %s -unquote_string-> %s\n",
safe_orig, safe_quoted, safe_unquoted);
amfree(safe_orig);
amfree(safe_quoted);
amfree(safe_unquoted);
success = FALSE;
}
amfree(quoted);
amfree(unquoted);
}
return success;
}
void
add_property_value(
char *value)
{
if (value) {
prop_values = g_slist_prepend(prop_values, unquote_string(value));
}
}
/* For one auto-props config entry (NAME, VALUE), if the filename pattern
NAME matches BATON->filename case insensitively then add the properties
listed in VALUE into BATON->properties.
BATON must point to an auto_props_baton_t.
*/
static svn_boolean_t
auto_props_enumerator(const char *name,
const char *value,
void *baton,
apr_pool_t *pool)
{
int i;
auto_props_baton_t *autoprops = baton;
apr_array_header_t *props;
/* nothing to do here without a value */
if (*value == 0)
return TRUE;
/* check if filename matches and return if it doesn't */
if (apr_fnmatch(name, autoprops->filename, APR_FNM_CASE_BLIND) == APR_FNM_NOMATCH)
return TRUE;
split_props(&props, value, autoprops->pool);
for (i = 0; i < props->nelts; i++)
{
size_t len;
const char *this_value;
char *property = APR_ARRAY_IDX(props, i, char *);
char *equal_sign = strchr(property, '=');
if (equal_sign)
{
*equal_sign = '\0';
equal_sign++;
trim_string(&equal_sign);
unquote_string(&equal_sign);
this_value = equal_sign;
}
else
{
this_value = "";
}
trim_string(&property);
len = strlen(property);
if (len > 0)
{
svn_string_t *propval = apr_palloc(autoprops->pool,
sizeof(*propval));
propval->data = this_value;
propval->len = strlen(this_value);
apr_hash_set(autoprops->properties, property, len, propval);
if (strcmp(property, SVN_PROP_MIME_TYPE) == 0)
autoprops->mimetype = this_value;
else if (strcmp(property, SVN_PROP_EXECUTABLE) == 0)
autoprops->have_executable = TRUE;
}
}
return TRUE;
}
int
cd_glob(
char * glob,
int verbose)
{
char *regex;
char *regex_path;
char *s;
char *uqglob;
int result;
char *tpath_on_disk = NULL;
if (disk_name == NULL) {
g_printf(_("Must select disk before changing directory\n"));
return 0;
}
uqglob = unquote_string(glob);
regex = glob_to_regex(uqglob);
dbprintf(_("cd_glob (%s) -> %s\n"), uqglob, regex);
if ((s = validate_regexp(regex)) != NULL) {
g_printf(_("\"%s\" is not a valid shell wildcard pattern: "), glob);
puts(s);
amfree(regex);
amfree(uqglob);
return 0;
}
/*
* glob_to_regex() anchors the beginning of the pattern with ^,
* but we will be tacking it onto the end of the current directory
* in add_file, so strip that off. Also, it anchors the end with
* $, but we need to match a trailing /, add it if it is not there
*/
regex_path = g_strdup(regex + 1);
amfree(regex);
if(regex_path[strlen(regex_path) - 2] != '/' ) {
regex_path[strlen(regex_path) - 1] = '\0';
strappend(regex_path, "/$");
}
/* convert path (assumed in cwd) to one on disk */
if (g_str_equal(disk_path, "/"))
tpath_on_disk = g_strconcat("/", regex_path, NULL);
else {
char *clean_disk_tpath = clean_regex(disk_tpath, 0);
tpath_on_disk = g_strjoin(NULL, clean_disk_tpath, "/", regex_path, NULL);
amfree(clean_disk_tpath);
}
result = cd_dir(tpath_on_disk, uqglob, verbose);
amfree(regex_path);
amfree(tpath_on_disk);
amfree(uqglob);
return result;
}
int
cd_regex(
char * regex,
int verbose)
{
char *s;
char *uq_orig_regex;
char *uqregex;
int len_uqregex;
int result;
char *tpath_on_disk = NULL;
if (disk_name == NULL) {
g_printf(_("Must select disk before changing directory\n"));
return 0;
}
uq_orig_regex = unquote_string(regex);
uqregex = g_strdup(uq_orig_regex);
/* Add a terminating '/' if it is not there, maybe before a '$' */
len_uqregex = strlen(uqregex);
if (uqregex[len_uqregex-1] == '$') {
if (uqregex[len_uqregex-2] != '/') {
uqregex[len_uqregex-1] = '\0';
strappend(uqregex, "/$");
}
} else if (uqregex[len_uqregex-1] != '/') {
//uqregex[len_uqregex-1] = '\0';
strappend(uqregex, "/");
}
if ((s = validate_regexp(uqregex)) != NULL) {
g_printf(_("\"%s\" is not a valid regular expression: "), uq_orig_regex);
amfree(uqregex);
amfree(uq_orig_regex);
puts(s);
return 0;
}
/* convert path (assumed in cwd) to one on disk */
if (g_str_equal(disk_path, "/"))
tpath_on_disk = g_strconcat("/", uqregex, NULL);
else {
char *clean_disk_tpath = clean_regex(disk_tpath, 0);
tpath_on_disk = g_strjoin(NULL, clean_disk_tpath, "/", regex, NULL);
amfree(clean_disk_tpath);
}
result = cd_dir(tpath_on_disk, uq_orig_regex, verbose);
amfree(tpath_on_disk);
amfree(uqregex);
amfree(uq_orig_regex);
return result;
}
void
local_cd(
char *dir)
{
char *uqdir = unquote_string(dir);
if (chdir(uqdir) == -1) {
perror(uqdir);
}
amfree(uqdir);
}
void
cd_regex(
char * regex,
int verbose)
{
char *s;
char *uq_orig_regex;
char *uqregex;
int len_uqregex;
char *path_on_disk = NULL;
if (disk_name == NULL) {
g_printf(_("Must select disk before changing directory\n"));
return;
}
uq_orig_regex = unquote_string(regex);
uqregex = stralloc(uq_orig_regex);
/* Add a terminating '/' if it is not there, maybe before a '$' */
len_uqregex = strlen(uqregex);
if (uqregex[len_uqregex-1] == '$') {
if (uqregex[len_uqregex-2] != '/') {
uqregex[len_uqregex-1] = '\0';
strappend(uqregex, "/$");
}
} else if (uqregex[len_uqregex-1] != '/') {
//uqregex[len_uqregex-1] = '\0';
strappend(uqregex, "/");
}
if ((s = validate_regexp(uqregex)) != NULL) {
g_printf(_("\"%s\" is not a valid regular expression: "), uq_orig_regex);
amfree(uqregex);
amfree(uq_orig_regex);
puts(s);
return;
}
/* convert path (assumed in cwd) to one on disk */
if (strcmp(disk_path, "/") == 0)
path_on_disk = stralloc2("/", uqregex);
else {
char *clean_disk_path = clean_regex(disk_path);
path_on_disk = vstralloc(clean_disk_path, "/", regex, NULL);
amfree(clean_disk_path);
}
cd_dir(path_on_disk, uq_orig_regex, verbose);
amfree(path_on_disk);
amfree(uqregex);
amfree(uq_orig_regex);
}
char *
findpass(
char * disk,
char ** domain)
{
FILE *fp;
static char *buffer = NULL;
char *s, *d, *pw = NULL;
int ch;
char *qname;
*domain = NULL; /* just to be sure */
if ( (fp = fopen("/etc/amandapass", "r")) ) {
amfree(buffer);
for (; (buffer = agets(fp)) != NULL; free(buffer)) {
if (buffer[0] == '\0')
continue;
s = buffer;
ch = *s++;
skip_whitespace(s, ch); /* find start of disk name */
if (!ch || ch == '#') {
continue;
}
qname = s-1; /* start of disk name */
skip_quoted_string(s, ch);
if (ch && ch != '#') {
s[-1] = '\0'; /* terminate disk name */
d = unquote_string(qname);
if ((strcmp(d,"*") == 0) || (strcmp(disk, d) == 0)) {
skip_whitespace(s, ch); /* find start of password */
if (ch && ch != '#') {
pw = s - 1; /* start of password */
skip_non_whitespace_cs(s, ch);
s[-1] = '\0'; /* terminate password */
pw = stralloc(pw);
skip_whitespace(s, ch); /* find start of domain */
if (ch && ch != '#') {
*domain = s - 1; /* start of domain */
skip_non_whitespace_cs(s, ch);
s[-1] = '\0'; /* terminate domain */
*domain = stralloc(*domain);
}
}
amfree(d);
break;
}
amfree(d);
}
}
afclose(fp);
}
return pw;
}
/* set the tape server and device */
void
set_tape(
char * tape)
{
char *uqtape = unquote_string(tape);
char *tapedev = strchr(uqtape, ':');
if (tapedev)
{
if (tapedev != uqtape) {
if((strchr(tapedev+1, ':') == NULL) &&
(g_str_has_prefix(uqtape, "null:") ||
g_str_has_prefix(uqtape, "rait:") ||
g_str_has_prefix(uqtape, "file:") ||
g_str_has_prefix(uqtape, "tape:"))) {
tapedev = uqtape;
}
else {
*tapedev = '\0';
g_free(tape_server_name);
tape_server_name = g_strdup(uqtape);
++tapedev;
}
} else { /* reset server_name if start with : */
amfree(tape_server_name);
++tapedev;
}
} else
tapedev = uqtape;
if (tapedev[0])
{
if (g_str_equal(tapedev, "default"))
amfree(tape_device_name);
else {
g_free(tape_device_name);
tape_device_name = g_strdup(tapedev);
}
}
if (tape_device_name)
g_printf (_("Using tape \"%s\""), tape_device_name);
else
g_printf (_("Using default tape"));
if (tape_server_name)
g_printf (_(" from server %s.\n"), tape_server_name);
else
g_printf (_(".\nTape server unspecified, assumed to be %s.\n"),
server_name);
amfree(uqtape);
}
static char *
copy_string_unquote (const char *str)
{
char *output = xstrdup (str);
size_t len = strlen (output);
if ((*output == '"' || *output == '\'')
&& output[len-1] == *output)
{
memmove (output, output+1, len-2);
output[len-2] = 0;
}
unquote_string (output);
return output;
}
/* set the tape server and device */
void
set_tape(
char * tape)
{
char *uqtape = unquote_string(tape);
char *tapedev = strchr(uqtape, ':');
if (tapedev)
{
if (tapedev != uqtape) {
if((strchr(tapedev+1, ':') == NULL) &&
(strncmp(uqtape, "null:", 5) == 0 ||
strncmp(uqtape, "rait:", 5) == 0 ||
strncmp(uqtape, "file:", 5) == 0 ||
strncmp(uqtape, "tape:", 5) == 0)) {
tapedev = uqtape;
}
else {
*tapedev = '\0';
tape_server_name = newstralloc(tape_server_name, uqtape);
++tapedev;
}
} else { /* reset server_name if start with : */
amfree(tape_server_name);
++tapedev;
}
} else
tapedev = uqtape;
if (tapedev[0])
{
if (strcmp(tapedev, "default") == 0)
amfree(tape_device_name);
else
tape_device_name = newstralloc(tape_device_name, tapedev);
}
if (tape_device_name)
g_printf (_("Using tape \"%s\""), tape_device_name);
else
g_printf (_("Using default tape"));
if (tape_server_name)
g_printf (_(" from server %s.\n"), tape_server_name);
else
g_printf (_(".\nTape server unspecified, assumed to be %s.\n"),
server_name);
}
/* set the tape server and device (deprecated version) */
void
set_tape(
char * tape)
{
char *uqtape = unquote_string(tape);
char *tapedev = strchr(uqtape, ':');
char *host = NULL;
g_printf(_("NOTE: 'settape' is deprecated; use setdevice instead.\n"));
if (tapedev)
{
/* This command is deprecated because this parsing is going to fall
* behind the list of available device names at some point, or to shadow
* an interesting hostname (wouldn't 'tape' be a good name for a
* tape server?) */
if (tapedev != uqtape) {
if((strchr(tapedev+1, ':') == NULL) &&
(strncmp_const(uqtape, "null:") == 0 ||
strncmp_const(uqtape, "rait:") == 0 ||
strncmp_const(uqtape, "file:") == 0 ||
strncmp_const(uqtape, "s3:") == 0 ||
strncmp_const(uqtape, "tape:") == 0)) {
tapedev = uqtape;
}
else {
*tapedev = '\0';
host = stralloc(uqtape);
++tapedev;
}
} else {
++tapedev;
}
} else
tapedev = uqtape;
if (tapedev[0])
{
if (strcmp(tapedev, "default") == 0)
tapedev = NULL;
}
/* call out to the new version */
set_device(host, tapedev);
amfree(host);
amfree(uqtape);
}
static int
parse_taper_datestamp_log(
char *logline,
char **datestamp,
char **label)
{
char *s;
int ch;
s = logline;
ch = *s++;
skip_whitespace(s, ch);
if(ch == '\0') {
return 0;
}
if(strncmp_const_skip(s - 1, "datestamp", s, ch) != 0) {
return 0;
}
skip_whitespace(s, ch);
if(ch == '\0') {
return 0;
}
*datestamp = s - 1;
skip_non_whitespace(s, ch);
s[-1] = '\0';
skip_whitespace(s, ch);
if(ch == '\0') {
return 0;
}
if(strncmp_const_skip(s - 1, "label", s, ch) != 0) {
return 0;
}
skip_whitespace(s, ch);
if(ch == '\0') {
return 0;
}
*label = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
*label = unquote_string(*label);
return 1;
}
void
set_property_name(
char *name,
int append)
{
property_t *prop;
char *property_name, *pn;
pn = unquote_string(name);
property_name = amandaify_property_name(pn);
amfree(pn);
if (!append) {
g_hash_table_remove(proplist, property_name);
prop = NULL;
} else {
prop = g_hash_table_lookup(proplist, property_name);
}
if (!prop) {
prop = malloc(sizeof(property_t));
prop->append = 0;
prop->priority = 1;
prop->values = NULL;
g_hash_table_insert(proplist, g_strdup(property_name), prop);
}
/* add prop_values to prop->values */
if (!prop->values) {
prop->values = prop_values;
prop_values = NULL;
} else {
GSList *pv;
for(pv = prop_values; pv != NULL; pv = pv->next) {
prop->values = g_slist_append(prop->values, pv->data);
}
g_slist_free(prop_values);
prop_values = NULL;
}
amfree(property_name);
}
void
list_disk(
char * amdevice)
{
char *cmd = NULL;
char *uqamdevice;
if(amdevice) {
uqamdevice = unquote_string(amdevice);
cmd = g_strconcat("LISTDISK ", uqamdevice, NULL);
amfree(uqamdevice);
if (converse(cmd) == -1)
exit(1);
amfree(cmd);
}
else {
cmd = g_strdup("LISTDISK");
if (converse(cmd) == -1)
exit(1);
amfree(cmd);
}
}
void
list_disk(
char * amdevice)
{
char *cmd = NULL;
char *qamdevice, *uqamdevice;
if(amdevice) {
uqamdevice = unquote_string(amdevice);
qamdevice = quote_string(uqamdevice);
cmd = stralloc2("LISTDISK ", qamdevice);
amfree(uqamdevice);
amfree(qamdevice);
if (converse(cmd) == -1)
exit(1);
amfree(cmd);
}
else {
cmd = stralloc("LISTDISK");
if (converse(cmd) == -1)
exit(1);
amfree(cmd);
}
}
void
cd_regex(
char * regex)
{
char *s;
char *uqregex;
char *path_on_disk = NULL;
if (disk_name == NULL) {
g_printf(_("Must select disk before changing directory\n"));
return;
}
uqregex = unquote_string(regex);
if ((s = validate_regexp(uqregex)) != NULL) {
g_printf(_("\"%s\" is not a valid regular expression: "), uqregex);
amfree(uqregex);
puts(s);
return;
}
/* convert path (assumed in cwd) to one on disk */
if (g_str_equal(disk_path, "/"))
path_on_disk = g_strconcat("/", regex, NULL);
else {
char *clean_disk_path = clean_regex(disk_path, 0);
path_on_disk = g_strjoin(NULL, clean_disk_path, "/", regex, NULL);
amfree(clean_disk_path);
}
cd_dir(path_on_disk, uqregex);
amfree(path_on_disk);
amfree(uqregex);
}
void
parse_file_header(
const char *buffer,
dumpfile_t *file,
size_t buflen)
{
char *buf, *line, *tok, *line1;
size_t lsize;
char *uqname;
int in_quotes;
char *saveptr = NULL;
/* put the buffer into a writable chunk of memory and nul-term it */
buf = alloc(buflen + 1);
memcpy(buf, buffer, buflen);
buf[buflen] = '\0';
fh_init(file);
/* extract the first unquoted line */
in_quotes = 0;
for (line = buf, lsize = 0; lsize < buflen; line++) {
if ((*line == '\n') && !in_quotes)
break;
if (*line == '"') {
in_quotes = !in_quotes;
} else if ((*line == '\\') && (*(line + 1) == '"')) {
line++;
lsize++;
}
lsize++;
}
*line = '\0';
line1 = alloc(lsize + 1);
strncpy(line1, buf, lsize);
line1[lsize] = '\0';
*line = '\n';
tok = strtok_r(line1, " ", &saveptr);
if (tok == NULL) {
g_fprintf(stderr, _("%s: Empty amanda header: buflen=%zu lsize=%zu\n"), get_pname(),
buflen,
lsize);
hexdump(buffer, lsize);
strange_header(file, buffer, buflen, _("<Non-empty line>"), tok);
goto out;
}
if (strcmp(tok, "NETDUMP:") != 0 && strcmp(tok, "AMANDA:") != 0) {
amfree(buf);
file->type = F_UNKNOWN;
amfree(line1);
return;
}
tok = strtok_r(NULL, " ", &saveptr);
if (tok == NULL) {
strange_header(file, buffer, buflen, _("<file type>"), tok);
goto out;
}
file->type = str2filetype(tok);
switch (file->type) {
case F_TAPESTART:
tok = strtok_r(NULL, " ", &saveptr);
if ((tok == NULL) || (strcmp(tok, "DATE") != 0)) {
strange_header(file, buffer, buflen, "DATE", tok);
goto out;
}
tok = strtok_r(NULL, " ", &saveptr);
if (tok == NULL) {
strange_header(file, buffer, buflen, _("<date stamp>"), tok);
goto out;
}
strncpy(file->datestamp, tok, SIZEOF(file->datestamp) - 1);
tok = strtok_r(NULL, " ", &saveptr);
if ((tok == NULL) || (strcmp(tok, "TAPE") != 0)) {
strange_header(file, buffer, buflen, "TAPE", tok);
goto out;
}
tok = strtok_r(NULL, " ", &saveptr);
if (tok == NULL) {
strange_header(file, buffer, buflen, _("<file type>"), tok);
goto out;
}
strncpy(file->name, tok, SIZEOF(file->name) - 1);
break;
case F_DUMPFILE:
case F_CONT_DUMPFILE:
case F_SPLIT_DUMPFILE:
tok = strtok_r(NULL, " ", &saveptr);
if (tok == NULL) {
strange_header(file, buffer, buflen, _("<date stamp>"), tok);
goto out;
}
strncpy(file->datestamp, tok, SIZEOF(file->datestamp) - 1);
tok = strtok_r(NULL, " ", &saveptr);
if (tok == NULL) {
strange_header(file, buffer, buflen, _("<file name>"), tok);
goto out;
}
strncpy(file->name, tok, SIZEOF(file->name) - 1);
tok = strquotedstr(&saveptr);
if (tok == NULL) {
strange_header(file, buffer, buflen, _("<disk name>"), tok);
goto out;
}
uqname = unquote_string(tok);
strncpy(file->disk, uqname, SIZEOF(file->disk) - 1);
amfree(uqname);
if(file->type == F_SPLIT_DUMPFILE) {
tok = strtok_r(NULL, " ", &saveptr);
if (tok == NULL || strcmp(tok, "part") != 0) {
strange_header(file, buffer, buflen, "part", tok);
goto out;
}
tok = strtok_r(NULL, "/", &saveptr);
if ((tok == NULL) || (sscanf(tok, "%d", &file->partnum) != 1)) {
strange_header(file, buffer, buflen, _("<part num param>"), tok);
goto out;
}
/* If totalparts == -1, then the original dump was done in
streaming mode (no holding disk), thus we don't know how
many parts there are. */
tok = strtok_r(NULL, " ", &saveptr);
if((tok == NULL) || (sscanf(tok, "%d", &file->totalparts) != 1)) {
strange_header(file, buffer, buflen, _("<total parts param>"), tok);
goto out;
}
}
tok = strtok_r(NULL, " ", &saveptr);
if ((tok == NULL) || (strcmp(tok, "lev") != 0)) {
strange_header(file, buffer, buflen, "lev", tok);
goto out;
}
tok = strtok_r(NULL, " ", &saveptr);
if ((tok == NULL) || (sscanf(tok, "%d", &file->dumplevel) != 1)) {
strange_header(file, buffer, buflen, _("<dump level param>"), tok);
goto out;
}
tok = strtok_r(NULL, " ", &saveptr);
if ((tok == NULL) || (strcmp(tok, "comp") != 0)) {
strange_header(file, buffer, buflen, "comp", tok);
goto out;
}
tok = strtok_r(NULL, " ", &saveptr);
if (tok == NULL) {
strange_header(file, buffer, buflen, _("<comp param>"), tok);
goto out;
}
strncpy(file->comp_suffix, tok, SIZEOF(file->comp_suffix) - 1);
file->compressed = strcmp(file->comp_suffix, "N");
/* compatibility with pre-2.2 amanda */
if (strcmp(file->comp_suffix, "C") == 0)
strncpy(file->comp_suffix, ".Z", SIZEOF(file->comp_suffix) - 1);
tok = strtok_r(NULL, " ", &saveptr);
/* "program" is optional */
if (tok == NULL || strcmp(tok, "program") != 0) {
break;
}
tok = strtok_r(NULL, " ", &saveptr);
if (tok == NULL) {
strange_header(file, buffer, buflen, _("<program name>"), tok);
goto out;
}
strncpy(file->program, tok, SIZEOF(file->program) - 1);
if (file->program[0] == '\0')
strncpy(file->program, "RESTORE", SIZEOF(file->program) - 1);
if ((tok = strtok_r(NULL, " ", &saveptr)) == NULL)
break; /* reached the end of the buffer */
/* "encryption" is optional */
if (BSTRNCMP(tok, "crypt") == 0) {
tok = strtok_r(NULL, " ", &saveptr);
if (tok == NULL) {
strange_header(file, buffer, buflen, _("<crypt param>"), tok);
goto out;
}
strncpy(file->encrypt_suffix, tok,
SIZEOF(file->encrypt_suffix) - 1);
file->encrypted = BSTRNCMP(file->encrypt_suffix, "N");
if ((tok = strtok_r(NULL, " ", &saveptr)) == NULL)
break;
}
/* "srvcompprog" is optional */
if (BSTRNCMP(tok, "server_custom_compress") == 0) {
tok = strtok_r(NULL, " ", &saveptr);
if (tok == NULL) {
strange_header(file, buffer, buflen,
_("<server custom compress param>"), tok);
goto out;
}
strncpy(file->srvcompprog, tok, SIZEOF(file->srvcompprog) - 1);
if ((tok = strtok_r(NULL, " ", &saveptr)) == NULL)
break;
}
/* "clntcompprog" is optional */
if (BSTRNCMP(tok, "client_custom_compress") == 0) {
tok = strtok_r(NULL, " ", &saveptr);
if (tok == NULL) {
strange_header(file, buffer, buflen,
_("<client custom compress param>"), tok);
goto out;
}
strncpy(file->clntcompprog, tok, SIZEOF(file->clntcompprog) - 1);
if ((tok = strtok_r(NULL, " ", &saveptr)) == NULL)
break;
}
/* "srv_encrypt" is optional */
if (BSTRNCMP(tok, "server_encrypt") == 0) {
tok = strtok_r(NULL, " ", &saveptr);
if (tok == NULL) {
strange_header(file, buffer, buflen,
_("<server encrypt param>"), tok);
goto out;
}
strncpy(file->srv_encrypt, tok, SIZEOF(file->srv_encrypt) - 1);
if ((tok = strtok_r(NULL, " ", &saveptr)) == NULL)
break;
}
/* "clnt_encrypt" is optional */
if (BSTRNCMP(tok, "client_encrypt") == 0) {
tok = strtok_r(NULL, " ", &saveptr);
if (tok == NULL) {
strange_header(file, buffer, buflen,
_("<client encrypt param>"), tok);
goto out;
}
strncpy(file->clnt_encrypt, tok, SIZEOF(file->clnt_encrypt) - 1);
if ((tok = strtok_r(NULL, " ", &saveptr)) == NULL)
break;
}
/* "srv_decrypt_opt" is optional */
if (BSTRNCMP(tok, "server_decrypt_option") == 0) {
tok = strtok_r(NULL, " ", &saveptr);
if (tok == NULL) {
strange_header(file, buffer, buflen,
_("<server decrypt param>"), tok);
goto out;
}
strncpy(file->srv_decrypt_opt, tok,
SIZEOF(file->srv_decrypt_opt) - 1);
if ((tok = strtok_r(NULL, " ", &saveptr)) == NULL)
break;
}
/* "clnt_decrypt_opt" is optional */
if (BSTRNCMP(tok, "client_decrypt_option") == 0) {
tok = strtok_r(NULL, " ", &saveptr);
if (tok == NULL) {
strange_header(file, buffer, buflen,
_("<client decrypt param>"), tok);
goto out;
}
strncpy(file->clnt_decrypt_opt, tok,
SIZEOF(file->clnt_decrypt_opt) - 1);
if ((tok = strtok_r(NULL, " ", &saveptr)) == NULL)
break;
}
break;
case F_TAPEEND:
tok = strtok_r(NULL, " ", &saveptr);
/* DATE is optional */
if (tok != NULL) {
if (strcmp(tok, "DATE") == 0) {
tok = strtok_r(NULL, " ", &saveptr);
if(tok == NULL)
file->datestamp[0] = '\0';
else
strncpy(file->datestamp, tok, SIZEOF(file->datestamp) - 1);
} else {
strange_header(file, buffer, buflen, _("<DATE>"), tok);
}
} else {
file->datestamp[0] = '\0';
}
break;
case F_NOOP:
/* nothing follows */
break;
default:
strange_header(file, buffer, buflen,
_("TAPESTART|DUMPFILE|CONT_DUMPFILE|SPLIT_DUMPFILE|TAPEEND|NOOP"), tok);
goto out;
}
(void)strtok_r(buf, "\n", &saveptr); /* this is the first line */
/* iterate through the rest of the lines */
while ((line = strtok_r(NULL, "\n", &saveptr)) != NULL) {
#define SC "CONT_FILENAME="
if (strncmp(line, SC, SIZEOF(SC) - 1) == 0) {
line += SIZEOF(SC) - 1;
strncpy(file->cont_filename, line,
SIZEOF(file->cont_filename) - 1);
continue;
}
#undef SC
#define SC "PARTIAL="
if (strncmp(line, SC, SIZEOF(SC) - 1) == 0) {
line += SIZEOF(SC) - 1;
file->is_partial = !strcasecmp(line, "yes");
continue;
}
#undef SC
#define SC "APPLICATION="
if (strncmp(line, SC, SIZEOF(SC) - 1) == 0) {
line += SIZEOF(SC) - 1;
strncpy(file->application, line,
SIZEOF(file->application) - 1);
continue;
}
#undef SC
#define SC "DLE="
if (strncmp(line, SC, SIZEOF(SC) - 1) == 0) {
line += SIZEOF(SC) - 1;
file->dle_str = parse_heredoc(line, &saveptr);
}
#undef SC
#define SC _("To restore, position tape at start of file and run:")
if (strncmp(line, SC, SIZEOF(SC) - 1) == 0)
continue;
#undef SC
#define SC "\tdd if=<tape> "
if (strncmp(line, SC, SIZEOF(SC) - 1) == 0) {
char *cmd1, *cmd2, *cmd3=NULL;
/* skip over dd command */
if ((cmd1 = strchr(line, '|')) == NULL) {
strncpy(file->recover_cmd, "BUG",
SIZEOF(file->recover_cmd) - 1);
continue;
}
*cmd1++ = '\0';
/* block out first pipeline command */
if ((cmd2 = strchr(cmd1, '|')) != NULL) {
*cmd2++ = '\0';
if ((cmd3 = strchr(cmd2, '|')) != NULL)
*cmd3++ = '\0';
}
/* clean up some extra spaces in various fields */
chomp(cmd1);
chomp(cmd2);
chomp(cmd3);
/* three cmds: decrypt | uncompress | recover
* two cmds: uncompress | recover
* XXX note that if there are two cmds, the first one
* XXX could be either uncompress or decrypt. Since no
* XXX code actually call uncompress_cmd/decrypt_cmd, it's ok
* XXX for header information.
* one cmds: recover
*/
if ( cmd3 == NULL) {
if (cmd2 == NULL) {
strncpy(file->recover_cmd, cmd1,
SIZEOF(file->recover_cmd) - 1);
} else {
g_snprintf(file->uncompress_cmd,
SIZEOF(file->uncompress_cmd), "%s |", cmd1);
strncpy(file->recover_cmd, cmd2,
SIZEOF(file->recover_cmd) - 1);
}
} else { /* cmd3 presents: decrypt | uncompress | recover */
g_snprintf(file->decrypt_cmd,
SIZEOF(file->decrypt_cmd), "%s |", cmd1);
g_snprintf(file->uncompress_cmd,
SIZEOF(file->uncompress_cmd), "%s |", cmd2);
strncpy(file->recover_cmd, cmd3,
SIZEOF(file->recover_cmd) - 1);
}
continue;
}
#undef SC
/* XXX complain about weird lines? */
}
out:
amfree(buf);
amfree(line1);
}
void
set_disk(
char * dsk,
char * mtpt)
{
char *cmd = NULL;
char *uqdsk;
char *uqmtpt = NULL;
if (is_extract_list_nonempty())
{
g_printf(_("Must clear extract list before changing disk\n"));
return;
}
/* if mount point specified, check it is valid */
if (mtpt != NULL) {
uqmtpt = unquote_string(mtpt);
if (*mtpt != '/') {
g_printf(_("Mount point \"%s\" invalid - must start with /\n"), uqmtpt);
amfree(uqmtpt);
return;
}
}
clear_dir_list();
uqdsk = unquote_string(dsk);
cmd = g_strconcat("DISK ", uqdsk, NULL);
if (converse(cmd) == -1)
exit(1);
amfree(cmd);
if (!server_happy()) {
amfree(uqdsk);
amfree(uqmtpt);
return;
}
g_free(disk_name);
disk_name = g_strdup(uqdsk);
if (mtpt == NULL)
{
/* mount point not specified */
if (*uqdsk == '/')
{
/* disk specified by mount point, hence use it */
g_free(mount_point);
mount_point = g_strdup(uqdsk);
}
else
{
/* device name given, use '/' because nothing better */
g_free(mount_point);
mount_point = g_strdup("/");
}
}
else
{
/* mount point specified */
g_free(mount_point);
mount_point = g_strdup(uqmtpt);
}
/* set the working directory to the mount point */
/* there is the possibility that there are no index records for the
disk for the given date, hence setting the directory to the
mount point will fail. Preempt this by checking first so we can write
a more informative message. */
if (exchange("OISD /") == -1)
exit(1);
if (server_happy())
{
g_free(disk_path);
disk_path = g_strdup("/");
suck_dir_list_from_server(); /* get list of directory contents */
}
else
{
g_printf(_("No index records for disk for specified date\n"));
g_printf(_("If date correct, notify system administrator\n"));
g_free(disk_path);
disk_path = g_strdup("/"); /* fake it */
clear_dir_list();
}
amfree(uqmtpt);
amfree(uqdsk);
}
void feature_recorder::make_histogram(const class histogram_def &def)
{
beregex reg(def.pattern,REG_EXTENDED);
string ifname = fname_counter(""); // source of features
ifstream f(ifname.c_str());
if(!f.is_open()){
std::cerr << "Cannot open histogram input file: " << ifname << "\n";
return;
}
/* Read each line of the feature file and add it to the histogram.
* If we run out of memory, dump that histogram to a file and start
* on the next histogram.
*/
for(int histogram_counter = 0;histogram_counter<max_histogram_files;histogram_counter++){
HistogramMaker h(def.flags); /* of seen features, created in pass two */
try {
string line;
while(getline(f,line)){
if(line.size()==0) continue; // empty line
if(line[0]=='#') continue; // comment line
truncate_at(line,'\r'); // truncate at a \r if there is one.
/** If there is a string required in the line and it isn't present, don't use this line */
if(def.require.size()){
if(line.find_first_of(def.require)==std::string::npos){
continue;
}
}
string feature = extract_feature(line);
if(feature.find('\\')!=string::npos){
feature = unquote_string(feature); // reverse \xxx encoding
}
/** If there is a pattern to use to prune down the feature, use it */
if(def.pattern.size()){
string new_feature = feature;
if(!reg.search(feature,&new_feature,0,0)){
// no search match; avoid this feature
continue;
}
feature = new_feature;
}
/* Remove what follows after \t if this is a context file */
size_t tab=feature.find('\t');
if(tab!=string::npos) feature.erase(tab); // erase from tab to end
h.add(feature);
}
f.close();
}
catch (const std::exception &e) {
std::cerr << "ERROR: " << e.what() << " generating histogram "
<< name << "\n";
}
/* Output what we have */
stringstream real_suffix;
real_suffix << def.suffix;
if(histogram_counter>0) real_suffix << histogram_counter;
string ofname = fname_counter(real_suffix.str()); // histogram name
ofstream o;
o.open(ofname.c_str());
if(!o.is_open()){
cerr << "Cannot open histogram output file: " << ofname << "\n";
return;
}
HistogramMaker::FrequencyReportVector *fr = h.makeReport();
if(fr->size()>0){
banner_stamp(o,histogram_file_header);
o << *fr; // sends the entire histogram
}
delete fr;
o.close();
if(f.is_open()==false){
return; // input file was closed
}
}
std::cerr << "Looped " << max_histogram_files
<< " times on histogram; something seems wrong\n";
}
static void
read_directory_file (void)
{
char *strp;
FILE *fp;
char buf[512]; /* FIXME: use a symbol */
static char *path = NULL;
if (path == NULL)
path = xmalloc (PATH_MAX);
time (&time_now);
if (listed_incremental_option[0] != '/'
#if DOSWIN
/* The case of DOSWIN absolute file name with a drive letter. */
&& !(listed_incremental_option[0] && listed_incremental_option[1] == ':')
#endif
)
{
char *current_directory = xgetcwd ();
if (!current_directory)
FATAL_ERROR ((0, 0, _("Could not get current directory")));
listed_incremental_option
= concat_with_slash (current_directory, listed_incremental_option);
}
fp = fopen (listed_incremental_option, "r");
if (fp == 0 && errno != ENOENT)
{
ERROR ((0, errno, _("Cannot open %s"), listed_incremental_option));
return;
}
if (!fp)
return;
fgets (buf, sizeof (buf), fp);
/* FIXME: Using newer_ctime_option as a first time flag looks fairly dubious
to me! So, using -N with incremental might be buggy just because of the
next few lines. I saw a few unexplained, almost harsh advices from FSF
people about *not* using -N with incremental dumps, and here might lie
(part of) the reason. */
if (!newer_ctime_option)
{
time_option_threshold = atol (buf);
newer_ctime_option = true;
}
while (fgets (buf, sizeof (buf), fp))
{
dev_t device_number;
ino_t inode_number;
strp = &buf[strlen (buf)];
if (strp[-1] == '\n')
strp[-1] = '\0';
/* FIXME: For files ending with an incomplete line, maybe a NUL might
be missing, here... */
strp = buf;
device_number = atol (strp);
while (ISDIGIT (*strp))
strp++;
inode_number = atol (strp);
while (ISSPACE (*strp))
strp++;
while (ISDIGIT (*strp))
strp++;
strp++;
unquote_string (strp);
note_directory (strp, device_number, inode_number, NULL);
}
if (fclose (fp) == EOF)
ERROR ((0, errno, "%s", listed_incremental_option));
}
void
set_host(
const char *host)
{
char *cmd = NULL;
struct hostent *hp = NULL;
char **hostp;
int found_host = 0;
char *uqhost = unquote_string(host);
if (is_extract_list_nonempty())
{
g_printf(_("Must clear extract list before changing host\n"));
amfree(uqhost);
return;
}
/*
* The idea here is to try as many permutations of the hostname
* as we can imagine. The server will reject anything it doesn't
* recognize.
*/
cmd = stralloc2("HOST ", uqhost);
if (converse(cmd) == -1)
exit(1);
if (server_happy())
found_host = 1;
/*
* Try converting the given host to a fully qualified, canonical
* name.
*/
if (!found_host) {
if ((hp = gethostbyname(uqhost)) != NULL) {
host = hp->h_name;
g_printf(_("Trying host %s ...\n"), host);
cmd = newstralloc2(cmd, "HOST ", host);
if (converse(cmd) == -1)
exit(1);
if(server_happy())
found_host = 1;
}
}
/*
* Since we have them, try any CNAMEs that were traversed from uqhost
* to the canonical name (this assumes gethostbyname was called above)
*/
if (!found_host) {
if (hp) {
for (hostp = hp->h_aliases; (host = *hostp) != NULL; hostp++)
{
g_printf(_("Trying host %s ...\n"), host);
cmd = newstralloc2(cmd, "HOST ", host);
if (converse(cmd) == -1)
exit(1);
if(server_happy())
{
found_host = 1;
break;
}
}
}
}
/* Try looking up the canonical name of the host */
if (!found_host) {
char *canonname;
int result;
result = resolve_hostname(uqhost, 0, NULL, &canonname);
if (result == 0 && canonname) {
host = canonname;
g_printf(_("Trying host %s ...\n"), host);
cmd = newstralloc2(cmd, "HOST ", host);
if (converse(cmd) == -1)
exit(1);
if(server_happy())
found_host = 1;
}
}
if(found_host) {
dump_hostname = newstralloc(dump_hostname, host);
amfree(disk_name);
amfree(mount_point);
amfree(disk_path);
clear_dir_list();
}
amfree(cmd);
amfree(uqhost);
}
void
set_host(
const char * host)
{
char *cmd = NULL;
struct hostent *hp;
char **hostp;
int found_host = 0;
char *uqhost;
if (is_extract_list_nonempty())
{
g_printf(_("Must clear extract list before changing host\n"));
return;
}
uqhost = unquote_string(host);
cmd = g_strconcat("HOST ", uqhost, NULL);
if (converse(cmd) == -1)
exit(1);
if (server_happy())
{
found_host = 1;
}
else
{
/*
* Try converting the given host to a fully qualified name
* and then try each of the aliases.
*/
if ((hp = gethostbyname(uqhost)) != NULL) {
host = hp->h_name;
g_printf(_("Trying host %s ...\n"), host);
g_free(cmd);
cmd = g_strconcat("HOST ", host, NULL);
if (converse(cmd) == -1)
exit(1);
if(server_happy())
{
found_host = 1;
}
else
{
for (hostp = hp->h_aliases; (host = *hostp) != NULL; hostp++)
{
g_printf(_("Trying host %s ...\n"), host);
g_free(cmd);
cmd = g_strconcat("HOST ", host, NULL);
if (converse(cmd) == -1)
exit(1);
if(server_happy())
{
found_host = 1;
break;
}
}
}
}
}
if(found_host)
{
g_free(dump_hostname);
dump_hostname = g_strdup(host);
amfree(disk_name);
amfree(mount_point);
amfree(disk_path);
clear_dir_list();
}
amfree(cmd);
amfree(uqhost);
}
/* WARNING: Function accesses globals find_diskqp, curlog, curlog, curstr,
* dynamic_disklist */
gboolean
search_logfile(
find_result_t **output_find,
const char *label,
const char *passed_datestamp,
const char *logfile,
disklist_t * dynamic_disklist)
{
FILE *logf;
char *host, *host_undo;
char *disk = NULL, *qdisk, *disk_undo;
char *date, *date_undo;
int partnum;
int totalparts;
int maxparts = -1;
char *number;
int fileno;
char *current_label;
char *rest, *rest_undo;
char *ck_label=NULL;
int level = 0;
off_t filenum;
char *ck_datestamp=NULL;
char *datestamp;
char *s;
int ch;
disk_t *dp;
GHashTable* valid_label;
GHashTable* part_by_dle;
find_result_t *part_find;
find_result_t *a_part_find;
gboolean right_label = FALSE;
gboolean found_something = FALSE;
double sec;
off_t kb;
off_t bytes;
off_t orig_kb;
int taper_part = 0;
g_return_val_if_fail(output_find != NULL, 0);
g_return_val_if_fail(logfile != NULL, 0);
current_label = g_strdup("");
if (string_chunk == NULL) {
string_chunk = g_string_chunk_new(32768);
}
valid_label = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
part_by_dle = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
datestamp = g_strdup(passed_datestamp);
if((logf = fopen(logfile, "r")) == NULL) {
error(_("could not open logfile %s: %s"), logfile, strerror(errno));
/*NOTREACHED*/
}
filenum = (off_t)0;
while(get_logline(logf)) {
if (curlog == L_START && curprog == P_TAPER) {
amfree(ck_label);
ck_datestamp = NULL;
if(parse_taper_datestamp_log(curstr, &ck_datestamp,
&ck_label) == 0) {
g_printf(_("strange log line in %s \"start taper %s\"\n"),
logfile, curstr);
continue;
}
if (datestamp != NULL) {
if (!g_str_equal(datestamp, ck_datestamp)) {
g_printf(_("Log file %s stamped %s, expecting %s!\n"),
logfile, ck_datestamp, datestamp);
amfree(ck_label);
break;
}
}
right_label = volume_matches(label, ck_label, ck_datestamp);
if (right_label && ck_label) {
g_hash_table_insert(valid_label, g_strdup(ck_label),
GINT_TO_POINTER(1));
}
if (label && datestamp && right_label) {
found_something = TRUE;
}
amfree(current_label);
current_label = ck_label;
ck_label = NULL;
if (datestamp == NULL) {
datestamp = g_strdup(ck_datestamp);
}
filenum = (off_t)0;
}
if (!datestamp)
continue;
if (right_label &&
(curlog == L_SUCCESS ||
curlog == L_CHUNK || curlog == L_PART || curlog == L_PARTPARTIAL) &&
curprog == P_TAPER) {
filenum++;
} else if (right_label && curlog == L_PARTIAL && curprog == P_TAPER &&
taper_part == 0) {
filenum++;
}
partnum = -1;
totalparts = -1;
if (curlog == L_SUCCESS || curlog == L_CHUNKSUCCESS ||
curlog == L_DONE || curlog == L_FAIL ||
curlog == L_CHUNK || curlog == L_PART || curlog == L_PARTIAL ||
curlog == L_PARTPARTIAL ) {
s = curstr;
ch = *s++;
skip_whitespace(s, ch);
if(ch == '\0') {
g_printf(_("strange log line in %s \"%s\"\n"),
logfile, curstr);
continue;
}
if (curlog == L_PART || curlog == L_PARTPARTIAL) {
char *part_label;
char *qpart_label = s - 1;
taper_part++;
skip_quoted_string(s, ch);
s[-1] = '\0';
part_label = unquote_string(qpart_label);
if (!g_hash_table_lookup(valid_label, part_label)) {
amfree(part_label);
continue;
}
amfree(current_label);
current_label = part_label;
skip_whitespace(s, ch);
if(ch == '\0') {
g_printf("strange log line in %s \"%s\"\n",
logfile, curstr);
continue;
}
number = s - 1;
skip_non_whitespace(s, ch);
s[-1] = '\0';
fileno = atoi(number);
filenum = fileno;
if (filenum == 0)
continue;
skip_whitespace(s, ch);
if(ch == '\0') {
g_printf("strange log line in %s \"%s\"\n",
logfile, curstr);
continue;
}
} else {
taper_part = 0;
}
host = s - 1;
skip_non_whitespace(s, ch);
host_undo = s - 1;
*host_undo = '\0';
skip_whitespace(s, ch);
if(ch == '\0') {
g_printf(_("strange log line in %s \"%s\"\n"),
logfile, curstr);
continue;
}
qdisk = s - 1;
skip_quoted_string(s, ch);
disk_undo = s - 1;
*disk_undo = '\0';
disk = unquote_string(qdisk);
skip_whitespace(s, ch);
if(ch == '\0') {
g_printf(_("strange log line in %s \"%s\"\n"),
logfile, curstr);
amfree(disk);
continue;
}
date = s - 1;
skip_non_whitespace(s, ch);
date_undo = s - 1;
*date_undo = '\0';
if(strlen(date) < 3) { /* old log didn't have datestamp */
level = atoi(date);
date = datestamp;
partnum = 1;
totalparts = 1;
} else {
if (curprog == P_TAPER &&
(curlog == L_CHUNK || curlog == L_PART ||
curlog == L_PARTPARTIAL || curlog == L_PARTIAL ||
curlog == L_DONE)) {
char *s1, ch1;
skip_whitespace(s, ch);
number = s - 1;
skip_non_whitespace(s, ch);
s1 = &s[-1];
ch1 = *s1;
skip_whitespace(s, ch);
if (*(s-1) != '[') {
*s1 = ch1;
sscanf(number, "%d/%d", &partnum, &totalparts);
if (partnum > maxparts)
maxparts = partnum;
if (totalparts > maxparts)
maxparts = totalparts;
} else { /* nparts is not in all PARTIAL lines */
partnum = 1;
totalparts = 1;
s = number + 1;
}
} else {
skip_whitespace(s, ch);
}
if(ch == '\0' || sscanf(s - 1, "%d", &level) != 1) {
g_printf(_("Fstrange log line in %s \"%s\"\n"),
logfile, s-1);
amfree(disk);
continue;
}
skip_integer(s, ch);
}
skip_whitespace(s, ch);
if(ch == '\0') {
g_printf(_("strange log line in %s \"%s\"\n"),
logfile, curstr);
amfree(disk);
continue;
}
rest = s - 1;
skip_non_whitespace(s, ch);
rest_undo = s - 1;
*rest_undo = '\0';
if (g_str_equal(rest, "[sec")) {
skip_whitespace(s, ch);
if(ch == '\0') {
g_printf(_("strange log line in %s \"%s\"\n"),
logfile, curstr);
amfree(disk);
continue;
}
sec = atof(s - 1);
skip_non_whitespace(s, ch);
skip_whitespace(s, ch);
rest = s - 1;
skip_non_whitespace(s, ch);
rest_undo = s - 1;
*rest_undo = '\0';
if (!g_str_equal(rest, "kb") &&
!g_str_equal(rest, "bytes")) {
g_printf(_("Bstrange log line in %s \"%s\"\n"),
logfile, curstr);
amfree(disk);
continue;
}
skip_whitespace(s, ch);
if (ch == '\0') {
g_printf(_("strange log line in %s \"%s\"\n"),
logfile, curstr);
amfree(disk);
continue;
}
if (g_str_equal(rest, "kb")) {
kb = atof(s - 1);
bytes = 0;
} else {
bytes = atof(s - 1);
kb = bytes / 1024;
}
skip_non_whitespace(s, ch);
skip_whitespace(s, ch);
rest = s - 1;
skip_non_whitespace(s, ch);
rest_undo = s - 1;
*rest_undo = '\0';
if (!g_str_equal(rest, "kps")) {
g_printf(_("Cstrange log line in %s \"%s\"\n"),
logfile, curstr);
amfree(disk);
continue;
}
skip_whitespace(s, ch);
if (ch == '\0') {
g_printf(_("strange log line in %s \"%s\"\n"),
logfile, curstr);
amfree(disk);
continue;
}
/* kps = atof(s - 1); */
skip_non_whitespace(s, ch);
skip_whitespace(s, ch);
rest = s - 1;
skip_non_whitespace(s, ch);
rest_undo = s - 1;
*rest_undo = '\0';
if (!g_str_equal(rest, "orig-kb")) {
orig_kb = 0;
} else {
skip_whitespace(s, ch);
if(ch == '\0') {
g_printf(_("strange log line in %s \"%s\"\n"),
logfile, curstr);
amfree(disk);
continue;
}
orig_kb = atof(s - 1);
}
} else {
sec = 0;
kb = 0;
bytes = 0;
orig_kb = 0;
*rest_undo = ' ';
}
if (g_str_has_prefix(rest, "error")) rest += 6;
if (g_str_has_prefix(rest, "config")) rest += 7;
dp = lookup_disk(host,disk);
if ( dp == NULL ) {
if (dynamic_disklist == NULL) {
amfree(disk);
continue;
}
dp = add_disk(dynamic_disklist, host, disk);
enqueue_disk(dynamic_disklist, dp);
}
if (find_match(host, disk)) {
if(curprog == P_TAPER) {
char *key = g_strdup_printf(
"HOST:%s DISK:%s: DATE:%s LEVEL:%d",
host, disk, date, level);
find_result_t *new_output_find = g_new0(find_result_t, 1);
part_find = g_hash_table_lookup(part_by_dle, key);
maxparts = partnum;
if (maxparts < totalparts)
maxparts = totalparts;
for (a_part_find = part_find;
a_part_find;
a_part_find = a_part_find->next) {
if (maxparts < a_part_find->partnum)
maxparts = a_part_find->partnum;
if (maxparts < a_part_find->totalparts)
maxparts = a_part_find->totalparts;
}
new_output_find->timestamp = g_string_chunk_insert_const(string_chunk, date);
new_output_find->write_timestamp = g_string_chunk_insert_const(string_chunk, datestamp);
new_output_find->hostname=g_string_chunk_insert_const(string_chunk, host);
new_output_find->diskname=g_string_chunk_insert_const(string_chunk, disk);
new_output_find->level=level;
new_output_find->partnum = partnum;
new_output_find->totalparts = totalparts;
new_output_find->label=g_string_chunk_insert_const(string_chunk, current_label);
new_output_find->status=NULL;
new_output_find->dump_status=NULL;
new_output_find->message="";
new_output_find->filenum=filenum;
new_output_find->sec=sec;
new_output_find->kb=kb;
new_output_find->bytes=bytes;
new_output_find->orig_kb=orig_kb;
new_output_find->next=NULL;
if (curlog == L_SUCCESS) {
new_output_find->status = "OK";
new_output_find->dump_status = "OK";
new_output_find->next = *output_find;
new_output_find->partnum = 1; /* L_SUCCESS is pre-splitting */
*output_find = new_output_find;
found_something = TRUE;
} else if (curlog == L_CHUNKSUCCESS || curlog == L_DONE ||
curlog == L_PARTIAL || curlog == L_FAIL) {
/* result line */
if (curlog == L_PARTIAL || curlog == L_FAIL) {
/* set dump_status of each part */
for (a_part_find = part_find;
a_part_find;
a_part_find = a_part_find->next) {
if (curlog == L_PARTIAL)
a_part_find->dump_status = "PARTIAL";
else {
a_part_find->dump_status = "FAIL";
a_part_find->message = g_string_chunk_insert_const(string_chunk, rest);
}
}
} else {
if (maxparts > -1) { /* format with part */
/* must check if all part are there */
int num_part = maxparts;
for (a_part_find = part_find;
a_part_find;
a_part_find = a_part_find->next) {
if (a_part_find->partnum == num_part &&
g_str_equal(a_part_find->status, "OK"))
num_part--;
}
/* set dump_status of each part */
for (a_part_find = part_find;
a_part_find;
a_part_find = a_part_find->next) {
if (num_part == 0) {
a_part_find->dump_status = "OK";
} else {
a_part_find->dump_status = "FAIL";
a_part_find->message =
g_string_chunk_insert_const(string_chunk, "Missing part");
}
}
}
}
if (curlog == L_DONE) {
for (a_part_find = part_find;
a_part_find;
a_part_find = a_part_find->next) {
if (a_part_find->totalparts == -1) {
a_part_find->totalparts = maxparts;
}
if (a_part_find->orig_kb == 0) {
a_part_find->orig_kb = orig_kb;
}
}
}
if (part_find) { /* find last element */
for (a_part_find = part_find;
a_part_find->next != NULL;
a_part_find=a_part_find->next) {
}
/* merge part_find to *output_find */
a_part_find->next = *output_find;
*output_find = part_find;
part_find = NULL;
maxparts = -1;
found_something = TRUE;
g_hash_table_remove(part_by_dle, key);
}
free_find_result(&new_output_find);
} else { /* part line */
if (curlog == L_PART || curlog == L_CHUNK) {
new_output_find->status = "OK";
new_output_find->dump_status = "OK";
} else { /* PARTPARTIAL */
new_output_find->status = "PARTIAL";
new_output_find->dump_status = "PARTIAL";
}
/* Add to part_find list */
if (part_find) {
new_output_find->next = part_find;
part_find = new_output_find;
} else {
new_output_find->next = NULL;
part_find = new_output_find;
}
g_hash_table_insert(part_by_dle, g_strdup(key),
part_find);
found_something = TRUE;
}
amfree(key);
}
else if(curlog == L_FAIL) {
char *status_failed;
/* print other failures too -- this is a hack to ensure that failures which
* did not make it to tape are also listed in the output of 'amadmin x find';
* users that do not want this information (e.g., Amanda::DB::Catalog) should
* filter dumps with a NULL label. */
find_result_t *new_output_find = g_new0(find_result_t, 1);
new_output_find->next = *output_find;
new_output_find->timestamp = g_string_chunk_insert_const(string_chunk, date);
new_output_find->write_timestamp = g_strdup("00000000000000"); /* dump was not written.. */
new_output_find->hostname=g_string_chunk_insert_const(string_chunk, host);
new_output_find->diskname=g_string_chunk_insert_const(string_chunk, disk);
new_output_find->level=level;
new_output_find->label=NULL;
new_output_find->partnum=partnum;
new_output_find->totalparts=totalparts;
new_output_find->filenum=0;
new_output_find->sec=sec;
new_output_find->kb=kb;
new_output_find->bytes=bytes;
new_output_find->orig_kb=orig_kb;
status_failed = g_strjoin(NULL,
"FAILED (",
program_str[(int)curprog],
") ",
rest,
NULL);
new_output_find->status = g_string_chunk_insert_const(string_chunk, status_failed);
amfree(status_failed);
new_output_find->dump_status="";
new_output_find->message="";
*output_find=new_output_find;
found_something = TRUE;
maxparts = -1;
}
}
amfree(disk);
}
}
g_hash_table_destroy(valid_label);
afclose(logf);
amfree(datestamp);
amfree(current_label);
amfree(disk);
return found_something;
}
cmddatas_t *
read_cmdfile(
char *filename)
{
cmddatas_t *cmddatas = g_new0(cmddatas_t, 1);
cmddata_t *cmddata;
char *s, *fp, *operation;
char ch;
char **xlines;
int i;
int pid;
pid_t pids[NB_PIDS];
pid_t new_pids[NB_PIDS];
int nb_pids = 0;
int result;
gboolean generic_command_restore = FALSE;
gboolean specific_command_restore = FALSE;
cmddatas->lock = file_lock_new(filename);
cmddatas->cmdfile = g_hash_table_new_full(g_direct_hash, g_direct_equal,
NULL, &free_cmddata);
need_rewrite = FALSE;
// open
while ((result = file_lock_lock(cmddatas->lock)) == 1) {
sleep(1);
}
if (result != 0) {
g_debug("read_cmdfile open failed: %s", strerror(errno));
}
if (!cmddatas->lock->data) {
cmddatas->version = 1;
cmddatas->max_id = 0;
return cmddatas;
}
xlines = g_strsplit(cmddatas->lock->data, "\n", 0);
// read
if (sscanf(xlines[0], "VERSION %d", &cmddatas->version) != 1) {};
if (sscanf(xlines[1], "ID %d", &cmddatas->max_id) != 1) {};
// read cmd
for (i=2; xlines[i] != NULL; i++) {
int id;
s = xlines[i];
if (*s == '\0') continue;
ch = *s++;
skip_whitespace(s, ch);
if (ch == '\0' || sscanf((s - 1), "%d", &id) != 1) {
continue;
}
skip_integer(s, ch);
skip_whitespace(s, ch);
operation = s - 1;
skip_non_whitespace(s, ch);
s[-1] = '\0';
if (!g_str_equal(operation, "FLUSH") &&
!g_str_equal(operation, "COPY") &&
!g_str_equal(operation, "RESTORE")) {
g_debug("BAD operation %s: %s", operation, s);
continue;
}
cmddata = g_new0(cmddata_t, 1);
cmddata->id = id;
skip_whitespace(s, ch);
fp = s - 1;
skip_non_whitespace(s, ch);
s[-1] = '\0';
cmddata->config = unquote_string(fp);
if (g_str_equal(operation, "FLUSH")) {
cmddata->operation = CMD_FLUSH;
skip_whitespace(s,ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->holding_file = unquote_string(fp);
} else if (g_str_equal(operation, "COPY")) {
char *src_labels;
char *slabels;
char *a;
cmddata->operation = CMD_COPY;
skip_whitespace(s,ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->src_storage = unquote_string(fp);
skip_whitespace(s,ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->src_pool = unquote_string(fp);
skip_whitespace(s,ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->src_label = unquote_string(fp);
skip_whitespace(s,ch);
fp = s - 1;
skip_integer(s, ch);
s[-1] = '\0';
cmddata->src_fileno = atoi(fp);
skip_whitespace(s,ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
slabels = src_labels = unquote_string(fp);
cmddata->src_labels_str = g_strdup(src_labels);
a = strstr(slabels, " ;");
if (a) {
slabels = a+2;
while ((a = strstr(slabels, " ;"))) {
*a = '\0';
cmddata->src_labels = g_slist_append(cmddata->src_labels, g_strdup(slabels));
slabels = a+2;
}
}
g_free(src_labels);
skip_whitespace(s,ch);
fp = s - 1;
skip_integer(s, ch);
s[-1] = '\0';
cmddata->start_time = atoll(fp);
} else if (g_str_equal(operation, "RESTORE")) {
cmddata->operation = CMD_RESTORE;
skip_whitespace(s,ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->src_storage = unquote_string(fp);
skip_whitespace(s,ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->src_pool = unquote_string(fp);
skip_whitespace(s,ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
if (g_str_equal(cmddata->src_pool, "HOLDING")) {
cmddata->holding_file = unquote_string(fp);
} else {
cmddata->src_label = unquote_string(fp);
}
skip_whitespace(s,ch);
fp = s - 1;
skip_integer(s, ch);
s[-1] = '\0';
cmddata->src_fileno = atoi(fp);
skip_whitespace(s,ch);
fp = s - 1;
skip_integer(s, ch);
s[-1] = '\0';
cmddata->expire = atoll(fp);
} else {
}
skip_whitespace(s, ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->hostname = unquote_string(fp);
skip_whitespace(s, ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->diskname = unquote_string(fp);
skip_whitespace(s, ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->dump_timestamp = unquote_string(fp);
skip_whitespace(s,ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->level = atoi(fp);
skip_whitespace(s, ch);
if (cmddata->operation != CMD_RESTORE) {
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->dst_storage = unquote_string(fp);
skip_whitespace(s, ch);
}
fp = s - 1;
skip_non_whitespace(s, ch);
s[-1] = '\0';
if (sscanf(fp, "WORKING:%d", &pid) != 1) {
}
cmddata->working_pid = pid;
if (cmddata->operation == CMD_RESTORE) {
if (cmddata->working_pid == 0)
generic_command_restore = TRUE;
else
specific_command_restore = TRUE;
}
skip_whitespace(s, ch);
fp = s - 1;
skip_non_whitespace(s, ch);
s[-1] = '\0';
if (g_str_equal(fp, "DONE")) {
cmddata->status = CMD_DONE;
} else if (g_str_equal(fp, "TODO")) {
cmddata->status = CMD_TODO;
} else if (strncmp(fp, "PARTIAL", 7) == 0) {
long long lsize;
cmddata->status = CMD_PARTIAL;
if (sscanf(fp, "PARTIAL:%lld", &lsize) != 1) {
} else {
cmddata->size = lsize;
}
} else {
}
/* validate working_pid */
if (!checked_working_pid && cmddata->working_pid != 0) {
int i;
for (i = 0; i < nb_pids; i++) {
if (pids[i] == cmddata->working_pid) {
cmddata->working_pid = new_pids[i];
i += 100;
continue;
}
}
if (nb_pids < NB_PIDS) {
pids[nb_pids] = cmddata->working_pid;
if (kill(cmddata->working_pid, 0) != 0)
cmddata->working_pid =0;
new_pids[nb_pids] = cmddata->working_pid;
nb_pids++;
}
}
g_hash_table_insert(cmddatas->cmdfile, GINT_TO_POINTER(cmddata->id), cmddata);
}
if (generic_command_restore) {
if (specific_command_restore) {
/* set expire to NOW+24h of all genric command_restore */
g_hash_table_foreach(cmddatas->cmdfile, &cmdfile_set_expire, NULL);
} else {
/* check start_time of all generic command_restore and remove them */
g_hash_table_foreach(cmddatas->cmdfile, &cmdfile_set_to_DONE, NULL);
}
}
g_strfreev(xlines);
checked_working_pid = 1;
if (need_rewrite) {
write_cmdfile(cmddatas);
return read_cmdfile(filename);
}
return cmddatas;
}
void
set_disk(
char * dsk,
char * mtpt)
{
char *cmd = NULL;
char *qdsk;
char *uqdsk;
char *uqmtpt = NULL;
if (is_extract_list_nonempty())
{
g_printf(_("Must clear extract list before changing disk\n"));
return;
}
/* if mount point specified, check it is valid */
if (mtpt != NULL) {
uqmtpt = unquote_string(mtpt);
if (*mtpt != '/') {
g_printf(_("Mount point \"%s\" invalid - must start with /\n"), uqmtpt);
amfree(uqmtpt);
return;
}
}
clear_dir_list();
uqdsk = unquote_string(dsk);
qdsk = quote_string(uqdsk);
cmd = stralloc2("DISK ", qdsk);
amfree(qdsk);
if (converse(cmd) == -1)
exit(1);
amfree(cmd);
if (!server_happy()) {
amfree(uqmtpt);
amfree(uqdsk);
return;
}
disk_name = newstralloc(disk_name, uqdsk);
if (mtpt == NULL)
{
/* mount point not specified */
if (*uqdsk == '/')
{
/* disk specified by mount point, hence use it */
mount_point = newstralloc(mount_point, uqdsk);
}
else
{
/* device name given, use '/' because nothing better */
mount_point = newstralloc(mount_point, "/");
}
}
else
{
/* mount point specified */
mount_point = newstralloc(mount_point, uqmtpt);
}
/* set the working directory to the mount point */
/* there is the possibility that there are no index records for the
disk for the given date, hence setting the directory to the
mount point will fail. Preempt this by checking first so we can write
a more informative message. */
if (exchange("OISD /") == -1)
exit(1);
if (server_happy())
{
disk_path = newstralloc(disk_path, "/");
suck_dir_list_from_server(); /* get list of directory contents */
}
else
{
g_printf(_("No index records for disk for specified date\n"));
g_printf(_("If date correct, notify system administrator\n"));
disk_path = newstralloc(disk_path, "/"); /* fake it */
clear_dir_list();
}
amfree(uqmtpt);
amfree(uqdsk);
if (am_has_feature(indexsrv_features, fe_amindexd_DLE)) {
char *dle_str;
char *errmsg = NULL;
cmd = stralloc("DLE");
if (exchange(cmd) == -1)
exit(1);
amfree(cmd);
if (!server_happy())
return;
dle_str = reply_line();
if (BSTRNCMP(dle_str+4, "NODLE") == 0) {
dump_dle = NULL;
} else {
dle_str = unquote_string(dle_str+4);
dump_dle = amxml_parse_node_CHAR(dle_str, &errmsg);
amfree(dle_str);
}
}
}
/* Get the next NELT_NAME element from name_array. Result is in
static storage and can't be relied upon across two calls.
If CHANGE_DIRS is true, treat any entries of type NELT_CHDIR as
the request to change to the given directory.
Entries of type NELT_FMASK cause updates of the matching_flags
value. */
struct name_elt *
name_next_elt (int change_dirs)
{
static struct name_elt entry;
const char *source;
char *cursor;
while (name_index != names)
{
struct name_elt *ep;
size_t source_len;
ep = &name_array[name_index++];
if (ep->type == NELT_FMASK)
{
matching_flags = ep->v.matching_flags;
continue;
}
source = ep->v.name;
source_len = strlen (source);
if (name_buffer_length < source_len)
{
do
{
name_buffer_length *= 2;
if (! name_buffer_length)
xalloc_die ();
}
while (name_buffer_length < source_len);
free (name_buffer);
name_buffer = xmalloc (name_buffer_length + 2);
}
strcpy (name_buffer, source);
/* Zap trailing slashes. */
cursor = name_buffer + strlen (name_buffer) - 1;
while (cursor > name_buffer && ISSLASH (*cursor))
*cursor-- = '\0';
if (change_dirs && ep->type == NELT_CHDIR)
{
if (chdir (name_buffer) < 0)
chdir_fatal (name_buffer);
}
else
{
if (unquote_option)
unquote_string (name_buffer);
if (incremental_option)
register_individual_file (name_buffer);
entry.type = ep->type;
entry.v.name = name_buffer;
return &entry;
}
}
return NULL;
}
cmddata_t *
cmdfile_parse_line (
char *line,
gboolean *generic_command_restore,
gboolean *specific_command_restore)
{
int pid;
char *s, *fp, *operation;
char ch;
cmddata_t *cmddata;
int id;
s = line;
if (*s == '\0') return NULL;
ch = *s++;
skip_whitespace(s, ch);
if (ch == '\0' || sscanf((s - 1), "%d", &id) != 1) {
return NULL;
}
skip_integer(s, ch);
skip_whitespace(s, ch);
operation = s - 1;
skip_non_whitespace(s, ch);
s[-1] = '\0';
if (!g_str_equal(operation, "FLUSH") &&
!g_str_equal(operation, "COPY") &&
!g_str_equal(operation, "RESTORE")) {
g_debug("BAD operation %s: %s", operation, s);
return NULL;
}
cmddata = g_new0(cmddata_t, 1);
cmddata->id = id;
skip_whitespace(s, ch);
fp = s - 1;
skip_non_whitespace(s, ch);
s[-1] = '\0';
cmddata->config = unquote_string(fp);
if (g_str_equal(operation, "FLUSH")) {
cmddata->operation = CMD_FLUSH;
skip_whitespace(s,ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->holding_file = unquote_string(fp);
} else if (g_str_equal(operation, "COPY")) {
char *src_labels;
char *slabels;
char *a;
cmddata->operation = CMD_COPY;
skip_whitespace(s,ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->src_storage = unquote_string(fp);
skip_whitespace(s,ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->src_pool = unquote_string(fp);
skip_whitespace(s,ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->src_label = unquote_string(fp);
skip_whitespace(s,ch);
fp = s - 1;
skip_integer(s, ch);
s[-1] = '\0';
cmddata->src_fileno = atoi(fp);
skip_whitespace(s,ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
slabels = src_labels = unquote_string(fp);
cmddata->src_labels_str = g_strdup(src_labels);
a = strstr(slabels, " ;");
if (a) {
slabels = a+2;
while ((a = strstr(slabels, " ;"))) {
*a = '\0';
cmddata->src_labels = g_slist_append(cmddata->src_labels, g_strdup(slabels));
slabels = a+2;
}
}
g_free(src_labels);
skip_whitespace(s,ch);
fp = s - 1;
skip_integer(s, ch);
s[-1] = '\0';
cmddata->start_time = atoll(fp);
} else if (g_str_equal(operation, "RESTORE")) {
cmddata->operation = CMD_RESTORE;
skip_whitespace(s,ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->src_storage = unquote_string(fp);
skip_whitespace(s,ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->src_pool = unquote_string(fp);
skip_whitespace(s,ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
if (g_str_equal(cmddata->src_pool, "HOLDING")) {
cmddata->holding_file = unquote_string(fp);
} else {
cmddata->src_label = unquote_string(fp);
}
skip_whitespace(s,ch);
fp = s - 1;
skip_integer(s, ch);
s[-1] = '\0';
cmddata->src_fileno = atoi(fp);
skip_whitespace(s,ch);
fp = s - 1;
skip_integer(s, ch);
s[-1] = '\0';
cmddata->expire = atoll(fp);
} else {
}
skip_whitespace(s, ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->hostname = unquote_string(fp);
skip_whitespace(s, ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->diskname = unquote_string(fp);
skip_whitespace(s, ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->dump_timestamp = unquote_string(fp);
skip_whitespace(s,ch);
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->level = atoi(fp);
skip_whitespace(s, ch);
if (cmddata->operation != CMD_RESTORE) {
fp = s - 1;
skip_quoted_string(s, ch);
s[-1] = '\0';
cmddata->dst_storage = unquote_string(fp);
skip_whitespace(s, ch);
}
fp = s - 1;
skip_non_whitespace(s, ch);
s[-1] = '\0';
if (sscanf(fp, "WORKING:%d", &pid) != 1) {
}
cmddata->working_pid = pid;
if (cmddata->operation == CMD_RESTORE) {
if (cmddata->working_pid == 0) {
if (generic_command_restore)
*generic_command_restore = TRUE;
} else {
if (specific_command_restore)
*specific_command_restore = TRUE;
}
}
skip_whitespace(s, ch);
fp = s - 1;
skip_non_whitespace(s, ch);
s[-1] = '\0';
if (g_str_equal(fp, "DONE")) {
cmddata->status = CMD_DONE;
} else if (g_str_equal(fp, "TODO")) {
cmddata->status = CMD_TODO;
} else if (strncmp(fp, "PARTIAL", 7) == 0) {
long long lsize;
cmddata->status = CMD_PARTIAL;
if (sscanf(fp, "PARTIAL:%lld", &lsize) != 1) {
} else {
cmddata->size = lsize;
}
} else {
}
return cmddata;
}
/* Read incremental snapshot formats 0 and 1 */
static void
read_incr_db_01 (int version, const char *initbuf)
{
int n;
uintmax_t u;
time_t sec;
long int nsec;
char *buf = NULL;
size_t bufsize = 0;
char *ebuf;
long lineno = 1;
if (version == 1)
{
if (getline (&buf, &bufsize, listed_incremental_stream) <= 0)
{
read_error (listed_incremental_option);
free (buf);
return;
}
++lineno;
}
else
{
buf = strdup (initbuf);
bufsize = strlen (buf) + 1;
}
sec = TYPE_MINIMUM (time_t);
nsec = -1;
errno = 0;
u = strtoumax (buf, &ebuf, 10);
if (!errno && TYPE_MAXIMUM (time_t) < u)
errno = ERANGE;
if (errno || buf == ebuf)
ERROR ((0, errno, "%s:%ld: %s",
quotearg_colon (listed_incremental_option),
lineno,
_("Invalid time stamp")));
else
{
sec = u;
if (version == 1 && *ebuf)
{
char const *buf_ns = ebuf + 1;
errno = 0;
u = strtoumax (buf_ns, &ebuf, 10);
if (!errno && BILLION <= u)
errno = ERANGE;
if (errno || buf_ns == ebuf)
{
ERROR ((0, errno, "%s:%ld: %s",
quotearg_colon (listed_incremental_option),
lineno,
_("Invalid time stamp")));
sec = TYPE_MINIMUM (time_t);
}
else
nsec = u;
}
else
{
/* pre-1 incremental format does not contain nanoseconds */
nsec = 0;
}
}
newer_mtime_option.tv_sec = sec;
newer_mtime_option.tv_nsec = nsec;
while (0 < (n = getline (&buf, &bufsize, listed_incremental_stream)))
{
dev_t dev;
ino_t ino;
bool nfs = buf[0] == '+';
char *strp = buf + nfs;
struct timespec mtime;
lineno++;
if (buf[n - 1] == '\n')
buf[n - 1] = '\0';
if (version == 1)
{
errno = 0;
u = strtoumax (strp, &ebuf, 10);
if (!errno && TYPE_MAXIMUM (time_t) < u)
errno = ERANGE;
if (errno || strp == ebuf || *ebuf != ' ')
{
ERROR ((0, errno, "%s:%ld: %s",
quotearg_colon (listed_incremental_option), lineno,
_("Invalid modification time (seconds)")));
sec = (time_t) -1;
}
else
sec = u;
strp = ebuf;
errno = 0;
u = strtoumax (strp, &ebuf, 10);
if (!errno && BILLION <= u)
errno = ERANGE;
if (errno || strp == ebuf || *ebuf != ' ')
{
ERROR ((0, errno, "%s:%ld: %s",
quotearg_colon (listed_incremental_option), lineno,
_("Invalid modification time (nanoseconds)")));
nsec = -1;
}
else
nsec = u;
mtime.tv_sec = sec;
mtime.tv_nsec = nsec;
strp = ebuf;
}
else
memset (&mtime, 0, sizeof mtime);
errno = 0;
u = strtoumax (strp, &ebuf, 10);
if (!errno && TYPE_MAXIMUM (dev_t) < u)
errno = ERANGE;
if (errno || strp == ebuf || *ebuf != ' ')
{
ERROR ((0, errno, "%s:%ld: %s",
quotearg_colon (listed_incremental_option), lineno,
_("Invalid device number")));
dev = (dev_t) -1;
}
else
dev = u;
strp = ebuf;
errno = 0;
u = strtoumax (strp, &ebuf, 10);
if (!errno && TYPE_MAXIMUM (ino_t) < u)
errno = ERANGE;
if (errno || strp == ebuf || *ebuf != ' ')
{
ERROR ((0, errno, "%s:%ld: %s",
quotearg_colon (listed_incremental_option), lineno,
_("Invalid inode number")));
ino = (ino_t) -1;
}
else
ino = u;
strp = ebuf;
strp++;
unquote_string (strp);
note_directory (strp, mtime, dev, ino, nfs, false, NULL);
}
free (buf);
}
/****************
* Scan the provided buffer and return the S expression in our internal
* format. Returns a newly allocated expression. If erroff is not NULL and
* a parsing error has occurred, the offset into buffer will be returned.
* If ARGFLAG is true, the function supports some printf like
* expressions.
* These are:
* %m - MPI
* %s - string (no autoswitch to secure allocation)
* %d - integer stored as string (no autoswitch to secure allocation)
* %b - memory buffer; this takes _two_ arguments: an integer with the
* length of the buffer and a pointer to the buffer.
* %S - Copy an gcry_sexp_t here. The S-expression needs to be a
* regular one, starting with a parenthesis.
* (no autoswitch to secure allocation)
* all other format elements are currently not defined and return an error.
* this includes the "%%" sequence becauce the percent sign is not an
* allowed character.
* FIXME: We should find a way to store the secure-MPIs not in the string
* but as reference to somewhere - this can help us to save huge amounts
* of secure memory. The problem is, that if only one element is secure, all
* other elements are automagicaly copied to secure memory too, so the most
* common operation gcry_sexp_cdr_mpi() will always return a secure MPI
* regardless whether it is needed or not.
*/
static gcry_error_t
vsexp_sscan (gcry_sexp_t *retsexp, size_t *erroff,
const char *buffer, size_t length, int argflag,
void **arg_list, va_list arg_ptr)
{
gcry_err_code_t err = 0;
static const char tokenchars[] =
"abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"0123456789-./_:*+=";
const char *p;
size_t n;
const char *digptr = NULL;
const char *quoted = NULL;
const char *tokenp = NULL;
const char *hexfmt = NULL;
const char *base64 = NULL;
const char *disphint = NULL;
const char *percent = NULL;
int hexcount = 0;
int quoted_esc = 0;
int datalen = 0;
size_t dummy_erroff;
struct make_space_ctx c;
int arg_counter = 0;
int level = 0;
if (!erroff)
erroff = &dummy_erroff;
/* Depending on whether ARG_LIST is non-zero or not, this macro gives
us the next argument, either from the variable argument list as
specified by ARG_PTR or from the argument array ARG_LIST. */
#define ARG_NEXT(storage, type) \
do \
{ \
if (!arg_list) \
storage = va_arg (arg_ptr, type); \
else \
storage = *((type *) (arg_list[arg_counter++])); \
} \
while (0)
/* The MAKE_SPACE macro is used before each store operation to
ensure that the buffer is large enough. It requires a global
context named C and jumps out to the label LEAVE on error! It
also sets ERROFF using the variables BUFFER and P. */
#define MAKE_SPACE(n) do { \
gpg_err_code_t _ms_err = make_space (&c, (n)); \
if (_ms_err) \
{ \
err = _ms_err; \
*erroff = p - buffer; \
goto leave; \
} \
} while (0)
/* The STORE_LEN macro is used to store the length N at buffer P. */
#define STORE_LEN(p,n) do { \
DATALEN ashort = (n); \
memcpy ( (p), &ashort, sizeof(ashort) ); \
(p) += sizeof (ashort); \
} while (0)
/* We assume that the internal representation takes less memory than
the provided one. However, we add space for one extra datalen so
that the code which does the ST_CLOSE can use MAKE_SPACE */
c.allocated = length + sizeof(DATALEN);
if (buffer && length && gcry_is_secure (buffer))
c.sexp = gcry_malloc_secure (sizeof *c.sexp + c.allocated - 1);
else
c.sexp = gcry_malloc (sizeof *c.sexp + c.allocated - 1);
if (!c.sexp)
{
err = gpg_err_code_from_errno (errno);
*erroff = 0;
goto leave;
}
c.pos = c.sexp->d;
for (p = buffer, n = length; n; p++, n--)
{
if (tokenp && !hexfmt)
{
if (strchr (tokenchars, *p))
continue;
else
{
datalen = p - tokenp;
MAKE_SPACE (datalen);
*c.pos++ = ST_DATA;
STORE_LEN (c.pos, datalen);
memcpy (c.pos, tokenp, datalen);
c.pos += datalen;
tokenp = NULL;
}
}
if (quoted)
{
if (quoted_esc)
{
switch (*p)
{
case 'b': case 't': case 'v': case 'n': case 'f':
case 'r': case '"': case '\'': case '\\':
quoted_esc = 0;
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7':
if (!((n > 2)
&& (p[1] >= '0') && (p[1] <= '7')
&& (p[2] >= '0') && (p[2] <= '7')))
{
*erroff = p - buffer;
/* Invalid octal value. */
err = GPG_ERR_SEXP_BAD_QUOTATION;
goto leave;
}
p += 2;
n -= 2;
quoted_esc = 0;
break;
case 'x':
if (!((n > 2) && hexdigitp (p+1) && hexdigitp (p+2)))
{
*erroff = p - buffer;
/* Invalid hex value. */
err = GPG_ERR_SEXP_BAD_QUOTATION;
goto leave;
}
p += 2;
n -= 2;
quoted_esc = 0;
break;
case '\r':
/* ignore CR[,LF] */
if (n && (p[1] == '\n'))
{
p++;
n--;
}
quoted_esc = 0;
break;
case '\n':
/* ignore LF[,CR] */
if (n && (p[1] == '\r'))
{
p++;
n--;
}
quoted_esc = 0;
break;
default:
*erroff = p - buffer;
/* Invalid quoted string escape. */
err = GPG_ERR_SEXP_BAD_QUOTATION;
goto leave;
}
}
else if (*p == '\\')
quoted_esc = 1;
else if (*p == '\"')
{
/* Keep it easy - we know that the unquoted string will
never be larger. */
unsigned char *save;
size_t len;
quoted++; /* Skip leading quote. */
MAKE_SPACE (p - quoted);
*c.pos++ = ST_DATA;
save = c.pos;
STORE_LEN (c.pos, 0); /* Will be fixed up later. */
len = unquote_string (quoted, p - quoted, c.pos);
c.pos += len;
STORE_LEN (save, len);
quoted = NULL;
}
}
else if (hexfmt)
{
if (isxdigit (*p))
hexcount++;
else if (*p == '#')
{
if ((hexcount & 1))
{
*erroff = p - buffer;
err = GPG_ERR_SEXP_ODD_HEX_NUMBERS;
goto leave;
}
datalen = hexcount / 2;
MAKE_SPACE (datalen);
*c.pos++ = ST_DATA;
STORE_LEN (c.pos, datalen);
for (hexfmt++; hexfmt < p; hexfmt++)
{
int tmpc;
if (whitespacep (hexfmt))
continue;
tmpc = hextonibble (*(const unsigned char*)hexfmt);
for (hexfmt++; hexfmt < p && whitespacep (hexfmt); hexfmt++)
;
if (hexfmt < p)
{
tmpc *= 16;
tmpc += hextonibble (*(const unsigned char*)hexfmt);
}
*c.pos++ = tmpc;
}
hexfmt = NULL;
}
else if (!whitespacep (p))
{
*erroff = p - buffer;
err = GPG_ERR_SEXP_BAD_HEX_CHAR;
goto leave;
}
}
else if (base64)
{
if (*p == '|')
base64 = NULL;
}
else if (digptr)
{
if (digitp (p))
;
else if (*p == ':')
{
datalen = atoi (digptr); /* FIXME: check for overflow. */
digptr = NULL;
if (datalen > n - 1)
{
*erroff = p - buffer;
/* Buffer too short. */
err = GPG_ERR_SEXP_STRING_TOO_LONG;
goto leave;
}
/* Make a new list entry. */
MAKE_SPACE (datalen);
*c.pos++ = ST_DATA;
STORE_LEN (c.pos, datalen);
memcpy (c.pos, p + 1, datalen);
c.pos += datalen;
n -= datalen;
p += datalen;
}
else if (*p == '\"')
{
digptr = NULL; /* We ignore the optional length. */
quoted = p;
quoted_esc = 0;
}
else if (*p == '#')
{
digptr = NULL; /* We ignore the optional length. */
hexfmt = p;
hexcount = 0;
}
else if (*p == '|')
{
digptr = NULL; /* We ignore the optional length. */
base64 = p;
}
else
{
*erroff = p - buffer;
err = GPG_ERR_SEXP_INV_LEN_SPEC;
goto leave;
}
}
else if (percent)
{
if (*p == 'm' || *p == 'M')
{
/* Insert an MPI. */
gcry_mpi_t m;
size_t nm = 0;
int mpifmt = *p == 'm'? GCRYMPI_FMT_STD: GCRYMPI_FMT_USG;
ARG_NEXT (m, gcry_mpi_t);
if (gcry_mpi_get_flag (m, GCRYMPI_FLAG_OPAQUE))
{
void *mp;
unsigned int nbits;
mp = gcry_mpi_get_opaque (m, &nbits);
nm = (nbits+7)/8;
if (mp && nm)
{
MAKE_SPACE (nm);
if (!gcry_is_secure (c.sexp->d)
&& gcry_mpi_get_flag (m, GCRYMPI_FLAG_SECURE))
{
/* We have to switch to secure allocation. */
gcry_sexp_t newsexp;
byte *newhead;
newsexp = gcry_malloc_secure (sizeof *newsexp
+ c.allocated - 1);
if (!newsexp)
{
err = gpg_err_code_from_errno (errno);
goto leave;
}
newhead = newsexp->d;
memcpy (newhead, c.sexp->d, (c.pos - c.sexp->d));
c.pos = newhead + (c.pos - c.sexp->d);
gcry_free (c.sexp);
c.sexp = newsexp;
}
*c.pos++ = ST_DATA;
STORE_LEN (c.pos, nm);
memcpy (c.pos, mp, nm);
c.pos += nm;
}
}
else
{
if (gcry_mpi_print (mpifmt, NULL, 0, &nm, m))
BUG ();
MAKE_SPACE (nm);
if (!gcry_is_secure (c.sexp->d)
&& gcry_mpi_get_flag ( m, GCRYMPI_FLAG_SECURE))
{
/* We have to switch to secure allocation. */
gcry_sexp_t newsexp;
byte *newhead;
newsexp = gcry_malloc_secure (sizeof *newsexp
+ c.allocated - 1);
if (!newsexp)
{
err = gpg_err_code_from_errno (errno);
goto leave;
}
newhead = newsexp->d;
memcpy (newhead, c.sexp->d, (c.pos - c.sexp->d));
c.pos = newhead + (c.pos - c.sexp->d);
gcry_free (c.sexp);
c.sexp = newsexp;
}
*c.pos++ = ST_DATA;
STORE_LEN (c.pos, nm);
if (gcry_mpi_print (mpifmt, c.pos, nm, &nm, m))
BUG ();
c.pos += nm;
}
}
else if (*p == 's')
{
/* Insert an string. */
const char *astr;
size_t alen;
ARG_NEXT (astr, const char *);
alen = strlen (astr);
MAKE_SPACE (alen);
*c.pos++ = ST_DATA;
STORE_LEN (c.pos, alen);
memcpy (c.pos, astr, alen);
c.pos += alen;
}
else if (*p == 'b')
{
/* Insert a memory buffer. */
const char *astr;
int alen;
ARG_NEXT (alen, int);
ARG_NEXT (astr, const char *);
MAKE_SPACE (alen);
if (alen
&& !gcry_is_secure (c.sexp->d)
&& gcry_is_secure (astr))
{
/* We have to switch to secure allocation. */
gcry_sexp_t newsexp;
byte *newhead;
newsexp = gcry_malloc_secure (sizeof *newsexp
+ c.allocated - 1);
if (!newsexp)
{
err = gpg_err_code_from_errno (errno);
goto leave;
}
newhead = newsexp->d;
memcpy (newhead, c.sexp->d, (c.pos - c.sexp->d));
c.pos = newhead + (c.pos - c.sexp->d);
gcry_free (c.sexp);
c.sexp = newsexp;
}
*c.pos++ = ST_DATA;
STORE_LEN (c.pos, alen);
memcpy (c.pos, astr, alen);
c.pos += alen;
}
else if (*p == 'd')
{
/* Insert an integer as string. */
int aint;
size_t alen;
char buf[35];
ARG_NEXT (aint, int);
sprintf (buf, "%d", aint);
alen = strlen (buf);
MAKE_SPACE (alen);
*c.pos++ = ST_DATA;
STORE_LEN (c.pos, alen);
memcpy (c.pos, buf, alen);
c.pos += alen;
}
else if (*p == 'u')
{
/* Insert an unsigned integer as string. */
unsigned int aint;
size_t alen;
char buf[35];
ARG_NEXT (aint, unsigned int);
sprintf (buf, "%u", aint);
alen = strlen (buf);
MAKE_SPACE (alen);
*c.pos++ = ST_DATA;
STORE_LEN (c.pos, alen);
memcpy (c.pos, buf, alen);
c.pos += alen;
}
else if (*p == 'S')
{
/* Insert a gcry_sexp_t. */
gcry_sexp_t asexp;
size_t alen, aoff;
ARG_NEXT (asexp, gcry_sexp_t);
alen = get_internal_buffer (asexp, &aoff);
if (alen)
{
MAKE_SPACE (alen);
memcpy (c.pos, asexp->d + aoff, alen);
c.pos += alen;
}
}
else
{
*erroff = p - buffer;
/* Invalid format specifier. */
err = GPG_ERR_SEXP_INV_LEN_SPEC;
goto leave;
}
percent = NULL;
}
else if (*p == '(')
{
if (disphint)
{
*erroff = p - buffer;
/* Open display hint. */
err = GPG_ERR_SEXP_UNMATCHED_DH;
goto leave;
}
MAKE_SPACE (0);
*c.pos++ = ST_OPEN;
level++;
}
else if (*p == ')')
{
/* Walk up. */
if (disphint)
{
*erroff = p - buffer;
/* Open display hint. */
err = GPG_ERR_SEXP_UNMATCHED_DH;
goto leave;
}
MAKE_SPACE (0);
*c.pos++ = ST_CLOSE;
level--;
}
else if (*p == '\"')
{
quoted = p;
quoted_esc = 0;
}
else if (*p == '#')
{
hexfmt = p;
hexcount = 0;
}
else if (*p == '|')
base64 = p;
else if (*p == '[')
{
if (disphint)
{
*erroff = p - buffer;
/* Open display hint. */
err = GPG_ERR_SEXP_NESTED_DH;
goto leave;
}
disphint = p;
}
else if (*p == ']')
{
if (!disphint)
{
*erroff = p - buffer;
/* Open display hint. */
err = GPG_ERR_SEXP_UNMATCHED_DH;
goto leave;
}
disphint = NULL;
}
else if (digitp (p))
{
if (*p == '0')
{
/* A length may not begin with zero. */
*erroff = p - buffer;
err = GPG_ERR_SEXP_ZERO_PREFIX;
goto leave;
}
digptr = p;
}
else if (strchr (tokenchars, *p))
tokenp = p;
else if (whitespacep (p))
;
else if (*p == '{')
{
/* fixme: handle rescanning: we can do this by saving our
current state and start over at p+1 -- Hmmm. At this
point here we are in a well defined state, so we don't
need to save it. Great. */
*erroff = p - buffer;
err = GPG_ERR_SEXP_UNEXPECTED_PUNC;
goto leave;
}
else if (strchr ("&\\", *p))
{
/* Reserved punctuation. */
*erroff = p - buffer;
err = GPG_ERR_SEXP_UNEXPECTED_PUNC;
goto leave;
}
else if (argflag && (*p == '%'))
percent = p;
else
{
/* Bad or unavailable. */
*erroff = p - buffer;
err = GPG_ERR_SEXP_BAD_CHARACTER;
goto leave;
}
}
MAKE_SPACE (0);
*c.pos++ = ST_STOP;
if (level && !err)
err = GPG_ERR_SEXP_UNMATCHED_PAREN;
leave:
if (err)
{
/* Error -> deallocate. */
if (c.sexp)
{
/* Extra paranoid wipe on error. */
if (gcry_is_secure (c.sexp))
wipememory (c.sexp, sizeof (struct gcry_sexp) + c.allocated - 1);
gcry_free (c.sexp);
}
/* This might be expected by existing code... */
*retsexp = NULL;
}
else
*retsexp = normalize (c.sexp);
return gcry_error (err);
#undef MAKE_SPACE
#undef STORE_LEN
}