int cmd_unbind_key_exec(struct cmd *self, unused struct cmd_ctx *ctx) { struct args *args = self->args; struct key_binding *bd; int key; if (args_has(args, 'a')) { while (!SPLAY_EMPTY(&key_bindings)) { bd = SPLAY_ROOT(&key_bindings); SPLAY_REMOVE(key_bindings, &key_bindings, bd); cmd_list_free(bd->cmdlist); xfree(bd); } return (0); } key = key_string_lookup_string(args->argv[0]); if (key == KEYC_NONE) { ctx->error(ctx, "unknown key: %s", args->argv[0]); return (-1); } if (args_has(args, 't')) return (cmd_unbind_key_table(self, ctx, key)); if (!args_has(args, 'n')) key |= KEYC_PREFIX; key_bindings_remove(key); return (0); }
void systrace_cleanpolicy(struct policy *policy) { struct filter *filter; struct policy_syscall *pflq; int i; /* Set the default policy to ask */ for (i = 0; i < INTERCEPT_MAXSYSCALLNR; i++) policy->kerneltable[i] = ICPOLICY_ASK; while ((filter = TAILQ_FIRST(&policy->prefilters)) != NULL) { TAILQ_REMOVE(&policy->prefilters, filter, policy_next); filter_free(filter); } while ((filter = TAILQ_FIRST(&policy->filters)) != NULL) { TAILQ_REMOVE(&policy->filters, filter, policy_next); filter_free(filter); } while ((pflq = SPLAY_ROOT(&policy->pflqs)) != NULL) { SPLAY_REMOVE(syscalltree, &policy->pflqs, pflq); while ((filter = TAILQ_FIRST(&pflq->flq)) != NULL) { TAILQ_REMOVE(&pflq->flq, filter, next); filter_free(filter); } free(pflq); } }
void filter_free(struct filtertree *filters) { struct filter *filter; while ((filter = SPLAY_ROOT(filters)) != NULL) { SPLAY_REMOVE(filtertree, filters, filter); free(filter); } free(filters); }
void tree_merge(struct tree *dst, struct tree *src) { struct treeentry *entry; while (!SPLAY_EMPTY(src)) { entry = SPLAY_ROOT(src); SPLAY_REMOVE(tree, src, entry); if (SPLAY_INSERT(tree, dst, entry)) errx(1, "tree_merge: duplicate"); } }
void key_bindings_clean(void) { struct key_binding *bd; while (!SPLAY_EMPTY(&dead_key_bindings)) { bd = SPLAY_ROOT(&dead_key_bindings); SPLAY_REMOVE(key_bindings, &dead_key_bindings, bd); cmd_list_free(bd->cmdlist); xfree(bd); } }
void aux_free(void *arg) { struct aux *aux = arg; struct auxtree *tree = &aux->tree; struct auxkey *key; while ((key = SPLAY_ROOT(tree)) != NULL) { SPLAY_REMOVE(auxtree, tree, key); free(key); } free(arg); }
void options_free(struct options *oo) { struct options_entry *o; while (!SPLAY_EMPTY(&oo->tree)) { o = SPLAY_ROOT(&oo->tree); SPLAY_REMOVE(options_tree, &oo->tree, o); xfree(o->name); if (o->type == OPTIONS_STRING) xfree(o->value.string); xfree(o); } }
void mode_key_free_trees(void) { const struct mode_key_table *mtab; struct mode_key_binding *mbind; for (mtab = mode_key_tables; mtab->name != NULL; mtab++) { while (!SPLAY_EMPTY(mtab->tree)) { mbind = SPLAY_ROOT(mtab->tree); SPLAY_REMOVE(mode_key_tree, mtab->tree, mbind); xfree(mbind); } } }
int tree_root(struct tree *t, uint64_t *id, void **data) { struct treeentry *entry; entry = SPLAY_ROOT(&t->tree); if (entry == NULL) return (0); if (id) *id = entry->id; if (data) *data = entry->data; return (1); }
void tree_merge(struct tree *dst, struct tree *src) { struct treeentry *entry; while (!SPLAY_EMPTY(&src->tree)) { entry = SPLAY_ROOT(&src->tree); SPLAY_REMOVE(_tree, &src->tree, entry); if (SPLAY_INSERT(_tree, &dst->tree, entry)) errx(1, "tree_merge: duplicate"); } dst->count += src->count; src->count = 0; }
void dict_merge(struct dict *dst, struct dict *src) { struct dictentry *entry; while (!SPLAY_EMPTY(&src->dict)) { entry = SPLAY_ROOT(&src->dict); SPLAY_REMOVE(_dict, &src->dict, entry); if (SPLAY_INSERT(_dict, &dst->dict, entry)) errx(1, "dict_merge: duplicate"); } dst->count += src->count; src->count = 0; }
int dict_root(struct dict *d, const char **k, void **data) { struct dictentry *entry; entry = SPLAY_ROOT(&d->dict); if (entry == NULL) return (0); if (k) *k = entry->key; if (data) *data = entry->data; return (1); }
int main(int argc, char **argv) { struct node *tmp, *ins; int i, max, min; SPLAY_INIT(&root); for (i = 0; i < ITER; i++) { tmp = malloc(sizeof(struct node)); if (tmp == NULL) err(1, "malloc"); do { tmp->key = arc4random_uniform(MAX-MIN); tmp->key += MIN; } while (SPLAY_FIND(tree, &root, tmp) != NULL); if (i == 0) max = min = tmp->key; else { if (tmp->key > max) max = tmp->key; if (tmp->key < min) min = tmp->key; } if (SPLAY_INSERT(tree, &root, tmp) != NULL) errx(1, "SPLAY_INSERT failed"); } ins = SPLAY_MIN(tree, &root); if (ins->key != min) errx(1, "min does not match"); tmp = ins; ins = SPLAY_MAX(tree, &root); if (ins->key != max) errx(1, "max does not match"); if (SPLAY_REMOVE(tree, &root, tmp) != tmp) errx(1, "SPLAY_REMOVE failed"); for (i = 0; i < ITER - 1; i++) { tmp = SPLAY_ROOT(&root); if (tmp == NULL) errx(1, "SPLAY_ROOT error"); if (SPLAY_REMOVE(tree, &root, tmp) != tmp) errx(1, "SPLAY_REMOVE error"); free(tmp); } exit(0); }
void purge_config(uint8_t what) { struct listener *l; struct map *m; struct rule *r; struct ssl *s; struct mapel *me; if (what & PURGE_LISTENERS) { while ((l = TAILQ_FIRST(env->sc_listeners)) != NULL) { TAILQ_REMOVE(env->sc_listeners, l, entry); free(l); } free(env->sc_listeners); env->sc_listeners = NULL; } if (what & PURGE_MAPS) { while ((m = TAILQ_FIRST(env->sc_maps)) != NULL) { TAILQ_REMOVE(env->sc_maps, m, m_entry); while ((me = TAILQ_FIRST(&m->m_contents))) { TAILQ_REMOVE(&m->m_contents, me, me_entry); free(me); } free(m); } free(env->sc_maps); env->sc_maps = NULL; } if (what & PURGE_RULES) { while ((r = TAILQ_FIRST(env->sc_rules)) != NULL) { TAILQ_REMOVE(env->sc_rules, r, r_entry); free(r); } free(env->sc_rules); env->sc_rules = NULL; } if (what & PURGE_SSL) { while ((s = SPLAY_ROOT(env->sc_ssl)) != NULL) { SPLAY_REMOVE(ssltree, env->sc_ssl, s); free(s->ssl_cert); free(s->ssl_key); free(s); } free(env->sc_ssl); env->sc_ssl = NULL; } }
void options_free(struct options *oo) { struct options_entry *o; while (!SPLAY_EMPTY(&oo->tree)) { o = SPLAY_ROOT(&oo->tree); SPLAY_REMOVE(options_tree, &oo->tree, o); xfree(o->name); if (o->type == OPTIONS_STRING) xfree(o->str); else if (o->type == OPTIONS_DATA) o->freefn(o->data); xfree(o); } }
int dict_poproot(struct dict *d, void **data) { struct dictentry *entry; entry = SPLAY_ROOT(&d->dict); if (entry == NULL) return (0); if (data) *data = entry->data; SPLAY_REMOVE(_dict, &d->dict, entry); free(entry); d->count -= 1; return (1); }
int tree_poproot(struct tree *t, uint64_t *id, void **data) { struct treeentry *entry; entry = SPLAY_ROOT(t); if (entry == NULL) return (0); if (id) *id = entry->id; if (data) *data = entry->data; SPLAY_REMOVE(tree, t, entry); free(entry); return (1); }
int tree_poproot(struct tree *t, uint64_t *id, void **data) { struct treeentry *entry; entry = SPLAY_ROOT(&t->tree); if (entry == NULL) return (0); if (id) *id = entry->id; if (data) *data = entry->data; SPLAY_REMOVE(_tree, &t->tree, entry); free(entry); t->count -= 1; return (1); }
int cmd_unbind_key_exec(struct cmd *self, unused struct cmd_ctx *ctx) { struct cmd_unbind_key_data *data = self->data; struct key_binding *bd; if (data == NULL) return (0); if (data->flag_all) { while (!SPLAY_EMPTY(&key_bindings)) { bd = SPLAY_ROOT(&key_bindings); SPLAY_REMOVE(key_bindings, &key_bindings, bd); cmd_list_free(bd->cmdlist); xfree(bd); } } else { if (data->tablename != NULL) return (cmd_unbind_key_table(self, ctx)); key_bindings_remove(data->key); } return (0); }