void mtev_skiplist_add_index(mtev_skiplist *sl,
mtev_skiplist_comparator_t comp,
mtev_skiplist_comparator_t compk) {
mtev_skiplist_node *m = NULL;
mtev_skiplist *ni;
int icount=0;
mtev_skiplist_find(sl->index, (void *)comp, &m);
if(m) return; /* Index already there! */
ni = (mtev_skiplist *)malloc(sizeof(mtev_skiplist));
mtev_skiplisti_init(ni);
mtev_skiplist_set_compare(ni, comp, compk);
/* Build the new index... This can be expensive! */
m = mtev_skiplist_insert(sl->index, ni);
while(m->prev) m=m->prev, icount++;
for(m=mtev_skiplist_getlist(sl); m; mtev_skiplist_next(sl, &m)) {
int j=icount-1;
mtev_skiplist_node *nsln;
nsln = mtev_skiplist_insert(ni, m->data);
/* skip from main index down list */
while(j>0) m=m->nextindex, j--;
/* insert this node in the indexlist after m */
nsln->nextindex = m->nextindex;
if(m->nextindex) m->nextindex->previndex = nsln;
nsln->previndex = m;
m->nextindex = nsln;
}
}
int noit_check_resolver_fetch(const char *target, char *buff, int len,
uint8_t prefer_family) {
int i, rv;
uint8_t progression[2];
dns_cache_node *n;
void *vnode;
buff[0] = '\0';
if(!target) return -1;
progression[0] = prefer_family;
progression[1] = (prefer_family == AF_INET) ? AF_INET6 : AF_INET;
if(mtev_hash_retrieve(&etc_hosts_cache, target, strlen(target), &vnode)) {
static_host_node *node = vnode;
for(i=0; i<2; i++) {
switch(progression[i]) {
case AF_INET:
if(node->has_ip4) {
inet_ntop(AF_INET, &node->ip4, buff, len);
return 1;
}
break;
case AF_INET6:
if(node->has_ip6) {
inet_ntop(AF_INET6, &node->ip6, buff, len);
return 1;
}
break;
}
}
}
rv = -1;
DCLOCK();
n = mtev_skiplist_find(&nc_dns_cache, target, NULL);
if(n != NULL) {
if(n->last_updated == 0) goto leave; /* not resolved yet */
rv = n->ip4_cnt + n->ip6_cnt;
for(i=0; i<2; i++) {
switch(progression[i]) {
case AF_INET:
if(n->ip4_cnt > 0) {
inet_ntop(AF_INET, &n->ip4[0], buff, len);
goto leave;
}
break;
case AF_INET6:
if(n->ip6_cnt > 0) {
inet_ntop(AF_INET6, &n->ip6[0], buff, len);
goto leave;
}
break;
}
}
}
leave:
DCUNLOCK();
return rv;
}
static void fetch_and_kill_by_check(int64_t check_no) {
struct proc_state *ps;
ps = mtev_skiplist_find(&active_procs, &check_no, NULL);
if(ps) {
ps->cancelled = 1;
kill(ps->pid, SIGKILL);
}
}
static int
noit_console_manip_dns_cache(mtev_console_closure_t ncct,
int argc, char **argv,
mtev_console_state_t *dstate,
void *closure) {
int i;
if(argc == 0) {
nc_printf(ncct, "dns_cache what?\n");
return 0;
}
DCLOCK();
if(closure == NULL) {
/* adding */
for(i=0;i<argc;i++) {
dns_cache_node *n;
n = mtev_skiplist_find(&nc_dns_cache, argv[i], NULL);
if(NULL != n) {
nc_printf(ncct, " == Already in system ==\n");
nc_print_dns_cache_node(ncct, argv[i], n);
}
else {
nc_printf(ncct, "%s submitted.\n", argv[i]);
noit_check_resolver_remind_internal(argv[i], mtev_false);
}
}
}
else {
for(i=0;i<argc;i++) {
dns_cache_node *n;
n = mtev_skiplist_find(&nc_dns_cache, argv[i], NULL);
if(NULL != n) {
if(n->lookup_inflight_v4 || n->lookup_inflight_v6)
nc_printf(ncct, "%s is currently resolving and cannot be removed.\n");
else {
mtev_skiplist_remove(&nc_dns_cache, argv[i], dns_cache_node_free);
nc_printf(ncct, "%s removed.\n", argv[i]);
}
}
else nc_printf(ncct, "%s not in system.\n", argv[i]);
}
}
DCUNLOCK();
return 0;
}
int mtev_skiplist_remove_compare(mtev_skiplist *sli,
const void *data,
mtev_freefunc_t myfree,
mtev_skiplist_comparator_t comp) {
mtev_skiplist_node *m;
mtev_skiplist *sl;
if(comp==sli->comparek || !sli->index) {
sl = sli;
} else {
mtev_skiplist_find(sli->index, (void *)comp, &m);
mtevAssert(m);
sl= (mtev_skiplist *) m->data;
}
mtev_skiplisti_find_compare(sl, data, &m, NULL, NULL, sl->comparek);
if(!m) return 0;
while(m->previndex) m=m->previndex;
return mtev_skiplisti_remove(m->sl, m, myfree);
}
static void
noit_check_resolver_remind_internal(const char *target,
mtev_boolean needs_lock) {
dns_cache_node *n;
if(!target) return;
if(needs_lock) DCLOCK();
n = mtev_skiplist_find(&nc_dns_cache, target, NULL);
if(n != NULL) {
n->last_needed = time(NULL);
if(needs_lock) DCUNLOCK();
return;
}
n = calloc(1, sizeof(*n));
n->target = strdup(target);
n->last_needed = time(NULL);
mtev_skiplist_insert(&nc_dns_cache, n);
if(needs_lock) DCUNLOCK();
}
void *mtev_skiplist_find_neighbors_compare(mtev_skiplist *sli,
const void *data,
mtev_skiplist_node **iter,
mtev_skiplist_node **prev,
mtev_skiplist_node **next,
mtev_skiplist_comparator_t comp) {
mtev_skiplist_node *m = NULL;
mtev_skiplist *sl;
if(iter) *iter = NULL;
if(prev) *prev = NULL;
if(next) *next = NULL;
if(comp==sli->compare || !sli->index) {
sl = sli;
} else {
mtev_skiplist_find(sli->index, (void *)comp, &m);
mtevAssert(m);
sl= (mtev_skiplist *) m->data;
}
mtev_skiplisti_find_compare(sl, data, iter, prev, next, sl->comparek);
return (iter && *iter)?((*iter)->data):NULL;
}
static int
noit_console_show_dns_cache(mtev_console_closure_t ncct,
int argc, char **argv,
mtev_console_state_t *dstate,
void *closure) {
int i;
DCLOCK();
if(argc == 0) {
mtev_skiplist_node *sn;
for(sn = mtev_skiplist_getlist(&nc_dns_cache); sn;
mtev_skiplist_next(&nc_dns_cache, &sn)) {
dns_cache_node *n = (dns_cache_node *)sn->data;
nc_print_dns_cache_node(ncct, n->target, n);
}
}
for(i=0;i<argc;i++) {
dns_cache_node *n;
n = mtev_skiplist_find(&nc_dns_cache, argv[i], NULL);
nc_print_dns_cache_node(ncct, argv[i], n);
}
DCUNLOCK();
return 0;
}
