void
noit_control_dispatch_delegate(eventer_func_t listener_dispatch,
u_int32_t cmd,
eventer_func_t delegate_dispatch) {
u_int32_t *cmd_copy;
eventer_func_t *handler_copy;
void *vdelegation_table;
noit_hash_table *delegation_table;
if(!noit_hash_retrieve(&listener_commands,
(char *)&listener_dispatch, sizeof(listener_dispatch),
&vdelegation_table)) {
delegation_table = calloc(1, sizeof(*delegation_table));
handler_copy = malloc(sizeof(*handler_copy));
*handler_copy = listener_dispatch;
noit_hash_store(&listener_commands,
(char *)handler_copy, sizeof(*handler_copy),
delegation_table);
}
else
delegation_table = (noit_hash_table *)vdelegation_table;
cmd_copy = malloc(sizeof(*cmd_copy));
*cmd_copy = cmd;
handler_copy = malloc(sizeof(*handler_copy));
*handler_copy = delegate_dispatch;
noit_hash_replace(delegation_table,
(char *)cmd_copy, sizeof(*cmd_copy),
handler_copy,
free, free);
}
int eventer_name_callback_ext(const char *name,
eventer_func_t f,
void (*fn)(char *,int,eventer_t,void *),
void *cl) {
void **fptr = malloc(sizeof(*fptr));
*fptr = (void *)f;
noit_hash_replace(&__name_to_func, strdup(name), strlen(name),
(void *)f, free, NULL);
struct callback_details *cd;
cd = calloc(1, sizeof(*cd));
cd->simple_name = strdup(name);
cd->functional_name = fn;
cd->closure = cl;
noit_hash_replace(&__func_to_name, (char *)fptr, sizeof(*fptr), cd,
free, free_callback_details);
return 0;
}
int
noit_check_interpolate_register_oper_fn(const char *name,
intperpolate_oper_fn f) {
noit_hash_replace(&interpolation_operators,
strdup(name), strlen(name),
(void *)f,
free, NULL);
return 0;
}
static int
ip_acl_onload(noit_image_t *self) {
int i, cnt;
noit_conf_section_t *acl_c;
ip_acl_module_id = noit_check_register_module("ip_acl");
if(ip_acl_module_id < 0) return -1;
acl_c = noit_conf_get_sections(NULL, "/noit/acls//acl", &cnt);
if(acl_c) {
for(i=0; i<cnt; i++) {
char *name;
int j, rcnt, arcnt = 0;
noit_conf_section_t *rule_c;
if(noit_conf_get_string(acl_c[i], "@name", &name)) {
rule_c = noit_conf_get_sections(acl_c[i], "rule", &rcnt);
if(rule_c) {
btrie *acl = calloc(1, sizeof(*acl));
for(j=0; j<rcnt; j++) {
int mask = -1, rv;
char dirstr[16] = "unspecified";
char *cp, target[256] = "";
union {
struct in_addr addr4;
struct in6_addr addr6;
} a;
noit_conf_get_stringbuf(rule_c[j], "self::node()", target, sizeof(target));
if(NULL != (cp = strchr(target, '/'))) {
*cp++ = '\0';
mask = atoi(cp);
}
if(!noit_conf_get_stringbuf(rule_c[j], "@type", dirstr, sizeof(dirstr)) ||
(strcmp(dirstr, "deny") && strcmp(dirstr, "allow"))) {
noitL(noit_error, "Unknown acl rule type \"%s\" in acl \"%s\"\n",
dirstr, name);
}
else if(inet_pton(AF_INET, target, &a) == 1) {
if(mask == -1) mask = 32;
noit_add_route_ipv4(acl, &a.addr4, mask, strcmp(dirstr, "allow") ? DENY_PTR : ALLOW_PTR);
arcnt++;
}
else if(inet_pton(AF_INET6, target, &a) == 1) {
if(mask == -1) mask = 128;
noit_add_route_ipv6(acl, &a.addr6, mask, strcmp(dirstr, "allow") ? DENY_PTR : ALLOW_PTR);
arcnt++;
}
}
noitL(noit_error, "ACL %s/%p -> %d/%d rules\n", name, acl, arcnt, rcnt);
noit_hash_replace(&acls, name, strlen(name), acl, free, free_btrie);
free(rule_c);
}
}
}
free(acl_c);
}
return 0;
}
void
noit_log_stream_set_property(noit_log_stream_t ls,
const char *prop, const char *v) {
if(!ls) return;
if(!ls->config) {
ls->config = calloc(1, sizeof(*ls->config));
noit_hash_init(ls->config);
}
noit_hash_replace(ls->config, prop, strlen(prop), (void *)v, free, free);
}
void
noit_console_userdata_set(struct __noit_console_closure *ncct,
const char *name, void *data,
state_userdata_free_func_t freefunc) {
noit_console_userdata_t *item;
item = calloc(1, sizeof(*item));
item->name = strdup(name);
item->data = data;
item->freefunc = freefunc;
noit_hash_replace(&ncct->userdata, item->name, strlen(item->name),
item, NULL, noit_console_userdata_free);
}
static int
storage_node_quick_lookup(const char *uuid_str, const char *remote_cn,
int *sid_out, int *storagenode_id_out,
const char **remote_cn_out,
const char **fqdn_out, const char **dsn_out) {
/* only called from the main thread -- no safety issues */
void *vstr;
const char *actual_remote_cn = NULL;
if(remote_cn) actual_remote_cn = remote_cn;
uuid_t id;
uuid_parse((char *)uuid_str, id);
if(noit_hash_retrieve(&uuid_map, (const char *)id, UUID_SIZE, &vstr)) {
char *str = (char *)vstr;
if(remote_cn && strcmp(str, remote_cn)) {
/* replace with new remote */
void *key = malloc(UUID_SIZE);
memcpy(key, id, UUID_SIZE);
actual_remote_cn = strdup(remote_cn);
noit_hash_replace(&uuid_map, key, UUID_SIZE, (void *)actual_remote_cn,
free, free);
}
}
else if(remote_cn) {
void *key = malloc(UUID_SIZE);
memcpy(key, id, UUID_SIZE);
noit_hash_store(&uuid_map, key, UUID_SIZE, strdup(remote_cn));
}
if(!actual_remote_cn) actual_remote_cn = "[[null]]";
if(sid_out) *sid_out = 0;
if(storagenode_id_out) *storagenode_id_out = 0;
if(remote_cn_out) *remote_cn_out = actual_remote_cn;
if(fqdn_out) *fqdn_out = "";
if(dsn_out) *dsn_out = "";
return 0;
}
noit_check_t *
noit_fire_check(xmlNodePtr attr, xmlNodePtr config, const char **error) {
char *target = NULL, *name = NULL, *module = NULL, *filterset = NULL;
int timeout = 0;
noit_module_t *m;
noit_check_t *c = NULL;
xmlNodePtr a, co;
noit_hash_table *conf_hash = NULL;
for(a = attr->children; a; a = a->next) {
if(!strcmp((char *)a->name, "target"))
target = (char *)xmlNodeGetContent(a);
else if(!strcmp((char *)a->name, "name"))
name = (char *)xmlNodeGetContent(a);
else if(!strcmp((char *)a->name, "module"))
module = (char *)xmlNodeGetContent(a);
else if(!strcmp((char *)a->name, "filterset"))
filterset = (char *)xmlNodeGetContent(a);
else if(!strcmp((char *)a->name, "timeout")) {
char *timeout_str = (char *)xmlNodeGetContent(a);
timeout = atoi(timeout_str);
free(timeout_str);
}
}
m = noit_module_lookup(module);
if(!m) {
*error = "cannot find requested module";
goto error;
}
conf_hash = calloc(1, sizeof(*conf_hash));
for(co = config->children; co; co = co->next) {
char *name, *val;
xmlChar *tmp_val;
name = strdup((char *)co->name);
tmp_val = xmlNodeGetContent(co);
val = strdup(tmp_val ? (char *)tmp_val : "");
noit_hash_replace(conf_hash, name, strlen(name), val, free, free);
xmlFree(tmp_val);
}
if(!m->initiate_check) {
*error = "that module cannot run checks";
goto error;
}
c = calloc(1, sizeof(*c));
noit_check_update(c, target, name, filterset,
conf_hash, 0, timeout, NULL, NP_TRANSIENT);
c->module = strdup(module);
uuid_generate(c->checkid);
c->flags |= NP_DISABLED; /* this is hack to know we haven't run it yet */
if(NOIT_CHECK_SHOULD_RESOLVE(c))
noit_check_resolve(c);
error:
if(conf_hash) {
noit_hash_destroy(conf_hash, free, free);
free(conf_hash);
}
if(target) xmlFree(target);
if(name) xmlFree(name);
if(module) xmlFree(module);
if(filterset) xmlFree(filterset);
return c;
}
void
noit_filter_compile_add(noit_conf_section_t setinfo) {
noit_conf_section_t *rules;
int j, fcnt;
char filterset_name[256];
filterset_t *set;
if(!noit_conf_get_stringbuf(setinfo, "@name",
filterset_name, sizeof(filterset_name))) {
noitL(noit_error,
"filterset with no name, skipping as it cannot be referenced.\n");
return;
}
set = calloc(1, sizeof(*set));
set->ref_cnt = 1;
set->name = strdup(filterset_name);
rules = noit_conf_get_sections(setinfo, "rule", &fcnt);
/* Here we will work through the list backwards pushing the rules on
* the front of the list. That way we can simply walk them in order
* for the application process.
*/
noitL(noit_debug, "Compiling filterset '%s'\n", set->name);
for(j=fcnt-1; j>=0; j--) {
filterrule_t *rule;
char buffer[256];
if(!noit_conf_get_stringbuf(rules[j], "@type", buffer, sizeof(buffer)) ||
(strcmp(buffer, "accept") && strcmp(buffer, "allow") && strcmp(buffer, "deny"))) {
noitL(noit_error, "rule must have type 'accept' or 'allow' or 'deny'\n");
continue;
}
noitL(noit_debug, "Prepending %s into %s\n", buffer, set->name);
rule = calloc(1, sizeof(*rule));
rule->type = (!strcmp(buffer, "accept") || !strcmp(buffer, "allow")) ?
NOIT_FILTER_ACCEPT : NOIT_FILTER_DENY;
/* Compile our rules */
#define RULE_COMPILE(rname) do { \
char *longre = NULL; \
if(noit_conf_get_string(rules[j], "@" #rname, &longre)) { \
const char *error; \
int erroffset; \
rule->rname = pcre_compile(longre, 0, &error, &erroffset, NULL); \
if(!rule->rname) { \
noitL(noit_error, "set '%s' rule '%s: %s' compile failed: %s\n", \
set->name, #rname, longre, error ? error : "???"); \
} \
else { \
rule->rname##_e = pcre_study(rule->rname, 0, &error); \
} \
free(longre); \
} \
} while(0)
RULE_COMPILE(target);
RULE_COMPILE(module);
RULE_COMPILE(name);
RULE_COMPILE(metric);
rule->next = set->rules;
set->rules = rule;
}
free(rules);
LOCKFS();
noit_hash_replace(filtersets, set->name, strlen(set->name), (void *)set,
NULL, filterset_free);
UNLOCKFS();
}
noit_check_t *
noit_fire_check(xmlNodePtr attr, xmlNodePtr config, const char **error) {
char *target = NULL, *name = NULL, *module = NULL, *filterset = NULL;
char *resolve_rtype = NULL;
int timeout = 0, flags = NP_TRANSIENT, i, mod_cnt;
noit_module_t *m;
noit_check_t *c = NULL;
xmlNodePtr a, co;
noit_hash_table *conf_hash = NULL;
noit_hash_table **moptions = NULL;
for(a = attr->children; a; a = a->next) {
if(!strcmp((char *)a->name, "target"))
target = (char *)xmlNodeGetContent(a);
else if(!strcmp((char *)a->name, "name"))
name = (char *)xmlNodeGetContent(a);
else if(!strcmp((char *)a->name, "module"))
module = (char *)xmlNodeGetContent(a);
else if(!strcmp((char *)a->name, "filterset"))
filterset = (char *)xmlNodeGetContent(a);
else if(!strcmp((char *)a->name, "timeout")) {
char *timeout_str = (char *)xmlNodeGetContent(a);
timeout = atoi(timeout_str);
free(timeout_str);
} else if(!strcmp((char *)a->name, "resolve_rtype"))
resolve_rtype = (char *)xmlNodeGetContent(a);
}
m = noit_module_lookup(module);
if(!m) {
*error = "cannot find requested module";
goto error;
}
conf_hash = calloc(1, sizeof(*conf_hash));
if(config) {
for(co = config->children; co; co = co->next) {
char *name, *val;
xmlChar *tmp_val;
name = strdup((char *)co->name);
tmp_val = xmlNodeGetContent(co);
val = strdup(tmp_val ? (char *)tmp_val : "");
noit_hash_replace(conf_hash, name, strlen(name), val, free, free);
xmlFree(tmp_val);
}
}
mod_cnt = noit_check_registered_module_cnt();
if(mod_cnt > 0) {
moptions = alloca(mod_cnt * sizeof(*moptions));
memset(moptions, 0, mod_cnt * sizeof(*moptions));
for(i=0; i<mod_cnt; i++) {
const char *name;
noit_conf_section_t checks;
name = noit_check_registered_module(i);
checks = noit_conf_get_section(NULL, "/noit/checks");
if(name) moptions[i] = noit_conf_get_namespaced_hash(checks, "config", name);
}
}
if(!m->initiate_check) {
*error = "that module cannot run checks";
goto error;
}
flags |= noit_calc_rtype_flag(resolve_rtype);
c = calloc(1, sizeof(*c));
noit_check_update(c, target, name, filterset,
conf_hash, moptions, 0, timeout, NULL, flags);
c->module = strdup(module);
uuid_generate(c->checkid);
c->flags |= NP_DISABLED; /* this is hack to know we haven't run it yet */
if(NOIT_CHECK_SHOULD_RESOLVE(c))
noit_check_resolve(c);
error:
if(conf_hash) {
noit_hash_destroy(conf_hash, free, free);
free(conf_hash);
}
if(moptions) {
for(i=0; i<mod_cnt; i++) {
if(moptions[i]) {
noit_hash_destroy(moptions[i], free, free);
free(moptions[i]);
}
}
}
if(target) xmlFree(target);
if(name) xmlFree(name);
if(module) xmlFree(module);
if(filterset) xmlFree(filterset);
if (resolve_rtype) xmlFree(resolve_rtype);
return c;
}
void
__stats_add_metric(stats_t *newstate, metric_t *m) {
noit_hash_replace(&newstate->metrics, m->metric_name, strlen(m->metric_name),
m, NULL, __free_metric);
}
