svn_stringbuf_t *
svn_fs_fs__unparse_representation(representation_t *rep,
int format,
svn_boolean_t mutable_rep_truncated,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
char buffer[SVN_INT64_BUFFER_SIZE];
if (svn_fs_fs__id_txn_used(&rep->txn_id) && mutable_rep_truncated)
return svn_stringbuf_ncreate("-1", 2, result_pool);
if (format < SVN_FS_FS__MIN_REP_SHARING_FORMAT || !rep->has_sha1)
return svn_stringbuf_createf
(result_pool, "%ld %" APR_UINT64_T_FMT " %" SVN_FILESIZE_T_FMT
" %" SVN_FILESIZE_T_FMT " %s",
rep->revision, rep->item_index, rep->size,
rep->expanded_size,
format_digest(rep->md5_digest, svn_checksum_md5, FALSE,
scratch_pool));
svn__ui64tobase36(buffer, rep->uniquifier.number);
return svn_stringbuf_createf
(result_pool, "%ld %" APR_UINT64_T_FMT " %" SVN_FILESIZE_T_FMT
" %" SVN_FILESIZE_T_FMT " %s %s %s/_%s",
rep->revision, rep->item_index, rep->size,
rep->expanded_size,
format_digest(rep->md5_digest, svn_checksum_md5,
FALSE, scratch_pool),
format_digest(rep->sha1_digest, svn_checksum_sha1,
!rep->has_sha1, scratch_pool),
svn_fs_fs__id_txn_unparse(&rep->uniquifier.noderev_txn_id,
scratch_pool),
buffer);
}
svn_stringbuf_t *
svn_fs_x__unparse_representation(svn_fs_x__representation_t *rep,
svn_boolean_t mutable_rep_truncated,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
if (!rep->has_sha1)
return svn_stringbuf_createf
(result_pool,
"%" APR_INT64_T_FMT " %" APR_UINT64_T_FMT " %" SVN_FILESIZE_T_FMT
" %" SVN_FILESIZE_T_FMT " %s",
rep->id.change_set, rep->id.number, rep->size,
rep->expanded_size,
format_digest(rep->md5_digest, svn_checksum_md5, FALSE,
scratch_pool));
return svn_stringbuf_createf
(result_pool,
"%" APR_INT64_T_FMT " %" APR_UINT64_T_FMT " %" SVN_FILESIZE_T_FMT
" %" SVN_FILESIZE_T_FMT " %s %s",
rep->id.change_set, rep->id.number, rep->size,
rep->expanded_size,
format_digest(rep->md5_digest, svn_checksum_md5,
FALSE, scratch_pool),
format_digest(rep->sha1_digest, svn_checksum_sha1,
!rep->has_sha1, scratch_pool));
}
/* Set *HANDLE to an open filehandle for a temporary file (i.e.,
automatically deleted when closed), into which the LOCK_TOKENS have
been written out in the format described in the pre-commit hook
template.
LOCK_TOKENS is as returned by svn_fs__access_get_lock_tokens().
Allocate *HANDLE in POOL, and use POOL for temporary allocations. */
static svn_error_t *
lock_token_content(apr_file_t **handle, apr_hash_t *lock_tokens,
apr_pool_t *pool)
{
svn_stringbuf_t *lock_str = svn_stringbuf_create("LOCK-TOKENS:\n", pool);
apr_hash_index_t *hi;
for (hi = apr_hash_first(pool, lock_tokens); hi;
hi = apr_hash_next(hi))
{
void *val;
const char *path, *token;
apr_hash_this(hi, (void *)&token, NULL, &val);
path = val;
svn_stringbuf_appendstr(lock_str,
svn_stringbuf_createf(pool, "%s|%s\n",
svn_path_uri_autoescape(path, pool),
token));
}
svn_stringbuf_appendcstr(lock_str, "\n");
return create_temp_file(handle,
svn_stringbuf__morph_into_string(lock_str), pool);
}
/* Write a single change entry, path PATH, change CHANGE, to STREAM.
All temporary allocations are in SCRATCH_POOL. */
static svn_error_t *
write_change_entry(svn_stream_t *stream,
svn_fs_x__change_t *change,
apr_pool_t *scratch_pool)
{
const char *change_string = NULL;
const char *kind_string = "";
svn_stringbuf_t *buf;
apr_size_t len;
switch (change->change_kind)
{
case svn_fs_path_change_modify:
change_string = ACTION_MODIFY;
break;
case svn_fs_path_change_add:
change_string = ACTION_ADD;
break;
case svn_fs_path_change_delete:
change_string = ACTION_DELETE;
break;
case svn_fs_path_change_replace:
change_string = ACTION_REPLACE;
break;
default:
return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
_("Invalid change type %d"),
change->change_kind);
}
SVN_ERR_ASSERT(change->node_kind == svn_node_dir
|| change->node_kind == svn_node_file);
kind_string = apr_psprintf(scratch_pool, "-%s",
change->node_kind == svn_node_dir
? SVN_FS_X__KIND_DIR
: SVN_FS_X__KIND_FILE);
buf = svn_stringbuf_createf(scratch_pool, "%s%s %s %s %s %s\n",
change_string, kind_string,
change->text_mod ? FLAG_TRUE : FLAG_FALSE,
change->prop_mod ? FLAG_TRUE : FLAG_FALSE,
change->mergeinfo_mod == svn_tristate_true
? FLAG_TRUE : FLAG_FALSE,
auto_escape_path(change->path.data, scratch_pool));
if (SVN_IS_VALID_REVNUM(change->copyfrom_rev))
{
svn_stringbuf_appendcstr(buf, apr_psprintf(scratch_pool, "%ld %s",
change->copyfrom_rev,
auto_escape_path(change->copyfrom_path,
scratch_pool)));
}
svn_stringbuf_appendbyte(buf, '\n');
/* Write all change info in one write call. */
len = buf->len;
return svn_error_trace(svn_stream_write(stream, buf->data, &len));
}
svn_stringbuf_t *
svn_fs_fs__unparse_revision_trailer(apr_off_t root_offset,
apr_off_t changes_offset,
apr_pool_t *result_pool)
{
return svn_stringbuf_createf(result_pool,
"%" APR_OFF_T_FMT " %" APR_OFF_T_FMT "\n",
root_offset,
changes_offset);
}
svn_stringbuf_t *
svn_fs_fs__unparse_footer(apr_off_t l2p_offset,
svn_checksum_t *l2p_checksum,
apr_off_t p2l_offset,
svn_checksum_t *p2l_checksum,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
return svn_stringbuf_createf(result_pool,
"%" APR_OFF_T_FMT " %s %" APR_OFF_T_FMT " %s",
l2p_offset,
svn_checksum_to_cstring(l2p_checksum,
scratch_pool),
p2l_offset,
svn_checksum_to_cstring(p2l_checksum,
scratch_pool));
}
static svn_error_t *
test11(const char **msg,
svn_boolean_t msg_only,
svn_test_opts_t *opts,
apr_pool_t *pool)
{
svn_stringbuf_t *s;
*msg = "formatting strings from varargs";
if (msg_only)
return SVN_NO_ERROR;
s = svn_stringbuf_createf(pool,
"This %s is used in test %d.",
"string",
12);
if (strcmp(s->data, "This string is used in test 12.") == 0)
return SVN_NO_ERROR;
else
return fail(pool, "test failed");
}
/* Write a single change entry, path PATH, change CHANGE, to STREAM.
Only include the node kind field if INCLUDE_NODE_KIND is true. Only
include the mergeinfo-mod field if INCLUDE_MERGEINFO_MODS is true.
All temporary allocations are in SCRATCH_POOL. */
static svn_error_t *
write_change_entry(svn_stream_t *stream,
const char *path,
svn_fs_path_change2_t *change,
svn_boolean_t include_node_kind,
svn_boolean_t include_mergeinfo_mods,
apr_pool_t *scratch_pool)
{
const char *idstr;
const char *change_string = NULL;
const char *kind_string = "";
const char *mergeinfo_string = "";
svn_stringbuf_t *buf;
apr_size_t len;
switch (change->change_kind)
{
case svn_fs_path_change_modify:
change_string = ACTION_MODIFY;
break;
case svn_fs_path_change_add:
change_string = ACTION_ADD;
break;
case svn_fs_path_change_delete:
change_string = ACTION_DELETE;
break;
case svn_fs_path_change_replace:
change_string = ACTION_REPLACE;
break;
case svn_fs_path_change_reset:
change_string = ACTION_RESET;
break;
default:
return svn_error_createf(SVN_ERR_FS_CORRUPT, NULL,
_("Invalid change type %d"),
change->change_kind);
}
if (change->node_rev_id)
idstr = svn_fs_fs__id_unparse(change->node_rev_id, scratch_pool)->data;
else
idstr = ACTION_RESET;
if (include_node_kind)
{
SVN_ERR_ASSERT(change->node_kind == svn_node_dir
|| change->node_kind == svn_node_file);
kind_string = apr_psprintf(scratch_pool, "-%s",
change->node_kind == svn_node_dir
? SVN_FS_FS__KIND_DIR
: SVN_FS_FS__KIND_FILE);
}
if (include_mergeinfo_mods && change->mergeinfo_mod != svn_tristate_unknown)
mergeinfo_string = apr_psprintf(scratch_pool, " %s",
change->mergeinfo_mod == svn_tristate_true
? FLAG_TRUE
: FLAG_FALSE);
buf = svn_stringbuf_createf(scratch_pool, "%s %s%s %s %s%s %s\n",
idstr, change_string, kind_string,
change->text_mod ? FLAG_TRUE : FLAG_FALSE,
change->prop_mod ? FLAG_TRUE : FLAG_FALSE,
mergeinfo_string,
path);
if (SVN_IS_VALID_REVNUM(change->copyfrom_rev))
{
svn_stringbuf_appendcstr(buf, apr_psprintf(scratch_pool, "%ld %s",
change->copyfrom_rev,
change->copyfrom_path));
}
svn_stringbuf_appendbyte(buf, '\n');
/* Write all change info in one write call. */
len = buf->len;
return svn_error_trace(svn_stream_write(stream, buf->data, &len));
}
/* Helper function for run_hook_cmd(). Wait for a hook to finish
executing and return either SVN_NO_ERROR if the hook script completed
without error, or an error describing the reason for failure.
NAME and CMD are the name and path of the hook program, CMD_PROC
is a pointer to the structure representing the running process,
and READ_ERRHANDLE is an open handle to the hook's stderr.
Hooks are considered to have failed if we are unable to wait for the
process, if we are unable to read from the hook's stderr, if the
process has failed to exit cleanly (due to a coredump, for example),
or if the process returned a non-zero return code.
Any error output returned by the hook's stderr will be included in an
error message, though the presence of output on stderr is not itself
a reason to fail a hook. */
static svn_error_t *
check_hook_result(const char *name, const char *cmd, apr_proc_t *cmd_proc,
apr_file_t *read_errhandle, apr_pool_t *pool)
{
svn_error_t *err, *err2;
svn_stringbuf_t *native_stderr, *failure_message;
const char *utf8_stderr;
int exitcode;
apr_exit_why_e exitwhy;
err2 = svn_stringbuf_from_aprfile(&native_stderr, read_errhandle, pool);
err = svn_io_wait_for_cmd(cmd_proc, cmd, &exitcode, &exitwhy, pool);
if (err)
{
svn_error_clear(err2);
return svn_error_trace(err);
}
if (APR_PROC_CHECK_EXIT(exitwhy) && exitcode == 0)
{
/* The hook exited cleanly. However, if we got an error reading
the hook's stderr, fail the hook anyway, because this might be
symptomatic of a more important problem. */
if (err2)
{
return svn_error_createf
(SVN_ERR_REPOS_HOOK_FAILURE, err2,
_("'%s' hook succeeded, but error output could not be read"),
name);
}
return SVN_NO_ERROR;
}
/* The hook script failed. */
/* If we got the stderr output okay, try to translate it into UTF-8.
Ensure there is something sensible in the UTF-8 string regardless. */
if (!err2)
{
err2 = svn_utf_cstring_to_utf8(&utf8_stderr, native_stderr->data, pool);
if (err2)
utf8_stderr = _("[Error output could not be translated from the "
"native locale to UTF-8.]");
}
else
{
utf8_stderr = _("[Error output could not be read.]");
}
/*### It would be nice to include the text of any translation or read
error in the messages above before we clear it here. */
svn_error_clear(err2);
if (!APR_PROC_CHECK_EXIT(exitwhy))
{
failure_message = svn_stringbuf_createf(pool,
_("'%s' hook failed (did not exit cleanly: "
"apr_exit_why_e was %d, exitcode was %d). "),
name, exitwhy, exitcode);
}
else
{
const char *action;
if (strcmp(name, "start-commit") == 0
|| strcmp(name, "pre-commit") == 0)
action = _("Commit");
else if (strcmp(name, "pre-revprop-change") == 0)
action = _("Revprop change");
else if (strcmp(name, "pre-lock") == 0)
action = _("Lock");
else if (strcmp(name, "pre-unlock") == 0)
action = _("Unlock");
else
action = NULL;
if (action == NULL)
failure_message = svn_stringbuf_createf(
pool, _("%s hook failed (exit code %d)"),
name, exitcode);
else
failure_message = svn_stringbuf_createf(
pool, _("%s blocked by %s hook (exit code %d)"),
action, name, exitcode);
}
if (utf8_stderr[0])
{
svn_stringbuf_appendcstr(failure_message,
_(" with output:\n"));
svn_stringbuf_appendcstr(failure_message, utf8_stderr);
}
else
{
svn_stringbuf_appendcstr(failure_message,
_(" with no output."));
}
return svn_error_create(SVN_ERR_REPOS_HOOK_FAILURE, err,
failure_message->data);
}
svn_string_t *
svn_cache__format_info(const svn_cache__info_t *info,
svn_boolean_t access_only,
apr_pool_t *result_pool)
{
enum { _1MB = 1024 * 1024 };
apr_uint64_t misses = info->gets - info->hits;
double hit_rate = (100.0 * (double)info->hits)
/ (double)(info->gets ? info->gets : 1);
double write_rate = (100.0 * (double)info->sets)
/ (double)(misses ? misses : 1);
double data_usage_rate = (100.0 * (double)info->used_size)
/ (double)(info->data_size ? info->data_size : 1);
double data_entry_rate = (100.0 * (double)info->used_entries)
/ (double)(info->total_entries ? info->total_entries : 1);
const char *histogram = "";
if (!access_only)
{
svn_stringbuf_t *text = svn_stringbuf_create_empty(result_pool);
int i;
int count = sizeof(info->histogram) / sizeof(info->histogram[0]);
for (i = count - 1; i >= 0; --i)
if (info->histogram[i] > 0 || text->len > 0)
text = svn_stringbuf_createf(result_pool,
i == count - 1
? "%s%12" APR_UINT64_T_FMT
" buckets with >%d entries\n"
: "%s%12" APR_UINT64_T_FMT
" buckets with %d entries\n",
text->data, info->histogram[i], i);
histogram = text->data;
}
return access_only
? svn_string_createf(result_pool,
"%s\n"
"gets : %" APR_UINT64_T_FMT
", %" APR_UINT64_T_FMT " hits (%5.2f%%)\n"
"sets : %" APR_UINT64_T_FMT
" (%5.2f%% of misses)\n",
info->id,
info->gets,
info->hits, hit_rate,
info->sets, write_rate)
: svn_string_createf(result_pool,
"%s\n"
"gets : %" APR_UINT64_T_FMT
", %" APR_UINT64_T_FMT " hits (%5.2f%%)\n"
"sets : %" APR_UINT64_T_FMT
" (%5.2f%% of misses)\n"
"failures: %" APR_UINT64_T_FMT "\n"
"used : %" APR_UINT64_T_FMT " MB (%5.2f%%)"
" of %" APR_UINT64_T_FMT " MB data cache"
" / %" APR_UINT64_T_FMT " MB total cache memory\n"
" %" APR_UINT64_T_FMT " entries (%5.2f%%)"
" of %" APR_UINT64_T_FMT " total\n%s",
info->id,
info->gets,
info->hits, hit_rate,
info->sets, write_rate,
info->failures,
info->used_size / _1MB, data_usage_rate,
info->data_size / _1MB,
info->total_size / _1MB,
info->used_entries, data_entry_rate,
info->total_entries,
histogram);
}
svn_error_t *
svn_diff_hunk_readline_diff_text(svn_diff_hunk_t *hunk,
svn_stringbuf_t **stringbuf,
const char **eol,
svn_boolean_t *eof,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_diff_hunk_t dummy;
svn_stringbuf_t *line;
apr_size_t max_len;
apr_off_t pos;
if (hunk->diff_text_range.current >= hunk->diff_text_range.end)
{
/* We're past the range. Indicate that no bytes can be read. */
*eof = TRUE;
if (eol)
*eol = NULL;
*stringbuf = svn_stringbuf_create("", result_pool);
return SVN_NO_ERROR;
}
pos = 0;
SVN_ERR(svn_io_file_seek(hunk->apr_file, APR_CUR, &pos, scratch_pool));
SVN_ERR(svn_io_file_seek(hunk->apr_file, APR_SET,
&hunk->diff_text_range.current, scratch_pool));
max_len = hunk->diff_text_range.end - hunk->diff_text_range.current;
SVN_ERR(readline(hunk->apr_file, &line, eol, eof, max_len, result_pool,
scratch_pool));
hunk->diff_text_range.current = 0;
SVN_ERR(svn_io_file_seek(hunk->apr_file, APR_CUR,
&hunk->diff_text_range.current, scratch_pool));
SVN_ERR(svn_io_file_seek(hunk->apr_file, APR_SET, &pos, scratch_pool));
if (hunk->patch->reverse)
{
if (parse_hunk_header(line->data, &dummy, "@@", scratch_pool))
{
/* Line is a hunk header, reverse it. */
line = svn_stringbuf_createf(result_pool,
"@@ -%lu,%lu +%lu,%lu @@",
hunk->modified_start,
hunk->modified_length,
hunk->original_start,
hunk->original_length);
}
else if (parse_hunk_header(line->data, &dummy, "##", scratch_pool))
{
/* Line is a hunk header, reverse it. */
line = svn_stringbuf_createf(result_pool,
"## -%lu,%lu +%lu,%lu ##",
hunk->modified_start,
hunk->modified_length,
hunk->original_start,
hunk->original_length);
}
else
{
if (line->data[0] == '+')
line->data[0] = '-';
else if (line->data[0] == '-')
line->data[0] = '+';
}
}
*stringbuf = line;
return SVN_NO_ERROR;
}