static void
enter_record(
char * name,
int level,
time_t dumpdate)
{
amandates_t *amdp;
char *qname;
amdp = lookup(name, 0);
if (level < 0 || level >= DUMP_LEVELS) {
qname = quote_string(name);
/* this is not allowed, but we can ignore it */
dbprintf(_("amandates botch: %s lev %d: new dumpdate %ld\n"),
qname, level, (long) dumpdate);
amfree(qname);
return;
} else if(dumpdate < amdp->dates[level]) {
qname = quote_string(name);
/* this is not allowed, but we can ignore it */
dbprintf(_("amandates botch: %s lev %d: new dumpdate %ld old %ld\n"),
qname, level, (long) dumpdate, (long) amdp->dates[level]);
amfree(qname);
return;
}
amdp->dates[level] = dumpdate;
}
/****
* Test the strquotedstr function
*/
static int
test_strquotedstr_skipping(void)
{
char **iter1, **iter2;
gboolean success = TRUE;
/* the idea here is to loop over all pairs of strings, forming a
* string by quoting them with quote_string and inserting a space, then
* re-splitting with strquotedstr. This should get us back to our
* starting point. Note that we have to begin with a non-quoted identifier,
* becuse strquotedstr requires that strtok_r has already been called. */
for (iter1 = quotable_strings; *iter1; iter1++) {
for (iter2 = quotable_strings; *iter2; iter2++) {
char *q1 = quote_string(*iter1);
char *q2 = quote_string(*iter2);
char *combined = vstralloc("START ", q1, " ", q2, NULL);
char *copy = g_strdup(combined);
char *saveptr = NULL;
char *tok;
int i;
tok = strtok_r(copy, " ", &saveptr);
for (i = 1; i <= 2; i++) {
char *expected = (i == 1)? q1:q2;
tok = strquotedstr(&saveptr);
if (!tok) {
g_fprintf(stderr, "while parsing '%s', call %d to strquotedstr returned NULL\n",
combined, i);
success = FALSE;
goto next;
}
if (0 != strcmp(tok, expected)) {
char *safe = safestr(tok);
g_fprintf(stderr, "while parsing '%s', call %d to strquotedstr returned '%s' "
"but '%s' was expected.\n",
combined, i, safe, expected);
success = FALSE;
goto next;
}
}
if (strquotedstr(&saveptr) != NULL) {
g_fprintf(stderr, "while parsing '%s', call 3 to strquotedstr did not return NULL\n",
combined);
success = FALSE;
goto next;
}
next:
amfree(q1);
amfree(q2);
amfree(copy);
amfree(combined);
}
}
return success;
}
void
amandates_updateone(
char * name,
int level,
time_t dumpdate)
{
amandates_t *amdp;
char *qname;
assert(!readonly);
amdp = lookup(name, 1);
if (level < 0 || level >= DUMP_LEVELS) {
/* this is not allowed, but we can ignore it */
qname = quote_string(name);
dbprintf(_("amandates updateone: %s lev %d: bad level, dumpdate %ld"),
name, level, (long) dumpdate);
amfree(qname);
return;
} else if (dumpdate < amdp->dates[level]) {
/* this is not allowed, but we can ignore it */
qname = quote_string(name);
dbprintf(_("amandates updateone: %s lev %d: new dumpdate %ld old %ld"),
name, level, (long) dumpdate, (long) amdp->dates[level]);
amfree(qname);
return;
}
amdp->dates[level] = dumpdate;
updated = 1;
}
/* Print a user ID, with a default string (like "everyone") for NULL. */
static void print_id(struct gale_text var,struct gale_text dfl) {
struct gale_text value = gale_var(var);
int i = 1;
if (0 == value.l) {
gale_print(stdout,0,G_(" *"));
gale_print(stdout,gale_print_bold,dfl);
gale_print(stdout,0,G_("*"));
return;
}
do {
int at;
struct gale_text local,domain;
gale_print(stdout,0,G_(" "));
for (at = 0; at < value.l && '@' != value.p[at]; ++at) ;
local = gale_text_left(value,at);
domain = gale_text_right(value,-at);
if (quote_string(&local) || quote_string(&domain)) {
gale_print(stdout,0,G_("'"));
gale_print(stdout,gale_print_bold,local);
gale_print(stdout,0,domain);
gale_print(stdout,0,G_("'"));
} else {
gale_print(stdout,gale_print_bold,local);
gale_print(stdout,0,domain);
}
value = gale_var(gale_text_concat(3,var,G_("_"),
gale_text_from_number(++i,10,0)));
} while (0 != value.l);
}
/* We call this when we can't find a tape to write data to. This could
happen with the first (or only) part of a file, but it could also
happen with an intermediate part of a split dump. dump_bytes
is 0 if this is the first part of a dump. */
static void bail_no_volume(
dump_info_t *dump_info,
char *errmsg)
{
char *errstr;
if (errmsg)
errstr = quote_string(errmsg);
else
errstr = quote_string("no new tape");
if (dump_info->total_bytes > 0) {
/* Second or later part of a split dump, so PARTIAL message. */
double dump_time = g_timeval_to_double(dump_info->total_time);
guint64 dump_kbytes = dump_info->total_bytes / 1024;
double dump_kbps = get_kbps(dump_kbytes, dump_time);
putresult(PARTIAL,
"%s INPUT-GOOD TAPE-ERROR "
"\"[sec %f kb %ju kps %f]\" \"\" %s\n",
dump_info->handle,
dump_time, (uintmax_t)dump_kbytes, dump_kbps, errstr);
put_partial_log(dump_info, dump_time, dump_kbytes, errstr);
} else {
char * qdiskname = quote_string(dump_info->diskname);
putresult(FAILED,
"%s INPUT-GOOD TAPE-ERROR \"\" %s\n",
dump_info->handle, errstr);
log_add(L_FAIL, "%s %s %s %d %s",
dump_info->hostname, qdiskname, dump_info->timestamp,
dump_info->level, errstr);
amfree(qdiskname);
}
amfree(errstr);
}
int copy_file(
char *dst,
char *src,
char **errmsg)
{
int infd, outfd;
int save_errno;
ssize_t nb;
char buf[32768];
char *quoted;
if ((infd = open(src, O_RDONLY)) == -1) {
save_errno = errno;
quoted = quote_string(src);
*errmsg = g_strdup_printf(_("Can't open file '%s' for reading: %s"),
quoted, strerror(save_errno));
amfree(quoted);
return -1;
}
if ((outfd = open(dst, O_WRONLY|O_CREAT, 0600)) == -1) {
save_errno = errno;
quoted = quote_string(dst);
*errmsg = g_strdup_printf(_("Can't open file '%s' for writting: %s"),
quoted, strerror(save_errno));
amfree(quoted);
close(infd);
return -1;
}
while ((nb=read(infd, &buf, sizeof(buf))) > 0) {
if (full_write(outfd,&buf,nb) < (size_t)nb) {
save_errno = errno;
quoted = quote_string(dst);
*errmsg = g_strdup_printf(_("Error writing to '%s': %s"),
quoted, strerror(save_errno));
amfree(quoted);
close(infd);
close(outfd);
return -1;
}
}
if (errno != 0) {
save_errno = errno;
quoted = quote_string(src);
*errmsg = g_strdup_printf(_("Error reading from '%s': %s"),
quoted, strerror(save_errno));
amfree(quoted);
close(infd);
close(outfd);
return -1;
}
close(infd);
close(outfd);
return 0;
}
static krb5_error_code
unparse_name_fixed(krb5_context context,
krb5_const_principal principal,
char *name,
size_t len,
int flags)
{
size_t idx = 0;
int i;
int short_form = (flags & KRB5_PRINCIPAL_UNPARSE_SHORT) != 0;
int no_realm = (flags & KRB5_PRINCIPAL_UNPARSE_NO_REALM) != 0;
int display = (flags & KRB5_PRINCIPAL_UNPARSE_DISPLAY) != 0;
if (!no_realm && princ_realm(principal) == NULL) {
krb5_set_error_message(context, ERANGE,
N_("Realm missing from principal, "
"can't unparse", ""));
return ERANGE;
}
for(i = 0; i < princ_num_comp(principal); i++){
if(i)
add_char(name, idx, len, '/');
idx = quote_string(princ_ncomp(principal, i), name, idx, len, display);
if(idx == len) {
krb5_set_error_message(context, ERANGE,
N_("Out of space printing principal", ""));
return ERANGE;
}
}
/* add realm if different from default realm */
if(short_form && !no_realm) {
krb5_realm r;
krb5_error_code ret;
ret = krb5_get_default_realm(context, &r);
if(ret)
return ret;
if(strcmp(princ_realm(principal), r) != 0)
short_form = 0;
free(r);
}
if(!short_form && !no_realm) {
add_char(name, idx, len, '@');
idx = quote_string(princ_realm(principal), name, idx, len, display);
if(idx == len) {
krb5_set_error_message(context, ERANGE,
N_("Out of space printing "
"realm of principal", ""));
return ERANGE;
}
}
return 0;
}
static void
amstar_selfcheck(
application_argument_t *argument)
{
fprintf(stdout, "OK amstar\n");
if (argument->dle.disk) {
char *qdisk = quote_string(argument->dle.disk);
fprintf(stdout, "OK %s\n", qdisk);
amfree(qdisk);
}
if (argument->dle.device) {
char *qdevice = quote_string(argument->dle.device);
fprintf(stdout, "OK %s\n", qdevice);
amfree(qdevice);
}
if (star_directory) {
char *qdirectory = quote_string(star_directory);
fprintf(stdout, "OK %s\n", qdirectory);
amfree(qdirectory);
}
if (argument->dle.include_list &&
argument->dle.include_list->nb_element >= 0) {
fprintf(stdout, "ERROR include-list not supported for backup\n");
}
if (!star_path) {
fprintf(stdout, "ERROR STAR-PATH not defined\n");
} else {
check_file(star_path, X_OK);
}
if (argument->calcsize) {
char *calcsize = vstralloc(amlibexecdir, "/", "calcsize", NULL);
check_file(calcsize, X_OK);
check_suid(calcsize);
amfree(calcsize);
}
{
char *amandates_file;
amandates_file = getconf_str(CNF_AMANDATES);
check_file(amandates_file, R_OK|W_OK);
}
set_root_privs(1);
if (argument->dle.device) {
check_dir(argument->dle.device, R_OK);
}
set_root_privs(0);
}
static void
check_space(
char * dir,
off_t kbytes)
{
struct fs_usage fsusage;
char *quoted = quote_string(dir);
intmax_t kb_avail;
if(get_fs_usage(dir, NULL, &fsusage) == -1) {
g_printf(_("ERROR [cannot get filesystem usage for %s: %s]\n"), quoted, strerror(errno));
amfree(quoted);
return;
}
/* do the division first to avoid potential integer overflow */
kb_avail = fsusage.fsu_bavail / 1024 * fsusage.fsu_blocksize;
if (fsusage.fsu_bavail_top_bit_set || fsusage.fsu_bavail == 0) {
g_printf(_("ERROR [dir %s needs %lldKB, has nothing available.]\n"), quoted,
(long long)kbytes);
} else if (kb_avail < kbytes) {
g_printf(_("ERROR [dir %s needs %lldKB, only has %lldKB available.]\n"), quoted,
(long long)kbytes,
(long long)kb_avail);
} else {
g_printf(_("OK %s has more than %lldKB available.\n"),
quoted, (long long)kbytes);
}
amfree(quoted);
}
static void
amgtar_selfcheck(
application_argument_t *argument)
{
amgtar_build_exinclude(&argument->dle, 1, NULL, NULL, NULL, NULL);
printf("OK amgtar\n");
if (gnutar_path) {
check_file(gnutar_path, X_OK);
} else {
printf(_("ERROR [GNUTAR program not available]\n"));
}
set_root_privs(1);
if (gnutar_listdir && strlen(gnutar_listdir) == 0)
gnutar_listdir = NULL;
if (gnutar_listdir) {
check_dir(gnutar_listdir, R_OK|W_OK);
} else {
printf(_("ERROR [No GNUTAR-LISTDIR]\n"));
}
if (argument->dle.disk) {
char *qdisk = quote_string(argument->dle.disk);
fprintf(stdout, "OK %s\n", qdisk);
amfree(qdisk);
}
if (gnutar_directory) {
check_dir(gnutar_directory, R_OK);
} else if (argument->dle.device) {
check_dir(argument->dle.device, R_OK);
}
set_root_privs(0);
}
GncSqlStatementPtr
GncSqlBackend::build_update_statement(const gchar* table_name,
QofIdTypeConst obj_name, gpointer pObject,
const EntryVec& table) const noexcept
{
GncSqlStatementPtr stmt;
std::ostringstream sql;
g_return_val_if_fail (table_name != nullptr, nullptr);
g_return_val_if_fail (obj_name != nullptr, nullptr);
g_return_val_if_fail (pObject != nullptr, nullptr);
PairVec values{get_object_values (obj_name, pObject, table)};
// Create the SQL statement
sql << "UPDATE " << table_name << " SET ";
for (auto const& col_value : values)
{
if (col_value != *values.begin())
sql << ",";
sql << col_value.first << "=" <<
quote_string(col_value.second);
}
stmt = create_statement_from_sql(sql.str());
/* We want our where condition to be just the first column and
* value, i.e. the guid of the object.
*/
values.erase(values.begin() + 1, values.end());
stmt->add_where_cond(obj_name, values);
return stmt;
}
GncSqlStatementPtr
GncSqlBackend::build_insert_statement (const char* table_name,
QofIdTypeConst obj_name,
gpointer pObject,
const EntryVec& table) const noexcept
{
GncSqlStatementPtr stmt;
PairVec col_values;
std::ostringstream sql;
g_return_val_if_fail (table_name != nullptr, nullptr);
g_return_val_if_fail (obj_name != nullptr, nullptr);
g_return_val_if_fail (pObject != nullptr, nullptr);
PairVec values{get_object_values(obj_name, pObject, table)};
sql << "INSERT INTO " << table_name <<"(";
for (auto const& col_value : values)
{
if (col_value != *values.begin())
sql << ",";
sql << col_value.first;
}
sql << ") VALUES(";
for (auto col_value : values)
{
if (col_value != *values.begin())
sql << ",";
sql << quote_string(col_value.second);
}
sql << ")";
stmt = create_statement_from_sql(sql.str());
return stmt;
}
/* In running mode (not startup mode), get a command from driver and
deal with it. */
static gboolean process_driver_command(taper_state_t * state) {
struct cmdargs *cmdargs;
char * q;
/* This will return QUIT if driver has died. */
cmdargs = getcmd();
switch (cmdargs->cmd) {
case PORT_WRITE:
/*
* PORT-WRITE
* handle
* hostname
* features
* diskname
* level
* datestamp
* splitsize
* split_diskbuffer
*/
process_port_write(state, cmdargs);
break;
case FILE_WRITE:
/*
* FILE-WRITE
* handle
* filename
* hostname
* features
* diskname
* level
* datestamp
* splitsize
*/
process_file_write(state, cmdargs);
break;
case QUIT:
free_cmdargs(cmdargs);
if (state->device && state->device->volume_label) {
log_add(L_INFO, "tape %s kb %lld fm %d [OK]\n",
state->device->volume_label,
(long long)((state->total_bytes+(off_t)1023) / (off_t)1024),
state->device->file);
}
return send_quitting(state);
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;
}
free_cmdargs(cmdargs);
return TRUE;
}
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;
}
static int
test_split_quoted_strings(void)
{
char **iter1, **iter2, **iter3;
gboolean success = TRUE;
char *middle_strings[] = {
"",
"foo",
"\"foo\"",
"sp aces",
NULL,
};
/* the idea here is to loop over all triples of strings, forming a
* string by quoting them with quote_string and inserting a space, then
* re-splitting with split_quoted_string. This should get us back to our
* starting point. */
for (iter1 = quotable_strings; *iter1; iter1++) {
for (iter2 = middle_strings; *iter2; iter2++) {
for (iter3 = quotable_strings; *iter3; iter3++) {
char *q1 = quote_string(*iter1);
char *q2 = quote_string(*iter2);
char *q3 = quote_string(*iter3);
const char *expected[4] = { *iter1, *iter2, *iter3, NULL };
char *combined = vstralloc(q1, " ", q2, " ", q3, NULL);
char **tokens;
tokens = split_quoted_strings(combined);
success = compare_strv(expected, tokens, "split_quoted_strings", combined)
&& success;
amfree(q1);
amfree(q2);
amfree(q3);
amfree(combined);
g_strfreev(tokens);
}
}
}
return success;
}
static void
quote_string_test(void)
{
char const source[] = "foobar";
char buffer[12];
char *buffer_end = buffer + sizeof buffer;
int result = quote_string(source, "<%=", "%>", buffer, buffer_end);
assert(0 == result);
ASSERT_STR_EQ("<%=foobar%>", buffer);
}
/* Put an L_PARTIAL message to the logfile. */
static void put_partial_log(dump_info_t * dump_info, double dump_time,
guint64 dump_kbytes, char *errstr) {
char * qdiskname = quote_string(dump_info->diskname);
log_add(L_PARTIAL, "%s %s %s %d %d [sec %f kb %ju kps %f] %s",
dump_info->hostname, qdiskname, dump_info->timestamp,
dump_info->current_part, dump_info->level, dump_time,
(uintmax_t)dump_kbytes, get_kbps(dump_kbytes, dump_time),
errstr);
amfree(qdiskname);
}
static void
quote_string_for_empty_quotes_test(void)
{
char const source[] = "foobar";
char buffer[7];
char *buffer_end = buffer + sizeof buffer;
int result = quote_string(source, "", "", buffer, buffer_end);
assert(0 == result);
ASSERT_STR_EQ("foobar", buffer);
}
/* Error.chpl:67 */
static void ioerror2(syserr error, chpl_string msg, chpl_string path, int64_t offset, int64_t _ln, c_string _fn) {
int32_t call_tmp;
chpl_bool call_tmp2;
int32_t strerror_err;
c_string call_tmp3;
_ref_int32_t _ref_tmp_ = NULL;
c_string call_tmp4;
int64_t call_tmp5;
c_string call_tmp6;
c_string_copy call_tmp7;
c_string call_tmp8;
c_string call_tmp9;
c_string_copy call_tmp10;
c_string call_tmp11;
c_string_copy call_tmp12;
c_string call_tmp13;
c_string_copy call_tmp14;
c_string call_tmp15;
c_string_copy call_tmp16;
c_string_copy call_tmp17;
uint32_t call_tmp18;
c_string call_tmp19;
c_string call_tmp20;
c_string_copy call_tmp21;
call_tmp = qio_err_iserr(error);
call_tmp2 = (call_tmp != INT32(0));
if (call_tmp2) {
strerror_err = INT32(0);
_ref_tmp_ = &strerror_err;
call_tmp3 = sys_strerror_syserr_str(error, _ref_tmp_);
c_string_from_string(&call_tmp4, &path, _ln, _fn);
call_tmp5 = string_length(call_tmp4);
call_tmp6 = quote_string(path, call_tmp5, _ln, _fn);
call_tmp7 = string_concat(call_tmp3, " ", _ln, _fn);
c_string_from_string(&call_tmp8, &msg, _ln, _fn);
call_tmp9 = ((c_string)(call_tmp7));
call_tmp10 = string_concat(call_tmp9, call_tmp8, _ln, _fn);
call_tmp11 = ((c_string)(call_tmp10));
call_tmp12 = string_concat(call_tmp11, " with path ", _ln, _fn);
call_tmp13 = ((c_string)(call_tmp12));
call_tmp14 = string_concat(call_tmp13, call_tmp6, _ln, _fn);
call_tmp15 = ((c_string)(call_tmp14));
call_tmp16 = string_concat(call_tmp15, " offset ", _ln, _fn);
call_tmp18 = ((uint32_t)(INT64(8)));
call_tmp17 = integral_to_c_string_copy(offset, call_tmp18, true);
call_tmp19 = ((c_string)(call_tmp16));
call_tmp20 = ((c_string)(call_tmp17));
call_tmp21 = string_concat(call_tmp19, call_tmp20, _ln, _fn);
chpl_error(call_tmp21, _ln, _fn);
}
return;
}
static int id_width(struct gale_text var,struct gale_text dfl) {
struct gale_text value = gale_var(var);
int i = 1,len = 0;
if (0 == value.l) return 3 + dfl.l;
do {
if (quote_string(&value)) len += 2;
len += 1 + value.l;
value = gale_var(gale_text_concat(3,var,G_("_"),
gale_text_from_number(++i,10,0)));
} while (0 != value.l);
return len;
}
void
cupsBackendReport(
const char *device_scheme, /* I - device-scheme string */
const char *device_uri, /* I - device-uri string */
const char *device_make_and_model, /* I - device-make-and-model string or @code NULL@ */
const char *device_info, /* I - device-info string or @code NULL@ */
const char *device_id, /* I - device-id string or @code NULL@ */
const char *device_location) /* I - device-location string or @code NULL@ */
{
if (!device_scheme || !device_uri)
return;
printf("%s %s", device_scheme, device_uri);
if (device_make_and_model && *device_make_and_model)
quote_string(device_make_and_model);
else
quote_string("unknown");
quote_string(device_info);
quote_string(device_id);
quote_string(device_location);
putchar('\n');
fflush(stdout);
}
static void
quote_string_for_buffer_too_small_test(void)
{
char const source[] = "foobar";
char buffer[8];
char *buffer_end = buffer + sizeof buffer;
errno = 0;
int result = quote_string(source, "<%=", "%>", buffer, buffer_end);
assert(EINVAL == errno);
assert(-1 == result);
ASSERT_STR_EQ("", buffer);
}
static void
amstar_selfcheck(
application_argument_t *argument)
{
fprintf(stdout, "OK amstar\n");
if (argument->dle.disk) {
char *qdisk = quote_string(argument->dle.disk);
fprintf(stdout, "OK %s\n", qdisk);
amfree(qdisk);
}
if (argument->dle.device) {
char *qdevice = quote_string(argument->dle.device);
fprintf(stdout, "OK %s\n", qdevice);
amfree(qdevice);
}
if (!star_path) {
fprintf(stdout, "ERROR STAR-PATH not defined\n");
} else {
check_file(star_path, X_OK);
}
if (argument->calcsize) {
char *calcsize = vstralloc(amlibexecdir, "/", "calcsize", NULL);
check_file(calcsize, X_OK);
check_suid(calcsize);
amfree(calcsize);
}
{
char *amandates_file;
amandates_file = getconf_str(CNF_AMANDATES);
check_file(amandates_file, R_OK|W_OK);
}
}
void
set_storage(void)
{
char *qstorage = quote_string(storage_in);
char *cmd = g_strconcat("STORAGE ", qstorage, NULL);
storage_in = NULL;
g_free(qstorage);
if (exchange(cmd) == -1)
exit(1);
g_free(cmd);
if (!server_happy()) {
}
suck_dir_list_from_server(); /* get list of directory contents */
}
/*
* get pattern which match to #include lines.
*
* i) arg include file name
* r) pattern which match to #include lines
*/
static char *
include_pattern(const char *arg)
{
#if defined(_WIN32)
#define INCLUDE "^[ \t]*#[ \t]*include[ \t].*[\\\"\"</\\]%s[\\\"\">]"
#elif defined(__DJGPP__)
#define INCLUDE "^[ \t]*#[ \t]*include[ \t].*[\"</\\]%s[\">]"
#else
#define INCLUDE "^[ \t]*#[ \t]*include[ \t].*[\"</]%s[\">]"
#endif
STATIC_STRBUF(pat);
strbuf_clear(pat);
strbuf_sprintf(pat, INCLUDE, quote_string(arg));
return strbuf_value(pat);
}
/* sets a date, mapping given date into standard form if needed */
int
set_date(
char * date)
{
char *cmd = NULL;
char *qdisk_path;
clear_dir_list();
cmd = g_strconcat("DATE ", date, NULL);
if (converse(cmd) == -1)
exit(1);
/* if a host/disk/directory is set, then check if that directory
is still valid at the new date, and if not set directory to
mount_point */
if (disk_path != NULL) {
qdisk_path = quote_string(disk_path);
g_free(cmd);
cmd = g_strconcat("OISD ", qdisk_path, NULL);
amfree(qdisk_path);
if (exchange(cmd) == -1)
exit(1);
if (server_happy())
{
suck_dir_list_from_server();
}
else
{
g_printf(_("No index records for cwd on new date\n"));
g_printf(_("Setting cwd to mount point\n"));
g_free(disk_path);
g_free(disk_tpath);
disk_path = g_strdup("/"); /* fake it */
disk_tpath = g_strdup("/"); /* fake it */
clear_dir_list();
}
}
amfree(cmd);
return 0;
}
/**
* Write the header information.
* @param arg ignored optional user param
* @param style the name of the format style (for transformation)
* @param dst the destination markup file handle
* @return 1 if successful, 0 otherwise
*/
int STIL_write_header( void *arg, dest_file *dst, UChar *style )
{
int res = 1;
U_COMMA = utf8toutf16(",");
U_COMMANL = utf8toutf16(",\n");
U_LF = utf8toutf16("\n");
U_HEAD = utf8toutf16( "{\n");
U_TAIL = utf8toutf16( "\n ]\n}\n");
U_STYLE = utf8toutf16(" \"style\": ");
U_RANGES_START = utf8toutf16(" \"ranges\": [\n");
U_RANGE_START = utf8toutf16(" {\n");
U_RANGE_END = utf8toutf16(" }");
U_NAME = utf8toutf16(" \"name\": ");
U_RELOFF = utf8toutf16(" \"reloff\": ");
U_LEN = utf8toutf16(" \"len\": ");
U_REMOVED = utf8toutf16(" \"removed\": ");
U_CONTENT = utf8toutf16(" \"content\": ");
U_ANNOTATIONS = utf8toutf16(" \"annotations\": [ ");
U_ANNOTATIONS_END = utf8toutf16(" ]\n");
U_ANNOTATION = utf8toutf16("{ ");
U_ANNOTATION_END = utf8toutf16(" }");
U_TRUE = utf8toutf16("true");
U_COLON = utf8toutf16(": ");
// write header
UChar **items = calloc(5,sizeof(UChar*));
if ( items != NULL )
{
items[0] = U_HEAD;
items[1] = U_STYLE;
items[2] = quote_string(style,u_strlen(style));
items[3] = U_COMMANL;
items[4] = U_RANGES_START;
res = write_utf16_array( items, 5, dst );
if ( items[2] != NULL )
free( items[2] );
free( items );
}
else
res = 0;
return res;
}
static int
append_string(char **str, size_t *total_len, const char *ss,
size_t len, int quote)
{
char *s, *qs;
if (quote)
qs = quote_string(ss, len, &len);
else
qs = rk_UNCONST(ss);
s = realloc(*str, len + *total_len + 1);
if (s == NULL)
_hx509_abort("allocation failure"); /* XXX */
memcpy(s + *total_len, qs, len);
if (qs != ss)
free(qs);
s[*total_len + len] = '\0';
*str = s;
*total_len += len;
return 0;
}
/* Error.chpl:55 */
static void ioerror(syserr error, chpl_string msg, chpl_string path, int64_t _ln, c_string _fn) {
int32_t call_tmp;
chpl_bool call_tmp2;
int32_t strerror_err;
c_string call_tmp3;
_ref_int32_t _ref_tmp_ = NULL;
c_string call_tmp4;
int64_t call_tmp5;
c_string call_tmp6;
c_string_copy call_tmp7;
c_string call_tmp8;
c_string call_tmp9;
c_string_copy call_tmp10;
c_string call_tmp11;
c_string_copy call_tmp12;
c_string call_tmp13;
c_string_copy call_tmp14;
call_tmp = qio_err_iserr(error);
call_tmp2 = (call_tmp != INT32(0));
if (call_tmp2) {
strerror_err = INT32(0);
_ref_tmp_ = &strerror_err;
call_tmp3 = sys_strerror_syserr_str(error, _ref_tmp_);
c_string_from_string(&call_tmp4, &path, _ln, _fn);
call_tmp5 = string_length(call_tmp4);
call_tmp6 = quote_string(path, call_tmp5, _ln, _fn);
call_tmp7 = string_concat(call_tmp3, " ", _ln, _fn);
c_string_from_string(&call_tmp8, &msg, _ln, _fn);
call_tmp9 = ((c_string)(call_tmp7));
call_tmp10 = string_concat(call_tmp9, call_tmp8, _ln, _fn);
call_tmp11 = ((c_string)(call_tmp10));
call_tmp12 = string_concat(call_tmp11, " with path ", _ln, _fn);
call_tmp13 = ((c_string)(call_tmp12));
call_tmp14 = string_concat(call_tmp13, call_tmp6, _ln, _fn);
chpl_error(call_tmp14, _ln, _fn);
}
return;
}
void
finish_amandates(void)
{
amandates_t *amdp;
int level;
char *qname;
if(amdf == NULL)
return;
if(updated) {
if(readonly) {
error(_("updated amandates after opening readonly"));
/*NOTREACHED*/
}
rewind(amdf);
for(amdp = amandates_list; amdp != NULL; amdp = amdp->next) {
for(level = 0; level < DUMP_LEVELS; level++) {
if(amdp->dates[level] == EPOCH) continue;
qname = quote_string(amdp->name);
g_fprintf(amdf, "%s %d %ld\n",
qname, level, (long) amdp->dates[level]);
amfree(qname);
}
}
}
if(amfunlock(fileno(amdf), g_amandates_file) == -1) {
error(_("could not unlock %s: %s"), g_amandates_file, strerror(errno));
/*NOTREACHED*/
}
if (fclose(amdf) == EOF) {
error(_("error [closing %s: %s]"), g_amandates_file, strerror(errno));
/*NOTREACHED*/
}
amdf = NULL;
}
