/* Compare a file being deleted against an empty file.
*/
static svn_error_t *
diff_deleted_file(svn_wc_notify_state_t *state_p,
svn_boolean_t *tree_conflicted_p,
const char *path,
struct edit_baton *eb,
apr_pool_t *scratch_pool)
{
struct file_baton *b = make_file_baton(path, FALSE, eb, scratch_pool);
/* struct edit_baton *eb = b->edit_baton;*/
const char *mimetype1, *mimetype2;
if (eb->cancel_func)
SVN_ERR(eb->cancel_func(eb->cancel_baton));
if (eb->text_deltas)
SVN_ERR(get_file_from_ra(b, FALSE, scratch_pool));
else
SVN_ERR(get_empty_file(eb, &b->path_start_revision));
SVN_ERR(get_empty_file(eb, &b->path_end_revision));
get_file_mime_types(&mimetype1, &mimetype2, b);
SVN_ERR(eb->diff_callbacks->file_deleted(state_p, tree_conflicted_p,
b->path,
b->path_start_revision,
b->path_end_revision,
mimetype1, mimetype2,
b->pristine_props,
eb->diff_cmd_baton,
scratch_pool));
return SVN_NO_ERROR;
}
long sys_pipe(int *read_end, int *write_end, int flags)
{
if (vm_verify(¤t->mm, read_end, sizeof(*read_end), VM_WRITE))
return -EFAULT;
if (vm_verify(¤t->mm, write_end, sizeof(*write_end), VM_WRITE))
return -EFAULT;
int read_fd, write_fd;
struct file *read_file = get_empty_file();
struct file *write_file = get_empty_file();
struct pipe_private *pipe = slab_alloc(pipe_cachep);
if ((read_fd = get_fd(current, 0)) < 0)
return read_fd;
current->filp[read_fd] = read_file;
if ((write_fd = get_fd(current, 0)) < 0) {
current->filp[read_fd] = NULL;
return write_fd;
}
current->filp[write_fd] = write_file;
INIT_WAIT_QUEUE(&pipe->read_wait);
INIT_WAIT_QUEUE(&pipe->write_wait);
pipe->read_end = read_file;
pipe->write_end = write_file;
pipe->buf = flexbuf_alloc(0);
read_file->f_inode = write_file->f_inode = NULL;
read_file->f_flags = write_file->f_flags = flags;
read_file->f_rdev = write_file->f_rdev = 0;
read_file->f_mode = O_READ;
read_file->f_op = &pipe_read_operations;
read_file->f_private = pipe;
write_file->f_mode = O_WRITE;
write_file->f_op = &pipe_write_operations;
write_file->f_private = pipe;
current->filp[read_fd] = read_file;
current->filp[write_fd] = write_file;
*read_end = read_fd;
*write_end = write_fd;
return 0;
}
/* 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;
}
/* An svn_delta_editor_t function. */
static svn_error_t *
apply_textdelta(void *file_baton,
const char *base_md5_digest,
apr_pool_t *pool,
svn_txdelta_window_handler_t *handler,
void **handler_baton)
{
struct file_baton *b = file_baton;
svn_stream_t *src_stream;
svn_stream_t *result_stream;
apr_pool_t *scratch_pool = b->pool;
/* Skip *everything* within a newly tree-conflicted directory. */
if (b->skip)
{
*handler = svn_delta_noop_window_handler;
*handler_baton = NULL;
return SVN_NO_ERROR;
}
/* If we're not sending file text, then ignore any that we receive. */
if (! b->edit_baton->text_deltas)
{
/* Supply valid paths to indicate there is a text change. */
SVN_ERR(get_empty_file(b->edit_baton, &b->path_start_revision));
SVN_ERR(get_empty_file(b->edit_baton, &b->path_end_revision));
*handler = svn_delta_noop_window_handler;
*handler_baton = NULL;
return SVN_NO_ERROR;
}
/* We need the expected pristine file, so go get it */
if (!b->added)
SVN_ERR(get_file_from_ra(b, FALSE, scratch_pool));
else
SVN_ERR(get_empty_file(b->edit_baton, &(b->path_start_revision)));
SVN_ERR_ASSERT(b->path_start_revision != NULL);
if (base_md5_digest != NULL)
{
svn_checksum_t *base_md5_checksum;
SVN_ERR(svn_checksum_parse_hex(&base_md5_checksum, svn_checksum_md5,
base_md5_digest, scratch_pool));
if (!svn_checksum_match(base_md5_checksum, b->start_md5_checksum))
return svn_error_trace(svn_checksum_mismatch_err(
base_md5_checksum,
b->start_md5_checksum,
scratch_pool,
_("Base checksum mismatch for '%s'"),
b->path));
}
/* Open the file to be used as the base for second revision */
SVN_ERR(svn_stream_open_readonly(&src_stream, b->path_start_revision,
scratch_pool, scratch_pool));
/* Open the file that will become the second revision after applying the
text delta, it starts empty */
SVN_ERR(svn_stream_open_unique(&result_stream, &b->path_end_revision, NULL,
svn_io_file_del_on_pool_cleanup,
scratch_pool, scratch_pool));
svn_txdelta_apply(src_stream,
result_stream,
b->result_digest,
b->path, b->pool,
&(b->apply_handler), &(b->apply_baton));
*handler = window_handler;
*handler_baton = file_baton;
return SVN_NO_ERROR;
}