/*
** Remove any lock that has the specified locktoken.
**
** If locktoken == NULL, then ALL locks are removed.
*/
static dav_error *
remove_lock(dav_lockdb *lockdb,
const dav_resource *resource,
const dav_locktoken *locktoken)
{
dav_lockdb_private *info = lockdb->info;
svn_error_t *serr;
svn_lock_t *slock;
const char *token = NULL;
/* Sanity check: if the resource has no associated path in the fs,
then there's nothing to do. */
if (! resource->info->repos_path)
return 0;
/* Another easy out: if an svn client sent a 'keep_locks' header
(typically in a DELETE request, as part of 'svn commit
--no-unlock'), then ignore dav_method_delete()'s attempt to
unconditionally remove the lock. */
if (info->keep_locks)
return 0;
/* If the resource's fs path is unreadable, we don't allow a lock to
be removed from it. */
if (! dav_svn__allow_read_resource(resource, SVN_INVALID_REVNUM,
resource->pool))
return dav_svn__new_error(resource->pool, HTTP_FORBIDDEN,
DAV_ERR_LOCK_SAVE_LOCK,
"Path is not accessible.");
if (locktoken == NULL)
{
/* Need to manually discover any lock on the resource. */
serr = svn_fs_get_lock(&slock,
resource->info->repos->fs,
resource->info->repos_path,
resource->pool);
if (serr)
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Failed to check path for a lock.",
resource->pool);
if (slock)
token = slock->token;
}
else
{
token = locktoken->uuid_str;
}
if (token)
{
/* Notice that a generic DAV client is unable to forcibly
'break' a lock, because info->lock_break will always be
FALSE. An svn client, however, can request a 'forced' break.*/
serr = svn_repos_fs_unlock(resource->info->repos->repos,
resource->info->repos_path,
token,
info->lock_break,
resource->pool);
if (serr && serr->apr_err == SVN_ERR_FS_NO_USER)
{
svn_error_clear(serr);
return dav_svn__new_error(resource->pool, HTTP_UNAUTHORIZED,
DAV_ERR_LOCK_SAVE_LOCK,
"Anonymous lock removal is not allowed.");
}
else if (serr)
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Failed to remove a lock.",
resource->pool);
/* Log the unlocking as a 'high-level' action. */
dav_svn__operational_log(resource->info,
svn_log__unlock_one_path(
resource->info->repos_path,
info->lock_break,
resource->info->r->pool));
}
return 0;
}
dav_error *
dav_svn__get_mergeinfo_report(const dav_resource *resource,
const apr_xml_doc *doc,
ap_filter_t *output)
{
svn_error_t *serr;
dav_error *derr = NULL;
apr_xml_elem *child;
svn_mergeinfo_catalog_t catalog;
svn_boolean_t include_descendants = FALSE;
dav_svn__authz_read_baton arb;
const dav_svn_repos *repos = resource->info->repos;
int ns;
apr_bucket_brigade *bb;
apr_hash_index_t *hi;
/* These get determined from the request document. */
svn_revnum_t rev = SVN_INVALID_REVNUM;
/* By default look for explicit mergeinfo only. */
svn_mergeinfo_inheritance_t inherit = svn_mergeinfo_explicit;
apr_array_header_t *paths
= apr_array_make(resource->pool, 0, sizeof(const char *));
/* Sanity check. */
if (!resource->info->repos_path)
return dav_svn__new_error(resource->pool, HTTP_BAD_REQUEST, 0,
"The request does not specify a repository path");
ns = dav_svn__find_ns(doc->namespaces, SVN_XML_NAMESPACE);
if (ns == -1)
{
return dav_svn__new_error_tag(resource->pool, HTTP_BAD_REQUEST, 0,
"The request does not contain the 'svn:' "
"namespace, so it is not going to have "
"certain required elements.",
SVN_DAV_ERROR_NAMESPACE,
SVN_DAV_ERROR_TAG);
}
for (child = doc->root->first_child; child != NULL; child = child->next)
{
/* if this element isn't one of ours, then skip it */
if (child->ns != ns)
continue;
if (strcmp(child->name, SVN_DAV__REVISION) == 0)
rev = SVN_STR_TO_REV(dav_xml_get_cdata(child, resource->pool, 1));
else if (strcmp(child->name, SVN_DAV__INHERIT) == 0)
{
inherit = svn_inheritance_from_word(
dav_xml_get_cdata(child, resource->pool, 1));
}
else if (strcmp(child->name, SVN_DAV__PATH) == 0)
{
const char *target;
const char *rel_path = dav_xml_get_cdata(child, resource->pool, 0);
if ((derr = dav_svn__test_canonical(rel_path, resource->pool)))
return derr;
/* Force REL_PATH to be a relative path, not an fspath. */
rel_path = svn_relpath_canonicalize(rel_path, resource->pool);
/* Append the REL_PATH to the base FS path to get an
absolute repository path. */
target = svn_fspath__join(resource->info->repos_path, rel_path,
resource->pool);
(*((const char **)(apr_array_push(paths)))) = target;
}
else if (strcmp(child->name, SVN_DAV__INCLUDE_DESCENDANTS) == 0)
{
const char *word = dav_xml_get_cdata(child, resource->pool, 1);
if (strcmp(word, "yes") == 0)
include_descendants = TRUE;
/* Else the client isn't supposed to send anyway, so just
leave it false. */
}
/* else unknown element; skip it */
}
/* Build authz read baton */
arb.r = resource->info->r;
arb.repos = resource->info->repos;
/* Build mergeinfo brigade */
bb = apr_brigade_create(resource->pool, output->c->bucket_alloc);
serr = svn_repos_fs_get_mergeinfo(&catalog, repos->repos, paths, rev,
inherit, include_descendants,
dav_svn__authz_read_func(&arb),
&arb, resource->pool);
if (serr)
{
derr = dav_svn__convert_err(serr, HTTP_BAD_REQUEST, serr->message,
resource->pool);
goto cleanup;
}
serr = svn_mergeinfo__remove_prefix_from_catalog(&catalog, catalog,
resource->info->repos_path,
resource->pool);
if (serr)
{
derr = dav_svn__convert_err(serr, HTTP_BAD_REQUEST, serr->message,
resource->pool);
goto cleanup;
}
/* Ideally, dav_svn__brigade_printf() would set a flag in bb (or rather,
in r->sent_bodyct, see dav_method_report()), and ap_fflush()
would not set that flag unless it actually sent something. But
we are condemned to live in another universe, so we must keep
track ourselves of whether we've sent anything or not. See the
long comment after the 'cleanup' label for more details. */
serr = dav_svn__brigade_puts(bb, output,
DAV_XML_HEADER DEBUG_CR
"<S:" SVN_DAV__MERGEINFO_REPORT " "
"xmlns:S=\"" SVN_XML_NAMESPACE "\" "
"xmlns:D=\"DAV:\">" DEBUG_CR);
if (serr)
{
derr = dav_svn__convert_err(serr, HTTP_BAD_REQUEST, serr->message,
resource->pool);
goto cleanup;
}
for (hi = apr_hash_first(resource->pool, catalog); hi;
hi = apr_hash_next(hi))
{
const void *key;
void *value;
const char *path;
svn_mergeinfo_t mergeinfo;
svn_string_t *mergeinfo_string;
apr_hash_this(hi, &key, NULL, &value);
path = key;
mergeinfo = value;
serr = svn_mergeinfo_to_string(&mergeinfo_string, mergeinfo,
resource->pool);
if (serr)
{
derr = dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Error ending REPORT response.",
resource->pool);
goto cleanup;
}
serr = dav_svn__brigade_printf
(bb, output,
"<S:" SVN_DAV__MERGEINFO_ITEM ">"
DEBUG_CR
"<S:" SVN_DAV__MERGEINFO_PATH ">%s</S:" SVN_DAV__MERGEINFO_PATH ">"
DEBUG_CR
"<S:" SVN_DAV__MERGEINFO_INFO ">%s</S:" SVN_DAV__MERGEINFO_INFO ">"
DEBUG_CR
"</S:" SVN_DAV__MERGEINFO_ITEM ">",
apr_xml_quote_string(resource->pool, path, 0),
apr_xml_quote_string(resource->pool, mergeinfo_string->data, 0));
if (serr)
{
derr = dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Error ending REPORT response.",
resource->pool);
goto cleanup;
}
}
if ((serr = dav_svn__brigade_puts(bb, output,
"</S:" SVN_DAV__MERGEINFO_REPORT ">"
DEBUG_CR)))
{
derr = dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Error ending REPORT response.",
resource->pool);
goto cleanup;
}
cleanup:
/* We've detected a 'high level' svn action to log. */
dav_svn__operational_log(resource->info,
svn_log__get_mergeinfo(paths, inherit,
include_descendants,
resource->pool));
return dav_svn__final_flush_or_error(resource->info->r, bb, output,
derr, resource->pool);
}
/*
** Append the specified lock(s) to the set of locks on this resource.
**
** If "make_indirect" is true (non-zero), then the specified lock(s)
** should be converted to an indirect lock (if it is a direct lock)
** before appending. Note that the conversion to an indirect lock does
** not alter the passed-in lock -- the change is internal the
** append_locks function.
**
** Multiple locks are specified using the lock->next links.
*/
static dav_error *
append_locks(dav_lockdb *lockdb,
const dav_resource *resource,
int make_indirect,
const dav_lock *lock)
{
dav_lockdb_private *info = lockdb->info;
svn_lock_t *slock;
svn_error_t *serr;
dav_error *derr;
/* If the resource's fs path is unreadable, we don't allow a lock to
be created on it. */
if (! dav_svn__allow_read_resource(resource, SVN_INVALID_REVNUM,
resource->pool))
return dav_svn__new_error(resource->pool, HTTP_FORBIDDEN,
DAV_ERR_LOCK_SAVE_LOCK,
"Path is not accessible.");
if (lock->next)
return dav_svn__new_error(resource->pool, HTTP_BAD_REQUEST,
DAV_ERR_LOCK_SAVE_LOCK,
"Tried to attach multiple locks to a resource.");
/* RFC2518bis (section 7.4) doesn't require us to support
'lock-null' resources at all. Instead, it asks that we treat
'LOCK nonexistentURL' as a PUT (followed by a LOCK) of a 0-byte file. */
if (! resource->exists)
{
svn_revnum_t rev, new_rev;
svn_fs_txn_t *txn;
svn_fs_root_t *txn_root;
const char *conflict_msg;
dav_svn_repos *repos = resource->info->repos;
apr_hash_t *revprop_table = apr_hash_make(resource->pool);
apr_hash_set(revprop_table, SVN_PROP_REVISION_AUTHOR,
APR_HASH_KEY_STRING, svn_string_create(repos->username,
resource->pool));
if (resource->info->repos->is_svn_client)
return dav_svn__new_error(resource->pool, HTTP_METHOD_NOT_ALLOWED,
DAV_ERR_LOCK_SAVE_LOCK,
"Subversion clients may not lock "
"nonexistent paths.");
else if (! resource->info->repos->autoversioning)
return dav_svn__new_error(resource->pool, HTTP_METHOD_NOT_ALLOWED,
DAV_ERR_LOCK_SAVE_LOCK,
"Attempted to lock non-existent path; "
"turn on autoversioning first.");
/* Commit a 0-byte file: */
if ((serr = svn_fs_youngest_rev(&rev, repos->fs, resource->pool)))
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Could not determine youngest revision",
resource->pool);
if ((serr = svn_repos_fs_begin_txn_for_commit2(&txn, repos->repos, rev,
revprop_table,
resource->pool)))
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Could not begin a transaction",
resource->pool);
if ((serr = svn_fs_txn_root(&txn_root, txn, resource->pool)))
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Could not begin a transaction",
resource->pool);
if ((serr = svn_fs_make_file(txn_root, resource->info->repos_path,
resource->pool)))
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Could not create empty file.",
resource->pool);
if ((serr = dav_svn__attach_auto_revprops(txn,
resource->info->repos_path,
resource->pool)))
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Could not create empty file.",
resource->pool);
serr = svn_repos_fs_commit_txn(&conflict_msg, repos->repos,
&new_rev, txn, resource->pool);
if (SVN_IS_VALID_REVNUM(new_rev))
{
/* ### Log an error in post commit FS processing? */
svn_error_clear(serr);
}
else
{
svn_error_clear(svn_fs_abort_txn(txn, resource->pool));
if (serr)
return dav_svn__convert_err(serr, HTTP_CONFLICT,
apr_psprintf(resource->pool,
"Conflict when "
"committing '%s'.",
conflict_msg),
resource->pool);
else
return dav_svn__new_error(resource->pool,
HTTP_INTERNAL_SERVER_ERROR,
0,
"Commit failed but there was no error "
"provided.");
}
}
/* Convert the dav_lock into an svn_lock_t. */
derr = dav_lock_to_svn_lock(&slock, lock, resource->info->repos_path,
info, resource->info->repos->is_svn_client,
resource->pool);
if (derr)
return derr;
/* Now use the svn_lock_t to actually perform the lock. */
serr = svn_repos_fs_lock(&slock,
resource->info->repos->repos,
slock->path,
slock->token,
slock->comment,
slock->is_dav_comment,
slock->expiration_date,
info->working_revnum,
info->lock_steal,
resource->pool);
if (serr && serr->apr_err == SVN_ERR_FS_NO_USER)
{
svn_error_clear(serr);
return dav_svn__new_error(resource->pool, HTTP_UNAUTHORIZED,
DAV_ERR_LOCK_SAVE_LOCK,
"Anonymous lock creation is not allowed.");
}
else if (serr)
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Failed to create new lock.",
resource->pool);
/* A standard webdav LOCK response doesn't include any information
about the creation date. We send it in a custom header, so that
svn clients can fill in svn_lock_t->creation_date. A generic DAV
client should just ignore the header. */
apr_table_setn(info->r->headers_out, SVN_DAV_CREATIONDATE_HEADER,
svn_time_to_cstring(slock->creation_date, resource->pool));
/* A standard webdav LOCK response doesn't include any information
about the owner of the lock. ('DAV:owner' has nothing to do with
authorization, it's just a comment that we map to
svn_lock_t->comment.) We send the owner in a custom header, so
that svn clients can fill in svn_lock_t->owner. A generic DAV
client should just ignore the header. */
apr_table_setn(info->r->headers_out, SVN_DAV_LOCK_OWNER_HEADER,
slock->owner);
/* Log the locking as a 'high-level' action. */
dav_svn__operational_log(resource->info,
svn_log__lock_one_path(slock->path, info->lock_steal,
resource->info->r->pool));
return 0;
}
/* Respond to a client request for a REPORT of type file-revs-report for the
RESOURCE. Get request body from DOC and send result to OUTPUT. */
dav_error *
dav_svn__file_revs_report(const dav_resource *resource,
const apr_xml_doc *doc,
ap_filter_t *output)
{
svn_error_t *serr;
dav_error *derr = NULL;
apr_xml_elem *child;
int ns;
struct file_rev_baton frb;
dav_svn__authz_read_baton arb;
const char *abs_path = NULL;
/* These get determined from the request document. */
svn_revnum_t start = SVN_INVALID_REVNUM;
svn_revnum_t end = SVN_INVALID_REVNUM;
svn_boolean_t include_merged_revisions = FALSE; /* off by default */
/* Construct the authz read check baton. */
arb.r = resource->info->r;
arb.repos = resource->info->repos;
/* Sanity check. */
if (!resource->info->repos_path)
return dav_svn__new_error(resource->pool, HTTP_BAD_REQUEST, 0,
"The request does not specify a repository path");
ns = dav_svn__find_ns(doc->namespaces, SVN_XML_NAMESPACE);
/* ### This is done on other places, but the document element is
in this namespace, so is this necessary at all? */
if (ns == -1)
{
return dav_svn__new_error_tag(resource->pool, HTTP_BAD_REQUEST, 0,
"The request does not contain the 'svn:' "
"namespace, so it is not going to have "
"certain required elements.",
SVN_DAV_ERROR_NAMESPACE,
SVN_DAV_ERROR_TAG);
}
/* Get request information. */
for (child = doc->root->first_child; child != NULL; child = child->next)
{
/* if this element isn't one of ours, then skip it */
if (child->ns != ns)
continue;
if (strcmp(child->name, "start-revision") == 0)
start = SVN_STR_TO_REV(dav_xml_get_cdata(child, resource->pool, 1));
else if (strcmp(child->name, "end-revision") == 0)
end = SVN_STR_TO_REV(dav_xml_get_cdata(child, resource->pool, 1));
else if (strcmp(child->name, "include-merged-revisions") == 0)
include_merged_revisions = TRUE; /* presence indicates positivity */
else if (strcmp(child->name, "path") == 0)
{
const char *rel_path = dav_xml_get_cdata(child, resource->pool, 0);
if ((derr = dav_svn__test_canonical(rel_path, resource->pool)))
return derr;
/* Force REL_PATH to be a relative path, not an fspath. */
rel_path = svn_relpath_canonicalize(rel_path, resource->pool);
/* Append the REL_PATH to the base FS path to get an
absolute repository path. */
abs_path = svn_fspath__join(resource->info->repos_path, rel_path,
resource->pool);
}
/* else unknown element; skip it */
}
/* Check that all parameters are present and valid. */
if (! abs_path)
return dav_svn__new_error_tag(resource->pool, HTTP_BAD_REQUEST, 0,
"Not all parameters passed.",
SVN_DAV_ERROR_NAMESPACE,
SVN_DAV_ERROR_TAG);
frb.bb = apr_brigade_create(resource->pool,
output->c->bucket_alloc);
frb.output = output;
frb.needs_header = TRUE;
frb.svndiff_version = resource->info->svndiff_version;
frb.compression_level = dav_svn__get_compression_level(resource->info->r);
/* file_rev_handler will send header first time it is called. */
/* Get the revisions and send them. */
serr = svn_repos_get_file_revs2(resource->info->repos->repos,
abs_path, start, end, include_merged_revisions,
dav_svn__authz_read_func(&arb), &arb,
file_rev_handler, &frb, resource->pool);
if (serr)
{
/* We don't 'goto cleanup' because ap_fflush() tells httpd
to write the HTTP headers out, and that includes whatever
r->status is at that particular time. When we call
dav_svn__convert_err(), we don't immediately set r->status
right then, so r->status remains 0, hence HTTP status 200
would be misleadingly returned. */
return (dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
serr->message, resource->pool));
}
if ((serr = maybe_send_header(&frb)))
{
derr = dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Error beginning REPORT reponse",
resource->pool);
goto cleanup;
}
if ((serr = dav_svn__brigade_puts(frb.bb, frb.output,
"</S:file-revs-report>" DEBUG_CR)))
{
derr = dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Error ending REPORT reponse",
resource->pool);
goto cleanup;
}
cleanup:
/* We've detected a 'high level' svn action to log. */
dav_svn__operational_log(resource->info,
svn_log__get_file_revs(abs_path, start, end,
include_merged_revisions,
resource->pool));
return dav_svn__final_flush_or_error(resource->info->r, frb.bb, output,
derr, resource->pool);
}
dav_error *
dav_svn__get_inherited_props_report(const dav_resource *resource,
const apr_xml_doc *doc,
ap_filter_t *output)
{
svn_error_t *serr;
dav_error *derr = NULL;
apr_xml_elem *child;
apr_array_header_t *inherited_props;
dav_svn__authz_read_baton arb;
int ns;
apr_bucket_brigade *bb;
const char *path = "/";
svn_fs_root_t *root;
int i;
svn_revnum_t rev = SVN_INVALID_REVNUM;
apr_pool_t *iterpool;
/* Sanity check. */
if (!resource->info->repos_path)
return dav_svn__new_error(resource->pool, HTTP_BAD_REQUEST, 0,
"The request does not specify a repository path");
ns = dav_svn__find_ns(doc->namespaces, SVN_XML_NAMESPACE);
if (ns == -1)
{
return dav_svn__new_error_svn(resource->pool, HTTP_BAD_REQUEST, 0,
"The request does not contain the 'svn:' "
"namespace, so it is not going to have "
"certain required elements");
}
iterpool = svn_pool_create(resource->pool);
for (child = doc->root->first_child;
child != NULL;
child = child->next)
{
/* if this element isn't one of ours, then skip it */
if (child->ns != ns)
continue;
if (strcmp(child->name, SVN_DAV__REVISION) == 0)
{
rev = SVN_STR_TO_REV(dav_xml_get_cdata(child, iterpool, 1));
}
else if (strcmp(child->name, SVN_DAV__PATH) == 0)
{
path = dav_xml_get_cdata(child, resource->pool, 0);
if ((derr = dav_svn__test_canonical(path, iterpool)))
return derr;
path = svn_fspath__join(resource->info->repos_path, path,
resource->pool);
}
/* else unknown element; skip it */
}
/* Build authz read baton */
arb.r = resource->info->r;
arb.repos = resource->info->repos;
/* Build inherited property brigade */
bb = apr_brigade_create(resource->pool, output->c->bucket_alloc);
serr = svn_fs_revision_root(&root, resource->info->repos->fs,
rev, resource->pool);
if (serr != NULL)
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"couldn't retrieve revision root",
resource->pool);
serr = svn_repos_fs_get_inherited_props(&inherited_props, root, path, NULL,
dav_svn__authz_read_func(&arb),
&arb, resource->pool, iterpool);
if (serr)
{
derr = dav_svn__convert_err(serr, HTTP_BAD_REQUEST, NULL,
resource->pool);
goto cleanup;
}
serr = dav_svn__brigade_puts(bb, output,
DAV_XML_HEADER DEBUG_CR
"<S:" SVN_DAV__INHERITED_PROPS_REPORT " "
"xmlns:S=\"" SVN_XML_NAMESPACE "\" "
"xmlns:D=\"DAV:\">" DEBUG_CR);
if (serr)
{
derr = dav_svn__convert_err(serr, HTTP_BAD_REQUEST, NULL,
resource->pool);
goto cleanup;
}
for (i = 0; i < inherited_props->nelts; i++)
{
svn_prop_inherited_item_t *elt =
APR_ARRAY_IDX(inherited_props, i, svn_prop_inherited_item_t *);
svn_pool_clear(iterpool);
serr = dav_svn__brigade_printf(
bb, output,
"<S:" SVN_DAV__IPROP_ITEM ">"
DEBUG_CR
"<S:" SVN_DAV__IPROP_PATH ">%s</S:" SVN_DAV__IPROP_PATH ">"
DEBUG_CR,
apr_xml_quote_string(resource->pool, elt->path_or_url, 0));
if (!serr)
{
apr_hash_index_t *hi;
for (hi = apr_hash_first(resource->pool, elt->prop_hash);
hi;
hi = apr_hash_next(hi))
{
const char *propname = apr_hash_this_key(hi);
svn_string_t *propval = apr_hash_this_val(hi);
const char *xml_safe;
serr = dav_svn__brigade_printf(
bb, output,
"<S:" SVN_DAV__IPROP_PROPNAME ">%s</S:"
SVN_DAV__IPROP_PROPNAME ">" DEBUG_CR,
apr_xml_quote_string(iterpool, propname, 0));
if (!serr)
{
if (svn_xml_is_xml_safe(propval->data, propval->len))
{
svn_stringbuf_t *tmp = NULL;
svn_xml_escape_cdata_string(&tmp, propval,
iterpool);
xml_safe = tmp->data;
serr = dav_svn__brigade_printf(
bb, output,
"<S:" SVN_DAV__IPROP_PROPVAL ">%s</S:"
SVN_DAV__IPROP_PROPVAL ">" DEBUG_CR, xml_safe);
}
else
{
xml_safe = svn_base64_encode_string2(
propval, TRUE, iterpool)->data;
serr = dav_svn__brigade_printf(
bb, output,
"<S:" SVN_DAV__IPROP_PROPVAL
" encoding=\"base64\"" ">%s</S:"
SVN_DAV__IPROP_PROPVAL ">" DEBUG_CR, xml_safe);
}
}
if (serr)
break;
}
if (!serr)
serr = dav_svn__brigade_printf(bb, output,
"</S:" SVN_DAV__IPROP_ITEM ">"
DEBUG_CR);
}
if (serr)
{
derr = dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Error ending REPORT response.",
resource->pool);
goto cleanup;
}
}
if ((serr = dav_svn__brigade_puts(bb, output,
"</S:" SVN_DAV__INHERITED_PROPS_REPORT ">"
DEBUG_CR)))
{
derr = dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Error ending REPORT response.",
resource->pool);
goto cleanup;
}
cleanup:
/* Log this 'high level' svn action. */
dav_svn__operational_log(resource->info,
svn_log__get_inherited_props(path, rev,
resource->pool));
svn_pool_destroy(iterpool);
return dav_svn__final_flush_or_error(resource->info->r, bb, output,
derr, resource->pool);
}
static dav_error *
db_first_name(dav_db *db, dav_prop_name *pname)
{
/* for operational logging */
const char *action = NULL;
/* if we don't have a copy of the properties, then get one */
if (db->props == NULL)
{
svn_error_t *serr;
/* Working Baseline, Baseline, or (Working) Version resource */
if (db->resource->baselined)
{
if (db->resource->type == DAV_RESOURCE_TYPE_WORKING)
serr = svn_fs_txn_proplist(&db->props,
db->resource->info->root.txn,
db->p);
else
{
action = svn_log__rev_proplist(db->resource->info->root.rev,
db->resource->pool);
serr = svn_repos_fs_revision_proplist
(&db->props,
db->resource->info->repos->repos,
db->resource->info->root.rev,
db->authz_read_func,
db->authz_read_baton,
db->p);
}
}
else
{
svn_node_kind_t kind;
serr = svn_fs_node_proplist(&db->props,
db->resource->info->root.root,
get_repos_path(db->resource->info),
db->p);
if (! serr)
serr = svn_fs_check_path(&kind, db->resource->info->root.root,
get_repos_path(db->resource->info),
db->p);
if (! serr)
{
if (kind == svn_node_dir)
action = svn_log__get_dir(db->resource->info->repos_path,
db->resource->info->root.rev,
FALSE, TRUE, 0, db->resource->pool);
else
action = svn_log__get_file(db->resource->info->repos_path,
db->resource->info->root.rev,
FALSE, TRUE, db->resource->pool);
}
}
if (serr != NULL)
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"could not begin sequencing through "
"properties",
db->resource->pool);
}
/* begin the iteration over the hash */
db->hi = apr_hash_first(db->p, db->props);
/* fetch the first key */
get_name(db, pname);
/* If we have a high-level action to log, do so. */
if (action != NULL)
dav_svn__operational_log(db->resource->info, action);
return NULL;
}
static dav_error *
save_value(dav_db *db, const dav_prop_name *name,
const svn_string_t *const *old_value_p,
const svn_string_t *value)
{
const char *propname;
svn_error_t *serr;
const dav_resource *resource = db->resource;
apr_pool_t *subpool;
/* get the repos-local name */
get_repos_propname(db, name, &propname);
if (propname == NULL)
{
if (db->resource->info->repos->autoversioning)
/* ignore the unknown namespace of the incoming prop. */
propname = name->name;
else
return dav_svn__new_error(db->p, HTTP_CONFLICT, 0,
"Properties may only be defined in the "
SVN_DAV_PROP_NS_SVN " and "
SVN_DAV_PROP_NS_CUSTOM " namespaces.");
}
/* We've got three different types of properties (node, txn, and
revision), and we've got two different protocol versions to deal
with. Let's try to make some sense of this, shall we?
HTTP v1:
working baseline ('wbl') resource -> txn prop change
non-working, baselined resource ('bln') -> rev prop change [*]
working, non-baselined resource ('wrk') -> node prop change
HTTP v2:
transaction resource ('txn') -> txn prop change
revision resource ('rev') -> rev prop change
transaction root resource ('txr') -> node prop change
[*] This is a violation of the DeltaV spec (### see issue #916).
*/
/* A subpool to cope with mod_dav making multiple calls, e.g. during
PROPPATCH with multiple values. */
subpool = svn_pool_create(db->resource->pool);
if (db->resource->baselined)
{
if (db->resource->working)
{
serr = svn_repos_fs_change_txn_prop(resource->info->root.txn,
propname, value,
subpool);
}
else
{
serr = svn_repos_fs_change_rev_prop4(resource->info->repos->repos,
resource->info->root.rev,
resource->info->repos->username,
propname, old_value_p, value,
TRUE, TRUE,
db->authz_read_func,
db->authz_read_baton,
subpool);
/* Prepare any hook failure message to get sent over the wire */
if (serr)
{
svn_error_t *purged_serr = svn_error_purge_tracing(serr);
if (purged_serr->apr_err == SVN_ERR_REPOS_HOOK_FAILURE)
purged_serr->message = apr_xml_quote_string
(purged_serr->pool,
purged_serr->message, 1);
/* mod_dav doesn't handle the returned error very well, it
generates its own generic error that will be returned to
the client. Cache the detailed error here so that it can
be returned a second time when the rollback mechanism
triggers. */
resource->info->revprop_error = svn_error_dup(purged_serr);
}
/* Tell the logging subsystem about the revprop change. */
dav_svn__operational_log(resource->info,
svn_log__change_rev_prop(
resource->info->root.rev,
propname, subpool));
}
}
else if (resource->info->restype == DAV_SVN_RESTYPE_TXN_COLLECTION)
{
serr = svn_repos_fs_change_txn_prop(resource->info->root.txn,
propname, value, subpool);
}
else
{
serr = svn_repos_fs_change_node_prop(resource->info->root.root,
get_repos_path(resource->info),
propname, value, subpool);
}
svn_pool_destroy(subpool);
if (serr != NULL)
return dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
NULL, resource->pool);
/* a change to the props was made; make sure our cached copy is gone */
db->props = NULL;
return NULL;
}
dav_error *
dav_svn__replay_report(const dav_resource *resource,
const apr_xml_doc *doc,
dav_svn__output *output)
{
dav_error *derr = NULL;
svn_revnum_t low_water_mark = SVN_INVALID_REVNUM;
svn_revnum_t rev;
const svn_delta_editor_t *editor;
svn_boolean_t send_deltas = TRUE;
dav_svn__authz_read_baton arb;
const char *base_dir;
apr_bucket_brigade *bb;
apr_xml_elem *child;
svn_fs_root_t *root;
svn_error_t *err;
void *edit_baton;
int ns;
/* In Subversion 1.8, we allowed this REPORT to be issue against a
revision resource. Doing so means the REV is part of the request
URL, and BASE_DIR is embedded in the request body.
The old-school (and incorrect, see issue #4287 --
https://issues.apache.org/jira/browse/SVN-4287) way was
to REPORT on the public URL of the BASE_DIR and embed the REV in
the report body.
*/
if (resource->baselined
&& (resource->type == DAV_RESOURCE_TYPE_VERSION))
{
rev = resource->info->root.rev;
base_dir = NULL;
}
else
{
rev = SVN_INVALID_REVNUM;
base_dir = resource->info->repos_path;
}
arb.r = resource->info->r;
arb.repos = resource->info->repos;
ns = dav_svn__find_ns(doc->namespaces, SVN_XML_NAMESPACE);
if (ns == -1)
return dav_svn__new_error_svn(resource->pool, HTTP_BAD_REQUEST, 0, 0,
"The request does not contain the 'svn:' "
"namespace, so it is not going to have an "
"svn:revision element. That element is "
"required");
for (child = doc->root->first_child; child != NULL; child = child->next)
{
if (child->ns == ns)
{
const char *cdata;
if (strcmp(child->name, "revision") == 0)
{
if (SVN_IS_VALID_REVNUM(rev))
{
/* Uh... we already have a revision to use, either
because this tag is non-unique or because the
request was submitted against a revision-bearing
resource URL. Either way, something's not
right. */
return malformed_element_error("revision", resource->pool);
}
cdata = dav_xml_get_cdata(child, resource->pool, 1);
rev = SVN_STR_TO_REV(cdata);
}
else if (strcmp(child->name, "low-water-mark") == 0)
{
cdata = dav_xml_get_cdata(child, resource->pool, 1);
if (! cdata)
return malformed_element_error("low-water-mark",
resource->pool);
low_water_mark = SVN_STR_TO_REV(cdata);
}
else if (strcmp(child->name, "send-deltas") == 0)
{
apr_int64_t parsed_val;
cdata = dav_xml_get_cdata(child, resource->pool, 1);
if (! cdata)
return malformed_element_error("send-deltas", resource->pool);
err = svn_cstring_strtoi64(&parsed_val, cdata, 0, 1, 10);
if (err)
{
svn_error_clear(err);
return malformed_element_error("send-deltas", resource->pool);
}
send_deltas = parsed_val != 0;
}
else if (strcmp(child->name, "include-path") == 0)
{
cdata = dav_xml_get_cdata(child, resource->pool, 1);
if ((derr = dav_svn__test_canonical(cdata, resource->pool)))
return derr;
/* Force BASE_DIR to be a relative path, not an fspath. */
base_dir = svn_relpath_canonicalize(cdata, resource->pool);
}
}
}
if (! SVN_IS_VALID_REVNUM(rev))
return dav_svn__new_error_svn
(resource->pool, HTTP_BAD_REQUEST, 0, 0,
"Request was missing the revision argument");
if (! SVN_IS_VALID_REVNUM(low_water_mark))
return dav_svn__new_error_svn
(resource->pool, HTTP_BAD_REQUEST, 0, 0,
"Request was missing the low-water-mark argument");
if (! base_dir)
base_dir = "";
bb = apr_brigade_create(resource->pool,
dav_svn__output_get_bucket_alloc(output));
if ((err = svn_fs_revision_root(&root, resource->info->repos->fs, rev,
resource->pool)))
{
derr = dav_svn__convert_err(err, HTTP_INTERNAL_SERVER_ERROR,
"Couldn't retrieve revision root",
resource->pool);
goto cleanup;
}
make_editor(&editor, &edit_baton, bb, output,
dav_svn__get_compression_level(resource->info->r),
resource->info->svndiff_version,
resource->pool);
if ((err = svn_repos_replay2(root, base_dir, low_water_mark,
send_deltas, editor, edit_baton,
dav_svn__authz_read_func(&arb), &arb,
resource->pool)))
{
derr = dav_svn__convert_err(err, HTTP_INTERNAL_SERVER_ERROR,
"Problem replaying revision",
resource->pool);
goto cleanup;
}
if ((err = end_report(edit_baton)))
{
derr = dav_svn__convert_err(err, HTTP_INTERNAL_SERVER_ERROR,
"Problem closing editor drive",
resource->pool);
goto cleanup;
}
cleanup:
dav_svn__operational_log(resource->info,
svn_log__replay(base_dir, rev,
resource->info->r->pool));
/* Flush the brigade. */
return dav_svn__final_flush_or_error(resource->info->r, bb, output,
derr, resource->pool);
}
dav_error *
dav_svn__log_report(const dav_resource *resource,
const apr_xml_doc *doc,
ap_filter_t *output)
{
svn_error_t *serr;
dav_error *derr = NULL;
apr_xml_elem *child;
struct log_receiver_baton lrb;
dav_svn__authz_read_baton arb;
const dav_svn_repos *repos = resource->info->repos;
const char *target = NULL;
int limit = 0;
int ns;
svn_boolean_t seen_revprop_element;
/* These get determined from the request document. */
svn_revnum_t start = SVN_INVALID_REVNUM; /* defaults to HEAD */
svn_revnum_t end = SVN_INVALID_REVNUM; /* defaults to HEAD */
svn_boolean_t discover_changed_paths = FALSE; /* off by default */
svn_boolean_t strict_node_history = FALSE; /* off by default */
svn_boolean_t include_merged_revisions = FALSE; /* off by default */
apr_array_header_t *revprops = apr_array_make(resource->pool, 3,
sizeof(const char *));
apr_array_header_t *paths
= apr_array_make(resource->pool, 1, sizeof(const char *));
/* Sanity check. */
if (!resource->info->repos_path)
return dav_svn__new_error(resource->pool, HTTP_BAD_REQUEST, 0,
"The request does not specify a repository path");
ns = dav_svn__find_ns(doc->namespaces, SVN_XML_NAMESPACE);
if (ns == -1)
{
return dav_svn__new_error_tag(resource->pool, HTTP_BAD_REQUEST, 0,
"The request does not contain the 'svn:' "
"namespace, so it is not going to have "
"certain required elements.",
SVN_DAV_ERROR_NAMESPACE,
SVN_DAV_ERROR_TAG);
}
/* If this is still FALSE after the loop, we haven't seen either of
the revprop elements, meaning a pre-1.5 client; we'll return the
standard author/date/log revprops. */
seen_revprop_element = FALSE;
lrb.requested_custom_revprops = FALSE;
lrb.encode_binary_props = FALSE;
for (child = doc->root->first_child; child != NULL; child = child->next)
{
/* if this element isn't one of ours, then skip it */
if (child->ns != ns)
continue;
if (strcmp(child->name, "start-revision") == 0)
start = SVN_STR_TO_REV(dav_xml_get_cdata(child, resource->pool, 1));
else if (strcmp(child->name, "end-revision") == 0)
end = SVN_STR_TO_REV(dav_xml_get_cdata(child, resource->pool, 1));
else if (strcmp(child->name, "limit") == 0)
{
serr = svn_cstring_atoi(&limit,
dav_xml_get_cdata(child, resource->pool, 1));
if (serr)
{
return dav_svn__convert_err(serr, HTTP_BAD_REQUEST,
"Malformed CDATA in element "
"\"limit\"", resource->pool);
}
}
else if (strcmp(child->name, "discover-changed-paths") == 0)
discover_changed_paths = TRUE; /* presence indicates positivity */
else if (strcmp(child->name, "strict-node-history") == 0)
strict_node_history = TRUE; /* presence indicates positivity */
else if (strcmp(child->name, "include-merged-revisions") == 0)
include_merged_revisions = TRUE; /* presence indicates positivity */
else if (strcmp(child->name, "encode-binary-props") == 0)
lrb.encode_binary_props = TRUE; /* presence indicates positivity */
else if (strcmp(child->name, "all-revprops") == 0)
{
revprops = NULL; /* presence indicates fetch all revprops */
seen_revprop_element = lrb.requested_custom_revprops = TRUE;
}
else if (strcmp(child->name, "no-revprops") == 0)
{
/* presence indicates fetch no revprops */
seen_revprop_element = lrb.requested_custom_revprops = TRUE;
}
else if (strcmp(child->name, "revprop") == 0)
{
if (revprops)
{
/* We're not fetching all revprops, append to fetch list. */
const char *name = dav_xml_get_cdata(child, resource->pool, 0);
APR_ARRAY_PUSH(revprops, const char *) = name;
if (!lrb.requested_custom_revprops
&& strcmp(name, SVN_PROP_REVISION_AUTHOR) != 0
&& strcmp(name, SVN_PROP_REVISION_DATE) != 0
&& strcmp(name, SVN_PROP_REVISION_LOG) != 0)
lrb.requested_custom_revprops = TRUE;
}
seen_revprop_element = TRUE;
}
else if (strcmp(child->name, "path") == 0)
{
const char *rel_path = dav_xml_get_cdata(child, resource->pool, 0);
if ((derr = dav_svn__test_canonical(rel_path, resource->pool)))
return derr;
/* Force REL_PATH to be a relative path, not an fspath. */
rel_path = svn_relpath_canonicalize(rel_path, resource->pool);
/* Append the REL_PATH to the base FS path to get an
absolute repository path. */
target = svn_fspath__join(resource->info->repos_path, rel_path,
resource->pool);
APR_ARRAY_PUSH(paths, const char *) = target;
}
/* else unknown element; skip it */
}
if (!seen_revprop_element)
{
/* pre-1.5 client */
APR_ARRAY_PUSH(revprops, const char *) = SVN_PROP_REVISION_AUTHOR;
APR_ARRAY_PUSH(revprops, const char *) = SVN_PROP_REVISION_DATE;
APR_ARRAY_PUSH(revprops, const char *) = SVN_PROP_REVISION_LOG;
}
/* Build authz read baton */
arb.r = resource->info->r;
arb.repos = resource->info->repos;
/* Build log receiver baton */
lrb.bb = apr_brigade_create(resource->pool, /* not the subpool! */
output->c->bucket_alloc);
lrb.output = output;
lrb.needs_header = TRUE;
lrb.stack_depth = 0;
/* lrb.requested_custom_revprops set above */
/* Our svn_log_entry_receiver_t sends the <S:log-report> header in
a lazy fashion. Before writing the first log message, it assures
that the header has already been sent (checking the needs_header
flag in our log_receiver_baton structure). */
/* Send zero or more log items. */
serr = svn_repos_get_logs4(repos->repos,
paths,
start,
end,
limit,
discover_changed_paths,
strict_node_history,
include_merged_revisions,
revprops,
dav_svn__authz_read_func(&arb),
&arb,
log_receiver,
&lrb,
resource->pool);
if (serr)
{
derr = dav_svn__convert_err(serr, HTTP_BAD_REQUEST, serr->message,
resource->pool);
goto cleanup;
}
if ((serr = maybe_send_header(&lrb)))
{
derr = dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Error beginning REPORT response.",
resource->pool);
goto cleanup;
}
if ((serr = dav_svn__brigade_puts(lrb.bb, lrb.output,
"</S:log-report>" DEBUG_CR)))
{
derr = dav_svn__convert_err(serr, HTTP_INTERNAL_SERVER_ERROR,
"Error ending REPORT response.",
resource->pool);
goto cleanup;
}
cleanup:
dav_svn__operational_log(resource->info,
svn_log__log(paths, start, end, limit,
discover_changed_paths,
strict_node_history,
include_merged_revisions, revprops,
resource->pool));
return dav_svn__final_flush_or_error(resource->info->r, lrb.bb, output,
derr, resource->pool);
}
dav_error *
dav_svn__replay_report(const dav_resource *resource,
const apr_xml_doc *doc,
ap_filter_t *output)
{
svn_revnum_t low_water_mark = SVN_INVALID_REVNUM;
svn_revnum_t rev = SVN_INVALID_REVNUM;
const svn_delta_editor_t *editor;
svn_boolean_t send_deltas = TRUE;
dav_svn__authz_read_baton arb;
const char *base_dir = resource->info->repos_path;
apr_bucket_brigade *bb;
apr_xml_elem *child;
svn_fs_root_t *root;
svn_error_t *err;
void *edit_baton;
int ns;
/* The request won't have a repos_path if it's for the root. */
if (! base_dir)
base_dir = "";
arb.r = resource->info->r;
arb.repos = resource->info->repos;
ns = dav_svn__find_ns(doc->namespaces, SVN_XML_NAMESPACE);
if (ns == -1)
return dav_svn__new_error_tag(resource->pool, HTTP_BAD_REQUEST, 0,
"The request does not contain the 'svn:' "
"namespace, so it is not going to have an "
"svn:revision element. That element is "
"required.",
SVN_DAV_ERROR_NAMESPACE,
SVN_DAV_ERROR_TAG);
for (child = doc->root->first_child; child != NULL; child = child->next)
{
if (child->ns == ns)
{
const char *cdata;
if (strcmp(child->name, "revision") == 0)
{
cdata = dav_xml_get_cdata(child, resource->pool, 1);
if (! cdata)
return malformed_element_error("revision", resource->pool);
rev = SVN_STR_TO_REV(cdata);
}
else if (strcmp(child->name, "low-water-mark") == 0)
{
cdata = dav_xml_get_cdata(child, resource->pool, 1);
if (! cdata)
return malformed_element_error("low-water-mark",
resource->pool);
low_water_mark = SVN_STR_TO_REV(cdata);
}
else if (strcmp(child->name, "send-deltas") == 0)
{
cdata = dav_xml_get_cdata(child, resource->pool, 1);
if (! cdata)
return malformed_element_error("send-deltas", resource->pool);
send_deltas = atoi(cdata);
}
}
}
if (! SVN_IS_VALID_REVNUM(rev))
return dav_svn__new_error_tag
(resource->pool, HTTP_BAD_REQUEST, 0,
"Request was missing the revision argument.",
SVN_DAV_ERROR_NAMESPACE, SVN_DAV_ERROR_TAG);
if (! SVN_IS_VALID_REVNUM(low_water_mark))
return dav_svn__new_error_tag
(resource->pool, HTTP_BAD_REQUEST, 0,
"Request was missing the low-water-mark argument.",
SVN_DAV_ERROR_NAMESPACE, SVN_DAV_ERROR_TAG);
bb = apr_brigade_create(resource->pool, output->c->bucket_alloc);
if ((err = svn_fs_revision_root(&root, resource->info->repos->fs, rev,
resource->pool)))
return dav_svn__convert_err(err, HTTP_INTERNAL_SERVER_ERROR,
"Couldn't retrieve revision root",
resource->pool);
make_editor(&editor, &edit_baton, bb, output, resource->pool);
if ((err = svn_repos_replay2(root, base_dir, low_water_mark,
send_deltas, editor, edit_baton,
dav_svn__authz_read_func(&arb), &arb,
resource->pool)))
return dav_svn__convert_err(err, HTTP_INTERNAL_SERVER_ERROR,
"Problem replaying revision",
resource->pool);
if ((err = end_report(edit_baton)))
return dav_svn__convert_err(err, HTTP_INTERNAL_SERVER_ERROR,
"Problem closing editor drive",
resource->pool);
{
const char *action, *log_base_dir;
if (base_dir && base_dir[0] != '\0')
log_base_dir = svn_path_uri_encode(base_dir, resource->info->r->pool);
else
log_base_dir = "/";
action = apr_psprintf(resource->info->r->pool, "replay %s r%ld",
log_base_dir, rev);
dav_svn__operational_log(resource->info, action);
}
ap_fflush(output, bb);
return NULL;
}
