static svn_error_t *
test_svn_subst_translate_string2(apr_pool_t *pool)
{
static const struct translate_string2_data_t tests[] =
{
/* No reencoding, no translation of line endings */
{ "abcdefz",
"abcdefz", FALSE, FALSE },
/* No reencoding, translation of line endings */
{ " \r\n\r\n \r\n \r\n",
" \n\n \n \n", FALSE, TRUE },
/* Reencoding, no translation of line endings */
{ "\xc7\xa9\xf4\xdf",
"\xc3\x87\xc2\xa9\xc3\xb4\xc3\x9f", TRUE, FALSE },
/* Reencoding, translation of line endings */
{ "\xc7\xa9\xf4\xdf\r\n",
"\xc3\x87\xc2\xa9\xc3\xb4\xc3\x9f\n", TRUE, TRUE },
{ NULL, NULL, FALSE, FALSE }
};
const struct translate_string2_data_t *t;
for (t = tests; t->source != NULL; t++)
{
svn_string_t *source_string = svn_string_create(t->source, pool);
svn_string_t *new_value = NULL;
svn_boolean_t translated_line_endings = ! t->translated_line_endings;
svn_boolean_t translated_to_utf8;
SVN_ERR(svn_subst_translate_string2(&new_value,
NULL, &translated_line_endings,
source_string, "ISO-8859-1", FALSE,
pool, pool));
SVN_TEST_STRING_ASSERT(new_value->data, t->expected_str);
SVN_TEST_ASSERT(translated_line_endings == t->translated_line_endings);
new_value = NULL;
translated_to_utf8 = ! t->translated_to_utf8;
translated_line_endings = ! t->translated_line_endings;
SVN_ERR(svn_subst_translate_string2(&new_value, &translated_to_utf8,
&translated_line_endings,
source_string, "ISO-8859-1", FALSE,
pool, pool));
SVN_TEST_STRING_ASSERT(new_value->data, t->expected_str);
SVN_TEST_ASSERT(translated_to_utf8 == t->translated_to_utf8);
SVN_TEST_ASSERT(translated_line_endings == t->translated_line_endings);
}
/* Test that when REPAIR is FALSE, SVN_ERR_IO_INCONSISTENT_EOL is returned. */
{
svn_string_t *source_string = svn_string_create(" \r \r\n \n ", pool);
svn_string_t *new_value = NULL;
svn_error_t *err = svn_subst_translate_string2(&new_value, NULL, NULL,
source_string,
"ISO-8859-1", FALSE, pool,
pool);
SVN_TEST_ASSERT_ERROR(err, SVN_ERR_IO_INCONSISTENT_EOL);
}
return SVN_NO_ERROR;
}
/* Normalize the encoding and line ending style of *STR, so that it contains
* only LF (\n) line endings and is encoded in UTF-8. After return, *STR may
* point at a new svn_string_t* allocated in RESULT_POOL.
*
* If SOURCE_PROP_ENCODING is NULL, then *STR is presumed to be encoded in
* UTF-8.
*
* *WAS_NORMALIZED is set to TRUE when *STR needed line ending normalization.
* Otherwise it is set to FALSE.
*
* SCRATCH_POOL is used for temporary allocations.
*/
static svn_error_t *
normalize_string(const svn_string_t **str,
svn_boolean_t *was_normalized,
const char *source_prop_encoding,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_string_t *new_str;
*was_normalized = FALSE;
if (*str == NULL)
return SVN_NO_ERROR;
SVN_ERR_ASSERT((*str)->data != NULL);
if (source_prop_encoding == NULL)
source_prop_encoding = "UTF-8";
new_str = NULL;
SVN_ERR(svn_subst_translate_string2(&new_str, NULL, was_normalized,
*str, source_prop_encoding, TRUE,
result_pool, scratch_pool));
*str = new_str;
return SVN_NO_ERROR;
}
svn_error_t *
svn_subst_translate_string(svn_string_t **new_value,
const svn_string_t *value,
const char *encoding,
apr_pool_t *pool)
{
return svn_subst_translate_string2(new_value, NULL, NULL, value,
encoding, FALSE, pool, pool);
}
static svn_error_t *
test_repairing_svn_subst_translate_string2(apr_pool_t *pool)
{
{
svn_string_t *source_string = svn_string_create(" \r \r\n \n ", pool);
svn_string_t *new_value = NULL;
SVN_ERR(svn_subst_translate_string2(&new_value, NULL, NULL, source_string,
"ISO-8859-1", TRUE, pool, pool));
SVN_TEST_ASSERT(new_value != NULL);
SVN_TEST_ASSERT(new_value->data != NULL);
SVN_TEST_STRING_ASSERT(new_value->data, " \n \n \n ");
}
return SVN_NO_ERROR;
}
/* The body of the svn_subst_translate_string2_null_encoding test. It should
only be called by test_svn_subst_translate_string2_null_encoding(), as this
code assumes that the process locale has been changed to a locale that uses
either CP-1252 or ISO-8859-1 for the default narrow string encoding. */
static svn_error_t *
test_svn_subst_translate_string2_null_encoding_helper(apr_pool_t *pool)
{
{
svn_string_t *new_value = NULL;
svn_boolean_t translated_to_utf8 = FALSE;
svn_boolean_t translated_line_endings = TRUE;
/* The 'AE' ligature, which is 0xc6 in both ISO-8859-1 and Windows-1252 */
svn_string_t *source_string = svn_string_create("\xc6", pool);
SVN_ERR(svn_subst_translate_string2(&new_value, &translated_to_utf8,
&translated_line_endings,
source_string, NULL, FALSE,
pool, pool));
SVN_TEST_STRING_ASSERT(new_value->data, "\xc3\x86");
SVN_TEST_ASSERT(translated_to_utf8);
SVN_TEST_ASSERT(!translated_line_endings);
}
return SVN_NO_ERROR;
}
/* Get a lock comment, allocate it in POOL and store it in *COMMENT. */
static svn_error_t *
get_comment(const char **comment, svn_client_ctx_t *ctx,
svn_cl__opt_state_t *opt_state, apr_pool_t *pool)
{
svn_string_t *comment_string;
if (opt_state->filedata)
{
/* Get it from the -F argument. */
if (strlen(opt_state->filedata->data) < opt_state->filedata->len)
{
/* A message containing a zero byte can't be represented as a C
string. */
return svn_error_create(SVN_ERR_CL_BAD_LOG_MESSAGE, NULL,
_("Lock comment contains a zero byte"));
}
comment_string = svn_string_create(opt_state->filedata->data, pool);
}
else if (opt_state->message)
{
/* Get if from the -m option. */
comment_string = svn_string_create(opt_state->message, pool);
}
else
{
*comment = NULL;
return SVN_NO_ERROR;
}
/* Translate to UTF8/LF. */
SVN_ERR(svn_subst_translate_string2(&comment_string, NULL, NULL,
comment_string, opt_state->encoding,
FALSE, pool, pool));
*comment = comment_string->data;
return SVN_NO_ERROR;
}
svn_error_t *
svn_cl__get_log_message(const char **log_msg,
const char **tmp_file,
const apr_array_header_t *commit_items,
void *baton,
apr_pool_t *pool)
{
svn_stringbuf_t *default_msg = NULL;
struct log_msg_baton *lmb = baton;
svn_stringbuf_t *message = NULL;
svn_config_t *cfg;
const char *mfc_after, *sponsored_by;
cfg = lmb->config ? svn_hash_gets(lmb->config, SVN_CONFIG_CATEGORY_CONFIG) : NULL;
/* Set default message. */
default_msg = svn_stringbuf_create(APR_EOL_STR, pool);
svn_stringbuf_appendcstr(default_msg, APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "PR:\t\t" APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "Submitted by:\t" APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "Reported by:\t" APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "Reviewed by:\t" APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "Approved by:\t" APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "Obtained from:\t" APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "MFC after:\t");
svn_config_get(cfg, &mfc_after, SVN_CONFIG_SECTION_MISCELLANY, "freebsd-mfc-after", NULL);
if (mfc_after != NULL)
svn_stringbuf_appendcstr(default_msg, mfc_after);
svn_stringbuf_appendcstr(default_msg, APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "MFH:\t\t" APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "Relnotes:\t" APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "Security:\t" APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "Sponsored by:\t");
svn_config_get(cfg, &sponsored_by, SVN_CONFIG_SECTION_MISCELLANY, "freebsd-sponsored-by",
#ifdef HAS_ORGANIZATION_NAME
ORGANIZATION_NAME);
#else
NULL);
#endif
if (sponsored_by != NULL)
svn_stringbuf_appendcstr(default_msg, sponsored_by);
svn_stringbuf_appendcstr(default_msg, APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "Differential Revision:\t" APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, EDITOR_EOF_PREFIX);
svn_stringbuf_appendcstr(default_msg, APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "> Description of fields to fill in above: 76 columns --|" APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "> PR: If and which Problem Report is related." APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "> Submitted by: If someone else sent in the change." APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "> Reported by: If someone else reported the issue." APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "> Reviewed by: If someone else reviewed your modification." APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "> Approved by: If you needed approval for this commit." APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "> Obtained from: If the change is from a third party." APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "> MFC after: N [day[s]|week[s]|month[s]]. Request a reminder email." APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "> MFH: Ports tree branch name. Request approval for merge." APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "> Relnotes: Set to 'yes' for mention in release notes." APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "> Security: Vulnerability reference (one per line) or description." APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "> Sponsored by: If the change was sponsored by an organization." APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "> Differential Revision: https://reviews.freebsd.org/D### (*full* phabric URL needed)." APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, "> Empty fields above will be automatically removed." APR_EOL_STR);
svn_stringbuf_appendcstr(default_msg, APR_EOL_STR);
*tmp_file = NULL;
if (lmb->message)
{
svn_string_t *log_msg_str = svn_string_create(lmb->message, pool);
SVN_ERR_W(svn_subst_translate_string2(&log_msg_str, NULL, NULL,
log_msg_str, lmb->message_encoding,
FALSE, pool, pool),
_("Error normalizing log message to internal format"));
/* Strip off the EOF marker text and the junk that follows it. */
truncate_buffer_at_prefix(&(log_msg_str->len), (char *)log_msg_str->data,
EDITOR_EOF_PREFIX);
cleanmsg(&(log_msg_str->len), (char*)log_msg_str->data);
*log_msg = log_msg_str->data;
return SVN_NO_ERROR;
}
if (! commit_items->nelts)
{
*log_msg = "";
return SVN_NO_ERROR;
}
while (! message)
{
/* We still don't have a valid commit message. Use $EDITOR to
get one. Note that svn_cl__edit_string_externally will still
return a UTF-8'ized log message. */
int i;
svn_stringbuf_t *tmp_message = svn_stringbuf_dup(default_msg, pool);
svn_error_t *err = SVN_NO_ERROR;
svn_string_t *msg_string = svn_string_create_empty(pool);
for (i = 0; i < commit_items->nelts; i++)
{
svn_client_commit_item3_t *item
= APR_ARRAY_IDX(commit_items, i, svn_client_commit_item3_t *);
const char *path = item->path;
char text_mod = '_', prop_mod = ' ', unlock = ' ';
if (! path)
path = item->url;
else if (lmb->base_dir)
path = svn_dirent_is_child(lmb->base_dir, path, pool);
/* If still no path, then just use current directory. */
if (! path || !*path)
path = ".";
if ((item->state_flags & SVN_CLIENT_COMMIT_ITEM_DELETE)
&& (item->state_flags & SVN_CLIENT_COMMIT_ITEM_ADD))
text_mod = 'R';
else if (item->state_flags & SVN_CLIENT_COMMIT_ITEM_ADD)
text_mod = 'A';
else if (item->state_flags & SVN_CLIENT_COMMIT_ITEM_DELETE)
text_mod = 'D';
else if (item->state_flags & SVN_CLIENT_COMMIT_ITEM_TEXT_MODS)
text_mod = 'M';
if (item->state_flags & SVN_CLIENT_COMMIT_ITEM_PROP_MODS)
prop_mod = 'M';
if (! lmb->keep_locks
&& item->state_flags & SVN_CLIENT_COMMIT_ITEM_LOCK_TOKEN)
unlock = 'U';
svn_stringbuf_appendbyte(tmp_message, text_mod);
svn_stringbuf_appendbyte(tmp_message, prop_mod);
svn_stringbuf_appendbyte(tmp_message, unlock);
if (item->state_flags & SVN_CLIENT_COMMIT_ITEM_IS_COPY)
/* History included via copy/move. */
svn_stringbuf_appendcstr(tmp_message, "+ ");
else
svn_stringbuf_appendcstr(tmp_message, " ");
svn_stringbuf_appendcstr(tmp_message, path);
svn_stringbuf_appendcstr(tmp_message, APR_EOL_STR);
}
msg_string->data = tmp_message->data;
msg_string->len = tmp_message->len;
/* Use the external edit to get a log message. */
if (! lmb->non_interactive)
{
err = svn_cmdline__edit_string_externally(&msg_string, &lmb->tmpfile_left,
lmb->editor_cmd,
lmb->base_dir ? lmb->base_dir : "",
msg_string, "svn-commit",
lmb->config, TRUE,
lmb->message_encoding,
pool);
}
else /* non_interactive flag says we can't pop up an editor, so error */
{
return svn_error_create
(SVN_ERR_CL_INSUFFICIENT_ARGS, NULL,
_("Cannot invoke editor to get log message "
"when non-interactive"));
}
/* Dup the tmpfile path into its baton's pool. */
*tmp_file = lmb->tmpfile_left = apr_pstrdup(lmb->pool,
lmb->tmpfile_left);
/* If the edit returned an error, handle it. */
if (err)
{
if (err->apr_err == SVN_ERR_CL_NO_EXTERNAL_EDITOR)
err = svn_error_quick_wrap
(err, _("Could not use external editor to fetch log message; "
"consider setting the $SVN_EDITOR environment variable "
"or using the --message (-m) or --file (-F) options"));
return svn_error_trace(err);
}
if (msg_string)
message = svn_stringbuf_create_from_string(msg_string, pool);
/* Strip off the EOF marker text and the junk that follows it. */
if (message)
truncate_buffer_at_prefix(&message->len, message->data,
EDITOR_EOF_PREFIX);
/*
* Since we're adding freebsd-specific tokens to the log message,
* clean out any leftovers to avoid accidently sending them to other
* projects that won't be expecting them.
*/
if (message)
cleanmsg(&message->len, message->data);
if (message)
{
/* We did get message, now check if it is anything more than just
white space as we will consider white space only as empty */
apr_size_t len;
for (len = 0; len < message->len; len++)
{
/* FIXME: should really use an UTF-8 whitespace test
rather than svn_ctype_isspace, which is ASCII only */
if (! svn_ctype_isspace(message->data[len]))
break;
}
if (len == message->len)
message = NULL;
}
if (! message)
{
const char *reply;
SVN_ERR(svn_cmdline_prompt_user2
(&reply,
_("\nLog message unchanged or not specified\n"
"(a)bort, (c)ontinue, (e)dit:\n"), NULL, pool));
if (reply)
{
int letter = apr_tolower(reply[0]);
/* If the user chooses to abort, we cleanup the
temporary file and exit the loop with a NULL
message. */
if ('a' == letter)
{
SVN_ERR(svn_io_remove_file2(lmb->tmpfile_left, FALSE, pool));
*tmp_file = lmb->tmpfile_left = NULL;
break;
}
/* If the user chooses to continue, we make an empty
message, which will cause us to exit the loop. We
also cleanup the temporary file. */
if ('c' == letter)
{
SVN_ERR(svn_io_remove_file2(lmb->tmpfile_left, FALSE, pool));
*tmp_file = lmb->tmpfile_left = NULL;
message = svn_stringbuf_create_empty(pool);
}
/* If the user chooses anything else, the loop will
continue on the NULL message. */
}
}
}
*log_msg = message ? message->data : NULL;
return SVN_NO_ERROR;
}
svn_error_t *
svn_cl__get_log_message(const char **log_msg,
const char **tmp_file,
const apr_array_header_t *commit_items,
void *baton,
apr_pool_t *pool)
{
svn_stringbuf_t *default_msg = NULL;
struct log_msg_baton *lmb = baton;
svn_stringbuf_t *message = NULL;
/* Set default message. */
default_msg = svn_stringbuf_create(APR_EOL_STR, pool);
svn_stringbuf_appendcstr(default_msg, EDITOR_EOF_PREFIX);
svn_stringbuf_appendcstr(default_msg, APR_EOL_STR APR_EOL_STR);
*tmp_file = NULL;
if (lmb->message)
{
svn_stringbuf_t *log_msg_buf = svn_stringbuf_create(lmb->message, pool);
svn_string_t *log_msg_str = apr_pcalloc(pool, sizeof(*log_msg_str));
/* Trim incoming messages of the EOF marker text and the junk
that follows it. */
truncate_buffer_at_prefix(&(log_msg_buf->len), log_msg_buf->data,
EDITOR_EOF_PREFIX);
/* Make a string from a stringbuf, sharing the data allocation. */
log_msg_str->data = log_msg_buf->data;
log_msg_str->len = log_msg_buf->len;
SVN_ERR_W(svn_subst_translate_string2(&log_msg_str, FALSE, FALSE,
log_msg_str, lmb->message_encoding,
FALSE, pool, pool),
_("Error normalizing log message to internal format"));
*log_msg = log_msg_str->data;
return SVN_NO_ERROR;
}
if (! commit_items->nelts)
{
*log_msg = "";
return SVN_NO_ERROR;
}
while (! message)
{
/* We still don't have a valid commit message. Use $EDITOR to
get one. Note that svn_cl__edit_externally will still return
a UTF-8'ized log message. */
int i;
svn_stringbuf_t *tmp_message = svn_stringbuf_dup(default_msg, pool);
svn_error_t *err = SVN_NO_ERROR;
svn_string_t *msg_string = svn_string_create("", pool);
for (i = 0; i < commit_items->nelts; i++)
{
svn_client_commit_item3_t *item
= APR_ARRAY_IDX(commit_items, i, svn_client_commit_item3_t *);
const char *path = item->path;
char text_mod = '_', prop_mod = ' ', unlock = ' ';
if (! path)
path = item->url;
else if (! *path)
path = ".";
if (! svn_path_is_url(path) && lmb->base_dir)
path = svn_dirent_is_child(lmb->base_dir, path, pool);
/* If still no path, then just use current directory. */
if (! path)
path = ".";
if ((item->state_flags & SVN_CLIENT_COMMIT_ITEM_DELETE)
&& (item->state_flags & SVN_CLIENT_COMMIT_ITEM_ADD))
text_mod = 'R';
else if (item->state_flags & SVN_CLIENT_COMMIT_ITEM_ADD)
text_mod = 'A';
else if (item->state_flags & SVN_CLIENT_COMMIT_ITEM_DELETE)
text_mod = 'D';
else if (item->state_flags & SVN_CLIENT_COMMIT_ITEM_TEXT_MODS)
text_mod = 'M';
if (item->state_flags & SVN_CLIENT_COMMIT_ITEM_PROP_MODS)
prop_mod = 'M';
if (! lmb->keep_locks
&& item->state_flags & SVN_CLIENT_COMMIT_ITEM_LOCK_TOKEN)
unlock = 'U';
svn_stringbuf_appendbyte(tmp_message, text_mod);
svn_stringbuf_appendbyte(tmp_message, prop_mod);
svn_stringbuf_appendbyte(tmp_message, unlock);
if (item->state_flags & SVN_CLIENT_COMMIT_ITEM_IS_COPY)
/* History included via copy/move. */
svn_stringbuf_appendcstr(tmp_message, "+ ");
else
svn_stringbuf_appendcstr(tmp_message, " ");
svn_stringbuf_appendcstr(tmp_message, path);
svn_stringbuf_appendcstr(tmp_message, APR_EOL_STR);
}
msg_string->data = tmp_message->data;
msg_string->len = tmp_message->len;
/* Use the external edit to get a log message. */
if (! lmb->non_interactive)
{
err = svn_cl__edit_string_externally(&msg_string, &lmb->tmpfile_left,
lmb->editor_cmd, lmb->base_dir,
msg_string, "svn-commit",
lmb->config, TRUE,
lmb->message_encoding,
pool);
}
else /* non_interactive flag says we can't pop up an editor, so error */
{
return svn_error_create
(SVN_ERR_CL_INSUFFICIENT_ARGS, NULL,
_("Cannot invoke editor to get log message "
"when non-interactive"));
}
/* Dup the tmpfile path into its baton's pool. */
*tmp_file = lmb->tmpfile_left = apr_pstrdup(lmb->pool,
lmb->tmpfile_left);
/* If the edit returned an error, handle it. */
if (err)
{
if (err->apr_err == SVN_ERR_CL_NO_EXTERNAL_EDITOR)
err = svn_error_quick_wrap
(err, _("Could not use external editor to fetch log message; "
"consider setting the $SVN_EDITOR environment variable "
"or using the --message (-m) or --file (-F) options"));
return svn_error_trace(err);
}
if (msg_string)
message = svn_stringbuf_create_from_string(msg_string, pool);
/* Strip the prefix from the buffer. */
if (message)
truncate_buffer_at_prefix(&message->len, message->data,
EDITOR_EOF_PREFIX);
if (message)
{
/* We did get message, now check if it is anything more than just
white space as we will consider white space only as empty */
apr_size_t len;
for (len = 0; len < message->len; len++)
{
/* FIXME: should really use an UTF-8 whitespace test
rather than svn_ctype_isspace, which is ASCII only */
if (! svn_ctype_isspace(message->data[len]))
break;
}
if (len == message->len)
message = NULL;
}
if (! message)
{
const char *reply;
SVN_ERR(svn_cmdline_prompt_user2
(&reply,
_("\nLog message unchanged or not specified\n"
"(a)bort, (c)ontinue, (e)dit:\n"), NULL, pool));
if (reply)
{
int letter = apr_tolower(reply[0]);
/* If the user chooses to abort, we cleanup the
temporary file and exit the loop with a NULL
message. */
if ('a' == letter)
{
SVN_ERR(svn_io_remove_file2(lmb->tmpfile_left, FALSE, pool));
*tmp_file = lmb->tmpfile_left = NULL;
break;
}
/* If the user chooses to continue, we make an empty
message, which will cause us to exit the loop. We
also cleanup the temporary file. */
if ('c' == letter)
{
SVN_ERR(svn_io_remove_file2(lmb->tmpfile_left, FALSE, pool));
*tmp_file = lmb->tmpfile_left = NULL;
message = svn_stringbuf_create("", pool);
}
/* If the user chooses anything else, the loop will
continue on the NULL message. */
}
}
}
*log_msg = message ? message->data : NULL;
return SVN_NO_ERROR;
}
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);
}
/* This implements the `svn_opt_subcommand_t' interface. */
svn_error_t *
svn_cl__propset(apr_getopt_t *os,
void *baton,
apr_pool_t *scratch_pool)
{
svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state;
svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx;
const char *pname;
svn_string_t *propval = NULL;
svn_boolean_t propval_came_from_cmdline;
apr_array_header_t *args, *targets;
/* PNAME and PROPVAL expected as first 2 arguments if filedata was
NULL, else PNAME alone will precede the targets. Get a UTF-8
version of the name, too. */
SVN_ERR(svn_opt_parse_num_args(&args, os,
opt_state->filedata ? 1 : 2, scratch_pool));
pname = APR_ARRAY_IDX(args, 0, const char *);
SVN_ERR(svn_utf_cstring_to_utf8(&pname, pname, scratch_pool));
if (! svn_prop_name_is_valid(pname))
return svn_error_createf(SVN_ERR_CLIENT_PROPERTY_NAME, NULL,
_("'%s' is not a valid Subversion property name"),
pname);
if (!opt_state->force)
SVN_ERR(svn_cl__check_svn_prop_name(pname, opt_state->revprop,
svn_cl__prop_use_set, scratch_pool));
/* Get the PROPVAL from either an external file, or from the command
line. */
if (opt_state->filedata)
{
propval = svn_string_create_from_buf(opt_state->filedata, scratch_pool);
propval_came_from_cmdline = FALSE;
}
else
{
propval = svn_string_create(APR_ARRAY_IDX(args, 1, const char *),
scratch_pool);
propval_came_from_cmdline = TRUE;
}
/* We only want special Subversion property values to be in UTF-8
and LF line endings. All other propvals are taken literally. */
if (svn_prop_needs_translation(pname))
SVN_ERR(svn_subst_translate_string2(&propval, NULL, NULL, propval,
opt_state->encoding, FALSE,
scratch_pool, scratch_pool));
else if (opt_state->encoding)
return svn_error_create
(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("--encoding option applies only to textual"
" Subversion-controlled properties"));
/* Suck up all the remaining arguments into a targets array */
SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os,
opt_state->targets,
ctx, FALSE,
scratch_pool));
/* Implicit "." is okay for revision properties; it just helps
us find the right repository. */
if (opt_state->revprop)
svn_opt_push_implicit_dot_target(targets, scratch_pool);
SVN_ERR(svn_cl__eat_peg_revisions(&targets, targets, scratch_pool));
if (opt_state->revprop) /* operate on a revprop */
{
svn_revnum_t rev;
const char *URL;
SVN_ERR(svn_cl__revprop_prepare(&opt_state->start_revision, targets,
&URL, ctx, scratch_pool));
/* Let libsvn_client do the real work. */
SVN_ERR(svn_client_revprop_set2(pname, propval, NULL,
URL, &(opt_state->start_revision),
&rev, opt_state->force, ctx,
scratch_pool));
}
else if (opt_state->start_revision.kind != svn_opt_revision_unspecified)
{
return svn_error_createf
(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("Cannot specify revision for setting versioned property '%s'"),
pname);
}
else /* operate on a normal, versioned property (not a revprop) */
{
if (opt_state->depth == svn_depth_unknown)
opt_state->depth = svn_depth_empty;
/* The customary implicit dot rule has been prone to user error
* here. People would do intuitive things like
*
* $ svn propset svn:executable script
*
* and then be surprised to get an error like:
*
* svn: Illegal target for the requested operation
* svn: Cannot set svn:executable on a directory ()
*
* So we don't do the implicit dot thing anymore. A * target
* must always be explicitly provided when setting a versioned
* property. See
*
* http://subversion.tigris.org/issues/show_bug.cgi?id=924
*
* for more details.
*/
if (targets->nelts == 0)
{
if (propval_came_from_cmdline)
{
return svn_error_createf
(SVN_ERR_CL_INSUFFICIENT_ARGS, NULL,
_("Explicit target required ('%s' interpreted as prop value)"),
propval->data);
}
else
{
return svn_error_create
(SVN_ERR_CL_INSUFFICIENT_ARGS, NULL,
_("Explicit target argument required"));
}
}
SVN_ERR(svn_cl__propset_print_binary_mime_type_warning(targets,
pname,
propval,
scratch_pool));
SVN_ERR(svn_client_propset_local(pname, propval, targets,
opt_state->depth, opt_state->force,
opt_state->changelists, ctx,
scratch_pool));
if (! opt_state->quiet)
svn_cl__check_boolean_prop_val(pname, propval->data, scratch_pool);
}
return SVN_NO_ERROR;
}
