/* * info-cmd.c -- Display information about a resource * * ==================================================================== * 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. * ==================================================================== */ /* ==================================================================== */ /*** Includes. ***/ #include "svn_string.h" #include "svn_cmdline.h" #include "svn_wc.h" #include "svn_pools.h" #include "svn_error_codes.h" #include "svn_error.h" #include "svn_dirent_uri.h" #include "svn_path.h" #include "svn_time.h" #include "svn_xml.h" #include "cl.h" #include "svn_private_config.h" #include "private/svn_client_private.h" /*** Code. ***/ /* The dirent fields we care about for our calls to svn_ra_get_dir2. */ #define DIRENT_FIELDS (SVN_DIRENT_KIND | \ SVN_DIRENT_CREATED_REV | \ SVN_DIRENT_TIME | \ SVN_DIRENT_LAST_AUTHOR) /* 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 increment *COUNTER on all children of DIR, but none of their children; if svn_depth_files, then increment *COUNTER on file children of DIR but not on subdirectories; if svn_depth_infinity, recurse fully. DIR is a relpath, relative to the root of RA_SESSION. */ static svn_error_t * push_dir_info(svn_ra_session_t *ra_session, const svn_client__pathrev_t *pathrev, const char *dir, int *counter, svn_depth_t depth, svn_client_ctx_t *ctx, apr_pool_t *pool) { apr_hash_t *tmpdirents; 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, pathrev->rev, DIRENT_FIELDS, pool)); for (hi = apr_hash_first(pool, tmpdirents); hi; hi = apr_hash_next(hi)) { const char *path; const char *name = apr_hash_this_key(hi); svn_dirent_t *the_ent = apr_hash_this_val(hi); svn_client__pathrev_t *child_pathrev; svn_pool_clear(subpool); if (ctx->cancel_func) SVN_ERR(ctx->cancel_func(ctx->cancel_baton)); path = svn_relpath_join(dir, name, subpool); child_pathrev = svn_client__pathrev_join_relpath(pathrev, name, subpool); if (depth >= svn_depth_immediates || (depth == svn_depth_files && the_ent->kind == svn_node_file)) ++(*counter); if (depth == svn_depth_infinity && the_ent->kind == svn_node_dir) SVN_ERR(push_dir_info(ra_session, child_pathrev, path, counter, depth, ctx, subpool)); } svn_pool_destroy(subpool); return SVN_NO_ERROR; } /* Stripped-down version of svn_client_info3 */ static svn_error_t * client_info(const char *abspath_or_url, const svn_opt_revision_t *peg_revision, const svn_opt_revision_t *revision, svn_depth_t depth, svn_boolean_t fetch_excluded, svn_boolean_t fetch_actual_only, const apr_array_header_t *changelists, int *counter, svn_client_ctx_t *ctx, apr_pool_t *pool) { svn_ra_session_t *ra_session; svn_client__pathrev_t *pathrev; svn_lock_t *lock; const char *base_name; svn_dirent_t *the_ent; svn_error_t *err; if (depth == svn_depth_unknown) depth = svn_depth_empty; /* Go repository digging instead. */ /* Trace rename history (starting at path_or_url@peg_revision) and return RA session to the possibly-renamed URL as it exists in REVISION. The ra_session returned will be anchored on this "final" URL. */ SVN_ERR(svn_client__ra_session_from_path2(&ra_session, &pathrev, abspath_or_url, NULL, peg_revision, revision, ctx, pool)); svn_uri_split(NULL, &base_name, pathrev->url, pool); /* Get the dirent for the URL itself. */ SVN_ERR(svn_ra_stat(ra_session, "", pathrev->rev, &the_ent, pool)); if (! the_ent) return svn_error_createf(SVN_ERR_RA_ILLEGAL_URL, NULL, _("URL '%s' non-existent in revision %ld"), pathrev->url, pathrev->rev); /* check for locks */ err = svn_ra_get_lock(ra_session, &lock, "", pool); /* An old mod_dav_svn will always work; there's nothing wrong with doing a PROPFIND for a property named "DAV:supportedlock". But an old svnserve will error. */ if (err && err->apr_err == SVN_ERR_RA_NOT_IMPLEMENTED) { svn_error_clear(err); lock = NULL; } else if (err) return svn_error_trace(err); /* Push the URL's dirent (and lock) at the callback.*/ ++(*counter); /* Possibly recurse, using the original RA session. */ if (depth > svn_depth_empty && (the_ent->kind == svn_node_dir)) { apr_hash_t *locks; if (peg_revision->kind == svn_opt_revision_head) { err = svn_ra_get_locks2(ra_session, &locks, "", depth, pool); /* Catch specific errors thrown by old mod_dav_svn or svnserve. */ if (err && (err->apr_err == SVN_ERR_RA_NOT_IMPLEMENTED || err->apr_err == SVN_ERR_UNSUPPORTED_FEATURE)) svn_error_clear(err); else if (err) return svn_error_trace(err); } SVN_ERR(push_dir_info(ra_session, pathrev, "", counter, depth, ctx, pool)); } return SVN_NO_ERROR; } /* This implements the `svn_opt_subcommand_t' interface. */ svn_error_t * svn_cl__null_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 seen_nonexistent_target = FALSE; svn_opt_revision_t peg_revision; const char *path_prefix; 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->depth == svn_depth_unknown) opt_state->depth = svn_depth_empty; SVN_ERR(svn_dirent_get_absolute(&path_prefix, "", pool)); for (i = 0; i < targets->nelts; i++) { const char *truepath; const char *target = APR_ARRAY_IDX(targets, i, const char *); int received_count = 0; 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(truepath)) { if (peg_revision.kind == svn_opt_revision_unspecified) peg_revision.kind = svn_opt_revision_head; } else { SVN_ERR(svn_dirent_get_absolute(&truepath, truepath, subpool)); } err = client_info(truepath, &peg_revision, &(opt_state->start_revision), opt_state->depth, TRUE, TRUE, NULL, &received_count, 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_RA_ILLEGAL_URL) { svn_handle_warning2(stderr, err, "svnbench: "); svn_error_clear(svn_cmdline_fprintf(stderr, subpool, "\n")); } else { return svn_error_trace(err); } svn_error_clear(err); err = NULL; seen_nonexistent_target = TRUE; } else { SVN_ERR(svn_cmdline_printf(pool, _("Number of status notifications " "received: %d\n"), received_count)); } } svn_pool_destroy(subpool); if (seen_nonexistent_target) return svn_error_create( SVN_ERR_ILLEGAL_TARGET, NULL, _("Could not display info for all targets because some " "targets don't exist")); else return SVN_NO_ERROR; }