svn_skel_t *svn_skel__dup(const svn_skel_t *src_skel, svn_boolean_t dup_data,
apr_pool_t *result_pool)
{
svn_skel_t *skel = apr_pmemdup(result_pool, src_skel, sizeof(svn_skel_t));
if (dup_data && skel->data)
{
if (skel->is_atom)
skel->data = apr_pmemdup(result_pool, skel->data, skel->len);
else
{
/* When creating a skel this would be NULL, 0 for a list.
When parsing a string to a skel this might point to real data
delimiting the sublist. We don't copy that from here. */
skel->data = NULL;
skel->len = 0;
}
}
if (skel->children)
skel->children = svn_skel__dup(skel->children, dup_data, result_pool);
if (skel->next)
skel->next = svn_skel__dup(skel->next, dup_data, result_pool);
return skel;
}
static void *filter_merge(apr_pool_t *pool, void *BASE, void *ADD)
{
mod_filter_cfg *base = BASE;
mod_filter_cfg *add = ADD;
mod_filter_chain *savelink = 0;
mod_filter_chain *newlink;
mod_filter_chain *p;
mod_filter_cfg *conf = apr_palloc(pool, sizeof(mod_filter_cfg));
conf->live_filters = apr_hash_overlay(pool, add->live_filters,
base->live_filters);
if (base->chain && add->chain) {
for (p = base->chain; p; p = p->next) {
newlink = apr_pmemdup(pool, p, sizeof(mod_filter_chain));
if (newlink->fname == NULL) {
conf->chain = savelink = newlink;
}
else if (savelink) {
savelink->next = newlink;
savelink = newlink;
}
else {
conf->chain = savelink = newlink;
}
}
for (p = add->chain; p; p = p->next) {
newlink = apr_pmemdup(pool, p, sizeof(mod_filter_chain));
/** Filter out merged chain resets */
if (newlink->fname == NULL) {
conf->chain = savelink = newlink;
}
else if (savelink) {
savelink->next = newlink;
savelink = newlink;
}
else {
conf->chain = savelink = newlink;
}
}
}
else if (add->chain) {
conf->chain = add->chain;
}
else {
conf->chain = base->chain;
}
return conf;
}
void
svn_stringbuf_replace(svn_stringbuf_t *str,
apr_size_t pos,
apr_size_t old_count,
const char *bytes,
apr_size_t new_count)
{
if (bytes + new_count > str->data && bytes < str->data + str->blocksize)
{
/* special case: BYTES overlaps with this string -> copy the source */
const char *temp = apr_pmemdup(str->pool, bytes, new_count);
svn_stringbuf_replace(str, pos, old_count, temp, new_count);
}
else
{
if (pos > str->len)
pos = str->len;
if (pos + old_count > str->len)
old_count = str->len - pos;
if (old_count < new_count)
{
apr_size_t delta = new_count - old_count;
svn_stringbuf_ensure(str, str->len + delta);
}
if (old_count != new_count)
memmove(str->data + pos + new_count, str->data + pos + old_count,
str->len - pos - old_count + 1);
memcpy(str->data + pos, bytes, new_count);
str->len += new_count - old_count;
}
}
static apr_status_t proc_mutex_flock_child_init(apr_proc_mutex_t **mutex,
apr_pool_t *pool,
const char *fname)
{
apr_proc_mutex_t *new_mutex;
int rv;
if (!fname) {
fname = (*mutex)->fname;
if (!fname) {
return APR_SUCCESS;
}
}
new_mutex = (apr_proc_mutex_t *)apr_pmemdup(pool, *mutex,
sizeof(apr_proc_mutex_t));
new_mutex->pool = pool;
new_mutex->fname = apr_pstrdup(pool, fname);
rv = apr_file_open(&new_mutex->interproc, new_mutex->fname,
APR_FOPEN_WRITE, 0, new_mutex->pool);
if (rv != APR_SUCCESS) {
return rv;
}
new_mutex->os.crossproc = new_mutex->interproc->filedes;
new_mutex->interproc_closing = 1;
*mutex = new_mutex;
return APR_SUCCESS;
}
static svn_error_t *
x509_name_to_certinfo(apr_array_header_t **result,
const x509_name *dn,
apr_pool_t *scratch_pool,
apr_pool_t *result_pool)
{
const x509_name *name = dn;
*result = apr_array_make(result_pool, 6, sizeof(svn_x509_name_attr_t *));
while (name != NULL) {
svn_x509_name_attr_t *attr = apr_palloc(result_pool, sizeof(svn_x509_name_attr_t));
attr->oid_len = name->oid.len;
attr->oid = apr_pmemdup(result_pool, name->oid.p, attr->oid_len);
attr->utf8_value = x509name_to_utf8_string(name, result_pool);
if (!attr->utf8_value)
/* this should never happen */
attr->utf8_value = apr_pstrdup(result_pool, "??");
APR_ARRAY_PUSH(*result, const svn_x509_name_attr_t *) = attr;
name = name->next;
}
return SVN_NO_ERROR;
}
svn_wc_info_t *
svn_wc_info_dup(const svn_wc_info_t *info,
apr_pool_t *pool)
{
svn_wc_info_t *new_info = apr_pmemdup(pool, info, sizeof(*new_info));
if (info->changelist)
new_info->changelist = apr_pstrdup(pool, info->changelist);
new_info->checksum = svn_checksum_dup(info->checksum, pool);
if (info->conflicts)
{
int i;
apr_array_header_t *new_conflicts
= apr_array_make(pool, info->conflicts->nelts, info->conflicts->elt_size);
for (i = 0; i < info->conflicts->nelts; i++)
{
APR_ARRAY_PUSH(new_conflicts, svn_wc_conflict_description2_t *)
= svn_wc__conflict_description2_dup(
APR_ARRAY_IDX(info->conflicts, i,
const svn_wc_conflict_description2_t *),
pool);
}
new_info->conflicts = new_conflicts;
}
/* Conforms to svn_ra_serf__xml_closed_t */
static svn_error_t *
getloc_closed(svn_ra_serf__xml_estate_t *xes,
void *baton,
int leaving_state,
const svn_string_t *cdata,
apr_hash_t *attrs,
apr_pool_t *scratch_pool)
{
loc_context_t *loc_ctx = baton;
const char *revstr;
const char *path;
SVN_ERR_ASSERT(leaving_state == LOCATION);
revstr = svn_hash_gets(attrs, "rev");
path = svn_hash_gets(attrs, "path");
if (revstr != NULL && path != NULL)
{
svn_revnum_t rev = SVN_STR_TO_REV(revstr);
apr_hash_set(loc_ctx->paths,
apr_pmemdup(loc_ctx->pool, &rev, sizeof(rev)), sizeof(rev),
apr_pstrdup(loc_ctx->pool, path));
}
return SVN_NO_ERROR;
}
static void *
fs_info_dup(const void *fsfs_info_void,
apr_pool_t *result_pool)
{
/* All fields are either ints or static strings. */
const svn_fs_fsfs_info_t *fsfs_info = fsfs_info_void;
return apr_pmemdup(result_pool, fsfs_info, sizeof(*fsfs_info));
}
static void *privileges_merge_cfg(apr_pool_t *pool, void *BASE, void *ADD)
{
/* inherit the mode if it's not set; the rest won't be inherited */
priv_cfg *base = BASE;
priv_cfg *add = ADD;
priv_cfg *ret = apr_pmemdup(pool, add, sizeof(priv_cfg));
ret->mode = (add->mode == PRIV_UNSET) ? base->mode : add->mode;
return ret;
}
/** Return a LDAP server suitable for an anonymous login to obtain its
RootDSE. */
int kdldap_servers_for_RootDSE(kdldap_servers *self,
apr_pool_t *pool,
kdldap_servers_list **srv_lst) {
if (self->use_dns)
return kdldap_ad_DNS_get_DC(self, pool, self->ad_forest, srv_lst);
else {
*srv_lst = apr_pmemdup(pool, self->static_ldap_servers, sizeof(kdldap_servers_list));
return 0;
}
}
/* Return a copy of KEY inside POOL, using CACHE->KLEN to figure out
* how. */
static const void *
duplicate_key(inprocess_cache_t *cache,
const void *key,
apr_pool_t *pool)
{
if (cache->klen == APR_HASH_KEY_STRING)
return apr_pstrdup(pool, key);
else
return apr_pmemdup(pool, key, cache->klen);
}
svn_fs_id_t *
svn_fs_fs__id_copy(const svn_fs_id_t *source, apr_pool_t *pool)
{
const fs_fs__id_t *id = (const fs_fs__id_t *)source;
fs_fs__id_t *new_id = apr_pmemdup(pool, id, sizeof(*new_id));
new_id->generic_id.fsap_data = new_id;
return (svn_fs_id_t *)new_id;
}
static svn_error_t *
close_handler_md5(void *baton)
{
struct md5_stream_baton *btn = baton;
SVN_ERR(svn_stream_close(btn->proxy));
if (btn->read_digest)
*btn->read_digest
= apr_pmemdup(btn->pool, btn->read_checksum->digest,
APR_MD5_DIGESTSIZE);
if (btn->write_digest)
*btn->write_digest
= apr_pmemdup(btn->pool, btn->write_checksum->digest,
APR_MD5_DIGESTSIZE);
return SVN_NO_ERROR;
}
/* Implements svn_cache__serialize_func_t */
static svn_error_t *
serialize_revnum(void **data,
apr_size_t *data_len,
void *in,
apr_pool_t *pool)
{
*data_len = sizeof(svn_revnum_t);
*data = apr_pmemdup(pool, in, *data_len);
return SVN_NO_ERROR;
}
/* Set in HASH the value VAL for the KEY (whose key length is KLEN).
* KEY will be duped into HASH's pool.
*/
static void
hash_set_copy(apr_hash_t *hash,
const void *key,
apr_ssize_t klen,
const void *val)
{
if (klen == APR_HASH_KEY_STRING)
klen = strlen(key);
apr_hash_set(hash, apr_pmemdup(apr_hash_pool_get(hash), key, klen),
klen, val);
}
svn_x509_name_attr_t *
svn_x509_name_attr_dup(const svn_x509_name_attr_t *attr,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
svn_x509_name_attr_t *result = apr_palloc(result_pool, sizeof(*result));
result->oid_len = attr->oid_len;
result->oid = apr_pmemdup(result_pool, attr->oid, attr->oid_len);
result->utf8_value = apr_pstrdup(result_pool, attr->utf8_value);
return result;
}
const void *
svn_sqlite__column_blob(svn_sqlite__stmt_t *stmt, int column,
apr_size_t *len, apr_pool_t *result_pool)
{
const void *val = sqlite3_column_blob(stmt->s3stmt, column);
*len = sqlite3_column_bytes(stmt->s3stmt, column);
if (result_pool && val != NULL)
val = apr_pmemdup(result_pool, val, *len);
return val;
}
int test_http_server_timeout_handler(void * cls,
struct MHD_Connection * connection,
const char * url,
const char * method,
const char * version,
const char * upload_data,
size_t * upload_data_size,
void ** ptr) {
test_http_server * handle = cls;
struct MHD_Response * response;
int ret;
int * c_count;
if (*ptr == NULL) {
handle->log = apr_hash_make(handle->pool);
/* The first time only the headers are valid,
do not respond in the first round... */
*ptr = cls; //just to flag its not null....
int * c_count = apr_palloc(handle->pool, sizeof(int));
*c_count = 0;
*ptr = c_count;
return MHD_YES;
}
c_count = *ptr;
if(*c_count == 0) {
//log the request....
apr_hash_set(handle->log, apr_pstrdup(handle->pool, "METHOD"), APR_HASH_KEY_STRING, apr_pstrdup(handle->pool, method));
apr_hash_set(handle->log, apr_pstrdup(handle->pool, "URL"), APR_HASH_KEY_STRING, apr_pstrdup(handle->pool, url));
apr_hash_set(handle->log, apr_pstrdup(handle->pool, "VERSION"), APR_HASH_KEY_STRING, apr_pstrdup(handle->pool, version));
apr_hash_set(handle->log, apr_pstrdup(handle->pool, "DATA_LENGTH"), APR_HASH_KEY_STRING, apr_pmemdup (handle->pool, upload_data_size, sizeof(size_t)));
apr_hash_set(handle->log, apr_pstrdup(handle->pool, "DATA"), APR_HASH_KEY_STRING, apr_pmemdup (handle->pool, upload_data, *upload_data_size));
}
*c_count = *c_count+1;
if(*upload_data_size == 0) {
//cause a timeout...
apr_sleep(handle->sleep_duration);
response = MHD_create_response_from_data(strlen(handle->response),
(void*) handle->response,
MHD_NO,
MHD_NO);
ret = MHD_queue_response(connection,
handle->response_code,
response);
MHD_destroy_response(response);
return ret;
} else {
*upload_data_size = 0; //we processed everything?
return MHD_YES;
}
}
MP_INLINE apr_status_t modperl_input_filter_write(pTHX_
modperl_filter_t *filter,
const char *buf,
apr_size_t *len)
{
apr_bucket_alloc_t *ba = filter->f->c->bucket_alloc;
char *copy = apr_pmemdup(filter->pool, buf, *len);
apr_bucket *bucket = apr_bucket_transient_create(copy, *len, ba);
MP_TRACE_f(MP_FUNC, MP_FILTER_NAME_FORMAT
"write out: %db [%s]:",
MP_FILTER_NAME(filter->f), *len,
MP_TRACE_STR_TRUNC(filter->pool, copy, *len));
APR_BRIGADE_INSERT_TAIL(filter->bb_out, bucket);
/* modperl_brigade_dump(filter->bb_out, NULL); */
return APR_SUCCESS;
}
svn_error_t *
svn_fs__compatible_version(svn_version_t **compatible_version,
apr_hash_t *config,
apr_pool_t *pool)
{
svn_version_t *version;
const char *compatible;
/* set compatible version according to generic option.
Make sure, we are always compatible to the current SVN version
(or older). */
compatible = svn_hash_gets(config, SVN_FS_CONFIG_COMPATIBLE_VERSION);
if (compatible)
{
SVN_ERR(svn_version__parse_version_string(&version,
compatible, pool));
add_compatility(version,
svn_subr_version()->major,
svn_subr_version()->minor);
}
else
{
version = apr_pmemdup(pool, svn_subr_version(), sizeof(*version));
}
/* specific options take precedence.
Let the lowest version compatibility requirement win */
if (svn_hash_gets(config, SVN_FS_CONFIG_PRE_1_4_COMPATIBLE))
add_compatility(version, 1, 3);
else if (svn_hash_gets(config, SVN_FS_CONFIG_PRE_1_5_COMPATIBLE))
add_compatility(version, 1, 4);
else if (svn_hash_gets(config, SVN_FS_CONFIG_PRE_1_6_COMPATIBLE))
add_compatility(version, 1, 5);
else if (svn_hash_gets(config, SVN_FS_CONFIG_PRE_1_8_COMPATIBLE))
add_compatility(version, 1, 7);
/* we ignored the patch level and tag so far.
* Give them a defined value. */
version->patch = 0;
version->tag = "";
/* done here */
*compatible_version = version;
return SVN_NO_ERROR;
}
/**
* get_3des_key:获取3des加密的密钥，长度24个字节
* @msr:上下文结构体
*
* 返回值：失败返回NULL，成功返回key字符串
*/
unsigned char *get_3des_key(apr_pool_t *pool, void *word)
{
unsigned char *key;
if (pool == NULL) {
return NULL;
}
/*先取key产生器的前25字节*/
key = (unsigned char *)apr_pmemdup(pool, (void *)word, 25);
if (key == NULL) {
return NULL;
}
/*第25位设置字符串结束符，返回24个字节的key*/
key[24] = 0;
return key;
}
/** Return a DC server suitable to check a user login. */
int kdldap_servers_for_user(kdldap_servers *self,
apr_pool_t *pool,
const char *dn,
kdldap_servers_list **srv_lst) {
apr_pool_t *lst_pool;
int err = -1;
apr_pool_create(&lst_pool, pool);
if (self->use_dns) {
apr_pool_t *fn_pool;
char *dns_dom;
DEBUG(_log_ldap_, "Looking for AD servers associated to DN %s.", dn);
apr_pool_create(&fn_pool, pool);
if (kdldap_DN_to_DNS(fn_pool, dn, &dns_dom) < 0)
KERROR_PUSH(_ldap_, 0, "failed to convert DN %s to DNS domain");
else {
/* Check on what domain the login attempt should be performed. */
DEBUG(_log_ldap_, "Looking for DC in domain %s.", dns_dom);
/* Find the DC. */
if (kdldap_ad_DNS_get_DC(self, lst_pool, dns_dom, srv_lst) < 0)
KERROR_PUSH(_ldap_, 0, "Failed to find a DC in %s", dns_dom);
else
err = 0;
}
if (err) {
apr_pool_destroy(lst_pool);
*srv_lst = NULL;
}
apr_pool_destroy(fn_pool);
return err;
}
else {
*srv_lst = apr_pmemdup(lst_pool, self->static_ldap_servers, sizeof(kdldap_servers_list));
return 0;
}
}
APR_DECLARE(apr_status_t) apr_file_setaside(apr_file_t **new_file,
apr_file_t *old_file,
apr_pool_t *p)
{
*new_file = (apr_file_t *)apr_pmemdup(p, old_file, sizeof(apr_file_t));
(*new_file)->pool = p;
if (old_file->buffered) {
(*new_file)->buffer = apr_palloc(p, old_file->bufsize);
(*new_file)->bufsize = old_file->bufsize;
if (old_file->direction == 1) {
memcpy((*new_file)->buffer, old_file->buffer, old_file->bufpos);
}
else {
memcpy((*new_file)->buffer, old_file->buffer, old_file->dataRead);
}
#if APR_HAS_THREADS
if (old_file->thlock) {
apr_thread_mutex_create(&((*new_file)->thlock),
APR_THREAD_MUTEX_DEFAULT, p);
apr_thread_mutex_destroy(old_file->thlock);
}
#endif /* APR_HAS_THREADS */
}
if (old_file->fname) {
(*new_file)->fname = apr_pstrdup(p, old_file->fname);
}
if (!(old_file->flags & APR_FOPEN_NOCLEANUP)) {
apr_pool_cleanup_register(p, (void *)(*new_file),
apr_unix_file_cleanup,
((*new_file)->flags & APR_INHERIT)
? apr_pool_cleanup_null
: apr_unix_child_file_cleanup);
}
old_file->filedes = -1;
apr_pool_cleanup_kill(old_file->pool, (void *)old_file,
apr_unix_file_cleanup);
#ifndef WAITIO_USES_POLL
(*new_file)->pollset = NULL;
#endif
return APR_SUCCESS;
}
/* This implements the `svn_ra_neon__startelem_cb_t' prototype. */
static svn_error_t *
gloc_start_element(int *elem, void *userdata, int parent_state,
const char *ns, const char *ln, const char **atts)
{
get_locations_baton_t *baton = userdata;
const svn_ra_neon__xml_elm_t *elm;
elm = svn_ra_neon__lookup_xml_elem(gloc_report_elements, ns, ln);
/* Just skip unknown elements. */
if (!elm)
{
*elem = NE_XML_DECLINE;
return SVN_NO_ERROR;
}
if (parent_state == ELEM_get_locations_report
&& elm->id == ELEM_location)
{
svn_revnum_t rev = SVN_INVALID_REVNUM;
const char *path;
const char *r;
r = svn_xml_get_attr_value("rev", atts);
if (r)
rev = SVN_STR_TO_REV(r);
path = svn_xml_get_attr_value("path", atts);
if (SVN_IS_VALID_REVNUM(rev) && path)
apr_hash_set(baton->hash,
apr_pmemdup(baton->pool, &rev, sizeof(rev)),
sizeof(rev), apr_pstrdup(baton->pool, path));
else
return svn_error_create(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
_("Expected a valid revnum and path"));
}
*elem = elm->id;
return SVN_NO_ERROR;
}
svn_client_info2_t *
svn_client_info2_dup(const svn_client_info2_t *info,
apr_pool_t *pool)
{
svn_client_info2_t *new_info = apr_pmemdup(pool, info, sizeof(*new_info));
if (new_info->URL)
new_info->URL = apr_pstrdup(pool, info->URL);
if (new_info->repos_root_URL)
new_info->repos_root_URL = apr_pstrdup(pool, info->repos_root_URL);
if (new_info->repos_UUID)
new_info->repos_UUID = apr_pstrdup(pool, info->repos_UUID);
if (info->last_changed_author)
new_info->last_changed_author = apr_pstrdup(pool, info->last_changed_author);
if (new_info->lock)
new_info->lock = svn_lock_dup(info->lock, pool);
if (new_info->wc_info)
new_info->wc_info = svn_wc_info_dup(info->wc_info, pool);
return new_info;
}
/**
* get_3des_vector:获取3des加密的明文向量，向量长度为8个字节
* @msr:上下文结构体
*
* 返回值：失败返回NULL，成功返回vector字符串
*/
unsigned char *get_3des_vector(apr_pool_t *pool, void *word)
{
unsigned char* vector;
if (pool == NULL) {
return NULL;
}
/*先取key产生器的第25位到第33位*/
vector = (unsigned char *)apr_pmemdup(pool, (void *)word + 24, 9);
if (vector == NULL) {
return NULL;
}
/*第9位设置字符串结束符，返回8个字节的向量*/
vector[8] = 0;
return vector;
}
APR_DECLARE(apr_status_t) apr_file_setaside(apr_file_t **new_file,
apr_file_t *old_file,
apr_pool_t *p)
{
*new_file = (apr_file_t *)apr_pmemdup(p, old_file, sizeof(apr_file_t));
(*new_file)->pool = p;
if (old_file->buffered) {
(*new_file)->buffer = apr_palloc(p, old_file->bufsize);
(*new_file)->bufsize = old_file->bufsize;
if (old_file->direction == 1) {
memcpy((*new_file)->buffer, old_file->buffer, old_file->bufpos);
}
else {
memcpy((*new_file)->buffer, old_file->buffer, old_file->dataRead);
}
if (old_file->mutex) {
apr_thread_mutex_create(&((*new_file)->mutex),
APR_THREAD_MUTEX_DEFAULT, p);
apr_thread_mutex_destroy(old_file->mutex);
}
}
if (old_file->fname) {
(*new_file)->fname = apr_pstrdup(p, old_file->fname);
}
if (!(old_file->flags & APR_FOPEN_NOCLEANUP)) {
apr_pool_cleanup_register(p, (void *)(*new_file),
apr_file_cleanup,
apr_file_cleanup);
}
old_file->filedes = -1;
apr_pool_cleanup_kill(old_file->pool, (void *)old_file,
apr_file_cleanup);
return APR_SUCCESS;
}
APR_DECLARE(apr_status_t) apr_file_setaside(apr_file_t **new_file,
apr_file_t *old_file,
apr_pool_t *p)
{
*new_file = (apr_file_t *)apr_pmemdup(p, old_file, sizeof(apr_file_t));
(*new_file)->pool = p;
if (old_file->buffered) {
(*new_file)->buffer = apr_palloc(p, old_file->bufsize);
(*new_file)->bufsize = old_file->bufsize;
if (old_file->direction == 1) {
memcpy((*new_file)->buffer, old_file->buffer, old_file->bufpos);
}
else {
memcpy((*new_file)->buffer, old_file->buffer, old_file->dataRead);
}
}
if (old_file->mutex) {
apr_thread_mutex_create(&((*new_file)->mutex),
APR_THREAD_MUTEX_DEFAULT, p);
apr_thread_mutex_destroy(old_file->mutex);
}
if (old_file->fname) {
(*new_file)->fname = apr_pstrdup(p, old_file->fname);
}
if (!(old_file->flags & APR_FOPEN_NOCLEANUP)) {
apr_pool_cleanup_register(p, (void *)(*new_file),
file_cleanup,
file_cleanup);
}
old_file->filehand = INVALID_HANDLE_VALUE;
apr_pool_cleanup_kill(old_file->pool, (void *)old_file,
file_cleanup);
#if APR_FILES_AS_SOCKETS
/* Create a pollset with room for one descriptor. */
/* ### check return codes */
(void) apr_pollset_create(&(*new_file)->pollset, 1, p, 0);
#endif
return APR_SUCCESS;
}
// string to addr_in
static const char* string_to_addr_in(apr_pool_t* p, const char* param, const char* port, addr_in_t* addr_in)
{
struct addrinfo hints, *result;
int r;
memset(&hints, 0, sizeof(hints));
hints.ai_flags = 0;
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = 0;
hints.ai_canonname = NULL;
hints.ai_addr = NULL;
hints.ai_next = NULL;
r = getaddrinfo(param, port, &hints, &result);
if(r!=0) return "getaddrinfo() failed.";
addr_in->addr = apr_pmemdup(p, result->ai_addr, result->ai_addrlen);
addr_in->len = result->ai_addrlen;
freeaddrinfo(result);
return NULL;
}
static svn_error_t *
start_getloc(svn_ra_serf__xml_parser_t *parser,
void *userData,
svn_ra_serf__dav_props_t name,
const char **attrs)
{
loc_context_t *loc_ctx = userData;
if (!loc_ctx->state && strcmp(name.name, "get-locations-report") == 0)
{
push_state(loc_ctx, REPORT);
}
else if (loc_ctx->state &&
loc_ctx->state->state == REPORT &&
strcmp(name.name, "location") == 0)
{
svn_revnum_t rev = SVN_INVALID_REVNUM;
const char *revstr, *path;
revstr = svn_xml_get_attr_value("rev", attrs);
if (revstr)
{
rev = SVN_STR_TO_REV(revstr);
}
path = svn_xml_get_attr_value("path", attrs);
if (SVN_IS_VALID_REVNUM(rev) && path)
{
apr_hash_set(loc_ctx->paths,
apr_pmemdup(loc_ctx->pool, &rev, sizeof(rev)),
sizeof(rev),
apr_pstrdup(loc_ctx->pool, path));
}
}
return SVN_NO_ERROR;
}
