#include "common.h"

#define INITIAL_WEB_DATA_LENGTH 16384

#define WEB_REQUEST_LENGTH 16384

#define TOO_BIG_REQUEST 16384

int web_client_timeout = DEFAULT_DISCONNECT_IDLE_WEB_CLIENTS_AFTER_SECONDS;

int web_donotrack_comply = 0;

#ifdef NETDATA_WITH_ZLIB

int web_enable_gzip = 1, web_gzip_level = 3, web_gzip_strategy = Z_DEFAULT_STRATEGY;

#endif /* NETDATA_WITH_ZLIB */

struct web_client *web_clients = NULL;

unsigned long long web_clients_count = 0;

static inline int web_client_crock_socket(struct web_client *w) {

#ifdef TCP_CORK

if(likely(!w->tcp_cork && w->ofd != -1)) {

w->tcp_cork = 1;

if(unlikely(setsockopt(w->ofd, IPPROTO_TCP, TCP_CORK, (char *) &w->tcp_cork, sizeof(int)) != 0)) {

error("%llu: failed to enable TCP_CORK on socket.", w->id);

w->tcp_cork = 0;

return -1;

}

}

#endif /* TCP_CORK */

return 0;

}

static inline int web_client_uncrock_socket(struct web_client *w) {

#ifdef TCP_CORK

if(likely(w->tcp_cork && w->ofd != -1)) {

w->tcp_cork = 0;

if(unlikely(setsockopt(w->ofd, IPPROTO_TCP, TCP_CORK, (char *) &w->tcp_cork, sizeof(int)) != 0)) {

error("%llu: failed to disable TCP_CORK on socket.", w->id);

w->tcp_cork = 1;

return -1;

}

}

#endif /* TCP_CORK */

return 0;

}

struct web_client *web_client_create(int listener)

{

struct web_client *w;

w = callocz(1, sizeof(struct web_client));

w->id = ++web_clients_count;

w->mode = WEB_CLIENT_MODE_NORMAL;

{

struct sockaddr *sadr;

socklen_t addrlen;

sadr = (struct sockaddr*) &w->clientaddr;

addrlen = sizeof(w->clientaddr);

w->ifd = accept4(listener, sadr, &addrlen, SOCK_NONBLOCK);

if (w->ifd == -1) {

error("%llu: Cannot accept new incoming connection.", w->id);

freez(w);

return NULL;

}

w->ofd = w->ifd;

if(getnameinfo(sadr, addrlen, w->client_ip, NI_MAXHOST, w->client_port, NI_MAXSERV, NI_NUMERICHOST | NI_NUMERICSERV) != 0) {

error("Cannot getnameinfo() on received client connection.");

strncpyz(w->client_ip, "UNKNOWN", NI_MAXHOST);

strncpyz(w->client_port, "UNKNOWN", NI_MAXSERV);

}

w->client_ip[NI_MAXHOST] = '\0';

w->client_port[NI_MAXSERV] = '\0';

switch(sadr->sa_family) {

case AF_INET:

debug(D_WEB_CLIENT_ACCESS, "%llu: New IPv4 web client from %s port %s on socket %d.", w->id, w->client_ip, w->client_port, w->ifd);

break;

case AF_INET6:

if(strncmp(w->client_ip, "::ffff:", 7) == 0) {

memmove(w->client_ip, &w->client_ip[7], strlen(&w->client_ip[7]) + 1);

debug(D_WEB_CLIENT_ACCESS, "%llu: New IPv4 web client from %s port %s on socket %d.", w->id, w->client_ip, w->client_port, w->ifd);

}

else

debug(D_WEB_CLIENT_ACCESS, "%llu: New IPv6 web client from %s port %s on socket %d.", w->id, w->client_ip, w->client_port, w->ifd);

break;

default:

debug(D_WEB_CLIENT_ACCESS, "%llu: New UNKNOWN web client from %s port %s on socket %d.", w->id, w->client_ip, w->client_port, w->ifd);

break;

}

int flag = 1;

if(setsockopt(w->ofd, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(int)) != 0)

error("%llu: failed to enable TCP_NODELAY on socket.", w->id);

flag = 1;

if(setsockopt(w->ifd, SOL_SOCKET, SO_KEEPALIVE, (char *) &flag, sizeof(int)) != 0)

error("%llu: Cannot set SO_KEEPALIVE on socket.", w->id);

}

w->response.data = buffer_create(INITIAL_WEB_DATA_LENGTH);

w->response.header = buffer_create(HTTP_RESPONSE_HEADER_SIZE);

w->response.header_output = buffer_create(HTTP_RESPONSE_HEADER_SIZE);

w->origin[0] = '*';

w->wait_receive = 1;

if(web_clients) web_clients->prev = w;

w->next = web_clients;

web_clients = w;

web_client_connected();

return(w);

}

