#include "first.h" #include "base.h" #include "fdevent.h" #include "h2.h" #include "http_chunk.h" #include "http_header.h" #include "log.h" #include "plugin.h" #include #include "sys-time.h" #include #include #include #include typedef struct { const buffer *config_url; const buffer *status_url; const buffer *statistics_url; int sort; } plugin_config; typedef struct { PLUGIN_DATA; plugin_config defaults; plugin_config conf; double traffic_out; double requests; double mod_5s_traffic_out[5]; double mod_5s_requests[5]; size_t mod_5s_ndx; double rel_traffic_out; double rel_requests; double abs_traffic_out; double abs_requests; double bytes_written; } plugin_data; INIT_FUNC(mod_status_init) { return calloc(1, sizeof(plugin_data)); } static void mod_status_merge_config_cpv(plugin_config * const pconf, const config_plugin_value_t * const cpv) { switch (cpv->k_id) { /* index into static config_plugin_keys_t cpk[] */ case 0: /* status.status-url */ pconf->status_url = cpv->v.b; break; case 1: /* status.config-url */ pconf->config_url = cpv->v.b; break; case 2: /* status.statistics-url */ pconf->statistics_url = cpv->v.b; break; case 3: /* status.enable-sort */ pconf->sort = (int)cpv->v.u; break; default:/* should not happen */ return; } } static void mod_status_merge_config(plugin_config * const pconf, const config_plugin_value_t *cpv) { do { mod_status_merge_config_cpv(pconf, cpv); } while ((++cpv)->k_id != -1); } static void mod_status_patch_config(request_st * const r, plugin_data * const p) { p->conf = p->defaults; /* copy small struct instead of memcpy() */ /*memcpy(&p->conf, &p->defaults, sizeof(plugin_config));*/ for (int i = 1, used = p->nconfig; i < used; ++i) { if (config_check_cond(r, (uint32_t)p->cvlist[i].k_id)) mod_status_merge_config(&p->conf, p->cvlist + p->cvlist[i].v.u2[0]); } } SETDEFAULTS_FUNC(mod_status_set_defaults) { static const config_plugin_keys_t cpk[] = { { CONST_STR_LEN("status.status-url"), T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION } ,{ CONST_STR_LEN("status.config-url"), T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION } ,{ CONST_STR_LEN("status.statistics-url"), T_CONFIG_STRING, T_CONFIG_SCOPE_CONNECTION } ,{ CONST_STR_LEN("status.enable-sort"), T_CONFIG_BOOL, T_CONFIG_SCOPE_CONNECTION } ,{ NULL, 0, T_CONFIG_UNSET, T_CONFIG_SCOPE_UNSET } }; plugin_data * const p = p_d; if (!config_plugin_values_init(srv, p, cpk, "mod_status")) return HANDLER_ERROR; /* process and validate config directives * (init i to 0 if global context; to 1 to skip empty global context) */ for (int i = !p->cvlist[0].v.u2[1]; i < p->nconfig; ++i) { config_plugin_value_t *cpv = p->cvlist + p->cvlist[i].v.u2[0]; for (; -1 != cpv->k_id; ++cpv) { switch (cpv->k_id) { case 0: /* status.status-url */ case 1: /* status.config-url */ case 2: /* status.statistics-url */ if (buffer_is_blank(cpv->v.b)) cpv->v.b = NULL; break; case 3: /* status.enable-sort */ break; default:/* should not happen */ break; } } } p->defaults.sort = 1; /* initialize p->defaults from global config context */ if (p->nconfig > 0 && p->cvlist->v.u2[1]) { const config_plugin_value_t *cpv = p->cvlist + p->cvlist->v.u2[0]; if (-1 != cpv->k_id) mod_status_merge_config(&p->defaults, cpv); } return HANDLER_GO_ON; } static void mod_status_append_state (buffer * const b, request_state_t state) { const char *s; size_t n; switch (state) { case CON_STATE_CONNECT: s = "connect"; n = sizeof("connect")-1; break; case CON_STATE_READ: s = "read"; n = sizeof("read")-1; break; case CON_STATE_READ_POST: s = "readpost"; n = sizeof("readpost")-1; break; case CON_STATE_WRITE: s = "write"; n = sizeof("write")-1; break; case CON_STATE_CLOSE: s = "close"; n = sizeof("close")-1; break; case CON_STATE_ERROR: s = "error"; n = sizeof("error")-1; break; case CON_STATE_HANDLE_REQUEST: s = "handle-req"; n = sizeof("handle-req")-1; break; case CON_STATE_REQUEST_START: s = "req-start"; n = sizeof("req-start")-1; break; case CON_STATE_REQUEST_END: s = "req-end"; n = sizeof("req-end")-1; break; case CON_STATE_RESPONSE_START: s = "resp-start"; n = sizeof("resp-start")-1; break; case CON_STATE_RESPONSE_END: s = "resp-end"; n = sizeof("resp-end")-1; break; default: s = "(unknown)"; n = sizeof("(unknown)")-1; break; } buffer_append_string_len(b, s, n); } static const char * mod_status_get_short_state (request_state_t state) { switch (state) { case CON_STATE_CONNECT: return "."; case CON_STATE_READ: return "r"; case CON_STATE_READ_POST: return "R"; case CON_STATE_WRITE: return "W"; case CON_STATE_CLOSE: return "C"; case CON_STATE_ERROR: return "E"; case CON_STATE_HANDLE_REQUEST: return "h"; case CON_STATE_REQUEST_START: return "q"; case CON_STATE_REQUEST_END: return "Q"; case CON_STATE_RESPONSE_START: return "s"; case CON_STATE_RESPONSE_END: return "S"; default: return "x"; } } static void mod_status_header_append_sort(buffer *b, plugin_data *p, const char* k, size_t klen) { p->conf.sort ? buffer_append_str3(b, CONST_STR_LEN(""), k, klen, CONST_STR_LEN(":\n")) : buffer_append_str3(b, CONST_STR_LEN(""), k, klen, CONST_STR_LEN("\n")); } static void mod_status_get_multiplier(buffer *b, double avg, int size) { char unit[] = " "; if (avg > size) { avg /= size; unit[1] = 'k'; } if (avg > size) { avg /= size; unit[1] = 'M'; } if (avg > size) { avg /= size; unit[1] = 'G'; } if (avg > size) { avg /= size; unit[1] = 'T'; } if (avg > size) { avg /= size; unit[1] = 'P'; } if (avg > size) { avg /= size; unit[1] = 'E'; } if (avg > size) { avg /= size; unit[1] = 'Z'; } if (avg > size) { avg /= size; unit[1] = 'Y'; } if (size == 1000) { buffer_append_int(b, (intmax_t)avg); } else { /* (size == 1024) */ char buf[32+1]; buffer_append_string_len(b, buf, (size_t) snprintf(buf, sizeof(buf), "%.2f", avg)); } buffer_append_string_len(b, unit, 2); } static void mod_status_html_rtable_r (buffer * const b, const request_st * const r, const connection * const con, const unix_time64_t cur_ts) { buffer_append_str3(b, CONST_STR_LEN(""), BUF_PTR_LEN(&con->dst_addr_buf), CONST_STR_LEN("")); if (r->reqbody_length) { buffer_append_int(b, r->reqbody_queue.bytes_in); buffer_append_string_len(b, CONST_STR_LEN("/")); buffer_append_int(b, r->reqbody_length); } else buffer_append_string_len(b, CONST_STR_LEN("0/0")); buffer_append_string_len(b, CONST_STR_LEN("")); buffer_append_int(b, r->write_queue.bytes_out); buffer_append_string_len(b, CONST_STR_LEN("/")); buffer_append_int(b, r->write_queue.bytes_out + chunkqueue_length(&r->write_queue)); buffer_append_string_len(b, CONST_STR_LEN("")); if (CON_STATE_READ == r->state && !buffer_is_blank(&r->target_orig)) { buffer_append_string_len(b, CONST_STR_LEN("keep-alive")); } else mod_status_append_state(b, r->state); buffer_append_string_len(b, CONST_STR_LEN("")); buffer_append_int(b, cur_ts - r->start_hp.tv_sec); buffer_append_string_len(b, CONST_STR_LEN("")); if (buffer_is_blank(r->server_name)) buffer_append_string_encoded(b, BUF_PTR_LEN(&r->uri.authority), ENCODING_HTML); else buffer_append_string_encoded(b, BUF_PTR_LEN(r->server_name), ENCODING_HTML); buffer_append_string_len(b, CONST_STR_LEN("")); if (!buffer_is_blank(&r->uri.path)) buffer_append_string_encoded(b, BUF_PTR_LEN(&r->uri.path), ENCODING_HTML); if (!buffer_is_blank(&r->uri.query)) { buffer_append_string_len(b, CONST_STR_LEN("?")); buffer_append_string_encoded(b, BUF_PTR_LEN(&r->uri.query), ENCODING_HTML); } if (!buffer_is_blank(&r->target_orig)) { buffer_append_string_len(b, CONST_STR_LEN(" (")); buffer_append_string_encoded(b, BUF_PTR_LEN(&r->target_orig), ENCODING_HTML); buffer_append_string_len(b, CONST_STR_LEN(")")); } buffer_append_string_len(b, CONST_STR_LEN("")); buffer_append_string_encoded(b, BUF_PTR_LEN(&r->physical.path), ENCODING_HTML); buffer_append_string_len(b, CONST_STR_LEN("\n")); } static void mod_status_html_rtable (request_st * const rq, const server * const srv, const unix_time64_t cur_ts) { /* connection table and URLs might be large, so double-buffer to aggregate * before sending to chunkqueue, which might be temporary file * (avoid write() per connection) */ buffer * const b = rq->tmp_buf; buffer_clear(b); for (const connection *con = srv->conns; con; con = con->next) { const request_st * const r = &con->request; if (r->http_status <= HTTP_VERSION_1_1) { if (buffer_string_space(b) < 4096) { http_chunk_append_mem(rq, BUF_PTR_LEN(b)); buffer_clear(b); } mod_status_html_rtable_r(b, r, con, cur_ts); } else { h2con * const h2c = con->h2; for (uint32_t j = 0, rused = h2c->rused; j < rused; ++j) { if (buffer_string_space(b) < 4096) { http_chunk_append_mem(rq, BUF_PTR_LEN(b)); buffer_clear(b); } mod_status_html_rtable_r(b, h2c->r[j], con, cur_ts); } } } http_chunk_append_mem(rq, BUF_PTR_LEN(b)); } static handler_t mod_status_handle_server_status_html(server *srv, request_st * const r, plugin_data *p) { buffer * const b = chunkqueue_append_buffer_open(&r->write_queue); buffer_string_prepare_append(b, 8192-1);/*(status page base HTML is ~5.2k)*/ double avg; uint32_t j; unix_time64_t ts; const unix_time64_t cur_ts = log_epoch_secs; int days, hours, mins, seconds; /*(CON_STATE_CLOSE must be last state in enum connection_state_t)*/ int cstates[CON_STATE_CLOSE+3]; memset(cstates, 0, sizeof(cstates)); buffer_copy_string_len(b, CONST_STR_LEN( "\n" "\n" "\n" " \n" " Status\n" " \n")); if (!buffer_is_blank(&r->uri.query) && 0 == memcmp(r->uri.query.ptr, CONST_STR_LEN("refresh="))) { /* Note: Refresh is an historical, but non-standard HTTP header * References (meta http-equiv="refresh" use is deprecated): * https://www.w3.org/TR/WCAG10-HTML-TECHS/#meta-element * https://www.w3.org/TR/WCAG10-CORE-TECHS/#auto-page-refresh * https://www.w3.org/QA/Tips/reback */ const long refresh = strtol(r->uri.query.ptr+sizeof("refresh=")-1, NULL, 10); if (refresh > 0) { buffer_append_string_len(b, CONST_STR_LEN("\n")); } } if (p->conf.sort) { buffer_append_string_len(b, CONST_STR_LEN( "\n")); } buffer_append_string_len(b, CONST_STR_LEN( " \n" "\n")); /* connection listing */ buffer_append_string_len(b, CONST_STR_LEN("

