svn_error_t *
svn_repos_get_commit_editor5(const svn_delta_editor_t **editor,
void **edit_baton,
svn_repos_t *repos,
svn_fs_txn_t *txn,
const char *repos_url,
const char *base_path,
apr_hash_t *revprop_table,
svn_commit_callback2_t commit_callback,
void *commit_baton,
svn_repos_authz_callback_t authz_callback,
void *authz_baton,
apr_pool_t *pool)
{
svn_delta_editor_t *e;
apr_pool_t *subpool = svn_pool_create(pool);
struct edit_baton *eb;
svn_delta_shim_callbacks_t *shim_callbacks =
svn_delta_shim_callbacks_default(pool);
/* Do a global authz access lookup. Users with no write access
whatsoever to the repository don't get a commit editor. */
if (authz_callback)
{
svn_boolean_t allowed;
SVN_ERR(authz_callback(svn_authz_write, &allowed, NULL, NULL,
authz_baton, pool));
if (!allowed)
return svn_error_create(SVN_ERR_AUTHZ_UNWRITABLE, NULL,
"Not authorized to open a commit editor.");
}
/* Allocate the structures. */
e = svn_delta_default_editor(pool);
eb = apr_pcalloc(subpool, sizeof(*eb));
/* Set up the editor. */
e->open_root = open_root;
e->delete_entry = delete_entry;
e->add_directory = add_directory;
e->open_directory = open_directory;
e->change_dir_prop = change_dir_prop;
e->add_file = add_file;
e->open_file = open_file;
e->close_file = close_file;
e->apply_textdelta = apply_textdelta;
e->change_file_prop = change_file_prop;
e->close_edit = close_edit;
e->abort_edit = abort_edit;
/* Set up the edit baton. */
eb->pool = subpool;
eb->revprop_table = svn_prop_hash_dup(revprop_table, subpool);
eb->commit_callback = commit_callback;
eb->commit_callback_baton = commit_baton;
eb->authz_callback = authz_callback;
eb->authz_baton = authz_baton;
eb->base_path = svn_fspath__canonicalize(base_path, subpool);
eb->repos = repos;
eb->repos_url = repos_url;
eb->repos_name = svn_dirent_basename(svn_repos_path(repos, subpool),
subpool);
eb->fs = svn_repos_fs(repos);
eb->txn = txn;
eb->txn_owner = txn == NULL;
*edit_baton = eb;
*editor = e;
shim_callbacks->fetch_props_func = fetch_props_func;
shim_callbacks->fetch_kind_func = fetch_kind_func;
shim_callbacks->fetch_base_func = fetch_base_func;
shim_callbacks->fetch_baton = eb;
SVN_ERR(svn_editor__insert_shims(editor, edit_baton, *editor, *edit_baton,
eb->repos_url, eb->base_path,
shim_callbacks, pool, pool));
return SVN_NO_ERROR;
}
int
main (int argc, const char **argv)
{
apr_pool_t *pool;
svn_error_t *err;
const char *URL;
svn_ra_session_t *session;
svn_ra_callbacks2_t *cbtable;
svn_revnum_t rev;
apr_hash_t *cfg_hash;
svn_auth_baton_t *auth_baton;
if (argc <= 1)
{
printf ("Usage: %s URL\n", argv[0]);
printf (" Print HEAD revision of URL's repository.\n");
return EXIT_FAILURE;
}
else
URL = argv[1];
/* Initialize the app. Send all error messages to 'stderr'. */
if (svn_cmdline_init ("headrev", stderr) != EXIT_SUCCESS)
return EXIT_FAILURE;
/* Create top-level memory pool. Be sure to read the HACKING file to
understand how to properly use/free subpools. */
pool = svn_pool_create (NULL);
/* Initialize the FS library. */
err = svn_fs_initialize (pool);
if (err) goto hit_error;
/* Make sure the ~/.subversion run-time config files exist, and load. */
err = svn_config_ensure (NULL, pool);
if (err) goto hit_error;
err = svn_config_get_config (&cfg_hash, NULL, pool);
if (err) goto hit_error;
/* Build an authentication baton. */
{
/* There are many different kinds of authentication back-end
"providers". See svn_auth.h for a full overview. */
svn_auth_provider_object_t *provider;
apr_array_header_t *providers
= apr_array_make (pool, 4, sizeof (svn_auth_provider_object_t *));
svn_client_get_simple_prompt_provider (&provider,
my_simple_prompt_callback,
NULL, /* baton */
2, /* retry limit */ pool);
APR_ARRAY_PUSH (providers, svn_auth_provider_object_t *) = provider;
svn_client_get_username_prompt_provider (&provider,
my_username_prompt_callback,
NULL, /* baton */
2, /* retry limit */ pool);
APR_ARRAY_PUSH (providers, svn_auth_provider_object_t *) = provider;
/* Register the auth-providers into the context's auth_baton. */
svn_auth_open (&auth_baton, providers, pool);
}
/* Create a table of callbacks for the RA session, mostly nonexistent. */
cbtable = apr_pcalloc (pool, sizeof(*cbtable));
cbtable->auth_baton = auth_baton;
cbtable->open_tmp_file = open_tmp_file;
/* Now do the real work. */
err = svn_ra_open2(&session, URL, cbtable, NULL, cfg_hash, pool);
if (err) goto hit_error;
err = svn_ra_get_latest_revnum(session, &rev, pool);
if (err) goto hit_error;
printf ("The latest revision is %ld.\n", rev);
return EXIT_SUCCESS;
hit_error:
svn_handle_error2 (err, stderr, FALSE, "headrev: ");
return EXIT_FAILURE;
}
/* This implements the `svn_opt_subcommand_t' interface. */
svn_error_t *
svn_cl__null_list(apr_getopt_t *os,
void *baton,
apr_pool_t *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;
apr_array_header_t *targets;
int i;
apr_pool_t *subpool = svn_pool_create(pool);
apr_uint32_t dirent_fields;
struct print_baton pb = { FALSE };
svn_boolean_t seen_nonexistent_target = FALSE;
svn_error_t *err;
SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os,
opt_state->targets,
ctx, FALSE, pool));
/* Add "." if user passed 0 arguments */
svn_opt_push_implicit_dot_target(targets, pool);
if (opt_state->verbose)
dirent_fields = SVN_DIRENT_ALL;
else
dirent_fields = SVN_DIRENT_KIND; /* the only thing we actually need... */
pb.ctx = ctx;
pb.verbose = opt_state->verbose;
if (opt_state->depth == svn_depth_unknown)
opt_state->depth = svn_depth_immediates;
/* For each target, try to list it. */
for (i = 0; i < targets->nelts; i++)
{
const char *target = APR_ARRAY_IDX(targets, i, const char *);
const char *truepath;
svn_opt_revision_t peg_revision;
svn_pool_clear(subpool);
SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton));
/* Get peg revisions. */
SVN_ERR(svn_opt_parse_path(&peg_revision, &truepath, target,
subpool));
err = svn_client_list3(truepath, &peg_revision,
&(opt_state->start_revision),
opt_state->depth,
dirent_fields,
opt_state->verbose,
FALSE, /* include externals */
print_dirent,
&pb, ctx, subpool);
if (err)
{
/* If one of the targets is a non-existent URL or wc-entry,
don't bail out. Just warn and move on to the next target. */
if (err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND ||
err->apr_err == SVN_ERR_FS_NOT_FOUND)
svn_handle_warning2(stderr, err, "svnbench: ");
else
return svn_error_trace(err);
svn_error_clear(err);
err = NULL;
seen_nonexistent_target = TRUE;
}
else if (!opt_state->quiet)
SVN_ERR(svn_cmdline_printf(pool,
_("%15s directories\n"
"%15s files\n"
"%15s locks\n"),
svn__ui64toa_sep(pb.directories, ',', pool),
svn__ui64toa_sep(pb.files, ',', pool),
svn__ui64toa_sep(pb.locks, ',', pool)));
}
svn_pool_destroy(subpool);
if (seen_nonexistent_target)
return svn_error_create(
SVN_ERR_ILLEGAL_TARGET, NULL,
_("Could not list all targets because some targets don't exist"));
else
return SVN_NO_ERROR;
}
svn_error_t *
svn_ra_neon__do_proppatch(svn_ra_neon__session_t *ras,
const char *url,
apr_hash_t *prop_changes,
apr_array_header_t *prop_deletes,
apr_hash_t *extra_headers,
apr_pool_t *pool)
{
svn_error_t *err;
svn_stringbuf_t *body;
apr_pool_t *subpool = svn_pool_create(pool);
/* just punt if there are no changes to make. */
if ((prop_changes == NULL || (! apr_hash_count(prop_changes)))
&& (prop_deletes == NULL || prop_deletes->nelts == 0))
return SVN_NO_ERROR;
/* easier to roll our own PROPPATCH here than use ne_proppatch(), which
* doesn't really do anything clever. */
body = svn_stringbuf_create
("<?xml version=\"1.0\" encoding=\"utf-8\" ?>" DEBUG_CR
"<D:propertyupdate xmlns:D=\"DAV:\" xmlns:V=\""
SVN_DAV_PROP_NS_DAV "\" xmlns:C=\""
SVN_DAV_PROP_NS_CUSTOM "\" xmlns:S=\""
SVN_DAV_PROP_NS_SVN "\">" DEBUG_CR, pool);
/* Handle property changes. */
if (prop_changes)
{
apr_hash_index_t *hi;
svn_stringbuf_appendcstr(body, "<D:set><D:prop>");
for (hi = apr_hash_first(pool, prop_changes); hi; hi = apr_hash_next(hi))
{
const void *key;
void *val;
svn_pool_clear(subpool);
apr_hash_this(hi, &key, NULL, &val);
append_setprop(body, key, val, subpool);
}
svn_stringbuf_appendcstr(body, "</D:prop></D:set>");
}
/* Handle property deletions. */
if (prop_deletes)
{
int n;
svn_stringbuf_appendcstr(body, "<D:remove><D:prop>");
for (n = 0; n < prop_deletes->nelts; n++)
{
const char *name = APR_ARRAY_IDX(prop_deletes, n, const char *);
svn_pool_clear(subpool);
append_setprop(body, name, NULL, subpool);
}
svn_stringbuf_appendcstr(body, "</D:prop></D:remove>");
}
svn_pool_destroy(subpool);
/* Finish up the body. */
svn_stringbuf_appendcstr(body, "</D:propertyupdate>");
/* Finish up the headers. */
if (! extra_headers)
extra_headers = apr_hash_make(pool);
apr_hash_set(extra_headers, "Content-Type", APR_HASH_KEY_STRING,
"text/xml; charset=UTF-8");
err = svn_ra_neon__simple_request(NULL, ras, "PROPPATCH", url,
extra_headers, body->data,
200, 207, pool);
if (err)
return svn_error_create
(SVN_ERR_RA_DAV_PROPPATCH_FAILED, err,
_("At least one property change failed; repository is unchanged"));
return SVN_NO_ERROR;
}
svn_error_t *
svn_ra_neon__search_for_starting_props(svn_ra_neon__resource_t **rsrc,
const char **missing_path,
svn_ra_neon__session_t *sess,
const char *url,
apr_pool_t *pool)
{
svn_error_t *err = SVN_NO_ERROR;
apr_size_t len;
svn_stringbuf_t *path_s;
ne_uri parsed_url;
svn_stringbuf_t *lopped_path =
svn_stringbuf_create(url, pool); /* initialize to make sure it'll fit
without reallocating */
apr_pool_t *iterpool = svn_pool_create(pool);
/* Split the url into its component pieces (scheme, host, path,
etc). We want the path part. */
ne_uri_parse(url, &parsed_url);
if (parsed_url.path == NULL)
{
ne_uri_free(&parsed_url);
return svn_error_createf(SVN_ERR_RA_ILLEGAL_URL, NULL,
_("Neon was unable to parse URL '%s'"), url);
}
svn_stringbuf_setempty(lopped_path);
path_s = svn_stringbuf_create(parsed_url.path, pool);
ne_uri_free(&parsed_url);
/* Try to get the starting_props from the public url. If the
resource no longer exists in HEAD, we'll get a failure. That's
fine: just keep removing components and trying to get the
starting_props from parent directories. */
while (! svn_path_is_empty(path_s->data))
{
svn_pool_clear(iterpool);
err = svn_ra_neon__get_starting_props(rsrc, sess, path_s->data,
NULL, iterpool);
if (! err)
break; /* found an existing parent! */
if (err->apr_err != SVN_ERR_FS_NOT_FOUND)
return err; /* found a _real_ error */
/* else... lop off the basename and try again. */
svn_stringbuf_set(lopped_path,
svn_path_join(svn_path_basename(path_s->data, iterpool),
lopped_path->data, iterpool));
len = path_s->len;
svn_path_remove_component(path_s);
/* if we detect an infinite loop, get out. */
if (path_s->len == len)
return svn_error_quick_wrap
(err, _("The path was not part of a repository"));
svn_error_clear(err);
}
/* error out if entire URL was bogus (not a single part of it exists
in the repository!) */
if (svn_path_is_empty(path_s->data))
return svn_error_createf(SVN_ERR_RA_ILLEGAL_URL, NULL,
_("No part of path '%s' was found in "
"repository HEAD"), parsed_url.path);
/* Duplicate rsrc out of iterpool into pool */
{
apr_hash_index_t *hi;
svn_ra_neon__resource_t *tmp = apr_pcalloc(pool, sizeof(*tmp));
tmp->url = apr_pstrdup(pool, (*rsrc)->url);
tmp->is_collection = (*rsrc)->is_collection;
tmp->pool = pool;
tmp->propset = apr_hash_make(pool);
for (hi = apr_hash_first(iterpool, (*rsrc)->propset);
hi; hi = apr_hash_next(hi))
{
const void *key;
void *val;
apr_hash_this(hi, &key, NULL, &val);
apr_hash_set(tmp->propset, apr_pstrdup(pool, key), APR_HASH_KEY_STRING,
svn_string_dup(val, pool));
}
*rsrc = tmp;
}
*missing_path = lopped_path->data;
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
/* Return the next *HUNK from a PATCH in APR_FILE.
* If no hunk can be found, set *HUNK to NULL.
* Set IS_PROPERTY to TRUE if we have a property hunk. If the returned HUNK
* is the first belonging to a certain property, then PROP_NAME and
* PROP_OPERATION will be set too. If we have a text hunk, PROP_NAME will be
* NULL. If IGNORE_WHITESPACE is TRUE, lines without leading spaces will be
* treated as context lines. Allocate results in RESULT_POOL.
* Use SCRATCH_POOL for all other allocations. */
static svn_error_t *
parse_next_hunk(svn_diff_hunk_t **hunk,
svn_boolean_t *is_property,
const char **prop_name,
svn_diff_operation_kind_t *prop_operation,
svn_patch_t *patch,
apr_file_t *apr_file,
svn_boolean_t ignore_whitespace,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
static const char * const minus = "--- ";
static const char * const text_atat = "@@";
static const char * const prop_atat = "##";
svn_stringbuf_t *line;
svn_boolean_t eof, in_hunk, hunk_seen;
apr_off_t pos, last_line;
apr_off_t start, end;
apr_off_t original_end;
apr_off_t modified_end;
svn_linenum_t original_lines;
svn_linenum_t modified_lines;
svn_linenum_t leading_context;
svn_linenum_t trailing_context;
svn_boolean_t changed_line_seen;
enum {
noise_line,
original_line,
modified_line,
context_line
} last_line_type;
apr_pool_t *iterpool;
*prop_operation = svn_diff_op_unchanged;
/* We only set this if we have a property hunk header. */
*prop_name = NULL;
*is_property = FALSE;
if (apr_file_eof(apr_file) == APR_EOF)
{
/* No more hunks here. */
*hunk = NULL;
return SVN_NO_ERROR;
}
in_hunk = FALSE;
hunk_seen = FALSE;
leading_context = 0;
trailing_context = 0;
changed_line_seen = FALSE;
original_end = 0;
modified_end = 0;
*hunk = apr_pcalloc(result_pool, sizeof(**hunk));
/* Get current seek position -- APR has no ftell() :( */
pos = 0;
SVN_ERR(svn_io_file_seek(apr_file, APR_CUR, &pos, scratch_pool));
/* Start out assuming noise. */
last_line_type = noise_line;
iterpool = svn_pool_create(scratch_pool);
do
{
svn_pool_clear(iterpool);
/* Remember the current line's offset, and read the line. */
last_line = pos;
SVN_ERR(readline(apr_file, &line, NULL, &eof, APR_SIZE_MAX,
iterpool, iterpool));
/* Update line offset for next iteration. */
pos = 0;
SVN_ERR(svn_io_file_seek(apr_file, APR_CUR, &pos, iterpool));
/* Lines starting with a backslash are comments, such as
* "\ No newline at end of file". */
if (line->data[0] == '\\')
{
if (in_hunk &&
((!*is_property &&
strcmp(line->data, "\\ No newline at end of file") == 0) ||
(*is_property &&
strcmp(line->data, "\\ No newline at end of property") == 0)))
{
char eolbuf[2];
apr_size_t len;
apr_off_t off;
apr_off_t hunk_text_end;
/* Comment terminates the hunk text and says the hunk text
* has no trailing EOL. Snip off trailing EOL which is part
* of the patch file but not part of the hunk text. */
off = last_line - 2;
SVN_ERR(svn_io_file_seek(apr_file, APR_SET, &off, iterpool));
len = sizeof(eolbuf);
SVN_ERR(svn_io_file_read_full2(apr_file, eolbuf, len, &len,
&eof, iterpool));
if (eolbuf[0] == '\r' && eolbuf[1] == '\n')
hunk_text_end = last_line - 2;
else if (eolbuf[1] == '\n' || eolbuf[1] == '\r')
hunk_text_end = last_line - 1;
else
hunk_text_end = last_line;
if (last_line_type == original_line && original_end == 0)
original_end = hunk_text_end;
else if (last_line_type == modified_line && modified_end == 0)
modified_end = hunk_text_end;
else if (last_line_type == context_line)
{
if (original_end == 0)
original_end = hunk_text_end;
if (modified_end == 0)
modified_end = hunk_text_end;
break;
}
SVN_ERR(svn_io_file_seek(apr_file, APR_SET, &pos, iterpool));
}
continue;
}
if (in_hunk)
{
char c;
static const char add = '+';
static const char del = '-';
if (! hunk_seen)
{
/* We're reading the first line of the hunk, so the start
* of the line just read is the hunk text's byte offset. */
start = last_line;
}
c = line->data[0];
if (original_lines > 0 && modified_lines > 0 &&
((c == ' ')
/* Tolerate chopped leading spaces on empty lines. */
|| (! eof && line->len == 0)
/* Maybe tolerate chopped leading spaces on non-empty lines. */
|| (ignore_whitespace && c != del && c != add)))
{
/* It's a "context" line in the hunk. */
hunk_seen = TRUE;
original_lines--;
modified_lines--;
if (changed_line_seen)
trailing_context++;
else
leading_context++;
last_line_type = context_line;
}
else if (original_lines > 0 && c == del)
{
/* It's a "deleted" line in the hunk. */
hunk_seen = TRUE;
changed_line_seen = TRUE;
/* A hunk may have context in the middle. We only want
trailing lines of context. */
if (trailing_context > 0)
trailing_context = 0;
original_lines--;
last_line_type = original_line;
}
else if (modified_lines > 0 && c == add)
{
/* It's an "added" line in the hunk. */
hunk_seen = TRUE;
changed_line_seen = TRUE;
/* A hunk may have context in the middle. We only want
trailing lines of context. */
if (trailing_context > 0)
trailing_context = 0;
modified_lines--;
last_line_type = modified_line;
}
else
{
if (eof)
{
/* The hunk ends at EOF. */
end = pos;
}
else
{
/* The start of the current line marks the first byte
* after the hunk text. */
end = last_line;
}
if (original_end == 0)
original_end = end;
if (modified_end == 0)
modified_end = end;
break; /* Hunk was empty or has been read. */
}
}
else
{
if (starts_with(line->data, text_atat))
{
/* Looks like we have a hunk header, try to rip it apart. */
in_hunk = parse_hunk_header(line->data, *hunk, text_atat,
iterpool);
if (in_hunk)
{
original_lines = (*hunk)->original_length;
modified_lines = (*hunk)->modified_length;
*is_property = FALSE;
}
}
else if (starts_with(line->data, prop_atat))
{
/* Looks like we have a property hunk header, try to rip it
* apart. */
in_hunk = parse_hunk_header(line->data, *hunk, prop_atat,
iterpool);
if (in_hunk)
{
original_lines = (*hunk)->original_length;
modified_lines = (*hunk)->modified_length;
*is_property = TRUE;
}
}
else if (starts_with(line->data, "Added: "))
{
SVN_ERR(parse_prop_name(prop_name, line->data, "Added: ",
result_pool));
if (*prop_name)
*prop_operation = svn_diff_op_added;
}
else if (starts_with(line->data, "Deleted: "))
{
SVN_ERR(parse_prop_name(prop_name, line->data, "Deleted: ",
result_pool));
if (*prop_name)
*prop_operation = svn_diff_op_deleted;
}
else if (starts_with(line->data, "Modified: "))
{
SVN_ERR(parse_prop_name(prop_name, line->data, "Modified: ",
result_pool));
if (*prop_name)
*prop_operation = svn_diff_op_modified;
}
else if (starts_with(line->data, minus)
|| starts_with(line->data, "diff --git "))
/* This could be a header of another patch. Bail out. */
break;
}
}
/* Check for the line length since a file may not have a newline at the
* end and we depend upon the last line to be an empty one. */
while (! eof || line->len > 0);
svn_pool_destroy(iterpool);
if (! eof)
/* Rewind to the start of the line just read, so subsequent calls
* to this function or svn_diff_parse_next_patch() don't end
* up skipping the line -- it may contain a patch or hunk header. */
SVN_ERR(svn_io_file_seek(apr_file, APR_SET, &last_line, scratch_pool));
if (hunk_seen && start < end)
{
(*hunk)->patch = patch;
(*hunk)->apr_file = apr_file;
(*hunk)->leading_context = leading_context;
(*hunk)->trailing_context = trailing_context;
(*hunk)->diff_text_range.start = start;
(*hunk)->diff_text_range.current = start;
(*hunk)->diff_text_range.end = end;
(*hunk)->original_text_range.start = start;
(*hunk)->original_text_range.current = start;
(*hunk)->original_text_range.end = original_end;
(*hunk)->modified_text_range.start = start;
(*hunk)->modified_text_range.current = start;
(*hunk)->modified_text_range.end = modified_end;
}
else
/* Something went wrong, just discard the result. */
*hunk = NULL;
return SVN_NO_ERROR;
}
/* This implements the `svn_opt_subcommand_t' interface. */
svn_error_t *
svn_cl__proplist(apr_getopt_t *os,
void *baton,
apr_pool_t *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;
apr_array_header_t *targets;
int i;
SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os,
opt_state->targets,
pool));
/* Add "." if user passed 0 file arguments */
svn_opt_push_implicit_dot_target(targets, pool);
if (opt_state->revprop) /* operate on revprops */
{
svn_revnum_t rev;
const char *URL;
apr_hash_t *proplist;
SVN_ERR(svn_cl__revprop_prepare(&opt_state->start_revision, targets,
&URL, pool));
/* Let libsvn_client do the real work. */
SVN_ERR(svn_client_revprop_list(&proplist,
URL, &(opt_state->start_revision),
&rev, ctx, pool));
if (opt_state->xml)
{
svn_stringbuf_t *sb = NULL;
char *revstr = apr_psprintf(pool, "%ld", rev);
SVN_ERR(svn_cl__xml_print_header("properties", pool));
svn_xml_make_open_tag(&sb, pool, svn_xml_normal,
"revprops",
"rev", revstr, NULL);
SVN_ERR(svn_cl__print_xml_prop_hash
(&sb, proplist, (! opt_state->verbose), pool));
svn_xml_make_close_tag(&sb, pool, "revprops");
SVN_ERR(svn_cl__error_checked_fputs(sb->data, stdout));
SVN_ERR(svn_cl__xml_print_footer("properties", pool));
}
else
{
SVN_ERR
(svn_cmdline_printf(pool,
_("Unversioned properties on revision %ld:\n"),
rev));
SVN_ERR(svn_cl__print_prop_hash
(proplist, (! opt_state->verbose), pool));
}
}
else /* operate on normal, versioned properties (not revprops) */
{
apr_pool_t *subpool = svn_pool_create(pool);
svn_proplist_receiver_t pl_receiver;
if (opt_state->xml)
{
SVN_ERR(svn_cl__xml_print_header("properties", pool));
pl_receiver = proplist_receiver_xml;
}
else
{
pl_receiver = proplist_receiver;
}
if (opt_state->depth == svn_depth_unknown)
opt_state->depth = svn_depth_empty;
for (i = 0; i < targets->nelts; i++)
{
const char *target = APR_ARRAY_IDX(targets, i, const char *);
proplist_baton_t pl_baton;
const char *truepath;
svn_opt_revision_t peg_revision;
svn_pool_clear(subpool);
SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton));
pl_baton.is_url = svn_path_is_url(target);
pl_baton.opt_state = opt_state;
/* Check for a peg revision. */
SVN_ERR(svn_opt_parse_path(&peg_revision, &truepath, target,
subpool));
SVN_ERR(svn_cl__try
(svn_client_proplist3(truepath, &peg_revision,
&(opt_state->start_revision),
opt_state->depth,
opt_state->changelists,
pl_receiver, &pl_baton,
ctx, subpool),
NULL, opt_state->quiet,
SVN_ERR_UNVERSIONED_RESOURCE,
SVN_ERR_ENTRY_NOT_FOUND,
SVN_NO_ERROR));
}
if (opt_state->xml)
SVN_ERR(svn_cl__xml_print_footer("properties", pool));
svn_pool_destroy(subpool);
}
return SVN_NO_ERROR;
}
/* This implements the `svn_opt_subcommand_t' interface. */
svn_error_t *
svn_cl__propedit(apr_getopt_t *os,
void *baton,
apr_pool_t *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, *pname_utf8;
apr_array_header_t *args, *targets;
int i;
/* Validate the input and get the property's name (and a UTF-8
version of that name). */
SVN_ERR(svn_opt_parse_num_args(&args, os, 1, pool));
pname = APR_ARRAY_IDX(args, 0, const char *);
SVN_ERR(svn_utf_cstring_to_utf8(&pname_utf8, pname, pool));
if (! svn_prop_name_is_valid(pname_utf8))
return svn_error_createf(SVN_ERR_CLIENT_PROPERTY_NAME, NULL,
_("'%s' is not a valid Subversion property name"),
pname_utf8);
if (opt_state->encoding && !svn_prop_needs_translation(pname_utf8))
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, pool));
if (opt_state->revprop) /* operate on a revprop */
{
svn_revnum_t rev;
const char *URL;
svn_string_t *propval;
svn_string_t original_propval;
const char *temp_dir;
/* Implicit "." is okay for revision properties; it just helps
us find the right repository. */
svn_opt_push_implicit_dot_target(targets, pool);
SVN_ERR(svn_cl__revprop_prepare(&opt_state->start_revision, targets,
&URL, pool));
/* Fetch the current property. */
SVN_ERR(svn_client_revprop_get(pname_utf8, &propval,
URL, &(opt_state->start_revision),
&rev, ctx, pool));
if (! propval)
{
propval = svn_string_create("", pool);
/* This is how we signify to svn_client_revprop_set2() that
we want it to check that the original value hasn't
changed, but that that original value was non-existent: */
original_propval.data = NULL; /* and .len is ignored */
}
else
{
original_propval = *propval;
}
/* Run the editor on a temporary file which contains the
original property value... */
SVN_ERR(svn_io_temp_dir(&temp_dir, pool));
SVN_ERR(svn_cl__edit_string_externally
(&propval, NULL,
opt_state->editor_cmd, temp_dir,
propval, "svn-prop",
ctx->config,
svn_prop_needs_translation(pname_utf8),
opt_state->encoding, pool));
/* ...and re-set the property's value accordingly. */
if (propval)
{
SVN_ERR(svn_client_revprop_set2(pname_utf8,
propval, &original_propval,
URL, &(opt_state->start_revision),
&rev, opt_state->force, ctx, pool));
SVN_ERR
(svn_cmdline_printf
(pool,
_("Set new value for property '%s' on revision %ld\n"),
pname_utf8, rev));
}
else
{
SVN_ERR(svn_cmdline_printf
(pool, _("No changes to property '%s' on revision %ld\n"),
pname_utf8, rev));
}
}
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 editing versioned property '%s'"),
pname_utf8);
}
else /* operate on a normal, versioned property (not a revprop) */
{
apr_pool_t *subpool = svn_pool_create(pool);
/* The customary implicit dot rule has been prone to user error
* here. For example, Jon Trowbridge <*****@*****.**> did
*
* $ svn propedit HACKING
*
* and then when he closed his editor, he was surprised to see
*
* Set new value for property 'HACKING' on ''
*
* ...meaning that the property named 'HACKING' had been set on
* the current working directory, with the value taken from the
* editor. So we don't do the implicit dot thing anymore; an
* explicit target is always required when editing a versioned
* property.
*/
if (targets->nelts == 0)
{
return svn_error_create
(SVN_ERR_CL_INSUFFICIENT_ARGS, NULL,
_("Explicit target argument required"));
}
SVN_ERR(svn_opt__eat_peg_revisions(&targets, targets, pool));
/* For each target, edit the property PNAME. */
for (i = 0; i < targets->nelts; i++)
{
apr_hash_t *props;
const char *target = APR_ARRAY_IDX(targets, i, const char *);
svn_string_t *propval, *edited_propval;
const char *base_dir = target;
const char *target_local;
svn_wc_adm_access_t *adm_access;
const svn_wc_entry_t *entry;
svn_opt_revision_t peg_revision;
svn_revnum_t base_rev = SVN_INVALID_REVNUM;
svn_pool_clear(subpool);
SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton));
/* Propedits can only happen on HEAD or the working copy, so
the peg revision can be as unspecified. */
peg_revision.kind = svn_opt_revision_unspecified;
/* Fetch the current property. */
SVN_ERR(svn_client_propget3(&props, pname_utf8, target,
&peg_revision,
&(opt_state->start_revision),
&base_rev, svn_depth_empty,
NULL, ctx, subpool));
/* Get the property value. */
propval = apr_hash_get(props, target, APR_HASH_KEY_STRING);
if (! propval)
propval = svn_string_create("", subpool);
if (svn_path_is_url(target))
{
/* For URLs, put the temporary file in the current directory. */
base_dir = ".";
}
else
{
if (opt_state->message || opt_state->filedata ||
opt_state->revprop_table)
{
return svn_error_create
(SVN_ERR_CL_UNNECESSARY_LOG_MESSAGE, NULL,
_("Local, non-commit operations do not take a log message "
"or revision properties"));
}
/* Split the path if it is a file path. */
SVN_ERR(svn_wc_adm_probe_open3(&adm_access, NULL, target,
FALSE, 0, ctx->cancel_func,
ctx->cancel_baton, subpool));
SVN_ERR(svn_wc_entry(&entry, target, adm_access, FALSE, subpool));
if (! entry)
return svn_error_createf
(SVN_ERR_ENTRY_NOT_FOUND, NULL,
_("'%s' does not appear to be a working copy path"), target);
if (entry->kind == svn_node_file)
svn_path_split(target, &base_dir, NULL, subpool);
}
/* Run the editor on a temporary file which contains the
original property value... */
SVN_ERR(svn_cl__edit_string_externally(&edited_propval, NULL,
opt_state->editor_cmd,
base_dir,
propval,
"svn-prop",
ctx->config,
svn_prop_needs_translation
(pname_utf8),
opt_state->encoding,
subpool));
target_local = svn_path_is_url(target) ? target
: svn_path_local_style(target, subpool);
/* ...and re-set the property's value accordingly. */
if (edited_propval && !svn_string_compare(propval, edited_propval))
{
svn_commit_info_t *commit_info = NULL;
svn_error_t *err = SVN_NO_ERROR;
svn_cl__check_boolean_prop_val(pname_utf8, edited_propval->data,
subpool);
if (ctx->log_msg_func3)
SVN_ERR(svn_cl__make_log_msg_baton(&(ctx->log_msg_baton3),
opt_state, NULL, ctx->config,
subpool));
err = svn_client_propset3(&commit_info,
pname_utf8, edited_propval, target,
svn_depth_empty, opt_state->force,
base_rev, NULL, opt_state->revprop_table,
ctx, subpool);
if (ctx->log_msg_func3)
SVN_ERR(svn_cl__cleanup_log_msg(ctx->log_msg_baton3,
err, pool));
else if (err)
return err;
/* Print a message if we successfully committed or if it
was just a wc propset (but not if the user aborted an URL
propedit). */
if (commit_info || ! svn_path_is_url(target))
SVN_ERR
(svn_cmdline_printf
(subpool, _("Set new value for property '%s' on '%s'\n"),
pname_utf8, target_local));
if (commit_info && ! opt_state->quiet)
SVN_ERR(svn_cl__print_commit_info(commit_info, subpool));
}
else
{
SVN_ERR
(svn_cmdline_printf
(subpool, _("No changes to property '%s' on '%s'\n"),
pname_utf8, target_local));
}
}
svn_pool_destroy(subpool);
}
return SVN_NO_ERROR;
}
/* Implements svn_test_driver_t. */
static svn_error_t *
random_test(apr_pool_t *pool)
{
apr_uint32_t seed, maxlen;
apr_size_t bytes_range;
int i, iterations, dump_files, print_windows;
const char *random_bytes;
/* Initialize parameters and print out the seed in case we dump core
or something. */
init_params(&seed, &maxlen, &iterations, &dump_files, &print_windows,
&random_bytes, &bytes_range, pool);
for (i = 0; i < iterations; i++)
{
/* Generate source and target for the delta and its application. */
apr_uint32_t subseed_base = svn_test_rand(&seed);
apr_file_t *source = generate_random_file(maxlen, subseed_base, &seed,
random_bytes, bytes_range,
dump_files, pool);
apr_file_t *target = generate_random_file(maxlen, subseed_base, &seed,
random_bytes, bytes_range,
dump_files, pool);
apr_file_t *source_copy = copy_tempfile(source, pool);
apr_file_t *target_regen = open_tempfile(NULL, pool);
svn_txdelta_stream_t *txdelta_stream;
svn_txdelta_window_handler_t handler;
svn_stream_t *stream;
void *handler_baton;
/* Set up a four-stage pipeline: create a delta, convert it to
svndiff format, parse it back into delta format, and apply it
to a copy of the source file to see if we get the same target
back. */
apr_pool_t *delta_pool = svn_pool_create(pool);
/* Make stage 4: apply the text delta. */
svn_txdelta_apply(svn_stream_from_aprfile(source_copy, delta_pool),
svn_stream_from_aprfile(target_regen, delta_pool),
NULL, NULL, delta_pool, &handler, &handler_baton);
/* Make stage 3: reparse the text delta. */
stream = svn_txdelta_parse_svndiff(handler, handler_baton, TRUE,
delta_pool);
/* Make stage 2: encode the text delta in svndiff format using
varying compression levels. */
svn_txdelta_to_svndiff3(&handler, &handler_baton, stream, 1, i % 10,
delta_pool);
/* Make stage 1: create the text delta. */
svn_txdelta2(&txdelta_stream,
svn_stream_from_aprfile(source, delta_pool),
svn_stream_from_aprfile(target, delta_pool),
FALSE,
delta_pool);
SVN_ERR(svn_txdelta_send_txstream(txdelta_stream,
handler,
handler_baton,
delta_pool));
svn_pool_destroy(delta_pool);
SVN_ERR(compare_files(target, target_regen, dump_files));
apr_file_close(source);
apr_file_close(target);
apr_file_close(source_copy);
apr_file_close(target_regen);
}
return SVN_NO_ERROR;
}
int
main (int argc, const char **argv)
{
apr_pool_t *pool;
svn_error_t *err;
apr_hash_t *locks;
apr_hash_index_t *hi;
const char *URL;
svn_ra_session_t *session;
svn_ra_callbacks_t *cbtable;
apr_hash_t *cfg_hash;
svn_auth_baton_t *auth_baton;
if (argc <= 1)
{
printf ("Usage: %s URL\n", argv[0]);
printf (" Print all locks at or below URL.\n");
return EXIT_FAILURE;
}
URL = argv[1];
/* Initialize the app. Send all error messages to 'stderr'. */
if (svn_cmdline_init ("ra_test", stderr) != EXIT_SUCCESS)
return EXIT_FAILURE;
/* Create top-level memory pool. Be sure to read the HACKING file to
understand how to properly use/free subpools. */
pool = svn_pool_create (NULL);
/* Initialize the FS library. */
err = svn_fs_initialize (pool);
if (err) goto hit_error;
/* Make sure the ~/.subversion run-time config files exist, and load. */
err = svn_config_ensure (NULL, pool);
if (err) goto hit_error;
err = svn_config_get_config (&cfg_hash, NULL, pool);
if (err) goto hit_error;
/* Build an authentication baton. */
{
/* There are many different kinds of authentication back-end
"providers". See svn_auth.h for a full overview. */
svn_auth_provider_object_t *provider;
apr_array_header_t *providers
= apr_array_make (pool, 4, sizeof (svn_auth_provider_object_t *));
svn_client_get_simple_prompt_provider (&provider,
my_simple_prompt_callback,
NULL, /* baton */
2, /* retry limit */ pool);
APR_ARRAY_PUSH (providers, svn_auth_provider_object_t *) = provider;
svn_client_get_username_prompt_provider (&provider,
my_username_prompt_callback,
NULL, /* baton */
2, /* retry limit */ pool);
APR_ARRAY_PUSH (providers, svn_auth_provider_object_t *) = provider;
/* Register the auth-providers into the context's auth_baton. */
svn_auth_open (&auth_baton, providers, pool);
}
/* Create a table of callbacks for the RA session, mostly nonexistent. */
cbtable = apr_pcalloc (pool, sizeof(*cbtable));
cbtable->auth_baton = auth_baton;
cbtable->open_tmp_file = open_tmp_file;
/* Now do the real work. */
err = svn_ra_open (&session, URL, cbtable, NULL, cfg_hash, pool);
if (err) goto hit_error;
err = svn_ra_get_locks (session, &locks, "", pool);
if (err) goto hit_error;
err = svn_cmdline_printf (pool, "\n");
if (err) goto hit_error;
for (hi = apr_hash_first (pool, locks); hi; hi = apr_hash_next (hi))
{
const void *key;
void *val;
const char *path, *cr_date, *exp_date;
svn_lock_t *lock;
apr_hash_this (hi, &key, NULL, &val);
path = key;
lock = val;
cr_date = svn_time_to_human_cstring (lock->creation_date, pool);
if (lock->expiration_date)
exp_date = svn_time_to_human_cstring (lock->expiration_date, pool);
else
exp_date = "never";
err = svn_cmdline_printf (pool, "%s\n", path);
if (err) goto hit_error;
err = svn_cmdline_printf (pool,
" UUID Token: %s\n", lock->token);
if (err) goto hit_error;
err = svn_cmdline_printf (pool,
" Owner: %s\n", lock->owner);
if (err) goto hit_error;
err = svn_cmdline_printf (pool,
" Comment: %s\n",
lock->comment ? lock->comment : "none");
if (err) goto hit_error;
err = svn_cmdline_printf (pool,
" Created: %s\n", cr_date);
if (err) goto hit_error;
err = svn_cmdline_printf (pool,
" Expires: %s\n\n", exp_date);
if (err) goto hit_error;
}
return EXIT_SUCCESS;
hit_error:
svn_handle_error2 (err, stderr, FALSE, "getlocks_test: ");
return EXIT_FAILURE;
}
svn_error_t *
svn_fs_fs__walk_rep_reference(svn_fs_t *fs,
svn_revnum_t start,
svn_revnum_t end,
svn_error_t *(*walker)(representation_t *,
void *,
svn_fs_t *,
apr_pool_t *),
void *walker_baton,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *pool)
{
fs_fs_data_t *ffd = fs->fsap_data;
svn_sqlite__stmt_t *stmt;
svn_boolean_t have_row;
int iterations = 0;
apr_pool_t *iterpool = svn_pool_create(pool);
/* Don't check ffd->rep_sharing_allowed. */
SVN_ERR_ASSERT(ffd->format >= SVN_FS_FS__MIN_REP_SHARING_FORMAT);
if (! ffd->rep_cache_db)
SVN_ERR(svn_fs_fs__open_rep_cache(fs, pool));
/* Check global invariants. */
if (start == 0)
{
svn_revnum_t max;
SVN_ERR(svn_sqlite__get_statement(&stmt, ffd->rep_cache_db,
STMT_GET_MAX_REV));
SVN_ERR(svn_sqlite__step(&have_row, stmt));
max = svn_sqlite__column_revnum(stmt, 0);
SVN_ERR(svn_sqlite__reset(stmt));
if (SVN_IS_VALID_REVNUM(max)) /* The rep-cache could be empty. */
SVN_ERR(svn_fs_fs__ensure_revision_exists(max, fs, iterpool));
}
SVN_ERR(svn_sqlite__get_statement(&stmt, ffd->rep_cache_db,
STMT_GET_REPS_FOR_RANGE));
SVN_ERR(svn_sqlite__bindf(stmt, "rr",
start, end));
/* Walk the cache entries. */
SVN_ERR(svn_sqlite__step(&have_row, stmt));
while (have_row)
{
representation_t *rep;
const char *sha1_digest;
svn_error_t *err;
svn_checksum_t *checksum;
/* Clear ITERPOOL occasionally. */
if (iterations++ % 16 == 0)
svn_pool_clear(iterpool);
/* Check for cancellation. */
if (cancel_func)
{
err = cancel_func(cancel_baton);
if (err)
return svn_error_compose_create(err, svn_sqlite__reset(stmt));
}
/* Construct a representation_t. */
rep = apr_pcalloc(iterpool, sizeof(*rep));
svn_fs_fs__id_txn_reset(&rep->txn_id);
sha1_digest = svn_sqlite__column_text(stmt, 0, iterpool);
err = svn_checksum_parse_hex(&checksum, svn_checksum_sha1,
sha1_digest, iterpool);
if (err)
return svn_error_compose_create(err, svn_sqlite__reset(stmt));
rep->has_sha1 = TRUE;
memcpy(rep->sha1_digest, checksum->digest, sizeof(rep->sha1_digest));
rep->revision = svn_sqlite__column_revnum(stmt, 1);
rep->item_index = svn_sqlite__column_int64(stmt, 2);
rep->size = svn_sqlite__column_int64(stmt, 3);
rep->expanded_size = svn_sqlite__column_int64(stmt, 4);
/* Walk. */
err = walker(rep, walker_baton, fs, iterpool);
if (err)
return svn_error_compose_create(err, svn_sqlite__reset(stmt));
SVN_ERR(svn_sqlite__step(&have_row, stmt));
}
SVN_ERR(svn_sqlite__reset(stmt));
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
static svn_error_t *
test_query_expectations(apr_pool_t *scratch_pool)
{
sqlite3 *sdb;
int i;
apr_pool_t *iterpool = svn_pool_create(scratch_pool);
svn_error_t *warnings = NULL;
svn_boolean_t supports_query_info;
SVN_ERR(create_memory_db(&sdb, scratch_pool));
SVN_ERR(supported_explain_query_plan(&supports_query_info, sdb,
scratch_pool));
if (!supports_query_info)
{
SQLITE_ERR(sqlite3_close(sdb));
return svn_error_create(SVN_ERR_TEST_SKIPPED, NULL,
"Sqlite doesn't support EXPLAIN QUERY PLAN");
}
for (i=0; i < STMT_SCHEMA_FIRST; i++)
{
sqlite3_stmt *stmt;
const char *tail;
int r;
svn_boolean_t warned = FALSE;
apr_array_header_t *rows = NULL;
if (is_schema_statement(i))
continue;
/* Prepare statement to find if it is a single statement. */
r = sqlite3_prepare_v2(sdb, wc_queries[i], -1, &stmt, &tail);
if (r != SQLITE_OK)
continue; /* Parse failure is already reported by 'test_parable' */
SQLITE_ERR(sqlite3_finalize(stmt));
if (tail[0] != '\0')
continue; /* Multi-queries are currently not testable */
svn_pool_clear(iterpool);
r = sqlite3_prepare_v2(sdb,
apr_pstrcat(iterpool,
"EXPLAIN QUERY PLAN ",
wc_queries[i],
NULL),
-1, &stmt, &tail);
if (r != SQLITE_OK)
continue; /* EXPLAIN not enabled or doesn't support this query */
while (SQLITE_ROW == (r = sqlite3_step(stmt)))
{
/*int iSelectid;
int iOrder;
int iFrom;*/
const unsigned char *zDetail;
char *detail;
struct explanation_item *item;
/* ### The following code is correct for current Sqlite versions
### (tested with 3.7.x), but the EXPLAIN QUERY PLAN output
### is not guaranteed to be stable for future versions. */
/* Names as in Sqlite documentation */
/*iSelectid = sqlite3_column_int(stmt, 0);
iOrder = sqlite3_column_int(stmt, 1);
iFrom = sqlite3_column_int(stmt, 2);*/
zDetail = sqlite3_column_text(stmt, 3);
if (! zDetail)
continue;
if (!rows)
rows = apr_array_make(iterpool, 10, sizeof(const char*));
detail = apr_pstrdup(iterpool, (const char*)zDetail);
APR_ARRAY_PUSH(rows, const char *) = detail;
SVN_ERR(parse_explanation_item(&item, detail, iterpool));
if (!item)
continue; /* Not parsable or not interesting */
if (item->search
&& item->automatic_index)
{
warned = TRUE;
if (!is_slow_statement(i))
{
warnings = svn_error_createf(SVN_ERR_TEST_FAILED, warnings,
"%s: "
"Creates a temporary index: %s\n",
wc_query_info[i][0], wc_queries[i]);
}
}
else if (item->search && item->primary_key)
{
/* Nice */
}
else if (item->search
&& ((item->expression_vars < 2 && is_node_table(item->table))
|| (item->expression_vars < 1))
&& !is_result_table(item->table))
{
warned = TRUE;
if (!is_slow_statement(i))
warnings = svn_error_createf(SVN_ERR_TEST_FAILED, warnings,
"%s: "
"Uses %s with only %d index component: (%s)\n%s",
wc_query_info[i][0], item->table,
item->expression_vars, item->expressions,
wc_queries[i]);
}
else if (item->search && !item->index)
{
warned = TRUE;
if (!is_slow_statement(i))
warnings = svn_error_createf(SVN_ERR_TEST_FAILED, warnings,
"%s: "
"Query on %s doesn't use an index:\n%s",
wc_query_info[i][0], item->table, wc_queries[i]);
}
else if (item->scan && !is_result_table(item->table))
{
warned = TRUE;
if (!is_slow_statement(i))
warnings = svn_error_createf(SVN_ERR_TEST_FAILED, warnings,
"Query %s: "
"Performs scan on %s:\n%s",
wc_query_info[i][0], item->table, wc_queries[i]);
}
else if (item->create_btree)
{
warned = TRUE;
if (!is_slow_statement(i))
warnings = svn_error_createf(SVN_ERR_TEST_FAILED, warnings,
"Query %s: Creates a temporary B-TREE:\n%s",
wc_query_info[i][0], wc_queries[i]);
}
}
SQLITE_ERR(sqlite3_reset(stmt));
SQLITE_ERR(sqlite3_finalize(stmt));
if (!warned && is_slow_statement(i))
{
printf("DBG: Expected %s to be reported as slow, but it wasn't\n",
wc_query_info[i][0]);
}
if (rows && warned != is_slow_statement(i))
{
int w;
svn_error_t *info = NULL;
for (w = rows->nelts-1; w >= 0; w--)
{
if (warned)
info = svn_error_createf(SVN_ERR_SQLITE_CONSTRAINT, info,
"|%s", APR_ARRAY_IDX(rows, w,
const char*));
else
printf("|%s\n", APR_ARRAY_IDX(rows, w, const char*));
}
warnings = svn_error_compose_create(warnings, info);
}
svn_error_t *
svn_config_walk_auth_data(const char *config_dir,
svn_config_auth_walk_func_t walk_func,
void *walk_baton,
apr_pool_t *scratch_pool)
{
int i;
apr_pool_t *iterpool;
svn_boolean_t finished = FALSE;
const char *cred_kinds[] =
{
SVN_AUTH_CRED_SIMPLE,
SVN_AUTH_CRED_USERNAME,
SVN_AUTH_CRED_SSL_CLIENT_CERT,
SVN_AUTH_CRED_SSL_CLIENT_CERT_PW,
SVN_AUTH_CRED_SSL_SERVER_TRUST,
NULL
};
iterpool = svn_pool_create(scratch_pool);
for (i = 0; cred_kinds[i]; i++)
{
const char *item_path;
const char *dir_path;
apr_hash_t *nodes;
svn_error_t *err;
apr_pool_t *itempool;
apr_hash_index_t *hi;
svn_pool_clear(iterpool);
if (finished)
break;
SVN_ERR(svn_auth__file_path(&item_path, cred_kinds[i], "!", config_dir,
iterpool));
dir_path = svn_dirent_dirname(item_path, iterpool);
err = svn_io_get_dirents3(&nodes, dir_path, TRUE, iterpool, iterpool);
if (err)
{
if (!APR_STATUS_IS_ENOENT(err->apr_err)
&& !SVN__APR_STATUS_IS_ENOTDIR(err->apr_err))
return svn_error_trace(err);
svn_error_clear(err);
continue;
}
itempool = svn_pool_create(iterpool);
for (hi = apr_hash_first(iterpool, nodes); hi; hi = apr_hash_next(hi))
{
svn_io_dirent2_t *dirent = svn__apr_hash_index_val(hi);
svn_stream_t *stream;
apr_hash_t *creds_hash;
const svn_string_t *realm;
svn_boolean_t delete_file = FALSE;
if (finished)
break;
if (dirent->kind != svn_node_file)
continue;
svn_pool_clear(itempool);
item_path = svn_dirent_join(dir_path, svn__apr_hash_index_key(hi),
itempool);
err = svn_stream_open_readonly(&stream, item_path,
itempool, itempool);
if (err)
{
/* Ignore this file. There are no credentials in it anyway */
svn_error_clear(err);
continue;
}
creds_hash = apr_hash_make(itempool);
err = svn_hash_read2(creds_hash, stream,
SVN_HASH_TERMINATOR, itempool);
err = svn_error_compose_create(err, svn_stream_close(stream));
if (err)
{
/* Ignore this file. There are no credentials in it anyway */
svn_error_clear(err);
continue;
}
realm = svn_hash_gets(creds_hash, SVN_CONFIG_REALMSTRING_KEY);
if (! realm)
continue; /* Not an auth file */
err = walk_func(&delete_file, walk_baton, cred_kinds[i],
realm->data, creds_hash, itempool);
if (err && err->apr_err == SVN_ERR_CEASE_INVOCATION)
{
svn_error_clear(err);
err = SVN_NO_ERROR;
finished = TRUE;
}
SVN_ERR(err);
if (delete_file)
{
/* Delete the file on disk */
SVN_ERR(svn_io_remove_file2(item_path, TRUE, itempool));
}
}
}
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
inline Try<Diff> diff(const std::string& from, const std::string& to)
{
// Initialize the Apache Portable Runtime subsystem, as necessary
// for using the svn library.
initialize();
// Note that svn_pool_create wraps apr_pool_create_ex, which is
// thread safe, see: http://goo.gl/NX0hps.
apr_pool_t* pool = svn_pool_create(NULL);
// First we need to produce a text delta stream by diffing 'source'
// against 'target'.
svn_string_t source;
source.data = from.data();
source.len = from.length();
svn_string_t target;
target.data = to.data();
target.len = to.length();
svn_txdelta_stream_t* delta;
#if SVN_VER_MAJOR >= 1 && SVN_VER_MINOR >= 8
svn_txdelta2(
&delta,
svn_stream_from_string(&source, pool),
svn_stream_from_string(&target, pool),
false,
pool);
#else
svn_txdelta(
&delta,
svn_stream_from_string(&source, pool),
svn_stream_from_string(&target, pool),
pool);
#endif
// Now we want to convert this text delta stream into an svndiff
// format based diff. Setup the handler that will consume the text
// delta and produce the svndiff.
svn_txdelta_window_handler_t handler;
void* baton = NULL;
svn_stringbuf_t* diff = svn_stringbuf_create_ensure(1024, pool);
#if SVN_VER_MAJOR >= 1 && SVN_VER_MINOR >= 7
svn_txdelta_to_svndiff3(
&handler,
&baton,
svn_stream_from_stringbuf(diff, pool),
0,
SVN_DELTA_COMPRESSION_LEVEL_DEFAULT,
pool);
#elif SVN_VER_MAJOR >= 1 && SVN_VER_MINOR >= 4
svn_txdelta_to_svndiff2(
&handler,
&baton,
svn_stream_from_stringbuf(diff, pool),
0,
pool);
#else
svn_txdelta_to_svndiff(
svn_stream_from_stringbuf(diff, pool),
pool,
&handler,
&baton);
#endif
// Now feed the text delta to the handler.
svn_error_t* error = svn_txdelta_send_txstream(delta, handler, baton, pool);
if (error != NULL) {
char buffer[1024];
std::string message(svn_err_best_message(error, buffer, 1024));
svn_pool_destroy(pool);
return Error(message);
}
Diff d(std::string(diff->data, diff->len));
svn_pool_destroy(pool);
return d;
}
/* Helper func for recursively fetching svn_dirent_t's from a remote
directory and pushing them at an info-receiver callback.
DEPTH is the depth starting at DIR, even though RECEIVER is never
invoked on DIR: if DEPTH is svn_depth_immediates, then invoke
RECEIVER on all children of DIR, but none of their children; if
svn_depth_files, then invoke RECEIVER on file children of DIR but
not on subdirectories; if svn_depth_infinity, recurse fully.
*/
static svn_error_t *
push_dir_info(svn_ra_session_t *ra_session,
const char *session_URL,
const char *dir,
svn_revnum_t rev,
const char *repos_UUID,
const char *repos_root,
svn_info_receiver_t receiver,
void *receiver_baton,
svn_depth_t depth,
svn_client_ctx_t *ctx,
apr_hash_t *locks,
apr_pool_t *pool)
{
apr_hash_t *tmpdirents;
svn_dirent_t *the_ent;
svn_info_t *info;
apr_hash_index_t *hi;
apr_pool_t *subpool = svn_pool_create(pool);
SVN_ERR(svn_ra_get_dir2(ra_session, &tmpdirents, NULL, NULL,
dir, rev, DIRENT_FIELDS, pool));
for (hi = apr_hash_first(pool, tmpdirents); hi; hi = apr_hash_next(hi))
{
const char *path, *URL, *fs_path;
const void *key;
svn_lock_t *lock;
void *val;
svn_pool_clear(subpool);
if (ctx->cancel_func)
SVN_ERR(ctx->cancel_func(ctx->cancel_baton));
apr_hash_this(hi, &key, NULL, &val);
the_ent = val;
path = svn_path_join(dir, key, subpool);
URL = svn_path_url_add_component2(session_URL, key, subpool);
fs_path = svn_path_is_child(repos_root, URL, subpool);
fs_path = apr_pstrcat(subpool, "/", fs_path, NULL);
fs_path = svn_path_uri_decode(fs_path, subpool);
lock = apr_hash_get(locks, fs_path, APR_HASH_KEY_STRING);
SVN_ERR(build_info_from_dirent(&info, the_ent, lock, URL, rev,
repos_UUID, repos_root, subpool));
if (depth >= svn_depth_immediates
|| (depth == svn_depth_files && the_ent->kind == svn_node_file))
{
SVN_ERR(receiver(receiver_baton, path, info, subpool));
}
if (depth == svn_depth_infinity && the_ent->kind == svn_node_dir)
{
SVN_ERR(push_dir_info(ra_session, URL, path,
rev, repos_UUID, repos_root,
receiver, receiver_baton,
depth, ctx, locks, subpool));
}
}
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
/* (Note: *LAST_SEED is an output parameter.) */
static svn_error_t *
do_random_combine_test(apr_pool_t *pool,
apr_uint32_t *last_seed)
{
apr_uint32_t seed, maxlen;
apr_size_t bytes_range;
int i, iterations, dump_files, print_windows;
const char *random_bytes;
/* Initialize parameters and print out the seed in case we dump core
or something. */
init_params(&seed, &maxlen, &iterations, &dump_files, &print_windows,
&random_bytes, &bytes_range, pool);
for (i = 0; i < iterations; i++)
{
/* Generate source and target for the delta and its application. */
apr_uint32_t subseed_base = svn_test_rand((*last_seed = seed, &seed));
apr_file_t *source = generate_random_file(maxlen, subseed_base, &seed,
random_bytes, bytes_range,
dump_files, pool);
apr_file_t *middle = generate_random_file(maxlen, subseed_base, &seed,
random_bytes, bytes_range,
dump_files, pool);
apr_file_t *target = generate_random_file(maxlen, subseed_base, &seed,
random_bytes, bytes_range,
dump_files, pool);
apr_file_t *source_copy = copy_tempfile(source, pool);
apr_file_t *middle_copy = copy_tempfile(middle, pool);
apr_file_t *target_regen = open_tempfile(NULL, pool);
svn_txdelta_stream_t *txdelta_stream_A;
svn_txdelta_stream_t *txdelta_stream_B;
svn_txdelta_window_handler_t handler;
svn_stream_t *stream;
void *handler_baton;
/* Set up a four-stage pipeline: create two deltas, combine them
and convert the result to svndiff format, parse that back
into delta format, and apply it to a copy of the source file
to see if we get the same target back. */
apr_pool_t *delta_pool = svn_pool_create(pool);
/* Make stage 4: apply the text delta. */
svn_txdelta_apply(svn_stream_from_aprfile(source_copy, delta_pool),
svn_stream_from_aprfile(target_regen, delta_pool),
NULL, NULL, delta_pool, &handler, &handler_baton);
/* Make stage 3: reparse the text delta. */
stream = svn_txdelta_parse_svndiff(handler, handler_baton, TRUE,
delta_pool);
/* Make stage 2: encode the text delta in svndiff format using
varying compression levels. */
svn_txdelta_to_svndiff3(&handler, &handler_baton, stream, 1, i % 10,
delta_pool);
/* Make stage 1: create the text deltas. */
svn_txdelta2(&txdelta_stream_A,
svn_stream_from_aprfile(source, delta_pool),
svn_stream_from_aprfile(middle, delta_pool),
FALSE,
delta_pool);
svn_txdelta2(&txdelta_stream_B,
svn_stream_from_aprfile(middle_copy, delta_pool),
svn_stream_from_aprfile(target, delta_pool),
FALSE,
delta_pool);
{
svn_txdelta_window_t *window_A;
svn_txdelta_window_t *window_B;
svn_txdelta_window_t *composite;
apr_pool_t *wpool = svn_pool_create(delta_pool);
do
{
SVN_ERR(svn_txdelta_next_window(&window_A, txdelta_stream_A,
wpool));
if (print_windows)
delta_window_print(window_A, "A ", stdout);
SVN_ERR(svn_txdelta_next_window(&window_B, txdelta_stream_B,
wpool));
if (print_windows)
delta_window_print(window_B, "B ", stdout);
if (!window_B)
break;
assert(window_A != NULL || window_B->src_ops == 0);
if (window_B->src_ops == 0)
{
composite = window_B;
composite->sview_len = 0;
}
else
composite = svn_txdelta_compose_windows(window_A, window_B,
wpool);
if (print_windows)
delta_window_print(composite, "AB", stdout);
/* The source view length should not be 0 if there are
source copy ops in the window. */
if (composite
&& composite->sview_len == 0 && composite->src_ops > 0)
return svn_error_create
(SVN_ERR_FS_GENERAL, NULL,
"combined delta window is inconsistent");
SVN_ERR(handler(composite, handler_baton));
svn_pool_clear(wpool);
}
while (composite != NULL);
svn_pool_destroy(wpool);
}
svn_pool_destroy(delta_pool);
SVN_ERR(compare_files(target, target_regen, dump_files));
apr_file_close(source);
apr_file_close(middle);
apr_file_close(target);
apr_file_close(source_copy);
apr_file_close(middle_copy);
apr_file_close(target_regen);
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_diff_parse_next_patch(svn_patch_t **patch,
svn_patch_file_t *patch_file,
svn_boolean_t reverse,
svn_boolean_t ignore_whitespace,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
apr_off_t pos, last_line;
svn_boolean_t eof;
svn_boolean_t line_after_tree_header_read = FALSE;
apr_pool_t *iterpool;
enum parse_state state = state_start;
if (apr_file_eof(patch_file->apr_file) == APR_EOF)
{
/* No more patches here. */
*patch = NULL;
return SVN_NO_ERROR;
}
*patch = apr_pcalloc(result_pool, sizeof(**patch));
pos = patch_file->next_patch_offset;
SVN_ERR(svn_io_file_seek(patch_file->apr_file, APR_SET, &pos, scratch_pool));
iterpool = svn_pool_create(scratch_pool);
do
{
svn_stringbuf_t *line;
svn_boolean_t valid_header_line = FALSE;
int i;
svn_pool_clear(iterpool);
/* Remember the current line's offset, and read the line. */
last_line = pos;
SVN_ERR(readline(patch_file->apr_file, &line, NULL, &eof,
APR_SIZE_MAX, iterpool, iterpool));
if (! eof)
{
/* Update line offset for next iteration. */
pos = 0;
SVN_ERR(svn_io_file_seek(patch_file->apr_file, APR_CUR, &pos,
iterpool));
}
/* Run the state machine. */
for (i = 0; i < (sizeof(transitions) / sizeof(transitions[0])); i++)
{
if (line->len > strlen(transitions[i].expected_input)
&& starts_with(line->data, transitions[i].expected_input)
&& state == transitions[i].required_state)
{
SVN_ERR(transitions[i].fn(&state, line->data, *patch,
result_pool, iterpool));
valid_header_line = TRUE;
break;
}
}
if (state == state_unidiff_found || state == state_git_header_found)
{
/* We have a valid diff header, yay! */
break;
}
else if (state == state_git_tree_seen && line_after_tree_header_read)
{
/* We have a valid diff header for a patch with only tree changes.
* Rewind to the start of the line just read, so subsequent calls
* to this function don't end up skipping the line -- it may
* contain a patch. */
SVN_ERR(svn_io_file_seek(patch_file->apr_file, APR_SET, &last_line,
scratch_pool));
break;
}
else if (state == state_git_tree_seen)
{
line_after_tree_header_read = TRUE;
}
else if (! valid_header_line && state != state_start)
{
/* We've encountered an invalid diff header.
*
* Rewind to the start of the line just read - it may be a new
* header that begins there. */
SVN_ERR(svn_io_file_seek(patch_file->apr_file, APR_SET, &last_line,
scratch_pool));
state = state_start;
}
}
while (! eof);
(*patch)->reverse = reverse;
if (reverse)
{
const char *temp;
temp = (*patch)->old_filename;
(*patch)->old_filename = (*patch)->new_filename;
(*patch)->new_filename = temp;
}
if ((*patch)->old_filename == NULL || (*patch)->new_filename == NULL)
{
/* Something went wrong, just discard the result. */
*patch = NULL;
}
else
SVN_ERR(parse_hunks(*patch, patch_file->apr_file, ignore_whitespace,
result_pool, iterpool));
svn_pool_destroy(iterpool);
patch_file->next_patch_offset = 0;
SVN_ERR(svn_io_file_seek(patch_file->apr_file, APR_CUR,
&patch_file->next_patch_offset, scratch_pool));
if (*patch)
{
/* Usually, hunks appear in the patch sorted by their original line
* offset. But just in case they weren't parsed in this order for
* some reason, we sort them so that our caller can assume that hunks
* are sorted as if parsed from a usual patch. */
qsort((*patch)->hunks->elts, (*patch)->hunks->nelts,
(*patch)->hunks->elt_size, compare_hunks);
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_ra__file_revs_from_log(svn_ra_session_t *ra_session,
const char *path,
svn_revnum_t start,
svn_revnum_t end,
svn_file_rev_handler_t handler,
void *handler_baton,
apr_pool_t *pool)
{
svn_node_kind_t kind;
const char *repos_url, *session_url, *fs_path;
apr_array_header_t *condensed_targets;
struct fr_log_message_baton lmb;
struct rev *rev;
apr_hash_t *last_props;
svn_stream_t *last_stream;
apr_pool_t *currpool, *lastpool;
/* Fetch the absolute FS path associated with PATH. */
SVN_ERR(get_fs_path(&fs_path, ra_session, path, pool));
/* Check to make sure we're dealing with a file. */
SVN_ERR(svn_ra_check_path(ra_session, path, end, &kind, pool));
if (kind == svn_node_dir)
return svn_error_createf(SVN_ERR_FS_NOT_FILE, NULL,
_("'%s' is not a file"), fs_path);
condensed_targets = apr_array_make(pool, 1, sizeof(const char *));
APR_ARRAY_PUSH(condensed_targets, const char *) = path;
lmb.path = fs_path;
lmb.eldest = NULL;
lmb.pool = pool;
/* Accumulate revision metadata by walking the revisions
backwards; this allows us to follow moves/copies
correctly. */
SVN_ERR(svn_ra_get_log2(ra_session,
condensed_targets,
end, start, 0, /* no limit */
TRUE, FALSE, FALSE,
NULL, fr_log_message_receiver, &lmb,
pool));
/* Reparent the session while we go back through the history. */
SVN_ERR(svn_ra_get_session_url(ra_session, &session_url, pool));
SVN_ERR(svn_ra_get_repos_root2(ra_session, &repos_url, pool));
SVN_ERR(svn_ra_reparent(ra_session, repos_url, pool));
currpool = svn_pool_create(pool);
lastpool = svn_pool_create(pool);
/* We want the first txdelta to be against the empty file. */
last_props = apr_hash_make(lastpool);
last_stream = svn_stream_empty(lastpool);
/* Walk the revision list in chronological order, downloading each fulltext,
diffing it with its predecessor, and calling the file_revs handler for
each one. Use two iteration pools rather than one, because the diff
routines need to look at a sliding window of revisions. Two pools gives
us a ring buffer of sorts. */
for (rev = lmb.eldest; rev; rev = rev->next)
{
const char *temp_path;
apr_pool_t *tmppool;
apr_hash_t *props;
apr_file_t *file;
svn_stream_t *stream;
apr_array_header_t *prop_diffs;
svn_txdelta_stream_t *delta_stream;
svn_txdelta_window_handler_t delta_handler = NULL;
void *delta_baton = NULL;
svn_pool_clear(currpool);
/* Get the contents of the file from the repository, and put them in
a temporary local file. */
SVN_ERR(svn_stream_open_unique(&stream, &temp_path, NULL,
svn_io_file_del_on_pool_cleanup,
currpool, currpool));
SVN_ERR(svn_ra_get_file(ra_session, rev->path + 1, rev->revision,
stream, NULL, &props, currpool));
SVN_ERR(svn_stream_close(stream));
/* Open up a stream to the local file. */
SVN_ERR(svn_io_file_open(&file, temp_path, APR_READ, APR_OS_DEFAULT,
currpool));
stream = svn_stream_from_aprfile2(file, FALSE, currpool);
/* Calculate the property diff */
SVN_ERR(svn_prop_diffs(&prop_diffs, props, last_props, lastpool));
/* Call the file_rev handler */
SVN_ERR(handler(handler_baton, rev->path, rev->revision, rev->props,
FALSE, /* merged revision */
&delta_handler, &delta_baton, prop_diffs, lastpool));
/* Compute and send delta if client asked for it. */
if (delta_handler)
{
/* Get the content delta. */
svn_txdelta(&delta_stream, last_stream, stream, lastpool);
/* And send. */
SVN_ERR(svn_txdelta_send_txstream(delta_stream, delta_handler,
delta_baton, lastpool));
}
/* Switch the pools and data for the next iteration */
tmppool = currpool;
currpool = lastpool;
lastpool = tmppool;
SVN_ERR(svn_stream_close(last_stream));
last_stream = stream;
last_props = props;
}
SVN_ERR(svn_stream_close(last_stream));
svn_pool_destroy(currpool);
svn_pool_destroy(lastpool);
/* Reparent the session back to the original URL. */
return svn_ra_reparent(ra_session, session_url, pool);
}
svn_error_t *
svn_client_revert2(const apr_array_header_t *paths,
svn_depth_t depth,
const apr_array_header_t *changelists,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
apr_pool_t *subpool;
svn_error_t *err = SVN_NO_ERROR;
int i;
svn_config_t *cfg;
svn_boolean_t use_commit_times;
struct revert_with_write_lock_baton baton;
/* Don't even attempt to modify the working copy if any of the
* targets look like URLs. URLs are invalid input. */
for (i = 0; i < paths->nelts; i++)
{
const char *path = APR_ARRAY_IDX(paths, i, const char *);
if (svn_path_is_url(path))
return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
_("'%s' is not a local path"), path);
}
cfg = ctx->config
? svn_hash_gets(ctx->config, SVN_CONFIG_CATEGORY_CONFIG)
: NULL;
SVN_ERR(svn_config_get_bool(cfg, &use_commit_times,
SVN_CONFIG_SECTION_MISCELLANY,
SVN_CONFIG_OPTION_USE_COMMIT_TIMES,
FALSE));
subpool = svn_pool_create(pool);
for (i = 0; i < paths->nelts; i++)
{
const char *path = APR_ARRAY_IDX(paths, i, const char *);
const char *local_abspath, *lock_target;
svn_boolean_t wc_root;
svn_pool_clear(subpool);
/* See if we've been asked to cancel this operation. */
if ((ctx->cancel_func)
&& ((err = ctx->cancel_func(ctx->cancel_baton))))
goto errorful;
err = svn_dirent_get_absolute(&local_abspath, path, pool);
if (err)
goto errorful;
baton.local_abspath = local_abspath;
baton.depth = depth;
baton.use_commit_times = use_commit_times;
baton.changelists = changelists;
baton.ctx = ctx;
err = svn_wc__is_wcroot(&wc_root, ctx->wc_ctx, local_abspath, pool);
if (err)
goto errorful;
lock_target = wc_root ? local_abspath
: svn_dirent_dirname(local_abspath, pool);
err = svn_wc__call_with_write_lock(revert, &baton, ctx->wc_ctx,
lock_target, FALSE, pool, pool);
if (err)
goto errorful;
}
errorful:
{
/* Sleep to ensure timestamp integrity. */
const char *sleep_path = NULL;
/* Only specify a path if we are certain all paths are on the
same filesystem */
if (paths->nelts == 1)
sleep_path = APR_ARRAY_IDX(paths, 0, const char *);
svn_io_sleep_for_timestamps(sleep_path, subpool);
}
svn_pool_destroy(subpool);
return svn_error_trace(err);
}
/* This implements the `svn_opt_subcommand_t' interface. */
svn_error_t *
svn_cl__info(apr_getopt_t *os,
void *baton,
apr_pool_t *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;
apr_array_header_t *targets = NULL;
apr_pool_t *subpool = svn_pool_create(pool);
int i;
svn_error_t *err;
svn_boolean_t saw_a_problem = FALSE;
svn_opt_revision_t peg_revision;
svn_info_receiver_t receiver;
SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os,
opt_state->targets,
ctx, pool));
/* Add "." if user passed 0 arguments. */
svn_opt_push_implicit_dot_target(targets, pool);
if (opt_state->xml)
{
receiver = print_info_xml;
/* If output is not incremental, output the XML header and wrap
everything in a top-level element. This makes the output in
its entirety a well-formed XML document. */
if (! opt_state->incremental)
SVN_ERR(svn_cl__xml_print_header("info", pool));
}
else
{
receiver = print_info;
if (opt_state->incremental)
return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("'incremental' option only valid in XML "
"mode"));
}
if (opt_state->depth == svn_depth_unknown)
opt_state->depth = svn_depth_empty;
for (i = 0; i < targets->nelts; i++)
{
const char *truepath;
const char *target = APR_ARRAY_IDX(targets, i, const char *);
svn_pool_clear(subpool);
SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton));
/* Get peg revisions. */
SVN_ERR(svn_opt_parse_path(&peg_revision, &truepath, target, subpool));
/* If no peg-rev was attached to a URL target, then assume HEAD. */
if ((svn_path_is_url(target))
&& (peg_revision.kind == svn_opt_revision_unspecified))
peg_revision.kind = svn_opt_revision_head;
err = svn_client_info2(truepath,
&peg_revision, &(opt_state->start_revision),
receiver, NULL, opt_state->depth,
opt_state->changelists, ctx, subpool);
if (err)
{
/* If one of the targets is a non-existent URL or wc-entry,
don't bail out. Just warn and move on to the next target. */
if (err->apr_err == SVN_ERR_UNVERSIONED_RESOURCE
|| err->apr_err == SVN_ERR_ENTRY_NOT_FOUND)
{
SVN_ERR(svn_cmdline_fprintf
(stderr, subpool,
_("%s: (Not a versioned resource)\n\n"),
svn_path_local_style(target, pool)));
}
else if (err->apr_err == SVN_ERR_RA_ILLEGAL_URL)
{
SVN_ERR(svn_cmdline_fprintf
(stderr, subpool,
_("%s: (Not a valid URL)\n\n"),
svn_path_local_style(target, pool)));
}
else
{
return err;
}
svn_error_clear(err);
err = NULL;
saw_a_problem = TRUE;
}
}
svn_pool_destroy(subpool);
if (opt_state->xml && (! opt_state->incremental))
SVN_ERR(svn_cl__xml_print_footer("info", pool));
if (saw_a_problem)
return svn_error_create(SVN_ERR_BASE, NULL, NULL);
else
return SVN_NO_ERROR;
}
svn_error_t *
svn_client_upgrade(const char *path,
svn_client_ctx_t *ctx,
apr_pool_t *scratch_pool)
{
const char *local_abspath;
apr_hash_t *externals;
apr_hash_index_t *hi;
apr_pool_t *iterpool;
apr_pool_t *iterpool2;
svn_opt_revision_t rev = {svn_opt_revision_unspecified, {0}};
struct repos_info_baton info_baton;
info_baton.state_pool = scratch_pool;
info_baton.ctx = ctx;
info_baton.last_repos = NULL;
info_baton.last_uuid = NULL;
if (svn_path_is_url(path))
return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
_("'%s' is not a local path"), path);
SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, scratch_pool));
SVN_ERR(svn_wc_upgrade(ctx->wc_ctx, local_abspath,
fetch_repos_info, &info_baton,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
scratch_pool));
/* Now it's time to upgrade the externals too. We do it after the wc
upgrade to avoid that errors in the externals causes the wc upgrade to
fail. Thanks to caching the performance penalty of walking the wc a
second time shouldn't be too severe */
SVN_ERR(svn_client_propget4(&externals, SVN_PROP_EXTERNALS, local_abspath,
&rev, &rev, NULL, svn_depth_infinity, NULL, ctx,
scratch_pool, scratch_pool));
iterpool = svn_pool_create(scratch_pool);
iterpool2 = svn_pool_create(scratch_pool);
for (hi = apr_hash_first(scratch_pool, externals); hi;
hi = apr_hash_next(hi))
{
int i;
const char *externals_parent_abspath;
const char *externals_parent_url;
const char *externals_parent_repos_root_url;
const char *externals_parent = svn__apr_hash_index_key(hi);
svn_string_t *external_desc = svn__apr_hash_index_val(hi);
apr_array_header_t *externals_p;
svn_error_t *err;
svn_pool_clear(iterpool);
externals_p = apr_array_make(iterpool, 1,
sizeof(svn_wc_external_item2_t*));
/* In this loop, an error causes the respective externals definition, or
* the external (inner loop), to be skipped, so that upgrade carries on
* with the other externals. */
err = svn_dirent_get_absolute(&externals_parent_abspath,
externals_parent, iterpool);
if (!err)
err = svn_wc__node_get_url(&externals_parent_url, ctx->wc_ctx,
externals_parent_abspath,
iterpool, iterpool);
if (!err)
err = svn_wc__node_get_repos_info(&externals_parent_repos_root_url,
NULL,
ctx->wc_ctx,
externals_parent_abspath,
iterpool, iterpool);
if (!err)
err = svn_wc_parse_externals_description3(
&externals_p, svn_dirent_dirname(path, iterpool),
external_desc->data, TRUE, iterpool);
if (err)
{
svn_wc_notify_t *notify =
svn_wc_create_notify(externals_parent,
svn_wc_notify_failed_external,
scratch_pool);
notify->err = err;
ctx->notify_func2(ctx->notify_baton2,
notify, scratch_pool);
svn_error_clear(err);
/* Next externals definition, please... */
continue;
}
for (i = 0; i < externals_p->nelts; i++)
{
svn_wc_external_item2_t *item;
const char *resolved_url;
const char *external_abspath;
const char *repos_relpath;
const char *repos_root_url;
const char *repos_uuid;
svn_node_kind_t external_kind;
svn_revnum_t peg_revision;
svn_revnum_t revision;
item = APR_ARRAY_IDX(externals_p, i, svn_wc_external_item2_t*);
svn_pool_clear(iterpool2);
external_abspath = svn_dirent_join(externals_parent_abspath,
item->target_dir,
iterpool2);
err = svn_wc__resolve_relative_external_url(
&resolved_url,
item,
externals_parent_repos_root_url,
externals_parent_url,
scratch_pool, scratch_pool);
if (err)
goto handle_error;
/* This is a hack. We only need to call svn_wc_upgrade() on external
* dirs, as file externals are upgraded along with their defining
* WC. Reading the kind will throw an exception on an external dir,
* saying that the wc must be upgraded. If it's a file, the lookup
* is done in an adm_dir belonging to the defining wc (which has
* already been upgraded) and no error is returned. If it doesn't
* exist (external that isn't checked out yet), we'll just get
* svn_node_none. */
err = svn_wc_read_kind(&external_kind, ctx->wc_ctx,
external_abspath, FALSE, iterpool2);
if (err && err->apr_err == SVN_ERR_WC_UPGRADE_REQUIRED)
{
svn_error_clear(err);
err = svn_client_upgrade(external_abspath, ctx, iterpool2);
if (err)
goto handle_error;
}
else if (err)
goto handle_error;
/* The upgrade of any dir should be done now, get the now reliable
* kind. */
err = svn_wc_read_kind(&external_kind, ctx->wc_ctx, external_abspath,
FALSE, iterpool2);
if (err)
goto handle_error;
/* Update the EXTERNALS table according to the root URL,
* relpath and uuid known in the upgraded external WC. */
/* We should probably have a function that provides all three
* of root URL, repos relpath and uuid at once, but here goes... */
/* First get the relpath, as that returns SVN_ERR_WC_PATH_NOT_FOUND
* when the node is not present in the file system.
* svn_wc__node_get_repos_info() would try to derive the URL. */
err = svn_wc__node_get_repos_relpath(&repos_relpath,
ctx->wc_ctx,
external_abspath,
iterpool2, iterpool2);
if (! err)
{
/* We got a repos relpath from a WC. So also get the root. */
err = svn_wc__node_get_repos_info(&repos_root_url,
&repos_uuid,
ctx->wc_ctx,
external_abspath,
iterpool2, iterpool2);
if (err)
goto handle_error;
}
else if (err && err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
{
/* The external is not currently checked out. Try to figure out
* the URL parts via the defined URL and fetch_repos_info(). */
svn_error_clear(err);
repos_relpath = NULL;
repos_root_url = NULL;
repos_uuid = NULL;
}
else if (err)
goto handle_error;
/* If we haven't got any information from the checked out external,
* or if the URL information mismatches the external's definition,
* ask fetch_repos_info() to find out the repos root. */
if (! repos_relpath || ! repos_root_url
|| 0 != strcmp(resolved_url,
svn_path_url_add_component2(repos_root_url,
repos_relpath,
scratch_pool)))
{
err = fetch_repos_info(&repos_root_url,
&repos_uuid,
&info_baton,
resolved_url,
scratch_pool, scratch_pool);
if (err)
goto handle_error;
repos_relpath = svn_uri_skip_ancestor(repos_root_url,
resolved_url,
iterpool2);
/* There's just the URL, no idea what kind the external is.
* That's fine, as the external isn't even checked out yet.
* The kind will be set during the next 'update'. */
external_kind = svn_node_unknown;
}
if (err)
goto handle_error;
peg_revision = (item->peg_revision.kind == svn_opt_revision_number
? item->peg_revision.value.number
: SVN_INVALID_REVNUM);
revision = (item->revision.kind == svn_opt_revision_number
? item->revision.value.number
: SVN_INVALID_REVNUM);
err = svn_wc__upgrade_add_external_info(ctx->wc_ctx,
external_abspath,
external_kind,
externals_parent,
repos_relpath,
repos_root_url,
repos_uuid,
peg_revision,
revision,
iterpool2);
handle_error:
if (err)
{
svn_wc_notify_t *notify =
svn_wc_create_notify(external_abspath,
svn_wc_notify_failed_external,
scratch_pool);
notify->err = err;
ctx->notify_func2(ctx->notify_baton2,
notify, scratch_pool);
svn_error_clear(err);
/* Next external node, please... */
}
}
}
svn_pool_destroy(iterpool);
svn_pool_destroy(iterpool2);
return SVN_NO_ERROR;
}
/* Dumps a node */
static svn_error_t *delta_dump_node(de_node_baton_t *node)
{
de_baton_t *de_baton = node->de_baton;
session_t *session = de_baton->session;
dump_options_t *opts = de_baton->opts;
char *path = node->path;
unsigned long prop_len, content_len;
char dump_content = 0, dump_props = 0;
apr_hash_index_t *hi;
/* Check if the node needs to be dumped at all */
if (!node->dump_needed) {
DEBUG_MSG("delta_dump_node(%s): aborting: dump not needed\n", node->path);
return SVN_NO_ERROR;
}
/* Check if this is a dry run */
if (opts->flags & DF_DRY_RUN) {
node->dump_needed = 0;
DEBUG_MSG("delta_dump_node(%s): aborting: DF_DRY_RUN\n", node->path);
return SVN_NO_ERROR;
}
/* If the node is a directory and no properties have been changed,
we don't need to dump it */
if ((node->action == 'M') && (node->kind == svn_node_dir) && (!node->props_changed)) {
node->dump_needed = 0;
DEBUG_MSG("delta_dump_node(%s): aborting: directory && action == 'M' && !props_changed\n", node->path);
return SVN_NO_ERROR;
}
/* If the node's parent has been copied, we don't need to dump it if its contents haven't changed.
Addionally, make sure the node doesn't contain extra copyfrom information. */
if ((node->cp_info == CPI_COPY) && (node->action == 'A') && (node->copyfrom_path == NULL)) {
node->dump_needed = 0;
DEBUG_MSG("delta_dump_node(%s): aborting: cp_info == CPI_COPY && action == 'A'\n", node->path);
return SVN_NO_ERROR;
}
DEBUG_MSG("delta_dump_node(%s): started\n", node->path);
/* Check for potential copy. This is neede here because it might change the action. */
delta_check_copy(node);
if (node->action == 'R') {
/* Special handling for replacements */
DEBUG_MSG("delta_dump_node(%s): running delta_dump_replace()\n", node->path);
return delta_dump_replace(node);
}
/* Dump node path */
if (opts->prefix != NULL) {
printf("%s: %s%s\n", SVN_REPOS_DUMPFILE_NODE_PATH, opts->prefix, path);
} else {
printf("%s: %s\n", SVN_REPOS_DUMPFILE_NODE_PATH, path);
}
/* Dump node kind */
if (node->action != 'D') {
printf("%s: %s\n", SVN_REPOS_DUMPFILE_NODE_KIND, node->kind == svn_node_file ? "file" : "dir");
}
/* Dump action */
printf("%s: ", SVN_REPOS_DUMPFILE_NODE_ACTION);
switch (node->action) {
case 'M':
printf("change\n");
if ((de_baton->opts->verbosity > 0) && !(de_baton->opts->flags & DF_DRY_RUN)) {
fprintf(stderr, _(" * editing path : %s ... "), path);
}
break;
case 'A':
printf("add\n");
if ((de_baton->opts->verbosity > 0) && !(de_baton->opts->flags & DF_DRY_RUN)) {
fprintf(stderr, _(" * adding path : %s ... "), path);
}
break;
case 'D':
printf("delete\n");
if ((de_baton->opts->verbosity > 0) && !(de_baton->opts->flags & DF_DRY_RUN)) {
fprintf(stderr, _(" * deleting path : %s ... "), path);
}
/* We can finish early here */
printf("\n\n");
delta_mark_node(node);
DEBUG_MSG("delta_dump_node(%s): deleted -> finished\n", node->path);
return SVN_NO_ERROR;
case 'R':
printf("replace\n");
break;
}
/* Check if the node content needs to be dumped */
if (node->kind == svn_node_file && node->applied_delta) {
DEBUG_MSG("delta_dump_node(%s): dump_content = 1\n", node->path);
dump_content = 1;
}
/* Check if the node properties need to be dumped */
if ((node->props_changed) || (node->action == 'A')) {
DEBUG_MSG("delta_dump_node(%s): dump_props = 1\n", node->path);
dump_props = 1;
}
/* Output copy information if neccessary */
if (node->cp_info == CPI_COPY) {
const char *copyfrom_path = delta_get_local_copyfrom_path(session->prefix, node->copyfrom_path);
printf("%s: %ld\n", SVN_REPOS_DUMPFILE_NODE_COPYFROM_REV, node->copyfrom_rev_local);
if (opts->prefix != NULL) {
printf("%s: %s%s\n", SVN_REPOS_DUMPFILE_NODE_COPYFROM_PATH, opts->prefix, copyfrom_path);
} else {
printf("%s: %s\n", SVN_REPOS_DUMPFILE_NODE_COPYFROM_PATH, copyfrom_path);
}
/* Maybe we don't need to dump the contents */
if ((node->action == 'A') && (node->kind == svn_node_file)) {
unsigned char *prev_md5 = rhash_get(md5_hash, copyfrom_path, APR_HASH_KEY_STRING);
if (prev_md5 && !memcmp(node->md5sum, prev_md5, APR_MD5_DIGESTSIZE)) {
DEBUG_MSG("md5sum matches\n");
dump_content = 0;
} else {
#ifdef DEBUG
if (prev_md5) {
DEBUG_MSG("md5sum doesn't match: (%s != %s)\n", svn_md5_digest_to_cstring(node->md5sum, node->pool), svn_md5_digest_to_cstring(prev_md5, node->pool));
} else {
DEBUG_MSG("md5sum of %s not available\n", copyfrom_path);
}
#endif
dump_content = 1;
}
}
if (!dump_content && !node->props_changed) {
printf("\n\n");
delta_mark_node(node);
return 0;
} else if (node->kind == svn_node_dir) {
dump_content = 0;
}
}
/* Deltify? */
if (dump_content && (opts->flags & DF_USE_DELTAS)) {
svn_error_t *err;
if ((err = delta_deltify_node(node))) {
return err;
}
}
#ifdef DUMP_DEBUG
/* Dump some extra debug info */
if (dump_content) {
printf("Debug-filename: %s\n", node->filename);
if (node->old_filename) {
printf("Debug-old-filename: %s\n", node->old_filename);
}
if (opts->flags & DF_USE_DELTAS) {
printf("Debug-delta-filename: %s\n", node->delta_filename);
}
}
#endif
/* Dump properties & content */
prop_len = 0;
content_len = 0;
/* Dump property size */
for (hi = apr_hash_first(node->pool, node->properties); hi; hi = apr_hash_next(hi)) {
const char *key;
svn_string_t *value;
apr_hash_this(hi, (const void **)(void *)&key, NULL, (void **)(void *)&value);
/* Don't dump the property if it has been deleted */
if (apr_hash_get(node->del_properties, key, APR_HASH_KEY_STRING) != NULL) {
continue;
}
prop_len += property_strlen(node->pool, key, value->data);
}
/* In dump format version 3, deleted properties should be dumped, too */
if (opts->dump_format == 3) {
for (hi = apr_hash_first(node->pool, node->del_properties); hi; hi = apr_hash_next(hi)) {
const char *key;
void *value;
apr_hash_this(hi, (const void **)(void *)&key, NULL, &value);
prop_len += property_del_strlen(node->pool, key);
}
}
if ((prop_len > 0)) {
dump_props = 1;
}
if (dump_props) {
if (opts->dump_format == 3) {
printf("%s: true\n", SVN_REPOS_DUMPFILE_PROP_DELTA);
}
prop_len += PROPS_END_LEN;
printf("%s: %lu\n", SVN_REPOS_DUMPFILE_PROP_CONTENT_LENGTH, prop_len);
}
/* Dump content size */
if (dump_content) {
char *fpath = (opts->flags & DF_USE_DELTAS) ? node->delta_filename : node->filename;
apr_finfo_t *info = apr_pcalloc(node->pool, sizeof(apr_finfo_t));
if (apr_stat(info, fpath, APR_FINFO_SIZE, node->pool) != APR_SUCCESS) {
DEBUG_MSG("delta_dump_node: FATAL: cannot stat %s\n", node->filename);
return svn_error_create(1, NULL, apr_psprintf(session->pool, "Cannot stat %s", node->filename));
}
content_len = (unsigned long)info->size;
if (opts->flags & DF_USE_DELTAS) {
printf("%s: true\n", SVN_REPOS_DUMPFILE_TEXT_DELTA);
}
printf("%s: %lu\n", SVN_REPOS_DUMPFILE_TEXT_CONTENT_LENGTH, content_len);
if (*node->md5sum != 0x00) {
printf("%s: %s\n", SVN_REPOS_DUMPFILE_TEXT_CONTENT_MD5, svn_md5_digest_to_cstring(node->md5sum, node->pool));
}
}
printf("%s: %lu\n\n", SVN_REPOS_DUMPFILE_CONTENT_LENGTH, (unsigned long)prop_len+content_len);
/* Dump properties */
if (dump_props) {
for (hi = apr_hash_first(node->pool, node->properties); hi; hi = apr_hash_next(hi)) {
const char *key;
svn_string_t *value;
apr_hash_this(hi, (const void **)(void *)&key, NULL, (void **)(void *)&value);
/* Don't dump the property if it has been deleted */
if (apr_hash_get(node->del_properties, key, APR_HASH_KEY_STRING) != NULL) {
continue;
}
property_dump(key, value->data);
}
/* In dump format version 3, deleted properties should be dumped, too */
if (opts->dump_format == 3) {
for (hi = apr_hash_first(node->pool, node->del_properties); hi; hi = apr_hash_next(hi)) {
const char *key;
void *value;
apr_hash_this(hi, (const void **)(void *)&key, NULL, &value);
property_del_dump(key);
}
}
printf(PROPS_END);
}
/* Dump content */
if (dump_content) {
svn_error_t *err;
apr_pool_t *pool = svn_pool_create(node->pool);
const char *fpath = (opts->flags & DF_USE_DELTAS) ? node->delta_filename : node->filename;
fflush(stdout);
if ((err = delta_cat_file(pool, fpath))) {
return err;
}
fflush(stdout);
svn_pool_destroy(pool);
#ifndef DUMP_DEBUG
if (opts->flags & DF_USE_DELTAS) {
apr_file_remove(node->delta_filename, node->pool);
}
#endif
}
printf("\n\n");
delta_mark_node(node);
return SVN_NO_ERROR;
}
svn_error_t * svn_ra_neon__get_props(apr_hash_t **results,
svn_ra_neon__session_t *sess,
const char *url,
int depth,
const char *label,
const ne_propname *which_props,
apr_pool_t *pool)
{
propfind_ctx_t pc;
svn_stringbuf_t *body;
apr_hash_t *extra_headers = apr_hash_make(pool);
svn_ra_neon__add_depth_header(extra_headers, depth);
/* If we have a label, use it. */
if (label != NULL)
apr_hash_set(extra_headers, "Label", 5, label);
/* It's easier to roll our own PROPFIND here than use neon's current
interfaces. */
/* The start of the request body is fixed: */
body = svn_stringbuf_create
("<?xml version=\"1.0\" encoding=\"utf-8\"?>" DEBUG_CR
"<propfind xmlns=\"DAV:\">" DEBUG_CR, pool);
/* Are we asking for specific propert(y/ies), or just all of them? */
if (which_props)
{
int n;
apr_pool_t *iterpool = svn_pool_create(pool);
svn_stringbuf_appendcstr(body, "<prop>" DEBUG_CR);
for (n = 0; which_props[n].name != NULL; n++)
{
svn_pool_clear(iterpool);
svn_stringbuf_appendcstr
(body, apr_pstrcat(iterpool, "<", which_props[n].name, " xmlns=\"",
which_props[n].nspace, "\"/>" DEBUG_CR, NULL));
}
svn_stringbuf_appendcstr(body, "</prop></propfind>" DEBUG_CR);
svn_pool_destroy(iterpool);
}
else
{
svn_stringbuf_appendcstr(body, "<allprop/></propfind>" DEBUG_CR);
}
/* Initialize our baton. */
memset(&pc, 0, sizeof(pc));
pc.pool = pool;
pc.propbuffer = apr_hash_make(pool);
pc.props = apr_hash_make(pool);
pc.cdata = svn_stringbuf_create("", pool);
/* Create and dispatch the request! */
SVN_ERR(svn_ra_neon__parsed_request(sess, "PROPFIND", url,
body->data, 0,
set_parser,
start_element,
svn_ra_neon__xml_collect_cdata,
end_element,
&pc, extra_headers, NULL, FALSE, pool));
*results = pc.props;
return SVN_NO_ERROR;
}
/* Prepare LINE for display, pruning or extending it to an appropriate
* display width, and stripping the EOL marker, if any.
* This function assumes that the data in LINE is encoded in UTF-8. */
static const char *
prepare_line_for_display(const char *line, apr_pool_t *pool)
{
svn_stringbuf_t *buf = svn_stringbuf_create(line, pool);
size_t width;
size_t line_width = LINE_DISPLAY_WIDTH;
apr_pool_t *iterpool;
/* Trim EOL. */
if (buf->len >= 2 &&
buf->data[buf->len - 2] == '\r' &&
buf->data[buf->len - 1] == '\n')
svn_stringbuf_chop(buf, 2);
else if (buf->len >= 1 &&
(buf->data[buf->len - 1] == '\n' ||
buf->data[buf->len - 1] == '\r'))
svn_stringbuf_chop(buf, 1);
/* Determine the on-screen width of the line. */
width = svn_utf_cstring_utf8_width(buf->data);
if (width == -1)
{
/* Determining the width failed. Try to get rid of unprintable
* characters in the line buffer. */
buf = svn_stringbuf_create(svn_xml_fuzzy_escape(buf->data, pool), pool);
width = svn_utf_cstring_utf8_width(buf->data);
if (width == -1)
width = buf->len; /* fallback: buffer length */
}
/* Trim further in case line is still too long, or add padding in case
* it is too short. */
iterpool = svn_pool_create(pool);
while (width > line_width)
{
const char *last_valid;
svn_pool_clear(iterpool);
svn_stringbuf_chop(buf, 1);
/* Be careful not to invalidate the UTF-8 string by trimming
* just part of a character. */
last_valid = svn_utf__last_valid(buf->data, buf->len);
if (last_valid < buf->data + buf->len)
svn_stringbuf_chop(buf, (buf->data + buf->len) - last_valid);
width = svn_utf_cstring_utf8_width(buf->data);
if (width == -1)
width = buf->len; /* fallback: buffer length */
}
svn_pool_destroy(iterpool);
while (width == 0 || width < line_width)
{
svn_stringbuf_appendbyte(buf, ' ');
width++;
}
SVN_ERR_ASSERT_NO_RETURN(width == line_width);
return buf->data;
}
/* The real implementation of svn_client__get_inheritable_props */
static svn_error_t *
get_inheritable_props(apr_hash_t **wcroot_iprops,
const char *local_abspath,
svn_revnum_t revision,
svn_depth_t depth,
svn_ra_session_t *ra_session,
svn_client_ctx_t *ctx,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
apr_hash_t *iprop_paths;
apr_hash_index_t *hi;
apr_pool_t *iterpool = svn_pool_create(scratch_pool);
apr_pool_t *session_pool = NULL;
*wcroot_iprops = apr_hash_make(result_pool);
SVN_ERR_ASSERT(SVN_IS_VALID_REVNUM(revision));
/* If we don't have a base revision for LOCAL_ABSPATH then it can't
possibly be a working copy root, nor can it contain any WC roots
in the form of switched subtrees. So there is nothing to cache. */
SVN_ERR(svn_wc__get_cached_iprop_children(&iprop_paths, depth,
ctx->wc_ctx, local_abspath,
scratch_pool, iterpool));
/* If we are in the midst of a checkout or an update that is bringing in
an external, then svn_wc__get_cached_iprop_children won't return
LOCAL_ABSPATH in IPROPS_PATHS because the former has no cached iprops
yet. So make sure LOCAL_ABSPATH is present if it's a WC root. */
if (!svn_hash_gets(iprop_paths, local_abspath))
{
svn_boolean_t needs_cached_iprops;
SVN_ERR(need_to_cache_iprops(&needs_cached_iprops, local_abspath,
ra_session, ctx, iterpool));
if (needs_cached_iprops)
{
const char *target_abspath = apr_pstrdup(scratch_pool,
local_abspath);
/* As value we set TARGET_ABSPATH, but any string besides ""
would do */
svn_hash_sets(iprop_paths, target_abspath, target_abspath);
}
}
for (hi = apr_hash_first(scratch_pool, iprop_paths);
hi;
hi = apr_hash_next(hi))
{
const char *child_abspath = svn__apr_hash_index_key(hi);
const char *child_repos_relpath = svn__apr_hash_index_val(hi);
const char *url;
apr_array_header_t *inherited_props;
svn_error_t *err;
svn_pool_clear(iterpool);
if (*child_repos_relpath == '\0')
{
/* A repository root doesn't have inherited properties */
continue;
}
SVN_ERR(svn_wc__node_get_url(&url, ctx->wc_ctx, child_abspath,
iterpool, iterpool));
if (ra_session)
SVN_ERR(svn_ra_reparent(ra_session, url, scratch_pool));
else
{
if (! session_pool)
session_pool = svn_pool_create(scratch_pool);
SVN_ERR(svn_client_open_ra_session2(&ra_session, url, NULL,
ctx,
session_pool, iterpool));
}
err = svn_ra_get_inherited_props(ra_session, &inherited_props,
"", revision,
result_pool, iterpool);
if (err)
{
if (err->apr_err != SVN_ERR_FS_NOT_FOUND)
return svn_error_trace(err);
svn_error_clear(err);
continue;
}
svn_hash_sets(*wcroot_iprops,
apr_pstrdup(result_pool, child_abspath),
inherited_props);
}
svn_pool_destroy(iterpool);
if (session_pool)
svn_pool_destroy(session_pool);
return SVN_NO_ERROR;
}
/* Edit CHUNK and return the result in *MERGED_CHUNK allocated in POOL. */
static svn_error_t *
edit_chunk(apr_array_header_t **merged_chunk,
apr_array_header_t *chunk,
const char *editor_cmd,
apr_hash_t *config,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
apr_file_t *temp_file;
const char *temp_file_name;
int i;
apr_off_t pos;
svn_boolean_t eof;
svn_error_t *err;
apr_pool_t *iterpool;
SVN_ERR(svn_io_open_unique_file3(&temp_file, &temp_file_name, NULL,
svn_io_file_del_on_pool_cleanup,
scratch_pool, scratch_pool));
iterpool = svn_pool_create(scratch_pool);
for (i = 0; i < chunk->nelts; i++)
{
svn_stringbuf_t *line = APR_ARRAY_IDX(chunk, i, svn_stringbuf_t *);
apr_size_t bytes_written;
svn_pool_clear(iterpool);
SVN_ERR(svn_io_file_write_full(temp_file, line->data, line->len,
&bytes_written, iterpool));
if (line->len != bytes_written)
return svn_error_create(SVN_ERR_IO_WRITE_ERROR, NULL,
_("Could not write data to temporary file"));
}
SVN_ERR(svn_io_file_flush_to_disk(temp_file, scratch_pool));
err = svn_cmdline__edit_file_externally(temp_file_name, editor_cmd,
config, scratch_pool);
if (err && (err->apr_err == SVN_ERR_CL_NO_EXTERNAL_EDITOR))
{
svn_error_t *root_err = svn_error_root_cause(err);
SVN_ERR(svn_cmdline_fprintf(stderr, scratch_pool, "%s\n",
root_err->message ? root_err->message :
_("No editor found.")));
svn_error_clear(err);
*merged_chunk = NULL;
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
else if (err && (err->apr_err == SVN_ERR_EXTERNAL_PROGRAM))
{
svn_error_t *root_err = svn_error_root_cause(err);
SVN_ERR(svn_cmdline_fprintf(stderr, scratch_pool, "%s\n",
root_err->message ? root_err->message :
_("Error running editor.")));
svn_error_clear(err);
*merged_chunk = NULL;
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
else if (err)
return svn_error_trace(err);
*merged_chunk = apr_array_make(result_pool, 1, sizeof(svn_stringbuf_t *));
pos = 0;
SVN_ERR(svn_io_file_seek(temp_file, APR_SET, &pos, scratch_pool));
do
{
svn_stringbuf_t *line;
const char *eol_str;
svn_pool_clear(iterpool);
SVN_ERR(svn_io_file_readline(temp_file, &line, &eol_str, &eof,
APR_SIZE_MAX, result_pool, iterpool));
if (eol_str)
svn_stringbuf_appendcstr(line, eol_str);
APR_ARRAY_PUSH(*merged_chunk, svn_stringbuf_t *) = line;
}
while (!eof);
svn_pool_destroy(iterpool);
SVN_ERR(svn_io_file_close(temp_file, scratch_pool));
return SVN_NO_ERROR;
}
static gpointer properties_thread (gpointer user_data)
{
struct thread_args *args = user_data;
svn_opt_revision_t revision;
svn_error_t *err;
svn_client_ctx_t *ctx = args->ctx;
apr_pool_t *subpool, *pool = args->pool;
TshPropertiesDialog *dialog = args->dialog;
gchar *path = args->path;
gchar *set_key = args->set_key;
gchar *set_value = args->set_value;
gboolean depth = args->depth;
svn_string_t *value;
GtkWidget *error;
gchar *error_str;
#if CHECK_SVN_VERSION_G(1,7)
apr_array_header_t *paths;
#endif
args->set_key = NULL;
args->set_value = NULL;
subpool = svn_pool_create (pool);
if (set_key)
{
value = set_value?svn_string_create(set_value, subpool):NULL;
#if CHECK_SVN_VERSION_G(1,7)
paths = apr_array_make (subpool, 1, sizeof (const char *));
APR_ARRAY_PUSH (paths, const char *) = path;
if ((err = svn_client_propset_local(set_key, value, paths, depth, FALSE,
NULL, ctx, subpool)))
#else
if ((err = svn_client_propset3(NULL, set_key, value, path, depth, FALSE,
SVN_INVALID_REVNUM, NULL, NULL, ctx,
subpool)))
#endif
{
error_str = tsh_strerror(err);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gdk_threads_enter();
G_GNUC_END_IGNORE_DEPRECATIONS
error = gtk_message_dialog_new(GTK_WINDOW(dialog), GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Set property failed"));
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(error), "%s", error_str);
tsh_dialog_start(GTK_DIALOG(error), FALSE);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gdk_threads_leave();
G_GNUC_END_IGNORE_DEPRECATIONS
g_free(error_str);
svn_error_clear(err);
}
}
g_free (set_key);
g_free (set_value);
revision.kind = svn_opt_revision_unspecified;
#if CHECK_SVN_VERSION_G(1,8)
svn_proplist_receiver2_t receiver2;
void *receiver2_baton;
wrap_proplist_receiver(&receiver2, &receiver2_baton, tsh_proplist_func,
dialog, pool);
if ((err = svn_client_proplist4(path, &revision, &revision, svn_depth_empty,
NULL, FALSE, receiver2, receiver2_baton, ctx,
subpool)))
#else
if ((err = svn_client_proplist3(path, &revision, &revision, svn_depth_empty,
NULL, tsh_proplist_func, dialog, ctx,
subpool)))
#endif
{
svn_pool_destroy (subpool);
error_str = tsh_strerror(err);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gdk_threads_enter();
G_GNUC_END_IGNORE_DEPRECATIONS
tsh_properties_dialog_done (dialog);
error = gtk_message_dialog_new(GTK_WINDOW(dialog), GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK, _("Properties failed"));
gtk_message_dialog_format_secondary_text(GTK_MESSAGE_DIALOG(error), "%s", error_str);
tsh_dialog_start(GTK_DIALOG(error), FALSE);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gdk_threads_leave();
G_GNUC_END_IGNORE_DEPRECATIONS
g_free(error_str);
svn_error_clear(err);
tsh_reset_cancel();
return GINT_TO_POINTER (FALSE);
}
svn_pool_destroy (subpool);
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gdk_threads_enter();
tsh_properties_dialog_done (dialog);
gdk_threads_leave();
G_GNUC_END_IGNORE_DEPRECATIONS
tsh_reset_cancel();
return GINT_TO_POINTER (TRUE);
}
/* Merge chunks CHUNK1 and CHUNK2.
* Each lines array contains elements of type svn_stringbuf_t*.
* Return the result in *MERGED_CHUNK, or set *MERGED_CHUNK to NULL in
* case the user chooses to postpone resolution of this chunk.
* If the user wants to abort the merge, set *ABORT_MERGE to TRUE. */
static svn_error_t *
merge_chunks(apr_array_header_t **merged_chunk,
svn_boolean_t *abort_merge,
apr_array_header_t *chunk1,
apr_array_header_t *chunk2,
svn_linenum_t current_line1,
svn_linenum_t current_line2,
const char *editor_cmd,
apr_hash_t *config,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_stringbuf_t *prompt;
int i;
int max_chunk_lines;
apr_pool_t *iterpool;
max_chunk_lines = chunk1->nelts > chunk2->nelts ? chunk1->nelts
: chunk2->nelts;
*abort_merge = FALSE;
/*
* Prepare the selection prompt.
*/
prompt = svn_stringbuf_create(
apr_psprintf(scratch_pool, "%s\n%s|%s\n%s",
_("Conflicting section found during merge:"),
prepare_line_for_display(
apr_psprintf(scratch_pool,
_("(1) their version (at line %lu)"),
current_line1),
scratch_pool),
prepare_line_for_display(
apr_psprintf(scratch_pool,
_("(2) your version (at line %lu)"),
current_line2),
scratch_pool),
get_sep_string(scratch_pool)),
scratch_pool);
iterpool = svn_pool_create(scratch_pool);
for (i = 0; i < max_chunk_lines; i++)
{
const char *line1;
const char *line2;
const char *prompt_line;
svn_pool_clear(iterpool);
if (i < chunk1->nelts)
{
svn_stringbuf_t *line_utf8;
SVN_ERR(svn_utf_stringbuf_to_utf8(&line_utf8,
APR_ARRAY_IDX(chunk1, i,
svn_stringbuf_t*),
iterpool));
line1 = prepare_line_for_display(line_utf8->data, iterpool);
}
else
svn_error_t *
svn_config__parse_registry(svn_config_t *cfg, const char *file,
svn_boolean_t must_exist, apr_pool_t *pool)
{
apr_pool_t *subpool;
svn_stringbuf_t *section, *option, *value;
svn_error_t *svn_err = SVN_NO_ERROR;
HKEY base_hkey, hkey;
DWORD index;
LONG err;
if (0 == strncmp(file, SVN_REGISTRY_HKLM, SVN_REGISTRY_HKLM_LEN))
{
base_hkey = HKEY_LOCAL_MACHINE;
file += SVN_REGISTRY_HKLM_LEN;
}
else if (0 == strncmp(file, SVN_REGISTRY_HKCU, SVN_REGISTRY_HKCU_LEN))
{
base_hkey = HKEY_CURRENT_USER;
file += SVN_REGISTRY_HKCU_LEN;
}
else
{
return svn_error_createf(SVN_ERR_BAD_FILENAME, NULL,
"Unrecognised registry path '%s'",
svn_path_local_style(file, pool));
}
err = RegOpenKeyEx(base_hkey, file, 0,
KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE,
&hkey);
if (err != ERROR_SUCCESS)
{
const int is_enoent = APR_STATUS_IS_ENOENT(APR_FROM_OS_ERROR(err));
if (!is_enoent)
return svn_error_createf(SVN_ERR_BAD_FILENAME, NULL,
"Can't open registry key '%s'",
svn_path_local_style(file, pool));
else if (must_exist && is_enoent)
return svn_error_createf(SVN_ERR_BAD_FILENAME, NULL,
"Can't find registry key '%s'",
svn_path_local_style(file, pool));
else
return SVN_NO_ERROR;
}
subpool = svn_pool_create(pool);
section = svn_stringbuf_create("", subpool);
option = svn_stringbuf_create("", subpool);
value = svn_stringbuf_create("", subpool);
/* The top-level values belong to the [DEFAULT] section */
svn_err = parse_section(cfg, hkey, SVN_CONFIG__DEFAULT_SECTION,
option, value);
if (svn_err)
goto cleanup;
/* Now enumerate the rest of the keys. */
svn_stringbuf_ensure(section, SVN_REG_DEFAULT_NAME_SIZE);
for (index = 0; ; ++index)
{
DWORD section_len = section->blocksize;
FILETIME last_write_time;
HKEY sub_hkey;
err = RegEnumKeyEx(hkey, index, section->data, §ion_len,
NULL, NULL, NULL, &last_write_time);
if (err == ERROR_NO_MORE_ITEMS)
break;
if (err == ERROR_MORE_DATA)
{
svn_stringbuf_ensure(section, section_len);
err = RegEnumKeyEx(hkey, index, section->data, §ion_len,
NULL, NULL, NULL, &last_write_time);
}
if (err != ERROR_SUCCESS)
{
svn_err = svn_error_create(SVN_ERR_MALFORMED_FILE, NULL,
"Can't enumerate registry keys");
goto cleanup;
}
err = RegOpenKeyEx(hkey, section->data, 0,
KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE,
&sub_hkey);
if (err != ERROR_SUCCESS)
{
svn_err = svn_error_create(SVN_ERR_MALFORMED_FILE, NULL,
"Can't open existing subkey");
goto cleanup;
}
svn_err = parse_section(cfg, sub_hkey, section->data, option, value);
RegCloseKey(sub_hkey);
if (svn_err)
goto cleanup;
}
cleanup:
RegCloseKey(hkey);
svn_pool_destroy(subpool);
return svn_err;
}
/* This function is the shared guts of add_file() and add_directory(),
which see for the meanings of the parameters. The only extra
parameter here is IS_DIR, which is TRUE when adding a directory,
and FALSE when adding a file. */
static svn_error_t *
add_file_or_directory(const char *path,
void *parent_baton,
const char *copy_path,
svn_revnum_t copy_revision,
svn_boolean_t is_dir,
apr_pool_t *pool,
void **return_baton)
{
struct dir_baton *pb = parent_baton;
struct edit_baton *eb = pb->edit_baton;
apr_pool_t *subpool = svn_pool_create(pool);
svn_boolean_t was_copied = FALSE;
const char *full_path;
/* Reject paths which contain control characters (related to issue #4340). */
SVN_ERR(svn_path_check_valid(path, pool));
full_path = svn_fspath__join(eb->base_path,
svn_relpath_canonicalize(path, pool), pool);
/* Sanity check. */
if (copy_path && (! SVN_IS_VALID_REVNUM(copy_revision)))
return svn_error_createf
(SVN_ERR_FS_GENERAL, NULL,
_("Got source path but no source revision for '%s'"), full_path);
if (copy_path)
{
const char *fs_path;
svn_fs_root_t *copy_root;
svn_node_kind_t kind;
size_t repos_url_len;
svn_repos_authz_access_t required;
/* Copy requires recursive write access to the destination path
and write access to the parent path. */
required = svn_authz_write | (is_dir ? svn_authz_recursive : 0);
SVN_ERR(check_authz(eb, full_path, eb->txn_root,
required, subpool));
SVN_ERR(check_authz(eb, pb->path, eb->txn_root,
svn_authz_write, subpool));
/* Check PATH in our transaction. Make sure it does not exist
unless its parent directory was copied (in which case, the
thing might have been copied in as well), else return an
out-of-dateness error. */
SVN_ERR(svn_fs_check_path(&kind, eb->txn_root, full_path, subpool));
if ((kind != svn_node_none) && (! pb->was_copied))
return svn_error_trace(out_of_date(full_path, kind));
/* For now, require that the url come from the same repository
that this commit is operating on. */
copy_path = svn_path_uri_decode(copy_path, subpool);
repos_url_len = strlen(eb->repos_url);
if (strncmp(copy_path, eb->repos_url, repos_url_len) != 0)
return svn_error_createf
(SVN_ERR_FS_GENERAL, NULL,
_("Source url '%s' is from different repository"), copy_path);
fs_path = apr_pstrdup(subpool, copy_path + repos_url_len);
/* Now use the "fs_path" as an absolute path within the
repository to make the copy from. */
SVN_ERR(svn_fs_revision_root(©_root, eb->fs,
copy_revision, subpool));
/* Copy also requires (recursive) read access to the source */
required = svn_authz_read | (is_dir ? svn_authz_recursive : 0);
SVN_ERR(check_authz(eb, fs_path, copy_root, required, subpool));
SVN_ERR(svn_fs_copy(copy_root, fs_path,
eb->txn_root, full_path, subpool));
was_copied = TRUE;
}
else
{
/* No ancestry given, just make a new directory or empty file.
Note that we don't perform an existence check here like the
copy-from case does -- that's because svn_fs_make_*()
already errors out if the file already exists. Verify write
access to the full path and to the parent. */
SVN_ERR(check_authz(eb, full_path, eb->txn_root,
svn_authz_write, subpool));
SVN_ERR(check_authz(eb, pb->path, eb->txn_root,
svn_authz_write, subpool));
if (is_dir)
SVN_ERR(svn_fs_make_dir(eb->txn_root, full_path, subpool));
else
SVN_ERR(svn_fs_make_file(eb->txn_root, full_path, subpool));
}
/* Cleanup our temporary subpool. */
svn_pool_destroy(subpool);
/* Build a new child baton. */
if (is_dir)
{
*return_baton = make_dir_baton(eb, pb, full_path, was_copied,
SVN_INVALID_REVNUM, pool);
}
else
{
struct file_baton *new_fb = apr_pcalloc(pool, sizeof(*new_fb));
new_fb->edit_baton = eb;
new_fb->path = full_path;
*return_baton = new_fb;
}
return SVN_NO_ERROR;
}