void web_client_reset(struct web_client *w) {

web_client_uncrock_socket(w);

debug(D_WEB_CLIENT, "%llu: Reseting client.", w->id);

if(likely(w->last_url[0])) {

struct timeval tv;

gettimeofday(&tv, NULL);

size_t size = (w->mode == WEB_CLIENT_MODE_FILECOPY)?w->response.rlen:w->response.data->len;

size_t sent = size;

#ifdef NETDATA_WITH_ZLIB

if(likely(w->response.zoutput)) sent = (size_t)w->response.zstream.total_out;

// --------------------------------------------------------------------

// global statistics

finished_web_request_statistics(usec_dt(&tv, &w->tv_in),

w->stats_received_bytes,

w->stats_sent_bytes,

size,

sent);

w->stats_received_bytes = 0;

w->stats_sent_bytes = 0;

// --------------------------------------------------------------------

// access log

log_access("%llu: (sent/all = %zu/%zu bytes %0.0f%%, prep/sent/total = %0.2f/%0.2f/%0.2f ms) %s: %d '%s'",

w->id,

sent, size, -((size > 0) ? ((size - sent) / (double) size * 100.0) : 0.0),

usec_dt(&w->tv_ready, &w->tv_in) / 1000.0,

usec_dt(&tv, &w->tv_ready) / 1000.0,

usec_dt(&tv, &w->tv_in) / 1000.0,

(w->mode == WEB_CLIENT_MODE_FILECOPY) ? "filecopy" : ((w->mode == WEB_CLIENT_MODE_OPTIONS)

? "options" : "data"),

w->response.code,

w->last_url

);

}

if(unlikely(w->mode == WEB_CLIENT_MODE_FILECOPY)) {

if(w->ifd != w->ofd) {

debug(D_WEB_CLIENT, "%llu: Closing filecopy input file descriptor %d.", w->id, w->ifd);

if(w->ifd != -1) close(w->ifd);

w->ifd = w->ofd;

}

}

w->last_url[0] = '\0';

w->cookie1[0] = '\0';

w->cookie2[0] = '\0';

w->origin[0] = '*';

w->origin[1] = '\0';

w->mode = WEB_CLIENT_MODE_NORMAL;

w->tcp_cork = 0;

w->donottrack = 0;

w->tracking_required = 0;

w->keepalive = 0;

w->decoded_url[0] = '\0';

buffer_reset(w->response.header_output);

buffer_reset(w->response.header);

buffer_reset(w->response.data);

w->response.rlen = 0;

w->response.sent = 0;

w->response.code = 0;

w->wait_receive = 1;

w->wait_send = 0;

w->response.zoutput = 0;

// if we had enabled compression, release it

#ifdef NETDATA_WITH_ZLIB

if(w->response.zinitialized) {

debug(D_DEFLATE, "%llu: Freeing compression resources.", w->id);

deflateEnd(&w->response.zstream);

w->response.zsent = 0;

w->response.zhave = 0;

w->response.zstream.avail_in = 0;

w->response.zstream.avail_out = 0;

w->response.zstream.total_in = 0;

w->response.zstream.total_out = 0;

w->response.zinitialized = 0;

}

#endif // NETDATA_WITH_ZLIB

}

struct web_client *web_client_free(struct web_client *w) {

web_client_reset(w);

struct web_client *n = w->next;

if(w == web_clients) web_clients = n;

debug(D_WEB_CLIENT_ACCESS, "%llu: Closing web client from %s port %s.", w->id, w->client_ip, w->client_port);

if(w->prev) w->prev->next = w->next;

if(w->next) w->next->prev = w->prev;

if(w->response.header_output) buffer_free(w->response.header_output);

if(w->response.header) buffer_free(w->response.header);

if(w->response.data) buffer_free(w->response.data);

if(w->ifd != -1) close(w->ifd);

if(w->ofd != -1 && w->ofd != w->ifd) close(w->ofd);

freez(w);

web_client_disconnected();

return(n);

}

