/* 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);
}
/* NAME, CMD and ARGS are the name, path to and arguments for the hook
program that is to be run. The hook's exit status will be checked,
and if an error occurred the hook's stderr output will be added to
the returned error.
If STDIN_HANDLE is non-null, pass it as the hook's stdin, else pass
no stdin to the hook.
If RESULT is non-null, set *RESULT to the stdout of the hook or to
a zero-length string if the hook generates no output on stdout. */
static svn_error_t *
run_hook_cmd(svn_string_t **result,
const char *name,
const char *cmd,
const char **args,
const char *const *hooks_env,
apr_file_t *stdin_handle,
apr_pool_t *pool)
{
apr_file_t *null_handle;
apr_status_t apr_err;
svn_error_t *err;
apr_proc_t cmd_proc;
if (result)
{
null_handle = NULL;
}
else
{
/* Redirect stdout to the null device */
apr_err = apr_file_open(&null_handle, SVN_NULL_DEVICE_NAME, APR_WRITE,
APR_OS_DEFAULT, pool);
if (apr_err)
return svn_error_wrap_apr
(apr_err, _("Can't create null stdout for hook '%s'"), cmd);
}
err = svn_io_start_cmd3(&cmd_proc, ".", cmd, args, hooks_env, FALSE,
FALSE, stdin_handle, result != NULL, null_handle,
TRUE, NULL, pool);
if (err)
{
/* CMD_PROC is not safe to use. Bail. */
return svn_error_createf
(SVN_ERR_REPOS_HOOK_FAILURE, err, _("Failed to start '%s' hook"), cmd);
}
else
{
err = check_hook_result(name, cmd, &cmd_proc, cmd_proc.err, pool);
}
/* Hooks are fallible, and so hook failure is "expected" to occur at
times. When such a failure happens we still want to close the pipe
and null file */
apr_err = apr_file_close(cmd_proc.err);
if (!err && apr_err)
return svn_error_wrap_apr
(apr_err, _("Error closing read end of stderr pipe"));
if (result)
{
svn_stringbuf_t *native_stdout;
SVN_ERR(svn_stringbuf_from_aprfile(&native_stdout, cmd_proc.out, pool));
apr_err = apr_file_close(cmd_proc.out);
if (!err && apr_err)
return svn_error_wrap_apr
(apr_err, _("Error closing read end of stderr pipe"));
*result = svn_stringbuf__morph_into_string(native_stdout);
}
else
{
apr_err = apr_file_close(null_handle);
if (!err && apr_err)
return svn_error_wrap_apr(apr_err, _("Error closing null file"));
}
return svn_error_trace(err);
}
svn_error_t *
svn_cl__edit_string_externally(svn_string_t **edited_contents /* UTF-8! */,
const char **tmpfile_left /* UTF-8! */,
const char *editor_cmd,
const char *base_dir /* UTF-8! */,
const svn_string_t *contents /* UTF-8! */,
const char *filename,
apr_hash_t *config,
svn_boolean_t as_text,
const char *encoding,
apr_pool_t *pool)
{
const char *editor;
const char *cmd;
apr_file_t *tmp_file;
const char *tmpfile_name;
const char *tmpfile_native;
const char *tmpfile_apr, *base_dir_apr;
svn_string_t *translated_contents;
apr_status_t apr_err, apr_err2;
apr_size_t written;
apr_finfo_t finfo_before, finfo_after;
svn_error_t *err = SVN_NO_ERROR, *err2;
char *old_cwd;
int sys_err;
svn_boolean_t remove_file = TRUE;
SVN_ERR(find_editor_binary(&editor, editor_cmd, config));
/* Convert file contents from UTF-8/LF if desired. */
if (as_text)
{
const char *translated;
SVN_ERR(svn_subst_translate_cstring2(contents->data, &translated,
APR_EOL_STR, FALSE,
NULL, FALSE, pool));
translated_contents = svn_string_create("", pool);
if (encoding)
SVN_ERR(svn_utf_cstring_from_utf8_ex2(&translated_contents->data,
translated, encoding, pool));
else
SVN_ERR(svn_utf_cstring_from_utf8(&translated_contents->data,
translated, pool));
translated_contents->len = strlen(translated_contents->data);
}
else
translated_contents = svn_string_dup(contents, pool);
/* Move to BASE_DIR to avoid getting characters that need quoting
into tmpfile_name */
apr_err = apr_filepath_get(&old_cwd, APR_FILEPATH_NATIVE, pool);
if (apr_err)
return svn_error_wrap_apr(apr_err, _("Can't get working directory"));
/* APR doesn't like "" directories */
if (base_dir[0] == '\0')
base_dir_apr = ".";
else
SVN_ERR(svn_path_cstring_from_utf8(&base_dir_apr, base_dir, pool));
apr_err = apr_filepath_set(base_dir_apr, pool);
if (apr_err)
{
return svn_error_wrap_apr
(apr_err, _("Can't change working directory to '%s'"), base_dir);
}
/*** From here on, any problems that occur require us to cd back!! ***/
/* Ask the working copy for a temporary file named FILENAME-something. */
err = svn_io_open_uniquely_named(&tmp_file, &tmpfile_name,
"" /* dirpath */,
filename,
".tmp",
svn_io_file_del_none, pool, pool);
if (err && (APR_STATUS_IS_EACCES(err->apr_err) || err->apr_err == EROFS))
{
const char *temp_dir_apr;
svn_error_clear(err);
SVN_ERR(svn_io_temp_dir(&base_dir, pool));
SVN_ERR(svn_path_cstring_from_utf8(&temp_dir_apr, base_dir, pool));
apr_err = apr_filepath_set(temp_dir_apr, pool);
if (apr_err)
{
return svn_error_wrap_apr
(apr_err, _("Can't change working directory to '%s'"), base_dir);
}
err = svn_io_open_uniquely_named(&tmp_file, &tmpfile_name,
"" /* dirpath */,
filename,
".tmp",
svn_io_file_del_none, pool, pool);
}
if (err)
goto cleanup2;
/*** From here on, any problems that occur require us to cleanup
the file we just created!! ***/
/* Dump initial CONTENTS to TMP_FILE. */
apr_err = apr_file_write_full(tmp_file, translated_contents->data,
translated_contents->len, &written);
apr_err2 = apr_file_close(tmp_file);
if (! apr_err)
apr_err = apr_err2;
/* Make sure the whole CONTENTS were written, else return an error. */
if (apr_err)
{
err = svn_error_wrap_apr(apr_err, _("Can't write to '%s'"),
tmpfile_name);
goto cleanup;
}
err = svn_path_cstring_from_utf8(&tmpfile_apr, tmpfile_name, pool);
if (err)
goto cleanup;
/* Get information about the temporary file before the user has
been allowed to edit its contents. */
apr_err = apr_stat(&finfo_before, tmpfile_apr,
APR_FINFO_MTIME, pool);
if (apr_err)
{
err = svn_error_wrap_apr(apr_err, _("Can't stat '%s'"), tmpfile_name);
goto cleanup;
}
/* Backdate the file a little bit in case the editor is very fast
and doesn't change the size. (Use two seconds, since some
filesystems have coarse granularity.) It's OK if this call
fails, so we don't check its return value.*/
apr_file_mtime_set(tmpfile_apr, finfo_before.mtime - 2000, pool);
/* Stat it again to get the mtime we actually set. */
apr_err = apr_stat(&finfo_before, tmpfile_apr,
APR_FINFO_MTIME | APR_FINFO_SIZE, pool);
if (apr_err)
{
err = svn_error_wrap_apr(apr_err, _("Can't stat '%s'"), tmpfile_name);
goto cleanup;
}
/* Prepare the editor command line. */
err = svn_utf_cstring_from_utf8(&tmpfile_native, tmpfile_name, pool);
if (err)
goto cleanup;
cmd = apr_psprintf(pool, "%s %s", editor, tmpfile_native);
/* If the caller wants us to leave the file around, return the path
of the file we'll use, and make a note not to destroy it. */
if (tmpfile_left)
{
*tmpfile_left = svn_dirent_join(base_dir, tmpfile_name, pool);
remove_file = FALSE;
}
/* Now, run the editor command line. */
sys_err = system(cmd);
if (sys_err != 0)
{
/* Extracting any meaning from sys_err is platform specific, so just
use the raw value. */
err = svn_error_createf(SVN_ERR_EXTERNAL_PROGRAM, NULL,
_("system('%s') returned %d"), cmd, sys_err);
goto cleanup;
}
/* Get information about the temporary file after the assumed editing. */
apr_err = apr_stat(&finfo_after, tmpfile_apr,
APR_FINFO_MTIME | APR_FINFO_SIZE, pool);
if (apr_err)
{
err = svn_error_wrap_apr(apr_err, _("Can't stat '%s'"), tmpfile_name);
goto cleanup;
}
/* If the file looks changed... */
if ((finfo_before.mtime != finfo_after.mtime) ||
(finfo_before.size != finfo_after.size))
{
svn_stringbuf_t *edited_contents_s;
err = svn_stringbuf_from_file2(&edited_contents_s, tmpfile_name, pool);
if (err)
goto cleanup;
*edited_contents = svn_stringbuf__morph_into_string(edited_contents_s);
/* Translate back to UTF8/LF if desired. */
if (as_text)
{
err = svn_subst_translate_string2(edited_contents, FALSE, FALSE,
*edited_contents, encoding, FALSE,
pool, pool);
if (err)
{
err = svn_error_quick_wrap
(err,
_("Error normalizing edited contents to internal format"));
goto cleanup;
}
}
}
else
{
/* No edits seem to have been made */
*edited_contents = NULL;
}
cleanup:
if (remove_file)
{
/* Remove the file from disk. */
err2 = svn_io_remove_file2(tmpfile_name, FALSE, pool);
/* Only report remove error if there was no previous error. */
if (! err && err2)
err = err2;
else
svn_error_clear(err2);
}
cleanup2:
/* If we against all probability can't cd back, all further relative
file references would be screwed up, so we have to abort. */
apr_err = apr_filepath_set(old_cwd, pool);
if (apr_err)
{
svn_handle_error2(svn_error_wrap_apr
(apr_err, _("Can't restore working directory")),
stderr, TRUE /* fatal */, "svn: ");
}
return svn_error_trace(err);
}
/* Remove r0 references from the mergeinfo string *STR.
*
* r0 was never a valid mergeinfo reference and cannot be committed with
* recent servers, but can be committed through a server older than 1.6.18
* for HTTP or older than 1.6.17 for the other protocols. See issue #4476
* "Mergeinfo containing r0 makes svnsync and dump and load fail".
*
* Set *WAS_CHANGED to TRUE if *STR was changed, otherwise to FALSE.
*/
static svn_error_t *
remove_r0_mergeinfo(const svn_string_t **str,
svn_boolean_t *was_changed,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_stringbuf_t *new_str = svn_stringbuf_create_empty(result_pool);
apr_array_header_t *lines;
int i;
SVN_ERR_ASSERT(*str && (*str)->data);
*was_changed = FALSE;
/* for each line */
lines = svn_cstring_split((*str)->data, "\n", FALSE, scratch_pool);
for (i = 0; i < lines->nelts; i++)
{
char *line = APR_ARRAY_IDX(lines, i, char *);
char *colon;
char *rangelist;
/* split at the last colon */
colon = strrchr(line, ':');
if (! colon)
return svn_error_createf(SVN_ERR_MERGEINFO_PARSE_ERROR, NULL,
_("Missing colon in svn:mergeinfo "
"property"));
rangelist = colon + 1;
/* remove r0 */
if (colon[1] == '0')
{
if (strncmp(rangelist, "0*,", 3) == 0)
{
rangelist += 3;
}
else if (strcmp(rangelist, "0*") == 0
|| strncmp(rangelist, "0,", 2) == 0
|| strncmp(rangelist, "0-1*", 4) == 0
|| strncmp(rangelist, "0-1,", 4) == 0
|| strcmp(rangelist, "0-1") == 0)
{
rangelist += 2;
}
else if (strcmp(rangelist, "0") == 0)
{
rangelist += 1;
}
else if (strncmp(rangelist, "0-", 2) == 0)
{
rangelist[0] = '1';
}
}
/* reassemble */
if (rangelist[0])
{
if (new_str->len)
svn_stringbuf_appendbyte(new_str, '\n');
svn_stringbuf_appendbytes(new_str, line, colon + 1 - line);
svn_stringbuf_appendcstr(new_str, rangelist);
}
}
if (strcmp((*str)->data, new_str->data) != 0)
{
*was_changed = TRUE;
}
*str = svn_stringbuf__morph_into_string(new_str);
return SVN_NO_ERROR;
}
static svn_error_t *
end_element(void *baton, int state, const char *nspace, const char *elt_name)
{
replay_baton_t *rb = baton;
const svn_ra_neon__xml_elm_t *elm
= svn_ra_neon__lookup_xml_elem(editor_report_elements, nspace, elt_name);
if (! elm)
return SVN_NO_ERROR;
switch (elm->id)
{
case ELEM_editor_report:
if (rb->dirs->nelts)
svn_pool_destroy(APR_ARRAY_IDX(rb->dirs, 0, dir_item_t).pool);
return SVN_NO_ERROR;
break;
case ELEM_apply_textdelta:
SVN_ERR(svn_stream_close(rb->base64_decoder));
rb->whandler = NULL;
rb->whandler_baton = NULL;
rb->svndiff_decoder = NULL;
rb->base64_decoder = NULL;
break;
case ELEM_change_file_prop:
case ELEM_change_dir_prop:
{
const svn_string_t *decoded_value;
if (rb->prop_accum)
{
const svn_string_t *prop;
prop = svn_stringbuf__morph_into_string(rb->prop_accum);
decoded_value = svn_base64_decode_string(prop, rb->prop_pool);
}
else
decoded_value = NULL; /* It's a delete */
if (elm->id == ELEM_change_dir_prop)
SVN_ERR(rb->editor->change_dir_prop(TOP_DIR(rb).baton,
rb->prop_name,
decoded_value,
TOP_DIR(rb).pool));
else
SVN_ERR(rb->editor->change_file_prop(rb->file_baton,
rb->prop_name,
decoded_value,
TOP_DIR(rb).file_pool));
}
break;
default:
break;
}
return SVN_NO_ERROR;
}
/* NAME, CMD and ARGS are the name, path to and arguments for the hook
program that is to be run. The hook's exit status will be checked,
and if an error occurred the hook's stderr output will be added to
the returned error.
If STDIN_HANDLE is non-null, pass it as the hook's stdin, else pass
no stdin to the hook.
If RESULT is non-null, set *RESULT to the stdout of the hook or to
a zero-length string if the hook generates no output on stdout. */
static svn_error_t *
run_hook_cmd(svn_string_t **result,
const char *name,
const char *cmd,
const char **args,
apr_hash_t *hooks_env,
apr_file_t *stdin_handle,
apr_pool_t *pool)
{
apr_file_t *null_handle;
apr_status_t apr_err;
svn_error_t *err;
apr_proc_t cmd_proc = {0};
apr_pool_t *cmd_pool;
apr_hash_t *hook_env = NULL;
if (result)
{
null_handle = NULL;
}
else
{
/* Redirect stdout to the null device */
apr_err = apr_file_open(&null_handle, SVN_NULL_DEVICE_NAME, APR_WRITE,
APR_OS_DEFAULT, pool);
if (apr_err)
return svn_error_wrap_apr
(apr_err, _("Can't create null stdout for hook '%s'"), cmd);
}
/* Tie resources allocated for the command to a special pool which we can
* destroy in order to clean up the stderr pipe opened for the process. */
cmd_pool = svn_pool_create(pool);
/* Check if a custom environment is defined for this hook, or else
* whether a default environment is defined. */
if (hooks_env)
{
hook_env = svn_hash_gets(hooks_env, name);
if (hook_env == NULL)
hook_env = svn_hash_gets(hooks_env,
SVN_REPOS__HOOKS_ENV_DEFAULT_SECTION);
}
err = svn_io_start_cmd3(&cmd_proc, ".", cmd, args,
env_from_env_hash(hook_env, pool, pool),
FALSE, FALSE, stdin_handle, result != NULL,
null_handle, TRUE, NULL, cmd_pool);
if (!err)
err = check_hook_result(name, cmd, &cmd_proc, cmd_proc.err, pool);
else
{
/* The command could not be started for some reason. */
err = svn_error_createf(SVN_ERR_REPOS_BAD_ARGS, err,
_("Failed to start '%s' hook"), cmd);
}
/* Hooks are fallible, and so hook failure is "expected" to occur at
times. When such a failure happens we still want to close the pipe
and null file */
if (!err && result)
{
svn_stringbuf_t *native_stdout;
err = svn_stringbuf_from_aprfile(&native_stdout, cmd_proc.out, pool);
if (!err)
*result = svn_stringbuf__morph_into_string(native_stdout);
}
/* Close resources allocated by svn_io_start_cmd3(), such as the pipe. */
svn_pool_destroy(cmd_pool);
/* Close the null handle. */
if (null_handle)
{
apr_err = apr_file_close(null_handle);
if (!err && apr_err)
return svn_error_wrap_apr(apr_err, _("Error closing null file"));
}
return svn_error_trace(err);
}
