static svn_error_t *ra_svn_handle_add_file(svn_ra_svn_conn_t *conn,
apr_pool_t *pool,
const apr_array_header_t *params,
ra_svn_driver_state_t *ds)
{
const char *path, *token, *file_token, *copy_path;
svn_revnum_t copy_rev;
ra_svn_token_entry_t *entry, *file_entry;
SVN_ERR(svn_ra_svn__parse_tuple(params, pool, "ccc(?cr)", &path, &token,
&file_token, ©_path, ©_rev));
SVN_ERR(lookup_token(ds, token, FALSE, &entry));
ds->file_refs++;
path = svn_relpath_canonicalize(path, pool);
/* Some operations pass COPY_PATH as a full URL (commits, etc.).
Others (replay, e.g.) deliver an fspath. That's ... annoying. */
if (copy_path)
{
if (svn_path_is_url(copy_path))
copy_path = svn_uri_canonicalize(copy_path, pool);
else
copy_path = svn_fspath__canonicalize(copy_path, pool);
}
file_entry = store_token(ds, NULL, file_token, TRUE, ds->file_pool);
SVN_CMD_ERR(ds->editor->add_file(path, entry->baton, copy_path, copy_rev,
ds->file_pool, &file_entry->baton));
return SVN_NO_ERROR;
}
static int
l_move (lua_State *L) {
const char *src_path = luaL_checkstring (L, 1);
const char *dest_path = luaL_checkstring (L, 2);
const char *message = (lua_gettop (L) < 3 || lua_isnil (L, 3)) ? "" : luaL_checkstring (L, 3);
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
src_path = svn_path_canonicalize (src_path, pool);
dest_path = svn_path_canonicalize (dest_path, pool);
svn_commit_info_t *commit_info = NULL;
if (svn_path_is_url (dest_path)) {
make_log_msg_baton (&(ctx->log_msg_baton2), message, NULL, ctx->config, pool, L);
ctx->log_msg_func2 = log_msg_func2;
}
err = svn_client_move4 (&commit_info, src_path, dest_path, FALSE, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
if (commit_info == NULL) {
lua_pushnil (L);
} else {
lua_pushinteger (L, commit_info->revision);
}
svn_pool_destroy (pool);
return 1;
}
/* Helper to parse local repository path. Try parsing next parameter
* of OS as a local path to repository. If successfull *REPOS_PATH
* will contain internal style path to the repository.
*/
static svn_error_t *
parse_local_repos_path (apr_getopt_t *os,
const char ** repos_path,
apr_pool_t *pool)
{
*repos_path = NULL;
/* Check to see if there is one more parameter. */
if (os->ind < os->argc)
{
const char * path = os->argv[os->ind++];
SVN_ERR (svn_utf_cstring_to_utf8 (repos_path, path, pool));
*repos_path = svn_path_internal_style (*repos_path, pool);
}
if (*repos_path == NULL)
{
return svn_error_create (SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("Repository argument required"));
}
else if (svn_path_is_url (*repos_path))
{
return svn_error_createf (SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("'%s' is an URL when it should be a path"),
*repos_path);
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_repos__retrieve_config(svn_config_t **cfg_p,
const char *path,
svn_boolean_t must_exist,
svn_boolean_t case_sensitive,
apr_pool_t *pool)
{
if (svn_path_is_url(path))
{
const char *dirent;
svn_error_t *err;
apr_pool_t *scratch_pool = svn_pool_create(pool);
err = svn_uri_get_dirent_from_file_url(&dirent, path, scratch_pool);
if (err == SVN_NO_ERROR)
err = authz_retrieve_config_repo(cfg_p, dirent, must_exist,
case_sensitive, pool, scratch_pool);
/* Close the repos and streams we opened. */
svn_pool_destroy(scratch_pool);
return err;
}
else
{
/* Outside of repo file or Windows registry*/
SVN_ERR(svn_config_read3(cfg_p, path, must_exist, case_sensitive,
case_sensitive, pool));
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_client_switch3(svn_revnum_t *result_rev,
const char *path,
const char *switch_url,
const svn_opt_revision_t *peg_revision,
const svn_opt_revision_t *revision,
svn_depth_t depth,
svn_boolean_t depth_is_sticky,
svn_boolean_t ignore_externals,
svn_boolean_t allow_unver_obstructions,
svn_boolean_t ignore_ancestry,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
svn_error_t *err;
svn_boolean_t sleep_here = FALSE;
if (svn_path_is_url(path))
return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
_("'%s' is not a local path"), path);
err = svn_client__switch_internal(result_rev, path, switch_url,
peg_revision, revision, depth,
depth_is_sticky, ignore_externals,
allow_unver_obstructions,
ignore_ancestry, &sleep_here, ctx, pool);
/* Sleep to ensure timestamp integrity (we do this regardless of
errors in the actual switch operation(s)). */
if (sleep_here)
svn_io_sleep_for_timestamps(path, pool);
return svn_error_trace(err);
}
svn_error_t *
svn_client_get_repos_root(const char **repos_root,
const char **repos_uuid,
const char *abspath_or_url,
svn_client_ctx_t *ctx,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_ra_session_t *ra_session;
/* If PATH_OR_URL is a local path we can fetch the repos root locally. */
if (!svn_path_is_url(abspath_or_url))
{
SVN_ERR(svn_wc__node_get_repos_info(repos_root, repos_uuid,
ctx->wc_ctx, abspath_or_url,
result_pool, scratch_pool));
return SVN_NO_ERROR;
}
/* If PATH_OR_URL was a URL, we use the RA layer to look it up. */
SVN_ERR(svn_client__open_ra_session_internal(&ra_session, NULL,
abspath_or_url,
NULL, NULL, FALSE, TRUE,
ctx, scratch_pool));
if (repos_root)
SVN_ERR(svn_ra_get_repos_root2(ra_session, repos_root, result_pool));
if (repos_uuid)
SVN_ERR(svn_ra_get_uuid2(ra_session, repos_uuid, result_pool));
return SVN_NO_ERROR;
}
svn_error_t *
svn_ra_neon__copy_href(svn_stringbuf_t *dst, const char *src,
apr_pool_t *pool)
{
/* parse the PATH element out of the URL and store it.
### do we want to verify the rest matches the current session?
Note: mod_dav does not (currently) use an absolute URL, but simply a
server-relative path (i.e. this uri_parse is effectively a no-op).
*/
apr_uri_t uri;
apr_status_t apr_status;
/* SRC can have trailing '/' */
if (svn_path_is_url(src))
src = svn_uri_canonicalize(src, pool);
else
src = svn_urlpath__canonicalize(src, pool);
apr_status = apr_uri_parse(pool, src, &uri);
if (apr_status != APR_SUCCESS)
return svn_error_wrap_apr(apr_status,
_("Unable to parse URL '%s'"),
src);
svn_stringbuf_setempty(dst);
svn_stringbuf_appendcstr(dst, uri.path);
return SVN_NO_ERROR;
}
static svn_error_t *
rewrite_urls(const apr_array_header_t *targets,
svn_boolean_t ignore_externals,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
apr_pool_t *subpool;
const char *from;
const char *to;
if (targets->nelts < 2)
return svn_error_create(SVN_ERR_CL_INSUFFICIENT_ARGS, 0, NULL);
from = APR_ARRAY_IDX(targets, 0, const char *);
to = APR_ARRAY_IDX(targets, 1, const char *);
/* "--relocate http https" and "--relocate http://foo svn://bar" are OK,
but things like "--relocate http://foo svn" are not */
if (svn_path_is_url(from) != svn_path_is_url(to))
return svn_error_createf
(SVN_ERR_INCORRECT_PARAMS, NULL,
_("'%s' to '%s' is not a valid relocation"), from, to);
subpool = svn_pool_create(pool);
if (targets->nelts == 2)
{
SVN_ERR(svn_client_relocate2("", from, to, ignore_externals,
ctx, pool));
}
else
{
int i;
for (i = 2; i < targets->nelts; i++)
{
const char *target = APR_ARRAY_IDX(targets, i, const char *);
svn_pool_clear(subpool);
SVN_ERR(svn_client_relocate2(target, from, to,
ignore_externals, ctx, subpool));
}
}
svn_pool_destroy(subpool);
return SVN_NO_ERROR;
}
svn_error_t *
svn_cl__check_target_is_local_path(const char *target)
{
if (svn_path_is_url(target))
return svn_error_createf(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("'%s' is not a local path"), target);
return SVN_NO_ERROR;
}
svn_client__pathrev_t *
svn_client__pathrev_create(const char *repos_root_url,
const char *repos_uuid,
svn_revnum_t rev,
const char *url,
apr_pool_t *result_pool)
{
svn_client__pathrev_t *loc = apr_palloc(result_pool, sizeof(*loc));
SVN_ERR_ASSERT_NO_RETURN(svn_path_is_url(repos_root_url));
SVN_ERR_ASSERT_NO_RETURN(svn_path_is_url(url));
loc->repos_root_url = apr_pstrdup(result_pool, repos_root_url);
loc->repos_uuid = apr_pstrdup(result_pool, repos_uuid);
loc->rev = rev;
loc->url = apr_pstrdup(result_pool, url);
return loc;
}
svn_error_t *JNIUtil::preprocessPath(const char *&path, apr_pool_t *pool)
{
/* URLs and wc-paths get treated differently. */
if (svn_path_is_url(path))
{
/* No need to canonicalize a URL's case or path separators. */
/* Convert to URI. */
path = svn_path_uri_from_iri(path, pool);
/* Auto-escape some ASCII characters. */
path = svn_path_uri_autoescape(path, pool);
/* The above doesn't guarantee a valid URI. */
if (! svn_path_is_uri_safe(path))
return svn_error_createf(SVN_ERR_BAD_URL, NULL,
_("URL '%s' is not properly URI-encoded"),
path);
/* Verify that no backpaths are present in the URL. */
if (svn_path_is_backpath_present(path))
return svn_error_createf(SVN_ERR_BAD_URL, NULL,
_("URL '%s' contains a '..' element"),
path);
/* strip any trailing '/' */
path = svn_uri_canonicalize(path, pool);
}
else /* not a url, so treat as a path */
{
/* Normalize path to subversion internal style */
/* ### In Subversion < 1.6 this method on Windows actually tried
to lookup the path on disk to fix possible invalid casings in
the passed path. (An extremely expensive operation; especially
on network drives).
This 'feature'is now removed as it penalizes every correct
path passed, and also breaks behavior of e.g.
'svn status .' returns '!' file, because there is only a "File"
on disk.
But when you then call 'svn status file', you get '? File'.
As JavaHL is designed to be platform independent I assume users
don't want this broken behavior on non round-trippable paths, nor
the performance penalty.
*/
path = svn_dirent_internal_style(path, pool);
/* For kicks and giggles, let's absolutize it. */
SVN_ERR(svn_dirent_get_absolute(&path, path, pool));
}
return NULL;
}
/* Attempt to find the repository root url for TARGET, possibly using CTX for
* authentication. If one is found and *ROOT_URL is not NULL, then just check
* that the root url for TARGET matches the value given in *ROOT_URL and
* return an error if it does not. If one is found and *ROOT_URL is NULL then
* set *ROOT_URL to the root url for TARGET, allocated from POOL.
* If a root url is not found for TARGET because it does not exist in the
* repository, then return with no error.
*
* TARGET is a UTF-8 encoded string that is fully canonicalized and escaped.
*/
static svn_error_t *
check_root_url_of_target(const char **root_url,
const char *target,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
svn_error_t *err;
const char *tmp_root_url;
const char *truepath;
svn_opt_revision_t opt_rev;
SVN_ERR(svn_opt_parse_path(&opt_rev, &truepath, target, pool));
if (!svn_path_is_url(truepath))
SVN_ERR(svn_dirent_get_absolute(&truepath, truepath, pool));
err = svn_client__get_repos_root(&tmp_root_url, truepath,
ctx, pool, pool);
if (err)
{
/* It is OK if the given target does not exist, it just means
* we will not be able to determine the root url from this particular
* argument.
*
* If the target itself is a URL to a repository that does not exist,
* that's fine, too. The callers will deal with this argument in an
* appropriate manter if it does not make any sense.
*
* Also tolerate locally added targets ("bad revision" error).
*/
if ((err->apr_err == SVN_ERR_ENTRY_NOT_FOUND)
|| (err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND)
|| (err->apr_err == SVN_ERR_WC_NOT_WORKING_COPY)
|| (err->apr_err == SVN_ERR_RA_LOCAL_REPOS_OPEN_FAILED)
|| (err->apr_err == SVN_ERR_CLIENT_BAD_REVISION))
{
svn_error_clear(err);
return SVN_NO_ERROR;
}
else
return svn_error_trace(err);
}
if (*root_url && tmp_root_url)
{
if (strcmp(*root_url, tmp_root_url) != 0)
return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
_("All non-relative targets must have "
"the same root URL"));
}
else
*root_url = tmp_root_url;
return SVN_NO_ERROR;
}
const svn_opt_revision_t *
svn_cl__rev_default_to_head_or_working(const svn_opt_revision_t *revision,
const char *path_or_url)
{
static svn_opt_revision_t head_rev = { svn_opt_revision_head, { 0 } };
static svn_opt_revision_t work_rev = { svn_opt_revision_working, { 0 } };
if (revision->kind == svn_opt_revision_unspecified)
return svn_path_is_url(path_or_url) ? &head_rev : &work_rev;
return revision;
}
/* Return a string of the form "PATH_OR_URL@REVISION". */
static const char *
path_for_display(const char *path_or_url,
const svn_opt_revision_t *revision,
apr_pool_t *pool)
{
const char *rev_str = svn_opt__revision_to_string(revision, pool);
if (! svn_path_is_url(path_or_url))
path_or_url = svn_dirent_local_style(path_or_url, pool);
return apr_psprintf(pool, "%s@%s", path_or_url, rev_str);
}
svn_error_t *
svn_client_root_url_from_path(const char **url,
const char *path_or_url,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
svn_opt_revision_t peg_revision;
peg_revision.kind = svn_path_is_url(path_or_url) ? svn_opt_revision_head
: svn_opt_revision_base;
return svn_client__get_repos_root(url, path_or_url, &peg_revision,
NULL, ctx, pool);
}
svn_error_t *
svn_client_add4(const char *path,
svn_depth_t depth,
svn_boolean_t force,
svn_boolean_t no_ignore,
svn_boolean_t add_parents,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
const char *parent_abspath;
const char *local_abspath;
const char *existing_parent_abspath;
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, pool));
/* ### this is a hack.
### before we switched to absolute paths, if a user tried to do
### 'svn add .', PATH would be "" and PARENT_PATH would also be "",
### thus emulating the behavior below. Now that we are using
### absolute paths, svn_dirent_dirname() doesn't behave the same way
### w.r.t. '.', so we need to include the following hack. This
### behavior is tested in schedule_tests-11. */
if (path[0] == 0)
parent_abspath = local_abspath;
else
parent_abspath = svn_dirent_dirname(local_abspath, pool);
existing_parent_abspath = NULL;
if (add_parents)
{
apr_pool_t *subpool;
const char *existing_parent_abspath2;
subpool = svn_pool_create(pool);
SVN_ERR(find_existing_parent(&existing_parent_abspath2, ctx,
parent_abspath, pool, subpool));
if (strcmp(existing_parent_abspath2, parent_abspath) != 0)
existing_parent_abspath = existing_parent_abspath2;
svn_pool_destroy(subpool);
}
SVN_WC__CALL_WITH_WRITE_LOCK(
add(local_abspath, depth, force, no_ignore, existing_parent_abspath,
ctx, pool),
ctx->wc_ctx,
existing_parent_abspath ? existing_parent_abspath : parent_abspath,
FALSE /* lock_anchor */, pool);
return SVN_NO_ERROR;
}
static int
l_delete (lua_State *L) {
const char *path = luaL_checkstring (L, 1);
const char *message = (lua_gettop (L) < 2 || lua_isnil (L, 2)) ? "" : luaL_checkstring (L, 2);
svn_boolean_t force = FALSE;
int itable = 3;
if (lua_gettop (L) >= itable && lua_istable (L, itable)) {
lua_getfield (L, itable, "force");
if (lua_isboolean (L, -1)) {
force = lua_toboolean (L, -1);
}
}
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
apr_array_header_t *array;
svn_commit_info_t *commit_info = NULL;
array = apr_array_make (pool, 1, sizeof (const char *));
(*((const char **) apr_array_push (array))) = path;
lua_newtable (L);
if (svn_path_is_url (path)) {
make_log_msg_baton (&(ctx->log_msg_baton2), message, NULL, ctx->config, pool, L);
ctx->log_msg_func2 = log_msg_func2;
}
err = svn_client_delete2 (&commit_info, array, force, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
if (commit_info == NULL) {
lua_pushnil (L);
} else {
lua_pushinteger (L, commit_info->revision);
}
svn_pool_destroy (pool);
return 1;
}
bool CTSVNPath::IsUrl() const
{
if (!m_bURLKnown)
{
EnsureFwdslashPathSet();
if(m_sUTF8FwdslashPath.IsEmpty())
{
SetUTF8FwdslashPath(m_sFwdslashPath);
}
m_bIsURL = !!svn_path_is_url(m_sUTF8FwdslashPath);
m_bURLKnown = true;
}
return m_bIsURL;
}
svn_error_t *
svn_client_propset_remote(const char *propname,
const svn_string_t *propval,
const char *url,
svn_boolean_t skip_checks,
svn_revnum_t base_revision_for_url,
const apr_hash_t *revprop_table,
svn_commit_callback2_t commit_callback,
void *commit_baton,
svn_client_ctx_t *ctx,
apr_pool_t *scratch_pool)
{
if (!svn_path_is_url(url))
return svn_error_create(SVN_ERR_ILLEGAL_TARGET, NULL,
_("Targets must be URLs"));
SVN_ERR(check_prop_name(propname, propval));
/* The rationale for requiring the base_revision_for_url
argument is that without it, it's too easy to possibly
overwrite someone else's change without noticing. (See also
tools/examples/svnput.c). */
if (! SVN_IS_VALID_REVNUM(base_revision_for_url))
return svn_error_create(SVN_ERR_CLIENT_BAD_REVISION, NULL,
_("Setting property on non-local targets "
"needs a base revision"));
/* ### When you set svn:eol-style or svn:keywords on a wc file,
### Subversion sends a textdelta at commit time to properly
### normalize the file in the repository. If we want to
### support editing these properties on URLs, then we should
### generate the same textdelta; for now, we won't support
### editing these properties on URLs. (Admittedly, this
### means that all the machinery with get_file_for_validation
### is unused.)
*/
if ((strcmp(propname, SVN_PROP_EOL_STYLE) == 0) ||
(strcmp(propname, SVN_PROP_KEYWORDS) == 0))
return svn_error_createf(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("Setting property '%s' on non-local "
"targets is not supported"), propname);
SVN_ERR(propset_on_url(propname, propval, url, skip_checks,
base_revision_for_url, revprop_table,
commit_callback, commit_baton, ctx, scratch_pool));
return SVN_NO_ERROR;
}
static int
l_copy (lua_State *L) {
const char *src_path = luaL_checkstring (L, 1);
const char *dest_path = luaL_checkstring (L, 2);
svn_opt_revision_t revision;
if (lua_gettop (L) < 3 || lua_isnil (L, 3)) {
revision.kind = svn_opt_revision_unspecified;
} else {
revision.kind = svn_opt_revision_number;
revision.value.number = lua_tointeger (L, 3);
}
const char *message = (lua_gettop (L) < 4 || lua_isnil (L, 4)) ? "" : luaL_checkstring (L, 4);
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
src_path = svn_path_canonicalize (src_path, pool);
dest_path = svn_path_canonicalize (dest_path, pool);
svn_commit_info_t *commit_info = NULL;
if (svn_path_is_url (dest_path)) {
make_log_msg_baton (&(ctx->log_msg_baton2), message, NULL, ctx->config, pool, L);
ctx->log_msg_func2 = log_msg_func2;
}
err = svn_client_copy3 (&commit_info, src_path, &revision, dest_path, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
if (commit_info == NULL) {
lua_pushnil (L);
} else {
lua_pushinteger (L, commit_info->revision);
}
svn_pool_destroy (pool);
return 1;
}
/* Canonicalize ACCESS_FILE into *CANONICALIZED_ACCESS_FILE based on the type
of argument. Error out on unsupported path types. If WITHIN_TXN is set,
ACCESS_FILE has to be a fspath in the repo. Use POOL for allocations. */
static svn_error_t *
canonicalize_access_file(const char **canonicalized_access_file,
const char *access_file,
svn_boolean_t within_txn,
apr_pool_t *pool)
{
if (svn_path_is_repos_relative_url(access_file))
{
/* Can't accept repos relative urls since we don't have the path to
* the repository. */
return svn_error_createf(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
("'%s' is a repository relative URL when it "
"should be a local path or file:// URL"),
access_file);
}
else if (svn_path_is_url(access_file))
{
if (within_txn)
{
/* Don't allow urls with transaction argument. */
return svn_error_createf(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
("'%s' is a URL when it should be a "
"repository-relative path"),
access_file);
}
*canonicalized_access_file = svn_uri_canonicalize(access_file, pool);
}
else if (within_txn)
{
/* Transaction flag means this has to be a fspath to the access file
* in the repo. */
*canonicalized_access_file =
svn_fspath__canonicalize(access_file, pool);
}
else
{
/* If it isn't a URL and there's no transaction flag then it's a
* dirent to the access file on local disk. */
*canonicalized_access_file =
svn_dirent_internal_style(access_file, pool);
}
return SVN_NO_ERROR;
}
svn_error_t *
svn_client_cleanup(const char *path,
svn_client_ctx_t *ctx,
apr_pool_t *scratch_pool)
{
const char *local_abspath;
svn_error_t *err;
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));
err = svn_wc_cleanup3(ctx->wc_ctx, local_abspath, ctx->cancel_func,
ctx->cancel_baton, scratch_pool);
svn_io_sleep_for_timestamps(path, scratch_pool);
return svn_error_trace(err);
}
svn_error_t *
svn_client__pathrev_create_with_session(svn_client__pathrev_t **pathrev_p,
svn_ra_session_t *ra_session,
svn_revnum_t rev,
const char *url,
apr_pool_t *result_pool)
{
svn_client__pathrev_t *pathrev = apr_palloc(result_pool, sizeof(*pathrev));
SVN_ERR_ASSERT(svn_path_is_url(url));
SVN_ERR(svn_ra_get_repos_root2(ra_session, &pathrev->repos_root_url,
result_pool));
SVN_ERR(svn_ra_get_uuid2(ra_session, &pathrev->repos_uuid, result_pool));
pathrev->rev = rev;
pathrev->url = apr_pstrdup(result_pool, url);
*pathrev_p = pathrev;
return SVN_NO_ERROR;
}
const char* CTSVNPath::GetSVNApiPath(apr_pool_t *pool) const
{
// This funny-looking 'if' is to avoid a subtle problem with empty paths, whereby
// each call to GetSVNApiPath returns a different pointer value.
// If you made multiple calls to GetSVNApiPath on the same string, only the last
// one would give you a valid pointer to an empty string, because each
// call would invalidate the previous call's return.
if(IsEmpty())
{
return "";
}
if(m_sFwdslashPath.IsEmpty())
{
SetFwdslashPath(m_sBackslashPath);
}
if(m_sUTF8FwdslashPath.IsEmpty())
{
SetUTF8FwdslashPath(m_sFwdslashPath);
}
if (svn_path_is_url(m_sUTF8FwdslashPath))
{
m_sUTF8FwdslashPathEscaped = CPathUtils::PathEscape(m_sUTF8FwdslashPath);
m_sUTF8FwdslashPathEscaped.Replace("file:////", "file://");
m_sUTF8FwdslashPathEscaped = svn_uri_canonicalize(m_sUTF8FwdslashPathEscaped, pool);
return m_sUTF8FwdslashPathEscaped;
}
else
{
m_sUTF8FwdslashPath = svn_dirent_canonicalize(m_sUTF8FwdslashPath, pool);
// for UNC paths that point to the server directly (e.g., \\MYSERVER), not
// to a share on the server, the svn_dirent_canonicalize() API returns
// a wrong path that asserts when subversion checks that the path is absolute
// (it returns /MYSERVER instead of //MYSERVER).
// We can't just add the second slash, since that would assert when svn checks
// for canonicalized paths.
// Since the network server itself isn't interesting anyway but only shares,
// we just return an empty path here.
if (!svn_dirent_is_absolute(m_sUTF8FwdslashPath))
m_sUTF8FwdslashPath.Empty();
}
return m_sUTF8FwdslashPath;
}
svn_error_t *
svn_client_add_to_changelist(const apr_array_header_t *paths,
const char *changelist,
svn_depth_t depth,
const apr_array_header_t *changelists,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
apr_pool_t *iterpool = svn_pool_create(pool);
int i;
if (changelist[0] == '\0')
return svn_error_create(SVN_ERR_BAD_CHANGELIST_NAME, NULL,
_("Target changelist name must not be empty"));
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);
}
for (i = 0; i < paths->nelts; i++)
{
const char *path = APR_ARRAY_IDX(paths, i, const char *);
const char *local_abspath;
svn_pool_clear(iterpool);
SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, iterpool));
SVN_ERR(svn_wc_set_changelist2(ctx->wc_ctx, local_abspath, changelist,
depth, changelists,
ctx->cancel_func, ctx->cancel_baton,
ctx->notify_func2, ctx->notify_baton2,
iterpool));
}
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
svn_error_t *
svn_client__assert_homogeneous_target_type(const apr_array_header_t *targets)
{
svn_boolean_t wc_present = FALSE, url_present = FALSE;
int i;
for (i = 0; i < targets->nelts; ++i)
{
const char *target = APR_ARRAY_IDX(targets, i, const char *);
if (! svn_path_is_url(target))
wc_present = TRUE;
else
url_present = TRUE;
if (url_present && wc_present)
return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
_("Cannot mix repository and working copy "
"targets"));
}
return SVN_NO_ERROR;
}
static int
l_mkdir (lua_State *L) {
const char *path = luaL_checkstring (L, 1);
const char *message = (lua_gettop (L) < 2 || lua_isnil (L, 2)) ? "" : luaL_checkstring (L, 2);
apr_pool_t *pool;
svn_error_t *err;
svn_client_ctx_t *ctx;
init_function (&ctx, &pool, L);
path = svn_path_canonicalize (path, pool);
svn_commit_info_t *commit_info = NULL;
apr_array_header_t *array;
array = apr_array_make (pool, 1, sizeof (const char *));
(*((const char **) apr_array_push (array))) = path;
if (svn_path_is_url (path)) {
make_log_msg_baton (&(ctx->log_msg_baton2), message, NULL, ctx->config, pool, L);
ctx->log_msg_func2 = log_msg_func2;
}
err = svn_client_mkdir2 (&commit_info, array, ctx, pool);
IF_ERROR_RETURN (err, pool, L);
if (commit_info == NULL) {
lua_pushnil (L);
} else {
lua_pushinteger (L, commit_info->revision);
}
svn_pool_destroy (pool);
return 1;
}
svn_error_t *
svn_client_switch3(svn_revnum_t *result_rev,
const char *path,
const char *switch_url,
const svn_opt_revision_t *peg_revision,
const svn_opt_revision_t *revision,
svn_depth_t depth,
svn_boolean_t depth_is_sticky,
svn_boolean_t ignore_externals,
svn_boolean_t allow_unver_obstructions,
svn_boolean_t ignore_ancestry,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
if (svn_path_is_url(path))
return svn_error_createf(SVN_ERR_ILLEGAL_TARGET, NULL,
_("'%s' is not a local path"), path);
return svn_client__switch_internal(result_rev, path, switch_url,
peg_revision, revision, depth,
depth_is_sticky, ignore_externals,
allow_unver_obstructions,
ignore_ancestry, NULL, ctx, pool);
}
svn_error_t *
svn_client__iprop_relpaths_to_urls(apr_array_header_t *inherited_props,
const char *repos_root_url,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
int i;
for (i = 0; i < inherited_props->nelts; i++)
{
svn_prop_inherited_item_t *elt =
APR_ARRAY_IDX(inherited_props, i, svn_prop_inherited_item_t *);
/* Convert repos root relpaths to full URLs. */
if (! (svn_path_is_url(elt->path_or_url)
|| svn_dirent_is_absolute(elt->path_or_url)))
{
elt->path_or_url = svn_path_url_add_component2(repos_root_url,
elt->path_or_url,
result_pool);
}
}
return SVN_NO_ERROR;
}
/* If the components of RELPATH exactly match (after being
URI-encoded) the final components of URL, return a copy of URL
minus those components allocated in RESULT_POOL; otherwise, return
NULL. */
static const char *
url_remove_final_relpath(const char *url,
const char *relpath,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
char *result = apr_pstrdup(result_pool, url);
char *result_end;
const char *relpath_end;
SVN_ERR_ASSERT_NO_RETURN(svn_path_is_url(url));
SVN_ERR_ASSERT_NO_RETURN(svn_relpath_is_canonical(relpath));
if (relpath[0] == 0)
return result;
relpath = svn_path_uri_encode(relpath, scratch_pool);
result_end = result + strlen(result) - 1;
relpath_end = relpath + strlen(relpath) - 1;
while (relpath_end >= relpath)
{
if (*result_end != *relpath_end)
return NULL;
relpath_end--;
result_end--;
}
if (*result_end != '/')
return NULL;
*result_end = 0;
return result;
}