uid_t web_files_uid(void) {

static char *web_owner = NULL;

static uid_t owner_uid = 0;

if(unlikely(!web_owner)) {

web_owner = config_get("global", "web files owner", config_get("global", "run as user", ""));

if(!web_owner || !*web_owner)

owner_uid = geteuid();

else {

// getpwnam() is not thread safe,

// but we have called this function once

// while single threaded

struct passwd *pw = getpwnam(web_owner);

if(!pw) {

error("User '%s' is not present. Ignoring option.", web_owner);

owner_uid = geteuid();

}

else {

debug(D_WEB_CLIENT, "Web files owner set to %s.", web_owner);

owner_uid = pw->pw_uid;

}

}

}

return(owner_uid);

}

gid_t web_files_gid(void) {

static char *web_group = NULL;

static gid_t owner_gid = 0;

if(unlikely(!web_group)) {

web_group = config_get("global", "web files group", config_get("global", "web files owner", ""));

if(!web_group || !*web_group)

owner_gid = getegid();

else {

// getgrnam() is not thread safe,

// but we have called this function once

// while single threaded

struct group *gr = getgrnam(web_group);

if(!gr) {

error("Group '%s' is not present. Ignoring option.", web_group);

owner_gid = getegid();

}

else {

debug(D_WEB_CLIENT, "Web files group set to %s.", web_group);

owner_gid = gr->gr_gid;

}

}

}

return(owner_gid);

}

int mysendfile(struct web_client *w, char *filename)

