src/web_client.c

   1 #include "common.h"
   2
   3 #define INITIAL_WEB_DATA_LENGTH 16384
   4 #define WEB_REQUEST_LENGTH 16384
   5 #define TOO_BIG_REQUEST 16384
   6
   7 int web_client_timeout = DEFAULT_DISCONNECT_IDLE_WEB_CLIENTS_AFTER_SECONDS;
   8 int web_donotrack_comply = 0;
   9
  10 #ifdef NETDATA_WITH_ZLIB
  11 int web_enable_gzip = 1, web_gzip_level = 3, web_gzip_strategy = Z_DEFAULT_STRATEGY;
  12 #endif /* NETDATA_WITH_ZLIB */
  13
  14 struct web_client *web_clients = NULL;
  15 unsigned long long web_clients_count = 0;
  16
  17 static inline int web_client_crock_socket(struct web_client *w) {
  18 #ifdef TCP_CORK
  19     if(likely(!w->tcp_cork && w->ofd != -1)) {
  20         w->tcp_cork = 1;
  21         if(unlikely(setsockopt(w->ofd, IPPROTO_TCP, TCP_CORK, (char *) &w->tcp_cork, sizeof(int)) != 0)) {
  22             error("%llu: failed to enable TCP_CORK on socket.", w->id);
  23             w->tcp_cork = 0;
  24             return -1;
  25         }
  26     }
  27 #endif /* TCP_CORK */
  28
  29     return 0;
  30 }
  31
  32 static inline int web_client_uncrock_socket(struct web_client *w) {
  33 #ifdef TCP_CORK
  34     if(likely(w->tcp_cork && w->ofd != -1)) {
  35         w->tcp_cork = 0;
  36         if(unlikely(setsockopt(w->ofd, IPPROTO_TCP, TCP_CORK, (char *) &w->tcp_cork, sizeof(int)) != 0)) {
  37             error("%llu: failed to disable TCP_CORK on socket.", w->id);
  38             w->tcp_cork = 1;
  39             return -1;
  40         }
  41     }
  42 #endif /* TCP_CORK */
  43
  44     return 0;
  45 }
  46
  47 struct web_client *web_client_create(int listener)
  48 {
  49     struct web_client *w;
  50
  51     w = callocz(1, sizeof(struct web_client));
  52     w->id = ++web_clients_count;
  53     w->mode = WEB_CLIENT_MODE_NORMAL;
  54
  55     {
  56         struct sockaddr *sadr;
  57         socklen_t addrlen;
  58
  59         sadr = (struct sockaddr*) &w->clientaddr;
  60         addrlen = sizeof(w->clientaddr);
  61
  62         w->ifd = accept4(listener, sadr, &addrlen, SOCK_NONBLOCK);
  63         if (w->ifd == -1) {
  64             error("%llu: Cannot accept new incoming connection.", w->id);
  65             freez(w);
  66             return NULL;
  67         }
  68         w->ofd = w->ifd;
  69
  70         if(getnameinfo(sadr, addrlen, w->client_ip, NI_MAXHOST, w->client_port, NI_MAXSERV, NI_NUMERICHOST | NI_NUMERICSERV) != 0) {
  71             error("Cannot getnameinfo() on received client connection.");
  72             strncpyz(w->client_ip,   "UNKNOWN", NI_MAXHOST);
  73             strncpyz(w->client_port, "UNKNOWN", NI_MAXSERV);
  74         }
  75         w->client_ip[NI_MAXHOST]   = '\0';
  76         w->client_port[NI_MAXSERV] = '\0';
  77
  78         switch(sadr->sa_family) {
  79         case AF_INET:
  80             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);
  81             break;
  82
  83         case AF_INET6:
  84             if(strncmp(w->client_ip, "::ffff:", 7) == 0) {
  85                 memmove(w->client_ip, &w->client_ip[7], strlen(&w->client_ip[7]) + 1);
  86                 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);
  87             }
  88             else
  89                 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);
  90             break;
  91
  92         default:
  93             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);
  94             break;
  95         }
  96
  97         int flag = 1;
  98         if(setsockopt(w->ofd, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(int)) != 0)
  99             error("%llu: failed to enable TCP_NODELAY on socket.", w->id);
 100
 101         flag = 1;
 102         if(setsockopt(w->ifd, SOL_SOCKET, SO_KEEPALIVE, (char *) &flag, sizeof(int)) != 0)
 103             error("%llu: Cannot set SO_KEEPALIVE on socket.", w->id);
 104     }
 105
 106     w->response.data = buffer_create(INITIAL_WEB_DATA_LENGTH);
 107     w->response.header = buffer_create(HTTP_RESPONSE_HEADER_SIZE);
 108     w->response.header_output = buffer_create(HTTP_RESPONSE_HEADER_SIZE);
 109     w->origin[0] = '*';
 110     w->wait_receive = 1;
 111
 112     if(web_clients) web_clients->prev = w;
 113     w->next = web_clients;
 114     web_clients = w;
 115
 116     web_client_connected();
 117
 118     return(w);
 119 }
 120
 121 void web_client_reset(struct web_client *w) {
 122     web_client_uncrock_socket(w);
 123
 124     debug(D_WEB_CLIENT, "%llu: Resetting client.", w->id);
 125
 126     if(likely(w->last_url[0])) {
 127         struct timeval tv;
 128         now_realtime_timeval(&tv);
 129
 130         size_t size = (w->mode == WEB_CLIENT_MODE_FILECOPY)?w->response.rlen:w->response.data->len;
 131         size_t sent = size;
 132 #ifdef NETDATA_WITH_ZLIB
 133         if(likely(w->response.zoutput)) sent = (size_t)w->response.zstream.total_out;
 134 #endif
 135
 136         // --------------------------------------------------------------------
 137         // global statistics
 138
 139         finished_web_request_statistics(dt_usec(&tv, &w->tv_in),
 140                                         w->stats_received_bytes,
 141                                         w->stats_sent_bytes,
 142                                         size,
 143                                         sent);
 144
 145         w->stats_received_bytes = 0;
 146         w->stats_sent_bytes = 0;
 147
 148
 149         // --------------------------------------------------------------------
 150         // access log
 151
 152         log_access("%llu: (sent/all = %zu/%zu bytes %0.0f%%, prep/sent/total = %0.2f/%0.2f/%0.2f ms) %s: %d '%s'",
 153                    w->id,
 154                    sent, size, -((size > 0) ? ((size - sent) / (double) size * 100.0) : 0.0),
 155                    dt_usec(&w->tv_ready, &w->tv_in) / 1000.0,
 156                    dt_usec(&tv, &w->tv_ready) / 1000.0,
 157                    dt_usec(&tv, &w->tv_in) / 1000.0,
 158                    (w->mode == WEB_CLIENT_MODE_FILECOPY) ? "filecopy" : ((w->mode == WEB_CLIENT_MODE_OPTIONS)
 159                                                                          ? "options" : "data"),
 160                    w->response.code,
 161                    w->last_url
 162         );
 163     }
 164
 165     if(unlikely(w->mode == WEB_CLIENT_MODE_FILECOPY)) {
 166         if(w->ifd != w->ofd) {
 167             debug(D_WEB_CLIENT, "%llu: Closing filecopy input file descriptor %d.", w->id, w->ifd);
 168             if(w->ifd != -1) close(w->ifd);
 169             w->ifd = w->ofd;
 170         }
 171     }
 172
 173     w->last_url[0] = '\0';
 174     w->cookie1[0] = '\0';
 175     w->cookie2[0] = '\0';
 176     w->origin[0] = '*';
 177     w->origin[1] = '\0';
 178
 179     w->mode = WEB_CLIENT_MODE_NORMAL;
 180
 181     w->tcp_cork = 0;
 182     w->donottrack = 0;
 183     w->tracking_required = 0;
 184     w->keepalive = 0;
 185     w->decoded_url[0] = '\0';
 186
 187     buffer_reset(w->response.header_output);
 188     buffer_reset(w->response.header);
 189     buffer_reset(w->response.data);
 190     w->response.rlen = 0;
 191     w->response.sent = 0;
 192     w->response.code = 0;
 193
 194     w->wait_receive = 1;
 195     w->wait_send = 0;
 196
 197     w->response.zoutput = 0;
 198
 199     // if we had enabled compression, release it
 200 #ifdef NETDATA_WITH_ZLIB
 201     if(w->response.zinitialized) {
 202         debug(D_DEFLATE, "%llu: Freeing compression resources.", w->id);
 203         deflateEnd(&w->response.zstream);
 204         w->response.zsent = 0;
 205         w->response.zhave = 0;
 206         w->response.zstream.avail_in = 0;
 207         w->response.zstream.avail_out = 0;
 208         w->response.zstream.total_in = 0;
 209         w->response.zstream.total_out = 0;
 210         w->response.zinitialized = 0;
 211     }
 212 #endif // NETDATA_WITH_ZLIB
 213 }
 214
 215 struct web_client *web_client_free(struct web_client *w) {
 216     web_client_reset(w);
 217
 218     struct web_client *n = w->next;
 219     if(w == web_clients) web_clients = n;
 220
 221     debug(D_WEB_CLIENT_ACCESS, "%llu: Closing web client from %s port %s.", w->id, w->client_ip, w->client_port);
 222
 223     if(w->prev) w->prev->next = w->next;
 224     if(w->next) w->next->prev = w->prev;
 225     if(w->response.header_output) buffer_free(w->response.header_output);
 226     if(w->response.header) buffer_free(w->response.header);
 227     if(w->response.data) buffer_free(w->response.data);
 228     if(w->ifd != -1) close(w->ifd);
 229     if(w->ofd != -1 && w->ofd != w->ifd) close(w->ofd);
 230     freez(w);
 231
 232     web_client_disconnected();
 233
 234     return(n);
 235 }
 236
 237 uid_t web_files_uid(void) {
 238     static char *web_owner = NULL;
 239     static uid_t owner_uid = 0;
 240
 241     if(unlikely(!web_owner)) {
 242         web_owner = config_get("global", "web files owner", config_get("global", "run as user", ""));
 243         if(!web_owner || !*web_owner)
 244             owner_uid = geteuid();
 245         else {
 246             // getpwnam() is not thread safe,
 247             // but we have called this function once
 248             // while single threaded
 249             struct passwd *pw = getpwnam(web_owner);
 250             if(!pw) {
 251                 error("User '%s' is not present. Ignoring option.", web_owner);
 252                 owner_uid = geteuid();
 253             }
 254             else {
 255                 debug(D_WEB_CLIENT, "Web files owner set to %s.", web_owner);
 256                 owner_uid = pw->pw_uid;
 257             }
 258         }
 259     }
 260
 261     return(owner_uid);
 262 }
 263
 264 gid_t web_files_gid(void) {
 265     static char *web_group = NULL;
 266     static gid_t owner_gid = 0;
 267
 268     if(unlikely(!web_group)) {
 269         web_group = config_get("global", "web files group", config_get("global", "web files owner", ""));
 270         if(!web_group || !*web_group)
 271             owner_gid = getegid();
 272         else {
 273             // getgrnam() is not thread safe,
 274             // but we have called this function once
 275             // while single threaded
 276             struct group *gr = getgrnam(web_group);
 277             if(!gr) {
 278                 error("Group '%s' is not present. Ignoring option.", web_group);
 279                 owner_gid = getegid();
 280             }
 281             else {
 282                 debug(D_WEB_CLIENT, "Web files group set to %s.", web_group);
 283                 owner_gid = gr->gr_gid;
 284             }
 285         }
 286     }
 287
 288     return(owner_gid);
 289 }
 290
 291 int mysendfile(struct web_client *w, char *filename)
 292 {
 293     debug(D_WEB_CLIENT, "%llu: Looking for file '%s/%s'", w->id, netdata_configured_web_dir, filename);
 294
 295     // skip leading slashes
 296     while (*filename == '/') filename++;
 297
 298     // if the filename contain known paths, skip them
 299     if(strncmp(filename, WEB_PATH_FILE "/", strlen(WEB_PATH_FILE) + 1) == 0)
 300         filename = &filename[strlen(WEB_PATH_FILE) + 1];
 301
 302     char *s;
 303     for(s = filename; *s ;s++) {
 304         if( !isalnum(*s) && *s != '/' && *s != '.' && *s != '-' && *s != '_') {
 305             debug(D_WEB_CLIENT_ACCESS, "%llu: File '%s' is not acceptable.", w->id, filename);
 306             buffer_sprintf(w->response.data, "Filename contains invalid characters: ");
 307             buffer_strcat_htmlescape(w->response.data, filename);
 308             return 400;
 309         }
 310     }
 311
 312     // if the filename contains a .. refuse to serve it
 313     if(strstr(filename, "..") != 0) {
 314         debug(D_WEB_CLIENT_ACCESS, "%llu: File '%s' is not acceptable.", w->id, filename);
 315         buffer_strcat(w->response.data, "Relative filenames are not supported: ");
 316         buffer_strcat_htmlescape(w->response.data, filename);
 317         return 400;
 318     }
 319
 320     // access the file
 321     char webfilename[FILENAME_MAX + 1];
 322     snprintfz(webfilename, FILENAME_MAX, "%s/%s", netdata_configured_web_dir, filename);
 323
 324     // check if the file exists
 325     struct stat stat;
 326     if(lstat(webfilename, &stat) != 0) {
 327         debug(D_WEB_CLIENT_ACCESS, "%llu: File '%s' is not found.", w->id, webfilename);
 328         buffer_strcat(w->response.data, "File does not exist, or is not accessible: ");
 329         buffer_strcat_htmlescape(w->response.data, webfilename);
 330         return 404;
 331     }
 332
 333     // check if the file is owned by expected user
 334     if(stat.st_uid != web_files_uid()) {
 335         error("%llu: File '%s' is owned by user %u (expected user %u). Access Denied.", w->id, webfilename, stat.st_uid, web_files_uid());
 336         buffer_strcat(w->response.data, "Access to file is not permitted: ");
 337         buffer_strcat_htmlescape(w->response.data, webfilename);
 338         return 403;
 339     }
 340
 341     // check if the file is owned by expected group
 342     if(stat.st_gid != web_files_gid()) {
 343         error("%llu: File '%s' is owned by group %u (expected group %u). Access Denied.", w->id, webfilename, stat.st_gid, web_files_gid());
 344         buffer_strcat(w->response.data, "Access to file is not permitted: ");
 345         buffer_strcat_htmlescape(w->response.data, webfilename);
 346         return 403;
 347     }
 348
 349     if((stat.st_mode & S_IFMT) == S_IFDIR) {
 350         snprintfz(webfilename, FILENAME_MAX, "%s/index.html", filename);
 351         return mysendfile(w, webfilename);
 352     }
 353
 354     if((stat.st_mode & S_IFMT) != S_IFREG) {
 355         error("%llu: File '%s' is not a regular file. Access Denied.", w->id, webfilename);
 356         buffer_strcat(w->response.data, "Access to file is not permitted: ");
 357         buffer_strcat_htmlescape(w->response.data, webfilename);
 358         return 403;
 359     }
 360
 361     // open the file
 362     w->ifd = open(webfilename, O_NONBLOCK, O_RDONLY);
 363     if(w->ifd == -1) {
 364         w->ifd = w->ofd;
 365
 366         if(errno == EBUSY || errno == EAGAIN) {
 367             error("%llu: File '%s' is busy, sending 307 Moved Temporarily to force retry.", w->id, webfilename);
 368             buffer_sprintf(w->response.header, "Location: /" WEB_PATH_FILE "/%s\r\n", filename);
 369             buffer_strcat(w->response.data, "File is currently busy, please try again later: ");
 370             buffer_strcat_htmlescape(w->response.data, webfilename);
 371             return 307;
 372         }
 373         else {
 374             error("%llu: Cannot open file '%s'.", w->id, webfilename);
 375             buffer_strcat(w->response.data, "Cannot open file: ");
 376             buffer_strcat_htmlescape(w->response.data, webfilename);
 377             return 404;
 378         }
 379     }
 380     if(fcntl(w->ifd, F_SETFL, O_NONBLOCK) < 0)
 381         error("%llu: Cannot set O_NONBLOCK on file '%s'.", w->id, webfilename);
 382
 383     // pick a Content-Type for the file
 384          if(strstr(filename, ".html") != NULL)  w->response.data->contenttype = CT_TEXT_HTML;
 385     else if(strstr(filename, ".js")   != NULL)  w->response.data->contenttype = CT_APPLICATION_X_JAVASCRIPT;
 386     else if(strstr(filename, ".css")  != NULL)  w->response.data->contenttype = CT_TEXT_CSS;
 387     else if(strstr(filename, ".xml")  != NULL)  w->response.data->contenttype = CT_TEXT_XML;
 388     else if(strstr(filename, ".xsl")  != NULL)  w->response.data->contenttype = CT_TEXT_XSL;
 389     else if(strstr(filename, ".txt")  != NULL)  w->response.data->contenttype = CT_TEXT_PLAIN;
 390     else if(strstr(filename, ".svg")  != NULL)  w->response.data->contenttype = CT_IMAGE_SVG_XML;
 391     else if(strstr(filename, ".ttf")  != NULL)  w->response.data->contenttype = CT_APPLICATION_X_FONT_TRUETYPE;
 392     else if(strstr(filename, ".otf")  != NULL)  w->response.data->contenttype = CT_APPLICATION_X_FONT_OPENTYPE;
 393     else if(strstr(filename, ".woff2")!= NULL)  w->response.data->contenttype = CT_APPLICATION_FONT_WOFF2;
 394     else if(strstr(filename, ".woff") != NULL)  w->response.data->contenttype = CT_APPLICATION_FONT_WOFF;
 395     else if(strstr(filename, ".eot")  != NULL)  w->response.data->contenttype = CT_APPLICATION_VND_MS_FONTOBJ;
 396     else if(strstr(filename, ".png")  != NULL)  w->response.data->contenttype = CT_IMAGE_PNG;
 397     else if(strstr(filename, ".jpg")  != NULL)  w->response.data->contenttype = CT_IMAGE_JPG;
 398     else if(strstr(filename, ".jpeg") != NULL)  w->response.data->contenttype = CT_IMAGE_JPG;
 399     else if(strstr(filename, ".gif")  != NULL)  w->response.data->contenttype = CT_IMAGE_GIF;
 400     else if(strstr(filename, ".bmp")  != NULL)  w->response.data->contenttype = CT_IMAGE_BMP;
 401     else if(strstr(filename, ".ico")  != NULL)  w->response.data->contenttype = CT_IMAGE_XICON;
 402     else if(strstr(filename, ".icns") != NULL)  w->response.data->contenttype = CT_IMAGE_ICNS;
 403     else w->response.data->contenttype = CT_APPLICATION_OCTET_STREAM;
 404
 405     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);
 406
 407     w->mode = WEB_CLIENT_MODE_FILECOPY;
 408     w->wait_receive = 1;
 409     w->wait_send = 0;
 410     buffer_flush(w->response.data);
 411     w->response.rlen = stat.st_size;
 412 #ifdef __APPLE__
 413     w->response.data->date = stat.st_mtimespec.tv_sec;
 414 #else
 415     w->response.data->date = stat.st_mtim.tv_sec;
 416 #endif /* __APPLE__ */
 417     buffer_cacheable(w->response.data);
 418
 419     return 200;
 420 }
 421
 422
 423 #ifdef NETDATA_WITH_ZLIB
 424 void web_client_enable_deflate(struct web_client *w, int gzip) {
 425     if(unlikely(w->response.zinitialized)) {
 426         debug(D_DEFLATE, "%llu: Compression has already be initialized for this client.", w->id);
 427         return;
 428     }
 429
 430     if(unlikely(w->response.sent)) {
 431         error("%llu: Cannot enable compression in the middle of a conversation.", w->id);
 432         return;
 433     }
 434
 435     w->response.zstream.zalloc = Z_NULL;
 436     w->response.zstream.zfree = Z_NULL;
 437     w->response.zstream.opaque = Z_NULL;
 438
 439     w->response.zstream.next_in = (Bytef *)w->response.data->buffer;
 440     w->response.zstream.avail_in = 0;
 441     w->response.zstream.total_in = 0;
 442
 443     w->response.zstream.next_out = w->response.zbuffer;
 444     w->response.zstream.avail_out = 0;
 445     w->response.zstream.total_out = 0;
 446
 447     w->response.zstream.zalloc = Z_NULL;
 448     w->response.zstream.zfree = Z_NULL;
 449     w->response.zstream.opaque = Z_NULL;
 450
 451 //  if(deflateInit(&w->response.zstream, Z_DEFAULT_COMPRESSION) != Z_OK) {
 452 //      error("%llu: Failed to initialize zlib. Proceeding without compression.", w->id);
 453 //      return;
 454 //  }
 455
 456     // Select GZIP compression: windowbits = 15 + 16 = 31
 457     if(deflateInit2(&w->response.zstream, web_gzip_level, Z_DEFLATED, 15 + ((gzip)?16:0), 8, web_gzip_strategy) != Z_OK) {
 458         error("%llu: Failed to initialize zlib. Proceeding without compression.", w->id);
 459         return;
 460     }
 461
 462     w->response.zsent = 0;
 463     w->response.zoutput = 1;
 464     w->response.zinitialized = 1;
 465
 466     debug(D_DEFLATE, "%llu: Initialized compression.", w->id);
 467 }
 468 #endif // NETDATA_WITH_ZLIB
 469
 470 void buffer_data_options2string(BUFFER *wb, uint32_t options) {
 471     int count = 0;
 472
 473     if(options & RRDR_OPTION_NONZERO) {
 474         if(count++) buffer_strcat(wb, " ");
 475         buffer_strcat(wb, "nonzero");
 476     }
 477
 478     if(options & RRDR_OPTION_REVERSED) {
 479         if(count++) buffer_strcat(wb, " ");
 480         buffer_strcat(wb, "flip");
 481     }
 482
 483     if(options & RRDR_OPTION_JSON_WRAP) {
 484         if(count++) buffer_strcat(wb, " ");
 485         buffer_strcat(wb, "jsonwrap");
 486     }
 487
 488     if(options & RRDR_OPTION_MIN2MAX) {
 489         if(count++) buffer_strcat(wb, " ");
 490         buffer_strcat(wb, "min2max");
 491     }
 492
 493     if(options & RRDR_OPTION_MILLISECONDS) {
 494         if(count++) buffer_strcat(wb, " ");
 495         buffer_strcat(wb, "ms");
 496     }
 497
 498     if(options & RRDR_OPTION_ABSOLUTE) {
 499         if(count++) buffer_strcat(wb, " ");
 500         buffer_strcat(wb, "absolute");
 501     }
 502
 503     if(options & RRDR_OPTION_SECONDS) {
 504         if(count++) buffer_strcat(wb, " ");
 505         buffer_strcat(wb, "seconds");
 506     }
 507
 508     if(options & RRDR_OPTION_NULL2ZERO) {
 509         if(count++) buffer_strcat(wb, " ");
 510         buffer_strcat(wb, "null2zero");
 511     }
 512
 513     if(options & RRDR_OPTION_OBJECTSROWS) {
 514         if(count++) buffer_strcat(wb, " ");
 515         buffer_strcat(wb, "objectrows");
 516     }
 517
 518     if(options & RRDR_OPTION_GOOGLE_JSON) {
 519         if(count++) buffer_strcat(wb, " ");
 520         buffer_strcat(wb, "google_json");
 521     }
 522
 523     if(options & RRDR_OPTION_PERCENTAGE) {
 524         if(count++) buffer_strcat(wb, " ");
 525         buffer_strcat(wb, "percentage");
 526     }
 527
 528     if(options & RRDR_OPTION_NOT_ALIGNED) {
 529         if(count++) buffer_strcat(wb, " ");
 530         buffer_strcat(wb, "unaligned");
 531     }
 532 }
 533
 534 uint32_t web_client_api_request_v1_data_options(char *o)
 535 {
 536     uint32_t ret = 0x00000000;
 537     char *tok;
 538
 539     while(o && *o && (tok = mystrsep(&o, ", |"))) {
 540         if(!*tok) continue;
 541
 542         if(!strcmp(tok, "nonzero"))
 543             ret |= RRDR_OPTION_NONZERO;
 544         else if(!strcmp(tok, "flip") || !strcmp(tok, "reversed") || !strcmp(tok, "reverse"))
 545             ret |= RRDR_OPTION_REVERSED;
 546         else if(!strcmp(tok, "jsonwrap"))
 547             ret |= RRDR_OPTION_JSON_WRAP;
 548         else if(!strcmp(tok, "min2max"))
 549             ret |= RRDR_OPTION_MIN2MAX;
 550         else if(!strcmp(tok, "ms") || !strcmp(tok, "milliseconds"))
 551             ret |= RRDR_OPTION_MILLISECONDS;
 552         else if(!strcmp(tok, "abs") || !strcmp(tok, "absolute") || !strcmp(tok, "absolute_sum") || !strcmp(tok, "absolute-sum"))
 553             ret |= RRDR_OPTION_ABSOLUTE;
 554         else if(!strcmp(tok, "seconds"))
 555             ret |= RRDR_OPTION_SECONDS;
 556         else if(!strcmp(tok, "null2zero"))
 557             ret |= RRDR_OPTION_NULL2ZERO;
 558         else if(!strcmp(tok, "objectrows"))
 559             ret |= RRDR_OPTION_OBJECTSROWS;
 560         else if(!strcmp(tok, "google_json"))
 561             ret |= RRDR_OPTION_GOOGLE_JSON;
 562         else if(!strcmp(tok, "percentage"))
 563             ret |= RRDR_OPTION_PERCENTAGE;
 564         else if(!strcmp(tok, "unaligned"))
 565             ret |= RRDR_OPTION_NOT_ALIGNED;
 566     }
 567
 568     return ret;
 569 }
 570
 571 uint32_t web_client_api_request_v1_data_format(char *name)
 572 {
 573     if(!strcmp(name, DATASOURCE_FORMAT_DATATABLE_JSON)) // datatable
 574         return DATASOURCE_DATATABLE_JSON;
 575
 576     else if(!strcmp(name, DATASOURCE_FORMAT_DATATABLE_JSONP)) // datasource
 577         return DATASOURCE_DATATABLE_JSONP;
 578
 579     else if(!strcmp(name, DATASOURCE_FORMAT_JSON)) // json
 580         return DATASOURCE_JSON;
 581
 582     else if(!strcmp(name, DATASOURCE_FORMAT_JSONP)) // jsonp
 583         return DATASOURCE_JSONP;
 584
 585     else if(!strcmp(name, DATASOURCE_FORMAT_SSV)) // ssv
 586         return DATASOURCE_SSV;
 587
 588     else if(!strcmp(name, DATASOURCE_FORMAT_CSV)) // csv
 589         return DATASOURCE_CSV;
 590
 591     else if(!strcmp(name, DATASOURCE_FORMAT_TSV) || !strcmp(name, "tsv-excel")) // tsv
 592         return DATASOURCE_TSV;
 593
 594     else if(!strcmp(name, DATASOURCE_FORMAT_HTML)) // html
 595         return DATASOURCE_HTML;
 596
 597     else if(!strcmp(name, DATASOURCE_FORMAT_JS_ARRAY)) // array
 598         return DATASOURCE_JS_ARRAY;
 599
 600     else if(!strcmp(name, DATASOURCE_FORMAT_SSV_COMMA)) // ssvcomma
 601         return DATASOURCE_SSV_COMMA;
 602
 603     else if(!strcmp(name, DATASOURCE_FORMAT_CSV_JSON_ARRAY)) // csvjsonarray
 604         return DATASOURCE_CSV_JSON_ARRAY;
 605
 606     return DATASOURCE_JSON;
 607 }
 608
 609 uint32_t web_client_api_request_v1_data_google_format(char *name)
 610 {
 611     if(!strcmp(name, "json"))
 612         return DATASOURCE_DATATABLE_JSONP;
 613
 614     else if(!strcmp(name, "html"))
 615         return DATASOURCE_HTML;
 616
 617     else if(!strcmp(name, "csv"))
 618         return DATASOURCE_CSV;
 619
 620     else if(!strcmp(name, "tsv-excel"))
 621         return DATASOURCE_TSV;
 622
 623     return DATASOURCE_JSON;
 624 }
 625
 626 const char *group_method2string(int group) {
 627     switch(group) {
 628         case GROUP_UNDEFINED:
 629             return "";
 630
 631         case GROUP_AVERAGE:
 632             return "average";
 633
 634         case GROUP_MIN:
 635             return "min";
 636
 637         case GROUP_MAX:
 638             return "max";
 639
 640         case GROUP_SUM:
 641             return "sum";
 642
 643         case GROUP_INCREMENTAL_SUM:
 644             return "incremental-sum";
 645
 646         default:
 647             return "unknown-group-method";
 648     }
 649 }
 650
 651 int web_client_api_request_v1_data_group(char *name, int def)
 652 {
 653     if(!strcmp(name, "average"))
 654         return GROUP_AVERAGE;
 655
 656     else if(!strcmp(name, "min"))
 657         return GROUP_MIN;
 658
 659     else if(!strcmp(name, "max"))
 660         return GROUP_MAX;
 661
 662     else if(!strcmp(name, "sum"))
 663         return GROUP_SUM;
 664
 665     else if(!strcmp(name, "incremental-sum"))
 666         return GROUP_INCREMENTAL_SUM;
 667
 668     return def;
 669 }
 670
 671 int web_client_api_request_v1_alarms(struct web_client *w, char *url)
 672 {
 673     int all = 0;
 674
 675     while(url) {
 676         char *value = mystrsep(&url, "?&");
 677         if (!value || !*value) continue;
 678
 679         if(!strcmp(value, "all")) all = 1;
 680         else if(!strcmp(value, "active")) all = 0;
 681     }
 682
 683     buffer_flush(w->response.data);
 684     w->response.data->contenttype = CT_APPLICATION_JSON;
 685     health_alarms2json(&localhost, w->response.data, all);
 686     return 200;
 687 }
 688
 689 int web_client_api_request_v1_alarm_log(struct web_client *w, char *url)
 690 {
 691     uint32_t after = 0;
 692
 693     while(url) {
 694         char *value = mystrsep(&url, "?&");
 695         if (!value || !*value) continue;
 696
 697         char *name = mystrsep(&value, "=");
 698         if(!name || !*name) continue;
 699         if(!value || !*value) continue;
 700
 701         if(!strcmp(name, "after")) after = strtoul(value, NULL, 0);
 702     }
 703
 704     buffer_flush(w->response.data);
 705     w->response.data->contenttype = CT_APPLICATION_JSON;
 706     health_alarm_log2json(&localhost, w->response.data, after);
 707     return 200;
 708 }
 709
 710 int web_client_api_request_single_chart(struct web_client *w, char *url, void callback(RRDSET *st, BUFFER *buf))
 711 {
 712     int ret = 400;
 713     char *chart = NULL;
 714
 715     buffer_flush(w->response.data);
 716
 717     while(url) {
 718         char *value = mystrsep(&url, "?&");
 719         if(!value || !*value) continue;
 720
 721         char *name = mystrsep(&value, "=");
 722         if(!name || !*name) continue;
 723         if(!value || !*value) continue;
 724
 725         // name and value are now the parameters
 726         // they are not null and not empty
 727
 728         if(!strcmp(name, "chart")) chart = value;
 729         //else {
 730         /// buffer_sprintf(w->response.data, "Unknown parameter '%s' in request.", name);
 731         //  goto cleanup;
 732         //}
 733     }
 734
 735     if(!chart || !*chart) {
 736         buffer_sprintf(w->response.data, "No chart id is given at the request.");
 737         goto cleanup;
 738     }
 739
 740     RRDSET *st = rrdset_find(chart);
 741     if(!st) st = rrdset_find_byname(chart);
 742     if(!st) {
 743         buffer_strcat(w->response.data, "Chart is not found: ");
 744         buffer_strcat_htmlescape(w->response.data, chart);
 745         ret = 404;
 746         goto cleanup;
 747     }
 748
 749     w->response.data->contenttype = CT_APPLICATION_JSON;
 750     callback(st, w->response.data);
 751     return 200;
 752
 753     cleanup:
 754     return ret;
 755 }
 756
 757 int web_client_api_request_v1_alarm_variables(struct web_client *w, char *url)
 758 {
 759     return web_client_api_request_single_chart(w, url, health_api_v1_chart_variables2json);
 760 }
 761
 762 int web_client_api_request_v1_charts(struct web_client *w, char *url)
 763 {
 764     (void)url;
 765
 766     buffer_flush(w->response.data);
 767     w->response.data->contenttype = CT_APPLICATION_JSON;
 768     rrd_stats_api_v1_charts(w->response.data);
 769     return 200;
 770 }
 771
 772 int web_client_api_request_v1_allmetrics(struct web_client *w, char *url)
 773 {
 774     int format = ALLMETRICS_SHELL;
 775
 776     while(url) {
 777         char *value = mystrsep(&url, "?&");
 778         if (!value || !*value) continue;
 779
 780         char *name = mystrsep(&value, "=");
 781         if(!name || !*name) continue;
 782         if(!value || !*value) continue;
 783
 784         if(!strcmp(name, "format")) {
 785             if(!strcmp(value, ALLMETRICS_FORMAT_SHELL))
 786                 format = ALLMETRICS_SHELL;
 787             else if(!strcmp(value, ALLMETRICS_FORMAT_PROMETHEUS))
 788                 format = ALLMETRICS_PROMETHEUS;
 789             else
 790                 format = 0;
 791         }
 792     }
 793
 794     buffer_flush(w->response.data);
 795     buffer_no_cacheable(w->response.data);
 796
 797     switch(format) {
 798         case ALLMETRICS_SHELL:
 799             w->response.data->contenttype = CT_TEXT_PLAIN;
 800             rrd_stats_api_v1_charts_allmetrics_shell(w->response.data);
 801             return 200;
 802
 803         case ALLMETRICS_PROMETHEUS:
 804             w->response.data->contenttype = CT_PROMETHEUS;
 805             rrd_stats_api_v1_charts_allmetrics_prometheus(w->response.data);
 806             return 200;
 807
 808         default:
 809             w->response.data->contenttype = CT_TEXT_PLAIN;
 810             buffer_strcat(w->response.data, "Which format? Only '" ALLMETRICS_FORMAT_SHELL "' and '" ALLMETRICS_FORMAT_PROMETHEUS "' is currently supported.");
 811             return 400;
 812     }
 813 }
 814
 815 int web_client_api_request_v1_chart(struct web_client *w, char *url)
 816 {
 817     return web_client_api_request_single_chart(w, url, rrd_stats_api_v1_chart);
 818 }
 819
 820 int web_client_api_request_v1_badge(struct web_client *w, char *url) {
 821     int ret = 400;
 822     buffer_flush(w->response.data);
 823
 824     BUFFER *dimensions = NULL;
 825
 826     const char *chart = NULL
 827             , *before_str = NULL
 828             , *after_str = NULL
 829             , *points_str = NULL
 830             , *multiply_str = NULL
 831             , *divide_str = NULL
 832             , *label = NULL
 833             , *units = NULL
 834             , *label_color = NULL
 835             , *value_color = NULL
 836             , *refresh_str = NULL
 837             , *precision_str = NULL
 838             , *alarm = NULL;
 839
 840     int group = GROUP_AVERAGE;
 841     uint32_t options = 0x00000000;
 842
 843     while(url) {
 844         char *value = mystrsep(&url, "/?&");
 845         if(!value || !*value) continue;
 846
 847         char *name = mystrsep(&value, "=");
 848         if(!name || !*name) continue;
 849         if(!value || !*value) continue;
 850
 851         debug(D_WEB_CLIENT, "%llu: API v1 badge.svg query param '%s' with value '%s'", w->id, name, value);
 852
 853         // name and value are now the parameters
 854         // they are not null and not empty
 855
 856         if(!strcmp(name, "chart")) chart = value;
 857         else if(!strcmp(name, "dimension") || !strcmp(name, "dim") || !strcmp(name, "dimensions") || !strcmp(name, "dims")) {
 858             if(!dimensions)
 859                 dimensions = buffer_create(100);
 860
 861             buffer_strcat(dimensions, "|");
 862             buffer_strcat(dimensions, value);
 863         }
 864         else if(!strcmp(name, "after")) after_str = value;
 865         else if(!strcmp(name, "before")) before_str = value;
 866         else if(!strcmp(name, "points")) points_str = value;
 867         else if(!strcmp(name, "group")) {
 868             group = web_client_api_request_v1_data_group(value, GROUP_AVERAGE);
 869         }
 870         else if(!strcmp(name, "options")) {
 871             options |= web_client_api_request_v1_data_options(value);
 872         }
 873         else if(!strcmp(name, "label")) label = value;
 874         else if(!strcmp(name, "units")) units = value;
 875         else if(!strcmp(name, "label_color")) label_color = value;
 876         else if(!strcmp(name, "value_color")) value_color = value;
 877         else if(!strcmp(name, "multiply")) multiply_str = value;
 878         else if(!strcmp(name, "divide")) divide_str = value;
 879         else if(!strcmp(name, "refresh")) refresh_str = value;
 880         else if(!strcmp(name, "precision")) precision_str = value;
 881         else if(!strcmp(name, "alarm")) alarm = value;
 882     }
 883
 884     if(!chart || !*chart) {
 885         buffer_no_cacheable(w->response.data);
 886         buffer_sprintf(w->response.data, "No chart id is given at the request.");
 887         goto cleanup;
 888     }
 889
 890     RRDSET *st = rrdset_find(chart);
 891     if(!st) st = rrdset_find_byname(chart);
 892     if(!st) {
 893         buffer_no_cacheable(w->response.data);
 894         buffer_svg(w->response.data, "chart not found", NAN, "", NULL, NULL, -1);
 895         ret = 200;
 896         goto cleanup;
 897     }
 898
 899     RRDCALC *rc = NULL;
 900     if(alarm) {
 901         rc = rrdcalc_find(st, alarm);
 902         if (!rc) {
 903             buffer_no_cacheable(w->response.data);
 904             buffer_svg(w->response.data, "alarm not found", NAN, "", NULL, NULL, -1);
 905             ret = 200;
 906             goto cleanup;
 907         }
 908     }
 909
 910     long long multiply  = (multiply_str  && *multiply_str )?str2l(multiply_str):1;
 911     long long divide    = (divide_str    && *divide_str   )?str2l(divide_str):1;
 912     long long before    = (before_str    && *before_str   )?str2l(before_str):0;
 913     long long after     = (after_str     && *after_str    )?str2l(after_str):-st->update_every;
 914     int       points    = (points_str    && *points_str   )?str2i(points_str):1;
 915     int       precision = (precision_str && *precision_str)?str2i(precision_str):-1;
 916
 917     if(!multiply) multiply = 1;
 918     if(!divide) divide = 1;
 919
 920     int refresh = 0;
 921     if(refresh_str && *refresh_str) {
 922         if(!strcmp(refresh_str, "auto")) {
 923             if(rc) refresh = rc->update_every;
 924             else if(options & RRDR_OPTION_NOT_ALIGNED)
 925                 refresh = st->update_every;
 926             else {
 927                 refresh = (int)(before - after);
 928                 if(refresh < 0) refresh = -refresh;
 929             }
 930         }
 931         else {
 932             refresh = str2i(refresh_str);
 933             if(refresh < 0) refresh = -refresh;
 934         }
 935     }
 936
 937     if(!label) {
 938         if(alarm) {
 939             char *s = (char *)alarm;
 940             while(*s) {
 941                 if(*s == '_') *s = ' ';
 942                 s++;
 943             }
 944             label = alarm;
 945         }
 946         else if(dimensions) {
 947             const char *dim = buffer_tostring(dimensions);
 948             if(*dim == '|') dim++;
 949             label = dim;
 950         }
 951         else
 952             label = st->name;
 953     }
 954     if(!units) {
 955         if(alarm) {
 956             if(rc->units)
 957                 units = rc->units;
 958             else
 959                 units = "";
 960         }
 961         else if(options & RRDR_OPTION_PERCENTAGE)
 962             units = "%";
 963         else
 964             units = st->units;
 965     }
 966
 967     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'"
 968             , w->id
 969             , chart
 970             , alarm?alarm:""
 971             , (dimensions)?buffer_tostring(dimensions):""
 972             , after
 973             , before
 974             , points
 975             , group
 976             , options
 977             );
 978
 979     if(rc) {
 980         if (refresh > 0) {
 981             buffer_sprintf(w->response.header, "Refresh: %d\r\n", refresh);
 982             w->response.data->expires = now_realtime_sec() + refresh;
 983         }
 984         else buffer_no_cacheable(w->response.data);
 985
 986         if(!value_color) {
 987             switch(rc->status) {
 988                 case RRDCALC_STATUS_CRITICAL:
 989                     value_color = "red";
 990                     break;
 991
 992                 case RRDCALC_STATUS_WARNING:
 993                     value_color = "orange";
 994                     break;
 995
 996                 case RRDCALC_STATUS_CLEAR:
 997                     value_color = "brightgreen";
 998                     break;
 999
1000                 case RRDCALC_STATUS_UNDEFINED:
1001                     value_color = "lightgrey";
1002                     break;
1003
1004                 case RRDCALC_STATUS_UNINITIALIZED:
1005                     value_color = "#000";
1006                     break;
1007
1008                 default:
1009                     value_color = "grey";
1010                     break;
1011             }
1012         }
1013
1014         buffer_svg(w->response.data,
1015                 label,
1016                 (isnan(rc->value)||isinf(rc->value)) ? rc->value : rc->value * multiply / divide,
1017                 units,
1018                 label_color,
1019                 value_color,
1020                 precision);
1021         ret = 200;
1022     }
1023     else {
1024         time_t latest_timestamp = 0;
1025         int value_is_null = 1;
1026         calculated_number n = NAN;
1027         ret = 500;
1028
1029         // if the collected value is too old, don't calculate its value
1030         if (rrdset_last_entry_t(st) >= (now_realtime_sec() - (st->update_every * st->gap_when_lost_iterations_above)))
1031             ret = rrd2value(st,
1032                             w->response.data,
1033                             &n,
1034                             (dimensions) ? buffer_tostring(dimensions) : NULL,
1035                             points,
1036                             after,
1037                             before,
1038                             group,
1039                             options,
1040                             NULL,
1041                             &latest_timestamp,
1042                             &value_is_null);
1043
1044         // if the value cannot be calculated, show empty badge
1045         if (ret != 200) {
1046             buffer_no_cacheable(w->response.data);
1047             value_is_null = 1;
1048             n = 0;
1049             ret = 200;
1050         }
1051         else if (refresh > 0) {
1052             buffer_sprintf(w->response.header, "Refresh: %d\r\n", refresh);
1053             w->response.data->expires = now_realtime_sec() + refresh;
1054         }
1055         else buffer_no_cacheable(w->response.data);
1056
1057         // render the badge
1058         buffer_svg(w->response.data,
1059                 label,
1060                 (value_is_null)?NAN:(n * multiply / divide),
1061                 units,
1062                 label_color,
1063                 value_color,
1064                 precision);
1065     }
1066
1067 cleanup:
1068     if(dimensions)
1069         buffer_free(dimensions);
1070     return ret;
1071 }
1072
1073 // returns the HTTP code
1074 int web_client_api_request_v1_data(struct web_client *w, char *url)
1075 {
1076     debug(D_WEB_CLIENT, "%llu: API v1 data with URL '%s'", w->id, url);
1077
1078     int ret = 400;
1079     BUFFER *dimensions = NULL;
1080
1081     buffer_flush(w->response.data);
1082
1083     char    *google_version = "0.6",
1084             *google_reqId = "0",
1085             *google_sig = "0",
1086             *google_out = "json",
1087             *responseHandler = NULL,
1088             *outFileName = NULL;
1089
1090     time_t last_timestamp_in_data = 0, google_timestamp = 0;
1091
1092     char *chart = NULL
1093             , *before_str = NULL
1094             , *after_str = NULL
1095             , *points_str = NULL;
1096
1097     int group = GROUP_AVERAGE;
1098     uint32_t format = DATASOURCE_JSON;
1099     uint32_t options = 0x00000000;
1100
1101     while(url) {
1102         char *value = mystrsep(&url, "?&");
1103         if(!value || !*value) continue;
1104
1105         char *name = mystrsep(&value, "=");
1106         if(!name || !*name) continue;
1107         if(!value || !*value) continue;
1108
1109         debug(D_WEB_CLIENT, "%llu: API v1 data query param '%s' with value '%s'", w->id, name, value);
1110
1111         // name and value are now the parameters
1112         // they are not null and not empty
1113
1114         if(!strcmp(name, "chart")) chart = value;
1115         else if(!strcmp(name, "dimension") || !strcmp(name, "dim") || !strcmp(name, "dimensions") || !strcmp(name, "dims")) {
1116             if(!dimensions) dimensions = buffer_create(100);
1117             buffer_strcat(dimensions, "|");
1118             buffer_strcat(dimensions, value);
1119         }
1120         else if(!strcmp(name, "after")) after_str = value;
1121         else if(!strcmp(name, "before")) before_str = value;
1122         else if(!strcmp(name, "points")) points_str = value;
1123         else if(!strcmp(name, "group")) {
1124             group = web_client_api_request_v1_data_group(value, GROUP_AVERAGE);
1125         }
1126         else if(!strcmp(name, "format")) {
1127             format = web_client_api_request_v1_data_format(value);
1128         }
1129         else if(!strcmp(name, "options")) {
1130             options |= web_client_api_request_v1_data_options(value);
1131         }
1132         else if(!strcmp(name, "callback")) {
1133             responseHandler = value;
1134         }
1135         else if(!strcmp(name, "filename")) {
1136             outFileName = value;
1137         }
1138         else if(!strcmp(name, "tqx")) {
1139             // parse Google Visualization API options
1140             // https://developers.google.com/chart/interactive/docs/dev/implementing_data_source
1141             char *tqx_name, *tqx_value;
1142
1143             while(value) {
1144                 tqx_value = mystrsep(&value, ";");
1145                 if(!tqx_value || !*tqx_value) continue;
1146
1147                 tqx_name = mystrsep(&tqx_value, ":");
1148                 if(!tqx_name || !*tqx_name) continue;
1149                 if(!tqx_value || !*tqx_value) continue;
1150
1151                 if(!strcmp(tqx_name, "version"))
1152                     google_version = tqx_value;
1153                 else if(!strcmp(tqx_name, "reqId"))
1154                     google_reqId = tqx_value;
1155                 else if(!strcmp(tqx_name, "sig")) {
1156                     google_sig = tqx_value;
1157                     google_timestamp = strtoul(google_sig, NULL, 0);
1158                 }
1159                 else if(!strcmp(tqx_name, "out")) {
1160                     google_out = tqx_value;
1161                     format = web_client_api_request_v1_data_google_format(google_out);
1162                 }
1163                 else if(!strcmp(tqx_name, "responseHandler"))
1164                     responseHandler = tqx_value;
1165                 else if(!strcmp(tqx_name, "outFileName"))
1166                     outFileName = tqx_value;
1167             }
1168         }
1169     }
1170
1171     if(!chart || !*chart) {
1172         buffer_sprintf(w->response.data, "No chart id is given at the request.");
1173         goto cleanup;
1174     }
1175
1176     RRDSET *st = rrdset_find(chart);
1177     if(!st) st = rrdset_find_byname(chart);
1178     if(!st) {
1179         buffer_strcat(w->response.data, "Chart is not found: ");
1180         buffer_strcat_htmlescape(w->response.data, chart);
1181         ret = 404;
1182         goto cleanup;
1183     }
1184
1185     long long before = (before_str && *before_str)?str2l(before_str):0;
1186     long long after  = (after_str  && *after_str) ?str2l(after_str):0;
1187     int       points = (points_str && *points_str)?str2i(points_str):0;
1188
1189     debug(D_WEB_CLIENT, "%llu: API command 'data' for chart '%s', dimensions '%s', after '%lld', before '%lld', points '%d', group '%d', format '%u', options '0x%08x'"
1190             , w->id
1191             , chart
1192             , (dimensions)?buffer_tostring(dimensions):""
1193             , after
1194             , before
1195             , points
1196             , group
1197             , format
1198             , options
1199             );
1200
1201     if(outFileName && *outFileName) {
1202         buffer_sprintf(w->response.header, "Content-Disposition: attachment; filename=\"%s\"\r\n", outFileName);
1203         debug(D_WEB_CLIENT, "%llu: generating outfilename header: '%s'", w->id, outFileName);
1204     }
1205
1206     if(format == DATASOURCE_DATATABLE_JSONP) {
1207         if(responseHandler == NULL)
1208             responseHandler = "google.visualization.Query.setResponse";
1209
1210         debug(D_WEB_CLIENT_ACCESS, "%llu: GOOGLE JSON/JSONP: version = '%s', reqId = '%s', sig = '%s', out = '%s', responseHandler = '%s', outFileName = '%s'",
1211                 w->id, google_version, google_reqId, google_sig, google_out, responseHandler, outFileName
1212             );
1213
1214         buffer_sprintf(w->response.data,
1215             "%s({version:'%s',reqId:'%s',status:'ok',sig:'%ld',table:",
1216             responseHandler, google_version, google_reqId, st->last_updated.tv_sec);
1217     }
1218     else if(format == DATASOURCE_JSONP) {
1219         if(responseHandler == NULL)
1220             responseHandler = "callback";
1221
1222         buffer_strcat(w->response.data, responseHandler);
1223         buffer_strcat(w->response.data, "(");
1224     }
1225
1226     ret = rrd2format(st, w->response.data, dimensions, format, points, after, before, group, options, &last_timestamp_in_data);
1227
1228     if(format == DATASOURCE_DATATABLE_JSONP) {
1229         if(google_timestamp < last_timestamp_in_data)
1230             buffer_strcat(w->response.data, "});");
1231
1232         else {
1233             // the client already has the latest data
1234             buffer_flush(w->response.data);
1235             buffer_sprintf(w->response.data,
1236                 "%s({version:'%s',reqId:'%s',status:'error',errors:[{reason:'not_modified',message:'Data not modified'}]});",
1237                 responseHandler, google_version, google_reqId);
1238         }
1239     }
1240     else if(format == DATASOURCE_JSONP)
1241         buffer_strcat(w->response.data, ");");
1242
1243 cleanup:
1244     if(dimensions) buffer_free(dimensions);
1245     return ret;
1246 }
1247
1248
1249 int web_client_api_request_v1_registry(struct web_client *w, char *url)
1250 {
1251     static uint32_t hash_action = 0, hash_access = 0, hash_hello = 0, hash_delete = 0, hash_search = 0,
1252             hash_switch = 0, hash_machine = 0, hash_url = 0, hash_name = 0, hash_delete_url = 0, hash_for = 0,
1253             hash_to = 0 /*, hash_redirects = 0 */;
1254
1255     if(unlikely(!hash_action)) {
1256         hash_action = simple_hash("action");
1257         hash_access = simple_hash("access");
1258         hash_hello = simple_hash("hello");
1259         hash_delete = simple_hash("delete");
1260         hash_search = simple_hash("search");
1261         hash_switch = simple_hash("switch");
1262         hash_machine = simple_hash("machine");
1263         hash_url = simple_hash("url");
1264         hash_name = simple_hash("name");
1265         hash_delete_url = simple_hash("delete_url");
1266         hash_for = simple_hash("for");
1267         hash_to = simple_hash("to");
1268 /*
1269         hash_redirects = simple_hash("redirects");
1270 */
1271     }
1272
1273     char person_guid[GUID_LEN + 1] = "";
1274
1275     debug(D_WEB_CLIENT, "%llu: API v1 registry with URL '%s'", w->id, url);
1276
1277     // FIXME
1278     // The browser may send multiple cookies with our id
1279
1280     char *cookie = strstr(w->response.data->buffer, NETDATA_REGISTRY_COOKIE_NAME "=");
1281     if(cookie)
1282         strncpyz(person_guid, &cookie[sizeof(NETDATA_REGISTRY_COOKIE_NAME)], 36);
1283
1284     char action = '\0';
1285     char *machine_guid = NULL,
1286             *machine_url = NULL,
1287             *url_name = NULL,
1288             *search_machine_guid = NULL,
1289             *delete_url = NULL,
1290             *to_person_guid = NULL;
1291 /*
1292     int redirects = 0;
1293 */
1294
1295     while(url) {
1296         char *value = mystrsep(&url, "?&");
1297         if (!value || !*value) continue;
1298
1299         char *name = mystrsep(&value, "=");
1300         if (!name || !*name) continue;
1301         if (!value || !*value) continue;
1302
1303         debug(D_WEB_CLIENT, "%llu: API v1 registry query param '%s' with value '%s'", w->id, name, value);
1304
1305         uint32_t hash = simple_hash(name);
1306
1307         if(hash == hash_action && !strcmp(name, "action")) {
1308             uint32_t vhash = simple_hash(value);
1309
1310             if(vhash == hash_access && !strcmp(value, "access")) action = 'A';
1311             else if(vhash == hash_hello && !strcmp(value, "hello")) action = 'H';
1312             else if(vhash == hash_delete && !strcmp(value, "delete")) action = 'D';
1313             else if(vhash == hash_search && !strcmp(value, "search")) action = 'S';
1314             else if(vhash == hash_switch && !strcmp(value, "switch")) action = 'W';
1315 #ifdef NETDATA_INTERNAL_CHECKS
1316             else error("unknown registry action '%s'", value);
1317 #endif /* NETDATA_INTERNAL_CHECKS */
1318         }
1319 /*
1320         else if(hash == hash_redirects && !strcmp(name, "redirects"))
1321             redirects = atoi(value);
1322 */
1323         else if(hash == hash_machine && !strcmp(name, "machine"))
1324             machine_guid = value;
1325
1326         else if(hash == hash_url && !strcmp(name, "url"))
1327             machine_url = value;
1328
1329         else if(action == 'A') {
1330             if(hash == hash_name && !strcmp(name, "name"))
1331                 url_name = value;
1332         }
1333         else if(action == 'D') {
1334             if(hash == hash_delete_url && !strcmp(name, "delete_url"))
1335                 delete_url = value;
1336         }
1337         else if(action == 'S') {
1338             if(hash == hash_for && !strcmp(name, "for"))
1339                 search_machine_guid = value;
1340         }
1341         else if(action == 'W') {
1342             if(hash == hash_to && !strcmp(name, "to"))
1343                 to_person_guid = value;
1344         }
1345 #ifdef NETDATA_INTERNAL_CHECKS
1346         else error("unused registry URL parameter '%s' with value '%s'", name, value);
1347 #endif /* NETDATA_INTERNAL_CHECKS */
1348     }
1349
1350     if(web_donotrack_comply && w->donottrack) {
1351         buffer_flush(w->response.data);
1352         buffer_sprintf(w->response.data, "Your web browser is sending 'DNT: 1' (Do Not Track). The registry requires persistent cookies on your browser to work.");
1353         return 400;
1354     }
1355
1356     if(action == 'A' && (!machine_guid || !machine_url || !url_name)) {
1357         error("Invalid registry request - access requires these parameters: machine ('%s'), url ('%s'), name ('%s')",
1358                 machine_guid?machine_guid:"UNSET", machine_url?machine_url:"UNSET", url_name?url_name:"UNSET");
1359         buffer_flush(w->response.data);
1360         buffer_strcat(w->response.data, "Invalid registry Access request.");
1361         return 400;
1362     }
1363     else if(action == 'D' && (!machine_guid || !machine_url || !delete_url)) {
1364         error("Invalid registry request - delete requires these parameters: machine ('%s'), url ('%s'), delete_url ('%s')",
1365                 machine_guid?machine_guid:"UNSET", machine_url?machine_url:"UNSET", delete_url?delete_url:"UNSET");
1366         buffer_flush(w->response.data);
1367         buffer_strcat(w->response.data, "Invalid registry Delete request.");
1368         return 400;
1369     }
1370     else if(action == 'S' && (!machine_guid || !machine_url || !search_machine_guid)) {
1371         error("Invalid registry request - search requires these parameters: machine ('%s'), url ('%s'), for ('%s')",
1372                 machine_guid?machine_guid:"UNSET", machine_url?machine_url:"UNSET", search_machine_guid?search_machine_guid:"UNSET");
1373         buffer_flush(w->response.data);
1374         buffer_strcat(w->response.data, "Invalid registry Search request.");
1375         return 400;
1376     }
1377     else if(action == 'W' && (!machine_guid || !machine_url || !to_person_guid)) {
1378         error("Invalid registry request - switching identity requires these parameters: machine ('%s'), url ('%s'), to ('%s')",
1379                 machine_guid?machine_guid:"UNSET", machine_url?machine_url:"UNSET", to_person_guid?to_person_guid:"UNSET");
1380         buffer_flush(w->response.data);
1381         buffer_strcat(w->response.data, "Invalid registry Switch request.");
1382         return 400;
1383     }
1384
1385     switch(action) {
1386         case 'A':
1387             w->tracking_required = 1;
1388             return registry_request_access_json(w, person_guid, machine_guid, machine_url, url_name, now_realtime_sec());
1389
1390         case 'D':
1391             w->tracking_required = 1;
1392             return registry_request_delete_json(w, person_guid, machine_guid, machine_url, delete_url, now_realtime_sec());
1393
1394         case 'S':
1395             w->tracking_required = 1;
1396             return registry_request_search_json(w, person_guid, machine_guid, machine_url, search_machine_guid, now_realtime_sec());
1397
1398         case 'W':
1399             w->tracking_required = 1;
1400             return registry_request_switch_json(w, person_guid, machine_guid, machine_url, to_person_guid, now_realtime_sec());
1401
1402         case 'H':
1403             return registry_request_hello_json(w);
1404
1405         default:
1406             buffer_flush(w->response.data);
1407             buffer_strcat(w->response.data, "Invalid registry request - you need to set an action: hello, access, delete, search");
1408             return 400;
1409     }
1410 }
1411
1412 int web_client_api_request_v1(struct web_client *w, char *url) {
1413     static uint32_t hash_data = 0, hash_chart = 0, hash_charts = 0, hash_registry = 0, hash_badge = 0, hash_alarms = 0, hash_alarm_log = 0, hash_alarm_variables = 0, hash_raw = 0;
1414
1415     if(unlikely(hash_data == 0)) {
1416         hash_data = simple_hash("data");
1417         hash_chart = simple_hash("chart");
1418         hash_charts = simple_hash("charts");
1419         hash_registry = simple_hash("registry");
1420         hash_badge = simple_hash("badge.svg");
1421         hash_alarms = simple_hash("alarms");
1422         hash_alarm_log = simple_hash("alarm_log");
1423         hash_alarm_variables = simple_hash("alarm_variables");
1424         hash_raw = simple_hash("allmetrics");
1425     }
1426
1427     // get the command
1428     char *tok = mystrsep(&url, "/?&");
1429     if(tok && *tok) {
1430         debug(D_WEB_CLIENT, "%llu: Searching for API v1 command '%s'.", w->id, tok);
1431         uint32_t hash = simple_hash(tok);
1432
1433         if(hash == hash_data && !strcmp(tok, "data"))
1434             return web_client_api_request_v1_data(w, url);
1435
1436         else if(hash == hash_chart && !strcmp(tok, "chart"))
1437             return web_client_api_request_v1_chart(w, url);
1438
1439         else if(hash == hash_charts && !strcmp(tok, "charts"))
1440             return web_client_api_request_v1_charts(w, url);
1441
1442         else if(hash == hash_registry && !strcmp(tok, "registry"))
1443             return web_client_api_request_v1_registry(w, url);
1444
1445         else if(hash == hash_badge && !strcmp(tok, "badge.svg"))
1446             return web_client_api_request_v1_badge(w, url);
1447
1448         else if(hash == hash_alarms && !strcmp(tok, "alarms"))
1449             return web_client_api_request_v1_alarms(w, url);
1450
1451         else if(hash == hash_alarm_log && !strcmp(tok, "alarm_log"))
1452             return web_client_api_request_v1_alarm_log(w, url);
1453
1454         else if(hash == hash_alarm_variables && !strcmp(tok, "alarm_variables"))
1455             return web_client_api_request_v1_alarm_variables(w, url);
1456
1457         else if(hash == hash_raw && !strcmp(tok, "allmetrics"))
1458             return web_client_api_request_v1_allmetrics(w, url);
1459
1460         else {
1461             buffer_flush(w->response.data);
1462             buffer_strcat(w->response.data, "Unsupported v1 API command: ");
1463             buffer_strcat_htmlescape(w->response.data, tok);
1464             return 404;
1465         }
1466     }
1467     else {
1468         buffer_flush(w->response.data);
1469         buffer_sprintf(w->response.data, "Which API v1 command?");
1470         return 400;
1471     }
1472 }
1473
1474 int web_client_api_request(struct web_client *w, char *url)
1475 {
1476     // get the api version
1477     char *tok = mystrsep(&url, "/?&");
1478     if(tok && *tok) {
1479         debug(D_WEB_CLIENT, "%llu: Searching for API version '%s'.", w->id, tok);
1480         if(strcmp(tok, "v1") == 0)
1481             return web_client_api_request_v1(w, url);
1482         else {
1483             buffer_flush(w->response.data);
1484             buffer_strcat(w->response.data, "Unsupported API version: ");
1485             buffer_strcat_htmlescape(w->response.data, tok);
1486             return 404;
1487         }
1488     }
1489     else {
1490         buffer_flush(w->response.data);
1491         buffer_sprintf(w->response.data, "Which API version?");
1492         return 400;
1493     }
1494 }
1495
1496 int web_client_api_old_data_request(struct web_client *w, char *url, int datasource_type)
1497 {
1498     if(!url || !*url) {
1499         buffer_flush(w->response.data);
1500         buffer_sprintf(w->response.data, "Incomplete request.");
1501         return 400;
1502     }
1503
1504     RRDSET *st = NULL;
1505
1506     char *args = strchr(url, '?');
1507     if(args) {
1508         *args='\0';
1509         args = &args[1];
1510     }
1511
1512     // get the name of the data to show
1513     char *tok = mystrsep(&url, "/");
1514     if(!tok) tok = "";
1515
1516     // do we have such a data set?
1517     if(*tok) {
1518         debug(D_WEB_CLIENT, "%llu: Searching for RRD data with name '%s'.", w->id, tok);
1519         st = rrdset_find_byname(tok);
1520         if(!st) st = rrdset_find(tok);
1521     }
1522
1523     if(!st) {
1524         // we don't have it
1525         // try to send a file with that name
1526         buffer_flush(w->response.data);
1527         return(mysendfile(w, tok));
1528     }
1529
1530     // we have it
1531     debug(D_WEB_CLIENT, "%llu: Found RRD data with name '%s'.", w->id, tok);
1532
1533     // how many entries does the client want?
1534     int lines = rrd_default_history_entries;
1535     int group_count = 1;
1536     time_t after = 0, before = 0;
1537     int group_method = GROUP_AVERAGE;
1538     int nonzero = 0;
1539
1540     if(url) {
1541         // parse the lines required
1542         tok = mystrsep(&url, "/");
1543         if(tok) lines = str2i(tok);
1544         if(lines < 1) lines = 1;
1545     }
1546     if(url) {
1547         // parse the group count required
1548         tok = mystrsep(&url, "/");
1549         if(tok && *tok) group_count = str2i(tok);
1550         if(group_count < 1) group_count = 1;
1551         //if(group_count > save_history / 20) group_count = save_history / 20;
1552     }
1553     if(url) {
1554         // parse the grouping method required
1555         tok = mystrsep(&url, "/");
1556         if(tok && *tok) {
1557             if(strcmp(tok, "max") == 0) group_method = GROUP_MAX;
1558             else if(strcmp(tok, "average") == 0) group_method = GROUP_AVERAGE;
1559             else if(strcmp(tok, "sum") == 0) group_method = GROUP_SUM;
1560             else debug(D_WEB_CLIENT, "%llu: Unknown group method '%s'", w->id, tok);
1561         }
1562     }
1563     if(url) {
1564         // parse after time
1565         tok = mystrsep(&url, "/");
1566         if(tok && *tok) after = str2ul(tok);
1567         if(after < 0) after = 0;
1568     }
1569     if(url) {
1570         // parse before time
1571         tok = mystrsep(&url, "/");
1572         if(tok && *tok) before = str2ul(tok);
1573         if(before < 0) before = 0;
1574     }
1575     if(url) {
1576         // parse nonzero
1577         tok = mystrsep(&url, "/");
1578         if(tok && *tok && strcmp(tok, "nonzero") == 0) nonzero = 1;
1579     }
1580
1581     w->response.data->contenttype = CT_APPLICATION_JSON;
1582     buffer_flush(w->response.data);
1583
1584     char *google_version = "0.6";
1585     char *google_reqId = "0";
1586     char *google_sig = "0";
1587     char *google_out = "json";
1588     char *google_responseHandler = "google.visualization.Query.setResponse";
1589     char *google_outFileName = NULL;
1590     time_t last_timestamp_in_data = 0;
1591     if(datasource_type == DATASOURCE_DATATABLE_JSON || datasource_type == DATASOURCE_DATATABLE_JSONP) {
1592
1593         w->response.data->contenttype = CT_APPLICATION_X_JAVASCRIPT;
1594
1595         while(args) {
1596             tok = mystrsep(&args, "&");
1597             if(tok && *tok) {
1598                 char *name = mystrsep(&tok, "=");
1599                 if(name && *name && strcmp(name, "tqx") == 0) {
1600                     char *key = mystrsep(&tok, ":");
1601                     char *value = mystrsep(&tok, ";");
1602                     if(key && value && *key && *value) {
1603                         if(strcmp(key, "version") == 0)
1604                             google_version = value;
1605
1606                         else if(strcmp(key, "reqId") == 0)
1607                             google_reqId = value;
1608
1609                         else if(strcmp(key, "sig") == 0)
1610                             google_sig = value;
1611
1612                         else if(strcmp(key, "out") == 0)
1613                             google_out = value;
1614
1615                         else if(strcmp(key, "responseHandler") == 0)
1616                             google_responseHandler = value;
1617
1618                         else if(strcmp(key, "outFileName") == 0)
1619                             google_outFileName = value;
1620                     }
1621                 }
1622             }
1623         }
1624
1625         debug(D_WEB_CLIENT_ACCESS, "%llu: GOOGLE JSONP: version = '%s', reqId = '%s', sig = '%s', out = '%s', responseHandler = '%s', outFileName = '%s'",
1626             w->id, google_version, google_reqId, google_sig, google_out, google_responseHandler, google_outFileName
1627             );
1628
1629         if(datasource_type == DATASOURCE_DATATABLE_JSONP) {
1630             last_timestamp_in_data = strtoul(google_sig, NULL, 0);
1631
1632             // check the client wants json
1633             if(strcmp(google_out, "json") != 0) {
1634                 buffer_sprintf(w->response.data,
1635                     "%s({version:'%s',reqId:'%s',status:'error',errors:[{reason:'invalid_query',message:'output format is not supported',detailed_message:'the format %s requested is not supported by netdata.'}]});",
1636                     google_responseHandler, google_version, google_reqId, google_out);
1637                     return 200;
1638             }
1639         }
1640     }
1641
1642     if(datasource_type == DATASOURCE_DATATABLE_JSONP) {
1643         buffer_sprintf(w->response.data,
1644             "%s({version:'%s',reqId:'%s',status:'ok',sig:'%ld',table:",
1645             google_responseHandler, google_version, google_reqId, st->last_updated.tv_sec);
1646     }
1647
1648     debug(D_WEB_CLIENT_ACCESS, "%llu: Sending RRD data '%s' (id %s, %d lines, %d group, %d group_method, %ld after, %ld before).",
1649         w->id, st->name, st->id, lines, group_count, group_method, after, before);
1650
1651     time_t timestamp_in_data = rrd_stats_json(datasource_type, st, w->response.data, lines, group_count, group_method, (unsigned long)after, (unsigned long)before, nonzero);
1652
1653     if(datasource_type == DATASOURCE_DATATABLE_JSONP) {
1654         if(timestamp_in_data > last_timestamp_in_data)
1655             buffer_strcat(w->response.data, "});");
1656
1657         else {
1658             // the client already has the latest data
1659             buffer_flush(w->response.data);
1660             buffer_sprintf(w->response.data,
1661                 "%s({version:'%s',reqId:'%s',status:'error',errors:[{reason:'not_modified',message:'Data not modified'}]});",
1662                 google_responseHandler, google_version, google_reqId);
1663         }
1664     }
1665
1666     return 200;
1667 }
1668
1669 const char *web_content_type_to_string(uint8_t contenttype) {
1670     switch(contenttype) {
1671         case CT_TEXT_HTML:
1672             return "text/html; charset=utf-8";
1673
1674         case CT_APPLICATION_XML:
1675             return "application/xml; charset=utf-8";
1676
1677         case CT_APPLICATION_JSON:
1678             return "application/json; charset=utf-8";
1679
1680         case CT_APPLICATION_X_JAVASCRIPT:
1681             return "application/x-javascript; charset=utf-8";
1682
1683         case CT_TEXT_CSS:
1684             return "text/css; charset=utf-8";
1685
1686         case CT_TEXT_XML:
1687             return "text/xml; charset=utf-8";
1688
1689         case CT_TEXT_XSL:
1690             return "text/xsl; charset=utf-8";
1691
1692         case CT_APPLICATION_OCTET_STREAM:
1693             return "application/octet-stream";
1694
1695         case CT_IMAGE_SVG_XML:
1696             return "image/svg+xml";
1697
1698         case CT_APPLICATION_X_FONT_TRUETYPE:
1699             return "application/x-font-truetype";
1700
1701         case CT_APPLICATION_X_FONT_OPENTYPE:
1702             return "application/x-font-opentype";
1703
1704         case CT_APPLICATION_FONT_WOFF:
1705             return "application/font-woff";
1706
1707         case CT_APPLICATION_FONT_WOFF2:
1708             return "application/font-woff2";
1709
1710         case CT_APPLICATION_VND_MS_FONTOBJ:
1711             return "application/vnd.ms-fontobject";
1712
1713         case CT_IMAGE_PNG:
1714             return "image/png";
1715
1716         case CT_IMAGE_JPG:
1717             return "image/jpeg";
1718
1719         case CT_IMAGE_GIF:
1720             return "image/gif";
1721
1722         case CT_IMAGE_XICON:
1723             return "image/x-icon";
1724
1725         case CT_IMAGE_BMP:
1726             return "image/bmp";
1727
1728         case CT_IMAGE_ICNS:
1729             return "image/icns";
1730
1731         case CT_PROMETHEUS:
1732             return "text/plain; version=0.0.4";
1733
1734         default:
1735         case CT_TEXT_PLAIN:
1736             return "text/plain; charset=utf-8";
1737     }
1738 }
1739
1740
1741 const char *web_response_code_to_string(int code) {
1742     switch(code) {
1743         case 200:
1744             return "OK";
1745
1746         case 307:
1747             return "Temporary Redirect";
1748
1749         case 400:
1750             return "Bad Request";
1751
1752         case 403:
1753             return "Forbidden";
1754
1755         case 404:
1756             return "Not Found";
1757
1758         case 412:
1759             return "Preconditions Failed";
1760
1761         default:
1762             if(code >= 100 && code < 200)
1763                 return "Informational";
1764
1765             if(code >= 200 && code < 300)
1766                 return "Successful";
1767
1768             if(code >= 300 && code < 400)
1769                 return "Redirection";
1770
1771             if(code >= 400 && code < 500)
1772                 return "Bad Request";
1773
1774             if(code >= 500 && code < 600)
1775                 return "Server Error";
1776
1777             return "Undefined Error";
1778     }
1779 }
1780
1781 static inline char *http_header_parse(struct web_client *w, char *s) {
1782     static uint32_t hash_origin = 0, hash_connection = 0, hash_accept_encoding = 0, hash_donottrack = 0;
1783
1784     if(unlikely(!hash_origin)) {
1785         hash_origin = simple_uhash("Origin");
1786         hash_connection = simple_uhash("Connection");
1787         hash_accept_encoding = simple_uhash("Accept-Encoding");
1788         hash_donottrack = simple_uhash("DNT");
1789     }
1790
1791     char *e = s;
1792
1793     // find the :
1794     while(*e && *e != ':') e++;
1795     if(!*e) return e;
1796
1797     // get the name
1798     *e = '\0';
1799
1800     // find the value
1801     char *v = e + 1, *ve;
1802
1803     // skip leading spaces from value
1804     while(*v == ' ') v++;
1805     ve = v;
1806
1807     // find the \r
1808     while(*ve && *ve != '\r') ve++;
1809     if(!*ve || ve[1] != '\n') {
1810         *e = ':';
1811         return ve;
1812     }
1813
1814     // terminate the value
1815     *ve = '\0';
1816
1817     // fprintf(stderr, "HEADER: '%s' = '%s'\n", s, v);
1818     uint32_t hash = simple_uhash(s);
1819
1820     if(hash == hash_origin && !strcasecmp(s, "Origin"))
1821         strncpyz(w->origin, v, ORIGIN_MAX);
1822
1823     else if(hash == hash_connection && !strcasecmp(s, "Connection")) {
1824         if(strcasestr(v, "keep-alive"))
1825             w->keepalive = 1;
1826     }
1827     else if(web_donotrack_comply && hash == hash_donottrack && !strcasecmp(s, "DNT")) {
1828         if(*v == '0') w->donottrack = 0;
1829         else if(*v == '1') w->donottrack = 1;
1830     }
1831 #ifdef NETDATA_WITH_ZLIB
1832     else if(hash == hash_accept_encoding && !strcasecmp(s, "Accept-Encoding")) {
1833         if(web_enable_gzip) {
1834             if(strcasestr(v, "gzip"))
1835                 web_client_enable_deflate(w, 1);
1836             //
1837             // does not seem to work
1838             // else if(strcasestr(v, "deflate"))
1839             //  web_client_enable_deflate(w, 0);
1840         }
1841     }
1842 #endif /* NETDATA_WITH_ZLIB */
1843
1844     *e = ':';
1845     *ve = '\r';
1846     return ve;
1847 }
1848
1849 // http_request_validate()
1850 // returns:
1851 // = 0 : all good, process the request
1852 // > 0 : request is not supported
1853 // < 0 : request is incomplete - wait for more data
1854
1855 static inline int http_request_validate(struct web_client *w) {
1856     char *s = w->response.data->buffer, *encoded_url = NULL;
1857
1858     // is is a valid request?
1859     if(!strncmp(s, "GET ", 4)) {
1860         encoded_url = s = &s[4];
1861         w->mode = WEB_CLIENT_MODE_NORMAL;
1862     }
1863     else if(!strncmp(s, "OPTIONS ", 8)) {
1864         encoded_url = s = &s[8];
1865         w->mode = WEB_CLIENT_MODE_OPTIONS;
1866     }
1867     else {
1868         w->wait_receive = 0;
1869         return 1;
1870     }
1871
1872     // find the SPACE + "HTTP/"
1873     while(*s) {
1874         // find the next space
1875         while (*s && *s != ' ') s++;
1876
1877         // is it SPACE + "HTTP/" ?
1878         if(*s && !strncmp(s, " HTTP/", 6)) break;
1879         else s++;
1880     }
1881
1882     // incomplete requests
1883     if(unlikely(!*s)) {
1884         w->wait_receive = 1;
1885         return -2;
1886     }
1887
1888     // we have the end of encoded_url - remember it
1889     char *ue = s;
1890
1891     // make sure we have complete request
1892     // complete requests contain: \r\n\r\n
1893     while(*s) {
1894         // find a line feed
1895         while(*s && *s++ != '\r');
1896
1897         // did we reach the end?
1898         if(unlikely(!*s)) break;
1899
1900         // is it \r\n ?
1901         if(likely(*s++ == '\n')) {
1902
1903             // is it again \r\n ? (header end)
1904             if(unlikely(*s == '\r' && s[1] == '\n')) {
1905                 // a valid complete HTTP request found
1906
1907                 *ue = '\0';
1908                 url_decode_r(w->decoded_url, encoded_url, URL_MAX + 1);
1909                 *ue = ' ';
1910
1911                 // copy the URL - we are going to overwrite parts of it
1912                 // FIXME -- we should avoid it
1913                 strncpyz(w->last_url, w->decoded_url, URL_MAX);
1914
1915                 w->wait_receive = 0;
1916                 return 0;
1917             }
1918
1919             // another header line
1920             s = http_header_parse(w, s);
1921         }
1922     }
1923
1924     // incomplete request
1925     w->wait_receive = 1;
1926     return -3;
1927 }
1928
1929 void web_client_process(struct web_client *w) {
1930     static uint32_t
1931             hash_api = 0,
1932             hash_netdata_conf = 0,
1933             hash_data = 0,
1934             hash_datasource = 0,
1935             hash_graph = 0,
1936             hash_list = 0,
1937             hash_all_json = 0;
1938
1939 #ifdef NETDATA_INTERNAL_CHECKS
1940     static uint32_t hash_exit = 0, hash_debug = 0, hash_mirror = 0;
1941 #endif
1942
1943     // start timing us
1944     now_realtime_timeval(&w->tv_in);
1945
1946     if(unlikely(!hash_api)) {
1947         hash_api = simple_hash("api");
1948         hash_netdata_conf = simple_hash("netdata.conf");
1949         hash_data = simple_hash(WEB_PATH_DATA);
1950         hash_datasource = simple_hash(WEB_PATH_DATASOURCE);
1951         hash_graph = simple_hash(WEB_PATH_GRAPH);
1952         hash_list = simple_hash("list");
1953         hash_all_json = simple_hash("all.json");
1954 #ifdef NETDATA_INTERNAL_CHECKS
1955         hash_exit = simple_hash("exit");
1956         hash_debug = simple_hash("debug");
1957         hash_mirror = simple_hash("mirror");
1958 #endif
1959     }
1960
1961     int code = 500;
1962     ssize_t bytes;
1963
1964     int what_to_do = http_request_validate(w);
1965
1966     // wait for more data
1967     if(what_to_do < 0) {
1968         if(w->response.data->len > TOO_BIG_REQUEST) {
1969             strcpy(w->last_url, "too big request");
1970
1971             debug(D_WEB_CLIENT_ACCESS, "%llu: Received request is too big (%zu bytes).", w->id, w->response.data->len);
1972
1973             code = 400;
1974             buffer_flush(w->response.data);
1975             buffer_sprintf(w->response.data, "Received request is too big  (%zu bytes).\r\n", w->response.data->len);
1976         }
1977         else {
1978             // wait for more data
1979             return;
1980         }
1981     }
1982     else if(what_to_do > 0) {
1983         // strcpy(w->last_url, "not a valid request");
1984
1985         debug(D_WEB_CLIENT_ACCESS, "%llu: Cannot understand '%s'.", w->id, w->response.data->buffer);
1986
1987         code = 500;
1988         buffer_flush(w->response.data);
1989         buffer_strcat(w->response.data, "I don't understand you...\r\n");
1990     }
1991     else { // what_to_do == 0
1992         if(w->mode == WEB_CLIENT_MODE_OPTIONS) {
1993             code = 200;
1994             w->response.data->contenttype = CT_TEXT_PLAIN;
1995             buffer_flush(w->response.data);
1996             buffer_strcat(w->response.data, "OK");
1997         }
1998         else {
1999             char *url = w->decoded_url;
2000             char *tok = mystrsep(&url, "/?");
2001             if(tok && *tok) {
2002                 uint32_t hash = simple_hash(tok);
2003                 debug(D_WEB_CLIENT, "%llu: Processing command '%s'.", w->id, tok);
2004
2005                 if(hash == hash_api && strcmp(tok, "api") == 0) {
2006                     // the client is requesting api access
2007                     code = web_client_api_request(w, url);
2008                 }
2009                 else if(hash == hash_netdata_conf && strcmp(tok, "netdata.conf") == 0) {
2010                     code = 200;
2011                     debug(D_WEB_CLIENT_ACCESS, "%llu: Sending netdata.conf ...", w->id);
2012
2013                     w->response.data->contenttype = CT_TEXT_PLAIN;
2014                     buffer_flush(w->response.data);
2015                     generate_config(w->response.data, 0);
2016                 }
2017                 else if(hash == hash_data && strcmp(tok, WEB_PATH_DATA) == 0) { // "data"
2018                     // the client is requesting rrd data -- OLD API
2019                     code = web_client_api_old_data_request(w, url, DATASOURCE_JSON);
2020                 }
2021                 else if(hash == hash_datasource && strcmp(tok, WEB_PATH_DATASOURCE) == 0) { // "datasource"
2022                     // the client is requesting google datasource -- OLD API
2023                     code = web_client_api_old_data_request(w, url, DATASOURCE_DATATABLE_JSONP);
2024                 }
2025                 else if(hash == hash_graph && strcmp(tok, WEB_PATH_GRAPH) == 0) { // "graph"
2026                     // the client is requesting an rrd graph -- OLD API
2027
2028                     // get the name of the data to show
2029                     tok = mystrsep(&url, "/?&");
2030                     if(tok && *tok) {
2031                         debug(D_WEB_CLIENT, "%llu: Searching for RRD data with name '%s'.", w->id, tok);
2032
2033                         // do we have such a data set?
2034                         RRDSET *st = rrdset_find_byname(tok);
2035                         if(!st) st = rrdset_find(tok);
2036                         if(!st) {
2037                             // we don't have it
2038                             // try to send a file with that name
2039                             buffer_flush(w->response.data);
2040                             code = mysendfile(w, tok);
2041                         }
2042                         else {
2043                             code = 200;
2044                             debug(D_WEB_CLIENT_ACCESS, "%llu: Sending %s.json of RRD_STATS...", w->id, st->name);
2045                             w->response.data->contenttype = CT_APPLICATION_JSON;
2046                             buffer_flush(w->response.data);
2047                             rrd_stats_graph_json(st, url, w->response.data);
2048                         }
2049                     }
2050                     else {
2051                         code = 400;
2052                         buffer_flush(w->response.data);
2053                         buffer_strcat(w->response.data, "Graph name?\r\n");
2054                     }
2055                 }
2056                 else if(hash == hash_list && strcmp(tok, "list") == 0) {
2057                     // OLD API
2058                     code = 200;
2059
2060                     debug(D_WEB_CLIENT_ACCESS, "%llu: Sending list of RRD_STATS...", w->id);
2061
2062                     buffer_flush(w->response.data);
2063                     RRDSET *st = localhost.rrdset_root;
2064
2065                     for ( ; st ; st = st->next )
2066                         buffer_sprintf(w->response.data, "%s\n", st->name);
2067                 }
2068                 else if(hash == hash_all_json && strcmp(tok, "all.json") == 0) {
2069                     // OLD API
2070                     code = 200;
2071                     debug(D_WEB_CLIENT_ACCESS, "%llu: Sending JSON list of all monitors of RRD_STATS...", w->id);
2072
2073                     w->response.data->contenttype = CT_APPLICATION_JSON;
2074                     buffer_flush(w->response.data);
2075                     rrd_stats_all_json(w->response.data);
2076                 }
2077 #ifdef NETDATA_INTERNAL_CHECKS
2078                 else if(hash == hash_exit && strcmp(tok, "exit") == 0) {
2079                     code = 200;
2080                     w->response.data->contenttype = CT_TEXT_PLAIN;
2081                     buffer_flush(w->response.data);
2082
2083                     if(!netdata_exit)
2084                         buffer_strcat(w->response.data, "ok, will do...");
2085                     else
2086                         buffer_strcat(w->response.data, "I am doing it already");
2087
2088                     error("web request to exit received.");
2089                     netdata_cleanup_and_exit(0);
2090                 }
2091                 else if(hash == hash_debug && strcmp(tok, "debug") == 0) {
2092                     buffer_flush(w->response.data);
2093
2094                     // get the name of the data to show
2095                     tok = mystrsep(&url, "/?&");
2096                     if(tok && *tok) {
2097                         debug(D_WEB_CLIENT, "%llu: Searching for RRD data with name '%s'.", w->id, tok);
2098
2099                         // do we have such a data set?
2100                         RRDSET *st = rrdset_find_byname(tok);
2101                         if(!st) st = rrdset_find(tok);
2102                         if(!st) {
2103                             code = 404;
2104                             buffer_strcat(w->response.data, "Chart is not found: ");
2105                             buffer_strcat_htmlescape(w->response.data, tok);
2106                             debug(D_WEB_CLIENT_ACCESS, "%llu: %s is not found.", w->id, tok);
2107                         }
2108                         else {
2109                             code = 200;
2110                             debug_flags |= D_RRD_STATS;
2111                             st->debug = !st->debug;
2112                             buffer_sprintf(w->response.data, "Chart has now debug %s: ", st->debug?"enabled":"disabled");
2113                             buffer_strcat_htmlescape(w->response.data, tok);
2114                             debug(D_WEB_CLIENT_ACCESS, "%llu: debug for %s is %s.", w->id, tok, st->debug?"enabled":"disabled");
2115                         }
2116                     }
2117                     else {
2118                         code = 500;
2119                         buffer_flush(w->response.data);
2120                         buffer_strcat(w->response.data, "debug which chart?\r\n");
2121                     }
2122                 }
2123                 else if(hash == hash_mirror && strcmp(tok, "mirror") == 0) {
2124                     code = 200;
2125
2126                     debug(D_WEB_CLIENT_ACCESS, "%llu: Mirroring...", w->id);
2127
2128                     // replace the zero bytes with spaces
2129                     buffer_char_replace(w->response.data, '\0', ' ');
2130
2131                     // just leave the buffer as is
2132                     // it will be copied back to the client
2133                 }
2134 #endif  /* NETDATA_INTERNAL_CHECKS */
2135                 else {
2136                     char filename[FILENAME_MAX+1];
2137                     url = filename;
2138                     strncpyz(filename, w->last_url, FILENAME_MAX);
2139                     tok = mystrsep(&url, "?");
2140                     buffer_flush(w->response.data);
2141                     code = mysendfile(w, (tok && *tok)?tok:"/");
2142                 }
2143             }
2144             else {
2145                 char filename[FILENAME_MAX+1];
2146                 url = filename;
2147                 strncpyz(filename, w->last_url, FILENAME_MAX);
2148                 tok = mystrsep(&url, "?");
2149                 buffer_flush(w->response.data);
2150                 code = mysendfile(w, (tok && *tok)?tok:"/");
2151             }
2152         }
2153     }
2154
2155     now_realtime_timeval(&w->tv_ready);
2156     w->response.sent = 0;
2157     w->response.code = code;
2158
2159     // set a proper last modified date
2160     if(unlikely(!w->response.data->date))
2161         w->response.data->date = w->tv_ready.tv_sec;
2162
2163     if(unlikely(code != 200))
2164         buffer_no_cacheable(w->response.data);
2165
2166     // set a proper expiration date, if not already set
2167     if(unlikely(!w->response.data->expires)) {
2168         if(w->response.data->options & WB_CONTENT_NO_CACHEABLE)
2169             w->response.data->expires = w->tv_ready.tv_sec + rrd_update_every;
2170         else
2171             w->response.data->expires = w->tv_ready.tv_sec + 86400;
2172     }
2173
2174     // prepare the HTTP response header
2175     debug(D_WEB_CLIENT, "%llu: Generating HTTP header with response %d.", w->id, code);
2176
2177     const char *content_type_string = web_content_type_to_string(w->response.data->contenttype);
2178     const char *code_msg = web_response_code_to_string(code);
2179
2180     // prepare the last modified and expiration dates
2181     char date[32], edate[32];
2182     {
2183         struct tm tmbuf, *tm;
2184
2185         tm = gmtime_r(&w->response.data->date, &tmbuf);
2186         strftime(date, sizeof(date), "%a, %d %b %Y %H:%M:%S %Z", tm);
2187
2188         tm = gmtime_r(&w->response.data->expires, &tmbuf);
2189         strftime(edate, sizeof(edate), "%a, %d %b %Y %H:%M:%S %Z", tm);
2190     }
2191
2192     buffer_sprintf(w->response.header_output,
2193         "HTTP/1.1 %d %s\r\n"
2194         "Connection: %s\r\n"
2195         "Server: NetData Embedded HTTP Server\r\n"
2196         "Access-Control-Allow-Origin: %s\r\n"
2197         "Access-Control-Allow-Credentials: true\r\n"
2198         "Content-Type: %s\r\n"
2199         "Date: %s\r\n"
2200         , code, code_msg
2201         , w->keepalive?"keep-alive":"close"
2202         , w->origin
2203         , content_type_string
2204         , date
2205         );
2206
2207     if(w->cookie1[0] || w->cookie2[0]) {
2208         if(w->cookie1[0]) {
2209             buffer_sprintf(w->response.header_output,
2210                "Set-Cookie: %s\r\n",
2211                w->cookie1);
2212         }
2213
2214         if(w->cookie2[0]) {
2215             buffer_sprintf(w->response.header_output,
2216                "Set-Cookie: %s\r\n",
2217                w->cookie2);
2218         }
2219
2220         if(web_donotrack_comply)
2221             buffer_sprintf(w->response.header_output,
2222                "Tk: T;cookies\r\n");
2223     }
2224     else {
2225         if(web_donotrack_comply) {
2226             if(w->tracking_required)
2227                 buffer_sprintf(w->response.header_output,
2228                    "Tk: T;cookies\r\n");
2229             else
2230                 buffer_sprintf(w->response.header_output,
2231                    "Tk: N\r\n");
2232         }
2233     }
2234
2235     if(w->mode == WEB_CLIENT_MODE_OPTIONS) {
2236         buffer_strcat(w->response.header_output,
2237             "Access-Control-Allow-Methods: GET, OPTIONS\r\n"
2238             "Access-Control-Allow-Headers: accept, x-requested-with, origin, content-type, cookie, pragma, cache-control\r\n"
2239             "Access-Control-Max-Age: 1209600\r\n" // 86400 * 14
2240             );
2241     }
2242     else {
2243         buffer_sprintf(w->response.header_output,
2244             "Cache-Control: %s\r\n"
2245             "Expires: %s\r\n",
2246             (w->response.data->options & WB_CONTENT_NO_CACHEABLE)?"no-cache":"public",
2247             edate);
2248     }
2249
2250     // copy a possibly available custom header
2251     if(unlikely(buffer_strlen(w->response.header)))
2252         buffer_strcat(w->response.header_output, buffer_tostring(w->response.header));
2253
2254     // headers related to the transfer method
2255     if(likely(w->response.zoutput)) {
2256         buffer_strcat(w->response.header_output,
2257             "Content-Encoding: gzip\r\n"
2258             "Transfer-Encoding: chunked\r\n"
2259             );
2260     }
2261     else {
2262         if(likely((w->response.data->len || w->response.rlen))) {
2263             // we know the content length, put it
2264             buffer_sprintf(w->response.header_output, "Content-Length: %zu\r\n", w->response.data->len? w->response.data->len: w->response.rlen);
2265         }
2266         else {
2267             // we don't know the content length, disable keep-alive
2268             w->keepalive = 0;
2269         }
2270     }
2271
2272     // end of HTTP header
2273     buffer_strcat(w->response.header_output, "\r\n");
2274
2275     // sent the HTTP header
2276     debug(D_WEB_DATA, "%llu: Sending response HTTP header of size %zu: '%s'"
2277             , w->id
2278             , buffer_strlen(w->response.header_output)
2279             , buffer_tostring(w->response.header_output)
2280             );
2281
2282     web_client_crock_socket(w);
2283
2284     bytes = send(w->ofd, buffer_tostring(w->response.header_output), buffer_strlen(w->response.header_output), 0);
2285     if(bytes != (ssize_t) buffer_strlen(w->response.header_output)) {
2286         if(bytes > 0)
2287             w->stats_sent_bytes += bytes;
2288
2289         debug(D_WEB_CLIENT, "%llu: HTTP Header failed to be sent (I sent %zu bytes but the system sent %zd bytes). Closing web client."
2290             , w->id
2291             , buffer_strlen(w->response.header_output)
2292             , bytes);
2293
2294         WEB_CLIENT_IS_DEAD(w);
2295         return;
2296     }
2297     else
2298         w->stats_sent_bytes += bytes;
2299
2300     // enable sending immediately if we have data
2301     if(w->response.data->len) w->wait_send = 1;
2302     else w->wait_send = 0;
2303
2304     // pretty logging
2305     switch(w->mode) {
2306         case WEB_CLIENT_MODE_OPTIONS:
2307             debug(D_WEB_CLIENT, "%llu: Done preparing the OPTIONS response. Sending data (%zu bytes) to client.", w->id, w->response.data->len);
2308             break;
2309
2310         case WEB_CLIENT_MODE_NORMAL:
2311             debug(D_WEB_CLIENT, "%llu: Done preparing the response. Sending data (%zu bytes) to client.", w->id, w->response.data->len);
2312             break;
2313
2314         case WEB_CLIENT_MODE_FILECOPY:
2315             if(w->response.rlen) {
2316                 debug(D_WEB_CLIENT, "%llu: Done preparing the response. Will be sending data file of %zu bytes to client.", w->id, w->response.rlen);
2317                 w->wait_receive = 1;
2318
2319                 /*
2320                 // utilize the kernel sendfile() for copying the file to the socket.
2321                 // this block of code can be commented, without anything missing.
2322                 // when it is commented, the program will copy the data using async I/O.
2323                 {
2324                     long len = sendfile(w->ofd, w->ifd, NULL, w->response.data->rbytes);
2325                     if(len != w->response.data->rbytes)
2326                         error("%llu: sendfile() should copy %ld bytes, but copied %ld. Falling back to manual copy.", w->id, w->response.data->rbytes, len);
2327                     else
2328                         web_client_reset(w);
2329                 }
2330                 */
2331             }
2332             else
2333                 debug(D_WEB_CLIENT, "%llu: Done preparing the response. Will be sending an unknown amount of bytes to client.", w->id);
2334             break;
2335
2336         default:
2337             fatal("%llu: Unknown client mode %d.", w->id, w->mode);
2338             break;
2339     }
2340 }
2341
2342 ssize_t web_client_send_chunk_header(struct web_client *w, size_t len)
2343 {
2344     debug(D_DEFLATE, "%llu: OPEN CHUNK of %zu bytes (hex: %zx).", w->id, len, len);
2345     char buf[24];
2346     sprintf(buf, "%zX\r\n", len);
2347
2348     ssize_t bytes = send(w->ofd, buf, strlen(buf), 0);
2349     if(bytes > 0) {
2350         debug(D_DEFLATE, "%llu: Sent chunk header %zd bytes.", w->id, bytes);
2351         w->stats_sent_bytes += bytes;
2352     }
2353
2354     else if(bytes == 0) {
2355         debug(D_WEB_CLIENT, "%llu: Did not send chunk header to the client.", w->id);
2356         WEB_CLIENT_IS_DEAD(w);
2357     }
2358     else {
2359         debug(D_WEB_CLIENT, "%llu: Failed to send chunk header to client.", w->id);
2360         WEB_CLIENT_IS_DEAD(w);
2361     }
2362
2363     return bytes;
2364 }
2365
2366 ssize_t web_client_send_chunk_close(struct web_client *w)
2367 {
2368     //debug(D_DEFLATE, "%llu: CLOSE CHUNK.", w->id);
2369
2370     ssize_t bytes = send(w->ofd, "\r\n", 2, 0);
2371     if(bytes > 0) {
2372         debug(D_DEFLATE, "%llu: Sent chunk suffix %zd bytes.", w->id, bytes);
2373         w->stats_sent_bytes += bytes;
2374     }
2375
2376     else if(bytes == 0) {
2377         debug(D_WEB_CLIENT, "%llu: Did not send chunk suffix to the client.", w->id);
2378         WEB_CLIENT_IS_DEAD(w);
2379     }
2380     else {
2381         debug(D_WEB_CLIENT, "%llu: Failed to send chunk suffix to client.", w->id);
2382         WEB_CLIENT_IS_DEAD(w);
2383     }
2384
2385     return bytes;
2386 }
2387
2388 ssize_t web_client_send_chunk_finalize(struct web_client *w)
2389 {
2390     //debug(D_DEFLATE, "%llu: FINALIZE CHUNK.", w->id);
2391
2392     ssize_t bytes = send(w->ofd, "\r\n0\r\n\r\n", 7, 0);
2393     if(bytes > 0) {
2394         debug(D_DEFLATE, "%llu: Sent chunk suffix %zd bytes.", w->id, bytes);
2395         w->stats_sent_bytes += bytes;
2396     }
2397
2398     else if(bytes == 0) {
2399         debug(D_WEB_CLIENT, "%llu: Did not send chunk finalize suffix to the client.", w->id);
2400         WEB_CLIENT_IS_DEAD(w);
2401     }
2402     else {
2403         debug(D_WEB_CLIENT, "%llu: Failed to send chunk finalize suffix to client.", w->id);
2404         WEB_CLIENT_IS_DEAD(w);
2405     }
2406
2407     return bytes;
2408 }
2409
2410 #ifdef NETDATA_WITH_ZLIB
2411 ssize_t web_client_send_deflate(struct web_client *w)
2412 {
2413     ssize_t len = 0, t = 0;
2414
2415     // when using compression,
2416     // w->response.sent is the amount of bytes passed through compression
2417
2418     debug(D_DEFLATE, "%llu: web_client_send_deflate(): w->response.data->len = %zu, w->response.sent = %zu, w->response.zhave = %zu, w->response.zsent = %zu, w->response.zstream.avail_in = %u, w->response.zstream.avail_out = %u, w->response.zstream.total_in = %lu, w->response.zstream.total_out = %lu.",
2419         w->id, w->response.data->len, w->response.sent, w->response.zhave, w->response.zsent, w->response.zstream.avail_in, w->response.zstream.avail_out, w->response.zstream.total_in, w->response.zstream.total_out);
2420
2421     if(w->response.data->len - w->response.sent == 0 && w->response.zstream.avail_in == 0 && w->response.zhave == w->response.zsent && w->response.zstream.avail_out != 0) {
2422         // there is nothing to send
2423
2424         debug(D_WEB_CLIENT, "%llu: Out of output data.", w->id);
2425
2426         // finalize the chunk
2427         if(w->response.sent != 0) {
2428             t = web_client_send_chunk_finalize(w);
2429             if(t < 0) return t;
2430         }
2431
2432         if(w->mode == WEB_CLIENT_MODE_FILECOPY && w->wait_receive && w->response.rlen && w->response.rlen > w->response.data->len) {
2433             // we have to wait, more data will come
2434             debug(D_WEB_CLIENT, "%llu: Waiting for more data to become available.", w->id);
2435             w->wait_send = 0;
2436             return t;
2437         }
2438
2439         if(unlikely(!w->keepalive)) {
2440             debug(D_WEB_CLIENT, "%llu: Closing (keep-alive is not enabled). %zu bytes sent.", w->id, w->response.sent);
2441             WEB_CLIENT_IS_DEAD(w);
2442             return t;
2443         }
2444
2445         // reset the client
2446         web_client_reset(w);
2447         debug(D_WEB_CLIENT, "%llu: Done sending all data on socket.", w->id);
2448         return t;
2449     }
2450
2451     if(w->response.zhave == w->response.zsent) {
2452         // compress more input data
2453
2454         // close the previous open chunk
2455         if(w->response.sent != 0) {
2456             t = web_client_send_chunk_close(w);
2457             if(t < 0) return t;
2458         }
2459
2460         debug(D_DEFLATE, "%llu: Compressing %zu new bytes starting from %zu (and %u left behind).", w->id, (w->response.data->len - w->response.sent), w->response.sent, w->response.zstream.avail_in);
2461
2462         // give the compressor all the data not passed through the compressor yet
2463         if(w->response.data->len > w->response.sent) {
2464             w->response.zstream.next_in = (Bytef *)&w->response.data->buffer[w->response.sent - w->response.zstream.avail_in];
2465             w->response.zstream.avail_in += (uInt) (w->response.data->len - w->response.sent);
2466         }
2467
2468         // reset the compressor output buffer
2469         w->response.zstream.next_out = w->response.zbuffer;
2470         w->response.zstream.avail_out = ZLIB_CHUNK;
2471
2472         // ask for FINISH if we have all the input
2473         int flush = Z_SYNC_FLUSH;
2474         if(w->mode == WEB_CLIENT_MODE_NORMAL
2475             || (w->mode == WEB_CLIENT_MODE_FILECOPY && !w->wait_receive && w->response.data->len == w->response.rlen)) {
2476             flush = Z_FINISH;
2477             debug(D_DEFLATE, "%llu: Requesting Z_FINISH, if possible.", w->id);
2478         }
2479         else {
2480             debug(D_DEFLATE, "%llu: Requesting Z_SYNC_FLUSH.", w->id);
2481         }
2482
2483         // compress
2484         if(deflate(&w->response.zstream, flush) == Z_STREAM_ERROR) {
2485             error("%llu: Compression failed. Closing down client.", w->id);
2486             web_client_reset(w);
2487             return(-1);
2488         }
2489
2490         w->response.zhave = ZLIB_CHUNK - w->response.zstream.avail_out;
2491         w->response.zsent = 0;
2492
2493         // keep track of the bytes passed through the compressor
2494         w->response.sent = w->response.data->len;
2495
2496         debug(D_DEFLATE, "%llu: Compression produced %zu bytes.", w->id, w->response.zhave);
2497
2498         // open a new chunk
2499         ssize_t t2 = web_client_send_chunk_header(w, w->response.zhave);
2500         if(t2 < 0) return t2;
2501         t += t2;
2502     }
2503
2504     debug(D_WEB_CLIENT, "%llu: Sending %zu bytes of data (+%zd of chunk header).", w->id, w->response.zhave - w->response.zsent, t);
2505
2506     len = send(w->ofd, &w->response.zbuffer[w->response.zsent], (size_t) (w->response.zhave - w->response.zsent), MSG_DONTWAIT);
2507     if(len > 0) {
2508         w->stats_sent_bytes += len;
2509         w->response.zsent += len;
2510         len += t;
2511         debug(D_WEB_CLIENT, "%llu: Sent %zd bytes.", w->id, len);
2512     }
2513     else if(len == 0) {
2514         debug(D_WEB_CLIENT, "%llu: Did not send any bytes to the client (zhave = %zu, zsent = %zu, need to send = %zu).",
2515             w->id, w->response.zhave, w->response.zsent, w->response.zhave - w->response.zsent);
2516
2517         WEB_CLIENT_IS_DEAD(w);
2518     }
2519     else {
2520         debug(D_WEB_CLIENT, "%llu: Failed to send data to client.", w->id);
2521         WEB_CLIENT_IS_DEAD(w);
2522     }
2523
2524     return(len);
2525 }
2526 #endif // NETDATA_WITH_ZLIB
2527
2528 ssize_t web_client_send(struct web_client *w) {
2529 #ifdef NETDATA_WITH_ZLIB
2530     if(likely(w->response.zoutput)) return web_client_send_deflate(w);
2531 #endif // NETDATA_WITH_ZLIB
2532
2533     ssize_t bytes;
2534
2535     if(unlikely(w->response.data->len - w->response.sent == 0)) {
2536         // there is nothing to send
2537
2538         debug(D_WEB_CLIENT, "%llu: Out of output data.", w->id);
2539
2540         // there can be two cases for this
2541         // A. we have done everything
2542         // B. we temporarily have nothing to send, waiting for the buffer to be filled by ifd
2543
2544         if(w->mode == WEB_CLIENT_MODE_FILECOPY && w->wait_receive && w->response.rlen && w->response.rlen > w->response.data->len) {
2545             // we have to wait, more data will come
2546             debug(D_WEB_CLIENT, "%llu: Waiting for more data to become available.", w->id);
2547             w->wait_send = 0;
2548             return 0;
2549         }
2550
2551         if(unlikely(!w->keepalive)) {
2552             debug(D_WEB_CLIENT, "%llu: Closing (keep-alive is not enabled). %zu bytes sent.", w->id, w->response.sent);
2553             WEB_CLIENT_IS_DEAD(w);
2554             return 0;
2555         }
2556
2557         web_client_reset(w);
2558         debug(D_WEB_CLIENT, "%llu: Done sending all data on socket. Waiting for next request on the same socket.", w->id);
2559         return 0;
2560     }
2561
2562     bytes = send(w->ofd, &w->response.data->buffer[w->response.sent], w->response.data->len - w->response.sent, MSG_DONTWAIT);
2563     if(likely(bytes > 0)) {
2564         w->stats_sent_bytes += bytes;
2565         w->response.sent += bytes;
2566         debug(D_WEB_CLIENT, "%llu: Sent %zd bytes.", w->id, bytes);
2567     }
2568     else if(likely(bytes == 0)) {
2569         debug(D_WEB_CLIENT, "%llu: Did not send any bytes to the client.", w->id);
2570         WEB_CLIENT_IS_DEAD(w);
2571     }
2572     else {
2573         debug(D_WEB_CLIENT, "%llu: Failed to send data to client.", w->id);
2574         WEB_CLIENT_IS_DEAD(w);
2575     }
2576
2577     return(bytes);
2578 }
2579
2580 ssize_t web_client_receive(struct web_client *w)
2581 {
2582     // do we have any space for more data?
2583     buffer_need_bytes(w->response.data, WEB_REQUEST_LENGTH);
2584
2585     ssize_t left = w->response.data->size - w->response.data->len;
2586     ssize_t bytes;
2587
2588     if(unlikely(w->mode == WEB_CLIENT_MODE_FILECOPY))
2589         bytes = read(w->ifd, &w->response.data->buffer[w->response.data->len], (size_t) (left - 1));
2590     else
2591         bytes = recv(w->ifd, &w->response.data->buffer[w->response.data->len], (size_t) (left - 1), MSG_DONTWAIT);
2592
2593     if(likely(bytes > 0)) {
2594         if(w->mode != WEB_CLIENT_MODE_FILECOPY)
2595             w->stats_received_bytes += bytes;
2596
2597         size_t old = w->response.data->len;
2598         w->response.data->len += bytes;
2599         w->response.data->buffer[w->response.data->len] = '\0';
2600
2601         debug(D_WEB_CLIENT, "%llu: Received %zd bytes.", w->id, bytes);
2602         debug(D_WEB_DATA, "%llu: Received data: '%s'.", w->id, &w->response.data->buffer[old]);
2603
2604         if(w->mode == WEB_CLIENT_MODE_FILECOPY) {
2605             w->wait_send = 1;
2606
2607             if(w->response.rlen && w->response.data->len >= w->response.rlen)
2608                 w->wait_receive = 0;
2609         }
2610     }
2611     else if(likely(bytes == 0)) {
2612         debug(D_WEB_CLIENT, "%llu: Out of input data.", w->id);
2613
2614         // if we cannot read, it means we have an error on input.
2615         // if however, we are copying a file from ifd to ofd, we should not return an error.
2616         // in this case, the error should be generated when the file has been sent to the client.
2617
2618         if(w->mode == WEB_CLIENT_MODE_FILECOPY) {
2619             // we are copying data from ifd to ofd
2620             // let it finish copying...
2621             w->wait_receive = 0;
2622
2623             debug(D_WEB_CLIENT, "%llu: Read the whole file.", w->id);
2624             if(w->ifd != w->ofd) close(w->ifd);
2625             w->ifd = w->ofd;
2626         }
2627         else {
2628             debug(D_WEB_CLIENT, "%llu: failed to receive data.", w->id);
2629             WEB_CLIENT_IS_DEAD(w);
2630         }
2631     }
2632     else {
2633         debug(D_WEB_CLIENT, "%llu: receive data failed.", w->id);
2634         WEB_CLIENT_IS_DEAD(w);
2635     }
2636
2637     return(bytes);
2638 }
2639
2640
2641 // --------------------------------------------------------------------------------------
2642 // the thread of a single client
2643
2644 // 1. waits for input and output, using async I/O
2645 // 2. it processes HTTP requests
2646 // 3. it generates HTTP responses
2647 // 4. it copies data from input to output if mode is FILECOPY
2648
2649 void *web_client_main(void *ptr)
2650 {
2651     if(pthread_setcanceltype(PTHREAD_CANCEL_DEFERRED, NULL) != 0)
2652         error("Cannot set pthread cancel type to DEFERRED.");
2653
2654     if(pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL) != 0)
2655         error("Cannot set pthread cancel state to ENABLE.");
2656
2657     struct web_client *w = ptr;
2658     struct pollfd fds[2], *ifd, *ofd;
2659     int retval, fdmax = 0, timeout;
2660
2661     log_access("%llu: %s port %s connected on thread task id %d", w->id, w->client_ip, w->client_port, gettid());
2662
2663     for(;;) {
2664         if(unlikely(w->dead)) {
2665             debug(D_WEB_CLIENT, "%llu: client is dead.", w->id);
2666             break;
2667         }
2668         else if(unlikely(!w->wait_receive && !w->wait_send)) {
2669             debug(D_WEB_CLIENT, "%llu: client is not set for neither receiving nor sending data.", w->id);
2670             break;
2671         }
2672
2673         if(unlikely(w->ifd < 0 || w->ofd < 0)) {
2674             error("%llu: invalid file descriptor, ifd = %d, ofd = %d (required 0 <= fd", w->id, w->ifd, w->ofd);
2675             break;
2676         }
2677
2678         if(w->ifd == w->ofd) {
2679             fds[0].fd = w->ifd;
2680             fds[0].events = 0;
2681             fds[0].revents = 0;
2682
2683             if(w->wait_receive) fds[0].events |= POLLIN;
2684             if(w->wait_send)    fds[0].events |= POLLOUT;
2685
2686             fds[1].fd = -1;
2687             fds[1].events = 0;
2688             fds[1].revents = 0;
2689
2690             ifd = ofd = &fds[0];
2691
2692             fdmax = 1;
2693         }
2694         else {
2695             fds[0].fd = w->ifd;
2696             fds[0].events = 0;
2697             fds[0].revents = 0;
2698             if(w->wait_receive) fds[0].events |= POLLIN;
2699             ifd = &fds[0];
2700
2701             fds[1].fd = w->ofd;
2702             fds[1].events = 0;
2703             fds[1].revents = 0;
2704             if(w->wait_send)    fds[1].events |= POLLOUT;
2705             ofd = &fds[1];
2706
2707             fdmax = 2;
2708         }
2709
2710         debug(D_WEB_CLIENT, "%llu: Waiting socket async I/O for %s %s", w->id, w->wait_receive?"INPUT":"", w->wait_send?"OUTPUT":"");
2711         errno = 0;
2712         timeout = web_client_timeout * 1000;
2713         retval = poll(fds, fdmax, timeout);
2714
2715         if(unlikely(retval == -1)) {
2716             if(errno == EAGAIN || errno == EINTR) {
2717                 debug(D_WEB_CLIENT, "%llu: EAGAIN received.", w->id);
2718                 continue;
2719             }
2720
2721             debug(D_WEB_CLIENT, "%llu: LISTENER: poll() failed (input fd = %d, output fd = %d). Closing client.", w->id, w->ifd, w->ofd);
2722             break;
2723         }
2724         else if(unlikely(!retval)) {
2725             debug(D_WEB_CLIENT, "%llu: Timeout while waiting socket async I/O for %s %s", w->id, w->wait_receive?"INPUT":"", w->wait_send?"OUTPUT":"");
2726             break;
2727         }
2728
2729         int used = 0;
2730         if(w->wait_send && ofd->revents & POLLOUT) {
2731             used++;
2732             if(web_client_send(w) < 0) {
2733                 debug(D_WEB_CLIENT, "%llu: Cannot send data to client. Closing client.", w->id);
2734                 break;
2735             }
2736         }
2737
2738         if(w->wait_receive && (ifd->revents & POLLIN || ifd->revents & POLLPRI)) {
2739             used++;
2740             if(web_client_receive(w) < 0) {
2741                 debug(D_WEB_CLIENT, "%llu: Cannot receive data from client. Closing client.", w->id);
2742                 break;
2743             }
2744
2745             if(w->mode == WEB_CLIENT_MODE_NORMAL) {
2746                 debug(D_WEB_CLIENT, "%llu: Attempting to process received data.", w->id);
2747                 web_client_process(w);
2748             }
2749         }
2750
2751         if(unlikely(!used)) {
2752             debug(D_WEB_CLIENT_ACCESS, "%llu: Received error on socket.", w->id);
2753             break;
2754         }
2755     }
2756
2757     web_client_reset(w);
2758
2759     log_access("%llu: %s port %s disconnected from thread task id %d", w->id, w->client_ip, w->client_port, gettid());
2760     debug(D_WEB_CLIENT, "%llu: done...", w->id);
2761
2762     // close the sockets/files now
2763     // to free file descriptors
2764     if(w->ifd == w->ofd) {
2765         if(w->ifd != -1) close(w->ifd);
2766     }
2767     else {
2768         if(w->ifd != -1) close(w->ifd);
2769         if(w->ofd != -1) close(w->ofd);
2770     }
2771     w->ifd = -1;
2772     w->ofd = -1;
2773
2774     w->obsolete = 1;
2775
2776     pthread_exit(NULL);
2777     return NULL;
2778 }