svn_error_t *
svn_fs__append_to_merged_froms(svn_mergeinfo_t *output,
svn_mergeinfo_t input,
const char *rel_path,
apr_pool_t *pool)
{
apr_hash_index_t *hi;
*output = apr_hash_make(pool);
for (hi = apr_hash_first(pool, input); hi; hi = apr_hash_next(hi))
{
const char *path = apr_hash_this_key(hi);
svn_rangelist_t *rangelist = apr_hash_this_val(hi);
svn_hash_sets(*output,
svn_fspath__join(path, rel_path, pool),
svn_rangelist_dup(rangelist, pool));
}
return SVN_NO_ERROR;
}
bool GitStatus::IsInExternal(const CTGitPath& /*path*/) const
{
#if 0
if (apr_hash_count(m_statushash) == 0)
return false;
GitPool localpool(m_pool);
apr_hash_index_t *hi;
const char* key;
for (hi = apr_hash_first(localpool, m_externalhash); hi; hi = apr_hash_next(hi))
{
apr_hash_this(hi, (const void**)&key, NULL, NULL);
if (key)
{
if (CTGitPath(CUnicodeUtils::GetUnicode(key)).IsAncestorOf(path))
return true;
}
}
#endif
return false;
}
void
Property::list()
{
Pool pool;
Revision revision;
m_entries.clear();
apr_array_header_t * props;
svn_error_t * error =
svn_client_proplist(&props,
m_path.c_str(),
revision,
false, /* recurse */
*m_context,
pool);
if (error != NULL)
{
throw ClientException(error);
}
for (int j = 0; j < props->nelts; ++j)
{
svn_client_proplist_item_t *item =
((svn_client_proplist_item_t **)props->elts)[j];
apr_hash_index_t *hi;
for (hi = apr_hash_first(pool, item->prop_hash); hi;
hi = apr_hash_next(hi))
{
const void *key;
void *val;
apr_hash_this(hi, &key, NULL, &val);
m_entries.push_back(PropertyEntry(
(const char *)key, getValue((const char *)key).c_str()));
}
}
}
static int setup_db_pool(apr_pool_t* p, apr_pool_t* plog,
apr_pool_t* ptemp, server_rec* s) {
void *data = NULL;
char *key;
const char *userdata_key = "pgasp_post_config";
apr_hash_index_t *idx;
apr_ssize_t len;
pgasp_config *pgasp;
// This code is used to prevent double initialization of the module during Apache startup
apr_pool_userdata_get(&data, userdata_key, s->process->pool);
if ( data == NULL ) {
apr_pool_userdata_set((const void *)1, userdata_key, apr_pool_cleanup_null, s->process->pool);
return OK;
}
for (idx = apr_hash_first(p, pgasp_pool_config); idx; idx = apr_hash_next(idx)) {
apr_hash_this(idx, (void *) &key, &len, (void *) &pgasp);
if ( apr_reslist_create(&pgasp->dbpool,
pgasp->nmin,
pgasp->nkeep,
pgasp->nmax,
pgasp->exptime,
pgasp_pool_construct,
pgasp_pool_destruct,
(void*)pgasp, p) != APR_SUCCESS ) {
ap_log_error(APLOG_MARK, APLOG_CRIT, 0, s, "mod_pgasp: failed to initialise") ;
return 500 ;
}
apr_pool_cleanup_register(p, pgasp->dbpool,
(void*)apr_reslist_destroy,
apr_pool_cleanup_null) ;
apr_hash_set(pgasp_pool_config, key, APR_HASH_KEY_STRING, pgasp);
}
return OK ;
}
/** Close connection */
static apt_bool_t rtsp_server_connection_close(rtsp_server_t *server, rtsp_server_connection_t *rtsp_connection)
{
apt_pollset_t *pollset = apt_poller_task_pollset_get(server->task);
apr_size_t remaining_sessions = 0;
if(!rtsp_connection || !rtsp_connection->sock) {
return FALSE;
}
apt_log(APT_LOG_MARK,APT_PRIO_INFO,"Close RTSP Connection %s",rtsp_connection->id);
apt_pollset_remove(pollset,&rtsp_connection->sock_pfd);
apr_socket_close(rtsp_connection->sock);
rtsp_connection->sock = NULL;
apt_list_elem_remove(server->connection_list,rtsp_connection->it);
rtsp_connection->it = NULL;
if(apt_list_is_empty(server->connection_list) == TRUE) {
apr_pool_clear(server->sub_pool);
server->connection_list = NULL;
}
remaining_sessions = apr_hash_count(rtsp_connection->session_table);
if(remaining_sessions) {
rtsp_server_session_t *session;
void *val;
apr_hash_index_t *it;
apt_log(APT_LOG_MARK,APT_PRIO_NOTICE,"Terminate Remaining RTSP Sessions [%"APR_SIZE_T_FMT"]",
remaining_sessions);
it = apr_hash_first(rtsp_connection->pool,rtsp_connection->session_table);
for(; it; it = apr_hash_next(it)) {
apr_hash_this(it,NULL,NULL,&val);
session = val;
if(session && session->terminating == FALSE) {
rtsp_server_session_terminate_request(server,session);
}
}
}
else {
rtsp_server_connection_destroy(rtsp_connection);
}
return TRUE;
}
svn_error_t *
svn_fs_x__dag_delete_if_mutable(svn_fs_t *fs,
const svn_fs_id_t *id,
apr_pool_t *pool)
{
dag_node_t *node;
/* Get the node. */
SVN_ERR(svn_fs_x__dag_get_node(&node, fs, id, pool));
/* If immutable, do nothing and return immediately. */
if (! svn_fs_x__dag_check_mutable(node))
return SVN_NO_ERROR;
/* Else it's mutable. Recurse on directories... */
if (node->kind == svn_node_dir)
{
apr_hash_t *entries;
apr_hash_index_t *hi;
/* Loop over hash entries */
SVN_ERR(svn_fs_x__dag_dir_entries(&entries, node, pool));
if (entries)
{
for (hi = apr_hash_first(pool, entries);
hi;
hi = apr_hash_next(hi))
{
svn_fs_dirent_t *dirent = svn__apr_hash_index_val(hi);
SVN_ERR(svn_fs_x__dag_delete_if_mutable(fs, dirent->id, pool));
}
}
}
/* ... then delete the node itself, after deleting any mutable
representations and strings it points to. */
return svn_fs_x__dag_remove_node(fs, id, pool);
}
/* Teardown session resources */
static apt_bool_t rtsp_client_session_resources_teardown(rtsp_client_t *client, rtsp_client_session_t *session)
{
void *val;
rtsp_message_t *setup_request;
rtsp_message_t *teardown_request;
apr_hash_index_t *it;
/* set termination state to in-progress and teardown remaining resources */
session->term_state = TERMINATION_STATE_INPROGRESS;
it = apr_hash_first(session->pool,session->resource_table);
for(; it; it = apr_hash_next(it)) {
apr_hash_this(it,NULL,NULL,&val);
setup_request = val;
if(!setup_request) continue;
teardown_request = rtsp_request_create(session->pool);
teardown_request->start_line.common.request_line.resource_name = setup_request->start_line.common.request_line.resource_name;
teardown_request->start_line.common.request_line.method_id = RTSP_METHOD_TEARDOWN;
rtsp_client_session_message_process(client,session,teardown_request);
}
return TRUE;
}
svn_error_t *
svn_rdump__normalize_props(apr_hash_t **normal_props,
apr_hash_t *props,
apr_pool_t *result_pool)
{
apr_hash_index_t *hi;
*normal_props = apr_hash_make(result_pool);
for (hi = apr_hash_first(result_pool, props); hi;
hi = apr_hash_next(hi))
{
const char *key = svn__apr_hash_index_key(hi);
const svn_string_t *value = svn__apr_hash_index_val(hi);
SVN_ERR(svn_rdump__normalize_prop(key, &value,
result_pool));
svn_hash_sets(*normal_props, key, value);
}
return SVN_NO_ERROR;
}
static apr_status_t
lcn_multi_reader_do_commit( lcn_index_reader_t *index_reader )
{
apr_status_t s = APR_SUCCESS;
unsigned int i;
lcn_multi_reader_t *multi_reader = (lcn_multi_reader_t*) index_reader;
for( i = 0; i < multi_reader->sub_readers_count; i++ )
{
apr_status_t status = lcn_index_reader_commit( multi_reader->sub_readers[i] );
if ( APR_SUCCESS == s && status )
{
s = status;
}
}
if ( LCN_TRUE == index_reader->is_directory_reader )
{
apr_hash_index_t *hi;
for( hi = apr_hash_first( index_reader->pool, index_reader->fs_fields); hi; hi = apr_hash_next( hi ))
{
lcn_fs_field_t *fs_field;
void *vval;
apr_hash_this( hi, NULL, NULL, &vval );
fs_field = (lcn_fs_field_t *) vval;
if ( NULL != fs_field && fs_field->is_modified )
{
LCNCE( lcn_fs_field_commit( fs_field, index_reader->pool ));
}
}
}
return s;
}
static apr_status_t lottery_stone_group_assembler(
apr_int32_t group_id,
apr_hash_t * group_hash,
apr_hash_t * prob_hash,
apr_pool_t * res_pool)
{
unsigned int count = apr_hash_count(group_hash);
if (count == 0) {
return -1;
}
// 圆桌理论，数据构建
lottery_group_prob * gp = (lottery_group_prob *)
apr_palloc(res_pool, sizeof(lottery_group_prob));
gp->count = count;
gp->ptt_array = (card_ptt_id_t *)
apr_palloc(res_pool, count * sizeof(card_ptt_id_t));
gp->prob_array = (apr_uint32_t *)
apr_palloc(res_pool, count * sizeof(apr_uint32_t));
gp->prob_sum = 0;
int i = 0;
lottery_stone_t * ls = NULL;
apr_hash_index_t * hi = NULL;
for (hi = apr_hash_first(NULL, group_hash);
hi != NULL;
hi = apr_hash_next(hi)) {
apr_hash_this(hi, NULL, NULL, (void **)&ls);
gp->ptt_array[i] = ls->ptt_id;
gp->prob_array[i] = ls->ptt_prob;
gp->prob_sum += ls->ptt_prob;
++ i;
}
apr_hash_set(prob_hash, &group_id, sizeof(group_id), gp);
return APR_SUCCESS;
}
service_manager_t *clone_service_manager(service_manager_t *sm)
{
apr_ssize_t klen;
service_manager_t *clone;
apr_hash_index_t *his;
apr_hash_t *section, *clone_section;
char *key;
//** Make an empty SM
clone = create_service_manager(sm);
//** Now cycle through all the tables and copy them
apr_thread_mutex_lock(sm->lock);
for (his = apr_hash_first(NULL, sm->table); his != NULL; his = apr_hash_next(his)) {
apr_hash_this(his, (const void **)&key, &klen, (void **)§ion);
clone_section = apr_hash_copy(clone->pool, section);
apr_hash_set(clone->table, apr_pstrdup(clone->pool, key), APR_HASH_KEY_STRING, clone_section);
}
apr_thread_mutex_unlock(sm->lock);
return(clone);
}
void destroy_hportal_context(portal_context_t *hpc)
{
apr_hash_index_t *hi;
host_portal_t *hp;
void *val;
for (hi=apr_hash_first(hpc->pool, hpc->table); hi != NULL; hi = apr_hash_next(hi)) {
apr_hash_this(hi, NULL, NULL, &val);
hp = (host_portal_t *)val;
apr_hash_set(hpc->table, hp->skey, APR_HASH_KEY_STRING, NULL);
destroy_hportal(hp);
}
apr_thread_mutex_destroy(hpc->lock);
apr_hash_clear(hpc->table);
apr_pool_destroy(hpc->pool);
free(hpc);
return;
}
svn_error_t *
svn_skel__unparse_proplist(svn_skel_t **skel_p,
const apr_hash_t *proplist,
apr_pool_t *pool)
{
svn_skel_t *skel = svn_skel__make_empty_list(pool);
apr_hash_index_t *hi;
/* Create the skel. */
if (proplist)
{
/* Loop over hash entries */
for (hi = apr_hash_first(pool, (apr_hash_t *)proplist); hi;
hi = apr_hash_next(hi))
{
const void *key;
void *val;
apr_ssize_t klen;
svn_string_t *value;
apr_hash_this(hi, &key, &klen, &val);
value = val;
/* VALUE */
svn_skel__prepend(svn_skel__mem_atom(value->data, value->len, pool),
skel);
/* NAME */
svn_skel__prepend(svn_skel__mem_atom(key, klen, pool), skel);
}
}
/* Validate and return the skel. */
if (! is_valid_proplist_skel(skel))
return skel_err("proplist");
*skel_p = skel;
return SVN_NO_ERROR;
}
void change_all_hportal_conn(portal_context_t *hpc, int min_conn, int max_conn, apr_time_t dt_connect)
{
apr_hash_index_t *hi;
host_portal_t *hp;
void *val;
apr_thread_mutex_lock(hpc->lock);
for (hi=apr_hash_first(hpc->pool, hpc->table); hi != NULL; hi = apr_hash_next(hi)) {
apr_hash_this(hi, NULL, NULL, &val);
hp = (host_portal_t *)val;
hportal_lock(hp);
//log_printf(0, "change_all_hportal_conn: hp=%s min=%d max=%d\n", hp->skey, min_conn, max_conn);
hp->min_conn = min_conn;
hp->max_conn = max_conn;
hp->stable_conn = max_conn;
hp->dt_connect = dt_connect;
hportal_unlock(hp);
}
apr_thread_mutex_unlock(hpc->lock);
}
int
svn_config_enumerate2(svn_config_t *cfg, const char *section,
svn_config_enumerator2_t callback, void *baton,
apr_pool_t *pool)
{
cfg_section_t *sec;
apr_hash_index_t *opt_ndx;
apr_pool_t *iteration_pool;
int count;
find_option(cfg, section, NULL, &sec);
if (sec == NULL)
return 0;
iteration_pool = svn_pool_create(pool);
count = 0;
for (opt_ndx = apr_hash_first(pool, sec->options);
opt_ndx != NULL;
opt_ndx = apr_hash_next(opt_ndx))
{
void *opt_ptr;
cfg_option_t *opt;
const char *temp_value;
apr_hash_this(opt_ndx, NULL, NULL, &opt_ptr);
opt = opt_ptr;
++count;
make_string_from_option(&temp_value, cfg, sec, opt, NULL);
svn_pool_clear(iteration_pool);
if (!callback(opt->name, temp_value, baton, iteration_pool))
break;
}
svn_pool_destroy(iteration_pool);
return count;
}
/**
* lists revision properties in @a path no matter whether local or
* repository
*
* @param path
* @param revision
* @param recurse
* @return PropertiesList
*/
std::pair<svn_revnum_t,PropertiesMap>
Client::revproplist(const Path &path,
const Revision &revision)
{
Pool pool;
apr_hash_t * props;
svn_revnum_t revnum;
svn_error_t * error =
svn_client_revprop_list(&props,
path.c_str(),
revision.revision(),
&revnum,
*m_context,
pool);
if (error != nullptr)
{
throw ClientException(error);
}
PropertiesMap prop_map;
apr_hash_index_t *hi;
for (hi = apr_hash_first(pool, props); hi;
hi = apr_hash_next(hi))
{
const void *key;
void *val;
apr_hash_this(hi, &key, nullptr, &val);
prop_map [std::string((const char *)key)] =
std::string(((const svn_string_t *)val)->data);
}
return std::pair<svn_revnum_t,PropertiesMap> (revnum, prop_map);
}
apr_array_header_t *
svn_prop_hash_to_array(const apr_hash_t *hash,
apr_pool_t *pool)
{
apr_hash_index_t *hi;
apr_array_header_t *array = apr_array_make(pool,
apr_hash_count((apr_hash_t *)hash),
sizeof(svn_prop_t));
for (hi = apr_hash_first(pool, (apr_hash_t *)hash); hi;
hi = apr_hash_next(hi))
{
const void *key;
void *val;
svn_prop_t prop;
apr_hash_this(hi, &key, NULL, &val);
prop.name = key;
prop.value = val;
APR_ARRAY_PUSH(array, svn_prop_t) = prop;
}
return array;
}
static svn_error_t *
logReceiver(void *baton,
apr_hash_t * changedPaths,
svn_revnum_t rev,
const char *author,
const char *date,
const char *msg,
apr_pool_t * pool)
{
LogEntries * entries = (LogEntries *) baton;
entries->insert(entries->begin(), LogEntry(rev, author, date, msg));
if (changedPaths != NULL)
{
LogEntry &entry = entries->front();
for (apr_hash_index_t *hi = apr_hash_first(pool, changedPaths);
hi != NULL;
hi = apr_hash_next(hi))
{
char *path;
void *val;
apr_hash_this(hi, (const void **)&path, NULL, &val);
svn_log_changed_path_t *log_item = reinterpret_cast<svn_log_changed_path_t *>(val);
entry.changedPaths.push_back(
LogChangePathEntry(path,
log_item->action,
log_item->copyfrom_path,
log_item->copyfrom_rev));
}
}
return NULL;
}
/* For all lock tokens in ALL_TOKENS for URLs under BASE_URL, add them
to a new hashtable allocated in POOL. *RESULT is set to point to this
new hash table. *RESULT will be keyed on const char * URI-decoded paths
relative to BASE_URL. The lock tokens will not be duplicated. */
static svn_error_t *
collect_lock_tokens(apr_hash_t **result,
apr_hash_t *all_tokens,
const char *base_url,
apr_pool_t *pool)
{
apr_hash_index_t *hi;
*result = apr_hash_make(pool);
for (hi = apr_hash_first(pool, all_tokens); hi; hi = apr_hash_next(hi))
{
const char *url = svn__apr_hash_index_key(hi);
const char *token = svn__apr_hash_index_val(hi);
const char *relpath = svn_uri_skip_ancestor(base_url, url, pool);
if (relpath)
{
svn_hash_sets(*result, relpath, token);
}
}
return SVN_NO_ERROR;
}
svn_boolean_t
svn_fs__prop_lists_equal(apr_hash_t *a,
apr_hash_t *b,
apr_pool_t *pool)
{
apr_hash_index_t *hi;
/* Quick checks and special cases. */
if (a == b)
return TRUE;
if (a == NULL)
return apr_hash_count(b) == 0;
if (b == NULL)
return apr_hash_count(a) == 0;
if (apr_hash_count(a) != apr_hash_count(b))
return FALSE;
/* Compare prop by prop. */
for (hi = apr_hash_first(pool, a); hi; hi = apr_hash_next(hi))
{
const char *key;
apr_ssize_t klen;
svn_string_t *val_a, *val_b;
apr_hash_this(hi, (const void **)&key, &klen, (void **)&val_a);
val_b = apr_hash_get(b, key, klen);
if (!val_b || !svn_string_compare(val_a, val_b))
return FALSE;
}
/* No difference found. */
return TRUE;
}
static dav_error *dav_acl_patch_exec(const dav_resource * resource,
const apr_xml_elem * elem,
int operation,
void *context,
dav_liveprop_rollback **rollback_ctx)
{
dav_repos_resource *db_r = resource->info->db_r;
const dav_repos_db *db = resource->info->db;
dav_elem_private *priv = elem->priv;
dav_error *err = NULL;
if (priv->propid == DAV_PROPID_group_member_set) {
apr_hash_t *new_members = (apr_hash_t*)context;
apr_array_header_t *to_remove = (apr_array_header_t *)apr_hash_get
(new_members, "-to-remove-", APR_HASH_KEY_STRING);
apr_hash_set(new_members, "-to-remove-", APR_HASH_KEY_STRING, NULL);
dav_repos_resource *prin = NULL;
int i = 0;
for (i = 0; to_remove && i < to_remove->nelts; i++) {
prin = &APR_ARRAY_IDX(to_remove, i, dav_repos_resource);
err = sabridge_rem_prin_frm_grp
(db_r->p, db, db_r->serialno, prin->serialno);
if (err) return err;
}
apr_hash_index_t *iter = apr_hash_first(db_r->p, new_members);
while (iter) {
apr_hash_this(iter, NULL, NULL, (void *)&prin);
err = sabridge_add_prin_to_grp
(db_r->p, db, db_r->serialno, prin->serialno);
if (err) return err;
iter = apr_hash_next(iter);
}
}
return NULL;
}
void compact_hportals(portal_context_t *hpc)
{
apr_hash_index_t *hi;
host_portal_t *hp;
void *val;
apr_thread_mutex_lock(hpc->lock);
for (hi=apr_hash_first(hpc->pool, hpc->table); hi != NULL; hi = apr_hash_next(hi)) {
apr_hash_this(hi, NULL, NULL, &val);
hp = (host_portal_t *)val;
hportal_lock(hp);
_reap_hportal(hp, 1); //** Clean up any closed connections
compact_hportal_direct(hp);
if ((hp->n_conn == 0) && (hp->closing_conn == 0) && (tbx_stack_count(hp->que) == 0) &&
(tbx_stack_count(hp->direct_list) == 0) && (tbx_stack_count(hp->closed_que) == 0)) { //** if not used so remove it
if (tbx_stack_count(hp->conn_list) != 0) {
log_printf(0, "ERROR! DANGER WILL ROBINSON! tbx_stack_count(hp->conn_list)=%d hp=%s\n", tbx_stack_count(hp->conn_list), hp->skey);
tbx_log_flush();
assert(tbx_stack_count(hp->conn_list) == 0);
} else {
hportal_unlock(hp);
apr_hash_set(hpc->table, hp->skey, APR_HASH_KEY_STRING, NULL); //** This removes the key
destroy_hportal(hp);
}
} else {
hportal_unlock(hp);
}
}
apr_thread_mutex_unlock(hpc->lock);
}
static apt_bool_t mrcp_client_agent_disconnect_raise(mrcp_connection_agent_t *agent, mrcp_connection_t *connection)
{
mrcp_control_channel_t *channel;
void *val;
apr_hash_index_t *it = apr_hash_first(connection->pool,connection->channel_table);
/* walk through the list of channels and raise disconnect event for them */
for(; it; it = apr_hash_next(it)) {
apr_hash_this(it,NULL,NULL,&val);
channel = val;
if(!channel) continue;
if(channel->active_request) {
mrcp_client_agent_request_cancel(channel->agent,channel,channel->active_request);
channel->active_request = NULL;
if(channel->request_timer) {
apt_timer_kill(channel->request_timer);
}
}
else if(agent->vtable->on_disconnect){
agent->vtable->on_disconnect(channel);
}
}
return TRUE;
}
JNIEXPORT void JNICALL
Java_Subversion_readDirectory(JNIEnv * env, jobject obj,
jstring path)
{
svn_error_t * err;
const char * pathC = (*env)->GetStringUTFChars(env, path, 0);
/* Get the head revision. */
svn_revnum_t rev;
err = ra_lib->get_latest_revnum(ra_session, &rev, pool);
if (err) barf(err);
/* Get a list of directory entries at `repoURL'. */
apr_hash_t * dirents;
err = ra_lib->get_dir(ra_session, pathC, rev, &dirents, 0, 0, pool);
if (err) barf(err);
/* Inefficient: should be initialised once (from a static
method). */
jclass cls = (*env)->GetObjectClass(env, obj);
jmethodID mid = (*env)->GetMethodID(env, cls, "acceptDirEntry", "(Ljava/lang/String;)V");
if (!mid) abort();
/* Send the list of entries to the Java side. */
apr_hash_index_t *hi;
for (hi = apr_hash_first(pool, dirents); hi; hi = apr_hash_next (hi)) {
const char * key;
apr_hash_this (hi, (const void * *) &key, 0, 0);
(*env)->CallVoidMethod(env, obj, mid,
(*env)->NewStringUTF(env, key));
}
(*env)->ReleaseStringUTFChars(env, path, pathC);
}
static char *parse_template(nproxy_connection_t * conn, const char *file) {
apr_file_t *f;
char b[4096];
apr_size_t blen;
apr_status_t status;
/**/ char *in_p = NULL;
nn_buffer_t *bufferin;
size_t out_size;
char *out_p = NULL;
nn_buffer_t *bufferout;
bufferin = nn_buffer_init(conn->pool, 0, 4096);
if (!bufferin) {
return NULL;
}
bufferout = nn_buffer_init(conn->pool, 0, 4096);
if (bufferout == NULL) {
return NULL;
}
if (APR_STATUS_SUCCESS != apr_file_open(&f, file, APR_READ, 0, conn->pool)) {
nn_log(NN_LOG_ERROR, "Cannot open template file %s", file);
return NULL;
}
do {
blen = sizeof(b);
status = apr_file_read(f, b, &blen);
if (blen > 0) {
if (nn_buffer_append(bufferin, b, blen) != APR_STATUS_SUCCESS) {
return NULL;
}
}
} while (blen > 0);
apr_file_close(f);
if (status != APR_EOF) {
/* An error occurred reading the file */
nn_log(NN_LOG_ERROR, "Error reading template file %s", file);
return NULL;
}
/* Now we have the full content of the file. We must start evaluating our substitutions. */
nn_buffer_get_char(bufferin, &in_p);
if (in_p == NULL) {
return NULL;
}
if (conn->var_hash) {
apr_hash_index_t *hi;
for (hi = apr_hash_first(conn->pool, conn->var_hash); hi; hi = apr_hash_next(hi)) {
apr_ssize_t vlen;
const char *var = NULL;
char *val = NULL;
apr_hash_this(hi, (const void **) &var, &vlen, (void *) &val);
if (!zstr(var) && !zstr(val)) {
char *s1 = NULL;
s1 = apr_psprintf(conn->pool, "{%s}", var);
nn_buffer_get_char(bufferin, &in_p);
if (in_p) {
nn_buffer_reset(bufferout);
do_subst(in_p, bufferout, s1, val);
out_size = nn_buffer_get_char(bufferout, &out_p);
if (out_size && out_p) {
nn_buffer_reset(bufferin);
nn_buffer_append(bufferin, out_p, out_size);
}
}
}
}
}
/* We won't destroy the buffer, it will be deleted with the pool */
nn_buffer_get_char(bufferin, &in_p);
return in_p;
}
svn_error_t * SVNAuthData::cleanup_callback(svn_boolean_t *delete_cred, void *cleanup_baton,
const char *cred_kind, const char *realmstring,
apr_hash_t * hash, apr_pool_t * scratch_pool)
{
std::tuple<std::vector<std::tuple<CString, CString, SVNAuthDataInfo>>*, std::vector<std::tuple<CString, CString, SVNAuthDataInfo>>> * tupleBaton =
(std::tuple<std::vector<std::tuple<CString, CString, SVNAuthDataInfo>>*, std::vector<std::tuple<CString, CString, SVNAuthDataInfo>>>*)cleanup_baton;
auto authList = std::get<0>(*tupleBaton);
auto delList = std::get<1>(*tupleBaton);
CString s1, s2;
if (cred_kind)
s1 = CUnicodeUtils::GetUnicode(cred_kind);
if (realmstring)
s2 = CUnicodeUtils::GetUnicode(realmstring);
SVNAuthDataInfo authinfodata;
for (apr_hash_index_t *hi = apr_hash_first(scratch_pool, hash); hi; hi = apr_hash_next(hi))
{
const void *vkey;
void *val;
apr_hash_this(hi, &vkey, NULL, &val);
const char * key = (const char*)vkey;
svn_string_t *value = (svn_string_t *)val;
if (strcmp(key, SVN_CONFIG_AUTHN_PASSWORD_KEY) == 0)
{
CStringA data(value->data, (int)value->len);
authinfodata.password = CUnicodeUtils::GetUnicode(data);
}
else if (strcmp(key, SVN_CONFIG_AUTHN_PASSPHRASE_KEY) == 0)
{
CStringA data(value->data, (int)value->len);
authinfodata.passphrase = CUnicodeUtils::GetUnicode(data);
}
else if (strcmp(key, SVN_CONFIG_AUTHN_PASSTYPE_KEY) == 0)
{
CStringA data(value->data, (int)value->len);
authinfodata.passtype = CUnicodeUtils::GetUnicode(data);
}
else if (strcmp(key, SVN_CONFIG_AUTHN_USERNAME_KEY) == 0)
{
CStringA data(value->data, (int)value->len);
authinfodata.username = CUnicodeUtils::GetUnicode(data);
}
else if (strcmp(key, SVN_CONFIG_AUTHN_ASCII_CERT_KEY) == 0)
{
const svn_string_t * der_cert = nullptr;
svn_x509_certinfo_t * certinfo = nullptr;
const apr_array_header_t * hostnames = nullptr;
svn_error_t *err;
/* Convert header-less PEM to DER by undoing base64 encoding. */
der_cert = svn_base64_decode_string(value, scratch_pool);
err = svn_x509_parse_cert(&certinfo, der_cert->data, der_cert->len,
scratch_pool, scratch_pool);
if (err)
continue;
authinfodata.subject = svn_x509_certinfo_get_subject(certinfo, scratch_pool);
authinfodata.validfrom = svn_time_to_human_cstring(svn_x509_certinfo_get_valid_from(certinfo), scratch_pool);
authinfodata.validuntil = svn_time_to_human_cstring(svn_x509_certinfo_get_valid_to(certinfo), scratch_pool);
authinfodata.issuer = svn_x509_certinfo_get_issuer(certinfo, scratch_pool);
authinfodata.fingerprint = svn_checksum_to_cstring_display(svn_x509_certinfo_get_digest(certinfo), scratch_pool);
hostnames = svn_x509_certinfo_get_hostnames(certinfo);
if (hostnames && !apr_is_empty_array(hostnames))
{
int i;
svn_stringbuf_t *buf = svn_stringbuf_create_empty(scratch_pool);
for (i = 0; i < hostnames->nelts; ++i)
{
const char *hostname = APR_ARRAY_IDX(hostnames, i, const char*);
if (i > 0)
svn_stringbuf_appendbytes(buf, ", ", 2);
svn_stringbuf_appendbytes(buf, hostname, strlen(hostname));
}
authinfodata.hostname = buf->data;
}
}
else if (strcmp(key, SVN_CONFIG_AUTHN_FAILURES_KEY) == 0)
svn_error_t* CSVNLogQuery::LogReceiver ( void *baton
, svn_log_entry_t *log_entry
, apr_pool_t *pool)
{
// a few globals
static const std::string svnLog (SVN_PROP_REVISION_LOG);
static const std::string svnDate (SVN_PROP_REVISION_DATE);
static const std::string svnAuthor (SVN_PROP_REVISION_AUTHOR);
// just in case ...
if (log_entry == NULL)
return NULL;
// where to send the pre-processed in-format
SBaton* receiverBaton = reinterpret_cast<SBaton*>(baton);
ILogReceiver* receiver = receiverBaton->receiver;
assert (receiver != NULL);
// parse revprops
std::string author;
std::string message;
__time64_t timeStamp = 0;
UserRevPropArray userRevProps;
try
{
if ( (log_entry->revision != SVN_INVALID_REVNUM)
&& (log_entry->revprops != NULL))
{
for ( apr_hash_index_t *index
= apr_hash_first (pool, log_entry->revprops)
; index != NULL
; index = apr_hash_next (index))
{
// extract next entry from hash
const char* key = NULL;
ptrdiff_t keyLen;
const char** val = NULL;
apr_hash_this ( index
, reinterpret_cast<const void**>(&key)
, &keyLen
, reinterpret_cast<void**>(&val));
// decode / dispatch it
std::string name = key;
std::string value = *val;
if (name == svnLog)
message = value;
else if (name == svnAuthor)
author = value;
else if (name == svnDate)
{
timeStamp = NULL;
if (value[0])
SVN_ERR (svn_time_from_cstring (&timeStamp, *val, pool));
}
else
{
userRevProps.Add (name, value);
}
}
}
}
catch (CMemoryException * e)
{
e->Delete();
}
StandardRevProps standardRevProps (author, message, timeStamp);
// the individual changes
TChangedPaths changedPaths;
try
{
if (log_entry->changed_paths2 != NULL)
{
apr_array_header_t *sorted_paths
= svn_sort__hash (log_entry->changed_paths2, svn_sort_compare_items_as_paths, pool);
for (int i = 0, count = sorted_paths->nelts; i < count; ++i)
{
changedPaths.push_back (SChangedPath());
SChangedPath& entry = changedPaths.back();
// find the item in the hash
svn_sort__item_t *item = &(APR_ARRAY_IDX ( sorted_paths
, i
, svn_sort__item_t));
// extract the path name
entry.path = SVN::MakeUIUrlOrPath ((const char *)item->key);
// decode the action
svn_log_changed_path2_t *log_item
= (svn_log_changed_path2_t *) apr_hash_get ( log_entry->changed_paths2
, item->key
, item->klen);
static const char actionKeys[7] = "AMRDVE";
const char* actionKey = strchr (actionKeys, log_item->action);
entry.action = actionKey == NULL
? 0
: 1 << (actionKey - actionKeys);
// node type
entry.nodeKind = log_item->node_kind;
// decode copy-from info
if ( log_item->copyfrom_path
&& SVN_IS_VALID_REVNUM (log_item->copyfrom_rev))
{
entry.copyFromPath = SVN::MakeUIUrlOrPath (log_item->copyfrom_path);
entry.copyFromRev = log_item->copyfrom_rev;
}
else
{
entry.copyFromRev = 0;
}
entry.text_modified = log_item->text_modified;
entry.props_modified = log_item->props_modified;
}
}
else if (log_entry->changed_paths != NULL)
{
apr_array_header_t *sorted_paths
= svn_sort__hash (log_entry->changed_paths, svn_sort_compare_items_as_paths, pool);
for (int i = 0, count = sorted_paths->nelts; i < count; ++i)
{
changedPaths.push_back (SChangedPath());
SChangedPath& entry = changedPaths.back();
// find the item in the hash
svn_sort__item_t *item = &(APR_ARRAY_IDX ( sorted_paths
, i
, svn_sort__item_t));
// extract the path name
entry.path = SVN::MakeUIUrlOrPath ((const char *)item->key);
// decode the action
svn_log_changed_path_t *log_item
= (svn_log_changed_path_t *) apr_hash_get ( log_entry->changed_paths
, item->key
, item->klen);
static const char actionKeys[7] = "AMRDVE";
const char* actionKey = strchr (actionKeys, log_item->action);
entry.action = actionKey == NULL
? 0
: 1 << (actionKey - actionKeys);
// node type
entry.nodeKind = svn_node_unknown;
// decode copy-from info
if ( log_item->copyfrom_path
&& SVN_IS_VALID_REVNUM (log_item->copyfrom_rev))
{
entry.copyFromPath = SVN::MakeUIUrlOrPath (log_item->copyfrom_path);
entry.copyFromRev = log_item->copyfrom_rev;
}
else
{
entry.copyFromRev = 0;
}
entry.text_modified = svn_tristate_unknown;
entry.props_modified = svn_tristate_unknown;
}
}
}
catch (CMemoryException * e)
{
e->Delete();
}
// now, report the change
try
{
// treat revision 0 special: only report/show it if either the author or a message is set, or if user props are set
if ( log_entry->revision
|| userRevProps.GetCount()
|| !standardRevProps.GetAuthor().empty()
|| !standardRevProps.GetMessage().empty())
{
MergeInfo mergeInfo = { log_entry->has_children != FALSE
, log_entry->non_inheritable != FALSE
, log_entry->subtractive_merge != FALSE };
receiver->ReceiveLog ( receiverBaton->includeChanges
? &changedPaths
: NULL
, log_entry->revision
, receiverBaton->includeStandardRevProps
? &standardRevProps
: NULL
, receiverBaton->includeUserRevProps
? &userRevProps
: NULL
, &mergeInfo);
}
}
catch (SVNError& e)
{
return svn_error_create (e.GetCode(), NULL, e.GetMessage());
}
catch (...)
{
// we must not leak exceptions back into SVN
}
return NULL;
}
/* This implements the `svn_opt_subcommand_t' interface. */
svn_error_t *
svn_cl__status(apr_getopt_t *os,
void *baton,
apr_pool_t *pool)
{
svn_cl__opt_state_t *opt_state = ((svn_cl__cmd_baton_t *) baton)->opt_state;
svn_client_ctx_t *ctx = ((svn_cl__cmd_baton_t *) baton)->ctx;
apr_array_header_t *targets;
apr_pool_t *subpool;
apr_hash_t *master_cl_hash = apr_hash_make(pool);
int i;
svn_opt_revision_t rev;
struct status_baton sb;
SVN_ERR(svn_cl__args_to_target_array_print_reserved(&targets, os,
opt_state->targets,
ctx, pool));
/* Add "." if user passed 0 arguments */
svn_opt_push_implicit_dot_target(targets, pool);
/* We want our -u statuses to be against HEAD. */
rev.kind = svn_opt_revision_head;
/* The notification callback, leave the notifier as NULL in XML mode */
if (! opt_state->xml)
svn_cl__get_notifier(&ctx->notify_func2, &ctx->notify_baton2, FALSE,
FALSE, FALSE, pool);
subpool = svn_pool_create(pool);
sb.had_print_error = FALSE;
if (opt_state->xml)
{
/* If output is not incremental, output the XML header and wrap
everything in a top-level element. This makes the output in
its entirety a well-formed XML document. */
if (! opt_state->incremental)
SVN_ERR(svn_cl__xml_print_header("status", pool));
}
else
{
if (opt_state->incremental)
return svn_error_create(SVN_ERR_CL_ARG_PARSING_ERROR, NULL,
_("'incremental' option only valid in XML "
"mode"));
}
sb.detailed = (opt_state->verbose || opt_state->update);
sb.show_last_committed = opt_state->verbose;
sb.skip_unrecognized = opt_state->quiet;
sb.repos_locks = opt_state->update;
sb.xml_mode = opt_state->xml;
sb.cached_changelists = master_cl_hash;
sb.cl_pool = pool;
SVN_ERR(svn_opt__eat_peg_revisions(&targets, targets, pool));
for (i = 0; i < targets->nelts; i++)
{
const char *target = APR_ARRAY_IDX(targets, i, const char *);
svn_revnum_t repos_rev = SVN_INVALID_REVNUM;
svn_pool_clear(subpool);
SVN_ERR(svn_cl__check_cancel(ctx->cancel_baton));
if (opt_state->xml)
SVN_ERR(print_start_target_xml(svn_path_local_style(target, subpool),
subpool));
/* Retrieve a hash of status structures with the information
requested by the user. */
SVN_ERR(svn_cl__try(svn_client_status4(&repos_rev, target, &rev,
print_status, &sb,
opt_state->depth,
opt_state->verbose,
opt_state->update,
opt_state->no_ignore,
opt_state->ignore_externals,
opt_state->changelists,
ctx, subpool),
NULL, opt_state->quiet,
/* not versioned: */
SVN_ERR_WC_NOT_DIRECTORY,
SVN_NO_ERROR));
if (opt_state->xml)
SVN_ERR(print_finish_target_xml(repos_rev, subpool));
}
/* If any paths were cached because they were associatied with
changelists, we can now display them as grouped changelists. */
if (apr_hash_count(master_cl_hash) > 0)
{
apr_hash_index_t *hi;
svn_stringbuf_t *buf;
if (opt_state->xml)
buf = svn_stringbuf_create("", pool);
for (hi = apr_hash_first(pool, master_cl_hash); hi;
hi = apr_hash_next(hi))
{
const char *changelist_name;
apr_array_header_t *path_array;
const void *key;
void *val;
int j;
apr_hash_this(hi, &key, NULL, &val);
changelist_name = key;
path_array = val;
/* ### TODO: For non-XML output, we shouldn't print the
### leading \n on the first changelist if there were no
### non-changelist entries. */
if (opt_state->xml)
{
svn_stringbuf_set(buf, "");
svn_xml_make_open_tag(&buf, pool, svn_xml_normal, "changelist",
"name", changelist_name, NULL);
SVN_ERR(svn_cl__error_checked_fputs(buf->data, stdout));
}
else
SVN_ERR(svn_cmdline_printf(pool, _("\n--- Changelist '%s':\n"),
changelist_name));
for (j = 0; j < path_array->nelts; j++)
{
struct status_cache *scache =
APR_ARRAY_IDX(path_array, j, struct status_cache *);
SVN_ERR(print_status_normal_or_xml(&sb, scache->path,
scache->status, pool));
}
if (opt_state->xml)
{
svn_stringbuf_set(buf, "");
svn_xml_make_close_tag(&buf, pool, "changelist");
SVN_ERR(svn_cl__error_checked_fputs(buf->data, stdout));
}
}
}
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;
}
APR_DECLARE(apr_status_t) stomp_write(stomp_connection *connection, stomp_frame *frame, apr_pool_t* pool) {
apr_status_t rc;
#define CHECK_SUCCESS if( rc!=APR_SUCCESS ) { return rc; }
// Write the command.
rc = stomp_write_buffer(connection, frame->command, strlen(frame->command));
CHECK_SUCCESS;
rc = stomp_write_buffer(connection, "\n", 1);
CHECK_SUCCESS;
// Write the headers
if( frame->headers != NULL ) {
apr_hash_index_t *i;
const void *key;
void *value;
for (i = apr_hash_first(NULL, frame->headers); i; i = apr_hash_next(i)) {
apr_hash_this(i, &key, NULL, &value);
rc = stomp_write_buffer(connection, key, strlen(key));
CHECK_SUCCESS;
rc = stomp_write_buffer(connection, ":", 1);
CHECK_SUCCESS;
rc = stomp_write_buffer(connection, value, strlen(value));
CHECK_SUCCESS;
rc = stomp_write_buffer(connection, "\n", 1);
CHECK_SUCCESS;
}
if(frame->body_length >= 0) {
apr_pool_t *length_pool;
char *length_string;
apr_pool_create(&length_pool, pool);
rc = stomp_write_buffer(connection, "content-length:", 15);
CHECK_SUCCESS;
length_string = apr_itoa(length_pool, frame->body_length);
rc = stomp_write_buffer(connection, length_string, strlen(length_string));
CHECK_SUCCESS;
rc = stomp_write_buffer(connection, "\n", 1);
CHECK_SUCCESS;
apr_pool_destroy(length_pool);
}
}
rc = stomp_write_buffer(connection, "\n", 1);
CHECK_SUCCESS;
// Write the body.
if( frame->body != NULL ) {
int body_length = frame->body_length;
if(body_length < 0)
body_length = strlen(frame->body);
rc = stomp_write_buffer(connection, frame->body, body_length);
CHECK_SUCCESS;
}
rc = stomp_write_buffer(connection, "\0\n", 2);
CHECK_SUCCESS;
#undef CHECK_SUCCESS
return APR_SUCCESS;
}