{

static char *web_dir = NULL;

// initialize our static data

if(unlikely(!web_dir)) web_dir = config_get("global", "web files directory", WEB_DIR);

debug(D_WEB_CLIENT, "%llu: Looking for file '%s/%s'", w->id, web_dir, filename);

// skip leading slashes

while (*filename == '/') filename++;

// if the filename contain known paths, skip them

if(strncmp(filename, WEB_PATH_FILE "/", strlen(WEB_PATH_FILE) + 1) == 0)

filename = &filename[strlen(WEB_PATH_FILE) + 1];

char *s;

for(s = filename; *s ;s++) {

if( !isalnum(*s) && *s != '/' && *s != '.' && *s != '-' && *s != '_') {

debug(D_WEB_CLIENT_ACCESS, "%llu: File '%s' is not acceptable.", w->id, filename);

buffer_sprintf(w->response.data, "File '%s' cannot be served. Filename contains invalid character '%c'", filename, *s);

return 400;

}

}

// if the filename contains a .. refuse to serve it

if(strstr(filename, "..") != 0) {

debug(D_WEB_CLIENT_ACCESS, "%llu: File '%s' is not acceptable.", w->id, filename);

buffer_sprintf(w->response.data, "File '%s' cannot be served. Relative filenames with '..' in them are not supported.", filename);

return 400;

}

// access the file

char webfilename[FILENAME_MAX + 1];

snprintfz(webfilename, FILENAME_MAX, "%s/%s", web_dir, filename);

// check if the file exists

struct stat stat;

if(lstat(webfilename, &stat) != 0) {

debug(D_WEB_CLIENT_ACCESS, "%llu: File '%s' is not found.", w->id, webfilename);

buffer_sprintf(w->response.data, "File '%s' does not exist, or is not accessible.", webfilename);

return 404;

}

// check if the file is owned by expected user

if(stat.st_uid != web_files_uid()) {

error("%llu: File '%s' is owned by user %u (expected user %u). Access Denied.", w->id, webfilename, stat.st_uid, web_files_uid());

buffer_sprintf(w->response.data, "Access to file '%s' is not permitted.", webfilename);

return 403;

}

// check if the file is owned by expected group

if(stat.st_gid != web_files_gid()) {

error("%llu: File '%s' is owned by group %u (expected group %u). Access Denied.", w->id, webfilename, stat.st_gid, web_files_gid());

buffer_sprintf(w->response.data, "Access to file '%s' is not permitted.", webfilename);

return 403;

}

if((stat.st_mode & S_IFMT) == S_IFDIR) {

snprintfz(webfilename, FILENAME_MAX, "%s/index.html", filename);

return mysendfile(w, webfilename);

}

if((stat.st_mode & S_IFMT) != S_IFREG) {

error("%llu: File '%s' is not a regular file. Access Denied.", w->id, webfilename);

buffer_sprintf(w->response.data, "Access to file '%s' is not permitted.", webfilename);

return 403;

}

// open the file

w->ifd = open(webfilename, O_NONBLOCK, O_RDONLY);

if(w->ifd == -1) {

w->ifd = w->ofd;

if(errno == EBUSY || errno == EAGAIN) {

error("%llu: File '%s' is busy, sending 307 Moved Temporarily to force retry.", w->id, webfilename);

buffer_sprintf(w->response.header, "Location: /" WEB_PATH_FILE "/%s\r\n", filename);

buffer_sprintf(w->response.data, "The file '%s' is currently busy. Please try again later.", webfilename);

return 307;

}

else {

error("%llu: Cannot open file '%s'.", w->id, webfilename);

buffer_sprintf(w->response.data, "Cannot open file '%s'.", webfilename);

return 404;

}

}

if(fcntl(w->ifd, F_SETFL, O_NONBLOCK) < 0)

error("%llu: Cannot set O_NONBLOCK on file '%s'.", w->id, webfilename);

// pick a Content-Type for the file

if(strstr(filename, ".html") != NULL) w->response.data->contenttype = CT_TEXT_HTML;

else if(strstr(filename, ".js") != NULL) w->response.data->contenttype = CT_APPLICATION_X_JAVASCRIPT;

else if(strstr(filename, ".css") != NULL) w->response.data->contenttype = CT_TEXT_CSS;

else if(strstr(filename, ".xml") != NULL) w->response.data->contenttype = CT_TEXT_XML;

else if(strstr(filename, ".xsl") != NULL) w->response.data->contenttype = CT_TEXT_XSL;

else if(strstr(filename, ".txt") != NULL) w->response.data->contenttype = CT_TEXT_PLAIN;

else if(strstr(filename, ".svg") != NULL) w->response.data->contenttype = CT_IMAGE_SVG_XML;

else if(strstr(filename, ".ttf") != NULL) w->response.data->contenttype = CT_APPLICATION_X_FONT_TRUETYPE;

else if(strstr(filename, ".otf") != NULL) w->response.data->contenttype = CT_APPLICATION_X_FONT_OPENTYPE;

else if(strstr(filename, ".woff2")!= NULL) w->response.data->contenttype = CT_APPLICATION_FONT_WOFF2;

else if(strstr(filename, ".woff") != NULL) w->response.data->contenttype = CT_APPLICATION_FONT_WOFF;

else if(strstr(filename, ".eot") != NULL) w->response.data->contenttype = CT_APPLICATION_VND_MS_FONTOBJ;

else if(strstr(filename, ".png") != NULL) w->response.data->contenttype = CT_IMAGE_PNG;

else if(strstr(filename, ".jpg") != NULL) w->response.data->contenttype = CT_IMAGE_JPG;

else if(strstr(filename, ".jpeg") != NULL) w->response.data->contenttype = CT_IMAGE_JPG;

else if(strstr(filename, ".gif") != NULL) w->response.data->contenttype = CT_IMAGE_GIF;

else if(strstr(filename, ".bmp") != NULL) w->response.data->contenttype = CT_IMAGE_BMP;

else if(strstr(filename, ".ico") != NULL) w->response.data->contenttype = CT_IMAGE_XICON;

else if(strstr(filename, ".icns") != NULL) w->response.data->contenttype = CT_IMAGE_ICNS;

else w->response.data->contenttype = CT_APPLICATION_OCTET_STREAM;

debug(D_WEB_CLIENT_ACCESS, "%llu: Sending file '%s' (%ld bytes, ifd %d, ofd %d).", w->id, webfilename, stat.st_size, w->ifd, w->ofd);

w->mode = WEB_CLIENT_MODE_FILECOPY;

w->wait_receive = 1;

w->wait_send = 0;

buffer_flush(w->response.data);

w->response.rlen = stat.st_size;

w->response.data->date = stat.st_mtim.tv_sec;

buffer_cacheable(w->response.data);

return 200;

}

#ifdef NETDATA_WITH_ZLIB

