/* Do a modifed check for LOCAL_ABSPATH, and all working children, to force
timestamp repair. */
static svn_error_t *
repair_timestamps(svn_wc__db_t *db,
const char *local_abspath,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *scratch_pool)
{
svn_kind_t kind;
svn_wc__db_status_t status;
if (cancel_func)
SVN_ERR(cancel_func(cancel_baton));
SVN_ERR(svn_wc__db_read_info(&status, &kind,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL,
db, local_abspath, scratch_pool, scratch_pool));
if (status == svn_wc__db_status_server_excluded
|| status == svn_wc__db_status_deleted
|| status == svn_wc__db_status_excluded
|| status == svn_wc__db_status_not_present)
return SVN_NO_ERROR;
if (kind == svn_kind_file
|| kind == svn_kind_symlink)
{
svn_boolean_t modified;
SVN_ERR(svn_wc__internal_file_modified_p(&modified,
db, local_abspath, FALSE,
scratch_pool));
}
else if (kind == svn_kind_dir)
{
apr_pool_t *iterpool = svn_pool_create(scratch_pool);
const apr_array_header_t *children;
int i;
SVN_ERR(svn_wc__db_read_children_of_working_node(&children, db,
local_abspath,
scratch_pool,
iterpool));
for (i = 0; i < children->nelts; ++i)
{
const char *child_abspath;
svn_pool_clear(iterpool);
child_abspath = svn_dirent_join(local_abspath,
APR_ARRAY_IDX(children, i,
const char *),
iterpool);
SVN_ERR(repair_timestamps(db, child_abspath,
cancel_func, cancel_baton, iterpool));
}
svn_pool_destroy(iterpool);
}
/* Diff the file PATH against its text base. At this
* stage we are dealing with a file that does exist in the working copy.
*
* DIR_BATON is the parent directory baton, PATH is the path to the file to
* be compared.
*
* Do all allocation in POOL.
*
* ### TODO: Need to work on replace if the new filename used to be a
* directory.
*/
static svn_error_t *
file_diff(struct diff_baton *eb,
const char *local_abspath,
const char *path,
apr_pool_t *scratch_pool)
{
svn_wc__db_t *db = eb->db;
const char *empty_file;
const char *original_repos_relpath;
svn_wc__db_status_t status;
svn_kind_t kind;
svn_revnum_t revision;
const svn_checksum_t *checksum;
svn_boolean_t op_root;
svn_boolean_t had_props, props_mod;
svn_boolean_t have_base, have_more_work;
svn_boolean_t replaced = FALSE;
svn_boolean_t base_replace = FALSE;
svn_wc__db_status_t base_status;
svn_revnum_t base_revision = SVN_INVALID_REVNUM;
const svn_checksum_t *base_checksum;
const char *pristine_abspath;
SVN_ERR(svn_wc__db_read_info(&status, &kind, &revision, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, &checksum, NULL,
&original_repos_relpath, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, NULL,
&op_root, &had_props, &props_mod,
&have_base, &have_more_work, NULL,
db, local_abspath, scratch_pool, scratch_pool));
if ((status == svn_wc__db_status_added) && (have_base || have_more_work))
{
SVN_ERR(svn_wc__db_node_check_replace(&replaced, &base_replace,
NULL, db, local_abspath,
scratch_pool));
if (replaced && base_replace /* && !have_more_work */)
{
svn_kind_t base_kind;
SVN_ERR(svn_wc__db_base_get_info(&base_status, &base_kind,
&base_revision,
NULL, NULL, NULL, NULL, NULL, NULL,
NULL, &base_checksum, NULL,
NULL, NULL, NULL,
db, local_abspath,
scratch_pool, scratch_pool));
if (base_status != svn_wc__db_status_normal
|| base_kind != kind)
{
/* We can't show a replacement here */
replaced = FALSE;
base_replace = FALSE;
}
}
else
{
/* We can't look in this middle working layer (yet).
We just report the change itself.
And if we could look at it, how would we report the addition
of this middle layer (and maybe different layers below that)?
For 1.7 we just do what we did before: Ignore this layering
problem and just show how the current file got in your wc.
*/
replaced = FALSE;
base_replace = FALSE;
}
}
/* Now refine ADDED to one of: ADDED, COPIED, MOVED_HERE. Note that only
the latter two have corresponding pristine info to diff against. */
if (status == svn_wc__db_status_added)
SVN_ERR(svn_wc__db_scan_addition(&status, NULL, NULL, NULL, NULL,
&original_repos_relpath, NULL, NULL,
NULL, NULL, NULL, db, local_abspath,
scratch_pool, scratch_pool));
SVN_ERR(get_empty_file(eb, &empty_file, scratch_pool));
/* When we show a delete, we show a diff of the original pristine against
* an empty file.
* A base-replace is treated like a delete plus an add.
*
* For this kind of diff we prefer to show the deletion of what was checked
* out over showing what was actually deleted (if that was defined by
* a higher layer). */
if (status == svn_wc__db_status_deleted ||
(base_replace && ! eb->ignore_ancestry))
{
apr_hash_t *del_props;
const svn_checksum_t *del_checksum;
const char *del_text_abspath;
const char *del_mimetype;
if (base_replace && ! eb->ignore_ancestry)
{
/* We show a deletion of the information in the BASE layer */
SVN_ERR(svn_wc__db_base_get_props(&del_props, db, local_abspath,
scratch_pool, scratch_pool));
del_checksum = base_checksum;
}
else
{
/* We show a deletion of what was actually deleted */
SVN_ERR_ASSERT(status == svn_wc__db_status_deleted);
SVN_ERR(svn_wc__get_pristine_props(&del_props, db, local_abspath,
scratch_pool, scratch_pool));
SVN_ERR(svn_wc__db_read_pristine_info(NULL, NULL, NULL, NULL, NULL,
NULL, &del_checksum, NULL,
NULL, db, local_abspath,
scratch_pool, scratch_pool));
}
SVN_ERR_ASSERT(del_checksum != NULL);
SVN_ERR(svn_wc__db_pristine_get_path(&del_text_abspath, db,
local_abspath, del_checksum,
scratch_pool, scratch_pool));
if (del_props == NULL)
del_props = apr_hash_make(scratch_pool);
del_mimetype = get_prop_mimetype(del_props);
SVN_ERR(eb->callbacks->file_deleted(NULL, NULL, path,
del_text_abspath,
empty_file,
del_mimetype,
NULL,
del_props,
eb->callback_baton,
scratch_pool));
if (status == svn_wc__db_status_deleted)
{
/* We're here only for showing a delete, so we're done. */
return SVN_NO_ERROR;
}
}
if (checksum != NULL)
SVN_ERR(svn_wc__db_pristine_get_path(&pristine_abspath, db, local_abspath,
checksum,
scratch_pool, scratch_pool));
else if (base_replace && eb->ignore_ancestry)
SVN_ERR(svn_wc__db_pristine_get_path(&pristine_abspath, db, local_abspath,
base_checksum,
scratch_pool, scratch_pool));
else
pristine_abspath = empty_file;
/* Now deal with showing additions, or the add-half of replacements.
* If the item is schedule-add *with history*, then we usually want
* to see the usual working vs. text-base comparison, which will show changes
* made since the file was copied. But in case we're showing copies as adds,
* we need to compare the copied file to the empty file. If we're doing a git
* diff, and the file was copied, we need to report the file as added and
* diff it against the text base, so that a "copied" git diff header, and
* possibly a diff against the copy source, will be generated for it. */
if ((! base_replace && status == svn_wc__db_status_added) ||
(base_replace && ! eb->ignore_ancestry) ||
((status == svn_wc__db_status_copied ||
status == svn_wc__db_status_moved_here) &&
(eb->show_copies_as_adds || eb->use_git_diff_format)))
{
const char *translated = NULL;
apr_hash_t *pristine_props;
apr_hash_t *actual_props;
const char *actual_mimetype;
apr_array_header_t *propchanges;
/* Get svn:mime-type from ACTUAL props of PATH. */
SVN_ERR(svn_wc__get_actual_props(&actual_props, db, local_abspath,
scratch_pool, scratch_pool));
actual_mimetype = get_prop_mimetype(actual_props);
/* Set the original properties to empty, then compute "changes" from
that. Essentially, all ACTUAL props will be "added". */
pristine_props = apr_hash_make(scratch_pool);
SVN_ERR(svn_prop_diffs(&propchanges, actual_props, pristine_props,
scratch_pool));
SVN_ERR(svn_wc__internal_translated_file(
&translated, local_abspath, db, local_abspath,
SVN_WC_TRANSLATE_TO_NF | SVN_WC_TRANSLATE_USE_GLOBAL_TMP,
eb->cancel_func, eb->cancel_baton,
scratch_pool, scratch_pool));
SVN_ERR(eb->callbacks->file_added(NULL, NULL, NULL, path,
(! eb->show_copies_as_adds &&
eb->use_git_diff_format &&
status != svn_wc__db_status_added) ?
pristine_abspath : empty_file,
translated,
0, revision,
NULL,
actual_mimetype,
original_repos_relpath,
SVN_INVALID_REVNUM, propchanges,
pristine_props, eb->callback_baton,
scratch_pool));
}
else
{
const char *translated = NULL;
apr_hash_t *pristine_props;
const char *pristine_mimetype;
const char *actual_mimetype;
apr_hash_t *actual_props;
apr_array_header_t *propchanges;
svn_boolean_t modified;
/* Here we deal with showing pure modifications. */
SVN_ERR(svn_wc__internal_file_modified_p(&modified, db, local_abspath,
FALSE, scratch_pool));
if (modified)
{
/* Note that this might be the _second_ time we translate
the file, as svn_wc__text_modified_internal_p() might have used a
tmp translated copy too. But what the heck, diff is
already expensive, translating twice for the sake of code
modularity is liveable. */
SVN_ERR(svn_wc__internal_translated_file(
&translated, local_abspath, db, local_abspath,
SVN_WC_TRANSLATE_TO_NF | SVN_WC_TRANSLATE_USE_GLOBAL_TMP,
eb->cancel_func, eb->cancel_baton,
scratch_pool, scratch_pool));
}
/* Get the properties, the svn:mime-type values, and compute the
differences between the two. */
if (base_replace
&& eb->ignore_ancestry)
{
/* We don't want the normal pristine properties (which are
from the WORKING tree). We want the pristines associated
with the BASE tree, which are saved as "revert" props. */
SVN_ERR(svn_wc__db_base_get_props(&pristine_props,
db, local_abspath,
scratch_pool, scratch_pool));
}
else
{
/* We can only fetch the pristine props (from BASE or WORKING) if
the node has not been replaced, or it was copied/moved here. */
SVN_ERR_ASSERT(!replaced
|| status == svn_wc__db_status_copied
|| status == svn_wc__db_status_moved_here);
SVN_ERR(svn_wc__db_read_pristine_props(&pristine_props, db,
local_abspath,
scratch_pool, scratch_pool));
/* baseprops will be NULL for added nodes */
if (!pristine_props)
pristine_props = apr_hash_make(scratch_pool);
}
pristine_mimetype = get_prop_mimetype(pristine_props);
SVN_ERR(svn_wc__db_read_props(&actual_props, db, local_abspath,
scratch_pool, scratch_pool));
actual_mimetype = get_prop_mimetype(actual_props);
SVN_ERR(svn_prop_diffs(&propchanges, actual_props, pristine_props,
scratch_pool));
if (modified || propchanges->nelts > 0)
{
SVN_ERR(eb->callbacks->file_changed(NULL, NULL, NULL,
path,
modified ? pristine_abspath
: NULL,
translated,
revision,
SVN_INVALID_REVNUM,
pristine_mimetype,
actual_mimetype,
propchanges,
pristine_props,
eb->callback_baton,
scratch_pool));
}
}
return SVN_NO_ERROR;
}
/* Make a copy of the filesystem node (or tree if RECURSIVE) at
SRC_ABSPATH under a temporary name in the directory
TMPDIR_ABSPATH and return the absolute path of the copy in
*DST_ABSPATH. Return the node kind of SRC_ABSPATH in *KIND. If
SRC_ABSPATH doesn't exist then set *DST_ABSPATH to NULL to indicate
that no copy was made. */
static svn_error_t *
copy_to_tmpdir(svn_skel_t **work_item,
svn_node_kind_t *kind,
svn_wc__db_t *db,
const char *src_abspath,
const char *dst_abspath,
const char *tmpdir_abspath,
svn_boolean_t file_copy,
svn_boolean_t unversioned,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_boolean_t is_special;
svn_io_file_del_t delete_when;
const char *dst_tmp_abspath;
svn_node_kind_t dsk_kind;
if (!kind)
kind = &dsk_kind;
*work_item = NULL;
SVN_ERR(svn_io_check_special_path(src_abspath, kind, &is_special,
scratch_pool));
if (*kind == svn_node_none)
{
return SVN_NO_ERROR;
}
else if (*kind == svn_node_unknown)
{
return svn_error_createf(SVN_ERR_NODE_UNEXPECTED_KIND, NULL,
_("Source '%s' is unexpected kind"),
svn_dirent_local_style(src_abspath,
scratch_pool));
}
else if (*kind == svn_node_dir || is_special)
delete_when = svn_io_file_del_on_close;
else /* the default case: (*kind == svn_node_file) */
delete_when = svn_io_file_del_none;
/* ### Do we need a pool cleanup to remove the copy? We can't use
### svn_io_file_del_on_pool_cleanup above because a) it won't
### handle the directory case and b) we need to be able to remove
### the cleanup before queueing the move work item. */
if (file_copy && !unversioned)
{
svn_boolean_t modified;
/* It's faster to look for mods on the source now, as
the timestamp might match, than to examine the
destination later as the destination timestamp will
never match. */
SVN_ERR(svn_wc__internal_file_modified_p(&modified,
db, src_abspath,
FALSE, scratch_pool));
if (!modified)
{
/* Why create a temp copy if we can just reinstall from pristine? */
SVN_ERR(svn_wc__wq_build_file_install(work_item,
db, dst_abspath, NULL, FALSE,
TRUE,
result_pool, scratch_pool));
return SVN_NO_ERROR;
}
}
/* Set DST_TMP_ABSPATH to a temporary unique path. If *KIND is file, leave
a file there and then overwrite it; otherwise leave no node on disk at
that path. In the latter case, something else might use that path
before we get around to using it a moment later, but never mind. */
SVN_ERR(svn_io_open_unique_file3(NULL, &dst_tmp_abspath, tmpdir_abspath,
delete_when, scratch_pool, scratch_pool));
if (*kind == svn_node_dir)
{
if (file_copy)
SVN_ERR(svn_io_copy_dir_recursively(
src_abspath,
tmpdir_abspath,
svn_dirent_basename(dst_tmp_abspath, scratch_pool),
TRUE, /* copy_perms */
cancel_func, cancel_baton,
scratch_pool));
else
SVN_ERR(svn_io_dir_make(dst_tmp_abspath, APR_OS_DEFAULT, scratch_pool));
}
else if (!is_special)
SVN_ERR(svn_io_copy_file(src_abspath, dst_tmp_abspath,
TRUE /* copy_perms */,
scratch_pool));
else
SVN_ERR(svn_io_copy_link(src_abspath, dst_tmp_abspath, scratch_pool));
if (file_copy)
{
/* Remove 'read-only' from the destination file; it's a local add now. */
SVN_ERR(svn_io_set_file_read_write(dst_tmp_abspath,
FALSE, scratch_pool));
}
SVN_ERR(svn_wc__wq_build_file_move(work_item, db, dst_abspath,
dst_tmp_abspath, dst_abspath,
result_pool, scratch_pool));
return SVN_NO_ERROR;
}
