/*
* propget-cmd.c -- Print properties and values of files/dirs
*
* ====================================================================
* 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_hash.h"
#include "svn_cmdline.h"
#include "svn_pools.h"
#include "svn_client.h"
#include "svn_string.h"
#include "svn_error_codes.h"
#include "svn_error.h"
#include "svn_utf.h"
#include "svn_sorts.h"
#include "svn_subst.h"
#include "svn_dirent_uri.h"
#include "svn_path.h"
#include "svn_props.h"
#include "svn_xml.h"
#include "cl.h"
#include "private/svn_cmdline_private.h"
#include "svn_private_config.h"
/*** Code. ***/
static svn_error_t *
stream_write(svn_stream_t *out,
const char *data,
apr_size_t len)
{
apr_size_t write_len = len;
/* We're gonna bail on an incomplete write here only because we know
that this stream is really stdout, which should never be blocking
on us. */
SVN_ERR(svn_stream_write(out, data, &write_len));
if (write_len != len)
return svn_error_create(SVN_ERR_STREAM_UNEXPECTED_EOF, NULL,
_("Error writing to stream"));
return SVN_NO_ERROR;
}
static svn_error_t *
print_properties_xml(const char *pname,
apr_hash_t *props,
apr_array_header_t *inherited_props,
apr_pool_t *pool)
{
apr_array_header_t *sorted_props;
int i;
apr_pool_t *iterpool = NULL;
svn_stringbuf_t *sb;
if (inherited_props && inherited_props->nelts)
{
iterpool = svn_pool_create(pool);
for (i = 0; i < inherited_props->nelts; i++)
{
const char *name_local;
svn_prop_inherited_item_t *iprop =
APR_ARRAY_IDX(inherited_props, i, svn_prop_inherited_item_t *);
svn_string_t *propval = svn__apr_hash_index_val(
apr_hash_first(pool, iprop->prop_hash));
sb = NULL;
svn_pool_clear(iterpool);
if (svn_path_is_url(iprop->path_or_url))
name_local = iprop->path_or_url;
else
name_local = svn_dirent_local_style(iprop->path_or_url, iterpool);
svn_xml_make_open_tag(&sb, iterpool, svn_xml_normal, "target",
"path", name_local, NULL);
svn_cmdline__print_xml_prop(&sb, pname, propval, TRUE, iterpool);
svn_xml_make_close_tag(&sb, iterpool, "target");
SVN_ERR(svn_cl__error_checked_fputs(sb->data, stdout));
}
}
if (iterpool == NULL)
iterpool = svn_pool_create(iterpool);
sorted_props = svn_sort__hash(props, svn_sort_compare_items_as_paths, pool);
for (i = 0; i < sorted_props->nelts; i++)
{
svn_sort__item_t item = APR_ARRAY_IDX(sorted_props, i, svn_sort__item_t);
const char *filename = item.key;
svn_string_t *propval = item.value;
sb = NULL;
svn_pool_clear(iterpool);
svn_xml_make_open_tag(&sb, iterpool, svn_xml_normal, "target",
"path", filename, NULL);
svn_cmdline__print_xml_prop(&sb, pname, propval, FALSE, iterpool);
svn_xml_make_close_tag(&sb, iterpool, "target");
SVN_ERR(svn_cl__error_checked_fputs(sb->data, stdout));
}
if (iterpool)
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
/* Print the property PNAME_UTF with the value PROPVAL set on ABSPATH_OR_URL
to the stream OUT.
If INHERITED_PROPERTY is true then the property described is inherited,
otherwise it is explicit.
WC_PATH_PREFIX is the absolute path of the current working directory (and
is ignored if ABSPATH_OR_URL is a URL).
All other arguments are as per print_properties. */
static svn_error_t *
print_single_prop(svn_string_t *propval,
const char *target_abspath_or_url,
const char *abspath_or_URL,
const char *wc_path_prefix,
svn_stream_t *out,
const char *pname_utf8,
svn_boolean_t print_filenames,
svn_boolean_t omit_newline,
svn_boolean_t like_proplist,
svn_boolean_t inherited_property,
apr_pool_t *scratch_pool)
{
if (print_filenames)
{
const char *header;
/* Print the file name. */
if (! svn_path_is_url(abspath_or_URL))
abspath_or_URL = svn_cl__local_style_skip_ancestor(wc_path_prefix,
abspath_or_URL,
scratch_pool);
/* In verbose mode, print exactly same as "proplist" does;
* otherwise, print a brief header. */
if (inherited_property)
{
if (like_proplist)
{
if (! svn_path_is_url(target_abspath_or_url))
target_abspath_or_url =
svn_cl__local_style_skip_ancestor(wc_path_prefix,
target_abspath_or_url,
scratch_pool);
header = apr_psprintf(
scratch_pool,
_("Inherited properties on '%s',\nfrom '%s':\n"),
target_abspath_or_url, abspath_or_URL);
}
else
{
header = apr_psprintf(scratch_pool, "%s - ", abspath_or_URL);
}
}
else
header = apr_psprintf(scratch_pool, like_proplist
? _("Properties on '%s':\n")
: "%s - ", abspath_or_URL);
SVN_ERR(svn_cmdline_cstring_from_utf8(&header, header, scratch_pool));
SVN_ERR(svn_subst_translate_cstring2(header, &header,
APR_EOL_STR, /* 'native' eol */
FALSE, /* no repair */
NULL, /* no keywords */
FALSE, /* no expansion */
scratch_pool));
SVN_ERR(stream_write(out, header, strlen(header)));
}
if (like_proplist)
{
/* Print the property name and value just as "proplist -v" does */
apr_hash_t *hash = apr_hash_make(scratch_pool);
svn_hash_sets(hash, pname_utf8, propval);
SVN_ERR(svn_cmdline__print_prop_hash(out, hash, FALSE, scratch_pool));
}
else
{
/* If this is a special Subversion property, it is stored as
UTF8, so convert to the native format. */
if (svn_prop_needs_translation(pname_utf8))
SVN_ERR(svn_subst_detranslate_string(&propval, propval,
TRUE, scratch_pool));
SVN_ERR(stream_write(out, propval->data, propval->len));
if (! omit_newline)
SVN_ERR(stream_write(out, APR_EOL_STR,
strlen(APR_EOL_STR)));
}
return SVN_NO_ERROR;
}
/* Print the properties in PROPS and/or *INHERITED_PROPS to the stream OUT.
PROPS is a hash mapping (const char *) path to (svn_string_t) property
value. INHERITED_PROPS is a depth-first ordered array of
svn_prop_inherited_item_t * structures.
TARGET_ABSPATH_OR_URL is the path which inherits INHERITED_PROPS.
PROPS may be an empty hash, but is never null. INHERITED_PROPS may be
null.
If IS_URL is true, all paths in PROPS are URLs, else all paths are local
paths.
PNAME_UTF8 is the property name of all the properties.
If PRINT_FILENAMES is true, print the item's path before each property.
If OMIT_NEWLINE is true, don't add a newline at the end of each property.
If LIKE_PROPLIST is true, print everything in a more verbose format
like "svn proplist -v" does. */
static svn_error_t *
print_properties(svn_stream_t *out,
const char *target_abspath_or_url,
const char *pname_utf8,
apr_hash_t *props,
apr_array_header_t *inherited_props,
svn_boolean_t print_filenames,
svn_boolean_t omit_newline,
svn_boolean_t like_proplist,
apr_pool_t *pool)
{
apr_array_header_t *sorted_props;
int i;
apr_pool_t *iterpool = svn_pool_create(pool);
const char *path_prefix;
SVN_ERR(svn_dirent_get_absolute(&path_prefix, "", pool));
if (inherited_props)
{
svn_pool_clear(iterpool);
for (i = 0; i < inherited_props->nelts; i++)
{
svn_prop_inherited_item_t *iprop =
APR_ARRAY_IDX(inherited_props, i, svn_prop_inherited_item_t *);
svn_string_t *propval = svn__apr_hash_index_val(apr_hash_first(pool,
iprop->prop_hash));
SVN_ERR(print_single_prop(propval, target_abspath_or_url,
iprop->path_or_url,
path_prefix, out, pname_utf8,
print_filenames, omit_newline,
like_proplist, TRUE, iterpool));
}
}
sorted_props = svn_sort__hash(props, svn_sort_compare_items_as_paths, pool);
for (i = 0; i < sorted_props->nelts; i++)
{
svn_sort__item_t item = APR_ARRAY_IDX(sorted_props, i, svn_sort__item_t);
const char *filename = item.key;
svn_string_t *propval = item.value;
svn_pool_clear(iterpool);
SVN_ERR(print_single_prop(propval, target_abspath_or_url, filename,
path_prefix, out, pname_utf8, print_filenames,
omit_newline, like_proplist, FALSE,
iterpool));
}
svn_pool_destroy(iterpool);
return SVN_NO_ERROR;
}
/* This implements the `svn_opt_subcommand_t' interface. */
svn_error_t *
svn_cl__propget(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;
const char *pname, *pname_utf8;
apr_array_header_t *args, *targets;
svn_stream_t *out;
if (opt_state->verbose && (opt_state->revprop || opt_state->strict
|| opt_state->xml))
return svn_error_create(SVN_ERR_CL_MUTUALLY_EXCLUSIVE_ARGS, NULL,
_("--verbose cannot be used with --revprop or "
"--strict or --xml"));
/* PNAME is first argument (and PNAME_UTF8 will be a UTF-8 version
thereof) */
SVN_ERR(svn_opt_parse_num_args(&args, os, 1, pool));
pname = APR_ARRAY_IDX(args, 0, const char *);
SVN_ERR(svn_utf_cstring_to_utf8(&pname_utf8, pname, pool));
if (! svn_prop_name_is_valid(pname_utf8))
return svn_error_createf(SVN_ERR_CLIENT_PROPERTY_NAME, NULL,
_("'%s' is not a valid Subversion property name"),
pname_utf8);
SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os,
opt_state->targets,
ctx, FALSE, pool));
/* Add "." if user passed 0 file arguments */
svn_opt_push_implicit_dot_target(targets, pool);
/* Open a stream to stdout. */
SVN_ERR(svn_stream_for_stdout(&out, pool));
if (opt_state->revprop) /* operate on a revprop */
{
svn_revnum_t rev;
const char *URL;
svn_string_t *propval;
if (opt_state->show_inherited_props)
return svn_error_create(
SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("--show-inherited-props can't be used with --revprop"));
SVN_ERR(svn_cl__revprop_prepare(&opt_state->start_revision, targets,
&URL, ctx, pool));
/* Let libsvn_client do the real work. */
SVN_ERR(svn_client_revprop_get(pname_utf8, &propval,
URL, &(opt_state->start_revision),
&rev, ctx, pool));
if (propval != NULL)
{
if (opt_state->xml)
{
svn_stringbuf_t *sb = NULL;
char *revstr = apr_psprintf(pool, "%ld", rev);
SVN_ERR(svn_cl__xml_print_header("properties", pool));
svn_xml_make_open_tag(&sb, pool, svn_xml_normal,
"revprops",
"rev", revstr, NULL);
svn_cmdline__print_xml_prop(&sb, pname_utf8, propval, FALSE,
pool);
svn_xml_make_close_tag(&sb, pool, "revprops");
SVN_ERR(svn_cl__error_checked_fputs(sb->data, stdout));
SVN_ERR(svn_cl__xml_print_footer("properties", pool));
}
else
{
svn_string_t *printable_val = propval;
/* If this is a special Subversion property, it is stored as
UTF8 and LF, so convert to the native locale and eol-style. */
if (svn_prop_needs_translation(pname_utf8))
SVN_ERR(svn_subst_detranslate_string(&printable_val, propval,
TRUE, pool));
SVN_ERR(stream_write(out, printable_val->data,
printable_val->len));
if (! opt_state->strict)
SVN_ERR(stream_write(out, APR_EOL_STR, strlen(APR_EOL_STR)));
}
}
}
else /* operate on a normal, versioned property (not a revprop) */
{
apr_pool_t *subpool = svn_pool_create(pool);
int i;
if (opt_state->xml)
SVN_ERR(svn_cl__xml_print_header("properties", subpool));
if (opt_state->depth == svn_depth_unknown)
opt_state->depth = svn_depth_empty;
/* Strict mode only makes sense for a single target. So make
sure we have only a single target, and that we're not being
asked to recurse on that target. */
if (opt_state->strict
&& ((targets->nelts > 1) || (opt_state->depth != svn_depth_empty)))
return svn_error_create
(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("Strict output of property values only available for single-"
"target, non-recursive propget operations"));
for (i = 0; i < targets->nelts; i++)
{
const char *target = APR_ARRAY_IDX(targets, i, const char *);
apr_hash_t *props;
svn_boolean_t print_filenames;
svn_boolean_t omit_newline;
svn_boolean_t like_proplist;
const char *truepath;
svn_opt_revision_t peg_revision;
apr_array_header_t *inherited_props;
svn_pool_clear(subpool);
SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton));
/* Check for a peg revision. */
SVN_ERR(svn_opt_parse_path(&peg_revision, &truepath, target,
subpool));
if (!svn_path_is_url(truepath))
SVN_ERR(svn_dirent_get_absolute(&truepath, truepath, subpool));
SVN_ERR(svn_client_propget5(
&props,
opt_state->show_inherited_props ? &inherited_props : NULL,
pname_utf8, truepath,
&peg_revision,
&(opt_state->start_revision),
NULL, opt_state->depth,
opt_state->changelists, ctx, subpool,
subpool));
/* Any time there is more than one thing to print, or where
the path associated with a printed thing is not obvious,
we'll print filenames. That is, unless we've been told
not to do so with the --strict option. */
print_filenames = ((opt_state->depth > svn_depth_empty
|| targets->nelts > 1
|| apr_hash_count(props) > 1
|| opt_state->verbose
|| opt_state->show_inherited_props)
&& (! opt_state->strict));
omit_newline = opt_state->strict;
like_proplist = opt_state->verbose && !opt_state->strict;
if (opt_state->xml)
SVN_ERR(print_properties_xml(
pname_utf8, props,
opt_state->show_inherited_props ? inherited_props : NULL,
subpool));
else
SVN_ERR(print_properties(
out, truepath, pname_utf8,
props,
opt_state->show_inherited_props ? inherited_props : NULL,
print_filenames,
omit_newline, like_proplist, subpool));
}
if (opt_state->xml)
SVN_ERR(svn_cl__xml_print_footer("properties", subpool));
svn_pool_destroy(subpool);
}
return SVN_NO_ERROR;
}