void web_client_enable_deflate(struct web_client *w, int gzip) {

if(unlikely(w->response.zinitialized)) {

error("%llu: Compression has already be initialized for this client.", w->id);

return;

}

if(unlikely(w->response.sent)) {

error("%llu: Cannot enable compression in the middle of a conversation.", w->id);

return;

}

w->response.zstream.zalloc = Z_NULL;

w->response.zstream.zfree = Z_NULL;

w->response.zstream.opaque = Z_NULL;

w->response.zstream.next_in = (Bytef *)w->response.data->buffer;

w->response.zstream.avail_in = 0;

w->response.zstream.total_in = 0;

w->response.zstream.next_out = w->response.zbuffer;

w->response.zstream.avail_out = 0;

w->response.zstream.total_out = 0;

w->response.zstream.zalloc = Z_NULL;

w->response.zstream.zfree = Z_NULL;

w->response.zstream.opaque = Z_NULL;

// Select GZIP compression: windowbits = 15 + 16 = 31

if(deflateInit2(&w->response.zstream, web_gzip_level, Z_DEFLATED, 15 + ((gzip)?16:0), 8, web_gzip_strategy) != Z_OK) {

error("%llu: Failed to initialize zlib. Proceeding without compression.", w->id);

return;

}

w->response.zsent = 0;

w->response.zoutput = 1;

w->response.zinitialized = 1;

debug(D_DEFLATE, "%llu: Initialized compression.", w->id);

}

#endif // NETDATA_WITH_ZLIB

void buffer_data_options2string(BUFFER *wb, uint32_t options) {

int count = 0;

if(options & RRDR_OPTION_NONZERO) {

if(count++) buffer_strcat(wb, " ");

buffer_strcat(wb, "nonzero");

}

if(options & RRDR_OPTION_REVERSED) {

if(count++) buffer_strcat(wb, " ");

buffer_strcat(wb, "flip");

}

if(options & RRDR_OPTION_JSON_WRAP) {

if(count++) buffer_strcat(wb, " ");

buffer_strcat(wb, "jsonwrap");

}

if(options & RRDR_OPTION_MIN2MAX) {

if(count++) buffer_strcat(wb, " ");

buffer_strcat(wb, "min2max");

}

if(options & RRDR_OPTION_MILLISECONDS) {

if(count++) buffer_strcat(wb, " ");

buffer_strcat(wb, "ms");

}

if(options & RRDR_OPTION_ABSOLUTE) {

if(count++) buffer_strcat(wb, " ");

buffer_strcat(wb, "abs");

}

if(options & RRDR_OPTION_SECONDS) {

if(count++) buffer_strcat(wb, " ");

buffer_strcat(wb, "seconds");

}

if(options & RRDR_OPTION_NULL2ZERO) {

if(count++) buffer_strcat(wb, " ");

buffer_strcat(wb, "null2zero");

}

if(options & RRDR_OPTION_OBJECTSROWS) {

if(count++) buffer_strcat(wb, " ");

buffer_strcat(wb, "objectrows");

}

if(options & RRDR_OPTION_GOOGLE_JSON) {

if(count++) buffer_strcat(wb, " ");

buffer_strcat(wb, "google_json");

}

if(options & RRDR_OPTION_PERCENTAGE) {

if(count++) buffer_strcat(wb, " ");

buffer_strcat(wb, "percentage");

}

if(options & RRDR_OPTION_NOT_ALIGNED) {

if(count++) buffer_strcat(wb, " ");

buffer_strcat(wb, "unaligned");

}

}

uint32_t web_client_api_request_v1_data_options(char *o)

{

uint32_t ret = 0x00000000;

char *tok;

while(o && *o && (tok = mystrsep(&o, ", |"))) {

if(!*tok) continue;

if(!strcmp(tok, "nonzero"))

ret |= RRDR_OPTION_NONZERO;

else if(!strcmp(tok, "flip") || !strcmp(tok, "reversed") || !strcmp(tok, "reverse"))

ret |= RRDR_OPTION_REVERSED;

else if(!strcmp(tok, "jsonwrap"))

ret |= RRDR_OPTION_JSON_WRAP;

else if(!strcmp(tok, "min2max"))

ret |= RRDR_OPTION_MIN2MAX;

else if(!strcmp(tok, "ms") || !strcmp(tok, "milliseconds"))

ret |= RRDR_OPTION_MILLISECONDS;

else if(!strcmp(tok, "abs") || !strcmp(tok, "absolute") || !strcmp(tok, "absolute_sum") || !strcmp(tok, "absolute-sum"))

ret |= RRDR_OPTION_ABSOLUTE;

else if(!strcmp(tok, "seconds"))

ret |= RRDR_OPTION_SECONDS;

else if(!strcmp(tok, "null2zero"))

ret |= RRDR_OPTION_NULL2ZERO;

else if(!strcmp(tok, "objectrows"))

ret |= RRDR_OPTION_OBJECTSROWS;

else if(!strcmp(tok, "google_json"))

ret |= RRDR_OPTION_GOOGLE_JSON;

else if(!strcmp(tok, "percentage"))

ret |= RRDR_OPTION_PERCENTAGE;

else if(!strcmp(tok, "unaligned"))

ret |= RRDR_OPTION_NOT_ALIGNED;

}

return ret;

}

