/* Check if the HOOK program exists and is a file or a symbolic link, using
POOL for temporary allocations.
If the hook exists but is a broken symbolic link, set *BROKEN_LINK
to TRUE, else if the hook program exists set *BROKEN_LINK to FALSE.
Return the hook program if found, else return NULL and don't touch
*BROKEN_LINK.
*/
static const char*
check_hook_cmd(const char *hook, svn_boolean_t *broken_link, apr_pool_t *pool)
{
static const char* const check_extns[] = {
#ifdef WIN32
/* For WIN32, we need to check with file name extension(s) added.
As Windows Scripting Host (.wsf) files can accomodate (at least)
JavaScript (.js) and VB Script (.vbs) code, extensions for the
corresponding file types need not be enumerated explicitly. */
".exe", ".cmd", ".bat", ".wsf", /* ### Any other extensions? */
#else
"",
#endif
NULL
};
const char *const *extn;
svn_error_t *err = NULL;
svn_boolean_t is_special;
for (extn = check_extns; *extn; ++extn)
{
const char *const hook_path =
(**extn ? apr_pstrcat(pool, hook, *extn, (char *)NULL) : hook);
svn_node_kind_t kind;
if (!(err = svn_io_check_resolved_path(hook_path, &kind, pool))
&& kind == svn_node_file)
{
*broken_link = FALSE;
return hook_path;
}
svn_error_clear(err);
if (!(err = svn_io_check_special_path(hook_path, &kind, &is_special,
pool))
&& is_special)
{
*broken_link = TRUE;
return hook_path;
}
svn_error_clear(err);
}
return NULL;
}
/* A helper function to parse_local_abspath() which returns the on-disk KIND
of LOCAL_ABSPATH, using DB and SCRATCH_POOL as needed.
This function may do strange things, but at long as it comes up with the
Right Answer, we should be happy. */
static svn_error_t *
get_path_kind(svn_node_kind_t *kind,
svn_wc__db_t *db,
const char *local_abspath,
apr_pool_t *scratch_pool)
{
svn_boolean_t special;
svn_node_kind_t node_kind;
/* This implements a *really* simple LRU cache, where "simple" is defined
as "only one element". In other words, we remember the most recently
queried path, and nothing else. This gives >80% cache hits. */
if (db->parse_cache.abspath
&& strcmp(db->parse_cache.abspath->data, local_abspath) == 0)
{
/* Cache hit! */
*kind = db->parse_cache.kind;
return SVN_NO_ERROR;
}
if (!db->parse_cache.abspath)
{
db->parse_cache.abspath = svn_stringbuf_create(local_abspath,
db->state_pool);
}
else
{
svn_stringbuf_set(db->parse_cache.abspath, local_abspath);
}
SVN_ERR(svn_io_check_special_path(local_abspath, &node_kind,
&special, scratch_pool));
db->parse_cache.kind = (special ? svn_node_symlink : node_kind);
*kind = db->parse_cache.kind;
return SVN_NO_ERROR;
}
/* Only call this if the on-disk node kind is a file. */
static svn_error_t *
add_file(const char *local_abspath,
svn_magic__cookie_t *magic_cookie,
svn_client_ctx_t *ctx,
apr_pool_t *pool)
{
apr_hash_t* properties;
apr_hash_index_t *hi;
const char *mimetype;
svn_node_kind_t kind;
svn_boolean_t is_special;
/* Check to see if this is a special file. */
SVN_ERR(svn_io_check_special_path(local_abspath, &kind, &is_special, pool));
if (is_special)
mimetype = NULL;
else
/* Get automatic properties */
/* This may fail on write-only files:
we open them to estimate file type.
That's why we postpone the add until after this step. */
SVN_ERR(svn_client__get_auto_props(&properties, &mimetype, local_abspath,
magic_cookie, ctx, pool));
/* Add the file */
SVN_ERR(svn_wc_add_from_disk(ctx->wc_ctx, local_abspath,
NULL, NULL, pool));
if (is_special)
/* This must be a special file. */
SVN_ERR(svn_wc_prop_set4(ctx->wc_ctx, local_abspath, SVN_PROP_SPECIAL,
svn_string_create(SVN_PROP_BOOLEAN_TRUE, pool),
svn_depth_empty, FALSE, NULL,
NULL, NULL /* cancellation */,
NULL, NULL /* notification */,
pool));
else if (properties)
{
/* loop through the hashtable and add the properties */
for (hi = apr_hash_first(pool, properties);
hi != NULL; hi = apr_hash_next(hi))
{
const char *pname = svn__apr_hash_index_key(hi);
const svn_string_t *pval = svn__apr_hash_index_val(hi);
svn_error_t *err;
/* It's probably best to pass 0 for force, so that if
the autoprops say to set some weird combination,
we just error and let the user sort it out. */
err = svn_wc_prop_set4(ctx->wc_ctx, local_abspath, pname, pval,
svn_depth_empty, FALSE, NULL,
NULL, NULL /* cancellation */,
NULL, NULL /* notification */,
pool);
if (err)
{
/* Don't leave the job half-done. If we fail to set a property,
* (try to) un-add the file. */
svn_error_clear(svn_wc_revert4(ctx->wc_ctx,
local_abspath,
svn_depth_empty,
FALSE /* use_commit_times */,
NULL /* changelists */,
NULL, NULL, NULL, NULL,
pool));
return svn_error_trace(err);
}
}
}
/* Report the addition to the caller. */
if (ctx->notify_func2 != NULL)
{
svn_wc_notify_t *notify = svn_wc_create_notify(local_abspath,
svn_wc_notify_add, pool);
notify->kind = svn_node_file;
notify->mime_type = mimetype;
(*ctx->notify_func2)(ctx->notify_baton2, notify, pool);
}
return SVN_NO_ERROR;
}
static svn_error_t *
add_file(const char *path,
svn_client_ctx_t *ctx,
svn_wc_adm_access_t *adm_access,
apr_pool_t *pool)
{
apr_hash_t* properties;
apr_hash_index_t *hi;
const char *mimetype;
svn_node_kind_t kind;
svn_boolean_t is_special;
/* Check to see if this is a special file. */
SVN_ERR(svn_io_check_special_path(path, &kind, &is_special, pool));
if (is_special)
mimetype = NULL;
else
/* Get automatic properties */
/* This may fail on write-only files:
we open them to estimate file type.
That's why we postpone the add until after this step. */
SVN_ERR(svn_client__get_auto_props(&properties, &mimetype, path, ctx,
pool));
/* Add the file */
SVN_ERR(svn_wc_add2(path, adm_access, NULL, SVN_INVALID_REVNUM,
ctx->cancel_func, ctx->cancel_baton,
NULL, NULL, pool));
if (is_special)
/* This must be a special file. */
SVN_ERR(svn_wc_prop_set2
(SVN_PROP_SPECIAL,
svn_string_create(SVN_PROP_BOOLEAN_TRUE, pool),
path, adm_access, FALSE, pool));
else if (properties)
{
/* loop through the hashtable and add the properties */
for (hi = apr_hash_first(pool, properties);
hi != NULL; hi = apr_hash_next(hi))
{
const void *pname;
void *pval;
apr_hash_this(hi, &pname, NULL, &pval);
/* It's probably best to pass 0 for force, so that if
the autoprops say to set some weird combination,
we just error and let the user sort it out. */
SVN_ERR(svn_wc_prop_set2(pname, pval, path,
adm_access, FALSE, pool));
}
}
/* Report the addition to the caller. */
if (ctx->notify_func2 != NULL)
{
svn_wc_notify_t *notify = svn_wc_create_notify(path, svn_wc_notify_add,
pool);
notify->kind = svn_node_file;
notify->mime_type = mimetype;
(*ctx->notify_func2)(ctx->notify_baton2, notify, pool);
}
return SVN_NO_ERROR;
}
/* Make a copy of the filesystem node (or tree if RECURSIVE) at
SRC_ABSPATH under a temporary name in the directory
TMPDIR_ABSPATH and return the absolute path of the copy in
*DST_ABSPATH. Return the node kind of SRC_ABSPATH in *KIND. If
SRC_ABSPATH doesn't exist then set *DST_ABSPATH to NULL to indicate
that no copy was made. */
static svn_error_t *
copy_to_tmpdir(svn_skel_t **work_item,
svn_node_kind_t *kind,
svn_wc__db_t *db,
const char *src_abspath,
const char *dst_abspath,
const char *tmpdir_abspath,
svn_boolean_t file_copy,
svn_boolean_t unversioned,
svn_cancel_func_t cancel_func,
void *cancel_baton,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_boolean_t is_special;
svn_io_file_del_t delete_when;
const char *dst_tmp_abspath;
svn_node_kind_t dsk_kind;
if (!kind)
kind = &dsk_kind;
*work_item = NULL;
SVN_ERR(svn_io_check_special_path(src_abspath, kind, &is_special,
scratch_pool));
if (*kind == svn_node_none)
{
return SVN_NO_ERROR;
}
else if (*kind == svn_node_unknown)
{
return svn_error_createf(SVN_ERR_NODE_UNEXPECTED_KIND, NULL,
_("Source '%s' is unexpected kind"),
svn_dirent_local_style(src_abspath,
scratch_pool));
}
else if (*kind == svn_node_dir || is_special)
delete_when = svn_io_file_del_on_close;
else /* the default case: (*kind == svn_node_file) */
delete_when = svn_io_file_del_none;
/* ### Do we need a pool cleanup to remove the copy? We can't use
### svn_io_file_del_on_pool_cleanup above because a) it won't
### handle the directory case and b) we need to be able to remove
### the cleanup before queueing the move work item. */
if (file_copy && !unversioned)
{
svn_boolean_t modified;
/* It's faster to look for mods on the source now, as
the timestamp might match, than to examine the
destination later as the destination timestamp will
never match. */
SVN_ERR(svn_wc__internal_file_modified_p(&modified,
db, src_abspath,
FALSE, scratch_pool));
if (!modified)
{
/* Why create a temp copy if we can just reinstall from pristine? */
SVN_ERR(svn_wc__wq_build_file_install(work_item,
db, dst_abspath, NULL, FALSE,
TRUE,
result_pool, scratch_pool));
return SVN_NO_ERROR;
}
}
/* Set DST_TMP_ABSPATH to a temporary unique path. If *KIND is file, leave
a file there and then overwrite it; otherwise leave no node on disk at
that path. In the latter case, something else might use that path
before we get around to using it a moment later, but never mind. */
SVN_ERR(svn_io_open_unique_file3(NULL, &dst_tmp_abspath, tmpdir_abspath,
delete_when, scratch_pool, scratch_pool));
if (*kind == svn_node_dir)
{
if (file_copy)
SVN_ERR(svn_io_copy_dir_recursively(
src_abspath,
tmpdir_abspath,
svn_dirent_basename(dst_tmp_abspath, scratch_pool),
TRUE, /* copy_perms */
cancel_func, cancel_baton,
scratch_pool));
else
SVN_ERR(svn_io_dir_make(dst_tmp_abspath, APR_OS_DEFAULT, scratch_pool));
}
else if (!is_special)
SVN_ERR(svn_io_copy_file(src_abspath, dst_tmp_abspath,
TRUE /* copy_perms */,
scratch_pool));
else
SVN_ERR(svn_io_copy_link(src_abspath, dst_tmp_abspath, scratch_pool));
if (file_copy)
{
/* Remove 'read-only' from the destination file; it's a local add now. */
SVN_ERR(svn_io_set_file_read_write(dst_tmp_abspath,
FALSE, scratch_pool));
}
SVN_ERR(svn_wc__wq_build_file_move(work_item, db, dst_abspath,
dst_tmp_abspath, dst_abspath,
result_pool, scratch_pool));
return SVN_NO_ERROR;
}
/*
* On success, leave *EXIT_CODE untouched and return SVN_NO_ERROR. On error,
* either return an error to be displayed, or set *EXIT_CODE to non-zero and
* return SVN_NO_ERROR.
*
* Why is this not an svn subcommand? I have this vague idea that it could
* be run as part of the build process, with the output embedded in the svn
* program. Obviously we don't want to have to run svn when building svn.
*/
static svn_error_t *
sub_main(int *exit_code, int argc, const char *argv[], apr_pool_t *pool)
{
const char *wc_path, *trail_url;
const char *local_abspath;
svn_wc_revision_status_t *res;
svn_boolean_t no_newline = FALSE, committed = FALSE;
svn_error_t *err;
apr_getopt_t *os;
svn_wc_context_t *wc_ctx;
svn_boolean_t quiet = FALSE;
svn_boolean_t is_version = FALSE;
const apr_getopt_option_t options[] =
{
{"no-newline", 'n', 0, N_("do not output the trailing newline")},
{"committed", 'c', 0, N_("last changed rather than current revisions")},
{"help", 'h', 0, N_("display this help")},
{"version", SVNVERSION_OPT_VERSION, 0,
N_("show program version information")},
{"quiet", 'q', 0,
N_("no progress (only errors) to stderr")},
{0, 0, 0, 0}
};
/* Check library versions */
SVN_ERR(check_lib_versions());
#if defined(WIN32) || defined(__CYGWIN__)
/* Set the working copy administrative directory name. */
if (getenv("SVN_ASP_DOT_NET_HACK"))
{
SVN_ERR(svn_wc_set_adm_dir("_svn", pool));
}
#endif
SVN_ERR(svn_cmdline__getopt_init(&os, argc, argv, pool));
os->interleave = 1;
while (1)
{
int opt;
const char *arg;
apr_status_t status = apr_getopt_long(os, options, &opt, &arg);
if (APR_STATUS_IS_EOF(status))
break;
if (status != APR_SUCCESS)
{
*exit_code = EXIT_FAILURE;
usage(pool);
return SVN_NO_ERROR;
}
switch (opt)
{
case 'n':
no_newline = TRUE;
break;
case 'c':
committed = TRUE;
break;
case 'q':
quiet = TRUE;
break;
case 'h':
help(options, pool);
return SVN_NO_ERROR;
case SVNVERSION_OPT_VERSION:
is_version = TRUE;
break;
default:
*exit_code = EXIT_FAILURE;
usage(pool);
return SVN_NO_ERROR;
}
}
if (is_version)
{
SVN_ERR(version(quiet, pool));
return SVN_NO_ERROR;
}
if (os->ind > argc || os->ind < argc - 2)
{
*exit_code = EXIT_FAILURE;
usage(pool);
return SVN_NO_ERROR;
}
SVN_ERR(svn_utf_cstring_to_utf8(&wc_path,
(os->ind < argc) ? os->argv[os->ind] : ".",
pool));
SVN_ERR(svn_opt__arg_canonicalize_path(&wc_path, wc_path, pool));
SVN_ERR(svn_dirent_get_absolute(&local_abspath, wc_path, pool));
SVN_ERR(svn_wc_context_create(&wc_ctx, NULL, pool, pool));
if (os->ind+1 < argc)
SVN_ERR(svn_utf_cstring_to_utf8(&trail_url, os->argv[os->ind+1], pool));
else
trail_url = NULL;
err = svn_wc_revision_status2(&res, wc_ctx, local_abspath, trail_url,
committed, NULL, NULL, pool, pool);
if (err && (err->apr_err == SVN_ERR_WC_PATH_NOT_FOUND
|| err->apr_err == SVN_ERR_WC_NOT_WORKING_COPY))
{
svn_node_kind_t kind;
svn_boolean_t special;
svn_error_clear(err);
SVN_ERR(svn_io_check_special_path(local_abspath, &kind, &special, pool));
if (special)
SVN_ERR(svn_cmdline_printf(pool, _("Unversioned symlink%s"),
no_newline ? "" : "\n"));
else if (kind == svn_node_dir)
SVN_ERR(svn_cmdline_printf(pool, _("Unversioned directory%s"),
no_newline ? "" : "\n"));
else if (kind == svn_node_file)
SVN_ERR(svn_cmdline_printf(pool, _("Unversioned file%s"),
no_newline ? "" : "\n"));
else
{
SVN_ERR(svn_cmdline_fprintf(stderr, pool,
kind == svn_node_none
? _("'%s' doesn't exist\n")
: _("'%s' is of unknown type\n"),
svn_dirent_local_style(local_abspath,
pool)));
*exit_code = EXIT_FAILURE;
return SVN_NO_ERROR;
}
return SVN_NO_ERROR;
}
SVN_ERR(err);
if (! SVN_IS_VALID_REVNUM(res->min_rev))
{
/* Local uncommitted modifications, no revision info was found. */
SVN_ERR(svn_cmdline_printf(pool, _("Uncommitted local addition, "
"copy or move%s"),
no_newline ? "" : "\n"));
return SVN_NO_ERROR;
}
/* Build compact '123[:456]M?S?' string. */
SVN_ERR(svn_cmdline_printf(pool, "%ld", res->min_rev));
if (res->min_rev != res->max_rev)
SVN_ERR(svn_cmdline_printf(pool, ":%ld", res->max_rev));
if (res->modified)
SVN_ERR(svn_cmdline_fputs("M", stdout, pool));
if (res->switched)
SVN_ERR(svn_cmdline_fputs("S", stdout, pool));
if (res->sparse_checkout)
SVN_ERR(svn_cmdline_fputs("P", stdout, pool));
if (! no_newline)
SVN_ERR(svn_cmdline_fputs("\n", stdout, pool));
return SVN_NO_ERROR;
}
