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); }