uint32_t web_client_api_request_v1_data_format(char *name)

{

if(!strcmp(name, DATASOURCE_FORMAT_DATATABLE_JSON)) // datatable

return DATASOURCE_DATATABLE_JSON;

else if(!strcmp(name, DATASOURCE_FORMAT_DATATABLE_JSONP)) // datasource

return DATASOURCE_DATATABLE_JSONP;

else if(!strcmp(name, DATASOURCE_FORMAT_JSON)) // json

return DATASOURCE_JSON;

else if(!strcmp(name, DATASOURCE_FORMAT_JSONP)) // jsonp

return DATASOURCE_JSONP;

else if(!strcmp(name, DATASOURCE_FORMAT_SSV)) // ssv

return DATASOURCE_SSV;

else if(!strcmp(name, DATASOURCE_FORMAT_CSV)) // csv

return DATASOURCE_CSV;

else if(!strcmp(name, DATASOURCE_FORMAT_TSV) || !strcmp(name, "tsv-excel")) // tsv

return DATASOURCE_TSV;

else if(!strcmp(name, DATASOURCE_FORMAT_HTML)) // html

return DATASOURCE_HTML;

else if(!strcmp(name, DATASOURCE_FORMAT_JS_ARRAY)) // array

return DATASOURCE_JS_ARRAY;

else if(!strcmp(name, DATASOURCE_FORMAT_SSV_COMMA)) // ssvcomma

return DATASOURCE_SSV_COMMA;

else if(!strcmp(name, DATASOURCE_FORMAT_CSV_JSON_ARRAY)) // csvjsonarray

return DATASOURCE_CSV_JSON_ARRAY;

return DATASOURCE_JSON;

}

uint32_t web_client_api_request_v1_data_google_format(char *name)

{

if(!strcmp(name, "json"))

return DATASOURCE_DATATABLE_JSONP;

else if(!strcmp(name, "html"))

return DATASOURCE_HTML;

else if(!strcmp(name, "csv"))

return DATASOURCE_CSV;

else if(!strcmp(name, "tsv-excel"))

return DATASOURCE_TSV;

return DATASOURCE_JSON;

}

const char *group_method2string(int group) {

switch(group) {

case GROUP_UNDEFINED:

return "";

case GROUP_AVERAGE:

return "average";

case GROUP_MIN:

return "min";

case GROUP_MAX:

return "max";

case GROUP_SUM:

return "sum";

case GROUP_INCREMENTAL_SUM:

return "incremental-sum";

default:

return "unknown-group-method";

}

}

int web_client_api_request_v1_data_group(char *name, int def)

{

if(!strcmp(name, "average"))

return GROUP_AVERAGE;

else if(!strcmp(name, "min"))

return GROUP_MIN;

else if(!strcmp(name, "max"))

return GROUP_MAX;

else if(!strcmp(name, "sum"))

return GROUP_SUM;

else if(!strcmp(name, "incremental-sum"))

return GROUP_INCREMENTAL_SUM;

return def;

}

int web_client_api_request_v1_alarms(struct web_client *w, char *url)

{

int all = 0;

while(url) {

char *value = mystrsep(&url, "?&");

if (!value || !*value) continue;

if(!strcmp(value, "all")) all = 1;

else if(!strcmp(value, "active")) all = 0;

}

buffer_flush(w->response.data);

w->response.data->contenttype = CT_APPLICATION_JSON;

health_alarms2json(&localhost, w->response.data, all);

return 200;

}

int web_client_api_request_v1_alarm_log(struct web_client *w, char *url)

