static svn_error_t *
end_element(void *baton, int state,
const char *nspace, const char *name)
{
options_ctx_t *oc = baton;
if (state == ELEM_href)
oc->activity_coll = svn_string_create_from_buf(oc->cdata, oc->pool);
return SVN_NO_ERROR;
}
svn_error_t *diff_output_stdout(
svn_stream_t *stream_output,
svn_diff_t *diff,
sp_playlist *playlist,
sp_track **tracks,
int num_tracks,
apr_pool_t *pool) {
svn_stringbuf_t *playlist_buf = svn_stringbuf_create("", pool),
*tracks_buf = svn_stringbuf_create("", pool);
append_playlist_tracks(playlist, playlist_buf);
append_tracks(tracks, num_tracks, tracks_buf);
svn_string_t *playlist_str = svn_string_create_from_buf(playlist_buf, pool),
*tracks_str = svn_string_create_from_buf(tracks_buf, pool);
return svn_diff_mem_string_output_unified(stream_output,
diff,
"playlist",
"tracks",
"utf-8",
playlist_str,
tracks_str,
pool);
}
/*
* This implements the `svn_ra_neon__xml_endelm_cb' prototype.
*/
static svn_error_t *
log_end_element(void *baton, int state,
const char *nspace, const char *name)
{
struct log_baton *lb = baton;
switch (state)
{
case ELEM_version_name:
lb->log_entry->revision = SVN_STR_TO_REV(lb->cdata->data);
break;
case ELEM_creator_displayname:
if (lb->want_author)
{
if (! lb->log_entry->revprops)
lb->log_entry->revprops = apr_hash_make(lb->subpool);
apr_hash_set(lb->log_entry->revprops, SVN_PROP_REVISION_AUTHOR,
APR_HASH_KEY_STRING,
svn_string_create_from_buf(lb->cdata, lb->subpool));
}
break;
case ELEM_log_date:
if (lb->want_date)
{
if (! lb->log_entry->revprops)
lb->log_entry->revprops = apr_hash_make(lb->subpool);
apr_hash_set(lb->log_entry->revprops, SVN_PROP_REVISION_DATE,
APR_HASH_KEY_STRING,
svn_string_create_from_buf(lb->cdata, lb->subpool));
}
break;
case ELEM_added_path:
case ELEM_replaced_path:
case ELEM_deleted_path:
case ELEM_modified_path:
{
char *path = apr_pstrdup(lb->subpool, lb->cdata->data);
if (! lb->log_entry->changed_paths)
lb->log_entry->changed_paths = apr_hash_make(lb->subpool);
apr_hash_set(lb->log_entry->changed_paths, path, APR_HASH_KEY_STRING,
lb->this_path_item);
break;
}
case ELEM_revprop:
if (! lb->log_entry->revprops)
lb->log_entry->revprops = apr_hash_make(lb->subpool);
apr_hash_set(lb->log_entry->revprops, lb->revprop_name,
APR_HASH_KEY_STRING,
svn_string_create_from_buf(lb->cdata, lb->subpool));
break;
case ELEM_comment:
if (lb->want_message)
{
if (! lb->log_entry->revprops)
lb->log_entry->revprops = apr_hash_make(lb->subpool);
apr_hash_set(lb->log_entry->revprops, SVN_PROP_REVISION_LOG,
APR_HASH_KEY_STRING,
svn_string_create_from_buf(lb->cdata, lb->subpool));
}
break;
case ELEM_log_item:
{
/* Compatability cruft so that we can provide limit functionality
even if the server doesn't support it.
If we've seen as many log entries as we're going to show just
error out of the XML parser so we can avoid having to parse the
remaining XML, but set lb->err to SVN_NO_ERROR so no error will
end up being shown to the user. */
if (lb->limit && (lb->nest_level == 0) && (++lb->count > lb->limit))
{
lb->limit_compat_bailout = TRUE;
return svn_error_create(APR_EGENERAL, NULL, NULL);
}
SVN_ERR((*(lb->receiver))(lb->receiver_baton,
lb->log_entry,
lb->subpool));
if (lb->log_entry->has_children)
{
lb->nest_level++;
}
if (! SVN_IS_VALID_REVNUM(lb->log_entry->revision))
{
assert(lb->nest_level);
lb->nest_level--;
}
reset_log_item(lb);
}
break;
}
/* Stop collecting cdata */
lb->want_cdata = NULL;
return SVN_NO_ERROR;
}
static svn_error_t *
end_element(svn_ra_serf__xml_parser_t *parser,
svn_ra_serf__dav_props_t name,
apr_pool_t *scratch_pool)
{
iprops_context_t *iprops_ctx = parser->user_data;
iprops_state_e state;
state = parser->state->current_state;
if (state == IPROPS_REPORT &&
strcmp(name.name, SVN_DAV__INHERITED_PROPS_REPORT) == 0)
{
svn_ra_serf__xml_pop_state(parser);
}
else if (state == IPROPS_PATH
&& strcmp(name.name, SVN_DAV__IPROP_PATH) == 0)
{
iprops_ctx->curr_iprop = apr_palloc(
iprops_ctx->pool, sizeof(svn_prop_inherited_item_t));
iprops_ctx->curr_iprop->path_or_url =
svn_path_url_add_component2(iprops_ctx->repos_root_url,
iprops_ctx->curr_path->data,
iprops_ctx->pool);
iprops_ctx->curr_iprop->prop_hash = apr_hash_make(iprops_ctx->pool);
svn_ra_serf__xml_pop_state(parser);
}
else if (state == IPROPS_PROPVAL
&& strcmp(name.name, SVN_DAV__IPROP_PROPVAL) == 0)
{
const svn_string_t *prop_val;
if (iprops_ctx->curr_prop_val_encoding)
{
svn_string_t encoded_prop_val;
if (strcmp(iprops_ctx->curr_prop_val_encoding, "base64") != 0)
return svn_error_create(SVN_ERR_XML_MALFORMED, NULL, NULL);
encoded_prop_val.data = iprops_ctx->curr_propval->data;
encoded_prop_val.len = iprops_ctx->curr_propval->len;
prop_val = svn_base64_decode_string(&encoded_prop_val,
iprops_ctx->pool);
}
else
{
prop_val = svn_string_create_from_buf(iprops_ctx->curr_propval,
iprops_ctx->pool);
}
svn_hash_sets(iprops_ctx->curr_iprop->prop_hash,
apr_pstrdup(iprops_ctx->pool,
iprops_ctx->curr_propname->data),
prop_val);
/* Clear current propname and propval in the event there are
multiple properties on the current path. */
svn_stringbuf_setempty(iprops_ctx->curr_propname);
svn_stringbuf_setempty(iprops_ctx->curr_propval);
svn_ra_serf__xml_pop_state(parser);
}
else if (state == IPROPS_PROPNAME
&& strcmp(name.name, SVN_DAV__IPROP_PROPNAME) == 0)
{
svn_ra_serf__xml_pop_state(parser);
}
else if (state == IPROPS_ITEM
&& strcmp(name.name, SVN_DAV__IPROP_ITEM) == 0)
{
APR_ARRAY_PUSH(iprops_ctx->iprops, svn_prop_inherited_item_t *) =
iprops_ctx->curr_iprop;
svn_ra_serf__xml_pop_state(parser);
}
/* This implements the `svn_opt_subcommand_t' interface. */
svn_error_t *
svn_cl__propset(apr_getopt_t *os,
void *baton,
apr_pool_t *scratch_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;
svn_string_t *propval = NULL;
svn_boolean_t propval_came_from_cmdline;
apr_array_header_t *args, *targets;
/* PNAME and PROPVAL expected as first 2 arguments if filedata was
NULL, else PNAME alone will precede the targets. Get a UTF-8
version of the name, too. */
SVN_ERR(svn_opt_parse_num_args(&args, os,
opt_state->filedata ? 1 : 2, scratch_pool));
pname = APR_ARRAY_IDX(args, 0, const char *);
SVN_ERR(svn_utf_cstring_to_utf8(&pname, pname, scratch_pool));
if (! svn_prop_name_is_valid(pname))
return svn_error_createf(SVN_ERR_CLIENT_PROPERTY_NAME, NULL,
_("'%s' is not a valid Subversion property name"),
pname);
if (!opt_state->force)
SVN_ERR(svn_cl__check_svn_prop_name(pname, opt_state->revprop,
svn_cl__prop_use_set, scratch_pool));
/* Get the PROPVAL from either an external file, or from the command
line. */
if (opt_state->filedata)
{
propval = svn_string_create_from_buf(opt_state->filedata, scratch_pool);
propval_came_from_cmdline = FALSE;
}
else
{
propval = svn_string_create(APR_ARRAY_IDX(args, 1, const char *),
scratch_pool);
propval_came_from_cmdline = TRUE;
}
/* We only want special Subversion property values to be in UTF-8
and LF line endings. All other propvals are taken literally. */
if (svn_prop_needs_translation(pname))
SVN_ERR(svn_subst_translate_string2(&propval, NULL, NULL, propval,
opt_state->encoding, FALSE,
scratch_pool, scratch_pool));
else if (opt_state->encoding)
return svn_error_create
(SVN_ERR_UNSUPPORTED_FEATURE, NULL,
_("--encoding option applies only to textual"
" Subversion-controlled properties"));
/* Suck up all the remaining arguments into a targets array */
SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os,
opt_state->targets,
ctx, FALSE,
scratch_pool));
/* Implicit "." is okay for revision properties; it just helps
us find the right repository. */
if (opt_state->revprop)
svn_opt_push_implicit_dot_target(targets, scratch_pool);
SVN_ERR(svn_cl__eat_peg_revisions(&targets, targets, scratch_pool));
if (opt_state->revprop) /* operate on a revprop */
{
svn_revnum_t rev;
const char *URL;
SVN_ERR(svn_cl__revprop_prepare(&opt_state->start_revision, targets,
&URL, ctx, scratch_pool));
/* Let libsvn_client do the real work. */
SVN_ERR(svn_client_revprop_set2(pname, propval, NULL,
URL, &(opt_state->start_revision),
&rev, opt_state->force, ctx,
scratch_pool));
}
else if (opt_state->start_revision.kind != svn_opt_revision_unspecified)
{
return svn_error_createf
(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("Cannot specify revision for setting versioned property '%s'"),
pname);
}
else /* operate on a normal, versioned property (not a revprop) */
{
if (opt_state->depth == svn_depth_unknown)
opt_state->depth = svn_depth_empty;
/* The customary implicit dot rule has been prone to user error
* here. People would do intuitive things like
*
* $ svn propset svn:executable script
*
* and then be surprised to get an error like:
*
* svn: Illegal target for the requested operation
* svn: Cannot set svn:executable on a directory ()
*
* So we don't do the implicit dot thing anymore. A * target
* must always be explicitly provided when setting a versioned
* property. See
*
* http://subversion.tigris.org/issues/show_bug.cgi?id=924
*
* for more details.
*/
if (targets->nelts == 0)
{
if (propval_came_from_cmdline)
{
return svn_error_createf
(SVN_ERR_CL_INSUFFICIENT_ARGS, NULL,
_("Explicit target required ('%s' interpreted as prop value)"),
propval->data);
}
else
{
return svn_error_create
(SVN_ERR_CL_INSUFFICIENT_ARGS, NULL,
_("Explicit target argument required"));
}
}
SVN_ERR(svn_cl__propset_print_binary_mime_type_warning(targets,
pname,
propval,
scratch_pool));
SVN_ERR(svn_client_propset_local(pname, propval, targets,
opt_state->depth, opt_state->force,
opt_state->changelists, ctx,
scratch_pool));
if (! opt_state->quiet)
svn_cl__check_boolean_prop_val(pname, propval->data, scratch_pool);
}
return SVN_NO_ERROR;
}
/* This implements the `svn_ra_neon__endelm_cb_t' prototype. */
static svn_error_t *
getlocks_end_element(void *userdata, int state,
const char *ns, const char *ln)
{
get_locks_baton_t *baton = userdata;
const svn_ra_neon__xml_elm_t *elm;
elm = svn_ra_neon__lookup_xml_elem(getlocks_report_elements, ns, ln);
/* Just skip unknown elements. */
if (elm == NULL)
return SVN_NO_ERROR;
switch (elm->id)
{
case ELEM_lock:
/* is the final svn_lock_t valid? all fields must be present
except for 'comment' and 'expiration_date'. */
if ((! baton->current_lock->path)
|| (! baton->current_lock->token)
|| (! baton->current_lock->owner)
|| (! baton->current_lock->creation_date))
SVN_ERR(svn_error_create(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
_("Incomplete lock data returned")));
/* Filter out unwanted paths. Since Subversion only allows
locks on files, we can treat depth=immediates the same as
depth=files for filtering purposes. Meaning, we'll keep
this lock if:
a) its path is the very path we queried, or
b) we've asked for a fully recursive answer, or
c) we've asked for depth=files or depth=immediates, and this
lock is on an immediate child of our query path.
*/
if ((strcmp(baton->path, baton->current_lock->path) == 0)
|| (baton->requested_depth == svn_depth_infinity))
{
apr_hash_set(baton->lock_hash, baton->current_lock->path,
APR_HASH_KEY_STRING, baton->current_lock);
}
else if ((baton->requested_depth == svn_depth_files) ||
(baton->requested_depth == svn_depth_immediates))
{
const char *rel_uri = svn_fspath__is_child(baton->path,
baton->current_lock->path,
baton->scratchpool);
if (rel_uri && (svn_path_component_count(rel_uri) == 1))
apr_hash_set(baton->lock_hash, baton->current_lock->path,
APR_HASH_KEY_STRING, baton->current_lock);
svn_pool_clear(baton->scratchpool);
}
break;
case ELEM_lock_path:
/* neon has already xml-unescaped the cdata for us. */
baton->current_lock->path =
svn_fspath__canonicalize(apr_pstrmemdup(baton->scratchpool,
baton->cdata_accum->data,
baton->cdata_accum->len),
baton->pool);
/* clean up the accumulator. */
svn_stringbuf_setempty(baton->cdata_accum);
svn_pool_clear(baton->scratchpool);
break;
case ELEM_lock_token:
/* neon has already xml-unescaped the cdata for us. */
baton->current_lock->token = apr_pstrmemdup(baton->pool,
baton->cdata_accum->data,
baton->cdata_accum->len);
/* clean up the accumulator. */
svn_stringbuf_setempty(baton->cdata_accum);
svn_pool_clear(baton->scratchpool);
break;
case ELEM_lock_creationdate:
SVN_ERR(svn_time_from_cstring(&(baton->current_lock->creation_date),
baton->cdata_accum->data,
baton->scratchpool));
/* clean up the accumulator. */
svn_stringbuf_setempty(baton->cdata_accum);
svn_pool_clear(baton->scratchpool);
break;
case ELEM_lock_expirationdate:
SVN_ERR(svn_time_from_cstring(&(baton->current_lock->expiration_date),
baton->cdata_accum->data,
baton->scratchpool));
/* clean up the accumulator. */
svn_stringbuf_setempty(baton->cdata_accum);
svn_pool_clear(baton->scratchpool);
break;
case ELEM_lock_owner:
case ELEM_lock_comment:
{
const char *final_val;
if (baton->encoding)
{
/* Possibly recognize other encodings someday. */
if (strcmp(baton->encoding, "base64") == 0)
{
svn_string_t *encoded_val;
const svn_string_t *decoded_val;
encoded_val = svn_string_create_from_buf(baton->cdata_accum,
baton->scratchpool);
decoded_val = svn_base64_decode_string(encoded_val,
baton->scratchpool);
final_val = decoded_val->data;
}
else
return svn_error_createf(SVN_ERR_RA_DAV_MALFORMED_DATA,
NULL,
_("Got unrecognized encoding '%s'"),
baton->encoding);
baton->encoding = NULL;
}
else
{
/* neon has already xml-unescaped the cdata for us. */
final_val = baton->cdata_accum->data;
}
if (elm->id == ELEM_lock_owner)
baton->current_lock->owner = apr_pstrdup(baton->pool, final_val);
if (elm->id == ELEM_lock_comment)
baton->current_lock->comment = apr_pstrdup(baton->pool, final_val);
/* clean up the accumulator. */
svn_stringbuf_setempty(baton->cdata_accum);
svn_pool_clear(baton->scratchpool);
break;
}
default:
break;
}
return SVN_NO_ERROR;
}
