static char *
conf_t_check_prompt(EditLine *el) {
noit_console_closure_t ncct;
noit_conf_t_userdata_t *info;
noit_check_t *check;
static char *tl = "noit(conf)# ";
static char *pfmt = "noit(conf:%s%s%s)# ";
el_get(el, EL_USERDATA, (void *)&ncct);
if(!ncct) return tl;
info = noit_console_userdata_get(ncct, NOIT_CONF_T_USERDATA);
if(!info) return tl;
check = noit_poller_lookup(info->current_check);
if(check &&
check->target && check->target[0] &&
check->name && check->name[0])
snprintf(info->prompt, sizeof(info->prompt),
pfmt, check->target, "`", check->name);
else {
char uuid_str[37];
uuid_unparse_lower(info->current_check, uuid_str);
snprintf(info->prompt, sizeof(info->prompt), pfmt, "[", uuid_str, "]");
}
return info->prompt;
}
int
noit_conf_check_set_attr(noit_console_closure_t ncct,
int argc, char **argv,
noit_console_state_t *state, void *closure) {
struct _valid_attr_t *attrinfo = closure;
noit_conf_t_userdata_t *info;
info = noit_console_userdata_get(ncct, NOIT_CONF_T_USERDATA);
if(!info || validate_attr_set_scope(info, attrinfo)) {
nc_printf(ncct, "'%s' attribute only valid in %s scope\n",
attrinfo->name, attrinfo->scope);
return -1;
}
if(argc != 1) {
nc_printf(ncct, "set requires exactly one value\n");
return -1;
}
/* Okay, we have an attribute and it should be set/replaced on the
* current path.
*/
if(replace_attr(ncct, info, attrinfo, argv[0])) {
return -1;
}
/* So, we updated an attribute, so we need to reload all checks
* that are descendent-or-self of this node.
*/
if(!strncmp(info->path, "/checks", strlen("/checks")))
refresh_subchecks(ncct, info);
if(!strncmp(info->path, "/filtersets", strlen("/filtersets")))
noit_refresh_filtersets(ncct, info);
return 0;
}
int
noit_console_config_unsetconfig(noit_console_closure_t ncct,
int argc, char **argv,
noit_console_state_t *state, void *closure) {
noit_conf_t_userdata_t *info;
info = noit_console_userdata_get(ncct, NOIT_CONF_T_USERDATA);
if(argc != 1) {
nc_printf(ncct, "one argument required.\n");
return -1;
}
/* Okay, we have an child name and it should be culled from
* current path/config.
*/
if(replace_config(ncct, info, argv[0], NULL)) {
return -1;
}
/* So, we updated an attribute, so we need to reload all checks
* that are descendent-or-self of this node.
*/
refresh_subchecks(ncct, info);
return 0;
}
static int
noit_console_filter_show(noit_console_closure_t ncct,
int argc, char **argv,
noit_console_state_t *state,
void *closure) {
noit_conf_t_userdata_t *info;
char xpath[1024];
xmlNodePtr fsnode;
noit_conf_section_t *rules;
int i, rulecnt;
info = noit_console_userdata_get(ncct, NOIT_CONF_T_USERDATA);
snprintf(xpath, sizeof(xpath), "/%s",
info->path);
fsnode = noit_conf_get_section(NULL, xpath);
if(!fsnode) {
nc_printf(ncct, "internal error\n");
return -1;
}
rules = noit_conf_get_sections(fsnode, "rule", &rulecnt);
for(i=0; i<rulecnt; i++) {
char val[256];
val[0] = '\0';
noit_conf_get_stringbuf(rules[i], "@type", val, sizeof(val));
nc_printf(ncct, "Rule %d [%s]:\n", i+1, val);
#define DUMP_ATTR(a) do { \
char *vstr; \
noit_conf_section_t ht; \
int cnt; \
ht = noit_conf_get_sections(rules[i], #a, &cnt); \
if(ht && cnt) { \
nc_printf(ncct, "\t%s: hash match of %d items\n", #a, cnt); \
} \
else if(noit_conf_get_string(rules[i], "@" #a, &vstr)) { \
nc_printf(ncct, "\t%s: /%s/\n", #a, val); \
free(vstr); \
} \
free(ht); \
} while(0)
DUMP_ATTR(target);
DUMP_ATTR(module);
DUMP_ATTR(name);
DUMP_ATTR(metric);
}
if(rules) free(rules);
return 0;
}
static char *
conf_t_filterset_prompt(EditLine *el) {
noit_console_closure_t ncct;
noit_conf_t_userdata_t *info;
static char *tl = "noit(conf)# ";
static char *pfmt = "noit(conf:filterset:%.*s%s)# ";
int max_space, namelen;
el_get(el, EL_USERDATA, (void *)&ncct);
if(!ncct) return tl;
info = noit_console_userdata_get(ncct, NOIT_CONF_T_USERDATA);
if(!info) return tl;
max_space = sizeof(info->prompt) - strlen(pfmt) + 6 - 1;
namelen = strlen(info->filter_name);
if(namelen > max_space)
snprintf(info->prompt, sizeof(info->prompt), pfmt,
max_space - 3, info->filter_name, "...");
else
snprintf(info->prompt, sizeof(info->prompt), pfmt,
namelen, info->filter_name, "");
return info->prompt;
}
static int
noit_console_config_show(noit_console_closure_t ncct,
int argc, char **argv,
noit_console_state_t *state, void *closure) {
noit_hash_iter iter = NOIT_HASH_ITER_ZERO;
const char *k;
int klen;
void *data;
int i, cnt, titled = 0, cliplen = 0;
const char *path = "", *basepath = NULL;
char xpath[1024];
noit_conf_t_userdata_t *info = NULL;
noit_hash_table *config;
xmlXPathObjectPtr pobj = NULL;
xmlXPathContextPtr xpath_ctxt = NULL, current_ctxt;
xmlDocPtr master_config = NULL;
xmlNodePtr node = NULL;
noit_conf_xml_xpath(&master_config, &xpath_ctxt);
if(argc > 1) {
nc_printf(ncct, "too many arguments\n");
return -1;
}
info = noit_console_userdata_get(ncct, NOIT_CONF_T_USERDATA);
if(info && info->path) path = basepath = info->path;
if(!info && argc == 0) {
nc_printf(ncct, "argument required when not in configuration mode\n");
return -1;
}
if(argc == 1) path = argv[0];
if(!basepath) basepath = path;
/* { / } is a special case */
if(!strcmp(basepath, "/")) basepath = "";
if(!strcmp(path, "/")) path = "";
if(!master_config) {
nc_printf(ncct, "no config\n");
return -1;
}
/* { / } is the only path that will end with a /
* in XPath { / / * } means something _entirely different than { / * }
* Ever notice how it is hard to describe xpath in C comments?
*/
/* We don't want to show the root node */
cliplen = strlen("/noit/");
/* If we are in configuration mode
* and we are without an argument or the argument is absolute,
* clip the current path off */
if(info && (argc == 0 || path[0] != '/')) cliplen += strlen(basepath);
if(!path[0] || path[0] == '/') /* base only, or absolute path requested */
snprintf(xpath, sizeof(xpath), "/noit%s/@*", path);
else
snprintf(xpath, sizeof(xpath), "/noit%s/%s/@*", basepath, path);
current_ctxt = xpath_ctxt;
pobj = xmlXPathEval((xmlChar *)xpath, current_ctxt);
if(!pobj || pobj->type != XPATH_NODESET) {
nc_printf(ncct, "no such object\n");
goto bad;
}
cnt = xmlXPathNodeSetGetLength(pobj->nodesetval);
titled = 0;
for(i=0; i<cnt; i++) {
node = (noit_conf_section_t)xmlXPathNodeSetItem(pobj->nodesetval, i);
if(!strcmp((char *)node->name, "check")) continue;
if(node->children && node->children == xmlGetLastChild(node) &&
xmlNodeIsText(node->children)) {
if(!titled++) nc_printf(ncct, "== Section Settings ==\n");
nc_printf(ncct, "%s: %s\n", xmlGetNodePath(node) + cliplen,
xmlXPathCastNodeToString(node->children));
}
}
xmlXPathFreeObject(pobj);
/* Print out all the config settings */
if(!path[0] || path[0] == '/') /* base only, or absolute path requested */
snprintf(xpath, sizeof(xpath), "/noit%s", path);
else
snprintf(xpath, sizeof(xpath), "/noit%s/%s", basepath, path);
pobj = xmlXPathEval((xmlChar *)xpath, current_ctxt);
if(!pobj || pobj->type != XPATH_NODESET) {
nc_printf(ncct, "no such object\n");
goto bad;
}
cnt = xmlXPathNodeSetGetLength(pobj->nodesetval);
if(cnt > 0) {
node = (noit_conf_section_t)xmlXPathNodeSetItem(pobj->nodesetval, 0);
titled = 0;
config = noit_conf_get_hash(node, "config");
while(noit_hash_next(config, &iter, &k, &klen, &data)) {
if(!titled++) nc_printf(ncct, "== Section [Aggregated] Config ==\n");
nc_printf(ncct, "config::%s: %s\n", k, (const char *)data);
}
noit_hash_destroy(config, free, free);
free(config);
}
xmlXPathFreeObject(pobj);
/* _shorten string_ turning last { / @ * } to { / * } */
if(!path[0] || path[0] == '/') /* base only, or absolute path requested */
snprintf(xpath, sizeof(xpath), "/noit%s/*", path);
else
snprintf(xpath, sizeof(xpath), "/noit%s/%s/*", basepath, path);
pobj = xmlXPathEval((xmlChar *)xpath, current_ctxt);
if(!pobj || pobj->type != XPATH_NODESET) {
nc_printf(ncct, "no such object\n");
goto bad;
}
cnt = xmlXPathNodeSetGetLength(pobj->nodesetval);
titled = 0;
for(i=0; i<cnt; i++) {
node = (noit_conf_section_t)xmlXPathNodeSetItem(pobj->nodesetval, i);
if(!strcmp((char *)node->name, "check")) continue;
if(!strcmp((char *)node->name, "filterset")) continue;
if(!strcmp((char *)xmlGetNodePath(node) + cliplen, "config")) continue;
if(!(node->children && node->children == xmlGetLastChild(node) &&
xmlNodeIsText(node->children))) {
if(!titled++) nc_printf(ncct, "== Subsections ==\n");
nc_printf(ncct, "%s\n", xmlGetNodePath(node) + cliplen);
}
}
titled = 0;
for(i=0; i<cnt; i++) {
node = (noit_conf_section_t)xmlXPathNodeSetItem(pobj->nodesetval, i);
if(!strcmp((char *)node->name, "filterset")) {
xmlAttr *attr;
char *filter_name = NULL;
for(attr=node->properties; attr; attr = attr->next) {
if(!strcmp((char *)attr->name, "name"))
filter_name = (char *)xmlXPathCastNodeToString(attr->children);
}
if(filter_name) {
nc_printf(ncct, "filterset[@name=\"%s\"]\n", filter_name);
xmlFree(filter_name);
}
else nc_printf(ncct, "fitlerset\n");
}
else if(!strcmp((char *)node->name, "check")) {
int busted = 1;
xmlAttr *attr;
char *uuid_str = "undefined";
if(!titled++) nc_printf(ncct, "== Checks ==\n");
for(attr=node->properties; attr; attr = attr->next) {
if(!strcmp((char *)attr->name, "uuid"))
uuid_str = (char *)xmlXPathCastNodeToString(attr->children);
}
if(uuid_str) {
uuid_t checkid;
nc_printf(ncct, "check[@uuid=\"%s\"] ", uuid_str);
if(uuid_parse(uuid_str, checkid) == 0) {
noit_check_t *check;
check = noit_poller_lookup(checkid);
if(check) {
busted = 0;
nc_printf(ncct, "%s`%s`%s", check->target, check->module, check->name);
}
}
}
else
nc_printf(ncct, "%s ", xmlGetNodePath(node) + cliplen);
if(busted) nc_printf(ncct, "[check not in running system]");
nc_write(ncct, "\n", 1);
}
}
xmlXPathFreeObject(pobj);
return 0;
bad:
if(pobj) xmlXPathFreeObject(pobj);
return -1;
}
static int
noit_console_config_nocheck(noit_console_closure_t ncct,
int argc, char **argv,
noit_console_state_t *state, void *closure) {
int i, cnt;
const char *err = "internal error";
noit_conf_t_userdata_t *info;
xmlXPathObjectPtr pobj = NULL;
xmlXPathContextPtr xpath_ctxt = NULL;
char xpath[1024];
uuid_t checkid;
noit_conf_xml_xpath(NULL, &xpath_ctxt);
if(argc < 1) {
nc_printf(ncct, "requires one argument\n");
return -1;
}
info = noit_console_userdata_get(ncct, NOIT_CONF_T_USERDATA);
if(noit_console_mkcheck_xpath(xpath, sizeof(xpath), info, argv[0])) {
nc_printf(ncct, "could not find check '%s'\n", argv[0]);
return -1;
}
pobj = xmlXPathEval((xmlChar *)xpath, xpath_ctxt);
if(!pobj || pobj->type != XPATH_NODESET ||
xmlXPathNodeSetIsEmpty(pobj->nodesetval)) {
err = "no checks found";
goto bad;
}
cnt = xmlXPathNodeSetGetLength(pobj->nodesetval);
for(i=0; i<cnt; i++) {
xmlNodePtr node;
char *uuid_conf;
node = (noit_conf_section_t)xmlXPathNodeSetItem(pobj->nodesetval, i);
uuid_conf = (char *)xmlGetProp(node, (xmlChar *)"uuid");
if(!uuid_conf || uuid_parse(uuid_conf, checkid)) {
nc_printf(ncct, "%s has invalid or missing UUID!\n",
(char *)xmlGetNodePath(node) + strlen("/noit"));
}
else {
if(argc > 1) {
int j;
for(j=1;j<argc;j++)
xmlUnsetProp(node, (xmlChar *)argv[j]);
} else {
nc_printf(ncct, "descheduling %s\n", uuid_conf);
noit_poller_deschedule(checkid);
xmlUnlinkNode(node);
}
noit_conf_mark_changed();
}
}
if(argc > 1) {
noit_poller_process_checks(xpath);
noit_poller_reload(xpath);
}
nc_printf(ncct, "rebuilding causal map...\n");
noit_poller_make_causal_map();
if(pobj) xmlXPathFreeObject(pobj);
return 0;
bad:
if(pobj) xmlXPathFreeObject(pobj);
nc_printf(ncct, "%s\n", err);
return -1;
}
static int
noit_console_show_check(noit_console_closure_t ncct,
int argc, char **argv,
noit_console_state_t *state, void *closure) {
int i, cnt;
noit_conf_t_userdata_t *info;
char xpath[1024];
xmlXPathObjectPtr pobj = NULL;
xmlXPathContextPtr xpath_ctxt = NULL;
noit_conf_xml_xpath(NULL, &xpath_ctxt);
if(argc > 1) {
nc_printf(ncct, "requires zero or one arguments\n");
return -1;
}
info = noit_console_userdata_get(ncct, NOIT_CONF_T_USERDATA);
/* We many not be in conf-t mode -- that's fine */
if(noit_console_mkcheck_xpath(xpath, sizeof(xpath), info,
argc ? argv[0] : NULL)) {
nc_printf(ncct, "could not find check '%s'\n", argv[0]);
return -1;
}
pobj = xmlXPathEval((xmlChar *)xpath, xpath_ctxt);
if(!pobj || pobj->type != XPATH_NODESET ||
xmlXPathNodeSetIsEmpty(pobj->nodesetval)) {
nc_printf(ncct, "no checks found\n");
goto out;
}
cnt = xmlXPathNodeSetGetLength(pobj->nodesetval);
if(info && cnt != 1) {
nc_printf(ncct, "Ambiguous check specified\n");
goto out;
}
for(i=0; i<cnt; i++) {
noit_hash_iter iter = NOIT_HASH_ITER_ZERO;
const char *k;
int klen;
void *data;
uuid_t checkid;
noit_check_t *check;
noit_hash_table *config;
xmlNodePtr node, anode, mnode = NULL;
char *uuid_conf;
char *module, *value;
node = (noit_conf_section_t)xmlXPathNodeSetItem(pobj->nodesetval, i);
uuid_conf = (char *)xmlGetProp(node, (xmlChar *)"uuid");
if(!uuid_conf || uuid_parse(uuid_conf, checkid)) {
nc_printf(ncct, "%s has invalid or missing UUID!\n",
(char *)xmlGetNodePath(node) + strlen("/noit"));
continue;
}
nc_printf(ncct, "==== %s ====\n", uuid_conf);
#define MYATTR(a,n,b) _noit_conf_get_string(node, &(n), "@" #a, &(b))
#define INHERIT(a,n,b) \
_noit_conf_get_string(node, &(n), "ancestor-or-self::node()/@" #a, &(b))
#define SHOW_ATTR(a) do { \
anode = NULL; \
value = NULL; \
INHERIT(a, anode, value); \
nc_attr_show(ncct, #a, node, anode, value); \
} while(0)
if(!INHERIT(module, mnode, module)) module = NULL;
if(MYATTR(name, anode, value))
nc_printf(ncct, " name: %s\n", value);
else
nc_printf(ncct, " name: %s [from module]\n", module ? module : "[undef]");
nc_attr_show(ncct, "module", node, mnode, module);
SHOW_ATTR(target);
SHOW_ATTR(period);
SHOW_ATTR(timeout);
SHOW_ATTR(oncheck);
SHOW_ATTR(filterset);
SHOW_ATTR(disable);
/* Print out all the config settings */
config = noit_conf_get_hash(node, "config");
while(noit_hash_next(config, &iter, &k, &klen, &data)) {
nc_printf(ncct, " config::%s: %s\n", k, (const char *)data);
}
noit_hash_destroy(config, free, free);
free(config);
check = noit_poller_lookup(checkid);
if(!check) {
nc_printf(ncct, " ERROR: not in running system\n");
}
else {
int idx = 0;
nc_printf(ncct, " currently: ");
if(NOIT_CHECK_RUNNING(check)) nc_printf(ncct, "%srunning", idx++?",":"");
if(NOIT_CHECK_KILLED(check)) nc_printf(ncct, "%skilled", idx++?",":"");
if(!NOIT_CHECK_CONFIGURED(check)) nc_printf(ncct, "%sunconfig", idx++?",":"");
if(NOIT_CHECK_DISABLED(check)) nc_printf(ncct, "%sdisabled", idx++?",":"");
if(!idx) nc_printf(ncct, "idle");
nc_write(ncct, "\n", 1);
if(check->stats.current.whence.tv_sec == 0) {
nc_printf(ncct, " last run: never\n");
}
else {
stats_t *c = &check->stats.current;
struct timeval now, diff;
gettimeofday(&now, NULL);
sub_timeval(now, c->whence, &diff);
nc_printf(ncct, " last run: %0.3f seconds ago\n",
diff.tv_sec + (diff.tv_usec / 1000000.0));
nc_printf(ncct, " availability/state: %s/%s\n",
noit_check_available_string(c->available),
noit_check_state_string(c->state));
nc_printf(ncct, " status: %s\n", c->status ? c->status : "[[null]]");
nc_printf(ncct, " metrics:\n");
memset(&iter, 0, sizeof(iter));
while(noit_hash_next(&c->metrics, &iter, &k, &klen, &data)) {
char buff[256];
noit_boolean filtered;
noit_stats_snprint_metric(buff, sizeof(buff), (metric_t *)data);
filtered = !noit_apply_filterset(check->filterset, check, (metric_t *)data);
nc_printf(ncct, " %c%s\n", filtered ? '*' : ' ', buff);
}
}
}
}
out:
if(pobj) xmlXPathFreeObject(pobj);
return 0;
}
static int
noit_console_check(noit_console_closure_t ncct,
int argc, char **argv,
noit_console_state_t *state, void *closure) {
int cnt;
noit_conf_t_userdata_t *info;
char xpath[1024], newuuid_str[37];
char *uuid_conf, *wanted;
uuid_t checkid;
xmlXPathContextPtr xpath_ctxt = NULL;
xmlXPathObjectPtr pobj = NULL;
xmlNodePtr node = NULL;
noit_boolean creating_new = noit_false;
if(closure) {
char *fake_argv[1] = { ".." };
noit_console_state_pop(ncct, 0, argv, NULL, NULL);
noit_console_config_cd(ncct, 1, fake_argv, NULL, NULL);
}
noit_conf_xml_xpath(NULL, &xpath_ctxt);
if(argc < 1) {
nc_printf(ncct, "requires at least one argument\n");
return -1;
}
if(argc % 2 == 0) {
nc_printf(ncct, "wrong number of arguments\n");
return -1;
}
info = noit_console_userdata_get(ncct, NOIT_CONF_T_USERDATA);
wanted = strcmp(argv[0], "new") ? argv[0] : NULL;
if(info && !wanted) {
/* We are creating a new node */
uuid_t out;
creating_new = noit_true;
if(strncmp(info->path, "/checks/", strlen("/checks/")) &&
strcmp(info->path, "/checks")) {
nc_printf(ncct, "New checks must be under /checks/\n");
return -1;
}
if(noit_conf_mkcheck_under(info->path, argc - 1, argv + 1, out)) {
nc_printf(ncct, "Error creating new check\n");
return -1;
}
newuuid_str[0] = '\0';
uuid_unparse_lower(out, newuuid_str);
wanted = newuuid_str;
}
/* We many not be in conf-t mode -- that's fine */
if(noit_console_mkcheck_xpath(xpath, sizeof(xpath), info, wanted)) {
nc_printf(ncct, "could not find check '%s'\n", wanted);
return -1;
}
pobj = xmlXPathEval((xmlChar *)xpath, xpath_ctxt);
if(!pobj || pobj->type != XPATH_NODESET ||
xmlXPathNodeSetIsEmpty(pobj->nodesetval)) {
nc_printf(ncct, "no checks found for '%s'\n", wanted);
goto out;
}
cnt = xmlXPathNodeSetGetLength(pobj->nodesetval);
if(info && cnt != 1) {
nc_printf(ncct, "Ambiguous check specified\n");
goto out;
}
node = (noit_conf_section_t)xmlXPathNodeSetItem(pobj->nodesetval, 0);
uuid_conf = (char *)xmlGetProp(node, (xmlChar *)"uuid");
if(!uuid_conf || uuid_parse(uuid_conf, checkid)) {
nc_printf(ncct, "%s has invalid or missing UUID!\n",
(char *)xmlGetNodePath(node) + strlen("/noit"));
goto out;
}
if(argc > 1 && !creating_new)
if(noit_config_check_update_attrs(node, argc - 1, argv + 1))
nc_printf(ncct, "Partially successful, error setting some attributes\n");
if(info) {
if(info->path) free(info->path);
info->path = strdup((char *)xmlGetNodePath(node) + strlen("/noit"));
uuid_copy(info->current_check, checkid);
if(argc > 1) refresh_subchecks(ncct, info);
if(state) {
noit_console_state_push_state(ncct, state);
noit_console_state_init(ncct);
}
goto out;
}
out:
if(pobj) xmlXPathFreeObject(pobj);
return 0;
}
static int
noit_console_filter_configure(noit_console_closure_t ncct,
int argc, char **argv,
noit_console_state_t *state,
void *closure) {
xmlNodePtr parent, fsnode = NULL;
int rv = -1;
noit_conf_t_userdata_t *info;
char xpath[1024];
info = noit_console_userdata_get(ncct, NOIT_CONF_T_USERDATA);
if(!info) {
nc_printf(ncct, "internal error\n");
goto cleanup;
}
if(strncmp(info->path, "/filtersets/", strlen("/filtersets/")) &&
strcmp(info->path, "/filtersets")) {
nc_printf(ncct, "filterset only allows inside /filtersets (not %s)\n",
info->path);
goto cleanup;
}
if(argc != 1) {
nc_printf(ncct, "filterset requires one argument\n");
goto cleanup;
}
snprintf(xpath, sizeof(xpath), "/%s", info->path);
parent = noit_conf_get_section(NULL, xpath);
if(!parent) {
nc_printf(ncct, "internal error, can't final current working path\n");
goto cleanup;
}
snprintf(xpath, sizeof(xpath), "filterset[@name=\"%s\"]", argv[0]);
fsnode = noit_conf_get_section(parent, xpath);
if(closure) {
int removed;
removed = noit_filter_remove(fsnode);
nc_printf(ncct, "%sremoved filterset '%s'\n",
removed ? "" : "failed to ", argv[0]);
if(removed) {
xmlUnlinkNode(fsnode);
xmlFreeNode(fsnode);
}
rv = !removed;
goto cleanup;
}
if(!fsnode) {
void *vfs;
nc_printf(ncct, "Cannot find filterset '%s'\n", argv[0]);
LOCKFS();
if(noit_hash_retrieve(filtersets, argv[0], strlen(argv[0]), &vfs)) {
UNLOCKFS();
nc_printf(ncct, "filter of the same name already exists\n");
goto cleanup;
}
UNLOCKFS();
/* Fine the parent path */
fsnode = xmlNewNode(NULL, (xmlChar *)"filterset");
xmlSetProp(fsnode, (xmlChar *)"name", (xmlChar *)argv[0]);
xmlAddChild(parent, fsnode);
nc_printf(ncct, "created new filterset\n");
}
if(info) {
char *xmlpath = NULL;
if(info->path) free(info->path);
xmlpath = (char *)xmlGetNodePath(fsnode);
info->path = strdup(xmlpath + strlen("/noit"));
free(xmlpath);
strlcpy(info->filter_name, argv[0], sizeof(info->filter_name));
if(state) {
noit_console_state_push_state(ncct, state);
noit_console_state_init(ncct);
}
}
cleanup:
return rv;
}
static int
noit_console_rule_configure(noit_console_closure_t ncct,
int argc, char **argv,
noit_console_state_t *state,
void *closure) {
xmlNodePtr fsnode = NULL;
noit_conf_t_userdata_t *info;
char xpath[1024];
info = noit_console_userdata_get(ncct, NOIT_CONF_T_USERDATA);
snprintf(xpath, sizeof(xpath), "/%s",
info->path);
fsnode = noit_conf_get_section(NULL, xpath);
if(!fsnode) {
nc_printf(ncct, "internal error");
return -1;
}
if(closure) {
int rulenum;
xmlNodePtr byebye;
/* removing a rule */
if(argc != 1) {
nc_printf(ncct, "requires one argument\n");
return -1;
}
rulenum = atoi(argv[0]);
snprintf(xpath, sizeof(xpath), "rule[%d]", rulenum);
byebye = noit_conf_get_section(fsnode, xpath);
if(!byebye) {
nc_printf(ncct, "cannot find rule\n");
return -1;
}
xmlUnlinkNode(byebye);
xmlFreeNode(byebye);
nc_printf(ncct, "removed\n");
}
else {
xmlNodePtr (*add_func)(xmlNodePtr, xmlNodePtr);
xmlNodePtr add_arg, new_rule;
int i, needs_type = 1;
if(argc < 1 || argc % 2) {
nc_printf(ncct, "even number of arguments required\n");
return -1;
}
if(!strcmp(argv[0], "before") || !strcmp(argv[0], "after")) {
int rulenum = atoi(argv[1]);
snprintf(xpath, sizeof(xpath), "rule[%d]", rulenum);
add_arg = noit_conf_get_section(fsnode, xpath);
if(!add_arg) {
nc_printf(ncct, "%s rule not found\n", xpath);
return -1;
}
if(*argv[0] == 'b') add_func = xmlAddPrevSibling;
else add_func = xmlAddNextSibling;
argc -= 2;
argv += 2;
}
else {
add_func = xmlAddChild;
add_arg = fsnode;
}
for(i=0;i<argc;i+=2) {
if(!strcmp(argv[i], "type")) needs_type = 0;
else if(strcmp(argv[i], "target") && strcmp(argv[i], "module") &&
strcmp(argv[i], "name") && strcmp(argv[i], "metric")) {
nc_printf(ncct, "unknown attribute '%s'\n", argv[i]);
return -1;
}
}
if(needs_type) {
nc_printf(ncct, "type <allow|deny> is required\n");
return -1;
}
new_rule = xmlNewNode(NULL, (xmlChar *)"rule");
for(i=0;i<argc;i+=2)
xmlSetProp(new_rule, (xmlChar *)argv[i], (xmlChar *)argv[i+1]);
add_func(add_arg, new_rule);
noit_filter_compile_add((noit_conf_section_t *)fsnode);
}
return 0;
}