{

uint32_t after = 0;

while(url) {

char *value = mystrsep(&url, "?&");

if (!value || !*value) continue;

char *name = mystrsep(&value, "=");

if(!name || !*name) continue;

if(!value || !*value) continue;

if(!strcmp(name, "after")) after = strtoul(value, NULL, 0);

}

buffer_flush(w->response.data);

w->response.data->contenttype = CT_APPLICATION_JSON;

health_alarm_log2json(&localhost, w->response.data, after);

return 200;

}

int web_client_api_request_v1_charts(struct web_client *w, char *url)

{

(void)url;

buffer_flush(w->response.data);

w->response.data->contenttype = CT_APPLICATION_JSON;

rrd_stats_api_v1_charts(w->response.data);

return 200;

}

int web_client_api_request_v1_chart(struct web_client *w, char *url)

{

int ret = 400;

char *chart = NULL;

buffer_flush(w->response.data);

while(url) {

char *value = mystrsep(&url, "?&");

if(!value || !*value) continue;

char *name = mystrsep(&value, "=");

if(!name || !*name) continue;

if(!value || !*value) continue;

// name and value are now the parameters

// they are not null and not empty

if(!strcmp(name, "chart")) chart = value;

//else {

/// buffer_sprintf(w->response.data, "Unknown parameter '%s' in request.", name);

// goto cleanup;

//}

}

if(!chart || !*chart) {

buffer_sprintf(w->response.data, "No chart id is given at the request.");

goto cleanup;

}

RRDSET *st = rrdset_find(chart);

if(!st) st = rrdset_find_byname(chart);

if(!st) {

buffer_sprintf(w->response.data, "Chart '%s' is not found.", chart);

ret = 404;

goto cleanup;

}

w->response.data->contenttype = CT_APPLICATION_JSON;

rrd_stats_api_v1_chart(st, w->response.data);

return 200;

cleanup:

return ret;

}

