#include <apr_pools.h>
#include <apr_tables.h>
#include <apr_strings.h>
#define APR_WANT_STRFUNC
#include <apr_want.h>
#include <ne_socket.h>
#include <ne_basic.h>
#include <ne_props.h>
#include <ne_xml.h>
#include "svn_error.h"
#include "svn_path.h"
#include "svn_dav.h"
#include "svn_base64.h"
#include "svn_xml.h"
#include "svn_time.h"
#include "svn_pools.h"
#include "svn_props.h"
#include "../libsvn_ra/ra_loader.h"
#include "svn_private_config.h"
#include "ra_dav.h"
const ne_propname svn_ra_dav__vcc_prop = {
"DAV:", "version-controlled-configuration"
};
const ne_propname svn_ra_dav__checked_in_prop = {
"DAV:", "checked-in"
};
static const ne_propname starting_props[] =
{
{ "DAV:", "version-controlled-configuration" },
{ "DAV:", "resourcetype" },
{ SVN_DAV_PROP_NS_DAV, "baseline-relative-path" },
{ SVN_DAV_PROP_NS_DAV, "repository-uuid"},
{ NULL }
};
static const ne_propname baseline_props[] =
{
{ "DAV:", "baseline-collection" },
{ "DAV:", "version-name" },
{ NULL }
};
typedef struct {
svn_ra_dav__xml_elmid id;
const char *name;
int is_property;
} elem_defn;
static const elem_defn elem_definitions[] =
{
{ ELEM_multistatus, "DAV:multistatus", 0 },
{ ELEM_response, "DAV:response", 0 },
{ ELEM_href, "DAV:href", SVN_RA_DAV__XML_CDATA },
{ ELEM_propstat, "DAV:propstat", 0 },
{ ELEM_prop, "DAV:prop", 0 },
{ ELEM_status, "DAV:status", SVN_RA_DAV__XML_CDATA },
{ ELEM_baseline, "DAV:baseline", SVN_RA_DAV__XML_CDATA },
{ ELEM_collection, "DAV:collection", SVN_RA_DAV__XML_CDATA },
{ ELEM_resourcetype, "DAV:resourcetype", 0 },
{ ELEM_baseline_coll, SVN_RA_DAV__PROP_BASELINE_COLLECTION, 0 },
{ ELEM_checked_in, SVN_RA_DAV__PROP_CHECKED_IN, 0 },
{ ELEM_vcc, SVN_RA_DAV__PROP_VCC, 0 },
{ ELEM_version_name, SVN_RA_DAV__PROP_VERSION_NAME, 1 },
{ ELEM_get_content_length, SVN_RA_DAV__PROP_GETCONTENTLENGTH, 1 },
{ ELEM_creationdate, SVN_RA_DAV__PROP_CREATIONDATE, 1 },
{ ELEM_creator_displayname, SVN_RA_DAV__PROP_CREATOR_DISPLAYNAME, 1 },
{ ELEM_baseline_relpath, SVN_RA_DAV__PROP_BASELINE_RELPATH, 1 },
{ ELEM_md5_checksum, SVN_RA_DAV__PROP_MD5_CHECKSUM, 1 },
{ ELEM_repository_uuid, SVN_RA_DAV__PROP_REPOSITORY_UUID, 1 },
{ ELEM_deadprop_count, SVN_RA_DAV__PROP_DEADPROP_COUNT, 1 },
{ 0 }
};
static const svn_ra_dav__xml_elm_t propfind_elements[] =
{
{ "DAV:", "multistatus", ELEM_multistatus, 0 },
{ "DAV:", "response", ELEM_response, 0 },
{ "DAV:", "href", ELEM_href, SVN_RA_DAV__XML_CDATA },
{ "DAV:", "propstat", ELEM_propstat, 0 },
{ "DAV:", "prop", ELEM_prop, 0 },
{ "DAV:", "status", ELEM_status, SVN_RA_DAV__XML_CDATA },
{ "DAV:", "baseline", ELEM_baseline, SVN_RA_DAV__XML_CDATA },
{ "DAV:", "baseline-collection", ELEM_baseline_coll, SVN_RA_DAV__XML_CDATA },
{ "DAV:", "checked-in", ELEM_checked_in, 0 },
{ "DAV:", "collection", ELEM_collection, SVN_RA_DAV__XML_CDATA },
{ "DAV:", "resourcetype", ELEM_resourcetype, 0 },
{ "DAV:", "version-controlled-configuration", ELEM_vcc, 0 },
{ "DAV:", "version-name", ELEM_version_name, SVN_RA_DAV__XML_CDATA },
{ "DAV:", "getcontentlength", ELEM_get_content_length,
SVN_RA_DAV__XML_CDATA },
{ "DAV:", "creationdate", ELEM_creationdate, SVN_RA_DAV__XML_CDATA },
{ "DAV:", "creator-displayname", ELEM_creator_displayname,
SVN_RA_DAV__XML_CDATA },
{ SVN_DAV_PROP_NS_DAV, "baseline-relative-path", ELEM_baseline_relpath,
SVN_RA_DAV__XML_CDATA },
{ SVN_DAV_PROP_NS_DAV, "md5-checksum", ELEM_md5_checksum,
SVN_RA_DAV__XML_CDATA },
{ SVN_DAV_PROP_NS_DAV, "repository-uuid", ELEM_repository_uuid,
SVN_RA_DAV__XML_CDATA },
{ SVN_DAV_PROP_NS_DAV, "deadprop-count", ELEM_deadprop_count,
SVN_RA_DAV__XML_CDATA },
{ "", "", ELEM_unknown, SVN_RA_DAV__XML_COLLECT },
{ NULL }
};
typedef struct propfind_ctx_t
{
apr_hash_t *props;
svn_ra_dav_resource_t *rsrc;
const char *encoding;
int status;
apr_hash_t *propbuffer;
svn_ra_dav__xml_elmid last_open_id;
ne_xml_parser *parser;
apr_pool_t *pool;
} propfind_ctx_t;
static const elem_defn *defn_from_id(svn_ra_dav__xml_elmid id)
{
const elem_defn *defn;
for (defn = elem_definitions; defn->name != NULL; ++defn)
{
if (id == defn->id)
return defn;
}
return NULL;
}
static void assign_rsrc_url(svn_ra_dav_resource_t *rsrc,
const char *url,
apr_pool_t *pool)
{
char *url_path;
apr_size_t len;
ne_uri parsed_url;
(void) ne_uri_parse(url, &parsed_url);
url_path = apr_pstrdup(pool, parsed_url.path);
ne_uri_free(&parsed_url);
len = strlen(url_path);
if (len > 1 && url_path[len - 1] == '/')
url_path[len - 1] = '\0';
rsrc->url = url_path;
}
static int validate_element(void *userdata,
svn_ra_dav__xml_elmid parent,
svn_ra_dav__xml_elmid child)
{
switch (parent)
{
case ELEM_root:
if (child == ELEM_multistatus)
return SVN_RA_DAV__XML_VALID;
else
return SVN_RA_DAV__XML_INVALID;
case ELEM_multistatus:
if (child == ELEM_response)
return SVN_RA_DAV__XML_VALID;
else
return SVN_RA_DAV__XML_DECLINE;
case ELEM_response:
if ((child == ELEM_href) || (child == ELEM_propstat))
return SVN_RA_DAV__XML_VALID;
else
return SVN_RA_DAV__XML_DECLINE;
case ELEM_propstat:
if ((child == ELEM_prop) || (child == ELEM_status))
return SVN_RA_DAV__XML_VALID;
else
return SVN_RA_DAV__XML_DECLINE;
case ELEM_prop:
return SVN_RA_DAV__XML_VALID;
case ELEM_baseline_coll:
case ELEM_checked_in:
case ELEM_vcc:
if (child == ELEM_href)
return SVN_RA_DAV__XML_VALID;
else
return SVN_RA_DAV__XML_DECLINE;
case ELEM_resourcetype:
if ((child == ELEM_collection) || (child == ELEM_baseline))
return SVN_RA_DAV__XML_VALID;
else
return SVN_RA_DAV__XML_DECLINE;
default:
return SVN_RA_DAV__XML_DECLINE;
}
}
static int start_element(void *userdata,
const svn_ra_dav__xml_elm_t *elm,
const char **atts)
{
propfind_ctx_t *pc = userdata;
switch (elm->id)
{
case ELEM_response:
if (pc->rsrc)
return SVN_RA_DAV__XML_INVALID;
pc->rsrc = apr_pcalloc(pc->pool, sizeof(*(pc->rsrc)));
pc->rsrc->pool = pc->pool;
pc->rsrc->propset = apr_hash_make(pc->pool);
pc->status = 0;
break;
case ELEM_propstat:
pc->status = 0;
break;
case ELEM_href:
pc->rsrc->href_parent = pc->last_open_id;
break;
case ELEM_collection:
pc->rsrc->is_collection = 1;
break;
case ELEM_unknown:
pc->encoding = ne_xml_get_attr(pc->parser, atts, SVN_DAV_PROP_NS_DAV,
"encoding");
if (pc->encoding)
pc->encoding = apr_pstrdup(pc->pool, pc->encoding);
break;
default:
break;
}
pc->last_open_id = elm->id;
return SVN_RA_DAV__XML_VALID;
}
static int end_element(void *userdata,
const svn_ra_dav__xml_elm_t *elm,
const char *cdata)
{
propfind_ctx_t *pc = userdata;
svn_ra_dav_resource_t *rsrc = pc->rsrc;
const char *name;
const svn_string_t *value = NULL;
const elem_defn *parent_defn;
const elem_defn *defn;
ne_status status;
switch (elm->id)
{
case ELEM_response:
if (!pc->rsrc->url)
return SVN_RA_DAV__XML_INVALID;
apr_hash_set(pc->props, pc->rsrc->url, APR_HASH_KEY_STRING, pc->rsrc);
pc->rsrc = NULL;
return SVN_RA_DAV__XML_VALID;
case ELEM_propstat:
if (pc->status)
{
apr_hash_index_t *hi = apr_hash_first(pc->pool, pc->propbuffer);
for (; hi; hi = apr_hash_next(hi))
{
const void *key;
apr_ssize_t klen;
void *val;
apr_hash_this(hi, &key, &klen, &val);
if (pc->status == 200)
apr_hash_set(rsrc->propset, key, klen, val);
apr_hash_set(pc->propbuffer, key, klen, NULL);
}
}
else if (! pc->status)
{
return SVN_RA_DAV__XML_INVALID;
}
return SVN_RA_DAV__XML_VALID;
case ELEM_status:
if (ne_parse_statusline(cdata, &status))
return SVN_RA_DAV__XML_INVALID;
free(status.reason_phrase);
pc->status = status.code;
return SVN_RA_DAV__XML_VALID;
case ELEM_href:
if (rsrc->href_parent == ELEM_response)
{
assign_rsrc_url(pc->rsrc, cdata, pc->pool);
return SVN_RA_DAV__XML_VALID;
}
parent_defn = defn_from_id(rsrc->href_parent);
if (!parent_defn)
return SVN_RA_DAV__XML_VALID;
name = parent_defn->name;
value = svn_string_create(cdata, pc->pool);
break;
default:
if (elm->id == ELEM_unknown)
{
name = apr_pstrcat(pc->pool, elm->nspace, elm->name, NULL);
}
else
{
defn = defn_from_id(elm->id);
if (! (defn && defn->is_property))
return SVN_RA_DAV__XML_VALID;
name = defn->name;
}
if (pc->encoding == NULL) {
value = svn_string_create(cdata, pc->pool);
break;
}
if (strcmp(pc->encoding, "base64") != 0)
return SVN_RA_DAV__XML_INVALID;
{
svn_string_t in;
in.data = cdata;
in.len = strlen(cdata);
value = svn_base64_decode_string(&in, pc->pool);
}
pc->encoding = NULL;
}
apr_hash_set(pc->propbuffer, name, APR_HASH_KEY_STRING, value);
return SVN_RA_DAV__XML_VALID;
}
static void set_parser(ne_xml_parser *parser,
void *baton)
{
propfind_ctx_t *pc = baton;
pc->parser = parser;
}
svn_error_t * svn_ra_dav__get_props(apr_hash_t **results,
ne_session *sess,
const char *url,
int depth,
const char *label,
const ne_propname *which_props,
apr_pool_t *pool)
{
svn_error_t *err = SVN_NO_ERROR;
propfind_ctx_t pc;
ne_buffer *body;
apr_hash_t *extra_headers = apr_hash_make(pool);
if (depth == NE_DEPTH_ZERO)
apr_hash_set(extra_headers, "Depth", 5, "0");
else if (depth == NE_DEPTH_ONE)
apr_hash_set(extra_headers, "Depth", 5, "1");
else if (depth == NE_DEPTH_INFINITE)
apr_hash_set(extra_headers, "Depth", 5, "infinite");
else
abort();
if (label != NULL)
apr_hash_set(extra_headers, "Label", 5, label);
body = ne_buffer_create();
ne_buffer_zappend(body,
"<?xml version=\"1.0\" encoding=\"utf-8\"?>" DEBUG_CR
"<propfind xmlns=\"DAV:\">" DEBUG_CR);
if (which_props)
{
int n;
ne_buffer_zappend(body, "<prop>" DEBUG_CR);
for (n = 0; which_props[n].name != NULL; n++)
{
ne_buffer_concat(body, "<", which_props[n].name, " xmlns=\"",
which_props[n].nspace, "\"/>" DEBUG_CR, NULL);
}
ne_buffer_zappend(body, "</prop></propfind>" DEBUG_CR);
}
else
{
ne_buffer_zappend(body, "<allprop/></propfind>" DEBUG_CR);
}
memset(&pc, 0, sizeof(pc));
pc.pool = pool;
pc.propbuffer = apr_hash_make(pool);
pc.props = apr_hash_make(pool);
err = svn_ra_dav__parsed_request_compat(sess, "PROPFIND", url,
body->data, 0,
set_parser, propfind_elements,
validate_element,
start_element, end_element,
&pc, extra_headers, NULL, FALSE,
pool);
ne_buffer_destroy(body);
*results = pc.props;
return err;
}
svn_error_t * svn_ra_dav__get_props_resource(svn_ra_dav_resource_t **rsrc,
ne_session *sess,
const char *url,
const char *label,
const ne_propname *which_props,
apr_pool_t *pool)
{
apr_hash_t *props;
char * url_path = apr_pstrdup(pool, url);
int len = strlen(url);
if (len > 1 && url[len - 1] == '/')
url_path[len - 1] = '\0';
SVN_ERR(svn_ra_dav__get_props(&props, sess, url_path, NE_DEPTH_ZERO,
label, which_props, pool));
if (1 || label != NULL)
{
apr_hash_index_t *hi = apr_hash_first(pool, props);
if (hi)
{
void *ent;
apr_hash_this(hi, NULL, NULL, &ent);
*rsrc = ent;
}
else
*rsrc = NULL;
}
else
{
*rsrc = apr_hash_get(props, url_path, APR_HASH_KEY_STRING);
}
if (*rsrc == NULL)
{
return svn_error_createf(APR_EGENERAL, NULL,
_("Failed to find label '%s' for URL '%s'"),
label ? label : "NULL", url_path);
}
return SVN_NO_ERROR;
}
svn_error_t * svn_ra_dav__get_one_prop(const svn_string_t **propval,
ne_session *sess,
const char *url,
const char *label,
const ne_propname *propname,
apr_pool_t *pool)
{
svn_ra_dav_resource_t *rsrc;
ne_propname props[2] = { { 0 } };
const char *name;
const svn_string_t *value;
props[0] = *propname;
SVN_ERR(svn_ra_dav__get_props_resource(&rsrc, sess, url, label, props,
pool));
name = apr_pstrcat(pool, propname->nspace, propname->name, NULL);
value = apr_hash_get(rsrc->propset, name, APR_HASH_KEY_STRING);
if (value == NULL)
{
return svn_error_createf(SVN_ERR_RA_DAV_PROPS_NOT_FOUND, NULL,
_("'%s' was not present on the resource"),
name);
}
*propval = value;
return SVN_NO_ERROR;
}
svn_error_t * svn_ra_dav__get_starting_props(svn_ra_dav_resource_t **rsrc,
ne_session *sess,
const char *url,
const char *label,
apr_pool_t *pool)
{
return svn_ra_dav__get_props_resource(rsrc, sess, url, label, starting_props,
pool);
}
svn_error_t *
svn_ra_dav__search_for_starting_props(svn_ra_dav_resource_t **rsrc,
const char **missing_path,
ne_session *sess,
const char *url,
apr_pool_t *pool)
{
svn_error_t *err = SVN_NO_ERROR;
apr_size_t len;
svn_stringbuf_t *path_s;
ne_uri parsed_url;
const char *lopped_path = "";
ne_uri_parse(url, &parsed_url);
if (parsed_url.path == NULL)
{
return svn_error_createf(SVN_ERR_RA_ILLEGAL_URL, NULL,
_("Neon was unable to parse URL '%s'"), url);
}
path_s = svn_stringbuf_create(parsed_url.path, pool);
while (! svn_path_is_empty(path_s->data))
{
err = svn_ra_dav__get_starting_props(rsrc, sess, path_s->data,
NULL, pool);
if (! err)
break;
if (err->apr_err != SVN_ERR_RA_DAV_PATH_NOT_FOUND)
goto error;
lopped_path = svn_path_join(svn_path_basename(path_s->data, pool),
lopped_path, pool);
len = path_s->len;
svn_path_remove_component(path_s);
if (path_s->len == len)
{
err = svn_error_quick_wrap
(err, _("The path was not part of a repository"));
goto error;
}
svn_error_clear(err);
}
if (svn_path_is_empty(path_s->data))
{
err = svn_error_createf(SVN_ERR_RA_ILLEGAL_URL, NULL,
_("No part of path '%s' was found in "
"repository HEAD"), parsed_url.path);
goto error;
}
*missing_path = lopped_path;
error:
ne_uri_free(&parsed_url);
return err;
}
svn_error_t *svn_ra_dav__get_vcc(const char **vcc,
ne_session *sess,
const char *url,
apr_pool_t *pool)
{
svn_ra_dav_resource_t *rsrc;
const char *lopped_path;
const svn_string_t *vcc_s;
SVN_ERR(svn_ra_dav__search_for_starting_props(&rsrc, &lopped_path,
sess, url, pool));
vcc_s = apr_hash_get(rsrc->propset,
SVN_RA_DAV__PROP_VCC, APR_HASH_KEY_STRING);
if (! vcc_s)
return svn_error_create(APR_EGENERAL, NULL,
_("The VCC property was not found on the "
"resource"));
*vcc = vcc_s->data;
return SVN_NO_ERROR;
}
svn_error_t *svn_ra_dav__get_baseline_props(svn_string_t *bc_relative,
svn_ra_dav_resource_t **bln_rsrc,
ne_session *sess,
const char *url,
svn_revnum_t revision,
const ne_propname *which_props,
apr_pool_t *pool)
{
svn_ra_dav_resource_t *rsrc;
const svn_string_t *vcc;
const svn_string_t *relative_path;
const char *my_bc_relative;
const char *lopped_path;
SVN_ERR(svn_ra_dav__search_for_starting_props(&rsrc, &lopped_path,
sess, url, pool));
vcc = apr_hash_get(rsrc->propset, SVN_RA_DAV__PROP_VCC, APR_HASH_KEY_STRING);
if (vcc == NULL)
{
return svn_error_create(APR_EGENERAL, NULL,
_("The VCC property was not found on the "
"resource"));
}
relative_path = apr_hash_get(rsrc->propset,
SVN_RA_DAV__PROP_BASELINE_RELPATH,
APR_HASH_KEY_STRING);
if (relative_path == NULL)
{
return svn_error_create(APR_EGENERAL, NULL,
_("The relative-path property was not "
"found on the resource"));
}
my_bc_relative = svn_path_join(relative_path->data,
svn_path_uri_decode(lopped_path, pool),
pool);
if (bc_relative)
{
bc_relative->data = my_bc_relative;
bc_relative->len = strlen(my_bc_relative);
}
if (revision == SVN_INVALID_REVNUM)
{
const svn_string_t *baseline;
SVN_ERR(svn_ra_dav__get_one_prop(&baseline, sess, vcc->data, NULL,
&svn_ra_dav__checked_in_prop, pool));
SVN_ERR(svn_ra_dav__get_props_resource(&rsrc, sess,
baseline->data, NULL,
which_props, pool));
}
else
{
char label[20];
apr_snprintf(label, sizeof(label), "%ld", revision);
SVN_ERR(svn_ra_dav__get_props_resource(&rsrc, sess, vcc->data, label,
which_props, pool));
}
*bln_rsrc = rsrc;
return SVN_NO_ERROR;
}
svn_error_t *svn_ra_dav__get_baseline_info(svn_boolean_t *is_dir,
svn_string_t *bc_url,
svn_string_t *bc_relative,
svn_revnum_t *latest_rev,
ne_session *sess,
const char *url,
svn_revnum_t revision,
apr_pool_t *pool)
{
svn_ra_dav_resource_t *baseline_rsrc, *rsrc;
const svn_string_t *my_bc_url;
svn_string_t my_bc_rel;
SVN_ERR(svn_ra_dav__get_baseline_props(&my_bc_rel,
&baseline_rsrc,
sess,
url,
revision,
baseline_props,
pool));
my_bc_url = apr_hash_get(baseline_rsrc->propset,
SVN_RA_DAV__PROP_BASELINE_COLLECTION,
APR_HASH_KEY_STRING);
if (my_bc_url == NULL)
{
return svn_error_create(APR_EGENERAL, NULL,
_("'DAV:baseline-collection' was not present "
"on the baseline resource"));
}
if (bc_url)
*bc_url = *my_bc_url;
if (latest_rev != NULL)
{
const svn_string_t *vsn_name= apr_hash_get(baseline_rsrc->propset,
SVN_RA_DAV__PROP_VERSION_NAME,
APR_HASH_KEY_STRING);
if (vsn_name == NULL)
{
return svn_error_create(APR_EGENERAL, NULL,
_("'DAV:version-name' was not present"
" on the baseline resource"));
}
*latest_rev = SVN_STR_TO_REV(vsn_name->data);
}
if (is_dir != NULL)
{
const char *full_bc_url = svn_path_url_add_component(my_bc_url->data,
my_bc_rel.data,
pool);
SVN_ERR(svn_ra_dav__get_props_resource(&rsrc, sess, full_bc_url,
NULL, starting_props, pool));
*is_dir = rsrc->is_collection;
}
if (bc_relative)
*bc_relative = my_bc_rel;
return SVN_NO_ERROR;
}
static void
do_setprop(ne_buffer *body,
const char *name,
const svn_string_t *value,
apr_pool_t *pool)
{
const char *encoding = "";
const char *xml_safe;
const char *xml_tag_name;
#define NSLEN (sizeof(SVN_PROP_PREFIX) - 1)
if (strncmp(name, SVN_PROP_PREFIX, NSLEN) == 0)
{
xml_tag_name = apr_pstrcat(pool, "S:", name + NSLEN, NULL);
}
#undef NSLEN
else
{
xml_tag_name = apr_pstrcat(pool, "C:", name, NULL);
}
if (! value)
{
ne_buffer_concat(body, "<", xml_tag_name, "/>", NULL);
return;
}
if (svn_xml_is_xml_safe(value->data, value->len))
{
svn_stringbuf_t *xml_esc = NULL;
svn_xml_escape_cdata_string(&xml_esc, value, pool);
xml_safe = xml_esc->data;
}
else
{
const svn_string_t *base64ed = svn_base64_encode_string(value, pool);
encoding = " V:encoding=\"base64\"";
xml_safe = base64ed->data;
}
ne_buffer_concat(body, "<", xml_tag_name, encoding, ">",
xml_safe, "</", xml_tag_name, ">", NULL);
return;
}
svn_error_t *
svn_ra_dav__do_proppatch(svn_ra_dav__session_t *ras,
const char *url,
apr_hash_t *prop_changes,
apr_array_header_t *prop_deletes,
apr_hash_t *extra_headers,
apr_pool_t *pool)
{
ne_request *req;
int code;
ne_buffer *body;
svn_error_t *err;
if ((prop_changes == NULL || (! apr_hash_count(prop_changes)))
&& (prop_deletes == NULL || prop_deletes->nelts == 0))
return SVN_NO_ERROR;
body = ne_buffer_create();
ne_buffer_zappend(body,
"<?xml version=\"1.0\" encoding=\"utf-8\" ?>" DEBUG_CR
"<D:propertyupdate xmlns:D=\"DAV:\" xmlns:V=\""
SVN_DAV_PROP_NS_DAV "\" xmlns:C=\""
SVN_DAV_PROP_NS_CUSTOM "\" xmlns:S=\""
SVN_DAV_PROP_NS_SVN "\">");
if (prop_changes)
{
apr_hash_index_t *hi;
apr_pool_t *subpool = svn_pool_create(pool);
ne_buffer_zappend(body, "<D:set><D:prop>");
for (hi = apr_hash_first(pool, prop_changes); hi; hi = apr_hash_next(hi))
{
const void *key;
void *val;
svn_pool_clear(subpool);
apr_hash_this(hi, &key, NULL, &val);
do_setprop(body, key, val, subpool);
}
ne_buffer_zappend(body, "</D:prop></D:set>");
svn_pool_destroy(subpool);
}
if (prop_deletes)
{
int n;
ne_buffer_zappend(body, "<D:remove><D:prop>");
for (n = 0; n < prop_deletes->nelts; n++)
{
const char *name = APR_ARRAY_IDX(prop_deletes, n, const char *);
do_setprop(body, name, NULL, pool);
}
ne_buffer_zappend(body, "</D:prop></D:remove>");
}
ne_buffer_zappend(body, "</D:propertyupdate>");
req = ne_request_create(ras->sess, "PROPPATCH", url);
ne_set_request_body_buffer(req, body->data, ne_buffer_size(body));
ne_add_request_header(req, "Content-Type", "text/xml; charset=UTF-8");
if (extra_headers != NULL)
{
apr_hash_index_t *hi;
for (hi = apr_hash_first(pool, extra_headers);
hi; hi = apr_hash_next(hi))
{
const void *key;
void *val;
apr_hash_this(hi, &key, NULL, &val);
ne_add_request_header(req, (const char *) key, (const char *) val);
}
}
code = ne_simple_request(ras->sess, req);
if (code == NE_OK)
{
err = SVN_NO_ERROR;
}
else
{
err = svn_error_create
(SVN_ERR_RA_DAV_PROPPATCH_FAILED, NULL,
_("At least one property change failed; repository is unchanged"));
}
ne_buffer_destroy(body);
return err;
}
svn_error_t *
svn_ra_dav__do_check_path(svn_ra_session_t *session,
const char *path,
svn_revnum_t revision,
svn_node_kind_t *kind,
apr_pool_t *pool)
{
svn_ra_dav__session_t *ras = session->priv;
const char *url = ras->url->data;
svn_error_t *err;
svn_boolean_t is_dir;
if (path)
url = svn_path_url_add_component(url, path, pool);
err = svn_ra_dav__get_baseline_info(&is_dir, NULL, NULL, NULL,
ras->sess, url, revision, pool);
if (err == SVN_NO_ERROR)
{
if (is_dir)
*kind = svn_node_dir;
else
*kind = svn_node_file;
}
else if (err->apr_err == SVN_ERR_RA_DAV_PATH_NOT_FOUND)
{
svn_error_clear(err);
*kind = svn_node_none;
return SVN_NO_ERROR;
}
return err;
}
svn_error_t *
svn_ra_dav__do_stat(svn_ra_session_t *session,
const char *path,
svn_revnum_t revision,
svn_dirent_t **dirent,
apr_pool_t *pool)
{
svn_ra_dav__session_t *ras = session->priv;
const char *url = ras->url->data;
const char *final_url;
apr_hash_t *resources;
apr_hash_index_t *hi;
svn_error_t *err;
if (path)
url = svn_path_url_add_component(url, path, pool);
if (! SVN_IS_VALID_REVNUM(revision))
{
final_url = url;
}
else
{
svn_string_t bc_url, bc_relative;
err = svn_ra_dav__get_baseline_info(NULL, &bc_url, &bc_relative,
NULL, ras->sess,
url, revision, pool);
if (err)
{
if (err->apr_err == SVN_ERR_RA_DAV_PATH_NOT_FOUND)
{
svn_error_clear(err);
*dirent = NULL;
return SVN_NO_ERROR;
}
else
return err;
}
final_url = svn_path_url_add_component(bc_url.data, bc_relative.data,
pool);
}
err = svn_ra_dav__get_props(&resources, ras->sess, final_url, NE_DEPTH_ZERO,
NULL, NULL , pool);
if (err)
{
if (err->apr_err == SVN_ERR_RA_DAV_PATH_NOT_FOUND)
{
svn_error_clear(err);
*dirent = NULL;
return SVN_NO_ERROR;
}
else
return err;
}
for (hi = apr_hash_first(pool, resources); hi; hi = apr_hash_next(hi))
{
const void *key;
void *val;
const char *childname;
svn_ra_dav_resource_t *resource;
const svn_string_t *propval;
apr_hash_index_t *h;
svn_dirent_t *entry;
apr_hash_this(hi, &key, NULL, &val);
childname = key;
resource = val;
entry = apr_pcalloc(pool, sizeof(*entry));
entry->kind = resource->is_collection ? svn_node_dir : svn_node_file;
if (entry->kind == svn_node_file)
{
propval = apr_hash_get(resource->propset,
SVN_RA_DAV__PROP_GETCONTENTLENGTH,
APR_HASH_KEY_STRING);
if (propval)
entry->size = svn__atoui64(propval->data);
}
for (h = apr_hash_first(pool, resource->propset);
h; h = apr_hash_next(h))
{
const void *kkey;
void *vval;
apr_hash_this(h, &kkey, NULL, &vval);
if (strncmp((const char *)kkey, SVN_DAV_PROP_NS_CUSTOM,
sizeof(SVN_DAV_PROP_NS_CUSTOM) - 1) == 0)
entry->has_props = TRUE;
else if (strncmp((const char *)kkey, SVN_DAV_PROP_NS_SVN,
sizeof(SVN_DAV_PROP_NS_SVN) - 1) == 0)
entry->has_props = TRUE;
}
propval = apr_hash_get(resource->propset,
SVN_RA_DAV__PROP_VERSION_NAME,
APR_HASH_KEY_STRING);
if (propval != NULL)
entry->created_rev = SVN_STR_TO_REV(propval->data);
propval = apr_hash_get(resource->propset,
SVN_RA_DAV__PROP_CREATIONDATE,
APR_HASH_KEY_STRING);
if (propval != NULL)
SVN_ERR(svn_time_from_cstring(&(entry->time),
propval->data, pool));
propval = apr_hash_get(resource->propset,
SVN_RA_DAV__PROP_CREATOR_DISPLAYNAME,
APR_HASH_KEY_STRING);
if (propval != NULL)
entry->last_author = propval->data;
*dirent = entry;
}
return SVN_NO_ERROR;
}