/* Set *PROPS to the pristine (base) properties at LOCAL_ABSPATH, if PRISTINE
* is true, or else the working value if PRISTINE is false.
*
* The keys of *PROPS will be 'const char *' property names, and the
* values 'const svn_string_t *' property values. Allocate *PROPS
* and its contents in RESULT_POOL. Use SCRATCH_POOL for temporary
* allocations.
*/
static svn_error_t *
pristine_or_working_props(apr_hash_t **props,
svn_wc_context_t *wc_ctx,
const char *local_abspath,
svn_boolean_t pristine,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
if (pristine)
{
return svn_error_trace(svn_wc_get_pristine_props(props,
wc_ctx,
local_abspath,
result_pool,
scratch_pool));
}
/* ### until svn_wc_prop_list2() returns a NULL value for locally-deleted
### nodes, then let's check manually. */
{
svn_boolean_t deleted;
SVN_ERR(svn_wc__node_is_status_deleted(&deleted, wc_ctx, local_abspath,
scratch_pool));
if (deleted)
{
*props = NULL;
return SVN_NO_ERROR;
}
}
return svn_error_trace(svn_wc_prop_list2(props, wc_ctx, local_abspath,
result_pool, scratch_pool));
}
/* Try to get properties for LOCAL_ABSPATH and return them in the property
* hash *PROPS. If there are no properties because LOCAL_ABSPATH is not
* versioned, return an empty property hash. */
static svn_error_t *
get_props(apr_hash_t **props,
const char *local_abspath,
svn_wc_context_t *wc_ctx,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_error_t *err;
err = svn_wc_prop_list2(props, wc_ctx, local_abspath, result_pool,
scratch_pool);
if (err)
{
if (err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND ||
err->apr_err == SVN_ERR_WC_NOT_WORKING_COPY)
{
svn_error_clear(err);
*props = apr_hash_make(result_pool);
/* ### Apply autoprops, like 'svn add' would? */
}
else
return svn_error_trace(err);
}
return SVN_NO_ERROR;
}
/* Make an unversioned copy of the versioned file at FROM_ABSPATH. Copy it
* to the destination path TO_ABSPATH.
*
* If REVISION is svn_opt_revision_working, copy the working version,
* otherwise copy the base version.
*
* Expand the file's keywords according to the source file's 'svn:keywords'
* property, if present. If copying a locally modified working version,
* append 'M' to the revision number and use '(local)' for the author.
*
* Translate the file's line endings according to the source file's
* 'svn:eol-style' property, if present. If NATIVE_EOL is not NULL, use it
* in place of the native EOL style. Throw an error if the source file has
* inconsistent line endings and EOL translation is attempted.
*
* Set the destination file's modification time to the source file's
* modification time if copying the working version and the working version
* is locally modified; otherwise set it to the versioned file's last
* changed time.
*
* Set the destination file's 'executable' flag according to the source
* file's 'svn:executable' property.
*/
static svn_error_t *
copy_one_versioned_file(const char *from_abspath,
const char *to_abspath,
svn_client_ctx_t *ctx,
const svn_opt_revision_t *revision,
const char *native_eol,
svn_boolean_t ignore_keywords,
apr_pool_t *scratch_pool)
{
apr_hash_t *kw = NULL;
svn_subst_eol_style_t style;
apr_hash_t *props;
svn_string_t *eol_style, *keywords, *executable, *special;
const char *eol = NULL;
svn_boolean_t local_mod = FALSE;
apr_time_t tm;
svn_stream_t *source;
svn_stream_t *dst_stream;
const char *dst_tmp;
svn_error_t *err;
svn_boolean_t is_deleted;
svn_wc_context_t *wc_ctx = ctx->wc_ctx;
SVN_ERR(svn_wc__node_is_status_deleted(&is_deleted, wc_ctx, from_abspath,
scratch_pool));
/* Don't export 'deleted' files and directories unless it's a
revision other than WORKING. These files and directories
don't really exist in WORKING. */
if (revision->kind == svn_opt_revision_working && is_deleted)
return SVN_NO_ERROR;
if (revision->kind != svn_opt_revision_working)
{
/* Only export 'added' files when the revision is WORKING. This is not
WORKING, so skip the 'added' files, since they didn't exist
in the BASE revision and don't have an associated text-base.
'replaced' files are technically the same as 'added' files.
### TODO: Handle replaced nodes properly.
### svn_opt_revision_base refers to the "new"
### base of the node. That means, if a node is locally
### replaced, export skips this node, as if it was locally
### added, because svn_opt_revision_base refers to the base
### of the added node, not to the node that was deleted.
### In contrast, when the node is copied-here or moved-here,
### the copy/move source's content will be exported.
### It is currently not possible to export the revert-base
### when a node is locally replaced. We need a new
### svn_opt_revision_ enum value for proper distinction
### between revert-base and commit-base.
Copied-/moved-here nodes have a base, so export both added and
replaced files when they involve a copy-/move-here.
We get all this for free from evaluating SOURCE == NULL:
*/
SVN_ERR(svn_wc_get_pristine_contents2(&source, wc_ctx, from_abspath,
scratch_pool, scratch_pool));
if (source == NULL)
return SVN_NO_ERROR;
SVN_ERR(svn_wc_get_pristine_props(&props, wc_ctx, from_abspath,
scratch_pool, scratch_pool));
}
else
{
svn_wc_status3_t *status;
/* ### hmm. this isn't always a specialfile. this will simply open
### the file readonly if it is a regular file. */
SVN_ERR(svn_subst_read_specialfile(&source, from_abspath, scratch_pool,
scratch_pool));
SVN_ERR(svn_wc_prop_list2(&props, wc_ctx, from_abspath, scratch_pool,
scratch_pool));
SVN_ERR(svn_wc_status3(&status, wc_ctx, from_abspath, scratch_pool,
scratch_pool));
if (status->text_status != svn_wc_status_normal)
local_mod = TRUE;
}
/* We can early-exit if we're creating a special file. */
special = apr_hash_get(props, SVN_PROP_SPECIAL,
APR_HASH_KEY_STRING);
if (special != NULL)
{
/* Create the destination as a special file, and copy the source
details into the destination stream. */
SVN_ERR(svn_subst_create_specialfile(&dst_stream, to_abspath,
scratch_pool, scratch_pool));
return svn_error_trace(
svn_stream_copy3(source, dst_stream, NULL, NULL, scratch_pool));
}
eol_style = apr_hash_get(props, SVN_PROP_EOL_STYLE,
APR_HASH_KEY_STRING);
keywords = apr_hash_get(props, SVN_PROP_KEYWORDS,
APR_HASH_KEY_STRING);
executable = apr_hash_get(props, SVN_PROP_EXECUTABLE,
APR_HASH_KEY_STRING);
if (eol_style)
SVN_ERR(get_eol_style(&style, &eol, eol_style->data, native_eol));
if (local_mod)
{
/* Use the modified time from the working copy of
the file */
SVN_ERR(svn_io_file_affected_time(&tm, from_abspath, scratch_pool));
}
else
{
SVN_ERR(svn_wc__node_get_changed_info(NULL, &tm, NULL, wc_ctx,
from_abspath, scratch_pool,
scratch_pool));
}
if (keywords)
{
svn_revnum_t changed_rev;
const char *suffix;
const char *url;
const char *author;
SVN_ERR(svn_wc__node_get_changed_info(&changed_rev, NULL, &author,
wc_ctx, from_abspath, scratch_pool,
scratch_pool));
if (local_mod)
{
/* For locally modified files, we'll append an 'M'
to the revision number, and set the author to
"(local)" since we can't always determine the
current user's username */
suffix = "M";
author = _("(local)");
}
else
{
suffix = "";
}
SVN_ERR(svn_wc__node_get_url(&url, wc_ctx, from_abspath,
scratch_pool, scratch_pool));
SVN_ERR(svn_subst_build_keywords2
(&kw, keywords->data,
apr_psprintf(scratch_pool, "%ld%s", changed_rev, suffix),
url, tm, author, scratch_pool));
}
/* For atomicity, we translate to a tmp file and then rename the tmp file
over the real destination. */
SVN_ERR(svn_stream_open_unique(&dst_stream, &dst_tmp,
svn_dirent_dirname(to_abspath, scratch_pool),
svn_io_file_del_none, scratch_pool,
scratch_pool));
/* If some translation is needed, then wrap the output stream (this is
more efficient than wrapping the input). */
if (eol || (kw && (apr_hash_count(kw) > 0)))
dst_stream = svn_subst_stream_translated(dst_stream,
eol,
FALSE /* repair */,
kw,
! ignore_keywords /* expand */,
scratch_pool);
/* ###: use cancel func/baton in place of NULL/NULL below. */
err = svn_stream_copy3(source, dst_stream, NULL, NULL, scratch_pool);
if (!err && executable)
err = svn_io_set_file_executable(dst_tmp, TRUE, FALSE, scratch_pool);
if (!err)
err = svn_io_set_file_affected_time(tm, dst_tmp, scratch_pool);
if (err)
return svn_error_compose_create(err, svn_io_remove_file2(dst_tmp, FALSE,
scratch_pool));
/* Now that dst_tmp contains the translated data, do the atomic rename. */
SVN_ERR(svn_io_file_rename(dst_tmp, to_abspath, scratch_pool));
if (ctx->notify_func2)
{
svn_wc_notify_t *notify = svn_wc_create_notify(to_abspath,
svn_wc_notify_update_add, scratch_pool);
notify->kind = svn_node_file;
(*ctx->notify_func2)(ctx->notify_baton2, notify, scratch_pool);
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_client_blame5(const char *target,
const svn_opt_revision_t *peg_revision,
const svn_opt_revision_t *start,
const svn_opt_revision_t *end,
const svn_diff_file_options_t *diff_options,
svn_boolean_t ignore_mime_type,
svn_boolean_t include_merged_revisions,
svn_client_blame_receiver3_t receiver,
void *receiver_baton,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
struct file_rev_baton frb;
svn_ra_session_t *ra_session;
svn_revnum_t start_revnum, end_revnum;
struct blame *walk, *walk_merged = NULL;
apr_pool_t *iterpool;
svn_stream_t *last_stream;
svn_stream_t *stream;
const char *target_abspath_or_url;
if (start->kind == svn_opt_revision_unspecified
|| end->kind == svn_opt_revision_unspecified)
return svn_error_create
(SVN_ERR_CLIENT_BAD_REVISION, NULL, NULL);
if (svn_path_is_url(target))
target_abspath_or_url = target;
else
SVN_ERR(svn_dirent_get_absolute(&target_abspath_or_url, target, pool));
/* Get an RA plugin for this filesystem object. */
SVN_ERR(svn_client__ra_session_from_path(&ra_session, &end_revnum, NULL,
target, NULL, peg_revision, end,
ctx, pool));
SVN_ERR(svn_client__get_revision_number(&start_revnum, NULL, ctx->wc_ctx,
target_abspath_or_url, ra_session,
start, pool));
if (end_revnum < start_revnum)
return svn_error_create
(SVN_ERR_CLIENT_BAD_REVISION, NULL,
_("Start revision must precede end revision"));
frb.start_rev = start_revnum;
frb.end_rev = end_revnum;
frb.target = target;
frb.ctx = ctx;
frb.diff_options = diff_options;
frb.ignore_mime_type = ignore_mime_type;
frb.include_merged_revisions = include_merged_revisions;
frb.last_filename = NULL;
frb.last_original_filename = NULL;
frb.chain = apr_palloc(pool, sizeof(*frb.chain));
frb.chain->blame = NULL;
frb.chain->avail = NULL;
frb.chain->pool = pool;
if (include_merged_revisions)
{
frb.merged_chain = apr_palloc(pool, sizeof(*frb.merged_chain));
frb.merged_chain->blame = NULL;
frb.merged_chain->avail = NULL;
frb.merged_chain->pool = pool;
}
SVN_ERR(svn_ra_get_repos_root2(ra_session, &frb.repos_root_url, pool));
frb.mainpool = pool;
/* The callback will flip the following two pools, because it needs
information from the previous call. Obviously, it can't rely on
the lifetime of the pool provided by get_file_revs. */
frb.lastpool = svn_pool_create(pool);
frb.currpool = svn_pool_create(pool);
if (include_merged_revisions)
{
frb.filepool = svn_pool_create(pool);
frb.prevfilepool = svn_pool_create(pool);
}
/* Collect all blame information.
We need to ensure that we get one revision before the start_rev,
if available so that we can know what was actually changed in the start
revision. */
SVN_ERR(svn_ra_get_file_revs2(ra_session, "",
start_revnum - (start_revnum > 0 ? 1 : 0),
end_revnum, include_merged_revisions,
file_rev_handler, &frb, pool));
if (end->kind == svn_opt_revision_working)
{
/* If the local file is modified we have to call the handler on the
working copy file with keywords unexpanded */
svn_wc_status3_t *status;
SVN_ERR(svn_wc_status3(&status, ctx->wc_ctx, target_abspath_or_url, pool,
pool));
if (status->text_status != svn_wc_status_normal)
{
apr_hash_t *props;
svn_stream_t *wcfile;
svn_string_t *keywords;
svn_stream_t *tempfile;
const char *temppath;
apr_hash_t *kw = NULL;
SVN_ERR(svn_wc_prop_list2(&props, ctx->wc_ctx, target_abspath_or_url,
pool, pool));
SVN_ERR(svn_stream_open_readonly(&wcfile, target, pool, pool));
keywords = apr_hash_get(props, SVN_PROP_KEYWORDS,
APR_HASH_KEY_STRING);
if (keywords)
SVN_ERR(svn_subst_build_keywords2(&kw, keywords->data, NULL, NULL,
0, NULL, pool));
wcfile = svn_subst_stream_translated(wcfile, "\n", TRUE, kw, FALSE,
pool);
SVN_ERR(svn_stream_open_unique(&tempfile, &temppath, NULL,
svn_io_file_del_on_pool_cleanup,
pool, pool));
SVN_ERR(svn_stream_copy3(wcfile, tempfile, ctx->cancel_func,
ctx->cancel_baton, pool));
SVN_ERR(add_file_blame(frb.last_filename, temppath, frb.chain, NULL,
frb.diff_options, pool));
frb.last_filename = temppath;
}
}
/* Report the blame to the caller. */
/* The callback has to have been called at least once. */
SVN_ERR_ASSERT(frb.last_filename != NULL);
/* Create a pool for the iteration below. */
iterpool = svn_pool_create(pool);
/* Open the last file and get a stream. */
SVN_ERR(svn_stream_open_readonly(&last_stream, frb.last_filename,
pool, pool));
stream = svn_subst_stream_translated(last_stream,
"\n", TRUE, NULL, FALSE, pool);
/* Perform optional merged chain normalization. */
if (include_merged_revisions)
{
/* If we never created any blame for the original chain, create it now,
with the most recent changed revision. This could occur if a file
was created on a branch and them merged to another branch. This is
semanticly a copy, and we want to use the revision on the branch as
the most recently changed revision. ### Is this really what we want
to do here? Do the sematics of copy change? */
if (!frb.chain->blame)
frb.chain->blame = blame_create(frb.chain, frb.rev, 0);
normalize_blames(frb.chain, frb.merged_chain, pool);
walk_merged = frb.merged_chain->blame;
}
/* Process each blame item. */
for (walk = frb.chain->blame; walk; walk = walk->next)
{
apr_off_t line_no;
svn_revnum_t merged_rev;
const char *merged_path;
apr_hash_t *merged_rev_props;
if (walk_merged)
{
merged_rev = walk_merged->rev->revision;
merged_rev_props = walk_merged->rev->rev_props;
merged_path = walk_merged->rev->path;
}
else
{
merged_rev = SVN_INVALID_REVNUM;
merged_rev_props = NULL;
merged_path = NULL;
}
for (line_no = walk->start;
!walk->next || line_no < walk->next->start;
++line_no)
{
svn_boolean_t eof;
svn_stringbuf_t *sb;
svn_pool_clear(iterpool);
SVN_ERR(svn_stream_readline(stream, &sb, "\n", &eof, iterpool));
if (ctx->cancel_func)
SVN_ERR(ctx->cancel_func(ctx->cancel_baton));
if (!eof || sb->len)
{
if (walk->rev)
SVN_ERR(receiver(receiver_baton, start_revnum, end_revnum,
line_no, walk->rev->revision,
walk->rev->rev_props, merged_rev,
merged_rev_props, merged_path,
sb->data, FALSE, iterpool));
else
SVN_ERR(receiver(receiver_baton, start_revnum, end_revnum,
line_no, SVN_INVALID_REVNUM,
NULL, SVN_INVALID_REVNUM,
NULL, NULL,
sb->data, TRUE, iterpool));
}
if (eof) break;
}
if (walk_merged)
walk_merged = walk_merged->next;
}
SVN_ERR(svn_stream_close(stream));
svn_pool_destroy(frb.lastpool);
svn_pool_destroy(frb.currpool);
if (include_merged_revisions)
{
svn_pool_destroy(frb.filepool);
svn_pool_destroy(frb.prevfilepool);
}
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
svn_error_t *
svn_client__get_normalized_stream(svn_stream_t **normal_stream,
svn_wc_context_t *wc_ctx,
const char *local_abspath,
const svn_opt_revision_t *revision,
svn_boolean_t expand_keywords,
svn_boolean_t normalize_eols,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
apr_hash_t *kw = NULL;
svn_subst_eol_style_t style;
apr_hash_t *props;
svn_string_t *eol_style, *keywords, *special;
const char *eol = NULL;
svn_boolean_t local_mod = FALSE;
apr_time_t tm;
svn_stream_t *input;
svn_node_kind_t kind;
SVN_ERR_ASSERT(SVN_CLIENT__REVKIND_IS_LOCAL_TO_WC(revision->kind));
SVN_ERR(svn_wc_read_kind(&kind, wc_ctx, local_abspath, FALSE, scratch_pool));
if (kind == svn_node_unknown || kind == svn_node_none)
return svn_error_createf(SVN_ERR_UNVERSIONED_RESOURCE, NULL,
_("'%s' is not under version control"),
svn_dirent_local_style(local_abspath,
scratch_pool));
if (kind != svn_node_file)
return svn_error_createf(SVN_ERR_CLIENT_IS_DIRECTORY, NULL,
_("'%s' refers to a directory"),
svn_dirent_local_style(local_abspath,
scratch_pool));
if (revision->kind != svn_opt_revision_working)
{
SVN_ERR(svn_wc_get_pristine_contents2(&input, wc_ctx, local_abspath,
result_pool, scratch_pool));
if (input == NULL)
return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
_("'%s' has no base revision until it is committed"),
svn_dirent_local_style(local_abspath, scratch_pool));
SVN_ERR(svn_wc_get_pristine_props(&props, wc_ctx, local_abspath,
scratch_pool, scratch_pool));
}
else
{
svn_wc_status3_t *status;
SVN_ERR(svn_stream_open_readonly(&input, local_abspath, scratch_pool,
result_pool));
SVN_ERR(svn_wc_prop_list2(&props, wc_ctx, local_abspath, scratch_pool,
scratch_pool));
SVN_ERR(svn_wc_status3(&status, wc_ctx, local_abspath, scratch_pool,
scratch_pool));
if (status->text_status != svn_wc_status_normal)
local_mod = TRUE;
}
eol_style = apr_hash_get(props, SVN_PROP_EOL_STYLE,
APR_HASH_KEY_STRING);
keywords = apr_hash_get(props, SVN_PROP_KEYWORDS,
APR_HASH_KEY_STRING);
special = apr_hash_get(props, SVN_PROP_SPECIAL,
APR_HASH_KEY_STRING);
if (eol_style)
svn_subst_eol_style_from_value(&style, &eol, eol_style->data);
if (local_mod && (! special))
{
/* Use the modified time from the working copy if
the file */
SVN_ERR(svn_io_file_affected_time(&tm, local_abspath, scratch_pool));
}
else
{
SVN_ERR(svn_wc__node_get_changed_info(NULL, &tm, NULL, wc_ctx,
local_abspath, scratch_pool,
scratch_pool));
}
if (keywords)
{
svn_revnum_t changed_rev;
const char *rev_str;
const char *author;
const char *url;
SVN_ERR(svn_wc__node_get_changed_info(&changed_rev, NULL, &author, wc_ctx,
local_abspath, scratch_pool,
scratch_pool));
SVN_ERR(svn_wc__node_get_url(&url, wc_ctx, local_abspath, scratch_pool,
scratch_pool));
if (local_mod)
{
/* For locally modified files, we'll append an 'M'
to the revision number, and set the author to
"(local)" since we can't always determine the
current user's username */
rev_str = apr_psprintf(scratch_pool, "%ldM", changed_rev);
author = _("(local)");
}
else
{
rev_str = apr_psprintf(scratch_pool, "%ld", changed_rev);
}
SVN_ERR(svn_subst_build_keywords2(&kw, keywords->data, rev_str, url, tm,
author, scratch_pool));
}
/* Wrap the output stream if translation is needed. */
if (eol != NULL || kw != NULL)
input = svn_subst_stream_translated(
input,
(eol_style && normalize_eols) ? SVN_SUBST_NATIVE_EOL_STR : eol,
FALSE, kw, expand_keywords, result_pool);
*normal_stream = input;
return SVN_NO_ERROR;
}