int web_client_api_request_v1_badge(struct web_client *w, char *url) {

int ret = 400;

buffer_flush(w->response.data);

BUFFER *dimensions = NULL;

const char *chart = NULL

, *before_str = NULL

, *after_str = NULL

, *points_str = NULL

, *multiply_str = NULL

, *divide_str = NULL

, *label = NULL

, *units = NULL

, *label_color = NULL

, *value_color = NULL

, *refresh_str = NULL

, *precision_str = NULL

, *alarm = NULL;

int group = GROUP_AVERAGE;

uint32_t options = 0x00000000;

while(url) {

char *value = mystrsep(&url, "/?&");

if(!value || !*value) continue;

char *name = mystrsep(&value, "=");

if(!name || !*name) continue;

if(!value || !*value) continue;

debug(D_WEB_CLIENT, "%llu: API v1 badge.svg query param '%s' with value '%s'", w->id, name, value);

// name and value are now the parameters

// they are not null and not empty

if(!strcmp(name, "chart")) chart = value;

else if(!strcmp(name, "dimension") || !strcmp(name, "dim") || !strcmp(name, "dimensions") || !strcmp(name, "dims")) {

if(!dimensions)

dimensions = buffer_create(100);

buffer_strcat(dimensions, "|");

buffer_strcat(dimensions, value);

}

else if(!strcmp(name, "after")) after_str = value;

else if(!strcmp(name, "before")) before_str = value;

else if(!strcmp(name, "points")) points_str = value;

else if(!strcmp(name, "group")) {

group = web_client_api_request_v1_data_group(value, GROUP_AVERAGE);

}

else if(!strcmp(name, "options")) {

options |= web_client_api_request_v1_data_options(value);

}

else if(!strcmp(name, "label")) label = value;

else if(!strcmp(name, "units")) units = value;

else if(!strcmp(name, "label_color")) label_color = value;

else if(!strcmp(name, "value_color")) value_color = value;

else if(!strcmp(name, "multiply")) multiply_str = value;

else if(!strcmp(name, "divide")) divide_str = value;

else if(!strcmp(name, "refresh")) refresh_str = value;

else if(!strcmp(name, "precision")) precision_str = value;

else if(!strcmp(name, "alarm")) alarm = value;

}

if(!chart || !*chart) {

buffer_no_cacheable(w->response.data);

buffer_sprintf(w->response.data, "No chart id is given at the request.");

goto cleanup;

}

RRDSET *st = rrdset_find(chart);

if(!st) st = rrdset_find_byname(chart);

if(!st) {

buffer_no_cacheable(w->response.data);

buffer_svg(w->response.data, "chart not found", 0, "", NULL, NULL, 1, -1);

ret = 200;

goto cleanup;

}

RRDCALC *rc = NULL;

if(alarm) {

rc = rrdcalc_find(st, alarm);

if (!rc) {

buffer_no_cacheable(w->response.data);

buffer_svg(w->response.data, "alarm not found", 0, "", NULL, NULL, 1, -1);

ret = 200;

goto cleanup;

}

}

long long multiply = (multiply_str && *multiply_str )?atol(multiply_str):1;

long long divide = (divide_str && *divide_str )?atol(divide_str):1;

long long before = (before_str && *before_str )?atol(before_str):0;

long long after = (after_str && *after_str )?atol(after_str):-st->update_every;

int points = (points_str && *points_str )?atoi(points_str):1;

int precision = (precision_str && *precision_str)?atoi(precision_str):-1;

if(!multiply) multiply = 1;

if(!divide) divide = 1;

int refresh = 0;

if(refresh_str && *refresh_str) {

if(!strcmp(refresh_str, "auto")) {

if(rc) refresh = rc->update_every;

else if(options & RRDR_OPTION_NOT_ALIGNED)

refresh = st->update_every;

else {

refresh = (int)(before - after);

if(refresh < 0) refresh = -refresh;

}

}

else {

refresh = atoi(refresh_str);

if(refresh < 0) refresh = -refresh;

}

}

if(!label) {

if(alarm) {

char *s = (char *)alarm;

while(*s) {

if(*s == '_') *s = ' ';

s++;

}

label = alarm;

}

else if(dimensions) {

const char *dim = buffer_tostring(dimensions);

if(*dim == '|') dim++;

label = dim;

}

else

label = st->name;

}

if(!units) {

if(alarm) {

if(rc->units)

units = rc->units;

else

units = "";

}

else if(options & RRDR_OPTION_PERCENTAGE)

units = "%";

else

units = st->units;

}

debug(D_WEB_CLIENT, "%llu: API command 'badge.svg' for chart '%s', alarm '%s', dimensions '%s', after '%lld', before '%lld', points '%d', group '%d', options '0x%08x'"

, w->id

, chart

, alarm?alarm:""

, (dimensions)?buffer_tostring(dimensions):""

, after

, before

, points

, group

, options

);

if(rc) {

calculated_number n = rc->value;

if(isnan(n) || isinf(n)) n = 0;

if (refresh > 0) {

buffer_sprintf(w->response.header, "Refresh: %d\r\n", refresh);

w->response.data->expires = time(NULL) + refresh;

}

else buffer_no_cacheable(w->response.data);

if(!value_color) {

switch(rc->status) {

case RRDCALC_STATUS_CRITICAL:

value_color = "red";

break;

case RRDCALC_STATUS_WARNING:

value_color = "orange";

break;

case RRDCALC_STATUS_CLEAR:

value_color = "brightgreen";

break;

case RRDCALC_STATUS_UNDEFINED:

value_color = "lightgrey";

break;

case RRDCALC_STATUS_UNINITIALIZED:

value_color = "#000";

break;

default:

value_color = "grey";

break;

}

}

buffer_svg(w->response.data,

label,

rc->value * multiply / divide,

units,

label_color,

value_color,

0,

precision);

ret = 200;

}

else {

time_t latest_timestamp = 0;

int value_is_null = 1;

calculated_number n = 0;

ret = 500;

// if the collected value is too old, don't calculate its value

if (rrdset_last_entry_t(st) >= (time(NULL) - (st->update_every * st->gap_when_lost_iterations_above)))

ret = rrd2value(st,

w->response.data,

&n,

(dimensions) ? buffer_tostring(dimensions) : NULL,

points,

after,

before,

group,

options,

NULL,

&latest_timestamp,

&value_is_null);

// if the value cannot be calculated, show empty badge

if (ret != 200) {

buffer_no_cacheable(w->response.data);

value_is_null = 1;

n = 0;

ret = 200;

}

else if (refresh > 0) {

buffer_sprintf(w->response.header, "Refresh: %d\r\n", refresh);

w->response.data->expires = time(NULL) + refresh;

}

else buffer_no_cacheable(w->response.data);

// render the badge