static KWallet::Wallet *
get_wallet(QString wallet_name,
apr_hash_t *parameters)
{
KWallet::Wallet *wallet =
static_cast<KWallet::Wallet *> (svn_hash_gets(parameters,
"kwallet-wallet"));
if (! wallet && ! svn_hash_gets(parameters, "kwallet-opening-failed"))
{
wallet = KWallet::Wallet::openWallet(wallet_name, get_wid(),
KWallet::Wallet::Synchronous);
if (wallet)
{
svn_hash_sets(parameters, "kwallet-wallet", wallet);
apr_pool_cleanup_register(apr_hash_pool_get(parameters),
parameters, kwallet_terminate,
apr_pool_cleanup_null);
svn_hash_sets(parameters, "kwallet-initialized", "");
}
else
{
svn_hash_sets(parameters, "kwallet-opening-failed", "");
}
}
return wallet;
}
/* Store CDATA into REVPROPS, associated with PROPNAME. If ENCODING is not
NULL, then it must base "base64" and CDATA will be decoded first.
NOTE: PROPNAME must live longer than REVPROPS. */
static svn_error_t *
collect_revprop(apr_hash_t *revprops,
const char *propname,
const svn_string_t *cdata,
const char *encoding)
{
apr_pool_t *result_pool = apr_hash_pool_get(revprops);
const svn_string_t *decoded;
if (encoding)
{
/* Check for a known encoding type. This is easy -- there's
only one. */
if (strcmp(encoding, "base64") != 0)
{
return svn_error_createf(SVN_ERR_RA_DAV_MALFORMED_DATA, NULL,
_("Unsupported encoding '%s'"),
encoding);
}
decoded = svn_base64_decode_string(cdata, result_pool);
}
else
{
decoded = svn_string_dup(cdata, result_pool);
}
/* Caller has ensured PROPNAME has sufficient lifetime. */
apr_hash_set(revprops, propname, APR_HASH_KEY_STRING, decoded);
return SVN_NO_ERROR;
}
svn_error_t *
svn_ra_serf__blncache_set(svn_ra_serf__blncache_t *blncache,
const char *baseline_url,
svn_revnum_t revision,
const char *bc_url,
apr_pool_t *pool)
{
if (bc_url && SVN_IS_VALID_REVNUM(revision))
{
apr_pool_t *cache_pool = apr_hash_pool_get(blncache->revnum_to_bc);
/* If the caches are too big, delete and recreate 'em and move along. */
if (MAX_CACHE_SIZE < (apr_hash_count(blncache->baseline_info)
+ apr_hash_count(blncache->revnum_to_bc)))
{
svn_pool_clear(cache_pool);
blncache->revnum_to_bc = apr_hash_make(cache_pool);
blncache->baseline_info = apr_hash_make(cache_pool);
}
hash_set_copy(blncache->revnum_to_bc, &revision, sizeof(revision),
apr_pstrdup(cache_pool, bc_url));
if (baseline_url)
{
hash_set_copy(blncache->baseline_info, baseline_url,
APR_HASH_KEY_STRING,
baseline_info_make(bc_url, revision, cache_pool));
}
}
return SVN_NO_ERROR;
}
/*
* Implementation of svn_ra_serf__prop_func_t that delivers all DAV properties
* in (const char * -> apr_hash_t *) on Namespace pointing to a second hash
* (const char * -> svn_string_t *) to the values.
*/
static svn_error_t *
deliver_node_props(void *baton,
const char *path,
const char *ns,
const char *name,
const svn_string_t *value,
apr_pool_t *scratch_pool)
{
apr_hash_t *nss = baton;
apr_hash_t *props;
apr_pool_t *result_pool = apr_hash_pool_get(nss);
props = svn_hash_gets(nss, ns);
if (!props)
{
props = apr_hash_make(result_pool);
ns = apr_pstrdup(result_pool, ns);
svn_hash_sets(nss, ns, props);
}
name = apr_pstrdup(result_pool, name);
svn_hash_sets(props, name, svn_string_dup(value, result_pool));
return SVN_NO_ERROR;
}
void
svn_dbg__print_props(apr_hash_t *props,
const char *header_fmt,
...)
{
/* We only build this code if SVN_DEBUG is defined. */
#ifdef SVN_DEBUG
apr_hash_index_t *hi;
va_list ap;
va_start(ap, header_fmt);
debug_vprintf(header_fmt, ap);
va_end(ap);
if (props == NULL)
{
svn_dbg__printf(" (null)\n");
return;
}
for (hi = apr_hash_first(apr_hash_pool_get(props), props); hi;
hi = apr_hash_next(hi))
{
const char *name = svn__apr_hash_index_key(hi);
svn_string_t *val = svn__apr_hash_index_val(hi);
svn_dbg__printf(" '%s' -> '%s'\n", name, val->data);
}
#endif /* SVN_DEBUG */
}
APR_DECLARE(apr_status_t) apr_dbd_get_driver(apr_pool_t *pool, const char *name,
const apr_dbd_driver_t **driver)
{
#if APR_HAVE_MODULAR_DSO
char modname[32];
char symname[34];
apr_dso_handle_sym_t symbol;
#endif
apr_status_t rv;
#if APR_HAVE_MODULAR_DSO
rv = apu_dso_mutex_lock();
if (rv) {
return rv;
}
#endif
*driver = apr_hash_get(drivers, name, APR_HASH_KEY_STRING);
if (*driver) {
#if APR_HAVE_MODULAR_DSO
apu_dso_mutex_unlock();
#endif
return APR_SUCCESS;
}
#if APR_HAVE_MODULAR_DSO
/* The driver DSO must have exactly the same lifetime as the
* drivers hash table; ignore the passed-in pool */
pool = apr_hash_pool_get(drivers);
#if defined(NETWARE)
apr_snprintf(modname, sizeof(modname), "dbd%s.nlm", name);
#elif defined(WIN32)
apr_snprintf(modname, sizeof(modname),
"apr_dbd_%s-" APR_STRINGIFY(APR_MAJOR_VERSION) ".dll", name);
#else
apr_snprintf(modname, sizeof(modname),
"apr_dbd_%s-" APR_STRINGIFY(APR_MAJOR_VERSION) ".so", name);
#endif
apr_snprintf(symname, sizeof(symname), "apr_dbd_%s_driver", name);
rv = apu_dso_load(NULL, &symbol, modname, symname, pool);
if (rv == APR_SUCCESS || rv == APR_EINIT) { /* previously loaded?!? */
*driver = symbol;
name = apr_pstrdup(pool, name);
apr_hash_set(drivers, name, APR_HASH_KEY_STRING, *driver);
rv = APR_SUCCESS;
if ((*driver)->init) {
(*driver)->init(pool);
}
}
apu_dso_mutex_unlock();
#else /* not builtin and !APR_HAS_DSO => not implemented */
rv = APR_ENOTIMPL;
#endif
return rv;
}
/* Recursively obfuscate path components */
const char *session_obfuscate_rec(apr_pool_t *pool, apr_hash_t *hash, apr_hash_t *taken, const char *path)
{
const char *obf = NULL, *dir, *base;
utils_path_split(pool, path, &dir, &base);
if (strcmp(dir, "/") && strlen(dir)) {
dir = session_obfuscate_rec(pool, hash, taken, dir);
}
if (strlen(base) == 0) {
return apr_pstrdup(pool, "");;
}
if ((obf = apr_hash_get(hash, base, APR_HASH_KEY_STRING)) == NULL) {
obf = session_make_obfuscated(apr_hash_pool_get(hash), taken);
apr_hash_set(hash, apr_pstrdup(apr_hash_pool_get(hash), base), APR_HASH_KEY_STRING, obf);
}
return (strlen(dir) ? utils_path_join(pool, dir, obf) : obf);
}
/* 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);
}
/* Record the mapping of FROM_REV to TO_REV in REV_MAP, ensuring that
anything added to the hash is allocated in the hash's pool. */
static void
set_revision_mapping(apr_hash_t *rev_map,
svn_revnum_t from_rev,
svn_revnum_t to_rev)
{
svn_revnum_t *mapped_revs = apr_palloc(apr_hash_pool_get(rev_map),
sizeof(svn_revnum_t) * 2);
mapped_revs[0] = from_rev;
mapped_revs[1] = to_rev;
apr_hash_set(rev_map, mapped_revs,
sizeof(svn_revnum_t), mapped_revs + 1);
}
static void extract_segments_exec(gpmon_packet_t* pkt)
{
gpmon_qexec_t *p;
gp_smon_to_mmon_packet_t *rec;
gpmon_query_seginfo_key_t qseg_key;
pidrec_t *pidrec;
if (pkt->pkttype != GPMON_PKTTYPE_QEXEC)
gpsmon_fatal(FLINE, "assert failed; expected pkttype qexec");
p = &pkt->u.qexec;
qseg_key.qkey.tmid = p->key.tmid;
qseg_key.qkey.ssid = p->key.ssid;
qseg_key.qkey.ccnt = p->key.ccnt;
qseg_key.segid = p->key.hash_key.segid;
rec = apr_hash_get(gx.querysegtab, &qseg_key, sizeof(qseg_key));
pidrec = apr_hash_get(gx.pidtab, &p->key.hash_key.pid, sizeof(p->key.hash_key.pid));
ASSERT(pidrec);
if (rec)
{
rec->u.queryseg.sum_cpu_elapsed += pidrec->cpu_elapsed;
rec->u.queryseg.sum_measures_rows_in += p->rowsin;
if (p->key.hash_key.segid == -1 && p->key.hash_key.nid == 1)
{
rec->u.queryseg.final_rowsout = p->rowsout;
}
}
else
{
rec = apr_palloc(apr_hash_pool_get(gx.querysegtab),
sizeof(gp_smon_to_mmon_packet_t));
CHECKMEM(rec);
gp_smon_to_mmon_set_header(rec, GPMON_PKTTYPE_QUERYSEG);
rec->u.queryseg.key = qseg_key;
if (p->key.hash_key.segid == -1 && p->key.hash_key.nid == 1)
{
rec->u.queryseg.final_rowsout = p->rowsout;
}
else
{
rec->u.queryseg.final_rowsout = -1;
}
rec->u.queryseg.sum_cpu_elapsed = pidrec->cpu_elapsed;
rec->u.queryseg.sum_measures_rows_in = p->rowsin;
apr_hash_set(gx.querysegtab, &rec->u.queryseg.key, sizeof(rec->u.queryseg.key), rec);
}
}
/* A conflict callback that simply records the conflicted path in BATON.
Implements svn_wc_conflict_resolver_func2_t.
*/
static svn_error_t *
record_conflict(svn_wc_conflict_result_t **result,
const svn_wc_conflict_description2_t *description,
void *baton,
apr_pool_t *result_pool,
apr_pool_t *scratch_pool)
{
apr_hash_t *conflicted_paths = baton;
svn_hash_sets(conflicted_paths,
apr_pstrdup(apr_hash_pool_get(conflicted_paths),
description->local_abspath), "");
*result = svn_wc_create_conflict_result(svn_wc_conflict_choose_postpone,
NULL, result_pool);
return SVN_NO_ERROR;
}
/* Record ACTION on the path in CDATA into PATHS. Other properties about
the action are pulled from ATTRS. */
static svn_error_t *
collect_path(apr_hash_t *paths,
char action,
const svn_string_t *cdata,
apr_hash_t *attrs)
{
apr_pool_t *result_pool = apr_hash_pool_get(paths);
svn_log_changed_path2_t *lcp;
const char *copyfrom_path;
const char *copyfrom_rev;
const char *path;
lcp = svn_log_changed_path2_create(result_pool);
lcp->action = action;
lcp->copyfrom_rev = SVN_INVALID_REVNUM;
/* COPYFROM_* are only recorded for ADDED_PATH and REPLACED_PATH. */
copyfrom_path = apr_hash_get(attrs, "copyfrom-path", APR_HASH_KEY_STRING);
copyfrom_rev = apr_hash_get(attrs, "copyfrom-rev", APR_HASH_KEY_STRING);
if (copyfrom_path && copyfrom_rev)
{
svn_revnum_t rev = SVN_STR_TO_REV(copyfrom_rev);
if (SVN_IS_VALID_REVNUM(rev))
{
lcp->copyfrom_path = apr_pstrdup(result_pool, copyfrom_path);
lcp->copyfrom_rev = rev;
}
}
lcp->node_kind = svn_node_kind_from_word(apr_hash_get(
attrs, "node-kind",
APR_HASH_KEY_STRING));
lcp->text_modified = svn_tristate__from_word(apr_hash_get(
attrs, "text-mods",
APR_HASH_KEY_STRING));
lcp->props_modified = svn_tristate__from_word(apr_hash_get(
attrs, "prop-mods",
APR_HASH_KEY_STRING));
path = apr_pstrmemdup(result_pool, cdata->data, cdata->len);
apr_hash_set(paths, path, APR_HASH_KEY_STRING, lcp);
return SVN_NO_ERROR;
}
/* Add EXTERNALS_PROP_VAL for the export destination path PATH to
TRAVERSAL_INFO. */
static svn_error_t *
add_externals(apr_hash_t *externals,
const char *path,
const svn_string_t *externals_prop_val)
{
apr_pool_t *pool = apr_hash_pool_get(externals);
const char *local_abspath;
if (! externals_prop_val)
return SVN_NO_ERROR;
SVN_ERR(svn_dirent_get_absolute(&local_abspath, path, pool));
apr_hash_set(externals, local_abspath, APR_HASH_KEY_STRING,
apr_pstrmemdup(pool, externals_prop_val->data,
externals_prop_val->len));
return SVN_NO_ERROR;
}
svn_error_t *
svn_ra_serf__deliver_svn_props(void *baton,
const char *path,
const char *ns,
const char *name,
const svn_string_t *value,
apr_pool_t *scratch_pool)
{
apr_hash_t *props = baton;
apr_pool_t *result_pool = apr_hash_pool_get(props);
const char *prop_name;
prop_name = svn_ra_serf__svnname_from_wirename(ns, name, result_pool);
if (prop_name == NULL)
return SVN_NO_ERROR;
svn_hash_sets(props, prop_name, svn_string_dup(value, result_pool));
return SVN_NO_ERROR;
}
/* An implementation of svn_config_enumerator2_t.
* Set environment variable NAME to value VALUE in the environment for
* all hooks (in case the current section is the default section),
* or the hook with the name corresponding to the current section's name. */
static svn_boolean_t
parse_hooks_env_option(const char *name, const char *value,
void *baton, apr_pool_t *pool)
{
struct parse_hooks_env_option_baton *bo = baton;
apr_pool_t *result_pool = apr_hash_pool_get(bo->hooks_env);
apr_hash_t *hook_env;
hook_env = svn_hash_gets(bo->hooks_env, bo->section);
if (hook_env == NULL)
{
hook_env = apr_hash_make(result_pool);
svn_hash_sets(bo->hooks_env, apr_pstrdup(result_pool, bo->section),
hook_env);
}
svn_hash_sets(hook_env, apr_pstrdup(result_pool, name),
apr_pstrdup(result_pool, value));
return TRUE;
}
/* This implements the svn_fs_get_locks_callback_t interface. */
static svn_error_t *
get_locks_callback(void *baton,
svn_lock_t *lock,
apr_pool_t *pool)
{
struct get_locks_baton_t *b = baton;
svn_boolean_t readable = TRUE;
apr_pool_t *hash_pool = apr_hash_pool_get(b->locks);
/* If there's auth to deal with, deal with it. */
if (b->authz_read_func)
SVN_ERR(b->authz_read_func(&readable, b->head_root, lock->path,
b->authz_read_baton, pool));
/* If we can read this lock path, add the lock to the return hash. */
if (readable)
svn_hash_sets(b->locks, apr_pstrdup(hash_pool, lock->path),
svn_lock_dup(lock, hash_pool));
return SVN_NO_ERROR;
}
/* got a packet from peer. put it in the queue */
static void gx_recvqlog(gpmon_packet_t* pkt)
{
gpmon_qlog_t* p;
gp_smon_to_mmon_packet_t* rec;
if (pkt->pkttype != GPMON_PKTTYPE_QLOG)
gpsmon_fatal(FLINE, "assert failed; expected pkttype qlog");
p = &pkt->u.qlog;
TR2(("Received qlog packet for query %d-%d-%d. Status now %d\n", p->key.tmid, p->key.ssid, p->key.ccnt, p->status));
rec = apr_hash_get(gx.qlogtab, &p->key, sizeof(p->key));
if (rec)
{
memcpy(&rec->u.qlog, p, sizeof(*p));
}
else
{
rec = gx_pkt_to_smon_to_mmon(apr_hash_pool_get(gx.qlogtab), pkt);
apr_hash_set(gx.qlogtab, &rec->u.qlog.key, sizeof(rec->u.qlog.key), rec);
}
}
static void gx_recvsegment(gpmon_packet_t* pkt)
{
gpmon_seginfo_t* p;
gp_smon_to_mmon_packet_t* rec;
if (pkt->pkttype != GPMON_PKTTYPE_SEGINFO)
gpsmon_fatal(FLINE, "assert failed; expected pkttype segment");
p = &pkt->u.seginfo;
TR2(("Received segment packet for dbid %d (dynamic_memory_used, dynamic_memory_available) (%llu %llu)\n", p->dbid, p->dynamic_memory_used, p->dynamic_memory_available));
rec = apr_hash_get(gx.segmenttab, &p->dbid, sizeof(p->dbid));
if (rec)
{
memcpy(&rec->u.seginfo, p, sizeof(*p));
}
else
{
rec = gx_pkt_to_smon_to_mmon(apr_hash_pool_get(gx.segmenttab), pkt);
apr_hash_set(gx.segmenttab, &rec->u.seginfo.dbid, sizeof(rec->u.seginfo.dbid), rec);
}
}
/* Conforms to svn_ra_serf__xml_closed_t */
static svn_error_t *
log_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)
{
log_context_t *log_ctx = baton;
if (leaving_state == ITEM)
{
svn_log_entry_t *log_entry;
const char *rev_str;
if (log_ctx->limit && (log_ctx->nest_level == 0)
&& (++log_ctx->count > log_ctx->limit))
{
return SVN_NO_ERROR;
}
log_entry = svn_log_entry_create(scratch_pool);
/* Pick up the paths from the context. These have the same lifetime
as this state. That is long enough for us to pass the paths to
the receiver callback. */
if (apr_hash_count(log_ctx->collect_paths) > 0)
{
log_entry->changed_paths = log_ctx->collect_paths;
log_entry->changed_paths2 = log_ctx->collect_paths;
}
/* ... and same story for the collected revprops. */
log_entry->revprops = log_ctx->collect_revprops;
log_entry->has_children = svn_hash__get_bool(attrs,
"has-children",
FALSE);
log_entry->subtractive_merge = svn_hash__get_bool(attrs,
"subtractive-merge",
FALSE);
rev_str = apr_hash_get(attrs, "revision", APR_HASH_KEY_STRING);
if (rev_str)
log_entry->revision = SVN_STR_TO_REV(rev_str);
else
log_entry->revision = SVN_INVALID_REVNUM;
/* Give the info to the reporter */
SVN_ERR(log_ctx->receiver(log_ctx->receiver_baton,
log_entry,
scratch_pool));
if (log_entry->has_children)
{
log_ctx->nest_level++;
}
if (! SVN_IS_VALID_REVNUM(log_entry->revision))
{
SVN_ERR_ASSERT(log_ctx->nest_level);
log_ctx->nest_level--;
}
/* These hash tables are going to be unusable once this state's
pool is destroyed. But let's not leave stale pointers in
structures that have a longer life. */
log_ctx->collect_revprops = NULL;
log_ctx->collect_paths = NULL;
}
else if (leaving_state == VERSION)
{
svn_ra_serf__xml_note(xes, ITEM, "revision", cdata->data);
}
else if (leaving_state == CREATOR)
{
if (log_ctx->want_author)
{
SVN_ERR(collect_revprop(log_ctx->collect_revprops,
SVN_PROP_REVISION_AUTHOR,
cdata,
apr_hash_get(attrs, "encoding",
APR_HASH_KEY_STRING)));
}
}
else if (leaving_state == DATE)
{
if (log_ctx->want_date)
{
SVN_ERR(collect_revprop(log_ctx->collect_revprops,
SVN_PROP_REVISION_DATE,
cdata,
apr_hash_get(attrs, "encoding",
APR_HASH_KEY_STRING)));
}
}
else if (leaving_state == COMMENT)
{
if (log_ctx->want_message)
{
SVN_ERR(collect_revprop(log_ctx->collect_revprops,
SVN_PROP_REVISION_LOG,
cdata,
apr_hash_get(attrs, "encoding",
APR_HASH_KEY_STRING)));
}
}
else if (leaving_state == REVPROP)
{
apr_pool_t *result_pool = apr_hash_pool_get(log_ctx->collect_revprops);
SVN_ERR(collect_revprop(
log_ctx->collect_revprops,
apr_pstrdup(result_pool,
apr_hash_get(attrs, "name", APR_HASH_KEY_STRING)),
cdata,
apr_hash_get(attrs, "encoding", APR_HASH_KEY_STRING)
));
}
else if (leaving_state == HAS_CHILDREN)
{
svn_ra_serf__xml_note(xes, ITEM, "has-children", "yes");
}
else if (leaving_state == SUBTRACTIVE_MERGE)
{
svn_ra_serf__xml_note(xes, ITEM, "subtractive-merge", "yes");
}
else
{
char action;
if (leaving_state == ADDED_PATH)
action = 'A';
else if (leaving_state == REPLACED_PATH)
action = 'R';
else if (leaving_state == DELETED_PATH)
action = 'D';
else
{
SVN_ERR_ASSERT(leaving_state == MODIFIED_PATH);
action = 'M';
}
SVN_ERR(collect_path(log_ctx->collect_paths, action, cdata, attrs));
}
return SVN_NO_ERROR;
}
static void gx_gettcpcmd(SOCKET sock, short event, void* arg)
{
char dump;
int n, e;
apr_pool_t* oldpool;
apr_hash_t* qetab;
apr_hash_t* qdtab;
apr_hash_t* pidtab;
apr_hash_t* segtab;
if (event & EV_TIMEOUT) // didn't get command from gpmmon, quit
{
if(gx.tcp_sock)
{
close(gx.tcp_sock);
gx.tcp_sock=0;
}
return;
}
apr_hash_t* querysegtab;
n = recv(sock, &dump, 1, 0);
if (n == 0)
gx_exit("peer closed");
if (n == -1)
gx_exit("socket error");
if (dump != 'D')
gx_exit("bad data");
TR1(("start dump %c\n", dump));
qetab = gx.qexectab;
qdtab = gx.qlogtab;
pidtab = gx.pidtab;
segtab = gx.segmenttab;
querysegtab = gx.querysegtab;
oldpool = apr_hash_pool_get(qetab);
/* make new hashtabs for next cycle */
{
apr_pool_t* newpool;
if (0 != (e = apr_pool_create_alloc(&newpool, gx.pool)))
{
gpsmon_fatalx(FLINE, e, "apr_pool_create_alloc failed");
}
/* qexec hash table */
gx.qexectab = apr_hash_make(newpool);
CHECKMEM(gx.qexectab);
/* qlog hash table */
gx.qlogtab = apr_hash_make(newpool);
CHECKMEM(gx.qlogtab);
/* segment hash table */
gx.segmenttab = apr_hash_make(newpool);
CHECKMEM(gx.segmenttab);
/* queryseg hash table */
gx.querysegtab = apr_hash_make(newpool);
CHECKMEM(gx.querysegtab);
/* pidtab hash table */
gx.pidtab = apr_hash_make(newpool);
CHECKMEM(gx.pidtab);
}
/* push out a metric of the machine */
send_machine_metrics(sock);
send_fsinfo(sock);
/* push out records */
{
apr_hash_index_t* hi;
gp_smon_to_mmon_packet_t* ppkt = 0;
gp_smon_to_mmon_packet_t localPacketObject;
pidrec_t* pidrec;
int count = 0;
apr_hash_t* query_cpu_table = NULL;
for (hi = apr_hash_first(0, querysegtab); hi; hi = apr_hash_next(hi))
{
void* vptr;
apr_hash_this(hi, 0, 0, &vptr);
ppkt = vptr;
if (ppkt->header.pkttype != GPMON_PKTTYPE_QUERYSEG)
continue;
TR2(("sending magic %x, pkttype %d\n", ppkt->header.magic, ppkt->header.pkttype));
send_smon_to_mon_pkt(sock, ppkt);
count++;
}
for (hi = apr_hash_first(0, segtab); hi; hi = apr_hash_next(hi))
{
void* vptr;
apr_hash_this(hi, 0, 0, &vptr);
ppkt = vptr;
if (ppkt->header.pkttype != GPMON_PKTTYPE_SEGINFO)
continue;
/* fill in hostname */
strncpy(ppkt->u.seginfo.hostname, gx.hostname, sizeof(ppkt->u.seginfo.hostname) - 1);
ppkt->u.seginfo.hostname[sizeof(ppkt->u.seginfo.hostname) - 1] = 0;
TR2(("sending magic %x, pkttype %d\n", ppkt->header.magic, ppkt->header.pkttype));
send_smon_to_mon_pkt(sock, ppkt);
count++;
}
for (hi = apr_hash_first(0, qdtab); hi; hi = apr_hash_next(hi))
{
void* vptr;
apr_hash_this(hi, 0, 0, &vptr);
ppkt = vptr;
if (ppkt->header.pkttype != GPMON_PKTTYPE_QLOG)
continue;
TR2(("sending magic %x, pkttype %d\n", ppkt->header.magic, ppkt->header.pkttype));
send_smon_to_mon_pkt(sock, ppkt);
count++;
}
for (hi = apr_hash_first(0, qetab); hi; hi = apr_hash_next(hi))
{
gpmon_qexec_t* qexec;
void *vptr;
apr_hash_this(hi, 0, 0, &vptr);
qexec = vptr;
/* fill in _p_metrics */
pidrec = apr_hash_get(pidtab, &qexec->key.hash_key.pid, sizeof(qexec->key.hash_key.pid));
if (pidrec) {
qexec->_p_metrics = pidrec->p_metrics;
qexec->_cpu_elapsed = pidrec->cpu_elapsed;
} else {
memset(&qexec->_p_metrics, 0, sizeof(qexec->_p_metrics));
}
/* fill in _hname */
strncpy(qexec->_hname, gx.hostname, sizeof(qexec->_hname) - 1);
qexec->_hname[sizeof(qexec->_hname) - 1] = 0;
if (0 == create_qexec_packet(qexec, &localPacketObject)) {
break;
}
TR2(("sending qexec, pkttype %d\n", localPacketObject.header.pkttype));
send_smon_to_mon_pkt(sock, &localPacketObject);
count++;
}
// calculate CPU utilization per query for this machine
query_cpu_table = apr_hash_make(oldpool);
CHECKMEM(query_cpu_table);
// loop through PID's and add to Query CPU Hash Table
for (hi = apr_hash_first(0, pidtab); hi; hi = apr_hash_next(hi))
{
void* vptr;
pidrec_t* lookup;
apr_hash_this(hi, 0, 0, &vptr);
pidrec = vptr;
TR2(("tmid %d ssid %d ccnt %d pid %d (CPU elapsed %d CPU Percent %.2f)\n",
pidrec->query_key.tmid, pidrec->query_key.ssid, pidrec->query_key.ccnt, pidrec->pid,
pidrec->cpu_elapsed, pidrec->p_metrics.cpu_pct));
// table is keyed on query key
lookup = apr_hash_get(query_cpu_table, &pidrec->query_key, sizeof(pidrec->query_key));
if (lookup)
{
// found other pids with same query key so add the metrics to that
lookup->cpu_elapsed += pidrec->cpu_elapsed;
lookup->p_metrics.cpu_pct += pidrec->p_metrics.cpu_pct;
}
else
{
// insert existing pid record into table keyed by query key
apr_hash_set(query_cpu_table, &pidrec->query_key, sizeof(pidrec->query_key), pidrec);
}
}
// reset packet to 0
ppkt = &localPacketObject;
memset(ppkt, 0, sizeof(gp_smon_to_mmon_packet_t));
gp_smon_to_mmon_set_header(ppkt,GPMON_PKTTYPE_QUERY_HOST_METRICS);
// add the hostname into the packet for DEBUGGING purposes only. This is not used
strncpy(ppkt->u.qlog.user, gx.hostname, sizeof(ppkt->u.qlog.user) - 1);
ppkt->u.qlog.user[sizeof(ppkt->u.qlog.user) - 1] = 0;
// loop through the query per cpu table and send the metrics
for (hi = apr_hash_first(0, query_cpu_table); hi; hi = apr_hash_next(hi))
{
void* vptr;
apr_hash_this(hi, 0, 0, &vptr);
pidrec = vptr;
ppkt->u.qlog.key.tmid = pidrec->query_key.tmid;
ppkt->u.qlog.key.ssid = pidrec->query_key.ssid;
ppkt->u.qlog.key.ccnt = pidrec->query_key.ccnt;
ppkt->u.qlog.cpu_elapsed = pidrec->cpu_elapsed;
ppkt->u.qlog.p_metrics.cpu_pct = pidrec->p_metrics.cpu_pct;
TR2(("SEND tmid %d ssid %d ccnt %d (CPU elapsed %d CPU Percent %.2f)\n",
ppkt->u.qlog.key.tmid, ppkt->u.qlog.key.ssid, ppkt->u.qlog.key.ccnt,
ppkt->u.qlog.cpu_elapsed, ppkt->u.qlog.p_metrics.cpu_pct));
send_smon_to_mon_pkt(sock, ppkt);
count++;
}
TR1(("end dump ... sent %d entries\n", count));
}
/* get rid of the old pool */
{
apr_pool_destroy(oldpool);
}
struct timeval tv;
tv.tv_sec = opt.terminate_timeout;
tv.tv_usec = 0;
if (event_add(&gx.tcp_event, &tv)) //reset timeout
{
gpmon_warningx(FLINE, APR_FROM_OS_ERROR(errno), "event_add failed");
}
return;
}
static void get_pid_metrics(apr_int32_t pid, apr_int32_t tmid, apr_int32_t ssid, apr_int32_t ccnt)
{
apr_int32_t status;
sigar_proc_cpu_t cpu;
sigar_proc_mem_t mem;
sigar_proc_fd_t fd;
pidrec_t* rec;
apr_pool_t* pool = apr_hash_pool_get(gx.pidtab);
rec = apr_hash_get(gx.pidtab, &pid, sizeof(pid));
if (rec && rec->updated_tick == gx.tick)
return; /* updated in current cycle */
memset(&cpu, 0, sizeof(cpu));
memset(&mem, 0, sizeof(mem));
memset(&fd, 0, sizeof(fd));
TR2(("--------------------- starting %d\n", pid));
if (!rec)
{
sigar_proc_exe_t exe;
/* There might be cases where the pid no longer exist, so we'll just
* zero out the memory first before doing anything */
rec = apr_pcalloc(pool, sizeof(*rec));
CHECKMEM(rec);
rec->pid = pid;
rec->query_key.tmid = tmid;
rec->query_key.ssid = ssid;
rec->query_key.ccnt = ccnt;
rec->pname = rec->cwd = 0;
if (0 == sigar_proc_exe_get(gx.sigar, pid, &exe))
{
rec->pname = apr_pstrdup(pool, exe.name);
rec->cwd = apr_pstrdup(pool, exe.root);
}
if (!rec->pname)
rec->pname = "unknown";
if (!rec->cwd)
rec->cwd = "unknown";
apr_hash_set(gx.pidtab, &rec->pid, sizeof(rec->pid), rec);
}
status = sigar_proc_mem_get(gx.sigar, pid, &mem);
/* ESRCH is error 3: (No such process) */
if (status != SIGAR_OK)
{
if (status != ESRCH) {
TR2(("[WARNING] %s. PID: %d\n", sigar_strerror(gx.sigar, status), pid));
}
return;
}
status = sigar_proc_cpu_get(gx.sigar, pid, &cpu);
if (status != SIGAR_OK)
{
if (status != ESRCH) {
TR2(("[WARNING] %s. PID: %d\n", sigar_strerror(gx.sigar, status), pid));
}
return;
}
status = sigar_proc_fd_get(gx.sigar, pid, &fd);
if (status != SIGAR_OK)
{
if (status != ESRCH) {
TR2(("[WARNING] %s. PID: %d\n", sigar_strerror(gx.sigar, status), pid));
}
return;
}
rec->updated_tick = gx.tick;
rec->p_metrics.fd_cnt = (apr_uint32_t) fd.total;
rec->p_metrics.cpu_pct = (float) (cpu.percent * cpu_cores_utilization_multiplier);
rec->p_metrics.mem.size = mem.size;
rec->p_metrics.mem.resident = mem.resident;
#ifdef __linux__
rec->p_metrics.mem.share = mem.share;
#else
rec->p_metrics.mem.share = 0;
#endif
rec->cpu_elapsed = cpu.total;
}
/* Implements svn_log_entry_receiver_t; helper for slow_get_locations.
As input, takes log_receiver_baton (defined above) and attempts to
"fill in" locations in the baton over the course of many
iterations. */
static svn_error_t *
log_receiver(void *baton,
svn_log_entry_t *log_entry,
apr_pool_t *pool)
{
struct log_receiver_baton *lrb = baton;
apr_pool_t *hash_pool = apr_hash_pool_get(lrb->locations);
const char *current_path = lrb->last_path;
const char *prev_path;
/* No paths were changed in this revision. Nothing to do. */
if (! log_entry->changed_paths2)
return SVN_NO_ERROR;
/* If we've run off the end of the path's history, there's nothing
to do. (This should never happen with a properly functioning
server, since we'd get no more log messages after the one where
path was created. But a malfunctioning server shouldn't cause us
to trigger an assertion failure.) */
if (! current_path)
return SVN_NO_ERROR;
/* If we haven't found our peg path yet, and we are now looking at a
revision equal to or older than the peg revision, then our
"current" path is our peg path. */
if ((! lrb->peg_path) && (log_entry->revision <= lrb->peg_revision))
lrb->peg_path = apr_pstrdup(lrb->pool, current_path);
/* Determine the paths for any of the revisions for which we haven't
gotten paths already. */
while (lrb->location_revisions->nelts)
{
svn_revnum_t next = APR_ARRAY_IDX(lrb->location_revisions,
lrb->location_revisions->nelts - 1,
svn_revnum_t);
if (log_entry->revision <= next)
{
apr_hash_set(lrb->locations,
apr_pmemdup(hash_pool, &next, sizeof(next)),
sizeof(next),
apr_pstrdup(hash_pool, current_path));
apr_array_pop(lrb->location_revisions);
}
else
break;
}
/* Figure out at which repository path our object of interest lived
in the previous revision. */
SVN_ERR(prev_log_path(&prev_path, NULL, NULL, log_entry->changed_paths2,
current_path, lrb->kind, log_entry->revision, pool));
/* Squirrel away our "next place to look" path (suffer the strcmp
hit to save on allocations). */
if (! prev_path)
lrb->last_path = NULL;
else if (strcmp(prev_path, current_path) != 0)
lrb->last_path = apr_pstrdup(lrb->pool, prev_path);
return SVN_NO_ERROR;
}
/* Merge the internal-use-only CHANGE into a hash of public-FS
svn_fs_path_change2_t CHANGES, collapsing multiple changes into a
single succinct change per path. */
static svn_error_t *
fold_change(apr_hash_t *changes,
const change_t *change)
{
apr_pool_t *pool = apr_hash_pool_get(changes);
svn_fs_path_change2_t *old_change, *new_change;
const char *path;
if ((old_change = svn_hash_gets(changes, change->path)))
{
/* This path already exists in the hash, so we have to merge
this change into the already existing one. */
/* Since the path already exists in the hash, we don't have to
dup the allocation for the path itself. */
path = change->path;
/* Sanity check: only allow NULL node revision ID in the
`reset' case. */
if ((! change->noderev_id) && (change->kind != svn_fs_path_change_reset))
return svn_error_create
(SVN_ERR_FS_CORRUPT, NULL,
_("Missing required node revision ID"));
/* Sanity check: we should be talking about the same node
revision ID as our last change except where the last change
was a deletion. */
if (change->noderev_id
&& (! svn_fs_base__id_eq(old_change->node_rev_id,
change->noderev_id))
&& (old_change->change_kind != svn_fs_path_change_delete))
return svn_error_create
(SVN_ERR_FS_CORRUPT, NULL,
_("Invalid change ordering: new node revision ID without delete"));
/* Sanity check: an add, replacement, or reset must be the first
thing to follow a deletion. */
if ((old_change->change_kind == svn_fs_path_change_delete)
&& (! ((change->kind == svn_fs_path_change_replace)
|| (change->kind == svn_fs_path_change_reset)
|| (change->kind == svn_fs_path_change_add))))
return svn_error_create
(SVN_ERR_FS_CORRUPT, NULL,
_("Invalid change ordering: non-add change on deleted path"));
/* Sanity check: an add can't follow anything except
a delete or reset. */
if ((change->kind == svn_fs_path_change_add)
&& (old_change->change_kind != svn_fs_path_change_delete)
&& (old_change->change_kind != svn_fs_path_change_reset))
return svn_error_create
(SVN_ERR_FS_CORRUPT, NULL,
_("Invalid change ordering: add change on preexisting path"));
/* Now, merge that change in. */
switch (change->kind)
{
case svn_fs_path_change_reset:
/* A reset here will simply remove the path change from the
hash. */
old_change = NULL;
break;
case svn_fs_path_change_delete:
if (old_change->change_kind == svn_fs_path_change_add)
{
/* If the path was introduced in this transaction via an
add, and we are deleting it, just remove the path
altogether. */
old_change = NULL;
}
else
{
/* A deletion overrules all previous changes. */
old_change->change_kind = svn_fs_path_change_delete;
old_change->text_mod = change->text_mod;
old_change->prop_mod = change->prop_mod;
}
break;
case svn_fs_path_change_add:
case svn_fs_path_change_replace:
/* An add at this point must be following a previous delete,
so treat it just like a replace. */
old_change->change_kind = svn_fs_path_change_replace;
old_change->node_rev_id = svn_fs_base__id_copy(change->noderev_id,
pool);
old_change->text_mod = change->text_mod;
old_change->prop_mod = change->prop_mod;
break;
case svn_fs_path_change_modify:
default:
if (change->text_mod)
old_change->text_mod = TRUE;
if (change->prop_mod)
old_change->prop_mod = TRUE;
break;
}
/* Point our new_change to our (possibly modified) old_change. */
new_change = old_change;
}
else
{
/* This change is new to the hash, so make a new public change
structure from the internal one (in the hash's pool), and dup
the path into the hash's pool, too. */
new_change = svn_fs__path_change_create_internal(
svn_fs_base__id_copy(change->noderev_id, pool),
change->kind,
pool);
new_change->text_mod = change->text_mod;
new_change->prop_mod = change->prop_mod;
new_change->node_kind = svn_node_unknown;
new_change->copyfrom_known = FALSE;
path = apr_pstrdup(pool, change->path);
}
/* Add (or update) this path. */
svn_hash_sets(changes, path, new_change);
return SVN_NO_ERROR;
}
svn_error_t *
svn_auth__ssl_client_cert_pw_cache_set(svn_boolean_t *saved,
void *credentials,
void *provider_baton,
apr_hash_t *parameters,
const char *realmstring,
svn_auth__password_set_t passphrase_set,
const char *passtype,
apr_pool_t *pool)
{
svn_auth_cred_ssl_client_cert_pw_t *creds = credentials;
apr_hash_t *creds_hash = NULL;
const char *config_dir;
svn_error_t *err;
svn_boolean_t dont_store_passphrase =
svn_hash_gets(parameters, SVN_AUTH_PARAM_DONT_STORE_SSL_CLIENT_CERT_PP)
!= NULL;
svn_boolean_t non_interactive =
svn_hash_gets(parameters, SVN_AUTH_PARAM_NON_INTERACTIVE) != NULL;
svn_boolean_t no_auth_cache =
(! creds->may_save)
|| (svn_hash_gets(parameters, SVN_AUTH_PARAM_NO_AUTH_CACHE) != NULL);
*saved = FALSE;
if (no_auth_cache)
return SVN_NO_ERROR;
config_dir = svn_hash_gets(parameters, SVN_AUTH_PARAM_CONFIG_DIR);
creds_hash = apr_hash_make(pool);
/* Don't store passphrase in any form if the user has told
us not to do so. */
if (! dont_store_passphrase)
{
svn_boolean_t may_save_passphrase = FALSE;
/* If the passphrase is going to be stored encrypted, go right
ahead and store it to disk. Else determine whether saving
in plaintext is OK. */
if (strcmp(passtype, SVN_AUTH__WINCRYPT_PASSWORD_TYPE) == 0
|| strcmp(passtype, SVN_AUTH__KWALLET_PASSWORD_TYPE) == 0
|| strcmp(passtype, SVN_AUTH__GNOME_KEYRING_PASSWORD_TYPE) == 0
|| strcmp(passtype, SVN_AUTH__KEYCHAIN_PASSWORD_TYPE) == 0)
{
may_save_passphrase = TRUE;
}
else
{
#ifdef SVN_DISABLE_PLAINTEXT_PASSWORD_STORAGE
may_save_passphrase = FALSE;
#else
const char *store_ssl_client_cert_pp_plaintext =
svn_hash_gets(parameters,
SVN_AUTH_PARAM_STORE_SSL_CLIENT_CERT_PP_PLAINTEXT);
ssl_client_cert_pw_file_provider_baton_t *b =
(ssl_client_cert_pw_file_provider_baton_t *)provider_baton;
if (svn_cstring_casecmp(store_ssl_client_cert_pp_plaintext,
SVN_CONFIG_ASK) == 0)
{
if (non_interactive)
{
/* In non-interactive mode, the default behaviour is
to not store the passphrase */
may_save_passphrase = FALSE;
}
else if (b->plaintext_passphrase_prompt_func)
{
/* We're interactive, and the client provided a
prompt callback. So we can ask the user.
Check for a cached answer before prompting.
This is a pointer-to-boolean, rather than just a
boolean, because we must distinguish between
"cached answer is no" and "no answer has been
cached yet". */
svn_boolean_t *cached_answer =
svn_hash_gets(b->plaintext_answers, realmstring);
if (cached_answer != NULL)
{
may_save_passphrase = *cached_answer;
}
else
{
apr_pool_t *cached_answer_pool;
/* Nothing cached for this realm, prompt the user. */
SVN_ERR((*b->plaintext_passphrase_prompt_func)(
&may_save_passphrase,
realmstring,
b->prompt_baton,
pool));
/* Cache the user's answer in case we're called again
* for the same realm.
*
* We allocate the answer cache in the hash table's pool
* to make sure that is has the same life time as the
* hash table itself. This means that the answer will
* survive across RA sessions -- which is important,
* because otherwise we'd prompt users once per RA session.
*/
cached_answer_pool = apr_hash_pool_get(b->plaintext_answers);
cached_answer = apr_palloc(cached_answer_pool,
sizeof(*cached_answer));
*cached_answer = may_save_passphrase;
svn_hash_sets(b->plaintext_answers, realmstring,
cached_answer);
}
}
else
{
may_save_passphrase = FALSE;
}
}
else if (svn_cstring_casecmp(store_ssl_client_cert_pp_plaintext,
SVN_CONFIG_FALSE) == 0)
{
may_save_passphrase = FALSE;
}
else if (svn_cstring_casecmp(store_ssl_client_cert_pp_plaintext,
SVN_CONFIG_TRUE) == 0)
{
may_save_passphrase = TRUE;
}
else
{
return svn_error_createf
(SVN_ERR_RA_DAV_INVALID_CONFIG_VALUE, NULL,
_("Config error: invalid value '%s' for option '%s'"),
store_ssl_client_cert_pp_plaintext,
SVN_AUTH_PARAM_STORE_SSL_CLIENT_CERT_PP_PLAINTEXT);
}
#endif
}
if (may_save_passphrase)
{
SVN_ERR(passphrase_set(saved, creds_hash, realmstring,
NULL, creds->password, parameters,
non_interactive, pool));
if (*saved && passtype)
{
svn_hash_sets(creds_hash, AUTHN_PASSTYPE_KEY,
svn_string_create(passtype, pool));
}
/* Save credentials to disk. */
err = svn_config_write_auth_data(creds_hash,
SVN_AUTH_CRED_SSL_CLIENT_CERT_PW,
realmstring, config_dir, pool);
svn_error_clear(err);
*saved = ! err;
}
}
return SVN_NO_ERROR;
}
static apr_status_t dbm_open_type(apr_dbm_type_t const* * vtable,
const char *type,
apr_pool_t *pool)
{
#if !APU_DSO_BUILD
*vtable = NULL;
if (!strcasecmp(type, "default")) *vtable = &DBM_VTABLE;
#if APU_HAVE_DB
else if (!strcasecmp(type, "db")) *vtable = &apr_dbm_type_db;
#endif
else if (*type && !strcasecmp(type + 1, "dbm")) {
#if APU_HAVE_GDBM
if (*type == 'G' || *type == 'g') *vtable = &apr_dbm_type_gdbm;
#endif
#if APU_HAVE_NDBM
if (*type == 'N' || *type == 'n') *vtable = &apr_dbm_type_ndbm;
#endif
#if APU_HAVE_SDBM
if (*type == 'S' || *type == 's') *vtable = &apr_dbm_type_sdbm;
#endif
/* avoid empty block */ ;
}
if (*vtable)
return APR_SUCCESS;
return APR_ENOTIMPL;
#else /* APU_DSO_BUILD */
char modname[32];
char symname[34];
apr_dso_handle_sym_t symbol;
apr_status_t rv;
int usertype = 0;
if (!strcasecmp(type, "default")) type = DBM_NAME;
else if (!strcasecmp(type, "db")) type = "db";
else if (*type && !strcasecmp(type + 1, "dbm")) {
if (*type == 'G' || *type == 'g') type = "gdbm";
else if (*type == 'N' || *type == 'n') type = "ndbm";
else if (*type == 'S' || *type == 's') type = "sdbm";
}
else usertype = 1;
if (apr_atomic_inc32(&initialised)) {
apr_atomic_set32(&initialised, 1); /* prevent wrap-around */
while (apr_atomic_read32(&in_init)) /* wait until we get fully inited */
;
}
else {
apr_pool_t *parent;
/* Top level pool scope, need process-scope lifetime */
for (parent = pool; parent; parent = apr_pool_parent_get(pool))
pool = parent;
/* deprecate in 2.0 - permit implicit initialization */
apu_dso_init(pool);
drivers = apr_hash_make(pool);
apr_hash_set(drivers, "sdbm", APR_HASH_KEY_STRING, &apr_dbm_type_sdbm);
apr_pool_cleanup_register(pool, NULL, dbm_term,
apr_pool_cleanup_null);
apr_atomic_dec32(&in_init);
}
rv = apu_dso_mutex_lock();
if (rv) {
*vtable = NULL;
return rv;
}
*vtable = apr_hash_get(drivers, type, APR_HASH_KEY_STRING);
if (*vtable) {
apu_dso_mutex_unlock();
return APR_SUCCESS;
}
/* The driver DSO must have exactly the same lifetime as the
* drivers hash table; ignore the passed-in pool */
pool = apr_hash_pool_get(drivers);
#if defined(NETWARE)
apr_snprintf(modname, sizeof(modname), "dbm%s.nlm", type);
#elif defined(WIN32)
apr_snprintf(modname, sizeof(modname),
"apr_dbm_%s-" APU_STRINGIFY(APU_MAJOR_VERSION) ".dll", type);
#else
apr_snprintf(modname, sizeof(modname),
"apr_dbm_%s-" APU_STRINGIFY(APU_MAJOR_VERSION) ".so", type);
#endif
apr_snprintf(symname, sizeof(symname), "apr_dbm_type_%s", type);
rv = apu_dso_load(NULL, &symbol, modname, symname, pool);
if (rv == APR_SUCCESS || rv == APR_EINIT) { /* previously loaded?!? */
*vtable = symbol;
if (usertype)
type = apr_pstrdup(pool, type);
apr_hash_set(drivers, type, APR_HASH_KEY_STRING, *vtable);
rv = APR_SUCCESS;
}
else
*vtable = NULL;
apu_dso_mutex_unlock();
return rv;
#endif /* APU_DSO_BUILD */
}
/* Conforms to svn_ra_serf__xml_closed_t */
static svn_error_t *
propfind_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)
{
propfind_context_t *ctx = baton;
if (leaving_state == MULTISTATUS)
{
/* We've gathered all the data from the reponse. Add this item
onto the "done list". External callers will then know this
request has been completed (tho stray response bytes may still
arrive). */
}
else if (leaving_state == HREF)
{
const char *path;
if (strcmp(ctx->depth, "1") == 0)
path = svn_urlpath__canonicalize(cdata->data, scratch_pool);
else
path = ctx->path;
svn_ra_serf__xml_note(xes, RESPONSE, "path", path);
SVN_ERR(ctx->prop_func(ctx->prop_func_baton,
path,
D_, "href",
cdata, scratch_pool));
}
else if (leaving_state == COLLECTION)
{
svn_ra_serf__xml_note(xes, PROPVAL, "altvalue", "collection");
}
else if (leaving_state == HREF_VALUE)
{
svn_ra_serf__xml_note(xes, PROPVAL, "altvalue", cdata->data);
}
else if (leaving_state == STATUS)
{
/* Parse the status field, and remember if this is a property
that we wish to ignore. (Typically, if it's not a 200, the
status will be 404 to indicate that a property we
specifically requested from the server doesn't exist.) */
apr_int64_t status = parse_status_code(cdata->data);
if (status != 200)
svn_ra_serf__xml_note(xes, PROPSTAT, "ignore-prop", "*");
}
else if (leaving_state == PROPVAL)
{
const char *encoding;
const svn_string_t *val_str;
const char *ns;
const char *name;
const char *altvalue;
if ((altvalue = svn_hash_gets(attrs, "altvalue")) != NULL)
{
val_str = svn_string_create(altvalue, scratch_pool);
}
else if ((encoding = svn_hash_gets(attrs, "V:encoding")) != NULL)
{
if (strcmp(encoding, "base64") != 0)
return svn_error_createf(SVN_ERR_RA_DAV_MALFORMED_DATA,
NULL,
_("Got unrecognized encoding '%s'"),
encoding);
/* Decode into the right pool. */
val_str = svn_base64_decode_string(cdata, scratch_pool);
}
else
{
/* Copy into the right pool. */
val_str = cdata;
}
/* The current path sits on the RESPONSE state.
Now, it would be nice if we could, at this point, know that
the status code for this property indicated a problem -- then
we could simply bail out here and ignore the property.
Sadly, though, we might get the status code *after* we get
the property value. So we'll carry on with our processing
here, setting the property and value as expected. Once we
know for sure the status code associate with the property,
we'll decide its fate. */
ns = svn_hash_gets(attrs, "ns");
name = svn_hash_gets(attrs, "name");
set_ns_prop(ctx->ps_props, ns, name, val_str,
apr_hash_pool_get(ctx->ps_props));
}
else
{
apr_hash_t *gathered;
SVN_ERR_ASSERT(leaving_state == PROPSTAT);
gathered = svn_ra_serf__xml_gather_since(xes, RESPONSE);
/* If we've squirreled away a note that says we want to ignore
these properties, we'll do so. Otherwise, we need to copy
them from the temporary hash into the ctx->ret_props hash. */
if (! svn_hash_gets(gathered, "ignore-prop"))
{
apr_hash_index_t *hi_ns;
const char *path;
apr_pool_t *iterpool = svn_pool_create(scratch_pool);
path = svn_hash_gets(gathered, "path");
if (!path)
path = ctx->path;
for (hi_ns = apr_hash_first(scratch_pool, ctx->ps_props);
hi_ns;
hi_ns = apr_hash_next(hi_ns))
{
const char *ns = apr_hash_this_key(hi_ns);
apr_hash_t *props = apr_hash_this_val(hi_ns);
apr_hash_index_t *hi_prop;
svn_pool_clear(iterpool);
for (hi_prop = apr_hash_first(iterpool, props);
hi_prop;
hi_prop = apr_hash_next(hi_prop))
{
const char *name = apr_hash_this_key(hi_prop);
const svn_string_t *value = apr_hash_this_val(hi_prop);
SVN_ERR(ctx->prop_func(ctx->prop_func_baton, path,
ns, name, value, iterpool));
}
}
svn_pool_destroy(iterpool);
}
ctx->ps_props = NULL; /* Allocated in PROPSTAT state pool */
}
return SVN_NO_ERROR;
}
apr_pool_t * vhx_cache_get_pool() {
return apr_hash_pool_get(cache);
}
apr_status_t apu_dso_load(apr_dso_handle_t **dlhandleptr,
apr_dso_handle_sym_t *dsoptr,
const char *module,
const char *modsym,
apr_pool_t *pool)
{
apr_dso_handle_t *dlhandle = NULL;
char *pathlist;
char path[APR_PATH_MAX + 1];
apr_array_header_t *paths;
apr_pool_t *global;
apr_status_t rv = APR_EDSOOPEN;
char *eos = NULL;
int i;
*dsoptr = apr_hash_get(dsos, module, APR_HASH_KEY_STRING);
if (*dsoptr) {
return APR_EINIT;
}
/* The driver DSO must have exactly the same lifetime as the
* drivers hash table; ignore the passed-in pool */
global = apr_hash_pool_get(dsos);
/* Retrieve our path search list or prepare for a single search */
if ((apr_env_get(&pathlist, APR_DSOPATH, pool) != APR_SUCCESS)
|| (apr_filepath_list_split(&paths, pathlist, pool) != APR_SUCCESS))
paths = apr_array_make(pool, 1, sizeof(char*));
#if defined(APR_DSO_LIBDIR)
/* Always search our prefix path, but on some platforms such as
* win32 this may be left undefined
*/
(*((char **)apr_array_push(paths))) = APR_DSO_LIBDIR;
#endif
for (i = 0; i < paths->nelts; ++i)
{
#if defined(WIN32)
/* Use win32 dso search semantics and attempt to
* load the relative lib on the first pass.
*/
if (!eos) {
eos = path;
--i;
}
else
#endif
{
eos = apr_cpystrn(path, ((char**)paths->elts)[i], sizeof(path));
if ((eos > path) && (eos - path < sizeof(path) - 1))
*(eos++) = '/';
}
apr_cpystrn(eos, module, sizeof(path) - (eos - path));
rv = apr_dso_load(&dlhandle, path, global);
if (dlhandleptr) {
*dlhandleptr = dlhandle;
}
if (rv == APR_SUCCESS) { /* APR_EDSOOPEN */
break;
}
#if defined(APR_DSO_LIBDIR)
else if (i < paths->nelts - 1) {
#else
else { /* No APR_DSO_LIBDIR to skip */
#endif
/* try with apr-APR_MAJOR_VERSION appended */
eos = apr_cpystrn(eos,
"apr-" APR_STRINGIFY(APR_MAJOR_VERSION) "/",
sizeof(path) - (eos - path));
apr_cpystrn(eos, module, sizeof(path) - (eos - path));
rv = apr_dso_load(&dlhandle, path, global);
if (dlhandleptr) {
*dlhandleptr = dlhandle;
}
if (rv == APR_SUCCESS) { /* APR_EDSOOPEN */
break;
}
}
}
if (rv != APR_SUCCESS) /* APR_ESYMNOTFOUND */
return rv;
rv = apr_dso_sym(dsoptr, dlhandle, modsym);
if (rv != APR_SUCCESS) { /* APR_ESYMNOTFOUND */
apr_dso_unload(dlhandle);
}
else {
module = apr_pstrdup(global, module);
apr_hash_set(dsos, module, APR_HASH_KEY_STRING, *dsoptr);
}
return rv;
}
/* Handle a open() call. Ensures that a file_info_t for the given NAME
* exists. Auto-create and initialize a handle_info_t for it linked to
* HANDLE.
*/
static void
open_file(const char *name, int handle)
{
file_stats_t *file = apr_hash_get(files, name, APR_HASH_KEY_STRING);
handle_info_t *handle_info = apr_hash_get(handles, &handle, sizeof(handle));
/* auto-create file info */
if (!file)
{
apr_pool_t *pool = apr_hash_pool_get(files);
apr_pool_t *subpool = svn_pool_create(pool);
apr_file_t *apr_file = NULL;
apr_finfo_t finfo = { 0 };
int cluster_count = 0;
/* determine file size (if file still exists) */
apr_file_open(&apr_file, name,
APR_READ | APR_BUFFERED, APR_OS_DEFAULT, subpool);
if (apr_file)
apr_file_info_get(&finfo, APR_FINFO_SIZE, apr_file);
svn_pool_destroy(subpool);
file = apr_pcalloc(pool, sizeof(*file));
file->name = apr_pstrdup(pool, name);
file->size = finfo.size;
/* pre-allocate cluster map accordingly
* (will be auto-expanded later if necessary) */
cluster_count = (int)(1 + (file->size - 1) / cluster_size);
file->read_map = apr_array_make(pool, file->size
? cluster_count
: 1, sizeof(word));
while (file->read_map->nelts < cluster_count)
APR_ARRAY_PUSH(file->read_map, byte) = 0;
/* determine first revision of rev / packed rev files */
if (strstr(name, "/db/revs/") != NULL && strstr(name, "manifest") == NULL)
if (strstr(name, ".pack/pack") != NULL)
file->rev_num = SVN_STR_TO_REV(strstr(name, "/db/revs/") + 9);
else
file->rev_num = SVN_STR_TO_REV(strrchr(name, '/') + 1);
else
file->rev_num = -1;
/* filter out log/phys index files */
if (file->rev_num >= 0)
{
const char *suffix = name + strlen(name) - 4;
if (strcmp(suffix, ".l2p") == 0 || strcmp(suffix, ".p2l") == 0)
file->rev_num = -1;
}
apr_hash_set(files, file->name, APR_HASH_KEY_STRING, file);
}
file->open_count++;
/* auto-create handle instance */
if (!handle_info)
{
apr_pool_t *pool = apr_hash_pool_get(handles);
int *key = apr_palloc(pool, sizeof(*key));
*key = handle;
handle_info = apr_pcalloc(pool, sizeof(*handle_info));
apr_hash_set(handles, key, sizeof(*key), handle_info);
}
/* link handle to file */
handle_info->file = file;
handle_info->last_read_start = 0;
handle_info->last_read_size = 0;
}
