diff options
Diffstat (limited to 'subversion/svn/list-cmd.c')
| -rw-r--r-- | subversion/svn/list-cmd.c | 424 |
1 files changed, 424 insertions, 0 deletions
diff --git a/subversion/svn/list-cmd.c b/subversion/svn/list-cmd.c new file mode 100644 index 0000000..efe4279 --- /dev/null +++ b/subversion/svn/list-cmd.c @@ -0,0 +1,424 @@ +/* + * list-cmd.c -- list a URL + * + * ==================================================================== + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * ==================================================================== + */ + +#include "svn_cmdline.h" +#include "svn_client.h" +#include "svn_error.h" +#include "svn_pools.h" +#include "svn_time.h" +#include "svn_xml.h" +#include "svn_dirent_uri.h" +#include "svn_path.h" +#include "svn_utf.h" +#include "svn_opt.h" + +#include "cl.h" + +#include "svn_private_config.h" + + + +/* Baton used when printing directory entries. */ +struct print_baton { + svn_boolean_t verbose; + svn_client_ctx_t *ctx; + + /* To keep track of last seen external information. */ + const char *last_external_parent_url; + const char *last_external_target; + svn_boolean_t in_external; +}; + +/* This implements the svn_client_list_func2_t API, printing a single + directory entry in text format. */ +static svn_error_t * +print_dirent(void *baton, + const char *path, + const svn_dirent_t *dirent, + const svn_lock_t *lock, + const char *abs_path, + const char *external_parent_url, + const char *external_target, + apr_pool_t *scratch_pool) +{ + struct print_baton *pb = baton; + const char *entryname; + static const char *time_format_long = NULL; + static const char *time_format_short = NULL; + + SVN_ERR_ASSERT((external_parent_url == NULL && external_target == NULL) || + (external_parent_url && external_target)); + + if (time_format_long == NULL) + time_format_long = _("%b %d %H:%M"); + if (time_format_short == NULL) + time_format_short = _("%b %d %Y"); + + if (pb->ctx->cancel_func) + SVN_ERR(pb->ctx->cancel_func(pb->ctx->cancel_baton)); + + if (strcmp(path, "") == 0) + { + if (dirent->kind == svn_node_file) + entryname = svn_dirent_basename(abs_path, scratch_pool); + else if (pb->verbose) + entryname = "."; + else + /* Don't bother to list if no useful information will be shown. */ + return SVN_NO_ERROR; + } + else + entryname = path; + + if (external_parent_url && external_target) + { + if ((pb->last_external_parent_url == NULL + && pb->last_external_target == NULL) + || (strcmp(pb->last_external_parent_url, external_parent_url) != 0 + || strcmp(pb->last_external_target, external_target) != 0)) + { + SVN_ERR(svn_cmdline_printf(scratch_pool, + _("Listing external '%s'" + " defined on '%s':\n"), + external_target, + external_parent_url)); + + pb->last_external_parent_url = external_parent_url; + pb->last_external_target = external_target; + } + } + + if (pb->verbose) + { + apr_time_t now = apr_time_now(); + apr_time_exp_t exp_time; + apr_status_t apr_err; + apr_size_t size; + char timestr[20]; + const char *sizestr, *utf8_timestr; + + /* svn_time_to_human_cstring gives us something *way* too long + to use for this, so we have to roll our own. We include + the year if the entry's time is not within half a year. */ + apr_time_exp_lt(&exp_time, dirent->time); + if (apr_time_sec(now - dirent->time) < (365 * 86400 / 2) + && apr_time_sec(dirent->time - now) < (365 * 86400 / 2)) + { + apr_err = apr_strftime(timestr, &size, sizeof(timestr), + time_format_long, &exp_time); + } + else + { + apr_err = apr_strftime(timestr, &size, sizeof(timestr), + time_format_short, &exp_time); + } + + /* if that failed, just zero out the string and print nothing */ + if (apr_err) + timestr[0] = '\0'; + + /* we need it in UTF-8. */ + SVN_ERR(svn_utf_cstring_to_utf8(&utf8_timestr, timestr, scratch_pool)); + + sizestr = apr_psprintf(scratch_pool, "%" SVN_FILESIZE_T_FMT, + dirent->size); + + return svn_cmdline_printf + (scratch_pool, "%7ld %-8.8s %c %10s %12s %s%s\n", + dirent->created_rev, + dirent->last_author ? dirent->last_author : " ? ", + lock ? 'O' : ' ', + (dirent->kind == svn_node_file) ? sizestr : "", + utf8_timestr, + entryname, + (dirent->kind == svn_node_dir) ? "/" : ""); + } + else + { + return svn_cmdline_printf(scratch_pool, "%s%s\n", entryname, + (dirent->kind == svn_node_dir) + ? "/" : ""); + } +} + + +/* This implements the svn_client_list_func2_t API, printing a single dirent + in XML format. */ +static svn_error_t * +print_dirent_xml(void *baton, + const char *path, + const svn_dirent_t *dirent, + const svn_lock_t *lock, + const char *abs_path, + const char *external_parent_url, + const char *external_target, + apr_pool_t *scratch_pool) +{ + struct print_baton *pb = baton; + const char *entryname; + svn_stringbuf_t *sb = svn_stringbuf_create_empty(scratch_pool); + + SVN_ERR_ASSERT((external_parent_url == NULL && external_target == NULL) || + (external_parent_url && external_target)); + + if (strcmp(path, "") == 0) + { + if (dirent->kind == svn_node_file) + entryname = svn_dirent_basename(abs_path, scratch_pool); + else + /* Don't bother to list if no useful information will be shown. */ + return SVN_NO_ERROR; + } + else + entryname = path; + + if (pb->ctx->cancel_func) + SVN_ERR(pb->ctx->cancel_func(pb->ctx->cancel_baton)); + + if (external_parent_url && external_target) + { + if ((pb->last_external_parent_url == NULL + && pb->last_external_target == NULL) + || (strcmp(pb->last_external_parent_url, external_parent_url) != 0 + || strcmp(pb->last_external_target, external_target) != 0)) + { + if (pb->in_external) + { + /* The external item being listed is different from the previous + one, so close the tag. */ + svn_xml_make_close_tag(&sb, scratch_pool, "external"); + pb->in_external = FALSE; + } + + svn_xml_make_open_tag(&sb, scratch_pool, svn_xml_normal, "external", + "parent_url", external_parent_url, + "target", external_target, + NULL); + + pb->last_external_parent_url = external_parent_url; + pb->last_external_target = external_target; + pb->in_external = TRUE; + } + } + + svn_xml_make_open_tag(&sb, scratch_pool, svn_xml_normal, "entry", + "kind", svn_cl__node_kind_str_xml(dirent->kind), + NULL); + + svn_cl__xml_tagged_cdata(&sb, scratch_pool, "name", entryname); + + if (dirent->kind == svn_node_file) + { + svn_cl__xml_tagged_cdata + (&sb, scratch_pool, "size", + apr_psprintf(scratch_pool, "%" SVN_FILESIZE_T_FMT, dirent->size)); + } + + svn_xml_make_open_tag(&sb, scratch_pool, svn_xml_normal, "commit", + "revision", + apr_psprintf(scratch_pool, "%ld", dirent->created_rev), + NULL); + svn_cl__xml_tagged_cdata(&sb, scratch_pool, "author", dirent->last_author); + if (dirent->time) + svn_cl__xml_tagged_cdata(&sb, scratch_pool, "date", + svn_time_to_cstring(dirent->time, scratch_pool)); + svn_xml_make_close_tag(&sb, scratch_pool, "commit"); + + if (lock) + { + svn_xml_make_open_tag(&sb, scratch_pool, svn_xml_normal, "lock", NULL); + svn_cl__xml_tagged_cdata(&sb, scratch_pool, "token", lock->token); + svn_cl__xml_tagged_cdata(&sb, scratch_pool, "owner", lock->owner); + svn_cl__xml_tagged_cdata(&sb, scratch_pool, "comment", lock->comment); + svn_cl__xml_tagged_cdata(&sb, scratch_pool, "created", + svn_time_to_cstring(lock->creation_date, + scratch_pool)); + if (lock->expiration_date != 0) + svn_cl__xml_tagged_cdata(&sb, scratch_pool, "expires", + svn_time_to_cstring + (lock->expiration_date, scratch_pool)); + svn_xml_make_close_tag(&sb, scratch_pool, "lock"); + } + + svn_xml_make_close_tag(&sb, scratch_pool, "entry"); + + return svn_cl__error_checked_fputs(sb->data, stdout); +} + + +/* This implements the `svn_opt_subcommand_t' interface. */ +svn_error_t * +svn_cl__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; + svn_boolean_t seen_nonexistent_target = FALSE; + svn_error_t *err; + svn_error_t *externals_err = SVN_NO_ERROR; + struct svn_cl__check_externals_failed_notify_baton nwb; + + 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->xml) + { + /* The XML output contains all the information, so "--verbose" + does not apply. */ + if (opt_state->verbose) + return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL, + _("'verbose' option invalid in XML mode")); + + /* 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("lists", pool)); + } + else + { + 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->verbose || opt_state->xml) + 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; + + if (opt_state->include_externals) + { + nwb.wrapped_func = ctx->notify_func2; + nwb.wrapped_baton = ctx->notify_baton2; + nwb.had_externals_error = FALSE; + ctx->notify_func2 = svn_cl__check_externals_failed_notify_wrapper; + ctx->notify_baton2 = &nwb; + } + + /* 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; + + /* Initialize the following variables for + every list target. */ + pb.last_external_parent_url = NULL; + pb.last_external_target = NULL; + pb.in_external = FALSE; + + 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 (opt_state->xml) + { + svn_stringbuf_t *sb = svn_stringbuf_create_empty(pool); + svn_xml_make_open_tag(&sb, pool, svn_xml_normal, "list", + "path", truepath[0] == '\0' ? "." : truepath, + NULL); + SVN_ERR(svn_cl__error_checked_fputs(sb->data, stdout)); + } + + err = svn_client_list3(truepath, &peg_revision, + &(opt_state->start_revision), + opt_state->depth, + dirent_fields, + (opt_state->xml || opt_state->verbose), + opt_state->include_externals, + opt_state->xml ? print_dirent_xml : 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, "svn: "); + else + return svn_error_trace(err); + + svn_error_clear(err); + err = NULL; + seen_nonexistent_target = TRUE; + } + + if (opt_state->xml) + { + svn_stringbuf_t *sb = svn_stringbuf_create_empty(pool); + + if (pb.in_external) + { + /* close the final external item's tag */ + svn_xml_make_close_tag(&sb, pool, "external"); + pb.in_external = FALSE; + } + + svn_xml_make_close_tag(&sb, pool, "list"); + SVN_ERR(svn_cl__error_checked_fputs(sb->data, stdout)); + } + } + + svn_pool_destroy(subpool); + + if (opt_state->include_externals && nwb.had_externals_error) + { + externals_err = svn_error_create(SVN_ERR_CL_ERROR_PROCESSING_EXTERNALS, + NULL, + _("Failure occurred processing one or " + "more externals definitions")); + } + + if (opt_state->xml && ! opt_state->incremental) + SVN_ERR(svn_cl__xml_print_footer("lists", pool)); + + if (seen_nonexistent_target) + err = svn_error_create(SVN_ERR_ILLEGAL_TARGET, NULL, + _("Could not list all targets because some targets don't exist")); + + return svn_error_compose_create(externals_err, err); +} |