Server-Status")); if (r->conf.server_tag) buffer_append_str3(b, CONST_STR_LEN( " ("), BUF_PTR_LEN(r->conf.server_tag), CONST_STR_LEN( ")")); buffer_append_string_len(b, CONST_STR_LEN("

" "" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n" "\n")); for (j = 0, avg = 0; j < 5; j++) { avg += p->mod_5s_requests[j]; } avg /= 5; buffer_append_string_len(b, CONST_STR_LEN("\n")); for (j = 0, avg = 0; j < 5; j++) { avg += p->mod_5s_traffic_out[j]; } avg /= 5; buffer_append_string_len(b, CONST_STR_LEN("\n" "
Hostname")); buffer_append_string_encoded(b, BUF_PTR_LEN(&r->uri.authority), ENCODING_HTML); if (!buffer_is_blank(r->server_name) && r->server_name != &r->uri.authority) { buffer_append_string_len(b, CONST_STR_LEN(" (")); buffer_append_string_encoded(b, BUF_PTR_LEN(r->server_name), ENCODING_HTML); buffer_append_string_len(b, CONST_STR_LEN(")")); } buffer_append_string_len(b, CONST_STR_LEN("
Uptime")); ts = cur_ts - srv->startup_ts; days = ts / (60 * 60 * 24); ts %= (60 * 60 * 24); hours = ts / (60 * 60); ts %= (60 * 60); mins = ts / (60); ts %= (60); seconds = ts; if (days) { buffer_append_int(b, days); buffer_append_string_len(b, CONST_STR_LEN(" days ")); } if (hours) { buffer_append_int(b, hours); buffer_append_string_len(b, CONST_STR_LEN(" hours ")); } if (mins) { buffer_append_int(b, mins); buffer_append_string_len(b, CONST_STR_LEN(" min ")); } buffer_append_int(b, seconds); buffer_append_string_len(b, CONST_STR_LEN(" s" "
Started at")); ts = srv->startup_ts; struct tm tm; buffer_append_strftime(b, "%F %T", localtime64_r(&ts, &tm)); buffer_append_string_len(b, CONST_STR_LEN("
absolute (since start)
Requests")); avg = p->abs_requests; mod_status_get_multiplier(b, avg, 1000); buffer_append_string_len(b, CONST_STR_LEN("req
Traffic")); avg = p->abs_traffic_out; mod_status_get_multiplier(b, avg, 1024); buffer_append_string_len(b, CONST_STR_LEN("byte
average (since start)
Requests")); avg = p->abs_requests / (cur_ts - srv->startup_ts); mod_status_get_multiplier(b, avg, 1000); buffer_append_string_len(b, CONST_STR_LEN("req/s
Traffic")); avg = p->abs_traffic_out / (cur_ts - srv->startup_ts); mod_status_get_multiplier(b, avg, 1024); buffer_append_string_len(b, CONST_STR_LEN("byte/s
average (5s sliding average)
Requests")); mod_status_get_multiplier(b, avg, 1000); buffer_append_string_len(b, CONST_STR_LEN("req/s
Traffic")); mod_status_get_multiplier(b, avg, 1024); buffer_append_string_len(b, CONST_STR_LEN("byte/s
\n" "
\n
\n"
	                                          ""));
	buffer_append_int(b, srv->srvconf.max_conns - srv->lim_conns);
	buffer_append_string_len(b, CONST_STR_LEN(" connections\n"));

	int per_line = 50;
	for (const connection *c = srv->conns; c; c = c->next) {
		const request_st * const cr = &c->request;
		const char *state;

		if ((c->h2 && 0 == c->h2->rused)
		    || (CON_STATE_READ == cr->state && !buffer_is_blank(&cr->target_orig))) {
			state = "k";
			++cstates[CON_STATE_CLOSE+2];
		} else {
			state = mod_status_get_short_state(cr->state);
			++cstates[(cr->state <= CON_STATE_CLOSE ? cr->state : CON_STATE_CLOSE+1)];
		}

		buffer_append_string_len(b, state, 1);

		if (0 == --per_line) {
			per_line = 50;
			buffer_append_string_len(b, CONST_STR_LEN("\n"));
		}
	}
	buffer_append_string_len(b, CONST_STR_LEN("\n\n\n"
	                                          "\n"));
	for (j = 0; j < CON_STATE_CLOSE+2; ++j) {
		/*(skip "unknown" state if there are none; there should not be any unknown)*/
		if (0 == cstates[j] && j == CON_STATE_CLOSE+1) continue;
		buffer_append_string_len(b, CONST_STR_LEN("\n"));
	}
	buffer_append_string_len(b, CONST_STR_LEN(
	  "
"));
	buffer_append_int(b, cstates[CON_STATE_CLOSE+2]);
	buffer_append_string_len(b, CONST_STR_LEN("  k = keep-alive
"));
		buffer_append_int(b, cstates[j]);
		buffer_append_str3(b, CONST_STR_LEN("  "),
		                      mod_status_get_short_state(j), 1,
		                      CONST_STR_LEN(" = "));
		mod_status_append_state(b, j);
		buffer_append_string_len(b, CONST_STR_LEN("
\n"
	  "
\n

Connections

\n" "\n" "")); mod_status_header_append_sort(b, p, CONST_STR_LEN("Client IP")); mod_status_header_append_sort(b, p, CONST_STR_LEN("Read")); mod_status_header_append_sort(b, p, CONST_STR_LEN("Written")); mod_status_header_append_sort(b, p, CONST_STR_LEN("State")); mod_status_header_append_sort(b, p, CONST_STR_LEN("Time")); mod_status_header_append_sort(b, p, CONST_STR_LEN("Host")); mod_status_header_append_sort(b, p, CONST_STR_LEN("URI")); mod_status_header_append_sort(b, p, CONST_STR_LEN("File")); buffer_append_string_len(b, CONST_STR_LEN("\n")); chunkqueue_append_buffer_commit(&r->write_queue); /* connection table might be large, so buffer separately */ mod_status_html_rtable(r, srv, cur_ts); http_chunk_append_mem(r, CONST_STR_LEN( "
\n" "\n" "\n" )); http_header_response_set(r, HTTP_HEADER_CONTENT_TYPE, CONST_STR_LEN("Content-Type"), CONST_STR_LEN("text/html")); return 0; } static handler_t mod_status_handle_server_status_text(server *srv, request_st * const r, plugin_data *p) { buffer *b = chunkqueue_append_buffer_open(&r->write_queue); /* output total number of requests */ buffer_append_string_len(b, CONST_STR_LEN("Total Accesses: ")); buffer_append_int(b, (intmax_t)p->abs_requests); buffer_append_string_len(b, CONST_STR_LEN("\nTotal kBytes: ")); buffer_append_int(b, (intmax_t)(p->abs_traffic_out / 1024)); buffer_append_string_len(b, CONST_STR_LEN("\nUptime: ")); buffer_append_int(b, log_epoch_secs - srv->startup_ts); buffer_append_string_len(b, CONST_STR_LEN("\nBusyServers: ")); buffer_append_int(b, srv->srvconf.max_conns - srv->lim_conns); buffer_append_string_len(b, CONST_STR_LEN("\nIdleServers: ")); buffer_append_int(b, srv->lim_conns); /*(could omit)*/ buffer_append_string_len(b, CONST_STR_LEN("\nScoreboard: ")); for (const connection *c = srv->conns; c; c = c->next) { const request_st * const cr = &c->request; const char *state = ((c->h2 && 0 == c->h2->rused) || (CON_STATE_READ == cr->state && !buffer_is_blank(&cr->target_orig))) ? "k" : mod_status_get_short_state(cr->state); buffer_append_string_len(b, state, 1); } for (uint32_t i = 0; i < srv->lim_conns; ++i) { /*(could omit)*/ buffer_append_string_len(b, CONST_STR_LEN("_")); } buffer_append_string_len(b, CONST_STR_LEN("\n")); chunkqueue_append_buffer_commit(&r->write_queue); /* set text/plain output */ http_header_response_set(r, HTTP_HEADER_CONTENT_TYPE, CONST_STR_LEN("Content-Type"), CONST_STR_LEN("text/plain")); return 0; } static handler_t mod_status_handle_server_status_json(server *srv, request_st * const r, plugin_data *p) { buffer *b = chunkqueue_append_buffer_open(&r->write_queue); double avg; uint32_t j; unsigned int jsonp = 0; if (buffer_clen(&r->uri.query) >= sizeof("jsonp=")-1 && 0 == memcmp(r->uri.query.ptr, CONST_STR_LEN("jsonp="))) { /* not a full parse of query string for multiple parameters, * not URL-decoding param and not XML-encoding (XSS protection), * so simply ensure that json function name isalnum() or '_' */ const char *f = r->uri.query.ptr + sizeof("jsonp=")-1; int len = 0; while (light_isalnum(f[len]) || f[len] == '_') ++len; if (0 != len && light_isalpha(f[0]) && f[len] == '\0') { buffer_append_str2(b, f, len, CONST_STR_LEN("(")); jsonp = 1; } } buffer_append_string_len(b, CONST_STR_LEN("{\n\t\"RequestsTotal\": ")); buffer_append_int(b, (intmax_t)p->abs_requests); buffer_append_string_len(b, CONST_STR_LEN(",\n\t\"TrafficTotal\": ")); buffer_append_int(b, (intmax_t)(p->abs_traffic_out / 1024)); buffer_append_string_len(b, CONST_STR_LEN(",\n\t\"Uptime\": ")); buffer_append_int(b, log_epoch_secs - srv->startup_ts); buffer_append_string_len(b, CONST_STR_LEN(",\n\t\"BusyServers\": ")); buffer_append_int(b, srv->srvconf.max_conns - srv->lim_conns); buffer_append_string_len(b, CONST_STR_LEN(",\n\t\"IdleServers\": ")); buffer_append_int(b, srv->lim_conns); /*(could omit)*/ buffer_append_string_len(b, CONST_STR_LEN(",\n")); for (j = 0, avg = 0; j < 5; j++) { avg += p->mod_5s_requests[j]; } avg /= 5; buffer_append_string_len(b, CONST_STR_LEN("\t\"RequestAverage5s\":")); buffer_append_int(b, avg); buffer_append_string_len(b, CONST_STR_LEN(",\n")); for (j = 0, avg = 0; j < 5; j++) { avg += p->mod_5s_traffic_out[j]; } avg /= 5; buffer_append_string_len(b, CONST_STR_LEN("\t\"TrafficAverage5s\":")); buffer_append_int(b, avg / 1024); /* kbps */ buffer_append_string_len(b, CONST_STR_LEN("\n}")); if (jsonp) buffer_append_string_len(b, CONST_STR_LEN(");")); chunkqueue_append_buffer_commit(&r->write_queue); /* set text/plain output */ http_header_response_set(r, HTTP_HEADER_CONTENT_TYPE, CONST_STR_LEN("Content-Type"), CONST_STR_LEN("application/javascript")); return 0; } static handler_t mod_status_handle_server_statistics(request_st * const r) { buffer *b; size_t i; array *st = &plugin_stats; if (0 == st->used) { /* we have nothing to send */ r->http_status = 204; r->resp_body_finished = 1; return HANDLER_FINISHED; } b = chunkqueue_append_buffer_open(&r->write_queue); for (i = 0; i < st->used; i++) { buffer_append_str2(b, BUF_PTR_LEN(&st->sorted[i]->key), CONST_STR_LEN(": ")); buffer_append_int(b, ((data_integer *)st->sorted[i])->value); buffer_append_string_len(b, CONST_STR_LEN("\n")); } chunkqueue_append_buffer_commit(&r->write_queue); http_header_response_set(r, HTTP_HEADER_CONTENT_TYPE, CONST_STR_LEN("Content-Type"), CONST_STR_LEN("text/plain")); r->http_status = 200; r->resp_body_finished = 1; return HANDLER_FINISHED; } static handler_t mod_status_handle_server_status(request_st * const r, plugin_data * const p) { server * const srv = r->con->srv; if (buffer_is_equal_string(&r->uri.query, CONST_STR_LEN("auto"))) { mod_status_handle_server_status_text(srv, r, p); } else if (buffer_clen(&r->uri.query) >= sizeof("json")-1 && 0 == memcmp(r->uri.query.ptr, CONST_STR_LEN("json"))) { mod_status_handle_server_status_json(srv, r, p); } else { mod_status_handle_server_status_html(srv, r, p); } r->http_status = 200; r->resp_body_finished = 1; return HANDLER_FINISHED; } static void mod_status_row_append(buffer *b, const char *k, size_t klen, const char *v, size_t vlen) { struct const_iovec iov[] = { { CONST_STR_LEN(" \n" " ") } ,{ k, klen } ,{ CONST_STR_LEN("\n" " ") } ,{ v, vlen } ,{ CONST_STR_LEN("\n" " \n") } }; buffer_append_iovec(b, iov, sizeof(iov)/sizeof(*iov)); } static void mod_status_header_append(buffer *b, const char *k, size_t klen) { buffer_append_str3(b, CONST_STR_LEN(" \n" " "), k, klen, CONST_STR_LEN("\n" " \n")); } static handler_t mod_status_handle_server_config(request_st * const r) { server * const srv = r->con->srv; buffer * const tb = r->tmp_buf; buffer_clear(tb); for (uint32_t i = 0; i < srv->plugins.used; ++i) { const char *name = ((plugin **)srv->plugins.ptr)[i]->name; if (i != 0) { buffer_append_string_len(tb, CONST_STR_LEN("
")); } buffer_append_string_len(tb, name, strlen(name)); } buffer *b = chunkqueue_append_buffer_open(&r->write_queue); /*(could expand the following into a single buffer_append_iovec(), * but this routine is not expected to be under high load)*/ buffer_append_string_len(b, CONST_STR_LEN( "\n" "\n" "\n" " \n" " Status\n" " \n" " \n")); if (r->conf.server_tag) buffer_append_str3(b, CONST_STR_LEN( "

"), BUF_PTR_LEN(r->conf.server_tag), CONST_STR_LEN( "

\n")); buffer_append_string_len(b, CONST_STR_LEN( " \n")); mod_status_header_append(b, CONST_STR_LEN("Server-Features")); #ifdef HAVE_PCRE_H mod_status_row_append(b, CONST_STR_LEN("RegEx Conditionals"), CONST_STR_LEN("enabled")); #else mod_status_row_append(b, CONST_STR_LEN("RegEx Conditionals"), CONST_STR_LEN("disabled - pcre missing")); #endif mod_status_header_append(b, CONST_STR_LEN("Network Engine")); mod_status_row_append(b, CONST_STR_LEN("fd-Event-Handler"), srv->srvconf.event_handler, strlen(srv->srvconf.event_handler)); mod_status_header_append(b, CONST_STR_LEN("Config-File-Settings")); mod_status_row_append(b, CONST_STR_LEN("Loaded Modules"), BUF_PTR_LEN(tb)); buffer_append_string_len(b, CONST_STR_LEN( "
\n" " \n" "\n" )); chunkqueue_append_buffer_commit(&r->write_queue); http_header_response_set(r, HTTP_HEADER_CONTENT_TYPE, CONST_STR_LEN("Content-Type"), CONST_STR_LEN("text/html")); r->http_status = 200; r->resp_body_finished = 1; return HANDLER_FINISHED; } static handler_t mod_status_handler(request_st * const r, void *p_d) { plugin_data *p = p_d; if (NULL != r->handler_module) return HANDLER_GO_ON; mod_status_patch_config(r, p); if (p->conf.status_url && buffer_is_equal(p->conf.status_url, &r->uri.path)) { return mod_status_handle_server_status(r, p); } else if (p->conf.config_url && buffer_is_equal(p->conf.config_url, &r->uri.path)) { return mod_status_handle_server_config(r); } else if (p->conf.statistics_url && buffer_is_equal(p->conf.statistics_url, &r->uri.path)) { return mod_status_handle_server_statistics(r); } return HANDLER_GO_ON; } TRIGGER_FUNC(mod_status_trigger) { plugin_data *p = p_d; /* check all connections */ for (const connection *c = srv->conns; c; c = c->next) p->bytes_written += c->bytes_written_cur_second; /* a sliding average */ p->mod_5s_traffic_out[p->mod_5s_ndx] = p->bytes_written; p->mod_5s_requests [p->mod_5s_ndx] = p->requests; p->mod_5s_ndx = (p->mod_5s_ndx+1) % 5; p->abs_traffic_out += p->bytes_written; p->rel_traffic_out += p->bytes_written; p->bytes_written = 0; /* reset storage - second */ p->traffic_out = 0; p->requests = 0; return HANDLER_GO_ON; } REQUESTDONE_FUNC(mod_status_account) { plugin_data *p = p_d; p->requests++; p->rel_requests++; p->abs_requests++; p->bytes_written += r->con->bytes_written_cur_second; return HANDLER_GO_ON; } int mod_status_plugin_init(plugin *p); int mod_status_plugin_init(plugin *p) { p->version = LIGHTTPD_VERSION_ID; p->name = "status"; p->init = mod_status_init; p->set_defaults= mod_status_set_defaults; p->handle_uri_clean = mod_status_handler; p->handle_trigger = mod_status_trigger; p->handle_request_done = mod_status_account; return 0; }