Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

447 lines (363 sloc) 12.103 kb
/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
/* Cherokee
*
* Authors:
* Alvaro Lopez Ortega <alvaro@alobbs.com>
*
* Copyright (C) 2001-2010 Alvaro Lopez Ortega
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of version 2 of the GNU General Public
* License as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*/
#include "common-internal.h"
#include "admin_server.h"
#include "bind.h"
#include "server-protected.h"
#include "connection-protected.h"
#include "connection_info.h"
#include "source_interpreter.h"
#include "util.h"
ret_t
cherokee_admin_server_reply_get_ports (cherokee_handler_t *hdl,
cherokee_dwriter_t *dwriter)
{
cherokee_list_t *i;
cherokee_bind_t *bind_entry;
cherokee_server_t *srv = HANDLER_SRV(hdl);
cherokee_dwriter_list_open (dwriter);
list_for_each (i, &srv->listeners) {
bind_entry = BIND(i);
cherokee_dwriter_dict_open (dwriter);
cherokee_dwriter_cstring (dwriter, "id");
cherokee_dwriter_integer (dwriter, bind_entry->id);
cherokee_dwriter_cstring (dwriter, "bind");
cherokee_dwriter_bstring (dwriter, &bind_entry->ip);
cherokee_dwriter_cstring (dwriter, "port");
cherokee_dwriter_integer (dwriter, bind_entry->port);
cherokee_dwriter_cstring (dwriter, "tls");
cherokee_dwriter_bool (dwriter, BIND_IS_TLS(bind_entry));
cherokee_dwriter_dict_close (dwriter);
}
cherokee_dwriter_list_close (dwriter);
return ret_ok;
}
ret_t
cherokee_admin_server_reply_get_traffic (cherokee_handler_t *hdl,
cherokee_dwriter_t *dwriter)
{
cherokee_server_t *srv = HANDLER_SRV(hdl);
cherokee_buffer_t *tmp = THREAD_TMP_BUF2 (HANDLER_THREAD(hdl));
cherokee_dwriter_dict_open (dwriter);
cherokee_dwriter_cstring (dwriter, "tx");
if (srv->collector) {
cherokee_dwriter_integer (dwriter, COLLECTOR_TX(srv->collector));
} else {
cherokee_dwriter_number (dwriter, "-1", 2);
}
cherokee_dwriter_cstring (dwriter, "rx");
if (srv->collector) {
cherokee_dwriter_integer (dwriter, COLLECTOR_RX(srv->collector));
} else {
cherokee_dwriter_number (dwriter, "-1", 2);
}
cherokee_dwriter_cstring (dwriter, "tx_formatted");
if (srv->collector != NULL) {
cherokee_buffer_clean (tmp);
cherokee_buffer_add_fsize (tmp, COLLECTOR_TX(srv->collector));
cherokee_dwriter_bstring (dwriter, tmp);
} else {
cherokee_dwriter_null (dwriter);
}
cherokee_dwriter_cstring (dwriter, "rx_formatted");
if (srv->collector != NULL) {
cherokee_buffer_clean (tmp);
cherokee_buffer_add_fsize (tmp, COLLECTOR_RX(srv->collector));
cherokee_dwriter_bstring (dwriter, tmp);
} else {
cherokee_dwriter_null (dwriter);
}
cherokee_dwriter_dict_close (dwriter);
return ret_ok;
}
static void
render_connection_info (cherokee_connection_info_t *conn_info,
cherokee_dwriter_t *dwriter)
{
cherokee_dwriter_dict_open (dwriter);
cherokee_dwriter_cstring (dwriter, "id");
cherokee_dwriter_bstring (dwriter, &conn_info->id);
cherokee_dwriter_cstring (dwriter, "ip");
cherokee_dwriter_bstring (dwriter, &conn_info->ip);
cherokee_dwriter_cstring (dwriter, "phase");
cherokee_dwriter_bstring (dwriter, &conn_info->phase);
if (! cherokee_buffer_is_empty(&conn_info->rx)) {
cherokee_dwriter_cstring (dwriter, "rx");
cherokee_dwriter_bstring (dwriter, &conn_info->rx);
}
if (! cherokee_buffer_is_empty(&conn_info->tx)) {
cherokee_dwriter_cstring (dwriter, "tx");
cherokee_dwriter_bstring (dwriter, &conn_info->tx);
}
if (! cherokee_buffer_is_empty(&conn_info->request)) {
cherokee_dwriter_cstring (dwriter, "request");
cherokee_dwriter_bstring (dwriter, &conn_info->request);
}
if (! cherokee_buffer_is_empty(&conn_info->handler)) {
cherokee_dwriter_cstring (dwriter, "handler");
cherokee_dwriter_bstring (dwriter, &conn_info->handler);
}
if (! cherokee_buffer_is_empty(&conn_info->total_size)) {
cherokee_dwriter_cstring (dwriter, "total_size");
cherokee_dwriter_bstring (dwriter, &conn_info->total_size);
}
if (! cherokee_buffer_is_empty(&conn_info->percent)) {
cherokee_dwriter_cstring (dwriter, "percent");
cherokee_dwriter_bstring (dwriter, &conn_info->percent);
}
if (! cherokee_buffer_is_empty(&conn_info->icon)) {
cherokee_dwriter_cstring (dwriter, "icon");
cherokee_dwriter_bstring (dwriter, &conn_info->icon);
}
cherokee_dwriter_dict_close (dwriter);
}
ret_t
cherokee_admin_server_reply_get_conns (cherokee_handler_t *hdl,
cherokee_dwriter_t *dwriter)
{
ret_t ret;
cherokee_list_t connections;
cherokee_list_t *i, *tmp;
cherokee_server_t *srv = HANDLER_SRV(hdl);
/* Build the connection-info list
*/
INIT_LIST_HEAD (&connections);
ret = cherokee_connection_info_list_server (&connections, srv, HANDLER(hdl));
if (unlikely (ret == ret_error)) {
return ret_error;
}
/* Render it
*/
cherokee_dwriter_list_open (dwriter);
list_for_each (i, &connections) {
cherokee_connection_info_t *conn_info = CONN_INFO(i);
/* It won't include details about the admin requests
*/
if (! cherokee_buffer_cmp_str (&conn_info->handler, "admin")) {
continue;
}
render_connection_info (conn_info, dwriter);
}
cherokee_dwriter_list_close (dwriter);
/* Free the connection info objects
*/
list_for_each_safe (i, tmp, &connections) {
cherokee_connection_info_free (CONN_INFO(i));
}
return ret_ok;
}
ret_t
cherokee_admin_server_reply_close_conn (cherokee_handler_t *hdl,
cherokee_dwriter_t *dwriter,
cherokee_buffer_t *question)
{
ret_t ret;
char *begin;
cherokee_server_t *server = HANDLER_SRV(hdl);
if (strncmp (question->buf, "del server.connection ", 22)) {
return ret_error;
}
begin = question->buf + 22;
ret = cherokee_server_del_connection (server, begin);
cherokee_dwriter_dict_open (dwriter);
cherokee_dwriter_cstring (dwriter, "close");
cherokee_dwriter_cstring (dwriter, ret == ret_ok ? "ok" : "failed");
cherokee_dwriter_dict_close (dwriter);
return ret_ok;
}
ret_t
cherokee_admin_server_reply_get_trace (cherokee_handler_t *hdl,
cherokee_dwriter_t *dwriter)
{
ret_t ret;
cherokee_buffer_t *traces_ref = NULL;
UNUSED (hdl);
ret = cherokee_trace_get_trace (&traces_ref);
if (ret != ret_ok) {
return ret_error;
}
cherokee_dwriter_dict_open (dwriter);
cherokee_dwriter_cstring (dwriter, "trace");
if (cherokee_buffer_is_empty (traces_ref)) {
cherokee_dwriter_null (dwriter);
} else {
cherokee_dwriter_bstring (dwriter, traces_ref);
}
cherokee_dwriter_dict_close (dwriter);
return ret_ok;
}
ret_t
cherokee_admin_server_reply_set_trace (cherokee_handler_t *hdl,
cherokee_dwriter_t *dwriter,
cherokee_buffer_t *question)
{
ret_t ret;
UNUSED (hdl);
/* Process question
*/
if (strncmp (question->buf, "set server.trace ", sizeof("set server.trace ")-1)) {
return ret_error;
}
cherokee_buffer_move_to_begin (question, sizeof("set server.trace "-1));
/* Set the traces
*/
ret = cherokee_trace_set_modules (question);
if (ret != ret_ok) {
return ret_error;
}
/* Reply
*/
cherokee_dwriter_dict_open (dwriter);
cherokee_dwriter_cstring (dwriter, "set");
cherokee_dwriter_bool (dwriter, ret == ret_ok);
cherokee_dwriter_dict_close (dwriter);
return ret_ok;
}
ret_t
cherokee_admin_server_reply_set_backup_mode (cherokee_handler_t *hdl,
cherokee_dwriter_t *dwriter,
cherokee_buffer_t *question)
{
ret_t ret;
cherokee_server_t *srv = HANDLER_SRV(hdl);
cherokee_boolean_t active;
cherokee_boolean_t mode;
/* Read if the resquest if for turning it on or off
*/
if (cherokee_buffer_cmp_str (question, "set server.backup_mode on") == 0) {
mode = true;
} else if (cherokee_buffer_cmp_str (question, "set server.backup_mode off") == 0) {
mode = false;
} else {
return ret_error;
}
/* Do it
*/
ret = cherokee_server_set_backup_mode (srv, mode);
if (ret != ret_ok) return ret;
/* Build the reply
*/
cherokee_server_get_backup_mode (srv, &active);
cherokee_dwriter_dict_open (dwriter);
cherokee_dwriter_cstring (dwriter, "backup_mode");
cherokee_dwriter_bool (dwriter, mode);
cherokee_dwriter_dict_close (dwriter);
return ret_ok;
}
ret_t
cherokee_admin_server_reply_get_thread_num (cherokee_handler_t *hdl,
cherokee_dwriter_t *dwriter)
{
cherokee_server_t *srv = HANDLER_SRV(hdl);
cherokee_dwriter_dict_open (dwriter);
cherokee_dwriter_cstring (dwriter, "thread_num");
cherokee_dwriter_integer (dwriter, srv->thread_num);
cherokee_dwriter_dict_close (dwriter);
return ret_ok;
}
static ret_t
sources_while (cherokee_buffer_t *key, void *value, void *param)
{
cherokee_dwriter_t *dwriter = DWRITER(param);
cherokee_source_t *source = SOURCE(value);
cherokee_dwriter_dict_open (dwriter);
cherokee_dwriter_cstring (dwriter, "id");
cherokee_dwriter_bstring (dwriter, key);
cherokee_dwriter_cstring (dwriter, "type");
switch (source->type) {
case source_host:
cherokee_dwriter_cstring (dwriter, "host");
break;
case source_interpreter:
cherokee_dwriter_cstring (dwriter, "interpreter");
break;
default:
cherokee_dwriter_dict_close (dwriter);
SHOULDNT_HAPPEN;
return ret_error;
}
cherokee_dwriter_cstring (dwriter, "bind");
cherokee_dwriter_bstring (dwriter, &source->original);
if (source->type == source_interpreter) {
cherokee_source_interpreter_t *source_int = SOURCE_INT(source);
cherokee_dwriter_cstring (dwriter, "PID");
cherokee_dwriter_integer (dwriter, source_int->pid);
cherokee_dwriter_cstring (dwriter, "debug");
cherokee_dwriter_bool (dwriter, source_int->debug);
cherokee_dwriter_cstring (dwriter, "timeout");
cherokee_dwriter_integer (dwriter, source_int->timeout);
cherokee_dwriter_cstring (dwriter, "interpreter");
cherokee_dwriter_bstring (dwriter, &source_int->interpreter);
}
cherokee_dwriter_dict_close (dwriter);
return ret_ok;
}
ret_t
cherokee_admin_server_reply_get_sources (cherokee_handler_t *hdl,
cherokee_dwriter_t *dwriter)
{
cherokee_server_t *srv = HANDLER_SRV(hdl);
cherokee_dwriter_list_open (dwriter);
cherokee_avl_while (&srv->sources, sources_while, dwriter, NULL, NULL);
cherokee_dwriter_list_close (dwriter);
return ret_ok;
}
ret_t
cherokee_admin_server_reply_kill_source (cherokee_handler_t *hdl,
cherokee_dwriter_t *dwriter,
cherokee_buffer_t *question)
{
ret_t ret;
char *begin;
cherokee_source_t *source = NULL;
cherokee_server_t *srv = HANDLER_SRV(hdl);
if (strncmp (question->buf, "kill server.source ", sizeof("kill server.source ")-1)) {
return ret_error;
}
begin = question->buf + sizeof("kill server.source ")-1;
ret = cherokee_avl_get_ptr (&srv->sources, begin, (void **)&source);
if (ret != ret_ok) {
cherokee_dwriter_dict_open (dwriter);
cherokee_dwriter_cstring (dwriter, "source");
cherokee_dwriter_cstring (dwriter, "not found");
cherokee_dwriter_dict_close (dwriter);
return ret_ok;
}
if ((source->type != source_interpreter) ||
((source->type == source_interpreter) && (SOURCE_INT(source)->pid <= 1)))
{
cherokee_dwriter_dict_open (dwriter);
cherokee_dwriter_cstring (dwriter, "source");
cherokee_dwriter_cstring (dwriter, "nothing to kill");
cherokee_dwriter_dict_close (dwriter);
return ret_ok;
}
// TODO ****
printf ("killing PID: %d\n", SOURCE_INT(source)->pid);
// *********
cherokee_dwriter_dict_open (dwriter);
cherokee_dwriter_cstring (dwriter, "source");
cherokee_dwriter_cstring (dwriter, "killed");
cherokee_dwriter_dict_close (dwriter);
return ret_ok;
}
Jump to Line
Something went wrong with that request. Please try again.