static int
rest_get_noit_config(noit_http_rest_closure_t *restc,
int npats, char **pats) {
noit_http_session_ctx *ctx = restc->http_ctx;
char *xml = NULL;
if(npats != 0) {
noit_http_response_server_error(ctx, "text/xml");
noit_http_response_end(ctx);
return 0;
}
xml = ingestor->get_noit_config(restc->remote_cn);
if(xml == NULL) {
char buff[1024];
snprintf(buff, sizeof(buff), "<error><remote_cn>%s</remote_cn>"
"<row_count>%d</row_count></error>\n",
restc->remote_cn, 0);
noit_http_response_append(ctx, buff, strlen(buff));
noit_http_response_not_found(ctx, "text/xml");
}
else {
noit_http_response_append(ctx, xml, strlen(xml));
noit_http_response_ok(ctx, "text/xml");
}
if(xml) free(xml);
noit_http_response_end(ctx);
return 0;
}
int
noit_rest_eventer_logs(noit_http_rest_closure_t *restc, int n, char **p) {
char *endptr = NULL;
const char *since_s, *last_s;
const char *jsonstr;
char errbuf[128];
unsigned long long since;
int last = 0;
struct json_object *doc;
noit_log_stream_t ls;
noit_http_request *req = noit_http_session_request(restc->http_ctx);
since_s = noit_http_request_querystring(req, "since");
if(since_s) since = strtoull(since_s, &endptr, 10);
last_s = noit_http_request_querystring(req, "last");
if(last_s) last = atoi(last_s);
assert(n==1);
ls = noit_log_stream_find(p[0]);
if(!ls || strcmp(noit_log_stream_get_type(ls),"memory"))
goto not_found;
doc = json_object_new_array();
if(endptr != since_s)
noit_log_memory_lines_since(ls, since, json_spit_log, doc);
else
noit_log_memory_lines(ls, last, json_spit_log, doc);
noit_http_response_ok(restc->http_ctx, "application/json");
jsonstr = json_object_to_json_string(doc);
noit_http_response_append(restc->http_ctx, jsonstr, strlen(jsonstr));
noit_http_response_append(restc->http_ctx, "\n", 1);
json_object_put(doc);
noit_http_response_end(restc->http_ctx);
return 0;
not_found:
doc = json_object_new_object();
snprintf(errbuf, sizeof(errbuf), "log '%s' not found", p[0]);
json_object_object_add(doc, "error", json_object_new_string(errbuf));
jsonstr = json_object_to_json_string(doc);
noit_http_response_not_found(restc->http_ctx, "application/json");
noit_http_response_append(restc->http_ctx, jsonstr, strlen(jsonstr));
noit_http_response_append(restc->http_ctx, "\n", 1);
json_object_put(doc);
noit_http_response_end(restc->http_ctx);
return 0;
}
static int rest_delete_feed(noit_http_rest_closure_t *restc,
int npats, char **pats) {
noit_http_session_ctx *ctx = restc->http_ctx;
const char *err = "unknown error";
const char *jpath_with_sub;
char jlogpath[PATH_MAX], *cp;
int rv;
noit_log_stream_t feed;
jlog_ctx *jctx;
feed = noit_log_stream_find("feed");
if(!feed) { err = "cannot find feed"; goto error; }
jpath_with_sub = noit_log_stream_get_path(feed);
strlcpy(jlogpath, jpath_with_sub, sizeof(jlogpath));
cp = strchr(jlogpath, '(');
if(cp) *cp = '\0';
jctx = jlog_new(jlogpath);
rv = jlog_ctx_remove_subscriber(jctx, pats[0]);
jlog_ctx_close(jctx);
if(rv < 0) {
err = jlog_ctx_err_string(jctx);
goto error;
}
/* removed or note, we should do a sweeping cleanup */
jlog_clean(jlogpath);
if(rv == 0) {
noit_http_response_not_found(ctx, "text/plain");
noit_http_response_end(ctx);
return 0;
}
noit_http_response_standard(ctx, 204, "OK", "text/plain");
noit_http_response_end(ctx);
return 0;
error:
noit_http_response_server_error(ctx, "text/plain");
noit_http_response_append(ctx, err, strlen(err));
noit_http_response_end(ctx);
return 0;
}
static int
rest_show_filter(noit_http_rest_closure_t *restc,
int npats, char **pats) {
noit_http_session_ctx *ctx = restc->http_ctx;
xmlDocPtr doc = NULL;
xmlNodePtr node, root;
char xpath[1024];
int error_code = 500;
if(npats != 2) goto error;
snprintf(xpath, sizeof(xpath), "//filtersets%sfilterset[@name=\"%s\"]",
pats[0], pats[1]);
node = noit_conf_get_section(NULL, xpath);
if(!node) goto not_found;
doc = xmlNewDoc((xmlChar *)"1.0");
root = xmlCopyNode(node, 1);
xmlDocSetRootElement(doc, root);
noit_http_response_ok(ctx, "text/xml");
noit_http_response_xml(ctx, doc);
noit_http_response_end(ctx);
goto cleanup;
not_found:
noit_http_response_not_found(ctx, "text/html");
noit_http_response_end(ctx);
goto cleanup;
error:
noit_http_response_standard(ctx, error_code, "ERROR", "text/html");
noit_http_response_end(ctx);
goto cleanup;
cleanup:
if(doc) xmlFreeDoc(doc);
return 0;
}
static int
rest_delete_filter(noit_http_rest_closure_t *restc,
int npats, char **pats) {
noit_http_session_ctx *ctx = restc->http_ctx;
xmlNodePtr node;
char xpath[1024];
int error_code = 500;
if(npats != 2) goto error;
snprintf(xpath, sizeof(xpath), "//filtersets%sfilterset[@name=\"%s\"]",
pats[0], pats[1]);
node = noit_conf_get_section(NULL, xpath);
if(!node) goto not_found;
if(noit_filter_remove(node) == 0) goto not_found;
CONF_REMOVE(node);
xmlUnlinkNode(node);
xmlFreeNode(node);
if(noit_conf_write_file(NULL) != 0)
noitL(noit_error, "local config write failed\n");
noit_conf_mark_changed();
noit_http_response_ok(ctx, "text/html");
noit_http_response_end(ctx);
goto cleanup;
not_found:
noit_http_response_not_found(ctx, "text/html");
noit_http_response_end(ctx);
goto cleanup;
error:
noit_http_response_standard(ctx, error_code, "ERROR", "text/html");
noit_http_response_end(ctx);
goto cleanup;
cleanup:
return 0;
}
static int
rest_show_check(noit_http_rest_closure_t *restc,
int npats, char **pats) {
noit_http_session_ctx *ctx = restc->http_ctx;
xmlXPathObjectPtr pobj = NULL;
xmlXPathContextPtr xpath_ctxt = NULL;
xmlDocPtr doc = NULL;
xmlNodePtr node, root, attr, config, state, tmp, anode;
uuid_t checkid;
noit_check_t *check;
char xpath[1024], *uuid_conf, *module, *value;
int rv, cnt, error_code = 500;
noit_hash_iter iter = NOIT_HASH_ITER_ZERO;
const char *k;
int klen;
void *data;
noit_hash_table *configh;
if(npats != 2) goto error;
rv = noit_check_xpath(xpath, sizeof(xpath), pats[0], pats[1]);
if(rv == 0) goto not_found;
if(rv < 0) goto error;
noit_conf_xml_xpath(NULL, &xpath_ctxt);
pobj = xmlXPathEval((xmlChar *)xpath, xpath_ctxt);
if(!pobj || pobj->type != XPATH_NODESET ||
xmlXPathNodeSetIsEmpty(pobj->nodesetval)) goto not_found;
cnt = xmlXPathNodeSetGetLength(pobj->nodesetval);
if(cnt != 1) goto error;
node = (noit_conf_section_t)xmlXPathNodeSetItem(pobj->nodesetval, 0);
uuid_conf = (char *)xmlGetProp(node, (xmlChar *)"uuid");
if(!uuid_conf || uuid_parse(uuid_conf, checkid)) goto error;
doc = xmlNewDoc((xmlChar *)"1.0");
root = xmlNewDocNode(doc, NULL, (xmlChar *)"check", NULL);
xmlDocSetRootElement(doc, root);
#define MYATTR(node,a,n,b) _noit_conf_get_string(node, &(n), "@" #a, &(b))
#define INHERIT(node,a,n,b) \
_noit_conf_get_string(node, &(n), "ancestor-or-self::node()/@" #a, &(b))
#define SHOW_ATTR(parent, node, a) do { \
xmlNodePtr anode = NULL; \
char *value = NULL; \
INHERIT(node, a, anode, value); \
if(value != NULL) { \
int clen, plen;\
const char *cpath, *apath; \
xmlNodePtr child; \
cpath = node ? (char *)xmlGetNodePath(node) : ""; \
apath = anode ? (char *)xmlGetNodePath(anode) : ""; \
clen = strlen(cpath); \
plen = strlen("/noit/checks"); \
child = xmlNewNode(NULL, (xmlChar *)#a); \
xmlNodeAddContent(child, (xmlChar *)value); \
if(!strncmp(cpath, apath, clen) && apath[clen] == '/') { \
} \
else { \
xmlSetProp(child, (xmlChar *)"inherited", (xmlChar *)apath+plen); \
} \
xmlAddChild(parent, child); \
} \
} while(0)
attr = xmlNewNode(NULL, (xmlChar *)"attributes");
xmlAddChild(root, attr);
SHOW_ATTR(attr,node,uuid);
/* Name is odd, it falls back transparently to module */
if(!INHERIT(node, module, tmp, module)) module = NULL;
xmlAddChild(attr, (tmp = xmlNewNode(NULL, (xmlChar *)"name")));
if(MYATTR(node, name, anode, value))
xmlNodeAddContent(tmp, (xmlChar *)value);
else if(module)
xmlNodeAddContent(tmp, (xmlChar *)module);
SHOW_ATTR(attr,node,module);
SHOW_ATTR(attr,node,target);
SHOW_ATTR(attr,node,period);
SHOW_ATTR(attr,node,timeout);
SHOW_ATTR(attr,node,oncheck);
SHOW_ATTR(attr,node,filterset);
SHOW_ATTR(attr,node,disable);
/* Add the config */
config = xmlNewNode(NULL, (xmlChar *)"config");
configh = noit_conf_get_hash(node, "config");
while(noit_hash_next(configh, &iter, &k, &klen, &data))
NODE_CONTENT(config, k, data);
noit_hash_destroy(configh, free, free);
free(configh);
xmlAddChild(root, config);
/* Add the state */
check = noit_poller_lookup(checkid);
if(!check) {
state = xmlNewNode(NULL, (xmlChar *)"state");
xmlSetProp(state, (xmlChar *)"error", (xmlChar *)"true");
}
else
state = noit_check_state_as_xml(check);
xmlAddChild(root, state);
noit_http_response_ok(ctx, "text/xml");
noit_http_response_xml(ctx, doc);
noit_http_response_end(ctx);
goto cleanup;
not_found:
noit_http_response_not_found(ctx, "text/html");
noit_http_response_end(ctx);
goto cleanup;
error:
noit_http_response_standard(ctx, error_code, "ERROR", "text/html");
noit_http_response_end(ctx);
goto cleanup;
cleanup:
if(pobj) xmlXPathFreeObject(pobj);
if(doc) xmlFreeDoc(doc);
return 0;
}
int
noit_rest_simple_file_handler(noit_http_rest_closure_t *restc,
int npats, char **pats) {
int drlen = 0;
const char *document_root = NULL;
const char *index_file = NULL;
noit_http_session_ctx *ctx = restc->http_ctx;
char file[PATH_MAX], rfile[PATH_MAX];
struct stat st;
int fd;
void *contents = MAP_FAILED;
const char *dot = NULL, *slash;
const char *content_type = "application/octet-stream";
if(npats != 1 ||
!noit_hash_retr_str(restc->ac->config,
"document_root", strlen("document_root"),
&document_root)) {
goto not_found;
}
if(!noit_hash_retr_str(restc->ac->config,
"index_file", strlen("index_file"),
&index_file)) {
index_file = "index.html";
}
drlen = strlen(document_root);
snprintf(file, sizeof(file), "%s/%s", document_root, pats[0]);
if(file[strlen(file) - 1] == '/') {
snprintf(file + strlen(file), sizeof(file) - strlen(file),
"%s", index_file);
}
/* resolve */
if(realpath(file, rfile) == NULL) goto not_found;
/* restrict */
if(strncmp(rfile, document_root, drlen)) goto denied;
if(rfile[drlen] != '/' && rfile[drlen + 1] != '/') goto denied;
/* stat */
/* coverity[fs_check_call] */
if(stat(rfile, &st) != 0) {
switch (errno) {
case EACCES: goto denied;
default: goto not_found;
}
}
/* open */
if(st.st_size > 0) {
/* coverity[toctou] */
fd = open(rfile, O_RDONLY);
if(fd < 0) goto not_found;
contents = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
close(fd);
if(contents == MAP_FAILED) goto not_found;
}
/* set content type */
slash = strchr(rfile, '/');
while(slash) {
const char *nslash = strchr(slash+1, '/');
if(!nslash) break;
slash = nslash;
}
if(slash) dot = strchr(slash+1, '.');
while(dot) {
const char *ndot = strchr(dot+1, '.');
if(!ndot) break;
dot = ndot;
}
/* If there is no extention, just use the filename */
if(!dot) dot = slash+1;
if(dot) {
char ext[PATH_MAX];
strlcpy(ext, "mime_type_", sizeof(ext));
strlcpy(ext+strlen(ext), dot+1, sizeof(ext)-strlen(ext));
if(!noit_hash_retr_str(restc->ac->config,
ext, strlen(ext),
&content_type)) {
if(!noit_hash_retr_str(&mime_type_defaults, dot+1, strlen(dot+1),
&content_type)) {
content_type = "application/octet-stream";
}
}
}
noit_http_response_ok(ctx, content_type);
if(st.st_size > 0) {
noit_http_response_append(ctx, contents, st.st_size);
munmap(contents, st.st_size);
}
noit_http_response_end(ctx);
return 0;
denied:
noit_http_response_denied(ctx, "text/html");
noit_http_response_end(ctx);
return 0;
not_found:
noit_http_response_not_found(ctx, "text/html");
noit_http_response_end(ctx);
return 0;
}
int
noit_rest_simple_file_handler(noit_http_rest_closure_t *restc,
int npats, char **pats) {
int drlen = 0;
const char *document_root = NULL;
const char *index_file = NULL;
noit_http_session_ctx *ctx = restc->http_ctx;
char file[PATH_MAX], rfile[PATH_MAX];
struct stat st;
int fd;
void *contents = MAP_FAILED;
if(npats != 1 ||
!noit_hash_retr_str(restc->ac->config,
"document_root", strlen("document_root"),
&document_root)) {
goto not_found;
}
if(!noit_hash_retr_str(restc->ac->config,
"index_file", strlen("index_file"),
&index_file)) {
index_file = "index.html";
}
drlen = strlen(document_root);
snprintf(file, sizeof(file), "%s/%s", document_root, pats[0]);
if(file[strlen(file) - 1] == '/') {
snprintf(file + strlen(file), sizeof(file) - strlen(file),
"%s", index_file);
}
/* resolve */
if(realpath(file, rfile) == NULL) goto not_found;
/* restrict */
if(strncmp(rfile, document_root, drlen)) goto denied;
if(rfile[drlen] != '/' && rfile[drlen + 1] != '/') goto denied;
/* stat */
if(stat(rfile, &st) != 0) {
switch (errno) {
case EACCES: goto denied;
default: goto not_found;
}
}
/* open */
if(st.st_size > 0) {
fd = open(rfile, O_RDONLY);
if(fd < 0) goto not_found;
contents = mmap(NULL, st.st_size, PROT_READ, MAP_SHARED, fd, 0);
close(fd);
if(contents == MAP_FAILED) goto not_found;
}
noit_http_response_ok(ctx, "text/html");
if(st.st_size > 0) {
noit_http_response_append(ctx, contents, st.st_size);
munmap(contents, st.st_size);
}
noit_http_response_end(ctx);
return 0;
denied:
noit_http_response_denied(ctx, "text/html");
noit_http_response_end(ctx);
return 0;
not_found:
noit_http_response_not_found(ctx, "text/html");
noit_http_response_end(ctx);
return 0;
}
