void avl_traverse(const avl_node_t *root, void (*fun)(bag_elem_t))
{
if (root) {
avl_traverse(root->left, fun);
(*fun)(root->elem);
avl_traverse(root->right, fun);
}
}
/*
* Called from a source, who wants to see if the pool has any connections
* in stock for it.
* Returns NULL on errors.
* Assert Class: 3
*/
connection_t *
pool_get_my_clients (const source_t *source)
{
avl_traverser trav = {0};
connection_t *clicon = NULL;
if (!source) {
xa_debug (1, "WARNING: pool_get_my_clients() called with NULL source!");
return NULL;
}
/* Acquire mutex lock */
pool_lock_write ();
/* Search for clients for this source */
while ((clicon = avl_traverse (pool, &trav)))
if (clicon->food.client->source == source)
break;
/* If found, remove it from the pool */
if (clicon)
if (avl_delete (pool, clicon) == NULL)
xa_debug (1, "WARNING: pool_get_my_clients(): Connection Pool Security Comprimised!");
/* Release mutex lock */
pool_unlock_write ();
return clicon;
}
int avl_traverse_lock(avl_tree_lock *tree, int (*callback)(void * /*entry*/, void * /*data*/), void *data) {
int ret;
avl_read_lock(tree);
ret = avl_traverse(&tree->avl_tree, callback, data);
avl_unlock(tree);
return ret;
}
int avl_traverse_lock(avl_tree_lock *t, int (*callback)(void *entry, void *data), void *data) {
int ret;
avl_read_lock(t);
ret = avl_traverse(&t->avl_tree, callback, data);
avl_unlock(t);
return ret;
}
void get_current_stats_proc (statistics_t *stat, int lock)
{
avl_traverser trav = {0};
time_t ec = 0, cc = 0;
connection_t *travcon;
zero_stats(stat);
if (lock)
thread_mutex_lock(&info.double_mutex);
thread_mutex_lock(&info.source_mutex);
ec = (time_t)tree_time(info.sources);
while ((travcon = avl_traverse(info.sources, &trav))) {
thread_mutex_lock(&travcon->food.source->mutex);
cc += (time_t)tree_time(travcon->food.source->clients);
thread_mutex_unlock(&travcon->food.source->mutex);
}
thread_mutex_unlock(&info.source_mutex);
if (lock)
thread_mutex_unlock(&info.double_mutex);
stat->client_connect_time = cc;
stat->source_connect_time = ec;
}
void stdout_update(int nb_results, int line_by_line)
{
struct display_data display_data;
display_data.duration = logtop_timespan(gl_env.logtop);
display_data.qte_of_elements = logtop_qte_of_elements(gl_env.logtop);
if (display_data.duration == 0)
display_data.duration = 1;
if (line_by_line)
{
avl_traverse(gl_env.logtop, nb_results,
display_result,
&display_data);
printf("\n");
}
else
{
display_header(&display_data);
avl_traverse(gl_env.logtop, nb_results,
display_line,
&display_data);
}
}
// the main method for registering an access
int registry_request_access_json(RRDHOST *host, struct web_client *w, char *person_guid, char *machine_guid, char *url, char *name, time_t when) {
if(unlikely(!registry.enabled))
return registry_json_disabled(host, w, "access");
// ------------------------------------------------------------------------
// verify the browser supports cookies
if(registry.verify_cookies_redirects > 0 && !person_guid[0]) {
buffer_flush(w->response.data);
registry_set_cookie(w, REGISTRY_VERIFY_COOKIES_GUID);
w->response.data->contenttype = CT_APPLICATION_JSON;
buffer_sprintf(w->response.data, "{ \"status\": \"redirect\", \"registry\": \"%s\" }", registry.registry_to_announce);
return 200;
}
if(unlikely(person_guid[0] && !strcmp(person_guid, REGISTRY_VERIFY_COOKIES_GUID)))
person_guid[0] = '\0';
// ------------------------------------------------------------------------
registry_lock();
REGISTRY_PERSON *p = registry_request_access(person_guid, machine_guid, url, name, when);
if(!p) {
registry_json_header(host, w, "access", REGISTRY_STATUS_FAILED);
registry_json_footer(w);
registry_unlock();
return 412;
}
// set the cookie
registry_set_person_cookie(w, p);
// generate the response
registry_json_header(host, w, "access", REGISTRY_STATUS_OK);
buffer_sprintf(w->response.data, ",\n\t\"person_guid\": \"%s\",\n\t\"urls\": [", p->guid);
struct registry_json_walk_person_urls_callback c = { p, NULL, w, 0 };
avl_traverse(&p->person_urls, registry_json_person_url_callback, &c);
buffer_strcat(w->response.data, "\n\t]\n");
registry_json_footer(w);
registry_unlock();
return 200;
}
REGISTRY_MACHINE *registry_request_machine(char *person_guid, char *machine_guid, char *url, char *request_machine, time_t when) {
(void)when;
char mbuf[GUID_LEN + 1];
REGISTRY_PERSON *p = NULL;
REGISTRY_MACHINE *m = NULL;
REGISTRY_PERSON_URL *pu = registry_verify_request(person_guid, machine_guid, url, &p, &m);
if(!pu || !p || !m) return NULL;
// make sure the machine GUID is valid
if(regenerate_guid(request_machine, mbuf) == -1) {
info("Registry Machine URLs request: invalid machine GUID, person: '%s', machine '%s', url '%s', request machine '%s'", p->guid, m->guid, pu->url->url, request_machine);
return NULL;
}
request_machine = mbuf;
// make sure the machine exists
m = registry_machine_find(request_machine);
if(!m) {
info("Registry Machine URLs request: machine not found, person: '%s', machine '%s', url '%s', request machine '%s'", p->guid, machine_guid, pu->url->url, request_machine);
return NULL;
}
// Verify the user has in the past accessed this machine
// We will walk through the PERSON_URLs to find the machine
// linking to our machine
// a structure to pass to the dictionary_get_all() callback handler
struct machine_request_callback_data rdata = { m, NULL };
// request a walk through on the dictionary
avl_traverse(&p->person_urls, machine_request_callback, &rdata);
if(rdata.result)
return m;
return NULL;
}
// the main method for switching user identity
int registry_request_switch_json(RRDHOST *host, struct web_client *w, char *person_guid, char *machine_guid, char *url, char *new_person_guid, time_t when) {
if(!registry.enabled)
return registry_json_disabled(host, w, "switch");
(void)url;
(void)when;
registry_lock();
REGISTRY_PERSON *op = registry_person_find(person_guid);
if(!op) {
registry_json_header(host, w, "switch", REGISTRY_STATUS_FAILED);
registry_json_footer(w);
registry_unlock();
return 430;
}
REGISTRY_PERSON *np = registry_person_find(new_person_guid);
if(!np) {
registry_json_header(host, w, "switch", REGISTRY_STATUS_FAILED);
registry_json_footer(w);
registry_unlock();
return 431;
}
REGISTRY_MACHINE *m = registry_machine_find(machine_guid);
if(!m) {
registry_json_header(host, w, "switch", REGISTRY_STATUS_FAILED);
registry_json_footer(w);
registry_unlock();
return 432;
}
struct registry_person_url_callback_verify_machine_exists_data data = { m, 0 };
// verify the old person has access to this machine
avl_traverse(&op->person_urls, registry_person_url_callback_verify_machine_exists, &data);
if(!data.count) {
registry_json_header(host, w, "switch", REGISTRY_STATUS_FAILED);
registry_json_footer(w);
registry_unlock();
return 433;
}
// verify the new person has access to this machine
data.count = 0;
avl_traverse(&np->person_urls, registry_person_url_callback_verify_machine_exists, &data);
if(!data.count) {
registry_json_header(host, w, "switch", REGISTRY_STATUS_FAILED);
registry_json_footer(w);
registry_unlock();
return 434;
}
// set the cookie of the new person
// the user just switched identity
registry_set_person_cookie(w, np);
// generate the response
registry_json_header(host, w, "switch", REGISTRY_STATUS_OK);
buffer_sprintf(w->response.data, ",\n\t\"person_guid\": \"%s\"", np->guid);
registry_json_footer(w);
registry_unlock();
return 200;
}
void bag_traverse(const bag_t *bag, void (*fun)(bag_elem_t))
{
avl_traverse(bag->root, fun);
}
