svn_error_t *
svn_opt__arg_canonicalize_path(const char **path_out, const char *path_in,
apr_pool_t *pool)
{
const char *apr_target;
char *truenamed_target; /* APR-encoded */
apr_status_t apr_err;
/* canonicalize case, and change all separators to '/'. */
SVN_ERR(svn_path_cstring_from_utf8(&apr_target, path_in, pool));
apr_err = apr_filepath_merge(&truenamed_target, "", apr_target,
APR_FILEPATH_TRUENAME, pool);
if (!apr_err)
/* We have a canonicalized APR-encoded target now. */
apr_target = truenamed_target;
else if (APR_STATUS_IS_ENOENT(apr_err))
/* It's okay for the file to not exist, that just means we
have to accept the case given to the client. We'll use
the original APR-encoded target. */
;
else
return svn_error_createf(apr_err, NULL,
_("Error resolving case of '%s'"),
svn_dirent_local_style(path_in, pool));
/* convert back to UTF-8. */
SVN_ERR(svn_path_cstring_to_utf8(path_out, apr_target, pool));
*path_out = svn_dirent_canonicalize(*path_out, pool);
return SVN_NO_ERROR;
}
/* Return in *LINK_TARGET_ABSPATH the absolute path the symlink at
* LOCAL_ABSPATH is pointing to. Perform all allocations in POOL. */
static svn_error_t *
read_link_target(const char **link_target_abspath,
const char *local_abspath,
apr_pool_t *pool)
{
svn_string_t *link_target;
const char *canon_link_target;
SVN_ERR(svn_io_read_link(&link_target, local_abspath, pool));
if (link_target->len == 0)
return svn_error_createf(SVN_ERR_WC_NOT_SYMLINK, NULL,
_("The symlink at '%s' points nowhere"),
svn_dirent_local_style(local_abspath, pool));
canon_link_target = svn_dirent_canonicalize(link_target->data, pool);
/* Treat relative symlinks as relative to LOCAL_ABSPATH's parent. */
if (!svn_dirent_is_absolute(canon_link_target))
canon_link_target = svn_dirent_join(svn_dirent_dirname(local_abspath,
pool),
canon_link_target, pool);
/* Collapse any .. in the symlink part of the path. */
if (svn_path_is_backpath_present(canon_link_target))
SVN_ERR(svn_dirent_get_absolute(link_target_abspath, canon_link_target,
pool));
else
*link_target_abspath = canon_link_target;
return SVN_NO_ERROR;
}
int
main(int argc, const char *argv[])
{
apr_pool_t *pool;
int exit_code = EXIT_SUCCESS;
svn_error_t *err;
const char *url;
svn_revnum_t revision;
const char *propname;
svn_string_t *propval;
svn_string_t *old_propval;
char *digits_end = NULL;
svn_boolean_t want_error;
const char *config_dir;
if (argc != 7)
{
fprintf(stderr, USAGE_MSG, argv[0], KEY_OLD_PROPVAL, KEY_NEW_PROPVAL);
exit(1);
}
if (apr_initialize() != APR_SUCCESS)
{
fprintf(stderr, "apr_initialize() failed.\n");
exit(1);
}
/* set up the global pool */
pool = svn_pool_create(NULL);
/* Parse argv. */
url = svn_uri_canonicalize(argv[1], pool);
revision = strtol(argv[2], &digits_end, 10);
propname = argv[3];
SVN_INT_ERR(extract_values_from_skel(&old_propval, &propval, argv[4], pool));
want_error = !strcmp(argv[5], "1");
config_dir = svn_dirent_canonicalize(argv[6], pool);
if ((! SVN_IS_VALID_REVNUM(revision)) || (! digits_end) || *digits_end)
SVN_INT_ERR(svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("Invalid revision number supplied")));
/* Do something. */
err = change_rev_prop(url, revision, propname, propval, old_propval,
want_error, config_dir, pool);
if (err)
{
svn_handle_error2(err, stderr, FALSE, "atomic-ra-revprop-change: ");
svn_error_clear(err);
exit_code = EXIT_FAILURE;
}
/* Clean up, and get outta here */
svn_pool_destroy(pool);
apr_terminate();
return exit_code;
}
bool SVNPatch::PatchPath( const CString& path )
{
svn_error_t * err = NULL;
apr_pool_t * scratchpool = NULL;
svn_client_ctx_t * ctx = NULL;
m_errorStr.Empty();
m_patchfile.Replace('\\', '/');
m_targetpath.Replace('\\', '/');
m_filetopatch = path.Mid(m_targetpath.GetLength()+1);
m_filetopatch.Replace('\\', '/');
apr_pool_create_ex(&scratchpool, m_pool, abort_on_pool_failure, NULL);
svn_error_clear(svn_client_create_context2(&ctx, SVNConfig::Instance().GetConfig(m_pool), scratchpool));
m_nRejected = 0;
err = svn_client_patch(svn_dirent_canonicalize(CUnicodeUtils::GetUTF8(m_patchfile), scratchpool), // patch_abspath
svn_dirent_canonicalize(CUnicodeUtils::GetUTF8(m_targetpath), scratchpool), // local_abspath
false, // dry_run
m_nStrip, // strip_count
false, // reverse
true, // ignore_whitespace
true, // remove_tempfiles
patchfile_func, // patch_func
this, // patch_baton
ctx, // client context
scratchpool);
apr_pool_destroy(scratchpool);
if (err)
{
m_errorStr = GetErrorMessage(err);
svn_error_clear(err);
return false;
}
return true;
}
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;
}
void
Path::init(const char * path)
{
Pool pool;
m_pathIsUrl = false;
if (path == 0)
m_path = "";
else
{
const char * int_path = svn_dirent_canonicalize(path, pool);
m_path = int_path;
if (svn::Url::isValid(int_path))
m_pathIsUrl = true;
}
}
int
main(int argc, const char **argv)
{
apr_pool_t *pool;
svn_error_t *err = SVN_NO_ERROR;
const char *repos_path;
/* Initialize the app. Send all error messages to 'stderr'. */
if (svn_cmdline_init(argv[0], stderr) == EXIT_FAILURE)
return EXIT_FAILURE;
pool = svn_pool_create(NULL);
if (argc <= 1)
{
usage_maybe_with_err(argv[0], "Not enough arguments.");
goto cleanup;
}
/* Convert argv[1] into a UTF8, internal-format, canonicalized path. */
if ((err = svn_utf_cstring_to_utf8(&repos_path, argv[1], pool)))
goto cleanup;
repos_path = svn_dirent_internal_style(repos_path, pool);
repos_path = svn_dirent_canonicalize(repos_path, pool);
if ((err = build_index(repos_path, pool)))
goto cleanup;
cleanup:
svn_pool_destroy(pool);
if (err)
{
svn_handle_error2(err, stderr, FALSE,
"svn-populate-node-origins-index: ");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
/* UTF-8 encode and canonicalize the content of LINE as FILE_NAME. */
static svn_error_t *
grab_filename(const char **file_name, const char *line, apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
const char *utf8_path;
const char *canon_path;
/* Grab the filename and encode it in UTF-8. */
/* TODO: Allow specifying the patch file's encoding.
* For now, we assume its encoding is native. */
/* ### This can fail if the filename cannot be represented in the current
* ### locale's encoding. */
SVN_ERR(svn_utf_cstring_to_utf8(&utf8_path,
line,
scratch_pool));
/* Canonicalize the path name. */
canon_path = svn_dirent_canonicalize(utf8_path, scratch_pool);
*file_name = apr_pstrdup(result_pool, canon_path);
return SVN_NO_ERROR;
}
bool SVNPatch::RemoveFile( const CString& path )
{
svn_error_t * err = NULL;
apr_pool_t * scratchpool = NULL;
svn_client_ctx_t * ctx = NULL;
apr_pool_create_ex(&scratchpool, m_pool, abort_on_pool_failure, NULL);
svn_error_clear(svn_client_create_context2(&ctx, SVNConfig::Instance().GetConfig(m_pool), scratchpool));
apr_array_header_t *targets = apr_array_make (scratchpool, 1, sizeof(const char *));
(*((const char **) apr_array_push (targets))) = svn_dirent_canonicalize(CUnicodeUtils::GetUTF8(path), scratchpool);
err = svn_client_delete4(targets, true, false, NULL, NULL, NULL, ctx, scratchpool);
apr_pool_destroy(scratchpool);
if (err)
{
svn_error_clear(err);
return false;
}
return true;
}
