mhttpd.cxx File Reference

#include <stdio.h>
#include <math.h>
#include <assert.h>
#include <algorithm>
#include <thread>
#include <deque>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include "midas.h"
#include "msystem.h"
#include "mxml.h"
#include "odbxx.h"
#include "mstrlcpy.h"
#include "mgd.h"
#include "history.h"
#include "mjsonrpc.h"
#include "mvodb.h"

Include dependency graph for mhttpd.cxx:

Go to the source code of this file.

Classes
class	Attachment
struct	MimetypeTableEntry
class	RequestTrace
class	RequestTraceBuf
class	Return
class	Param
struct	search_data
struct	CGIF_LABEL
struct	CGIF_BAR
struct	HistoryData
struct	HistVar
struct	HistPlot
struct	Cookies
struct	AuthEntry
class	Auth

Macros
#define	DEFAULT_REFRESH   60
#define	MAX_GROUPS   32
#define	MAX_VARS   100
#define	HTTP_ENCODING   "UTF-8"
#define	WEB_BUFFER_SIZE   (6*1024*1024)
#define	MAX_PARAM   500
#define	PARAM_LENGTH   256
#define	TEXT_SIZE   50000
#define	LN10   2.302585094
#define	LOG2   0.301029996
#define	LOG5   0.698970005
#define	ALLOC(t, n)   (t*)calloc(sizeof(t),(n))
#define	DELETE(x)   if (x) { free(x); (x)=NULL; }
#define	DELETEA(x, n)   if (x) { for (int i=0; i<(n); i++) { free((x)[i]); (x)[i]=NULL; }; DELETE(x); }
#define	STRDUP(x)   strdup(x)
#define	READ_HISTORY_DATA   0x1
#define	READ_HISTORY_RUNMARKER   0x2
#define	READ_HISTORY_LAST_WRITTEN   0x4
#define	RESPONSE_SENT   1
#define	RESPONSE_QUEUED   2
#define	RESPONSE_501   3

Functions
static std::string	toString (int i)
static std::string	GetMimetype (const std::string &ext)
static void	SaveMimetypes (MVOdb *odb)
void	show_hist_page (MVOdb *odb, Param *p, Return *r, const char *dec_path, char *buffer, int *buffer_size, int refresh)
int	vaxis (gdImagePtr im, gdFont *font, int col, int gcol, int x1, int y1, int width, int minor, int major, int text, int label, int grid, double ymin, double ymax, BOOL logaxis)
void	haxis (gdImagePtr im, gdFont *font, int col, int gcol, int x1, int y1, int width, int minor, int major, int text, int label, int grid, double xmin, double xmax)
void	get_elog_url (char *url, int len)
void	show_header (Return *r, const char *title, const char *method, const char *path, int refresh)
void	show_navigation_bar (Return *r, const char *cur_page)
char *	stristr (const char *str, const char *pattern)
static double	GetTimeSec ()
const char *	mhttpd_revision (void)
static std::string	UrlDecode (const char *p)
static void	urlDecode (char *p)
static void	urlEncode (char *ps, int ps_size)
static std::string	urlEncode (const char *text)
std::vector< std::string >	get_resource_paths ()
bool	open_resource_file (const char *filename, std::string *ppath, FILE **pfp)
std::string	get_content_type (const char *filename)
bool	send_fp (Return *r, const std::string &path, FILE *fp)
bool	send_file (Return *r, const std::string &path, bool generate_404=true)
bool	send_resource (Return *r, const std::string &name, bool generate_404=true)
INT	sendmail (const char *from_host, const char *smtp_host, const char *from, const char *to, const char *subject, const char *text)
void	redirect (Return *r, const char *path)
void	redirect_307 (Return *r, const char *path)
void	redirect2 (Return *r, const char *path)
INT	search_callback (HNDLE hDB, HNDLE hKey, KEY *key, INT level, void *info)
void	show_help_page (Return *r, const char *dec_path)
void	show_text_header (Return *r)
void	show_error (Return *r, const char *error)
void	show_error_404 (Return *r, const char *error)
void	check_obsolete_odb (HNDLE hDB, const char *odb_path)
void	init_menu_buttons (MVOdb *odb)
void	init_mhttpd_odb (MVOdb *odb)
void	init_elog_odb ()
void	strencode (Return *r, const char *text)
std::string	strencode2 (const char *text)
void	strencode3 (Return *r, const char *text)
void	strencode4 (Return *r, const char *text)
void	gen_odb_attachment (Return *r, const char *path, std::string &bout)
void	submit_elog (MVOdb *odb, Param *pp, Return *r, Attachment *a)
void	show_elog_attachment (Param *p, Return *r, const char *path)
BOOL	is_editable (char *eq_name, char *var_name)
void	show_eqtable_page (Param *pp, Return *r, int refresh)
char *	find_odb_tag (char *p, char *path, char *format, int *edit, char *type, char *pwd, char *tail)
void	show_odb_tag (Param *pp, Return *r, const char *path, const char *keypath1, const char *format, int n_var, int edit, char *type, char *pwd, char *tail)
int	evaluate_src (char *key, char *src, double *fvalue)
std::string	add_custom_path (const std::string &filename)
void	show_custom_file (Return *r, const char *name)
void	show_custom_gif (Return *rr, const char *name)
void	do_jrpc_rev0 (Param *p, Return *r)
void	do_jrpc_rev1 (Param *p, Return *r)
void	do_jrpc (Param *p, Return *r)
void	output_key (Param *p, Return *r, HNDLE hkey, int index, const char *format)
bool	starts_with (const std::string &s1, const char *s2)
void	javascript_commands (Param *p, Return *r, const char *cookie_cpwd)
void	show_custom_page (Param *pp, Return *r, const char *cookie_cpwd)
static void	show_cnaf_page (Param *p, Return *rr)
void	show_password_page (Return *r, const char *dec_path, const char *password)
BOOL	check_web_password (Return *r, HNDLE hDB, const char *dec_path, const char *password, const char *redir)
void	show_odb_page (Param *pp, Return *r, const char *dec_path, int write_access)
void	show_set_page (Param *pp, Return *r, const char *group, int index, const char *value)
void	show_find_page (Return *r, const char *value)
void	sec_to_label (char *result, int sec, int base, int force_date)
void	taxis (gdImagePtr im, gdFont *font, int col, int gcol, int x1, int y1, int width, int xr, int minor, int major, int text, int label, int grid, double xmin, double xmax)
int	time_to_sec (const char *str)
time_t	string_to_time (const char *str)
std::string	time_to_string (time_t t)
static void	history_watch_callback (HNDLE hDB, HNDLE hKey, int index, void *info)
static MidasHistoryInterface *	get_history (bool reset=false)
static void	LoadHistPlotFromOdb (MVOdb *odb, HistPlot *hp, const char *group, const char *panel)
int	read_history (const HistPlot &hp, int index, int flags, time_t tstart, time_t tend, time_t scale, HistoryData *data)
int	get_hist_last_written (MVOdb *odb, const char *group, const char *panel, time_t endtime, int index, int want_all, time_t *plastwritten)
void	generate_hist_graph (MVOdb *odb, Return *rr, const char *hgroup, const char *hpanel, char *buffer, int *buffer_size, int width, int height, time_t xendtime, int scale, int index, int labels, const char *bgcolor, const char *fgcolor, const char *gridcolor)
time_t	mktime_with_dst (const struct tm *ptms)
static std::string	add_param_to_url (const char *name, const char *value)
void	show_query_page (Param *p, Return *r)
static int	cmp_names (const void *a, const void *b)
const bool	cmp_events (const std::string &a, const std::string &b)
const bool	cmp_events1 (const std::string &a, const std::string &b)
const bool	cmp_tags (const TAG &a, const TAG &b)
int	xdb_get_data_index (HNDLE hDB, const char *str, void *value, int size, int index, int tid)
static int	xdb_find_key (HNDLE hDB, HNDLE dir, const char *str, HNDLE *hKey, int tid, int size)
static bool	cmp_vars (const HistVar &a, const HistVar &b)
static void	PrintHistPlot (const HistPlot &hp)
static std::string	NextHistPlotColour (const HistPlot &hp)
static int	NextHistPlotOrder (const HistPlot &hp)
static void	SplitEventAndTagNames (std::string var_name, std::string &event_name, std::string &tag_name)
static void	LoadHistPlotFromParam (HistPlot *hp, Param *p)
static void	AddHistPlotSelectedParam (HistPlot &hp, Param *p)
static void	SaveHistPlotToOdb (MVOdb *odb, const HistPlot &hp, const char *group, const char *panel)
static void	DeleteHistPlotDeleted (HistPlot &hp)
static void	SortHistPlotVars (HistPlot &hp)
void	show_hist_config_page (MVOdb *odb, Param *p, Return *r, const char *hgroup, const char *hpanel)
void	export_hist (MVOdb *odb, Return *r, const char *group, const char *panel, time_t endtime, int scale, int index, int labels)
void	send_icon (Return *r, const char *icon)
void	Lock (RequestTrace *t)
void	Unlock (RequestTrace *t)
void	interprete (Param *p, Return *r, Attachment *a, const Cookies *c, const char *dec_path, RequestTrace *t)
void	decode_query (Param *pp, const char *query_string)
void	decode_get (Return *rr, char *string, const Cookies *c, const char *url, const char *query_string, RequestTrace *t)
void	decode_post (Return *rr, const char *header, const char *string, const char *boundary, int length, const Cookies *c, const char *url, RequestTrace *t)
INT	check_odb_records (MVOdb *odb)
void	ctrlc_handler (int sig)
int	try_file_mg (const char *try_dir, const char *filename, std::string &path, FILE **fpp, bool trace)
int	find_file_mg (const char *filename, std::string &path, FILE **fpp, bool trace)
static bool	read_passwords (Auth *auth)
static void	xmg_mkmd5resp (const char *method, size_t method_len, const char *uri, size_t uri_len, const char *ha1, size_t ha1_len, const char *nonce, size_t nonce_len, const char *nc, size_t nc_len, const char *cnonce, size_t cnonce_len, const char *qop, size_t qop_len, char *resp)
static int	xmg_check_nonce (const char *nonce)
static void	xmg_http_send_digest_auth_request (struct mg_connection *c, const char *domain)
static std::string	check_digest_auth (struct http_message *hm, Auth *auth)
static std::string	mgstr (const mg_str *s)
static const std::string	find_header_mg (const struct http_message *msg, const char *name)
static const std::string	find_cookie_mg (const struct http_message *msg, const char *cookie_name)
static void	handle_event_mg (struct mg_connection *nc, int ev, void *ev_data)
void	decode_cookies (Cookies *c, const http_message *msg)
static int	handle_decode_get (struct mg_connection *nc, const http_message *msg, const char *uri, const char *query_string, RequestTrace *t)
static int	handle_decode_post (struct mg_connection *nc, const http_message *msg, const char *uri, const char *query_string, RequestTrace *t)
static int	handle_http_get (struct mg_connection *nc, const http_message *msg, const char *uri, RequestTrace *t)
static int	handle_http_post (struct mg_connection *nc, const http_message *msg, const char *uri, RequestTrace *t)
static void	handle_http_options_cors (struct mg_connection *nc, const http_message *msg, RequestTrace *t)
static bool	mongoose_passwords_enabled (const struct mg_connection *nc)
static void	handle_http_message (struct mg_connection *nc, http_message *msg)
static MJsonNode *	get_http_trace (const MJsonNode *params)
static MJsonNode *	set_http_trace (const MJsonNode *params)
static void	add_rpc_functions ()
int	main (int argc, const char *argv[])

Variables
static std::mutex	gMutex
static MVOdb *	gOdb = NULL
static BOOL	elog_mode = FALSE
static BOOL	history_mode = FALSE
static BOOL	verbose = FALSE
const char *	mname []
static const char	default_type_list [20][NAME_LENGTH]
static const char	default_system_list [20][NAME_LENGTH]
const MimetypeTableEntry	gMimetypeTable []
static MVOdb *	gMimeTypesOdb = NULL
const unsigned char	favicon_png []
const unsigned char	favicon_ico []
static int	http_trace = 0
static RequestTraceBuf *	gTraceBuf = NULL
static const char *	cgif_label_str []
static const char *	cgif_bar_str []
static bool	gDoSetupHistoryWatch = true
static bool	gDoReloadHistory = false
static MidasHistoryInterface *	gMh = NULL
static HNDLE	gMhkey = 0
std::atomic_bool	_abort {false}
static std::vector< std::string >	gAllowedHosts
static bool	verbose_mg = false
static bool	trace_mg = false
static bool	trace_mg_recv = false
static bool	trace_mg_send = false
static Auth *	gAuthMg = NULL

Macro Definition Documentation

ALLOC

#define ALLOC	(		t,
			n
	)		(t*)calloc(sizeof(t),(n))

Definition at line 8234 of file mhttpd.cxx.

DEFAULT_REFRESH

#define DEFAULT_REFRESH   60

Definition at line 39 of file mhttpd.cxx.

DELETE

#define DELETE

(

x

)

if (x) { free(x); (x)=NULL; }

Definition at line 8235 of file mhttpd.cxx.

DELETEA

#define DELETEA	(		x,
			n
	)		if (x) { for (int i=0; i<(n); i++) { free((x)[i]); (x)[i]=NULL; }; DELETE(x); }

Definition at line 8236 of file mhttpd.cxx.

HTTP_ENCODING

#define HTTP_ENCODING   "UTF-8"

Definition at line 211 of file mhttpd.cxx.

LN10

#define LN10   2.302585094

Definition at line 7628 of file mhttpd.cxx.

LOG2

#define LOG2   0.301029996

Definition at line 7629 of file mhttpd.cxx.

LOG5

#define LOG5   0.698970005

Definition at line 7630 of file mhttpd.cxx.

MAX_GROUPS

#define MAX_GROUPS   32

Definition at line 50 of file mhttpd.cxx.

MAX_PARAM

#define MAX_PARAM   500

Definition at line 695 of file mhttpd.cxx.

MAX_VARS

#define MAX_VARS   100

Definition at line 51 of file mhttpd.cxx.

PARAM_LENGTH

#define PARAM_LENGTH   256

Definition at line 696 of file mhttpd.cxx.

READ_HISTORY_DATA

#define READ_HISTORY_DATA   0x1

Definition at line 8320 of file mhttpd.cxx.

READ_HISTORY_LAST_WRITTEN

#define READ_HISTORY_LAST_WRITTEN   0x4

Definition at line 8322 of file mhttpd.cxx.

READ_HISTORY_RUNMARKER

#define READ_HISTORY_RUNMARKER   0x2

Definition at line 8321 of file mhttpd.cxx.

RESPONSE_501

#define RESPONSE_501   3

Definition at line 14255 of file mhttpd.cxx.

RESPONSE_QUEUED

#define RESPONSE_QUEUED   2

Definition at line 14254 of file mhttpd.cxx.

RESPONSE_SENT

#define RESPONSE_SENT   1

Definition at line 14253 of file mhttpd.cxx.

STRDUP

#define STRDUP

(

x

)

strdup(x)

Definition at line 8237 of file mhttpd.cxx.

TEXT_SIZE

#define TEXT_SIZE   50000

Definition at line 697 of file mhttpd.cxx.

WEB_BUFFER_SIZE

#define WEB_BUFFER_SIZE   (6*1024*1024)

Definition at line 509 of file mhttpd.cxx.

Function Documentation

add_custom_path()

std::string add_custom_path

(

const std::string &

filename

)

Definition at line 3570 of file mhttpd.cxx.

{
   // do not append custom path to absolute filenames
 
   if (filename[0] == '/')
      return filename;
   if (filename[0] == DIR_SEPARATOR)
      return filename;
 
   HNDLE hDB;
   cm_get_experiment_database(&hDB, NULL);
 
   std::string custom_path = "";
 
   int status = db_get_value_string(hDB, 0, "/Custom/Path", 0, &custom_path, TRUE);
 
   if (status != DB_SUCCESS)
      return filename;
 
   if (custom_path.length() < 1)
      return filename;
 
   if ((custom_path == DIR_SEPARATOR_STR) || !strchr(custom_path.c_str(), DIR_SEPARATOR)) {
      cm_msg(MERROR, "add_custom_path", "ODB /Custom/Path has a forbidden value \"%s\", please change it", custom_path.c_str());
      return filename;
   }
 
   custom_path = ss_replace_env_variables(custom_path);
 
   std::string full_filename = custom_path;
   if (full_filename[full_filename.length()-1] != DIR_SEPARATOR)
      full_filename += DIR_SEPARATOR_STR;
   full_filename += filename;
 
   return full_filename;
}

Here is the call graph for this function:

Here is the caller graph for this function:

add_param_to_url()

static std::string add_param_to_url ( const char *  name, const char *  value  )

static

Definition at line 9780 of file mhttpd.cxx.

{
   std::string s;
   s += name; // FIXME: should be URI-encoded
   s += "=";
   s += value; // FIXME: should be URI-encoded
   return s;
}

Here is the caller graph for this function:

add_rpc_functions()

static void add_rpc_functions ( )

static

Definition at line 16202 of file mhttpd.cxx.

{
   mjsonrpc_add_handler("set_http_trace", set_http_trace);
   mjsonrpc_add_handler("get_http_trace", get_http_trace);
}

Here is the call graph for this function:

Here is the caller graph for this function:

AddHistPlotSelectedParam()

static void AddHistPlotSelectedParam ( HistPlot &  hp, Param *  p  )

static

Definition at line 10377 of file mhttpd.cxx.

{
   int seln = atoi(p->getparam("seln"));
   for (int i=0; i<seln; i++) {
      char str[256];
      sprintf(str, "sel%d", i);
      
      std::string par = p->getparam(str);
      if (par.length() < 1)
         continue;
 
      std::string event_name, tag_name;
      SplitEventAndTagNames(par, event_name, tag_name);
      
      if (tag_name == "")
         continue;
      
      HistVar v;
      
      v.event_name = event_name;
      v.tag_name   = tag_name;
      v.colour     = NextHistPlotColour(hp);
      v.order      = NextHistPlotOrder(hp);
      
      hp.vars.push_back(v);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_digest_auth()

static std::string check_digest_auth ( struct http_message *  hm, Auth *  auth  )

static

Definition at line 13892 of file mhttpd.cxx.

{
   char expected_response[33];
 
   //printf("HereA!\n");
 
   /* Parse "Authorization:" header, fail fast on parse error */
   struct mg_str *hdr = mg_get_http_header(hm, "Authorization");
 
   if (!hdr)
      return "";
 
   //printf("HereB!\n");
 
   std::string user     = find_var_mg(hdr, "username");
   std::string cnonce   = find_var_mg(hdr, "cnonce");
   std::string response = find_var_mg(hdr, "response");
   std::string uri      = find_var_mg(hdr, "uri");
   std::string qop      = find_var_mg(hdr, "qop");
   std::string nc       = find_var_mg(hdr, "nc");
   std::string nonce    = find_var_mg(hdr, "nonce");
 
   if (user.length()<1) return "";
   if (cnonce.length()<1) return "";
   if (response.length()<1) return "";
   if (uri.length()<1) return "";
   if (qop.length()<1) return "";
   if (nc.length()<1) return "";
   if (nonce.length()<1) return "";
 
   if (xmg_check_nonce(nonce.c_str()) == 0) return "";
   //printf("HereB8!\n");
 
   //printf("HereC!\n");
 
   const char* uri_end = strchr(hm->uri.p, ' ');
   if (!uri_end) return "";
 
   size_t uri_length = uri_end - hm->uri.p;
 
   if (uri_length != uri.length())
      return "";
 
   int cmp = strncmp(hm->uri.p, uri.c_str(), uri_length);
 
   //printf("check URI: message %d %d [%d] authorization [%s]\n", (int)hm->uri.len, uri_length, cmp, uri);
 
   if (cmp != 0)
      return "";
 
   for (unsigned i=0; i<auth->passwords.size(); i++) {
      AuthEntry* e = &auth->passwords[i];
      if (e->username != user)
         continue;
      if (e->realm != auth->realm)
         continue;
      const char* f_ha1 = e->password.c_str();
      int uri_len = hm->uri.len;
      if (hm->uri.p[uri_len] == '?')
         uri_len += hm->query_string.len + 1; // "+1" accounts for the "?" character
      xmg_mkmd5resp(hm->method.p, hm->method.len,
                    hm->uri.p, uri_len,
                    f_ha1, strlen(f_ha1),
                    nonce.c_str(), nonce.length(),
                    nc.c_str(), nc.length(),
                    cnonce.c_str(), cnonce.length(),
                    qop.c_str(), qop.length(),
                    expected_response);
      int cmp = strcasecmp(response.c_str(), expected_response);
      //printf("digest_auth: expected %s, got %s, cmp %d\n", expected_response, response.c_str(), cmp);
      if (cmp == 0) {
         return e->username;
      }
    }
 
   return "";
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_obsolete_odb()

void check_obsolete_odb	(	HNDLE	hDB,
		const char *	odb_path
	)

Definition at line 1881 of file mhttpd.cxx.

{
   HNDLE hKey;
   int status = db_find_key(hDB, 0, odb_path, &hKey);
   if (status == DB_SUCCESS) {
      cm_msg(MERROR, "check_obsolete_odb", "ODB \"%s\" is obsolete, please delete it.", odb_path);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_odb_records()

INT check_odb_records

(

MVOdb *

odb

)

Definition at line 13389 of file mhttpd.cxx.

{
   HNDLE hDB, hKeyEq, hKey;
   RUNINFO_STR(runinfo_str);
   int i, status;
   KEY key;
 
   /* check /Runinfo structure */
   status = cm_get_experiment_database(&hDB, NULL);
   assert(status == DB_SUCCESS);
 
   status = db_check_record(hDB, 0, "/Runinfo", strcomb1(runinfo_str).c_str(), FALSE);
   if (status == DB_STRUCT_MISMATCH) {
      status = db_check_record(hDB, 0, "/Runinfo", strcomb1(runinfo_str).c_str(), TRUE);
      if (status == DB_SUCCESS) {
         cm_msg(MINFO, "check_odb_records", "ODB subtree /Runinfo corrected successfully");
      } else {
         cm_msg(MERROR, "check_odb_records", "Cannot correct ODB subtree /Runinfo, db_check_record() status %d", status);
         return 0;
      }
   } else if (status == DB_NO_KEY) {
      cm_msg(MERROR, "check_odb_records", "ODB subtree /Runinfo does not exist");
      status = db_create_record(hDB, 0, "/Runinfo", strcomb1(runinfo_str).c_str());
      if (status == DB_SUCCESS) {
         cm_msg(MINFO, "check_odb_records", "ODB subtree /Runinfo created successfully");
      } else {
         cm_msg(MERROR, "check_odb_records", "Cannot create ODB subtree /Runinfo, db_create_record() status %d", status);
         return 0;
      }
   } else if (status != DB_SUCCESS) {
      cm_msg(MERROR, "check_odb_records", "Cannot correct ODB subtree /Runinfo, db_check_record() status %d", status);
      return 0;
   }
 
   /* check /Equipment/<name>/Common structures */
   if (db_find_key(hDB, 0, "/equipment", &hKeyEq) == DB_SUCCESS) {
      for (i = 0 ;; i++) {
         db_enum_key(hDB, hKeyEq, i, &hKey);
         if (!hKey)
            break;
         db_get_key(hDB, hKey, &key);
 
         status = db_check_record(hDB, hKey, "Common", EQUIPMENT_COMMON_STR, FALSE);
         if (status == DB_STRUCT_MISMATCH) {
            status = db_check_record(hDB, hKey, "Common", EQUIPMENT_COMMON_STR, TRUE);
            if (status == DB_SUCCESS) {
               cm_msg(MINFO, "check_odb_records", "ODB subtree /Equipment/%s/Common corrected successfully", key.name);
            } else {
               cm_msg(MERROR, "check_odb_records", "Cannot correct ODB subtree /Equipment/%s/Common, db_check_record() status %d", key.name, status);
            }
         } else if (status != DB_SUCCESS) {
            cm_msg(MERROR, "check_odb_records", "Cannot correct ODB subtree /Equipment/%s/Common, db_check_record() status %d", key.name, status);
         }
      }
   }
 
   return CM_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

check_web_password()

BOOL check_web_password	(	Return *	r,
		HNDLE	hDB,
		const char *	dec_path,
		const char *	password,
		const char *	redir
	)

Definition at line 6736 of file mhttpd.cxx.

{
   HNDLE hkey;
   INT size;
   char str[256];
 
   /* check for password */
   db_find_key(hDB, 0, "/Experiment/Security/Web Password", &hkey);
   if (hkey) {
      size = sizeof(str);
      db_get_data(hDB, hkey, str, &size, TID_STRING);
      if (strcmp(password, str) == 0)
         return TRUE;
 
      /* show web password page */
      r->rsprintf("HTTP/1.1 200 Document follows\r\n");
      r->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
      r->rsprintf("Content-Type: text/html; charset=%s\r\n\r\n", HTTP_ENCODING);
 
      r->rsprintf("<html><head>\n");
      r->rsprintf("<link rel=\"icon\" href=\"favicon.png\" type=\"image/png\" />\n");
      r->rsprintf("<link rel=\"stylesheet\" href=\"midas.css\" type=\"text/css\" />\n");
      r->rsprintf("<link rel=\"stylesheet\" href=\"mhttpd.css\" type=\"text/css\" />\n");
      r->rsprintf("<title>Enter password</title></head><body>\n\n");
 
      r->rsprintf("<form method=\"GET\" action=\".\">\n\n");
 
      /* define hidden fields for current experiment and destination */
      if (redir[0])
         r->rsprintf("<input type=hidden name=redir value=\"%s\">\n", redir);
 
      /*---- page header ----*/
      r->rsprintf("<table class=\"headerTable\"><tr><td></td><tr></table>\n");
 
      r->rsprintf("<table class=\"dialogTable\">\n");  //main table
 
      if (password[0])
         r->rsprintf("<tr><th class=\"redLight\">Wrong password!</tr>\n");
 
      r->rsprintf
          ("<tr><th>Please enter password to obtain write access</tr>\n");
      r->rsprintf("<tr><td align=center><input type=password name=wpwd></tr>\n");
      r->rsprintf("<tr><td align=center><input type=submit value=Submit></tr>");
 
      r->rsprintf("</table>\n");
 
      r->rsprintf("</div>\n"); // closing for <div id="mmain">
      r->rsprintf("</form>\n");
      r->rsprintf("</body></html>\r\n");
 
      return FALSE;
   } else
      return TRUE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cmp_events()

const bool cmp_events	(	const std::string &	a,
		const std::string &	b
	)

Definition at line 10033 of file mhttpd.cxx.

{
  return cmp_names(a.c_str(), b.c_str()) < 0;
}

Here is the call graph for this function:

cmp_events1()

const bool cmp_events1	(	const std::string &	a,
		const std::string &	b
	)

Definition at line 10038 of file mhttpd.cxx.

{
  return a < b;
}

Here is the caller graph for this function:

cmp_names()

static int cmp_names ( const void *  a, const void *  b  )

static

Definition at line 9975 of file mhttpd.cxx.

{
  int i;
  const char*sa = (const char*)a;
  const char*sb = (const char*)b;
 
  int debug = 0;
 
  // Cannot use strcmp() because it does not know how to compare numerical values, e.g.
  // it thinks "111" is smaller than "9"
  //return strcmp(sa, sb);
 
  if (debug)
    printf("compare [%s] and [%s]\n", sa, sb);
 
  for (i=0; ; i++) {
    if (sa[i]==0 && sb[i]==0)
      return 0; // both strings have the same length and the same characters
 
    //printf("index %d, char [%c] [%c], isdigit %d %d\n", i, sa[i], sb[i], isdigit(sa[i]), isdigit(sb[i]));
 
    if (isdigit(sa[i]) && isdigit(sb[i])) {
      int va = atoi(sa+i);
      int vb = atoi(sb+i);
 
      if (debug)
        printf("index %d, values %d %d\n", i, va, vb);
 
      if (va < vb)
        return -1;
      else if (va > vb)
        return 1;
 
      // values are equal, skip the the end of the digits, compare any trailing text
      continue;
    }
 
    if (sa[i]==sb[i]) {
      continue;
    }
 
    if (debug)
      printf("index %d, char [%c] [%c]\n", i, sa[i], sb[i]);
 
    if (sa[i] == 0) // string sa is shorter
      return -1;
    else if (sb[i] == 0) // string sb is shorter
      return 1;
 
    if (sa[i]<sb[i])
      return -1;
    else
      return 1;
  }
 
  // NOT REACHED
}

Here is the call graph for this function:

Here is the caller graph for this function:

cmp_tags()

const bool cmp_tags	(	const TAG &	a,
		const TAG &	b
	)

Definition at line 10043 of file mhttpd.cxx.

{
  return cmp_names(a.name, b.name) < 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cmp_vars()

static bool cmp_vars ( const HistVar &  a, const HistVar &  b  )

static

Definition at line 10101 of file mhttpd.cxx.

{
   return a.order < b.order;
}

Here is the caller graph for this function:

ctrlc_handler()

void ctrlc_handler

(

int

sig

)

Definition at line 13453 of file mhttpd.cxx.

{
   _abort = true;
}

Here is the caller graph for this function:

decode_cookies()

void decode_cookies	(	Cookies *	c,
		const http_message *	msg
	)

Definition at line 14206 of file mhttpd.cxx.

{
   // extract password cookies
 
   char cookie_pwd[256]; // general access password
   char cookie_wpwd[256]; // "write mode" password
   char cookie_cpwd[256]; // custom page and javascript password
 
   cookie_pwd[0] = 0;
   cookie_wpwd[0] = 0;
   cookie_cpwd[0] = 0;
 
   std::string s = find_cookie_mg(msg, "midas_pwd");
   if (s.length() > 0) {
      mstrlcpy(cookie_pwd, s.c_str(), sizeof(cookie_pwd));
      cookie_pwd[strcspn(cookie_pwd, " ;\r\n")] = 0;
   }
 
   s = find_cookie_mg(msg, "midas_wpwd");
   if (s.length()) {
      mstrlcpy(cookie_wpwd, s.c_str(), sizeof(cookie_pwd));
      cookie_wpwd[strcspn(cookie_wpwd, " ;\r\n")] = 0;
   }
 
   s = find_cookie_mg(msg, "cpwd");
   if (s.length()) {
      mstrlcpy(cookie_cpwd, s.c_str(), sizeof(cookie_pwd));
      cookie_cpwd[strcspn(cookie_cpwd, " ;\r\n")] = 0;
   }
 
   // extract refresh rate
   c->refresh = DEFAULT_REFRESH;
   s = find_cookie_mg(msg, "midas_refr");
   if (s.length() > 0)
      c->refresh = atoi(s.c_str());
 
   // extract equipment expand flag
   //c->expand_equipment = 0;
   //s = find_cookie_mg(msg, "midas_expeq");
   //if (s.length() > 0)
   //   c->expand_equipment = atoi(s.c_str());
 
   c->cookie_pwd  = cookie_pwd;
   c->cookie_wpwd = cookie_wpwd;
   c->cookie_cpwd = cookie_cpwd;
}

Here is the call graph for this function:

Here is the caller graph for this function:

decode_get()

void decode_get	(	Return *	rr,
		char *	string,
		const Cookies *	c,
		const char *	url,
		const char *	query_string,
		RequestTrace *	t
	)

Definition at line 13195 of file mhttpd.cxx.

{
   char path[256];
 
   //printf("decode_get: string [%s], decode_url %d, url [%s], query_string [%s]\n", string, decode_url, url, query_string);
 
   Param* param = new Param();
 
   param->initparam();
 
   if (url)
      mstrlcpy(path, url + 1, sizeof(path));     /* strip leading '/' */
   else {
      mstrlcpy(path, string + 1, sizeof(path));     /* strip leading '/' */
 
      if (strchr(path, '?'))
         *strchr(path, '?') = 0;
   }
 
   param->setparam("path", path);
 
   assert(query_string != NULL);
 
   decode_query(param, query_string);
 
   param->setparam("query", query_string);
 
   char dec_path[256];
   mstrlcpy(dec_path, path, sizeof(dec_path));
 
   interprete(param, rr, NULL, c, dec_path, t);
 
   param->freeparam();
   delete param;
}

Here is the call graph for this function:

Here is the caller graph for this function:

decode_post()

void decode_post	(	Return *	rr,
		const char *	header,
		const char *	string,
		const char *	boundary,
		int	length,
		const Cookies *	c,
		const char *	url,
		RequestTrace *	t
	)

Definition at line 13233 of file mhttpd.cxx.

{
   bool debug_decode_post = false;
   
   Param* param = new Param;
 
   param->initparam();
 
   char path[256];
 
   if (url)
      mstrlcpy(path, url + 1, sizeof(path));     /* strip leading '/' */
   else {
      mstrlcpy(path, header + 1, sizeof(path));     /* strip leading '/' */
      if (strchr(path, '?'))
         *strchr(path, '?') = 0;
      if (strchr(path, ' '))
         *strchr(path, ' ') = 0;
   }
   param->setparam("path", path); // undecoded path
 
   Attachment* a = new Attachment;
 
   const char* pinit = string;
 
   /* return if no boundary defined */
   if (!boundary[0])
      return;
 
   if (strstr(string, boundary))
      string = strstr(string, boundary) + strlen(boundary);
 
   if (debug_decode_post)
      printf("decode_post: -->[%s]<--\n", string);
 
   do {
      //printf("decode_post: [%s]\n", string);
      if (strstr(string, "name=")) {
         const char* pitem = strstr(string, "name=") + 5;
         if (*pitem == '\"')
            pitem++;
 
         //printf("decode_post: pitem [%s]\n", pitem);
 
         if (strncmp(pitem, "attfile", 7) == 0) {
            int n = pitem[7] - '1';
 
            char file_name[256];
            file_name[0] = 0;
 
            /* evaluate file attachment */
            if (strstr(pitem, "filename=")) {
               const char* p = strstr(pitem, "filename=") + 9;
               if (*p == '\"')
                  p++;
               if (strstr(p, "\r\n\r\n"))
                  string = strstr(p, "\r\n\r\n") + 4;
               else if (strstr(p, "\r\r\n\r\r\n"))
                  string = strstr(p, "\r\r\n\r\r\n") + 6;
 
               mstrlcpy(file_name, p, sizeof(file_name));
 
               char* pp = file_name;
               if (strchr(pp, '\"'))
                  *strchr(pp, '\"') = 0;
 
               /* set attachment filename */
               char str[256];
               sprintf(str, "attachment%d", n);
               if (debug_decode_post)
                  printf("decode_post: [%s] = [%s]\n", str, file_name);
               param->setparam(str, file_name); // file_name should be decoded?
            }
 
            /* find next boundary */
            const char* ptmp = string;
            const char* p = NULL;
            do {
               while (*ptmp != '-')
                  ptmp++;
 
               p = strstr(ptmp, boundary);
               if (p != NULL) {
                  while (*p == '-')
                     p--;
                  if (*p == 10)
                     p--;
                  if (*p == 13)
                     p--;
                  p++;
                  break;
               } else
                  ptmp += strlen(ptmp);
 
            } while (TRUE);
 
            /* save pointer to file */
            if (file_name[0]) {
               size_t size = (POINTER_T) p - (POINTER_T) string;
               char* buf = (char*)malloc(size+1);
               if (!buf) {
                  return;
               }
               memcpy(buf, string, size);
               buf[size] = 0; // make sure string is NUL terminated
               a->attachment_buffer[n] = buf;
               a->attachment_size[n] = size;
               if (debug_decode_post)
                  printf("decode_post: attachment[%d] size %d data --->[%s]<---\n", n, (int)a->attachment_size[n], a->attachment_buffer[n]);
            }
 
            string = strstr(p, boundary) + strlen(boundary);
         } else {
            const char* p = pitem;
            if (strstr(p, "\r\n\r\n"))
               p = strstr(p, "\r\n\r\n") + 4;
            else if (strstr(p, "\r\r\n\r\r\n"))
               p = strstr(p, "\r\r\n\r\r\n") + 6;
 
            char* ppitem = (char*)strchr(pitem, '\"'); // NB: defeat "const char* string"
            if (ppitem)
               *ppitem = 0;
 
            char* pb = (char*)(strstr(p, boundary)); // NB: defeat "const char* string"
            if (pb) {
               string = pb + strlen(boundary);
               *pb = 0;
               char* ptmp = (char*)(p + (strlen(p) - 1)); // NB: defeat "const char* string"
               while (*ptmp == '-' || *ptmp == '\n' || *ptmp == '\r')
                  *ptmp-- = 0;
            } else {
               show_error(rr, "Invalid POST request");
               return;
            }
            if (debug_decode_post)
               printf("decode_post: [%s] = [%s]\n", pitem, p);
            param->setparam(pitem, p); // in decode_post()
         }
 
         while (*string == '-' || *string == '\n' || *string == '\r')
            string++;
      }
 
   } while ((POINTER_T) string - (POINTER_T) pinit < length);
 
   char dec_path[256];
   mstrlcpy(dec_path, path, sizeof(dec_path));
 
   interprete(param, rr, a, c, dec_path, t);
 
   delete a;
   delete param;
}

Here is the call graph for this function:

Here is the caller graph for this function:

decode_query()

void decode_query	(	Param *	pp,
		const char *	query_string
	)

Definition at line 13171 of file mhttpd.cxx.

{
   int len = strlen(query_string);
   char *buf = (char *)malloc(len+1);
   memcpy(buf, query_string, len+1);
   char* p = buf;
   p = strtok(p, "&");
   while (p != NULL) {
      char *pitem = p;
      p = strchr(p, '=');
      if (p != NULL) {
         *p++ = 0;
         urlDecode(pitem); // parameter name
         if (!equal_ustring(pitem, "format"))
            urlDecode(p); // parameter value
 
         pp->setparam(pitem, p); // decoded query parameters
 
         p = strtok(NULL, "&");
      }
   }
   free(buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

DeleteHistPlotDeleted()

static void DeleteHistPlotDeleted ( HistPlot &  hp )

static

Definition at line 10481 of file mhttpd.cxx.

{
   /* delete variables according to "hist_order" */
   
   while (1) {
      bool something_deleted = false;
      for (unsigned i=0; i<hp.vars.size(); i++) {
         if (hp.vars[i].order <= 0) {
            hp.vars.erase(hp.vars.begin() + i);
            something_deleted = true;
         }
      }
      if (!something_deleted)
         break;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_jrpc()

void do_jrpc	(	Param *	p,
		Return *	r
	)

Definition at line 4318 of file mhttpd.cxx.

{
   int status;
 
   const char *name   = p->getparam("name");
   const char *cmd    = p->getparam("rcmd");
   const char *args   = p->getparam("rarg");
 
   if (!name || !cmd || !args) {
      show_text_header(r);
      r->rsprintf("<INVALID_ARGUMENTS>");
      return;
   }
 
   show_text_header(r);
 
   int buf_length = 1024;
 
   int max_reply_length = atoi(p->getparam("max_reply_length"));
   if (max_reply_length > buf_length)
      buf_length = max_reply_length;
 
   char* buf = (char*)malloc(buf_length);
   buf[0] = 0;
 
   HNDLE hconn;
 
   status = cm_connect_client(name, &hconn);
 
   if (status != RPC_SUCCESS) {
      r->rsprintf("<RPC_CONNECT_ERROR>%d</RPC_CONNECT_ERROR>", status);
      return;
   }
 
   status = rpc_client_call(hconn, RPC_JRPC, cmd, args, buf, buf_length);
 
   if (status != RPC_SUCCESS) {
      r->rsprintf("<RPC_CALL_ERROR>%d</RPC_CALL_ERROR>", status);
      return;
   }
 
   r->rsprintf("%s", buf);
 
   //status = cm_disconnect_client(hconn, FALSE);
 
   free(buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_jrpc_rev0()

void do_jrpc_rev0	(	Param *	p,
		Return *	r
	)

Definition at line 4014 of file mhttpd.cxx.

{
   static RPC_LIST rpc_list[] = {
      { 9999, "mhttpd_jrpc_rev0", {
            {TID_STRING, RPC_IN}, // arg0
            {TID_STRING, RPC_IN}, // arg1
            {TID_STRING, RPC_IN}, // arg2
            {TID_STRING, RPC_IN}, // arg3
            {TID_STRING, RPC_IN}, // arg4
            {TID_STRING, RPC_IN}, // arg5
            {TID_STRING, RPC_IN}, // arg6
            {TID_STRING, RPC_IN}, // arg7
            {TID_STRING, RPC_IN}, // arg8
            {TID_STRING, RPC_IN}, // arg9
            {0}} },
      { 0 }
   };
 
   int count = 0, substring = 0, rpc;
 
   const char *xname   = p->getparam("name");
   const char *srpc    = p->getparam("rpc");
 
   if (!srpc || !xname) {
      show_text_header(r);
      r->rsprintf("<INVALID_ARGUMENTS>");
      return;
   }
 
   char sname[256];
   mstrlcpy(sname, xname, sizeof(sname));
 
   if (sname[strlen(sname)-1]=='*') {
      sname[strlen(sname)-1] = 0;
      substring = 1;
   }
 
   rpc = atoi(srpc);
 
   if (rpc<RPC_MIN_ID || rpc>RPC_MAX_ID) {
      show_text_header(r);
      r->rsprintf("<INVALID_RPC_ID>");
      return;
   }
 
   rpc_list[0].id = rpc;
   rpc_register_functions(rpc_list, NULL);
 
   show_text_header(r);
   r->rsprintf("calling rpc %d | ", rpc);
 
   if (1) {
      int status, i;
      char str[256];
      HNDLE hDB, hrootkey, hsubkey, hkey;
 
      cm_get_experiment_database(&hDB, NULL);
 
      /* find client which exports FCNA function */
      status = db_find_key(hDB, 0, "System/Clients", &hrootkey);
      if (status == DB_SUCCESS) {
         for (i=0; ; i++) {
            status = db_enum_key(hDB, hrootkey, i, &hsubkey);
            if (status == DB_NO_MORE_SUBKEYS)
               break;
 
            sprintf(str, "RPC/%d", rpc);
            status = db_find_key(hDB, hsubkey, str, &hkey);
            if (status == DB_SUCCESS) {
               char client_name[NAME_LENGTH];
               HNDLE hconn;
               int size;
 
               size = sizeof(client_name);
               status = db_get_value(hDB, hsubkey, "Name", client_name, &size, TID_STRING, FALSE);
               if (status != DB_SUCCESS)
                  continue;
 
               if (strlen(sname) > 0) {
                  if (substring) {
                     if (strstr(client_name, sname) != client_name)
                        continue;
                  } else {
                     if (strcmp(sname, client_name) != 0)
                        continue;
                  }
               }
 
               count++;
 
               r->rsprintf("client %s", client_name);
 
               status = cm_connect_client(client_name, &hconn);
               r->rsprintf(" %d", status);
 
               if (status == RPC_SUCCESS) {
                  status = rpc_client_call(hconn, rpc,
                                           p->getparam("arg0"),
                                           p->getparam("arg1"),
                                           p->getparam("arg2"),
                                           p->getparam("arg3"),
                                           p->getparam("arg4"),
                                           p->getparam("arg5"),
                                           p->getparam("arg6"),
                                           p->getparam("arg7"),
                                           p->getparam("arg8"),
                                           p->getparam("arg9")
                                           );
                  r->rsprintf(" %d", status);
 
                  //status = cm_disconnect_client(hconn, FALSE);
                  r->rsprintf(" %d", status);
               }
 
               r->rsprintf(" | ");
            }
         }
      }
   }
 
   r->rsprintf("rpc %d, called %d clients\n", rpc, count);
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_jrpc_rev1()

void do_jrpc_rev1	(	Param *	p,
		Return *	r
	)

Definition at line 4139 of file mhttpd.cxx.

{
   static RPC_LIST rpc_list[] = {
      { 9998, "mhttpd_jrpc_rev1", {
            {TID_STRING, RPC_OUT}, // return string
            {TID_INT,    RPC_IN},  // return string max length
            {TID_STRING, RPC_IN}, // arg0
            {TID_STRING, RPC_IN}, // arg1
            {TID_STRING, RPC_IN}, // arg2
            {TID_STRING, RPC_IN}, // arg3
            {TID_STRING, RPC_IN}, // arg4
            {TID_STRING, RPC_IN}, // arg5
            {TID_STRING, RPC_IN}, // arg6
            {TID_STRING, RPC_IN}, // arg7
            {TID_STRING, RPC_IN}, // arg8
            {TID_STRING, RPC_IN}, // arg9
            {0}} },
      { 0 }
   };
 
   int status, substring = 0, rpc;
 
   const char *xname   = p->getparam("name");
   const char *srpc    = p->getparam("rpc");
 
   if (!srpc || !xname) {
      show_text_header(r);
      r->rsprintf("<INVALID_ARGUMENTS>");
      return;
   }
 
   char sname[256];
   mstrlcpy(sname, xname, sizeof(sname));
 
   if (sname[strlen(sname)-1]=='*') {
      sname[strlen(sname)-1] = 0;
      substring = 1;
   }
 
   rpc = atoi(srpc);
 
   if (rpc<RPC_MIN_ID || rpc>RPC_MAX_ID) {
      show_text_header(r);
      r->rsprintf("<INVALID_RPC_ID>");
      return;
   }
 
   rpc_list[0].id = rpc;
   status = rpc_register_functions(rpc_list, NULL);
 
   //printf("cm_register_functions() for format \'%s\' status %d\n", sformat, status);
 
   show_text_header(r);
 
   std::string reply_header;
   std::string reply_body;
 
   //r->rsprintf("<?xml version=\"1.0\" encoding=\"%s\"?>\n", HTTP_ENCODING);
   //r->rsprintf("<!-- created by MHTTPD on (timestamp) -->\n");
   //r->rsprintf("<jrpc_rev1>\n");
   //r->rsprintf("  <rpc>%d</rpc>\n", rpc);
 
   if (1) {
      HNDLE hDB, hrootkey, hsubkey, hkey;
 
      cm_get_experiment_database(&hDB, NULL);
 
      int buf_length = 1024;
 
      int max_reply_length = atoi(p->getparam("max_reply_length"));
      if (max_reply_length > buf_length)
         buf_length = max_reply_length;
 
      char* buf = (char*)malloc(buf_length);
 
      /* find client which exports our RPC function */
      status = db_find_key(hDB, 0, "System/Clients", &hrootkey);
      if (status == DB_SUCCESS) {
         for (int i=0; ; i++) {
            status = db_enum_key(hDB, hrootkey, i, &hsubkey);
            if (status == DB_NO_MORE_SUBKEYS)
               break;
 
            char str[256];
            sprintf(str, "RPC/%d", rpc);
            status = db_find_key(hDB, hsubkey, str, &hkey);
            if (status == DB_SUCCESS) {
               char client_name[NAME_LENGTH];
               HNDLE hconn;
               int size;
 
               size = sizeof(client_name);
               status = db_get_value(hDB, hsubkey, "Name", client_name, &size, TID_STRING, FALSE);
               if (status != DB_SUCCESS)
                  continue;
 
               if (strlen(sname) > 0) {
                  if (substring) {
                     if (strstr(client_name, sname) != client_name)
                        continue;
                  } else {
                     if (strcmp(sname, client_name) != 0)
                        continue;
                  }
               }
 
               //r->rsprintf("  <client>\n");
               //r->rsprintf("    <name>%s</name>\n", client_name);
 
               int connect_status = -1;
               int call_status = -1;
               int call_length = 0;
               int disconnect_status = -1;
 
               connect_status = cm_connect_client(client_name, &hconn);
 
               //r->rsprintf("    <connect_status>%d</connect_status>\n", status);
 
               if (connect_status == RPC_SUCCESS) {
                  buf[0] = 0;
 
                  call_status = rpc_client_call(hconn, rpc,
                                                buf,
                                                buf_length,
                                                p->getparam("arg0"),
                                                p->getparam("arg1"),
                                                p->getparam("arg2"),
                                                p->getparam("arg3"),
                                                p->getparam("arg4"),
                                                p->getparam("arg5"),
                                                p->getparam("arg6"),
                                                p->getparam("arg7"),
                                                p->getparam("arg8"),
                                                p->getparam("arg9")
                                                );
 
                  //r->rsprintf("    <rpc_status>%d</rpc_status>\n", status);
                  //r->rsputs("<data>");
                  //r->rsputs(buf);
                  //r->rsputs("</data>\n");
 
                  if (call_status == RPC_SUCCESS) {
                     call_length = strlen(buf);
                     reply_body += buf;
                  }
 
                  //disconnect_status = cm_disconnect_client(hconn, FALSE);
                  //r->rsprintf("    <disconnect_status>%d</disconnect_status>\n", status);
               }
 
               //r->rsprintf("  </client>\n");
 
               if (reply_header.length() > 0)
                  reply_header += " | ";
 
               char tmp[256];
               sprintf(tmp, "%s %d %d %d %d", client_name, connect_status, call_status, disconnect_status, call_length);
               reply_header += tmp;
            }
         }
      }
 
      free(buf);
   }
 
   //r->rsprintf("  <called_clients>%d</called_clients>\n", count);
   //r->rsprintf("</jrpc_rev1>\n");
 
   if (reply_header.length() > 0) {
      r->rsputs(reply_header.c_str());
      r->rsputs(" || ");
      r->rsputs(reply_body.c_str());
      r->rsputs("\n");
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

evaluate_src()

int evaluate_src	(	char *	key,
		char *	src,
		double *	fvalue
	)

Definition at line 3497 of file mhttpd.cxx.

{
   HNDLE hDB, hkeyval;
   KEY vkey;
   int i, n, size, ivalue;
   char str[256], data[256];
 
   cm_get_experiment_database(&hDB, NULL);
 
   /* separate source from operators */
   for (i=0 ; i<(int)strlen(src) ; i++)
      if (src[i] == '>' || src[i] == '&')
         break;
   strncpy(str, src, i);
   str[i] = 0;
 
   /* strip trailing blanks */
   while (strlen(str) > 0 && str[strlen(str)-1] == ' ')
      str[strlen(str)-1] = 0;
 
   db_find_key(hDB, 0, str, &hkeyval);
   if (!hkeyval) {
      cm_msg(MERROR, "evaluate_src", "Invalid Src key \"%s\" for Fill \"%s\"",
             src, key);
      return 0;
   }
 
   db_get_key(hDB, hkeyval, &vkey);
   size = sizeof(data);
   db_get_value(hDB, 0, src, data, &size, vkey.type, FALSE);
   std::string value = db_sprintf(data, size, 0, vkey.type);
   if (equal_ustring(value.c_str(), "NAN"))
      return 0;
 
   if (vkey.type == TID_BOOL) {
      *fvalue = (value[0] == 'y');
   } else
      *fvalue = atof(value.c_str());
 
   /* evaluate possible operators */
   do {
      if (src[i] == '>' && src[i+1] == '>') {
         i+=2;
         n = atoi(src+i);
         while (src[i] == ' ' || isdigit(src[i]))
            i++;
         ivalue = (int)*fvalue;
         ivalue >>= n;
         *fvalue = ivalue;
      }
 
      if (src[i] == '&') {
         i+=1;
         while (src[i] == ' ')
            i++;
         if (src[i] == '0' && src[i+1] == 'x')
            sscanf(src+2+i, "%x", &n);
         else
            n = atoi(src+i);
         while (src[i] == ' ' || isxdigit(src[i]) || src[i] == 'x')
            i++;
         ivalue = (int)*fvalue;
         ivalue &= n;
         *fvalue = ivalue;
      }
 
   } while (src[i]);
 
   return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

export_hist()

void export_hist	(	MVOdb *	odb,
		Return *	r,
		const char *	group,
		const char *	panel,
		time_t	endtime,
		int	scale,
		int	index,
		int	labels
	)

Definition at line 11025 of file mhttpd.cxx.

{
   //HNDLE hDB, hkey, hkeypanel;
   //int size;
   int status;
   //char str[256];
 
   int debug = 0;
 
   ss_tzset(); // required for localtime_r()
 
#if 0
   cm_get_experiment_database(&hDB, NULL);
 
   /* check panel name in ODB */
   sprintf(str, "/History/Display/%s/%s", group, panel);
   db_find_key(hDB, 0, str, &hkeypanel);
   if (!hkeypanel) {
      sprintf(str, "Cannot find /History/Display/%s/%s in ODB\n", group, panel);
      show_error(r, str);
      return;
   }
 
   /* get runmarker flag */
   BOOL runmarker = 1;
   size = sizeof(runmarker);
   db_get_value(hDB, hkeypanel, "Show run markers", &runmarker, &size, TID_BOOL, TRUE);
 
   if (scale == 0) {
      /* get timescale */
      std::string ts = "1h";
      status = db_get_value_string(hDB, hkeypanel, "Timescale", 0, &ts, TRUE);
      if (status != DB_SUCCESS) {
         /* delete old integer key */
         db_find_key(hDB, hkeypanel, "Timescale", &hkey);
         if (hkey)
            db_delete_key(hDB, hkey, FALSE);
 
         ts = "1h";
         status = db_get_value_string(hDB, hkeypanel, "Timescale", 0, &ts, TRUE);
      }
 
      scale = time_to_sec(ts.c_str());
   }
#endif
 
   time_t now = ss_time();
 
   if (endtime == 0)
      endtime = now;
 
   HistoryData hsxxx;
   HistoryData* hsdata = &hsxxx;
 
   HistPlot hp;
   LoadHistPlotFromOdb(odb, &hp, group, panel);
 
   time_t starttime = endtime - scale;
 
   //printf("start %.0f, end %.0f, scale %.0f\n", (double)starttime, (double)endtime, (double)scale);
 
   status = read_history(hp, /*hDB, group, panel,*/ index, hp.show_run_markers, starttime, endtime, 0, hsdata);
   if (status != HS_SUCCESS) {
      char str[256];
      sprintf(str, "History error, status %d\n", status);
      show_error(r, str);
      return;
   }
 
   if (debug)
      hsdata->Print();
 
   int *i_var = (int *)malloc(sizeof(int)*hsdata->nvars);
 
   for (int i = 0; i < hsdata->nvars; i++)
      i_var[i] = -1;
 
   time_t t = 0;
 
   /* find first time where all variables are available */
   for (int i = 0; i < hsdata->nvars; i++)
      if (hsdata->odb_index[i] >= 0)
         if (hsdata->num_entries[i] > 0)
            if ((t == 0) || (hsdata->t[i][0] > t))
               t = hsdata->t[i][0];
 
   if (t == 0 && hsdata->nvars > 1) {
      show_error(r, "No history available for choosen period");
      free(i_var);
      return;
   }
 
   int run_index = -1;
   int state_index = -1;
   int n_run_number = 0;
   time_t* t_run_number = NULL;
   if (hp.show_run_markers)
      for (int i = 0; i < hsdata->nvars; i++) {
         if (hsdata->odb_index[i] == -2) {
            n_run_number = hsdata->num_entries[i];
            t_run_number = hsdata->t[i];
            run_index = i;
         } else if (hsdata->odb_index[i] == -1) {
            state_index = i;
         }
      }
 
   //printf("runmarker %d, state %d, run %d\n", runmarker, state_index, run_index);
 
   /* header */
   r->rsprintf("HTTP/1.1 200 Document follows\r\n");
   r->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
   r->rsprintf("Accept-Ranges: bytes\r\n");
   r->rsprintf("Cache-control: private, max-age=0, no-cache\r\n");
   r->rsprintf("Expires: Fri, 01 Jan 1983 00:00:00 GMT\r\n");
   r->rsprintf("Content-Type: text/plain\r\n");
   r->rsprintf("Content-disposition: attachment; filename=\"export.csv\"\r\n");
   r->rsprintf("\r\n");
 
   /* output header line with variable names */
   if (hp.show_run_markers && t_run_number)
      r->rsprintf("Time, Timestamp, Run, Run State, ");
   else
      r->rsprintf("Time, Timestamp, ");
 
   for (int i = 0, first = 1; i < hsdata->nvars; i++) {
      if (hsdata->odb_index[i] < 0)
         continue;
      if (hsdata->num_entries[i] <= 0)
         continue;
      if (!first)
         r->rsprintf(", ");
      first = 0;
      r->rsprintf("%s", hsdata->var_names[i]);
   }
   r->rsprintf("\n");
 
   int i_run = 0;
 
   do {
 
      if (debug)
         printf("hsdata %p, t %d, irun %d\n", hsdata, (int)t, i_run);
 
      /* find run number/state which is valid for t */
      if (hp.show_run_markers && t_run_number)
         while (i_run < n_run_number-1 && t_run_number[i_run+1] <= t)
            i_run++;
 
      //printf("irun %d\n", i_run);
 
      /* find index for all variables which is valid for t */
      for (int i = 0; i < hsdata->nvars; i++)
         while (hsdata->num_entries[i] > 0 && i_var[i] < hsdata->num_entries[i] - 1 && hsdata->t[i][i_var[i]+1] <= t)
            i_var[i]++;
 
      /* finish if last point for all variables reached */
      bool done = true;
      for (int i = 0 ; i < hsdata->nvars ; i++)
         if (hsdata->num_entries[i] > 0 && i_var[i] < hsdata->num_entries[i]) {
            done = false;
            break;
         }
 
      if (debug) {
         printf("step to time %d: ", (int)t);
         for (int i = 0; i < hsdata->nvars; i++) {
            printf(" [%d] %d, ", hsdata->num_entries[i], i_var[i]);
         }
         printf(" done: %d\n", done);
      }
 
      if (done)
         break;
 
      struct tm tms;
      localtime_r(&t, &tms);
 
      char fmt[256];
      //strcpy(fmt, "%c");
      strcpy(fmt, "%Y.%m.%d %H:%M:%S");
      char str[256];
      strftime(str, sizeof(str), fmt, &tms);
 
      if (t_run_number && run_index>=0 && state_index>=0) {
         if (t_run_number[i_run] <= t)
            r->rsprintf("%s, %d, %.0f, %.0f, ", str, (int)t, hsdata->v[run_index][i_run], hsdata->v[state_index][i_run]);
         else
            r->rsprintf("%s, %d, N/A, N/A, ", str, (int)t);
      } else
         r->rsprintf("%s, %d, ", str, (int)t);
 
      if (debug) {
         for (int i= 0 ; i < hsdata->nvars ; i++)
            printf(" %d (%g)", i_var[i], hsdata->v[i][i_var[i]]);
         printf("\n");
      }
 
      for (int i=0, first=1 ; i<hsdata->nvars ; i++) {
         if (i_var[i] < 0)
            continue;
         if (hsdata->odb_index[i] < 0)
            continue;
         if (!first)
            r->rsprintf(", ");
         first = 0;
         //r->rsprintf("(%d %g)", i_var[i], hsdata->v[i][i_var[i]]);
         r->rsprintf("%g", hsdata->v[i][i_var[i]]);
      }
      r->rsprintf("\n");
 
      /* find next t as smallest delta t */
      int dt = -1;
      for (int i = 0 ; i < hsdata->nvars ; i++)
         if (i_var[i]>=0 && hsdata->odb_index[i]>=0 && hsdata->num_entries[i]>0 && i_var[i]<hsdata->num_entries[i]-1) {
            int xdt = hsdata->t[i][i_var[i]+1] - t;
            if (debug)
               printf("var %d, i_var %d->%d, t %d->%d, dt %d\n", i, i_var[i], i_var[i]+1, (int)hsdata->t[i][i_var[i]], (int)hsdata->t[i][i_var[i]+1], xdt);
            if (dt <= 0 || xdt < dt)
               dt = xdt;
         }
 
      if (debug)
         printf("dt %d\n", dt);
 
      if (dt <= 0)
         break;
 
      t += dt;
 
   } while (1);
 
   free(i_var);
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_cookie_mg()

static const std::string find_cookie_mg ( const struct http_message *  msg, const char *  cookie_name  )

static

Definition at line 14154 of file mhttpd.cxx.

{
   const std::string cookies = find_header_mg(msg, "Cookie");
   if (cookies.length() < 1)
      return "";
   const char* p = strstr(cookies.c_str(), cookie_name);
   if (!p)
      return "";
   const char* v = p+strlen(cookie_name);
   if (*v != '=')
      return "";
   v++;
   //printf("cookie [%s] value [%s]\n", cookie_name, v);
   return v;
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_file_mg()

int find_file_mg	(	const char *	filename,
		std::string &	path,
		FILE **	fpp,
		bool	trace
	)

Definition at line 13672 of file mhttpd.cxx.

{
   std::string exptdir = cm_get_path();
 
   if (try_file_mg(".", filename, path, fpp, trace) == SUCCESS)
      return SUCCESS;
 
   if (try_file_mg(getenv("MIDAS_DIR"), filename, path, fpp, trace) == SUCCESS)
      return SUCCESS;
 
   if (try_file_mg(exptdir.c_str(), filename, path, fpp, trace) == SUCCESS)
      return SUCCESS;
 
   if (try_file_mg(getenv("MIDASSYS"), filename, path, fpp, trace) == SUCCESS)
      return SUCCESS;
 
   // setup default filename
   try_file_mg(exptdir.c_str(), filename, path, NULL, false);
   return SS_FILE_ERROR;
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_header_mg()

static const std::string find_header_mg ( const struct http_message *  msg, const char *  name  )

static

Definition at line 14141 of file mhttpd.cxx.

{
   size_t nlen = strlen(name);
   for (int i=0; i<MG_MAX_HTTP_HEADERS; i++) {
      if (msg->header_names[i].len != nlen)
         continue;
      if (strncmp(msg->header_names[i].p, name, nlen) != 0)
         continue;
      return mgstr(&msg->header_values[i]);
   }
   return "";
}

Here is the call graph for this function:

Here is the caller graph for this function:

find_odb_tag()

char * find_odb_tag	(	char *	p,
		char *	path,
		char *	format,
		int *	edit,
		char *	type,
		char *	pwd,
		char *	tail
	)

Definition at line 3091 of file mhttpd.cxx.

{
   char str[256], *ps, *pt;
   BOOL in_script;
 
   *edit = 0;
   *tail = 0;
   *format = 0;
   pwd[0] = 0;
   in_script = FALSE;
   strcpy(type, "text");
   do {
      while (*p && *p != '<')
         p++;
 
      /* return if end of string reached */
      if (!*p)
         return NULL;
 
      p++;
      while (*p && ((*p == ' ') || iscntrl(*p)))
         p++;
 
      strncpy(str, p, 6);
      str[6] = 0;
      if (equal_ustring(str, "script"))
         in_script = TRUE;
 
      strncpy(str, p, 7);
      str[7] = 0;
      if (equal_ustring(str, "/script"))
         in_script = FALSE;
 
      strncpy(str, p, 4);
      str[4] = 0;
      if (equal_ustring(str, "odb ")) {
         ps = p - 1;
         p += 4;
         while (*p && ((*p == ' ') || iscntrl(*p)))
            p++;
 
         do {
            strncpy(str, p, 7);
            str[7] = 0;
            if (equal_ustring(str, "format=")) {
               p += 7;
               if (*p == '\"') {
                  p++;
                  while (*p && *p != '\"')
                     *format++ = *p++;
                  *format = 0;
                  if (*p == '\"')
                    p++;
               } else {
                  while (*p && *p != ' ' && *p != '>')
                     *format++ = *p++;
                  *format = 0;
               }
 
            } else {
 
            strncpy(str, p, 4);
            str[4] = 0;
            if (equal_ustring(str, "src=")) {
               p += 4;
               if (*p == '\"') {
                  p++;
                  while (*p && *p != '\"')
                     *path++ = *p++;
                  *path = 0;
                  if (*p == '\"')
                    p++;
               } else {
                  while (*p && *p != ' ' && *p != '>')
                     *path++ = *p++;
                  *path = 0;
               }
            } else {
 
               if (in_script)
                  break;
 
               strncpy(str, p, 5);
               str[5] = 0;
               if (equal_ustring(str, "edit=")) {
                  p += 5;
 
                  if (*p == '\"') {
                     p++;
                     *edit = atoi(p);
                     if (*p == '\"')
                       p++;
                  } else {
                     *edit = atoi(p);
                     while (*p && *p != ' ' && *p != '>')
                        p++;
                  }
 
               } else {
 
                  strncpy(str, p, 5);
                  str[5] = 0;
                  if (equal_ustring(str, "type=")) {
                     p += 5;
                     if (*p == '\"') {
                        p++;
                        while (*p && *p != '\"')
                           *type++ = *p++;
                        *type = 0;
                        if (*p == '\"')
                          p++;
                     } else {
                        while (*p && *p != ' ' && *p != '>')
                           *type++ = *p++;
                        *type = 0;
                     }
                  } else {
                     strncpy(str, p, 4);
                     str[4] = 0;
                     if (equal_ustring(str, "pwd=")) {
                        p += 4;
                        if (*p == '\"') {
                           p++;
                           while (*p && *p != '\"')
                              *pwd++ = *p++;
                           *pwd = 0;
                           if (*p == '\"')
                             p++;
                        } else {
                           while (*p && *p != ' ' && *p != '>')
                              *pwd++ = *p++;
                           *pwd = 0;
                        }
                     } else {
                        if (strchr(p, '=')) {
                           mstrlcpy(str, p, sizeof(str));
                           pt = strchr(str, '=')+1;
                           if (*pt == '\"') {
                              pt++;
                              while (*pt && *pt != '\"')
                                 pt++;
                              if (*pt == '\"')
                                 pt++;
                              *pt = 0;
                           } else {
                              while (*pt && *pt != ' ' && *pt != '>')
                                 pt++;
                              *pt = 0;
                           }
                           if (tail[0]) {
                              mstrlcat(tail, " ", 256);
                              mstrlcat(tail, str, 256);
                           } else {
                              mstrlcat(tail, str, 256);
                           }
                           p += strlen(str);
                        }
                     }
                  }
               }
            }
            }
 
            while (*p && ((*p == ' ') || iscntrl(*p)))
               p++;
 
            if (*p == '<') {
               cm_msg(MERROR, "find_odb_tag", "Invalid odb tag '%s'", ps);
               return NULL;
            }
         } while (*p != '>');
 
         return ps;
      }
 
      while (*p && *p != '>')
         p++;
 
   } while (1);
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

gen_odb_attachment()

void gen_odb_attachment	(	Return *	r,
		const char *	path,
		std::string &	bout
	)

Definition at line 2134 of file mhttpd.cxx.

{
   HNDLE hDB, hkeyroot, hkey;
   KEY key;
   INT i, j, size;
   char data[1024];
   time_t now;
 
   cm_get_experiment_database(&hDB, NULL);
   db_find_key(hDB, 0, path, &hkeyroot);
   assert(hkeyroot);
 
   /* title row */
   //size = sizeof(str);
   //str[0] = 0;
   //db_get_value(hDB, 0, "/Experiment/Name", str, &size, TID_STRING, TRUE);
   time(&now);
 
   bout += "<table border=3 cellpadding=1 class=\"dialogTable\">\n";
   char ctimebuf[32];
   ctime_r(&now, ctimebuf);
   bout += msprintf("<tr><th colspan=2>%s</tr>\n", ctimebuf);
   bout += msprintf("<tr><th colspan=2>%s</tr>\n", path);
 
   /* enumerate subkeys */
   for (i = 0;; i++) {
      db_enum_link(hDB, hkeyroot, i, &hkey);
      if (!hkey)
         break;
      db_get_key(hDB, hkey, &key);
 
      /* resolve links */
      if (key.type == TID_LINK) {
         db_enum_key(hDB, hkeyroot, i, &hkey);
         db_get_key(hDB, hkey, &key);
      }
 
      if (key.type == TID_KEY) {
         /* for keys, don't display data value */
         bout += msprintf("<tr><td colspan=2>%s</td></tr>\n", key.name);
      } else {
         /* display single value */
         if (key.num_values == 1) {
            size = sizeof(data);
            db_get_data(hDB, hkey, data, &size, key.type);
            //printf("data size %d [%s]\n", size, data);
            std::string data_str = db_sprintf(data, key.item_size, 0, key.type);
            std::string hex_str = db_sprintfh(data, key.item_size, 0, key.type);
 
            if (data_str.empty() || equal_ustring(data_str.c_str(), "<NULL>")) {
               data_str = "(empty)";
               hex_str  = "";
            }
 
            if (strcmp(data_str.c_str(), hex_str.c_str()) != 0 && hex_str[0]) {
               //sprintf(b, "<tr><td>%s</td><td>%s (%s)</td></tr>\n", key.name, data_str, hex_str);
               bout += "<tr><td>";
               bout += key.name;
               bout += "</td><td>";
               bout += data_str;
               bout += " (";
               bout += hex_str;
               bout += ")</td></tr>\n";
            } else {
               bout += msprintf("<tr><td>%s</td><td>", key.name);
               bout += strencode2(data_str.c_str());
               bout += "</td></tr>\n";
            }
         } else {
            /* display first value */
            bout += msprintf("<tr><td rowspan=%d>%s</td>\n", key.num_values, key.name);
 
            for (j = 0; j < key.num_values; j++) {
               size = sizeof(data);
               db_get_data_index(hDB, hkey, data, &size, j, key.type);
               std::string data_str = db_sprintf(data, key.item_size, 0, key.type);
               std::string hex_str = db_sprintfh(data, key.item_size, 0, key.type);
 
               if (data_str.empty() || equal_ustring(data_str.c_str(), "<NULL>")) {
                  data_str = "(empty)";
                  hex_str  = "";
               }
 
               if (j > 0) {
                  bout += "<tr>";
               }
 
               if (strcmp(data_str.c_str(), hex_str.c_str()) != 0 && hex_str[0]) {
                  //sprintf(b, "<td>[%d] %s (%s)<br></td></tr>\n", j, data_str, hex_str);
                  bout += "<td>[";
                  bout += toString(j);
                  bout += "] ";
                  bout += data_str;
                  bout += " (";
                  bout += hex_str;
                  bout += ")<br></td></tr>\n";
               } else {
                  //sprintf(b, "<td>[%d] %s<br></td></tr>\n", j, data_str);
                  bout += "<td>[";
                  bout += toString(j);
                  bout += "] ";
                  bout += data_str;
                  bout += "<br></td></tr>\n";
               }
            }
         }
      }
   }
 
   bout += "</table>\n";
}

Here is the call graph for this function:

Here is the caller graph for this function:

generate_hist_graph()

void generate_hist_graph	(	MVOdb *	odb,
		Return *	rr,
		const char *	hgroup,
		const char *	hpanel,
		char *	buffer,
		int *	buffer_size,
		int	width,
		int	height,
		time_t	xendtime,
		int	scale,
		int	index,
		int	labels,
		const char *	bgcolor,
		const char *	fgcolor,
		const char *	gridcolor
	)

• check panel name in ODB *‍/

• split varname in event, variable and index *‍/

• get factors *‍/

• get offsets *‍/

• get axis type *‍/

• get show_values type *‍/

• get sort_vars type *‍/

• get old_vars type *‍/

• get min value *‍/

• get max value *‍/

• get runmarker flag *‍/

Definition at line 8604 of file mhttpd.cxx.

{
   HNDLE hDB;
   //KEY key;
   gdImagePtr im;
   gdGifBuffer gb;
   int i, j, k, l;
   //int n_vars;
   int size, status, r, g, b;
   //int x_marker;
   int length;
   int white, grey, red;
   //int black, ltgrey, green, blue;
   int fgcol, bgcol, gridcol;
   int curve_col[MAX_VARS];
   int state_col[3];
   char str[256], *p;
   //INT var_index[MAX_VARS];
   //char event_name[MAX_VARS][NAME_LENGTH];
   //char tag_name[MAX_VARS][64];
   //char var_name[MAX_VARS][NAME_LENGTH];
   //char varname[64];
   //char key_name[256];
   //float factor[MAX_VARS], offset[MAX_VARS];
   //BOOL logaxis, runmarker;
   //double xmin, xrange;
   double ymin, ymax;
   double upper_limit[MAX_VARS], lower_limit[MAX_VARS];
   //float minvalue = (float) -HUGE_VAL;
   //float maxvalue = (float) +HUGE_VAL;
   //int show_values = 0;
   //int sort_vars = 0;
   //int old_vars = 0;
   time_t starttime, endtime;
   int flags;
 
   time_t now = ss_time();
 
   if (xendtime == 0)
      xendtime = now;
 
   HistPlot hp;
   LoadHistPlotFromOdb(odb, &hp, hgroup, hpanel);
 
   std::vector<int> var_index; var_index.resize(hp.vars.size());
 
   for (size_t i=0; i<hp.vars.size(); i++) {
      var_index[i] = 0;
      const char *vp = strchr(hp.vars[i].tag_name.c_str(), '[');
      if (vp) {
         var_index[i] = atoi(vp + 1);
      }
   }
 
   int logaxis = hp.log_axis;
   double minvalue = hp.minimum;
   double maxvalue = hp.maximum;
   
   if ((minvalue == 0) && (maxvalue == 0)) {
      minvalue = -HUGE_VAL;
      maxvalue = +HUGE_VAL;
   }
 
   std::vector<int> x[MAX_VARS];
   std::vector<double> y[MAX_VARS];
 
   HistoryData  hsxxx;
   HistoryData* hsdata = &hsxxx;
 
   cm_get_experiment_database(&hDB, NULL);
 
   /* generate image */
   im = gdImageCreate(width, height);
 
   /* allocate standard colors */
   sscanf(bgcolor, "%02x%02x%02x", &r, &g, &b);
   bgcol = gdImageColorAllocate(im, r, g, b);
   sscanf(fgcolor, "%02x%02x%02x", &r, &g, &b);
   fgcol = gdImageColorAllocate(im, r, g, b);
   sscanf(gridcolor, "%02x%02x%02x", &r, &g, &b);
   gridcol = gdImageColorAllocate(im, r, g, b);
 
   grey = gdImageColorAllocate(im, 192, 192, 192);
   //ltgrey = gdImageColorAllocate(im, 208, 208, 208);
   white = gdImageColorAllocate(im, 255, 255, 255);
   //black = gdImageColorAllocate(im, 0, 0, 0);
   red = gdImageColorAllocate(im, 255, 0, 0);
   //green = gdImageColorAllocate(im, 0, 255, 0);
   //blue = gdImageColorAllocate(im, 0, 0, 255);
 
   curve_col[0] = gdImageColorAllocate(im, 0, 0, 255);
   curve_col[1] = gdImageColorAllocate(im, 0, 192, 0);
   curve_col[2] = gdImageColorAllocate(im, 255, 0, 0);
   curve_col[3] = gdImageColorAllocate(im, 0, 192, 192);
   curve_col[4] = gdImageColorAllocate(im, 255, 0, 255);
   curve_col[5] = gdImageColorAllocate(im, 192, 192, 0);
   curve_col[6] = gdImageColorAllocate(im, 128, 128, 128);
   curve_col[7] = gdImageColorAllocate(im, 128, 255, 128);
   curve_col[8] = gdImageColorAllocate(im, 255, 128, 128);
   curve_col[9] = gdImageColorAllocate(im, 128, 128, 255);
   for (i=10; i<MAX_VARS; i++)
      curve_col[i] = gdImageColorAllocate(im, 128, 128, 128);
 
   state_col[0] = gdImageColorAllocate(im, 255, 0, 0);
   state_col[1] = gdImageColorAllocate(im, 255, 255, 0);
   state_col[2] = gdImageColorAllocate(im, 0, 255, 0);
 
   /* Set transparent color. */
   gdImageColorTransparent(im, grey);
 
   /* Title */
   gdImageString(im, gdFontGiant, width / 2 - (strlen(hpanel) * gdFontGiant->w) / 2, 2, (char*)hpanel, fgcol);
 
   /* connect to history */
   MidasHistoryInterface *mh = get_history();
   if (mh == NULL) {
      sprintf(str, "History is not configured, see messages");
      gdImageString(im, gdFontSmall, width / 2 - (strlen(str) * gdFontSmall->w) / 2, height / 2, str, red);
      goto error;
   }
 
   //sprintf(str, "/History/Display/%s/%s", hgroup, hpanel);
   //db_find_key(hDB, 0, str, &hkeypanel);
   //if (!hkeypanel) {
   //   sprintf(str, "Cannot find /History/Display/%s/%s in ODB", hgroup, hpanel);
   //   gdImageString(im, gdFontSmall, width / 2 - (strlen(str) * gdFontSmall->w) / 2, height / 2, str, red);
   //   goto error;
   //}
 
   //db_find_key(hDB, hkeypanel, "Variables", &hkeydvar);
   //if (!hkeydvar) {
   //   sprintf(str, "Cannot find /History/Display/%s/%s/Variables in ODB", hgroup, hpanel);
   //   gdImageString(im, gdFontSmall, width / 2 - (strlen(str) * gdFontSmall->w) / 2, height / 2, str, red);
   //   goto error;
   //}
 
   //db_get_key(hDB, hkeydvar, &key);
   //n_vars = key.num_values;
 
   if (hp.vars.empty()) {
      sprintf(str, "No variables in panel %s/%s", hgroup, hpanel);
      gdImageString(im, gdFontSmall, width / 2 - (strlen(str) * gdFontSmall->w) / 2, height / 2, str, red);
      goto error;
   }
 
   if (hp.vars.size() > MAX_VARS) {
      sprintf(str, "Too many variables in panel %s/%s", hgroup, hpanel);
      gdImageString(im, gdFontSmall, width / 2 - (strlen(str) * gdFontSmall->w) / 2, height / 2, str, red);
      goto error;
   }
 
   ymin = ymax = 0;
   //logaxis = runmarker = 0;
 
   for (i = 0; i < (int)hp.vars.size(); i++) {
      if (index != -1 && index != i)
         continue;
 
      //size = sizeof(str);
      //status = db_get_data_index(hDB, hkeydvar, str, &size, i, TID_STRING);
      //if (status != DB_SUCCESS) {
      //   sprintf(str, "Cannot read tag %d in panel %s/%s, status %d", i, hgroup, hpanel, status);
      //   gdImageString(im, gdFontSmall, width / 2 - (strlen(str) * gdFontSmall->w) / 2, height / 2, str, red);
      //   goto error;
      //}
      //
      //mstrlcpy(tag_name[i], str, sizeof(tag_name[0]));
 
      //char *tp = strchr(tag_name[i], ':');
      //if (tp) {
      //   mstrlcpy(event_name[i], tag_name[i], sizeof(event_name[0]));
      //   char *ep = strchr(event_name[i], ':');
      //   if (ep)
      //      *ep = 0;
      //   mstrlcpy(var_name[i], tp+1, sizeof(var_name[0]));
      //   var_index[i] = 0;
      //   char *vp = strchr(var_name[i], '[');
      //   if (vp) {
      //      var_index[i] = atoi(vp + 1);
      //      *vp = 0;
      //  }
      //} else {
      //   sprintf(str, "Tag \"%s\" has wrong format in panel \"%s/%s\"", tag_name[i], hgroup, hpanel);
      //   gdImageString(im, gdFontSmall, width / 2 - (strlen(str) * gdFontSmall->w) / 2, height / 2, str, red);
      //   goto error;
      //}
      //
      //db_find_key(hDB, hkeypanel, "Colour", &hkey);
      //if (hkey) {
      //   size = sizeof(str);
      //   status = db_get_data_index(hDB, hkey, str, &size, i, TID_STRING);
      //   if (status == DB_SUCCESS) {
      //      if (str[0] == '#') {
      //         char sss[3];
      //         int r, g, b;
      //
      //         sss[0] = str[1];
      //         sss[1] = str[2];
      //         sss[2] = 0;
      //         r = strtoul(sss, NULL, 16);
      //         sss[0] = str[3];
      //         sss[1] = str[4];
      //         sss[2] = 0;
      //         g = strtoul(sss, NULL, 16);
      //         sss[0] = str[5];
      //         sss[1] = str[6];
      //         sss[2] = 0;
      //         b = strtoul(sss, NULL, 16);
      //
      //         curve_col[i] = gdImageColorAllocate(im, r, g, b);
      //     }
      //  }
      //}
 
      if (hp.vars[i].colour[0] == '#') {
         const char* str = hp.vars[i].colour.c_str();
         char sss[3];
         int r, g, b;
         
         sss[0] = str[1];
         sss[1] = str[2];
         sss[2] = 0;
         r = strtoul(sss, NULL, 16);
         sss[0] = str[3];
         sss[1] = str[4];
         sss[2] = 0;
         g = strtoul(sss, NULL, 16);
         sss[0] = str[5];
         sss[1] = str[6];
         sss[2] = 0;
         b = strtoul(sss, NULL, 16);
         
         curve_col[i] = gdImageColorAllocate(im, r, g, b);
      }
 
      /* get timescale */
      if (scale == 0) {
         //std::string ts = "1h";
         //status = db_get_value_string(hDB, hkeypanel, "Timescale", 0, &ts, TRUE);
         //if (status != DB_SUCCESS) {
         //   /* delete old integer key */
         //   db_find_key(hDB, hkeypanel, "Timescale", &hkey);
         //   if (hkey)
         //      db_delete_key(hDB, hkey, FALSE);
         //
         //   ts = "1h";
         //   status = db_get_value_string(hDB, hkeypanel, "Timescale", 0, &ts, TRUE);
         //}
 
         scale = time_to_sec(hp.timescale.c_str());
      }
 
      //for (j = 0; j < MAX_VARS; j++) {
      //   factor[j] = 1;
      //   offset[j] = 0;
      //}
 
      //size = sizeof(float) * n_vars;
      //db_get_value(hDB, hkeypanel, "Factor", factor, &size, TID_FLOAT, TRUE);
 
      //size = sizeof(float) * n_vars;
      //db_get_value(hDB, hkeypanel, "Offset", offset, &size, TID_FLOAT, TRUE);
 
      //size = sizeof(logaxis);
      //logaxis = 0;
      //db_get_value(hDB, hkeypanel, "Log axis", &logaxis, &size, TID_BOOL, TRUE);
 
      //size = sizeof(show_values);
      //show_values = 0;
      //db_get_value(hDB, hkeypanel, "Show values", &show_values, &size, TID_BOOL, TRUE);
 
      //size = sizeof(sort_vars);
      //sort_vars = 0;
      //db_get_value(hDB, hkeypanel, "Sort vars", &sort_vars, &size, TID_BOOL, TRUE);
 
      //size = sizeof(old_vars);
      //old_vars = 0;
      //db_get_value(hDB, hkeypanel, "Show old vars", &old_vars, &size, TID_BOOL, TRUE);
 
      //size = sizeof(minvalue);
      //minvalue = (float) -HUGE_VAL;
      //db_get_value(hDB, hkeypanel, "Minimum", &minvalue, &size, TID_FLOAT, TRUE);
 
      //size = sizeof(maxvalue);
      //maxvalue = (float) +HUGE_VAL;
      //db_get_value(hDB, hkeypanel, "Maximum", &maxvalue, &size, TID_FLOAT, TRUE);
 
      //if ((minvalue == 0) && (maxvalue == 0)) {
      //   minvalue = (float) -HUGE_VAL;
      //   maxvalue = (float) +HUGE_VAL;
      //}
 
      //size = sizeof(runmarker);
      //runmarker = 1;
      //db_get_value(hDB, hkeypanel, "Show run markers", &runmarker, &size, TID_BOOL, TRUE);
 
      /* make ODB path from tag name */
      std::string odbpath;
      HNDLE hkeyeq = 0;
      HNDLE hkeyroot;
      db_find_key(hDB, 0, "/Equipment", &hkeyroot);
      if (hkeyroot) {
         for (j = 0;; j++) {
            HNDLE hkeyeq;
            db_enum_key(hDB, hkeyroot, j, &hkeyeq);
 
            if (!hkeyeq)
               break;
 
            KEY key;
            db_get_key(hDB, hkeyeq, &key);
            if (equal_ustring(key.name, hp.vars[i].event_name.c_str())) {
               /* check if variable is individual key under variables/ */
               sprintf(str, "Variables/%s", hp.vars[i].tag_name.c_str());
               HNDLE hkey;
               db_find_key(hDB, hkeyeq, str, &hkey);
               if (hkey) {
                  //sprintf(odbpath, "/Equipment/%s/Variables/%s", event_name[i], var_name[i]);
                  odbpath = "";
                  odbpath += "/Equipment/";
                  odbpath += hp.vars[i].event_name;
                  odbpath += "/Variables/";
                  odbpath += hp.vars[i].tag_name;
                  break;
               }
 
               /* check if variable is in setttins/names array */
               HNDLE hkeynames;
               db_find_key(hDB, hkeyeq, "Settings/Names", &hkeynames);
               if (hkeynames) {
                  /* extract variable name and Variables/<key> */
                  mstrlcpy(str, hp.vars[i].tag_name.c_str(), sizeof(str));
                  p = str + strlen(str) - 1;
                  while (p > str && *p != ' ')
                     p--;
                  std::string key_name = p + 1;
                  *p = 0;
 
                  std::string varname = str;
 
                  /* find key in single name array */
                  db_get_key(hDB, hkeynames, &key);
                  for (k = 0; k < key.num_values; k++) {
                     size = sizeof(str);
                     db_get_data_index(hDB, hkeynames, str, &size, k, TID_STRING);
                     if (equal_ustring(str, varname.c_str())) {
                        //sprintf(odbpath, "/Equipment/%s/Variables/%s[%d]", event_name[i], key_name, k);
                        odbpath = "";
                        odbpath += "/Equipment/";
                        odbpath += hp.vars[i].event_name;
                        odbpath += "/Variables/";
                        odbpath += key_name;
                        odbpath += "[";
                        odbpath += toString(k);
                        odbpath += "]";
                        break;
                     }
                  }
               } else {
                  /* go through /variables/<name> entries */
                  HNDLE hkeyvars;
                  db_find_key(hDB, hkeyeq, "Variables", &hkeyvars);
                  if (hkeyvars) {
                     for (k = 0;; k++) {
                        db_enum_key(hDB, hkeyvars, k, &hkey);
 
                        if (!hkey)
                           break;
 
                        /* find "settins/names <key>" for this key */
                        db_get_key(hDB, hkey, &key);
 
                        /* find key in key_name array */
                        std::string key_name = key.name;
 
                        std::string path;
                        //sprintf(str, "Settings/Names %s", key_name);
                        path += "Settings/Names ";
                        path += key_name;
 
                        HNDLE hkeynames;
                        db_find_key(hDB, hkeyeq, path.c_str(), &hkeynames);
                        if (hkeynames) {
                           db_get_key(hDB, hkeynames, &key);
                           for (l = 0; l < key.num_values; l++) {
                              size = sizeof(str);
                              db_get_data_index(hDB, hkeynames, str, &size, l, TID_STRING);
                              if (equal_ustring(str, hp.vars[i].tag_name.c_str())) {
                                 //sprintf(odbpath, "/Equipment/%s/Variables/%s[%d]", event_name[i], key_name, l);
                                 odbpath = "";
                                 odbpath += "/Equipment/";
                                 odbpath += hp.vars[i].event_name;
                                 odbpath += "/Variables/";
                                 odbpath += key_name;
                                 odbpath += "[";
                                 odbpath += toString(l);
                                 odbpath += "]";
                                 break;
                              }
                           }
                        }
                     }
                  }
               }
 
               break;
            }
         }
 
         if (!hkeyeq) {
            db_find_key(hDB, 0, "/History/Links", &hkeyroot);
            if (hkeyroot) {
               for (j = 0;; j++) {
                  HNDLE hkey;
                  db_enum_link(hDB, hkeyroot, j, &hkey);
 
                  if (!hkey)
                     break;
 
                  KEY key;
                  db_get_key(hDB, hkey, &key);
                  if (equal_ustring(key.name, hp.vars[i].event_name.c_str())) {
                     db_enum_key(hDB, hkeyroot, j, &hkey);
                     db_find_key(hDB, hkey, hp.vars[i].tag_name.c_str(), &hkey);
                     if (hkey) {
                        db_get_key(hDB, hkey, &key);
                        odbpath = db_get_path(hDB, hkey);
                        if (key.num_values > 1) {
                           odbpath += "[";
                           odbpath += toString(var_index[i]);
                           odbpath += "]";
                        }
                        break;
                     }
                  }
               }
            }
         }
      }
 
      /* search alarm limits */
      upper_limit[i] = lower_limit[i] = -12345;
      db_find_key(hDB, 0, "Alarms/Alarms", &hkeyroot);
      if (odbpath.length() > 0 && hkeyroot) {
         for (j = 0;; j++) {
            HNDLE hkey;
            db_enum_key(hDB, hkeyroot, j, &hkey);
 
            if (!hkey)
               break;
 
            size = sizeof(str);
            db_get_value(hDB, hkey, "Condition", str, &size, TID_STRING, TRUE);
 
            if (strstr(str, odbpath.c_str())) {
               if (strchr(str, '<')) {
                  p = strchr(str, '<') + 1;
                  if (*p == '=')
                     p++;
                  if (hp.enable_factor) {
                     lower_limit[i] = (hp.vars[i].factor * (atof(p) - hp.vars[i].voffset) + hp.vars[i].offset);
                  } else {
                     lower_limit[i] = atof(p);
                  }
               }
               if (strchr(str, '>')) {
                  p = strchr(str, '>') + 1;
                  if (*p == '=')
                     p++;
                  if (hp.enable_factor) {
                     upper_limit[i] = (hp.vars[i].factor * (atof(p) - hp.vars[i].voffset) + hp.vars[i].offset);
                  } else {
                     upper_limit[i] = atof(p);
                  }
               }
            }
         }
      }
   } // loop over variables
 
   //starttime = now - scale + toffset;
   //endtime = now + toffset;
 
   starttime = xendtime - scale;
   endtime = xendtime;
 
   //printf("now %d, scale %d, xendtime %d, starttime %d, endtime %d\n", now, scale, xendtime, starttime, endtime);
 
   flags = READ_HISTORY_DATA;
   if (hp.show_run_markers)
      flags |= READ_HISTORY_RUNMARKER;
 
   status = read_history(hp, /*hDB, hgroup, hpanel,*/ index, flags, starttime, endtime, scale/1000+1, hsdata);
 
   if (status != HS_SUCCESS) {
      sprintf(str, "Complete history failure, read_history() status %d, see messages", status);
      gdImageString(im, gdFontSmall, width / 2 - (strlen(str) * gdFontSmall->w) / 2, height / 2, str, red);
      goto error;
   }
 
   DWORD n_point[MAX_VARS];
   char var_status[MAX_VARS][256];
 
   for (int k=0; k<hsdata->nvars; k++) {
      int i = hsdata->odb_index[k];
 
      if (i<0)
         continue;
 
      if (index != -1 && index != i)
         continue;
 
      n_point[i] = 0;
 
      var_status[i][0] = 0;
      if (hsdata->status[k] == HS_UNDEFINED_VAR) {
         sprintf(var_status[i], "not found in history");
         continue;
      } else if (hsdata->status[k] != HS_SUCCESS) {
         sprintf(var_status[i], "hs_read() error %d, see messages", hsdata->status[k]);
         continue;
      }
 
      int n_vp = 0;
      for (int j=0; j<hsdata->num_entries[k]; j++) {
         int xx = (int)(hsdata->t[k][j]);
         double yy = hsdata->v[k][j];
 
         /* skip NaNs */
         if (ss_isnan(yy))
            continue;
 
         /* skip INFs */
         if (!ss_isfin(yy))
            continue;
 
         /* avoid overflow */
         if (yy > 1E30)
            yy = 1E30f;
 
         /* apply factor and offset */
         if (hp.enable_factor) {
            yy = hp.vars[i].factor * (yy - hp.vars[i].voffset) + hp.vars[i].offset;
         }
 
         /* calculate ymin and ymax */
         if ((i == 0 || index != -1) && n_vp == 0)
            ymin = ymax = yy;
         else {
            if (yy > ymax)
               ymax = yy;
            if (yy < ymin)
               ymin = yy;
         }
 
         /* increment number of valid points */
 
         x[i].push_back(xx);
         y[i].push_back(yy);
 
         n_vp++;
 
      } // loop over data
 
      n_point[i] = n_vp;
 
      assert(x[i].size() == y[i].size());
   }
 
   //int flag;
   int xmaxm;
   int row;
   int xold;
   int yold;
   int aoffset;
   double yb1, yb2, yf1, yf2;
   int xs, ys;
   int x1, x2;
   int y1, y2;
   int xs_old;
   double ybase;
 
   gdPoint poly[3];
 
   if (ymin < minvalue)
      ymin = minvalue;
 
   if (ymax > maxvalue)
      ymax = maxvalue;
 
   /* check if ylow = 0 */
   if (index == -1) {
      //flag = 0;
      //size = sizeof(flag);
      //db_get_value(hDB, hkeypanel, "Zero ylow", &flag, &size, TID_BOOL, TRUE);
      if (hp.zero_ylow && ymin > 0)
         ymin = 0;
   }
 
   /* if min and max too close together, switch to linear axis */
   if (logaxis && ymin > 0 && ymax > 0) {
      yb1 = pow(10, floor(log(ymin) / LN10));
      yf1 = floor(ymin / yb1);
      yb2 = pow(10, floor(log(ymax) / LN10));
      yf2 = floor(ymax / yb2);
 
      if (yb1 == yb2 && yf1 == yf2)
         logaxis = 0;
      else {
         /* round down and up ymin and ymax */
         ybase = pow(10, floor(log(ymin) / LN10));
         ymin = (floor(ymin / ybase) * ybase);
         ybase = pow(10, floor(log(ymax) / LN10));
         ymax = ((floor(ymax / ybase) + 1) * ybase);
      }
   }
 
   /* avoid negative limits for log axis */
   if (logaxis) {
      if (ymax <= 0)
         ymax = 1;
      if (ymin <= 0)
         ymin = 1E-12f;
   }
 
   /* increase limits by 5% */
   if (ymin == 0 && ymax == 0) {
      ymin = -1;
      ymax = 1;
   } else {
      if (!logaxis) {
         ymax += (ymax - ymin) / 20.f;
 
         if (ymin != 0)
            ymin -= (ymax - ymin) / 20.f;
      }
   }
 
   /* avoid ymin == ymax */
   if (ymax == ymin) {
      if (logaxis) {
         ymax *= 2;
         ymin /= 2;
      } else {
         ymax += 10;
         ymin -= 10;
      }
   }
 
   /* calculate X limits */
   //xmin = (double) (-scale / 3600.0 + toffset / 3600.0);
   //xmax = (double) (toffset / 3600.0);
   //xrange = xmax - xmin;
   //xrange = scale/3600.0;
 
   /* caluclate required space for Y-axis */
   aoffset = vaxis(im, gdFontSmall, fgcol, gridcol, 0, 0, height, -3, -5, -7, -8, 0, ymin, ymax, logaxis);
   aoffset += 2;
 
   x1 = aoffset;
   y1 = height - 20;
   x2 = width - 20;
   y2 = 20;
 
   gdImageFilledRectangle(im, x1, y2, x2, y1, bgcol);
 
   /* draw axis frame */
   taxis(im, gdFontSmall, fgcol, gridcol, x1, y1, x2 - x1, width, 3, 5, 9, 10, 0, (double)starttime, (double)endtime);
 
   vaxis(im, gdFontSmall, fgcol, gridcol, x1, y1, y1 - y2, -3, -5, -7, -8, x2 - x1, ymin, ymax, logaxis);
   gdImageLine(im, x1, y2, x2, y2, fgcol);
   gdImageLine(im, x2, y2, x2, y1, fgcol);
 
   xs = ys = xold = yold = 0;
 
   /* old code for run markers, new code is below */
 
   /* write run markes if selected */
   if (/* DISABLES CODE */ (0) && hp.show_run_markers) {
 
      const char* event_names[] = {
         "Run transitions",
         "Run transitions",
         0 };
 
      const char* tag_names[] = {
         "State",
         "Run number",
         0 };
 
      const int tag_indexes[] = {
         0,
         0,
         0 };
 
      int num_entries[3];
      time_t *tbuf[3];
      double *dbuf[3];
      int     st[3];
 
      num_entries[0] = 0;
      num_entries[1] = 0;
 
      status = mh->hs_read(starttime - scale, endtime, 0,
                           2, event_names, tag_names, tag_indexes,
                           num_entries, tbuf, dbuf, st);
 
      //printf("read run info: status %d, entries %d %d\n", status, num_entries[0], num_entries[1]);
 
      int n_marker = num_entries[0];
 
      if (status == HS_SUCCESS && n_marker > 0 && n_marker < 100) {
         xs_old = -1;
         xmaxm = x1;
         for (j = 0; j < (int) n_marker; j++) {
            int col;
 
            // explicit algebra manipulation to clarify computations:
 
            //xmin = (double) (-scale / 3600.0 + toffset / 3600.0);
            //xrange = scale/3600.0;
            //time_t starttime = now - scale + toffset;
 
            //x_marker = (int)(tbuf[1][j] - now);
            //xs = (int) ((x_marker / 3600.0 - xmin) / xrange * (x2 - x1) + x1 + 0.5);
            //xs = (int) (((tbuf[1][j] - now) / 3600.0 - xmin) / xrange * (x2 - x1) + x1 + 0.5);
            //xs = (int) (((tbuf[1][j] - now) / 3600.0 - (-scale / 3600.0 + toffset / 3600.0)) / (scale/3600.0) * (x2 - x1) + x1 + 0.5);
            //xs = (int) (((tbuf[1][j] - now) - (-scale + toffset)) / (scale/1.0) * (x2 - x1) + x1 + 0.5);
            xs = (int) ((tbuf[1][j] - starttime) / (scale/1.0) * (x2 - x1) + x1 + 0.5);
 
            if (xs < x1)
               continue;
            if (xs >= x2)
               continue;
 
            double run_number = dbuf[1][j];
 
            if (xs <= xs_old)
               xs = xs_old + 1;
            xs_old = xs;
 
            if (dbuf[0][j] == 1)
               col = state_col[0];
            else if (dbuf[0][j] == 2)
               col = state_col[1];
            else if (dbuf[0][j] == 3)
               col = state_col[2];
            else
               col = state_col[0];
 
            gdImageDashedLine(im, xs, y1, xs, y2, col);
 
            sprintf(str, "%.0f", run_number);
 
            if (dbuf[0][j] == STATE_RUNNING) {
               if (xs > xmaxm) {
                  gdImageStringUp(im, gdFontSmall, xs + 0, y2 + 2 + gdFontSmall->w * strlen(str), str, fgcol);
                  xmaxm = xs - 2 + gdFontSmall->h;
               }
            } else if (dbuf[0][j] == STATE_STOPPED) {
               if (xs + 2 - gdFontSmall->h > xmaxm) {
                  gdImageStringUp(im, gdFontSmall, xs + 2 - gdFontSmall->h, y2 + 2 + gdFontSmall->w * strlen(str), str, fgcol);
                  xmaxm = xs - 1;
               }
            }
         }
      }
 
      if (num_entries[0]) {
         free(tbuf[0]);
         free(dbuf[0]);
         tbuf[0] = NULL;
         dbuf[0] = NULL;
      }
 
      if (num_entries[1]) {
         free(tbuf[1]);
         free(dbuf[1]);
         tbuf[1] = NULL;
         dbuf[1] = NULL;
      }
   }
 
   /* write run markes if selected */
   if (hp.show_run_markers) {
 
      int index_state = -1;
      int index_run_number = -1;
 
      for (int k=0; k<hsdata->nvars; k++) {
         if (hsdata->odb_index[k] == -1)
            index_state = k;
 
         if (hsdata->odb_index[k] == -2)
            index_run_number = k;
      }
 
      bool ok = true;
 
      if (ok)
         ok = (index_state >= 0) && (index_run_number >= 0);
 
      if (ok)
         ok = (hsdata->status[index_state] == HS_SUCCESS);
 
      if (ok)
         ok = (hsdata->status[index_run_number] == HS_SUCCESS);
 
      if (/* DISABLES CODE */ (0) && ok)
         printf("read run info: indexes: %d, %d, status: %d, %d, entries: %d, %d\n", index_state, index_run_number, hsdata->status[index_state], hsdata->status[index_run_number], hsdata->num_entries[index_state], hsdata->num_entries[index_run_number]);
 
      if (ok)
         ok = (hsdata->num_entries[index_state] == hsdata->num_entries[index_run_number]);
 
      int n_marker = hsdata->num_entries[index_state];
 
      if (ok && n_marker > 0 && n_marker < 100) {
         xs_old = -1;
         xmaxm = x1;
         for (j = 0; j < (int) n_marker; j++) {
            int col;
 
            // explicit algebra manipulation to clarify computations:
 
            //xmin = (double) (-scale / 3600.0 + toffset / 3600.0);
            //xrange = scale/3600.0;
            //time_t starttime = now - scale + toffset;
 
            //x_marker = (int)(tbuf[1][j] - now);
            //xs = (int) ((x_marker / 3600.0 - xmin) / xrange * (x2 - x1) + x1 + 0.5);
            //xs = (int) (((tbuf[1][j] - now) / 3600.0 - xmin) / xrange * (x2 - x1) + x1 + 0.5);
            //xs = (int) (((tbuf[1][j] - now) / 3600.0 - (-scale / 3600.0 + toffset / 3600.0)) / (scale/3600.0) * (x2 - x1) + x1 + 0.5);
            //xs = (int) (((tbuf[1][j] - now) - (-scale + toffset)) / (scale/1.0) * (x2 - x1) + x1 + 0.5);
            xs = (int) ((hsdata->t[index_state][j] - starttime) / (scale/1.0) * (x2 - x1) + x1 + 0.5);
 
            if (xs < x1)
               continue;
            if (xs >= x2)
               continue;
 
            double run_number = hsdata->v[index_run_number][j];
 
            if (xs <= xs_old)
               xs = xs_old + 1;
            xs_old = xs;
 
            int state = (int)hsdata->v[index_state][j];
 
            if (state == 1)
               col = state_col[0];
            else if (state == 2)
               col = state_col[1];
            else if (state == 3)
               col = state_col[2];
            else
               col = state_col[0];
 
            gdImageDashedLine(im, xs, y1, xs, y2, col);
 
            sprintf(str, "%.0f", run_number);
 
            if (state == STATE_RUNNING) {
               if (xs > xmaxm) {
                  gdImageStringUp(im, gdFontSmall, xs + 0, y2 + 2 + gdFontSmall->w * strlen(str), str, fgcol);
                  xmaxm = xs - 2 + gdFontSmall->h;
               }
            } else if (state == STATE_STOPPED) {
               if (xs + 2 - gdFontSmall->h > xmaxm) {
                  gdImageStringUp(im, gdFontSmall, xs + 2 - gdFontSmall->h, y2 + 2 + gdFontSmall->w * strlen(str), str, fgcol);
                  xmaxm = xs - 1;
               }
            }
         }
      }
   }
 
   for (i = 0; i < (int)hp.vars.size(); i++) {
      if (index != -1 && index != i)
         continue;
 
      /* draw alarm limits */
      if (lower_limit[i] != -12345) {
         if (logaxis) {
            if (lower_limit[i] <= 0)
               ys = y1;
            else
               ys = (int) (y1 - (log(lower_limit[i]) - log(ymin)) / (log(ymax) - log(ymin)) * (y1 - y2) + 0.5);
         } else {
            ys = (int) (y1 - (lower_limit[i] - ymin) / (ymax - ymin) * (y1 - y2) + 0.5);
         }
 
         if (xs < 0)
            xs = 0;
         if (xs >= width)
            xs = width-1;
         if (ys < 0)
            ys = 0;
         if (ys >= height)
            ys = height-1;
 
         if (ys > y2 && ys < y1) {
            gdImageDashedLine(im, x1, ys, x2, ys, curve_col[i]);
 
            poly[0].x = x1;
            poly[0].y = ys;
            poly[1].x = x1 + 5;
            poly[1].y = ys;
            poly[2].x = x1;
            poly[2].y = ys - 5;
 
            gdImageFilledPolygon(im, poly, 3, curve_col[i]);
         }
      }
      if (upper_limit[i] != -12345) {
         if (logaxis) {
            if (upper_limit[i] <= 0)
               ys = y1;
            else
               ys = (int) (y1 - (log(upper_limit[i]) - log(ymin)) / (log(ymax) - log(ymin)) * (y1 - y2) + 0.5);
         } else {
            ys = (int) (y1 - (upper_limit[i] - ymin) / (ymax - ymin) * (y1 - y2) + 0.5);
         }
 
         if (xs < 0)
            xs = 0;
         if (xs >= width)
            xs = width-1;
         if (ys < 0)
            ys = 0;
         if (ys >= height)
            ys = height-1;
 
         if (ys > y2 && ys < y1) {
            gdImageDashedLine(im, x1, ys, x2, ys, curve_col[i]);
 
            poly[0].x = x1;
            poly[0].y = ys;
            poly[1].x = x1 + 5;
            poly[1].y = ys;
            poly[2].x = x1;
            poly[2].y = ys + 5;
 
            gdImageFilledPolygon(im, poly, 3, curve_col[i]);
         }
      }
 
      for (j = 0; j < (int) n_point[i]; j++) {
         //xmin = (double) (-scale / 3600.0 + toffset / 3600.0);
         //xrange = scale/3600.0;
         //xs = (int) (((x[i][j]-now) / 3600.0 - xmin) / xrange * (x2 - x1) + x1 + 0.5);
         //xs = (int) (((x[i][j] - now + scale - toffset) / 3600.0) / xrange * (x2 - x1) + x1 + 0.5);
         //xs = (int) (((x[i][j] - starttime) / 3600.0) / xrange * (x2 - x1) + x1 + 0.5);
         xs = (int) (((x[i][j] - starttime)/1.0) / (1.0*scale) * (x2 - x1) + x1 + 0.5);
 
         if (logaxis) {
            if (y[i][j] <= 0)
               ys = y1;
            else
               ys = (int) (y1 - (log(y[i][j]) - log(ymin)) / (log(ymax) - log(ymin)) * (y1 - y2) + 0.5);
         } else {
            ys = (int) (y1 - (y[i][j] - ymin) / (ymax - ymin) * (y1 - y2) + 0.5);
         }
 
         if (xs < 0)
            xs = 0;
         if (xs >= width)
            xs = width-1;
         if (ys < 0)
            ys = 0;
         if (ys >= height)
            ys = height-1;
 
         if (j > 0)
            gdImageLine(im, xold, yold, xs, ys, curve_col[i]);
         xold = xs;
         yold = ys;
      }
 
      if (n_point[i] > 0) {
         poly[0].x = xs;
         poly[0].y = ys;
         poly[1].x = xs + 12;
         poly[1].y = ys - 6;
         poly[2].x = xs + 12;
         poly[2].y = ys + 6;
 
         gdImageFilledPolygon(im, poly, 3, curve_col[i]);
      }
   }
 
   if (labels) {
      for (i = 0; i < (int)hp.vars.size(); i++) {
         if (index != -1 && index != i)
            continue;
 
         //str[0] = 0;
         //status = db_find_key(hDB, hkeypanel, "Label", &hkeydvar);
         //if (status == DB_SUCCESS) {
         //   size = sizeof(str);
         //   status = db_get_data_index(hDB, hkeydvar, str, &size, i, TID_STRING);
         //}
 
         std::string str = hp.vars[i].label.c_str();
 
         if (str.empty()) {
            if (hp.enable_factor) {
               str = hp.vars[i].tag_name;
 
               if (hp.vars[i].voffset > 0)
                  str += msprintf(" - %G", hp.vars[i].voffset);
               else if (hp.vars[i].voffset < 0)
                  str += msprintf(" + %G", -hp.vars[i].voffset);
 
               if (hp.vars[i].factor != 1) {
                  if (hp.vars[i].voffset == 0)
                     str += msprintf(" * %+G", hp.vars[i].factor);
                  else {
                     str = msprintf("(%s) * %+G", str.c_str(), hp.vars[i].factor);
                  }
               }
 
               if (hp.vars[i].offset > 0)
                  str += msprintf(" + %G", hp.vars[i].offset);
               else if (hp.vars[i].offset < 0)
                  str += msprintf(" - %G", -hp.vars[i].offset);
 
            } else {
               str = hp.vars[i].tag_name;
            }
         }
 
         int k=0;
         for (int j=0; j<hsdata->nvars; j++)
            if (hsdata->odb_index[j] == i) {
               k = j;
               break;
            }
 
         if (/* DISABLES CODE */ (0)) {
            printf("graph %d: odb index %d, n_point %d, num_entries %d, have_last_written %d %d, status %d, var_status [%s]\n", i, k, n_point[i], hsdata->num_entries[k], hsdata->have_last_written, (int)hsdata->last_written[k], hsdata->status[k], var_status[i]);
         }
 
         if (hp.show_values) {
            char xstr[256];
            if (n_point[i] > 0) {
               sprintf(xstr," = %g", y[i][n_point[i]-1]);
            } else if (hsdata->num_entries[k] > 0) {
               sprintf(xstr," = all data is NaN or INF");
            } else if (hsdata->have_last_written) {
               if (hsdata->last_written[k]) {
                  char ctimebuf[32];
                  ctime_r(&hsdata->last_written[k], ctimebuf);
                  sprintf(xstr," = last data %s", ctimebuf);
                  // kill trailing '\n'
                  char*s = strchr(xstr, '\n');
                  if (s) *s=0;
                  // clear the unnecessary error status report
                  if (hsdata->status[k] == HS_UNDEFINED_VAR)
                     var_status[i][0] = 0;
               } else {
                  sprintf(xstr," = no data ever");
               }
            } else {
               sprintf(xstr," = no data");
            }
            str += xstr;
         }
 
         if (strlen(var_status[i]) > 1) {
            str += msprintf(" (%s)", var_status[i]);
         }
 
         row = index == -1 ? i : 0;
 
         gdImageFilledRectangle(im,
                                x1 + 10,
                                y2 + 10 + row * (gdFontMediumBold->h + 10),
                                x1 + 10 + str.length() * gdFontMediumBold->w + 10,
                                y2 + 10 + row * (gdFontMediumBold->h + 10) +
                                gdFontMediumBold->h + 2 + 2, white);
         gdImageRectangle(im, x1 + 10, y2 + 10 + row * (gdFontMediumBold->h + 10),
                          x1 + 10 + str.length() * gdFontMediumBold->w + 10,
                          y2 + 10 + row * (gdFontMediumBold->h + 10) +
                          gdFontMediumBold->h + 2 + 2, curve_col[i]);
 
         gdImageString(im, gdFontMediumBold,
                       x1 + 10 + 5, y2 + 10 + 2 + row * (gdFontMediumBold->h + 10),
                       (char*)str.c_str(),
                       curve_col[i]);
      }
   }
 
   gdImageRectangle(im, x1, y2, x2, y1, fgcol);
 
 error:
 
   /* generate GIF */
   gdImageInterlace(im, 1);
   gdImageGif(im, &gb);
   gdImageDestroy(im);
   length = gb.size;
 
   if (buffer == NULL) {
      rr->rsprintf("HTTP/1.1 200 Document follows\r\n");
      rr->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
 
      rr->rsprintf("Content-Type: image/gif\r\n");
      rr->rsprintf("Content-Length: %d\r\n", length);
      rr->rsprintf("Cache-control: private, max-age=0, no-cache\r\n");
      rr->rsprintf("Expires: Fri, 01-Jan-1983 00:00:00 GMT\r\n\r\n");
 
      rr->rmemcpy(gb.data, length);
   } else {
      if (length > *buffer_size) {
         printf("return buffer too small\n");
         return;
      }
 
      memcpy(buffer, gb.data, length);
      *buffer_size = length;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_content_type()

std::string get_content_type

(

const char *

filename

)

Definition at line 1133 of file mhttpd.cxx.

{
   std::string ext_upper;
   const char* p = filename;
   const char* last_dot = NULL;
   for (; *p; p++) {
      if (*p == '.')
         last_dot = p;
      if (*p == DIR_SEPARATOR)
         last_dot = NULL;
   }
 
   if (last_dot) {
      p = last_dot;
      for (; *p; p++)
         ext_upper += toupper(*p);
   }
 
   //printf("filename: [%s], ext [%s]\n", filename, ext_upper.c_str());
 
   std::string type = GetMimetype(ext_upper);
   if (type.length() > 0)
      return type;
 
   cm_msg(MERROR, "get_content_type", "Unknown HTTP Content-Type for resource file \'%s\', file extension \'%s\'", filename, ext_upper.c_str());
 
   return "text/plain";
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_elog_url()

void get_elog_url	(	char *	url,
		int	len
	)

Here is the caller graph for this function:

get_hist_last_written()

int get_hist_last_written	(	MVOdb *	odb,
		const char *	group,
		const char *	panel,
		time_t	endtime,
		int	index,
		int	want_all,
		time_t *	plastwritten
	)

Definition at line 8521 of file mhttpd.cxx.

{
   //HNDLE hDB;
   int status;
 
   time_t now = ss_time();
 
   if (endtime == 0)
      endtime = now;
 
   HistoryData  hsxxx;
   HistoryData* hsdata = &hsxxx;
 
   //cm_get_experiment_database(&hDB, NULL);
 
   HistPlot hp;
   LoadHistPlotFromOdb(odb, &hp, group, panel);
 
   double tstart = ss_millitime();
 
   int flags = READ_HISTORY_LAST_WRITTEN;
 
   status = read_history(hp, /*hDB, group, panel,*/ index, flags, endtime, endtime, 0, hsdata);
 
   if (status != HS_SUCCESS) {
      //sprintf(str, "Complete history failure, read_history() status %d, see messages", status);
      return status;
   }
 
   if (!hsdata->have_last_written) {
      //sprintf(str, "Complete history failure, read_history() status %d, see messages", status);
      return HS_FILE_ERROR;
   }
 
   int count = 0;
   time_t tmin = endtime;
   time_t tmax = 0;
 
   for (int k=0; k<hsdata->nvars; k++) {
      int i = hsdata->odb_index[k];
 
      if (i<0)
         continue;
      if (index != -1 && index != i)
         continue;
 
      time_t lw = hsdata->last_written[k];
 
      if (lw==0) // no last_written for this variable, skip it.
         continue;
 
      if (lw > endtime)
         lw = endtime; // just in case hs_get_last_written() returns dates in the "future" for this plot
 
      if (lw > tmax)
         tmax = lw;
 
      if (lw < tmin)
         tmin = lw;
 
      count++;
 
      //printf("odb index %d, last_written[%d] = %.0f, tmin %.0f, tmax %.0f, endtime %.0f\n", i, k, (double)lw, (double)tmin, (double)tmax, (double)endtime);
   }
 
   if (count == 0) // all variables have no last_written
      return HS_FILE_ERROR;
 
   if (want_all)
      *plastwritten = tmin; // all variables have data
   else
      *plastwritten = tmax; // at least one variable has data
 
   //printf("tmin %.0f, tmax %.0f, endtime %.0f, last written %.0f\n", (double)tmin, (double)tmax, (double)endtime, (double)*plastwritten);
 
   double tend = ss_millitime();
 
   if (/* DISABLES CODE */ (0))
      printf("get_hist_last_written: elapsed time %f ms\n", tend-tstart);
 
   return HS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_history()

static MidasHistoryInterface * get_history ( bool  reset = false )

static

Definition at line 8157 of file mhttpd.cxx.

{
   int status;
   HNDLE hDB;
 
   // history reconnect requested by watch callback?
 
   if (gDoReloadHistory) {
      gDoReloadHistory = false;
      reset = true;
   }
 
   // disconnect from previous history
 
   if (reset && gMh) {
      gMh->hs_disconnect();
      delete gMh;
      gMh = NULL;
      gMhkey = 0;
   }
 
   status = cm_get_experiment_database(&hDB, NULL);
   assert(status == CM_SUCCESS);
 
   // setup a watch on history configuration
 
   if (gDoSetupHistoryWatch) {
      HNDLE hKey;
      gDoSetupHistoryWatch = false;
 
      status = db_find_key(hDB, 0, "/Logger/History", &hKey);
      if (status == DB_SUCCESS)
         status = db_watch(hDB, hKey, history_watch_callback, NULL);
 
      status = db_find_key(hDB, 0, "/History/LoggerHistoryChannel", &hKey);
      if (status == DB_SUCCESS)
         status = db_watch(hDB, hKey, history_watch_callback, NULL);
   }
 
   // find out if ODB settings have changed and we need to connect to a different history channel
 
   HNDLE hKey = 0;
   status = hs_find_reader_channel(hDB, &hKey, verbose);
   if (status != HS_SUCCESS)
      return gMh;
 
   //printf("mh %p, hKey %d, mhkey %d\n", mh, hKey, mhkey);
 
   if (gMh && hKey == gMhkey) // same channel as before
      return gMh;
 
   if (gMh) {
      delete gMh;
      gMh = NULL;
      gMhkey = 0;
   }
 
   status = hs_get_history(hDB, hKey, HS_GET_READER|HS_GET_INACTIVE, verbose, &gMh);
   if (status != HS_SUCCESS || gMh==NULL) {
      cm_msg(MERROR, "get_history", "Cannot configure history, hs_get_history() status %d", status);
      gMh = NULL;
      return NULL;
   }
 
   gMhkey = hKey;
 
   // cm_msg(MINFO, "get_history", "Reading history from channel \'%s\' type \'%s\'", mh->name, mh->type);
 
   return gMh;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_http_trace()

static MJsonNode * get_http_trace ( const MJsonNode *  params )

static

Definition at line 16175 of file mhttpd.cxx.

{
   if (!params) {
      MJSO *doc = MJSO::I();
      doc->D("get current value of mhttpd http_trace");
      doc->P(NULL, 0, "there are no input parameters");
      doc->R(NULL, MJSON_INT, "current value of http_trace");
      return doc;
   }
 
   return mjsonrpc_make_result("http_trace", MJsonNode::MakeInt(http_trace));
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_resource_paths()

std::vector< std::string > get_resource_paths

(

)

Definition at line 989 of file mhttpd.cxx.

{
   HNDLE hDB;
   int status;
 
   cm_get_experiment_database(&hDB, NULL);
 
   std::vector<std::string> paths;
 
   // add /Experiment/Resources
   std::string buf;
   status = db_get_value_string(hDB, 0, "/Experiment/Resources", 0, &buf, TRUE);
   if (status == DB_SUCCESS && buf.length() > 0)
      paths.push_back(buf);
 
   // add  "/Logger/History/IMAGE/History dir"
   paths.push_back(cm_get_history_path("IMAGE"));
 
   // add /Logger/Data dir
   status = db_get_value_string(hDB, 0, "/Logger/Data dir", 0, &buf, TRUE);
   if (status == DB_SUCCESS && buf.length() > 0)
      paths.push_back(buf);
 
   std::string cwd = ss_getcwd();
   if (!cwd.empty()) {
      paths.push_back(cwd + "/");
      paths.push_back(cwd + "/resources/");
   }
   paths.push_back(cm_get_path());
   paths.push_back(cm_get_path() + "resources/");
   char *m = getenv("MIDASSYS");
   if (m) {
      paths.push_back(std::string(m) + "/resources/");
   }
 
   return paths;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetMimetype()

static std::string GetMimetype ( const std::string &  ext )

static

Definition at line 179 of file mhttpd.cxx.

{
   if (gMimeTypesOdb) {
      std::string mimetype;
      gMimeTypesOdb->RS(ext.c_str(), &mimetype);
      if (mimetype.length() > 0) {
         //printf("GetMimetype: %s -> %s from ODB\n", ext.c_str(), mimetype.c_str());
         return mimetype;
      }
   }
 
   for (int i=0; gMimetypeTable[i].ext[0]; i++) {
      if (ext == gMimetypeTable[i].ext) {
         //printf("GetMimetype: %s -> %s from built-in table\n", ext.c_str(), gMimetypeTable[i].mimetype.c_str());
         return gMimetypeTable[i].mimetype;
      }
   }
 
   //printf("GetMimetype: %s -> not found\n", ext.c_str());
   return "";
}

Here is the caller graph for this function:

GetTimeSec()

static double GetTimeSec ( )

static

Definition at line 374 of file mhttpd.cxx.

{
   struct timeval tv;
   gettimeofday(&tv, NULL);
   return tv.tv_sec*1.0 + tv.tv_usec/1000000.0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

handle_decode_get()

static int handle_decode_get ( struct mg_connection *  nc, const http_message *  msg, const char *  uri, const char *  query_string, RequestTrace *  t  )

static

Definition at line 14257 of file mhttpd.cxx.

{
   Cookies cookies;
 
   decode_cookies(&cookies, msg);
 
   // lock shared structures
 
#ifdef HAVE_MONGOOSE6
   int status = ss_mutex_wait_for(request_mutex, 0);
   assert(status == SS_SUCCESS);
#endif
 
   //t->fTimeLocked = GetTimeSec();
 
   // prepare return buffer
 
   Return *rr = new Return();
 
   rr->zero();
 
   // call midas
 
   decode_get(rr, NULL, &cookies, uri, query_string, t);
 
   if (trace_mg)
      printf("handle_decode_get: return buffer length %d bytes, strlen %d\n", rr->return_length, (int)strlen(rr->return_buffer));
 
   t->fTimeProcessed = GetTimeSec();
 
   if (rr->return_length == -1) {
      delete rr;
#ifdef HAVE_MONGOOSE6
      //t->fTimeUnlocked = GetTimeSec();
      ss_mutex_release(request_mutex);
#endif
      return RESPONSE_501;
   }
 
   if (rr->return_length == 0)
      rr->return_length = strlen(rr->return_buffer);
 
   //t->fTimeUnlocked = GetTimeSec();
 
#ifdef HAVE_MONGOOSE6
   ss_mutex_release(request_mutex);
#endif
 
   mg_send(nc, rr->return_buffer, rr->return_length);
 
   if (!strstr(rr->return_buffer, "Content-Length")) {
      // cannot do pipelined http if response generated by mhttpd
      // decode_get() has no Content-Length header.
      // must close the connection.
      nc->flags |= MG_F_SEND_AND_CLOSE;
   }
 
   t->fTimeSent = GetTimeSec();
 
   delete rr;
 
   return RESPONSE_SENT;
}

Here is the call graph for this function:

Here is the caller graph for this function:

handle_decode_post()

static int handle_decode_post ( struct mg_connection *  nc, const http_message *  msg, const char *  uri, const char *  query_string, RequestTrace *  t  )

static

Definition at line 14724 of file mhttpd.cxx.

{
 
   char boundary[256];
   boundary[0] = 0;
   const std::string ct = find_header_mg(msg, "Content-Type");
   if (ct.length() > 0) {
      const char* s = strstr(ct.c_str(), "boundary=");
      if (s)
         mstrlcpy(boundary, s+9, sizeof(boundary));
   }
 
#ifdef HAVE_MONGOOSE616
   if (multithread_mg)
      return queue_decode_post(nc, msg, boundary, uri, query_string, t);
#endif
 
   Cookies cookies;
 
   decode_cookies(&cookies, msg);
 
   const char* post_data = msg->body.p;
   int post_data_len = msg->body.len;
 
   // lock shared strctures
 
#ifdef HAVE_MONGOOSE6
   int status = ss_mutex_wait_for(request_mutex, 0);
   assert(status == SS_SUCCESS);
#endif
 
   // prepare return buffer
 
   Return* rr = new Return;
 
   rr->zero();
 
   //printf("post_data_len %d, data [%s], boundary [%s]\n", post_data_len, post_data, boundary);
 
   decode_post(rr, NULL, (char*)post_data, boundary, post_data_len, &cookies, uri, t);
 
   if (trace_mg)
      printf("handle_decode_post: return buffer length %d bytes, strlen %d\n", rr->return_length, (int)strlen(rr->return_buffer));
 
   if (rr->return_length == -1) {
#ifdef HAVE_MONGOOSE6
      ss_mutex_release(request_mutex);
#endif
      delete rr;
      return RESPONSE_501;
   }
 
   if (rr->return_length == 0)
      rr->return_length = strlen(rr->return_buffer);
 
#ifdef HAVE_MONGOOSE6
   ss_mutex_release(request_mutex);
#endif
 
   mg_send(nc, rr->return_buffer, rr->return_length);
 
   if (!strstr(rr->return_buffer, "Content-Length")) {
      // cannot do pipelined http if response generated by mhttpd
      // decode_get() has no Content-Length header.
      // must close the connection.
      nc->flags |= MG_F_SEND_AND_CLOSE;
   }
 
   delete rr;
 
   return RESPONSE_SENT;
}

Here is the call graph for this function:

Here is the caller graph for this function:

handle_event_mg()

static void handle_event_mg ( struct mg_connection *  nc, int  ev, void *  ev_data  )

static

Definition at line 14172 of file mhttpd.cxx.

{
   struct mbuf *io = &nc->recv_mbuf;
   switch (ev) {
   case MG_EV_POLL: // periodic call from loop_mg() via mg_mgr_poll()
      break;
   case MG_EV_ACCEPT:
      if (trace_mg)
         printf("handle_event_mg: nc %p, ev %d, ev_data %p -> accept\n", nc, ev, ev_data);
      break;
   case MG_EV_RECV:
      if (trace_mg)
         printf("handle_event_mg: nc %p, ev %d, ev_data %p -> recv %d, buffered %d bytes\n", nc, ev, ev_data, *(int*)ev_data, (int)io->len);
#if 0
      // This event handler implements simple TCP echo server
      mg_send(nc, io->buf, io->len);  // Echo received data back
      mbuf_remove(io, io->len);      // Discard data from recv buffer
#endif
      break;
   case MG_EV_SEND:
      if (trace_mg)
         printf("handle_event_mg: nc %p, ev %d, ev_data %p -> send %d bytes\n", nc, ev, ev_data, *(int*)ev_data);
      break;
   case MG_EV_CLOSE:
      if (trace_mg)
         printf("handle_event_mg: nc %p, ev %d, ev_data %p -> close\n", nc, ev, ev_data);
      break;
   default:
      if (trace_mg)
         printf("handle_event_mg: nc %p, ev %d, ev_data %p\n", nc, ev, ev_data);
      break;
   }
}

Here is the call graph for this function:

handle_http_get()

static int handle_http_get ( struct mg_connection *  nc, const http_message *  msg, const char *  uri, RequestTrace *  t  )

static

Definition at line 14797 of file mhttpd.cxx.

{
   std::string query_string = mgstr(&msg->query_string);
 
   if (trace_mg||verbose_mg)
      printf("handle_http_get: uri [%s], query [%s]\n", uri, query_string.c_str());
 
   if (query_string == "mjsonrpc_schema") {
      MJsonNode* s = mjsonrpc_get_schema();
      std::string reply = s->Stringify();
      delete s;
 
      int reply_length = reply.length();
 
      const std::string origin_header = find_header_mg(msg, "Origin");
 
      std::string headers;
      headers += "HTTP/1.1 200 OK\n";
      if (origin_header.length() > 0)
         headers += "Access-Control-Allow-Origin: " + std::string(origin_header) + "\n";
      else
         headers += "Access-Control-Allow-Origin: *\n";
      headers += "Access-Control-Allow-Credentials: true\n";
      headers += "Content-Length: " + toString(reply_length) + "\n";
      headers += "Content-Type: application/json\n";
      //headers += "Date: Sat, 08 Jul 2006 12:04:08 GMT\n";
 
      //printf("sending headers: %s\n", headers.c_str());
      //printf("sending reply: %s\n", reply.c_str());
 
      std::string send = headers + "\n" + reply;
 
      t->fTimeProcessed = GetTimeSec();
 
      mg_send(nc, send.c_str(), send.length());
 
      t->fTimeSent = GetTimeSec();
 
      return RESPONSE_SENT;
   }
 
   if (query_string == "mjsonrpc_schema_text") {
      MJsonNode* s = mjsonrpc_get_schema();
      std::string reply = mjsonrpc_schema_to_text(s);
      delete s;
 
      int reply_length = reply.length();
 
      const std::string origin_header = find_header_mg(msg, "Origin");
 
      std::string headers;
      headers += "HTTP/1.1 200 OK\n";
      if (origin_header.length() > 0)
         headers += "Access-Control-Allow-Origin: " + std::string(origin_header) + "\n";
      else
         headers += "Access-Control-Allow-Origin: *\n";
      headers += "Access-Control-Allow-Credentials: true\n";
      headers += "Content-Length: " + toString(reply_length) + "\n";
      headers += "Content-Type: text/plain\n";
      //headers += "Date: Sat, 08 Jul 2006 12:04:08 GMT\n";
 
      //printf("sending headers: %s\n", headers.c_str());
      //printf("sending reply: %s\n", reply.c_str());
 
      std::string send = headers + "\n" + reply;
 
      t->fTimeProcessed = GetTimeSec();
 
      mg_send(nc, send.c_str(), send.length());
 
      t->fTimeSent = GetTimeSec();
 
      return RESPONSE_SENT;
   }
 
#ifdef HAVE_MONGOOSE616
   if (multithread_mg)
      return queue_decode_get(nc, msg, uri, query_string.c_str(), t);
#endif
 
   return handle_decode_get(nc, msg, uri, query_string.c_str(), t);
}

Here is the call graph for this function:

Here is the caller graph for this function:

handle_http_message()

static void handle_http_message ( struct mg_connection *  nc, http_message *  msg  )

static

Definition at line 15071 of file mhttpd.cxx.

{
   std::string method = mgstr(&msg->method);
   std::string query_string = mgstr(&msg->query_string);
   std::string uri_encoded = mgstr(&msg->uri);
   std::string uri = UrlDecode(uri_encoded.c_str());
 
   if (trace_mg)
      printf("handle_http_message: method [%s] uri [%s] proto [%s]\n", method.c_str(), uri.c_str(), mgstr(&msg->proto).c_str());
 
   RequestTrace* t = new RequestTrace;
   t->fTimeReceived = GetTimeSec();
   t->fMethod = method;
   t->fUri = uri;
   t->fQuery = query_string;
 
   // process OPTIONS for Cross-origin (CORS) preflight request
   // see https://developer.mozilla.org/en-US/docs/Web/HTTP/Access_control_CORS
   if (method == "OPTIONS" && query_string == "mjsonrpc" && mg_get_http_header(msg, "Access-Control-Request-Method") != NULL) {
      handle_http_options_cors(nc, msg, t);
      t->fCompleted = true;
      gTraceBuf->AddTraceMTS(t);
      return;
   }
 
   if (gAuthMg && mongoose_passwords_enabled(nc)) {
      std::string username = check_digest_auth(msg, gAuthMg);
 
      // Cannot re-read the password file - it is not thread safe to do so
      // unless I lock gAuthMg for each call check_digest_auth() and if I do so,
      // I will serialize (single-thread) all the http requests and defeat
      // the whole point of multithreading the web server. K.O.
      //
      //if (username.length() < 1) {
      //   bool ok = read_passwords(&gAuthMg);
      //   if (ok)
      //      username = check_digest_auth(msg, &gAuthMg);
      //}
 
      if (trace_mg)
         printf("handle_http_message: auth user: \"%s\"\n", username.c_str());
 
      if (username.length() == 0) {
         if (trace_mg||verbose_mg)
            printf("handle_http_message: method [%s] uri [%s] query [%s] proto [%s], sending auth request for realm \"%s\"\n", method.c_str(), uri.c_str(), query_string.c_str(), mgstr(&msg->proto).c_str(), gAuthMg->realm.c_str());
 
         xmg_http_send_digest_auth_request(nc, gAuthMg->realm.c_str());
         t->fCompleted = true;
         gTraceBuf->AddTraceMTS(t);
         return;
      }
      t->fAuthOk = true;
   } else {
      t->fAuthOk = true;
   }
 
#ifdef HAVE_MONGOOSE616
   if (gProxyOdb && starts_with(uri, "/proxy/")) {
      std::string::size_type p1 = uri.find("/", 1);
      if (p1 == uri.length()-1) {
         std::string response = "404 Not Found (Proxy name is missing)";
         mg_send_head(nc, 404, response.length(), NULL);
         mg_send(nc, response.c_str(), response.length());
         delete t;
         return;
      }
      std::string::size_type p2 = uri.find("/", p1+1);
      if (p2 == std::string::npos) {
         std::string response = "404 Not Found (Proxy URL should end with a slash)";
         mg_send_head(nc, 404, response.length(), NULL);
         mg_send(nc, response.c_str(), response.length());
         delete t;
         return;
      }
      std::string p = uri.substr(p1+1, p2-p1-1);
      //printf("uri [%s], p1: %d, p2: %d, substr: [%s]\n", uri.c_str(), (int)p1, (int)p2, p.c_str());
      if (p.length() < 1) {
         std::string response = "404 Not Found (Double-slash or Proxy name is too short)";
         mg_send_head(nc, 404, response.length(), NULL);
         mg_send(nc, response.c_str(), response.length());
         delete t;
         return;
      }
      std::string destination;
      gProxyOdb->RS(p.c_str(), &destination);
      if (destination.length() < 1) {
         std::string response = "404 Not Found (Proxy not found in ODB)";
         mg_send_head(nc, 404, response.length(), NULL);
         mg_send(nc, response.c_str(), response.length());
         delete t;
         return;
      } else if (destination[0] == '#') {
         std::string response = "404 Not Found (Proxy commented-out in ODB)";
         mg_send_head(nc, 404, response.length(), NULL);
         mg_send(nc, response.c_str(), response.length());
         delete t;
         return;
      } else if (ends_with_char(destination, '/')) {
         std::string response = "404 Not Found (Proxy address should not end with a slash)";
         mg_send_head(nc, 404, response.length(), NULL);
         mg_send(nc, response.c_str(), response.length());
         delete t;
         return;
      } else if (!starts_with(destination, "http")) {
         std::string response = "404 Not Found (Proxy address does not start with http";
         mg_send_head(nc, 404, response.length(), NULL);
         mg_send(nc, response.c_str(), response.length());
         delete t;
         return;
      } else {
         std::string m;
         m += "/proxy";
         m += "/";
         m += p;
         mg_str mount = mg_mk_str(m.c_str());
         mg_str upstream = mg_mk_str(destination.c_str());
         if (verbose_mg||trace_mg) {
            printf("proxy: uri [%s] mount [%s] upstream [%s]\n", uri.c_str(), mgstr(&mount).c_str(), mgstr(&upstream).c_str());
         }
         mg_http_reverse_proxy(nc, msg, mount, upstream);
         delete t;
         return;
      }
   }
#endif
 
   int response = RESPONSE_501;
 
   if (method == "GET")
      response = handle_http_get(nc, msg, uri.c_str(), t);
   else if (method == "POST")
      response = handle_http_post(nc, msg, uri.c_str(), t);
 
   if (response == RESPONSE_501) {
      if (trace_mg||verbose_mg)
         printf("handle_http_message: sending 501 Not Implemented error\n");
 
      std::string response = "501 Not Implemented";
      mg_send_head(nc, 501, response.length(), NULL); // 501 Not Implemented
      mg_send(nc, response.c_str(), response.length());
   }
 
   if (response != RESPONSE_QUEUED) {
      t->fCompleted = true;
      gTraceBuf->AddTraceMTS(t);
   }
}

Here is the call graph for this function:

handle_http_options_cors()

static void handle_http_options_cors ( struct mg_connection *  nc, const http_message *  msg, RequestTrace *  t  )

static

Definition at line 15001 of file mhttpd.cxx.

{
   //
   // JSON-RPC CORS pre-flight request, see
   // https://en.wikipedia.org/wiki/Cross-origin_resource_sharing
   //
   // OPTIONS /resources/post-here/ HTTP/1.1
   // Host: bar.other
   // User-Agent: Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10.5; en-US; rv:1.9.1b3pre) Gecko/20081130 Minefield/3.1b3pre
   // Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
   // Accept-Language: en-us,en;q=0.5
   // Accept-Encoding: gzip,deflate
   // Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
   // Connection: keep-alive
   // Origin: http://foo.example
   // Access-Control-Request-Method: POST
   // Access-Control-Request-Headers: X-PINGOTHER
   //
   // HTTP/1.1 200 OK
   // Date: Mon, 01 Dec 2008 01:15:39 GMT
   // Server: Apache/2.0.61 (Unix)
   // Access-Control-Allow-Origin: http://foo.example
   // Access-Control-Allow-Methods: POST, GET, OPTIONS
   // Access-Control-Allow-Headers: X-PINGOTHER
   // Access-Control-Max-Age: 1728000
   // Vary: Accept-Encoding, Origin
   // Content-Encoding: gzip
   // Content-Length: 0
   // Keep-Alive: timeout=2, max=100
   // Connection: Keep-Alive
   // Content-Type: text/plain
   //
 
   const std::string origin_header = find_header_mg(msg, "Origin");
 
   if (trace_mg||verbose_mg)
      printf("handle_http_options_cors: origin [%s]\n", origin_header.c_str());
 
   std::string headers;
   headers += "HTTP/1.1 200 OK\n";
   //headers += "Date: Sat, 08 Jul 2006 12:04:08 GMT\n";
   if (origin_header.length() > 0)
      headers += "Access-Control-Allow-Origin: " + origin_header + "\n";
   else
      headers += "Access-Control-Allow-Origin: *\n";
   headers += "Access-Control-Allow-Headers: Content-Type\n";
   headers += "Access-Control-Allow-Credentials: true\n";
   headers += "Access-Control-Max-Age: 120\n";
   headers += "Content-Length: 0\n";
   headers += "Content-Type: text/plain\n";
   //printf("sending headers: %s\n", headers.c_str());
   //printf("sending reply: %s\n", reply.c_str());
 
   std::string send = headers + "\n";
 
   t->fTimeProcessed = GetTimeSec();
 
   mg_send(nc, send.c_str(), send.length());
 
   t->fTimeSent = GetTimeSec();
}

Here is the call graph for this function:

Here is the caller graph for this function:

handle_http_post()

static int handle_http_post ( struct mg_connection *  nc, const http_message *  msg, const char *  uri, RequestTrace *  t  )

static

Definition at line 14880 of file mhttpd.cxx.

{
   std::string query_string = mgstr(&msg->query_string);
   std::string post_data = mgstr(&msg->body);
 
   if (trace_mg||verbose_mg)
      printf("handle_http_post: uri [%s], query [%s], post data %d bytes\n", uri, query_string.c_str(), (int)post_data.length());
 
   if (query_string == "mjsonrpc") {
      const std::string origin_header = find_header_mg(msg, "Origin");
      const std::string ctype_header = find_header_mg(msg, "Content-Type");
 
      if (strstr(ctype_header.c_str(), "application/json") == NULL) {
         std::string headers;
         headers += "HTTP/1.1 415 Unsupported Media Type\n";
         //headers += "Date: Sat, 08 Jul 2006 12:04:08 GMT\n";
 
         //printf("sending headers: %s\n", headers.c_str());
         //printf("sending reply: %s\n", reply.c_str());
 
         std::string send = headers + "\n";
 
         t->fTimeProcessed = GetTimeSec();
 
         mg_send(nc, send.c_str(), send.length());
 
         t->fTimeSent = GetTimeSec();
 
         return RESPONSE_SENT;
      }
 
#ifdef HAVE_MONGOOSE616
      if (multithread_mg)
         return queue_mjsonrpc(nc, origin_header, post_data, t);
#endif
 
      //printf("post body: %s\n", post_data.c_str());
 
      t->fRPC = post_data;
 
#ifdef HAVE_MONGOOSE6
      int status = ss_mutex_wait_for(request_mutex, 0);
      assert(status == SS_SUCCESS);
#endif
 
      //t->fTimeLocked = GetTimeSec();
 
      MJsonNode* reply = mjsonrpc_decode_post_data(post_data.c_str());
 
      //t->fTimeUnlocked = GetTimeSec();
      
#ifdef HAVE_MONGOOSE6
      ss_mutex_release(request_mutex);
#endif
 
      if (reply->GetType() == MJSON_ARRAYBUFFER) {
         const char* ptr;
         size_t size;
         reply->GetArrayBuffer(&ptr, &size);
 
         std::string headers;
         headers += "HTTP/1.1 200 OK\n";
         if (origin_header.length() > 0)
            headers += "Access-Control-Allow-Origin: " + std::string(origin_header) + "\n";
         else
            headers += "Access-Control-Allow-Origin: *\n";
         headers += "Access-Control-Allow-Credentials: true\n";
         headers += "Content-Length: " + toString(size) + "\n";
         headers += "Content-Type: application/octet-stream\n";
         //headers += "Date: Sat, 08 Jul 2006 12:04:08 GMT\n";
 
         //printf("sending headers: %s\n", headers.c_str());
         //printf("sending reply: %s\n", reply_string.c_str());
 
         std::string send = headers + "\n";
 
         t->fTimeProcessed = GetTimeSec();
 
         mg_send(nc, send.c_str(), send.length());
         mg_send(nc, ptr, size);
 
         t->fTimeSent = GetTimeSec();
 
         delete reply;
 
         return RESPONSE_SENT;
      }
 
      std::string reply_string = reply->Stringify();
      int reply_length = reply_string.length();
 
      std::string headers;
      headers += "HTTP/1.1 200 OK\n";
      if (origin_header.length() > 0)
         headers += "Access-Control-Allow-Origin: " + std::string(origin_header) + "\n";
      else
         headers += "Access-Control-Allow-Origin: *\n";
      headers += "Access-Control-Allow-Credentials: true\n";
      headers += "Content-Length: " + toString(reply_length) + "\n";
      headers += "Content-Type: application/json\n";
      //headers += "Date: Sat, 08 Jul 2006 12:04:08 GMT\n";
 
      //printf("sending headers: %s\n", headers.c_str());
      //printf("sending reply: %s\n", reply_string.c_str());
 
      std::string send = headers + "\n" + reply_string;
 
      t->fTimeProcessed = GetTimeSec();
 
      mg_send(nc, send.c_str(), send.length());
 
      t->fTimeSent = GetTimeSec();
 
      delete reply;
 
      return RESPONSE_SENT;
   }
 
   return handle_decode_post(nc, msg, uri, query_string.c_str(), t);
}

Here is the call graph for this function:

Here is the caller graph for this function:

haxis()

void haxis	(	gdImagePtr	im,
		gdFont *	font,
		int	col,
		int	gcol,
		int	x1,
		int	y1,
		int	width,
		int	minor,
		int	major,
		int	text,
		int	label,
		int	grid,
		double	xmin,
		double	xmax
	)

Definition at line 7632 of file mhttpd.cxx.

{
   double dx, int_dx, frac_dx, x_act, label_dx, major_dx, x_screen, maxwidth;
   int tick_base, major_base, label_base, n_sig1, n_sig2, xs;
   char str[80];
   double base[] = { 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000 };
 
   if (xmax <= xmin || width <= 0)
      return;
 
   /* use 5 as min tick distance */
   dx = (xmax - xmin) / (double) (width / 5);
 
   frac_dx = modf(log(dx) / LN10, &int_dx);
   if (frac_dx < 0) {
      frac_dx += 1;
      int_dx -= 1;
   }
 
   tick_base = frac_dx < LOG2 ? 1 : frac_dx < LOG5 ? 2 : 3;
   major_base = label_base = tick_base + 1;
 
   /* rounding up of dx, label_dx */
   dx = pow(10, int_dx) * base[tick_base];
   major_dx = pow(10, int_dx) * base[major_base];
   label_dx = major_dx;
 
   /* number of significant digits */
   if (xmin == 0)
      n_sig1 = 0;
   else
      n_sig1 = (int) floor(log(fabs(xmin)) / LN10) - (int) floor(log(fabs(label_dx)) / LN10) + 1;
 
   if (xmax == 0)
      n_sig2 = 0;
   else
      n_sig2 =
         (int) floor(log(fabs(xmax)) / LN10) - (int) floor(log(fabs(label_dx)) / LN10) + 1;
 
   n_sig1 = MAX(n_sig1, n_sig2);
   n_sig1 = MAX(n_sig1, 4);
 
   /* determination of maximal width of labels */
   sprintf(str, "%1.*lG", n_sig1, floor(xmin / dx) * dx);
   maxwidth = font->h / 2 * strlen(str);
   sprintf(str, "%1.*lG", n_sig1, floor(xmax / dx) * dx);
   maxwidth = MAX(maxwidth, font->h / 2 * strlen(str));
   sprintf(str, "%1.*lG", n_sig1, floor(xmax / dx) * dx + label_dx);
   maxwidth = MAX(maxwidth, font->h / 2 * strlen(str));
 
   /* increasing label_dx, if labels would overlap */
   while (maxwidth > 0.7 * label_dx / (xmax - xmin) * width) {
      label_base++;
      label_dx = pow(10, int_dx) * base[label_base];
      if (label_base % 3 == 2 && major_base % 3 == 1) {
         major_base++;
         major_dx = pow(10, int_dx) * base[major_base];
      }
   }
 
   x_act = floor(xmin / dx) * dx;
 
   gdImageLine(im, x1, y1, x1 + width, y1, col);
 
   do {
      x_screen = (x_act - xmin) / (xmax - xmin) * width + x1;
      xs = (int) (x_screen + 0.5);
 
      if (x_screen > x1 + width + 0.001)
         break;
 
      if (x_screen >= x1) {
         if (fabs(floor(x_act / major_dx + 0.5) - x_act / major_dx) <
             dx / major_dx / 10.0) {
 
            if (fabs(floor(x_act / label_dx + 0.5) - x_act / label_dx) <
                dx / label_dx / 10.0) {
               /* label tick mark */
               gdImageLine(im, xs, y1, xs, y1 + text, col);
 
               /* grid line */
               if (grid != 0 && xs > x1 && xs < x1 + width)
                  gdImageLine(im, xs, y1, xs, y1 + grid, col);
 
               /* label */
               if (label != 0) {
                  sprintf(str, "%1.*lG", n_sig1, x_act);
                  gdImageString(im, font, (int) xs - font->w * strlen(str) / 2,
                                y1 + label, str, col);
               }
            } else {
               /* major tick mark */
               gdImageLine(im, xs, y1, xs, y1 + major, col);
 
               /* grid line */
               if (grid != 0 && xs > x1 && xs < x1 + width)
                  gdImageLine(im, xs, y1 - 1, xs, y1 + grid, gcol);
            }
 
         } else
            /* minor tick mark */
            gdImageLine(im, xs, y1, xs, y1 + minor, col);
 
      }
 
      x_act += dx;
 
      /* supress 1.23E-17 ... */
      if (fabs(x_act) < dx / 100)
         x_act = 0;
 
   } while (1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

history_watch_callback()

static void history_watch_callback ( HNDLE  hDB, HNDLE  hKey, int  index, void *  info  )

static

Definition at line 8145 of file mhttpd.cxx.

{
   //printf("history_watch_callback %d %d %d\n", hDB, hKey, index);
   gDoReloadHistory = true;
   cm_msg(MINFO, "history_watch_callback", "History configuration may have changed, will reconnect");
}

Here is the call graph for this function:

Here is the caller graph for this function:

init_elog_odb()

void init_elog_odb

(

)

Definition at line 1978 of file mhttpd.cxx.

{
   HNDLE hDB;
   int size;
   HNDLE hkey;
   cm_get_experiment_database(&hDB, NULL);
 
   BOOL external_elog = FALSE;
   std::string external_elog_url;
 
   size = sizeof(external_elog);
   db_get_value(hDB, 0, "/Elog/External Elog", &external_elog, &size, TID_BOOL, TRUE);
   db_get_value_string(hDB, 0, "/Elog/URL", 0, &external_elog_url, TRUE);
 
   BOOL allow_delete = FALSE;
   BOOL allow_edit = FALSE;
   size = sizeof(BOOL);
   db_get_value(hDB, 0, "/Elog/Allow delete", &allow_delete, &size, TID_BOOL, TRUE);
   db_get_value(hDB, 0, "/Elog/Allow edit", &allow_edit, &size, TID_BOOL, TRUE);
   //db_get_value(hDB, 0, "/Elog/Display run number", &display_run_number, &size, TID_BOOL, TRUE);
 
   if (db_find_key(hDB, 0, "/Elog/Buttons", &hkey) != DB_SUCCESS) {
      const char def_button[][NAME_LENGTH] = { "8h", "24h", "7d" };
      db_set_value(hDB, 0, "/Elog/Buttons", def_button, NAME_LENGTH*3, 3, TID_STRING);
   }
 
 
   /* get type list from ODB */
   size = 20 * NAME_LENGTH;
   if (db_find_key(hDB, 0, "/Elog/Types", &hkey) != DB_SUCCESS) {
      db_set_value(hDB, 0, "/Elog/Types", default_type_list, NAME_LENGTH * 20, 20, TID_STRING);
   }
 
   /* get system list from ODB */
   size = 20 * NAME_LENGTH;
   if (db_find_key(hDB, 0, "/Elog/Systems", &hkey) != DB_SUCCESS)
      db_set_value(hDB, 0, "/Elog/Systems", default_system_list, NAME_LENGTH * 20, 20, TID_STRING);
}

Here is the call graph for this function:

Here is the caller graph for this function:

init_menu_buttons()

void init_menu_buttons

(

MVOdb *

odb

)

Definition at line 1890 of file mhttpd.cxx.

{
   HNDLE hDB;
   BOOL true_value = TRUE;
   BOOL false_value = FALSE;
   int size = sizeof(true_value);
   cm_get_experiment_database(&hDB, NULL);
   db_get_value(hDB, 0, "/Experiment/Menu/Status",     &true_value,  &size, TID_BOOL, TRUE);
   db_get_value(hDB, 0, "/Experiment/Menu/Start",      &false_value, &size, TID_BOOL, TRUE);
   db_get_value(hDB, 0, "/Experiment/Menu/Transition", &true_value,  &size, TID_BOOL, TRUE);
   db_get_value(hDB, 0, "/Experiment/Menu/ODB",        &true_value,  &size, TID_BOOL, TRUE);
   db_get_value(hDB, 0, "/Experiment/Menu/OldODB",     &true_value,  &size, TID_BOOL, TRUE);
   db_get_value(hDB, 0, "/Experiment/Menu/Messages",   &true_value,  &size, TID_BOOL, TRUE);
   db_get_value(hDB, 0, "/Experiment/Menu/Chat",       &true_value,  &size, TID_BOOL, TRUE);
   db_get_value(hDB, 0, "/Experiment/Menu/Elog",       &true_value,  &size, TID_BOOL, TRUE);
   db_get_value(hDB, 0, "/Experiment/Menu/Alarms",     &true_value,  &size, TID_BOOL, TRUE);
   db_get_value(hDB, 0, "/Experiment/Menu/Programs",   &true_value,  &size, TID_BOOL, TRUE);
   db_get_value(hDB, 0, "/Experiment/Menu/Buffers",    &true_value,  &size, TID_BOOL, TRUE);
   db_get_value(hDB, 0, "/Experiment/Menu/History",    &true_value,  &size, TID_BOOL, TRUE);
   db_get_value(hDB, 0, "/Experiment/Menu/OldHistory", &true_value,  &size, TID_BOOL, TRUE);
   db_get_value(hDB, 0, "/Experiment/Menu/MSCB",       &true_value,  &size, TID_BOOL, TRUE);
   db_get_value(hDB, 0, "/Experiment/Menu/Sequencer",  &true_value,  &size, TID_BOOL, TRUE);
   db_get_value(hDB, 0, "/Experiment/Menu/Event Dump", &true_value,  &size, TID_BOOL, TRUE);
   db_get_value(hDB, 0, "/Experiment/Menu/Config",     &true_value,  &size, TID_BOOL, TRUE);
   db_get_value(hDB, 0, "/Experiment/Menu/Example",    &false_value, &size, TID_BOOL, TRUE);
   db_get_value(hDB, 0, "/Experiment/Menu/Help",       &true_value,  &size, TID_BOOL, TRUE);
 
   //std::string buf;
   //status = db_get_value_string(hDB, 0, "/Experiment/Menu buttons", 0, &buf, FALSE);
   //if (status == DB_SUCCESS) {
   //   cm_msg(MERROR, "init_menu_buttons", "ODB \"/Experiment/Menu buttons\" is obsolete, please delete it.");
   //}
 
   check_obsolete_odb(hDB, "/Experiment/Menu buttons");
   check_obsolete_odb(hDB, "/Experiment/Menu/OldSequencer");
   check_obsolete_odb(hDB, "/Experiment/Menu/NewSequencer");
}

Here is the call graph for this function:

Here is the caller graph for this function:

init_mhttpd_odb()

void init_mhttpd_odb

(

MVOdb *

odb

)

Definition at line 1930 of file mhttpd.cxx.

{
   HNDLE hDB;
   HNDLE hKey;
   int status;
   std::string s;
   cm_get_experiment_database(&hDB, NULL);
 
   status = db_find_key(hDB, 0, "/Experiment/Base URL", &hKey);
   if (status == DB_SUCCESS) {
      cm_msg(MERROR, "init_mhttpd_odb", "ODB \"/Experiment/Base URL\" is obsolete, please delete it.");
   }
 
   status = db_find_key(hDB, 0, "/Experiment/CSS File", &hKey);
   if (status == DB_SUCCESS) {
      cm_msg(MERROR, "init_mhttpd_odb", "ODB \"/Experiment/CSS File\" is obsolete, please delete it.");
   }
 
   status = db_find_key(hDB, 0, "/Experiment/JS File", &hKey);
   if (status == DB_SUCCESS) {
      cm_msg(MERROR, "init_mhttpd_odb", "ODB \"/Experiment/JS File\" is obsolete, please delete it.");
   }
 
   status = db_find_key(hDB, 0, "/Experiment/Start-Stop Buttons", &hKey);
   if (status == DB_SUCCESS) {
      cm_msg(MERROR, "init_mhttpd_odb", "ODB \"/Experiment/Start-Stop Buttons\" is obsolete, please delete it.");
   }
 
   bool xdefault = true;
   odb->RB("Experiment/Pause-Resume Buttons", &xdefault, true);
 
#ifdef HAVE_MONGOOSE616
   check_obsolete_odb(hDB, "/Experiment/midas http port");
   check_obsolete_odb(hDB, "/Experiment/midas https port");
   check_obsolete_odb(hDB, "/Experiment/http redirect to https");
   check_obsolete_odb(hDB, "/Experiment/Security/mhttpd hosts");
#endif
 
   status = db_find_key(hDB, 0, "/Logger/Message file", &hKey);
   if (status == DB_SUCCESS) {
      cm_msg(MERROR, "init_mhttpd_odb", "ODB \"/Logger/Message file\" is obsolete, please delete it and use \"/Logger/Message dir\" and \"/Logger/message file date format\" instead.");
   }
 
   check_obsolete_odb(hDB, "/Logger/Watchdog timeout");
}

Here is the call graph for this function:

Here is the caller graph for this function:

interprete()

void interprete	(	Param *	p,
		Return *	r,
		Attachment *	a,
		const Cookies *	c,
		const char *	dec_path,
		RequestTrace *	t
	)

Definition at line 12254 of file mhttpd.cxx.

{
   int status;
   HNDLE hkey, hDB;
 
   //printf("dec_path [%s]\n", dec_path);
 
   if (strstr(dec_path, "favicon.ico") != 0 ||
       strstr(dec_path, "favicon.png")) {
      send_icon(r, dec_path);
      return;
   }
 
   const char* password = p->getparam("pwd");
   const char* wpassword = p->getparam("wpwd");
   const char* command = p->getparam("cmd");
 
   //printf("interprete: dec_path [%s], command [%s]\n", dec_path, command);
 
   cm_get_experiment_database(&hDB, NULL);
   MVOdb* odb = gOdb;
 
   if (history_mode) {
      if (equal_ustring(command, "history")) {
         if (equal_ustring(command, "config")) {
            return;
         }
 
         Lock(t);
         show_hist_page(odb, p, r, dec_path, NULL, NULL, c->refresh);
         Unlock(t);
         return;
      }
      return;
   }
 
   /* check for password */
   db_find_key(hDB, 0, "/Experiment/Security/Password", &hkey);
   if (!password[0] && hkey) {
      char str[256];
      int size = sizeof(str);
      db_get_data(hDB, hkey, str, &size, TID_STRING);
 
      /* check for excemption */
      db_find_key(hDB, 0, "/Experiment/Security/Allowed programs/mhttpd", &hkey);
      if (hkey == 0 && strcmp(c->cookie_pwd.c_str(), str) != 0) {
         Lock(t);
         show_password_page(r, dec_path, "");
         Unlock(t);
         return;
      }
   }
 
   /*---- redirect with cookie if password given --------------------*/
 
   if (password[0]) {
      r->rsprintf("HTTP/1.1 302 Found\r\n");
      r->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
 
      time_t now;
      time(&now);
 
      now += 3600 * 24;
 
      struct tm gmt_tms;
      gmtime_r(&now, &gmt_tms);
 
      char str[256];
      strftime(str, sizeof(str), "%A, %d-%b-%Y %H:00:00 GMT", &gmt_tms);
 
      r->rsprintf("Set-Cookie: midas_pwd=%s; path=/; expires=%s\r\n",
               ss_crypt(password, "mi"), str);
 
      r->rsprintf("Location: ./\n\n<html>redir</html>\r\n");
      return;
   }
 
   if (wpassword[0]) {
      /* check if password correct */
      if (!check_web_password(r, hDB, dec_path, ss_crypt(wpassword, "mi"), p->getparam("redir")))
         return;
 
      r->rsprintf("HTTP/1.1 302 Found\r\n");
      r->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
 
      time_t now;
      time(&now);
 
      now += 3600 * 24;
 
      struct tm gmt_tms;
      gmtime_r(&now, &gmt_tms);
 
      char str[256];
      strftime(str, sizeof(str), "%A, %d-%b-%Y %H:%M:%S GMT", &gmt_tms);
 
      r->rsprintf("Set-Cookie: midas_wpwd=%s; path=/; expires=%s\r\n", ss_crypt(wpassword, "mi"), str);
 
      sprintf(str, "./%s", p->getparam("redir"));
      r->rsprintf("Location: %s\n\n<html>redir</html>\r\n", str);
      return;
   }
 
   /*---- send sound file -------------------------------------------*/
 
   if (strlen(dec_path) > 3 &&
       dec_path[strlen(dec_path)-3] == 'm' &&
       dec_path[strlen(dec_path)-2] == 'p' &&
       dec_path[strlen(dec_path)-1] == '3') {
      if (strrchr(dec_path, '/'))
         send_resource(r, strrchr(dec_path, '/')+1);
      else
         send_resource(r, dec_path);
      return;
   }
 
   /*---- send midas.js and midas.css -------------------------------*/
 
   if (strstr(dec_path, "midas.js")) {
      send_resource(r, "midas.js");
      return;
   }
 
   if (strstr(dec_path, "midas.css")) {
      send_resource(r, "midas.css");
      return;
   }
 
   /*---- send mhttpd.js --------------------------------------------*/
 
   if (strstr(dec_path, "mhttpd.js")) {
      send_resource(r, "mhttpd.js");
      return;
   }
 
   /*---- send obsolete.js ------------------------------------------*/
 
   if (strstr(dec_path, "obsolete.js")) {
      send_resource(r, "obsolete.js");
      return;
   }
 
   /*---- send the obsolete mhttpd.css ------------------------------*/
 
   if (strstr(dec_path, "mhttpd.css")) {
      send_resource(r, "mhttpd.css");
      return;
   }
 
   /*---- send controls.js ------------------------------------------*/
 
   if (strstr(dec_path, "controls.js")) {
      send_resource(r, "controls.js");
      return;
   }
 
   /*---- send example web page -------------------------------------*/
 
   if (equal_ustring(command, "example")) {
      send_resource(r, "example.html");
      return;
   }
 
   /*---- send example custom page -------------------------------------*/
 
   if (equal_ustring(command, "custom_example")) {
      send_resource(r, "custom_example.html");
      return;
   }
 
   if (equal_ustring(command, "plot_example")) {
      send_resource(r, "plot_example.html");
      return;
   }
 
   /*---- script command --------------------------------------------*/
 
   if (p->getparam("script") && *p->getparam("script")) {
 
      std::string str = msprintf("%s?script=%s", dec_path, p->getparam("script"));
      if (!check_web_password(r, hDB, dec_path, c->cookie_wpwd.c_str(), str.c_str()))
         return;
 
      std::string path;
      path += "/Script/";
      path += p->getparam("script");
 
      Lock(t);
 
      cm_exec_script(path.c_str());
 
      Unlock(t);
 
      if (p->isparam("redir"))
         redirect2(r, p->getparam("redir"));
      else
         redirect2(r, "");
 
      return;
   }
 
   /*---- customscript command --------------------------------------*/
 
   if (p->getparam("customscript") && *p->getparam("customscript")) {
 
      std::string str = msprintf("%s?customscript=%s", dec_path, p->getparam("customscript"));
      if (!check_web_password(r, hDB, dec_path, c->cookie_wpwd.c_str(), str.c_str()))
         return;
 
      std::string path;
      path += "/CustomScript/";
      path += p->getparam("customscript");
 
      Lock(t);
 
      cm_exec_script(path.c_str());
 
      Unlock(t);
 
      if (p->isparam("redir"))
         redirect2(r, p->getparam("redir"));
      else
         redirect2(r, str.c_str());
 
      return;
   }
 
   /*---- send the new html pages -----------------------------------*/
 
   if (equal_ustring(command, "start")) {
      send_resource(r, "start.html");
      return;
   }
 
   if ((equal_ustring(command, "") || equal_ustring(command, "status")) && strlen(dec_path) == 0) {
      if (midas::odb::exists("/Custom/Status")) {
         midas::odb custom("/Custom");
 
         std::string filename = custom["Status"];
         filename = add_custom_path(filename);
 
         // if custom file exists, send it (like normal web server)
         if (ss_file_exist(filename.c_str())) {
            send_file(r, filename);
            return;
         }
      } else
         send_resource(r, "status.html");
      return;
   }
 
   if (equal_ustring(command, "eqtable")) {
      send_resource(r, "eqtable.html");
      return;
   }
 
   if (equal_ustring(command, "newODB")) {
      send_resource(r, "odb.html");
      return;
   }
 
   if (equal_ustring(command, "programs")) {
      send_resource(r, "programs.html");
      return;
   }
 
   if (equal_ustring(command, "alarms")) {
      send_resource(r, "alarms.html");
      return;
   }
 
   if (equal_ustring(command, "transition")) {
      send_resource(r, "transition.html");
      return;
   }
 
   if (equal_ustring(command, "messages")) {
      send_resource(r, "messages.html");
      return;
   }
 
   if (equal_ustring(command, "config") &&
       !(dec_path[0] == 'H' && dec_path[1] == 'S' && dec_path[2] == '/')) {
      send_resource(r, "config.html");
      return;
   }
 
   if (equal_ustring(command, "chat")) {
      send_resource(r, "chat.html");
      return;
   }
 
   if (equal_ustring(command, "buffers")) {
      send_resource(r, "buffers.html");
      return;
   }
 
   if (equal_ustring(command, "Show elog")) {
      send_resource(r, "elog_show.html");
      return;
   }
 
   if (equal_ustring(command, "Query elog")) {
      send_resource(r, "elog_query_form.html");
      return;
   }
 
   if (equal_ustring(command, "New elog")) {
      send_resource(r, "elog_edit.html");
      return;
   }
 
   if (equal_ustring(command, "Edit elog")) {
      send_resource(r, "elog_edit.html");
      return;
   }
 
   if (equal_ustring(command, "Reply Elog")) {
      send_resource(r, "elog_edit.html");
      return;
   }
 
   if (equal_ustring(command, "Last elog")) {
      send_resource(r, "elog_show.html");
      return;
   }
 
   if (equal_ustring(command, "Submit Query")) {
      send_resource(r, "elog_query.html");
      return;
   }
 
   if (equal_ustring(dec_path, "spinning-wheel.gif")) {
      send_resource(r, "spinning-wheel.gif");
      return;
   }
 
   /*---- java script commands --------------------------------------*/
 
   if (equal_ustring(command, "jset") ||
       equal_ustring(command, "jget") ||
       equal_ustring(command, "jcopy") ||
       equal_ustring(command, "jpaste") ||
       equal_ustring(command, "jkey") ||
       equal_ustring(command, "jcreate") ||
       equal_ustring(command, "jresize") ||
       equal_ustring(command, "jlink") ||
       equal_ustring(command, "jrename") ||
       equal_ustring(command, "jreorder") ||
       equal_ustring(command, "jdelete") ||
       equal_ustring(command, "jmsg") ||
       equal_ustring(command, "jalm") ||
       equal_ustring(command, "jgenmsg") ||
       equal_ustring(command, "jrpc_rev0") ||
       equal_ustring(command, "jrpc_rev1") ||
       equal_ustring(command, "jrpc")) {
      Lock(t);
      javascript_commands(p, r, c->cookie_cpwd.c_str());
      Unlock(t);
      return;
   }
 
   /*---- history editord -------------------------------------------*/
 
   if (equal_ustring(command, "hs_edit")) {
      send_resource(r, "hs_edit.html");
      return;
   }
 
   /*---- history command -------------------------------------------*/
 
   if (equal_ustring(command, "oldhistory")) {
      Lock(t);
      show_hist_page(odb, p, r, dec_path, NULL, NULL, c->refresh);
      Unlock(t);
      return;
   }
 
   if (equal_ustring(command, "history")) {
      send_resource(r, "history.html");
      return;
   }
 
   /*---- MSCB command ----------------------------------------------*/
 
   if (equal_ustring(command, "MSCB")) {
      if (equal_ustring(command, "set")) {
         std::string str;
         str += dec_path;
         str += "?";
         str += add_param_to_url("cmd", command);
         if (!check_web_password(r, hDB, dec_path, c->cookie_wpwd.c_str(), str.c_str()))
            return;
      }
 
      Lock(t);
 
#ifdef HAVE_MSCB
      show_mscb_page(p, r, c->refresh);
#else
      show_error(r, "MSCB support not compiled into this version of mhttpd");
#endif
 
      Unlock(t);
      return;
   }
 
   /*---- help command ----------------------------------------------*/
 
   if (equal_ustring(command, "help")) {
      Lock(t);
      show_help_page(r, dec_path);
      Unlock(t);
      return;
   }
 
   /*---- trigger equipment readout ---------------------------*/
 
   if (strncmp(command, "Trigger", 7) == 0) {
      std::string cmd;
      cmd += "?cmd=";
      cmd += command;
      if (!check_web_password(r, hDB, dec_path, c->cookie_wpwd.c_str(), cmd.c_str())) {
         return;
      }
 
      Lock(t);
 
      /* extract equipment name */
      char eq_name[NAME_LENGTH];
 
      mstrlcpy(eq_name, command + 8, sizeof(eq_name));
      if (strchr(eq_name, ' '))
         *strchr(eq_name, ' ') = 0;
 
      /* get frontend name */
      std::string path;
      path += "/Equipment/";
      path += eq_name;
      path += "/Common/Frontend name";
      char fe_name[NAME_LENGTH];
      int size = NAME_LENGTH;
      db_get_value(hDB, 0, path.c_str(), fe_name, &size, TID_STRING, TRUE);
 
      /* and ID */
      path = "";
      path += "/Equipment/";
      path += eq_name;
      path += "/Common/Event ID";
      WORD event_id = 0;
      size = sizeof(event_id);
      db_get_value(hDB, 0, path.c_str(), &event_id, &size, TID_WORD, TRUE);
 
      if (cm_exist(fe_name, FALSE) != CM_SUCCESS) {
         std::string str;
         str += "Frontend \"";
         str += fe_name;
         str += "\" not running!";
         show_error(r, str.c_str());
      } else {
         HNDLE hconn;
         status = cm_connect_client(fe_name, &hconn);
         if (status != RPC_SUCCESS) {
            std::string str;
            str += "Cannot connect to frontend \"";
            str += fe_name;
            str +="\" !";
            show_error(r, str.c_str());
         } else {
            status = rpc_client_call(hconn, RPC_MANUAL_TRIG, event_id);
            if (status != CM_SUCCESS)
               show_error(r, "Error triggering event");
            else
               redirect(r, "");
 
            //cm_disconnect_client(hconn, FALSE);
         }
      }
 
      Unlock(t);
 
      return;
   }
 
   /*---- switch to next subrun -------------------------------------*/
 
   if (strncmp(command, "Next Subrun", 11) == 0) {
      int i = TRUE;
      db_set_value(hDB, 0, "/Logger/Next subrun", &i, sizeof(i), 1, TID_BOOL);
      redirect(r, "");
      return;
   }
 
   /*---- cancel command --------------------------------------------*/
 
   if (equal_ustring(command, "cancel")) {
      if (p->isparam("redir"))
         redirect(r, p->getparam("redir"));
      else
         redirect(r, "");
      return;
   }
 
   /*---- set command -----------------------------------------------*/
 
   if (equal_ustring(command, "set")) {
      char str[256];
      mstrlcpy(str, "?cmd=set", sizeof(str));
      if (!check_web_password(r, hDB, dec_path, c->cookie_wpwd.c_str(), str))
         return;
 
      const char* group = p->getparam("group");
      int index = atoi(p->getparam("index"));
      const char* value = p->getparam("value");
 
      Lock(t);
      show_set_page(p, r, group, index, value);
      Unlock(t);
      return;
   }
 
   /*---- find command ----------------------------------------------*/
 
   if (equal_ustring(command, "find")) {
      const char* value = p->getparam("value");
      Lock(t);
      show_find_page(r, value);
      Unlock(t);
      return;
   }
 
   /*---- CAMAC CNAF command ----------------------------------------*/
 
   if (equal_ustring(command, "CNAF") || strncmp(dec_path, "CNAF", 4) == 0) {
      if (!check_web_password(r, hDB, dec_path, c->cookie_wpwd.c_str(), "?cmd=CNAF"))
         return;
 
      Lock(t);
      show_cnaf_page(p, r);
      Unlock(t);
      return;
   }
 
   /*---- ELog command ----------------------------------------------*/
 
   if (equal_ustring(command, "elog")) {
      /* redirect to external ELOG if URL present */
      cm_get_experiment_database(&hDB, NULL);
      BOOL external_elog = FALSE;
      std::string external_elog_url;
      int size = sizeof(external_elog);
      status = db_get_value(hDB, 0, "/Elog/External Elog", &external_elog, &size, TID_BOOL, TRUE);
      status = db_get_value_string(hDB, 0, "/Elog/URL", 0, &external_elog_url, TRUE);
      if (external_elog && (external_elog_url.length() > 0)) {
         redirect(r, external_elog_url.c_str());
         return;
      }
      send_resource(r, "elog_show.html");
      return;
   }
 
   // special processing for "Elog last 7d", etc
 
   char cmdx[32];
   mstrlcpy(cmdx, command, sizeof(cmdx));
   cmdx[9] = 0;
 
   if (equal_ustring(cmdx, "Elog last")) {
      // "Elog last 7d", etc
      send_resource(r, "elog_query.html");
      return;
   }
 
   if (equal_ustring(command, "Create ELog from this page")) {
      std::string redir;
      redir += "?cmd=New+elog";
      redir += "&odb_path=";
      redir += p->getparam("odb_path");
      redirect(r, redir.c_str());
      return;
   }
 
   if (equal_ustring(command, "Submit elog")) {
      Lock(t);
      submit_elog(odb, p, r, a);
      Unlock(t);
      return;
   }
 
   if (equal_ustring(command, "elog_att")) {
      Lock(t);
      show_elog_attachment(p, r, dec_path);
      Unlock(t);
      return;
   }
 
   /*---- accept command --------------------------------------------*/
 
   if (equal_ustring(command, "accept")) {
      int refresh = atoi(p->getparam("refr"));
 
      /* redirect with cookie */
      r->rsprintf("HTTP/1.1 302 Found\r\n");
      r->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
      r->rsprintf("Content-Type: text/html; charset=%s\r\n", HTTP_ENCODING);
 
      time_t now;
      time(&now);
 
      now += 3600 * 24 * 365;
 
      struct tm gmt_tms;
      gmtime_r(&now, &gmt_tms);
 
      char str[256];
      strftime(str, sizeof(str), "%A, %d-%b-%Y %H:00:00 GMT", &gmt_tms);
 
      r->rsprintf("Set-Cookie: midas_refr=%d; path=/; expires=%s\r\n", refresh, str);
      r->rsprintf("Location: ./\r\n\r\n<html>redir</html>\r\n");
 
      return;
   }
 
   /*---- slow control display --------------------------------------*/
 
   if (equal_ustring(command, "eqtable")) {
      Lock(t);
      show_eqtable_page(p, r, c->refresh);
      Unlock(t);
      return;
   }
 
   /*---- sequencer page --------------------------------------------*/
 
   if (equal_ustring(command, "Sequencer")) {
      send_resource(r, "sequencer.html");
      return;
   }
 
   // obsolete
   if (equal_ustring(command, "seq")) {
      send_resource(r, "sequencer.html");
      return;
   }
 
   if (equal_ustring(command, "start_script")) {
      send_resource(r, "start_script.html");
      return;
   }
 
   if (equal_ustring(command, "load_script")) {
      send_resource(r, "load_script.html");
      return;
   }
 
   if (equal_ustring(command, "edit_script")) {
      send_resource(r, "edit_script.html");
      return;
   }
 
   /*---- show ODB --------------------------------------------------*/
 
   if (equal_ustring(command, "oldOdb")) {
      int write_access = TRUE;
      db_find_key(hDB, 0, "/Experiment/Security/Web Password", &hkey);
      if (hkey) {
         char str[256];
         int size = sizeof(str);
         db_get_data(hDB, hkey, str, &size, TID_STRING);
         if (strcmp(c->cookie_wpwd.c_str(), str) == 0)
            write_access = TRUE;
         else
            write_access = FALSE;
      }
 
      std::string odb_path;
      if (p->getparam("odb_path") && *p->getparam("odb_path"))
         odb_path = p->getparam("odb_path");
 
      Lock(t);
      show_odb_page(p, r, odb_path.c_str(), write_access);
      Unlock(t);
      return;
   }
 
   /*---- New ODB browser --------------------------------------------*/
 
   if (equal_ustring(command, "odb")) {
      send_resource(r, "odb.html");
      return;
   }
 
   /*---- ODB show open records --------------------------------------*/
 
   if (equal_ustring(command, "odb_sor")) {
      send_resource(r, "odb_sor.html");
      return;
   }
 
   /*---- ODB show clients -------------------------------------------*/
 
   if (equal_ustring(command, "odb_scl")) {
      send_resource(r, "odb_scl.html");
      return;
   }
 
   /*---- old ODB path ----------------------------------------------*/
 
   if ((command[0]==0) && dec_path[0]) {
      if (equal_ustring(dec_path, "root")) {
         std::string new_url = "./?cmd=odb";
         //printf("redirect old odb path url [%s] to [%s]\n", dec_path, new_url.c_str());
         redirect_307(r, new_url.c_str());
         return;
      }
   }
 
   if ((command[0]==0) && dec_path[0]) {
      HNDLE hkey;
      status = db_find_key(hDB, 0, dec_path, &hkey);
      //printf("try odb path [%s], status %d\n", dec_path, status);
      if (status == DB_SUCCESS) {
         int level = 0;
         for (const char* s = dec_path; *s; s++) {
            if (*s == '/')
               level++;
         }
         std::string new_url;
         if (level == 0) {
            // Top-level directory like /Logger, (which appears in dec_path as "Logger")
            new_url += "./";
         } else {
            for (int i=0; i<level; i++) {
               if (i>0)
                  new_url += "/";
               new_url += "..";
            }
         }
         new_url += "?cmd=odb";
         new_url += "&odb_path=";
         new_url += urlEncode(dec_path);
         //printf("redirect old odb path url [%s] to [%s]\n", dec_path, new_url.c_str());
         redirect_307(r, new_url.c_str());
         return;
      }
   }
 
   /*---- event dump ------------------------------------------------*/
 
   if (equal_ustring(command, "event dump")) {
      send_resource(r, "event_dump.html");
      return;
   }
 
   /*---- custom page -----------------------------------------------*/
 
   if (equal_ustring(command, "custom")) {
      Lock(t);
      show_custom_page(p, r, c->cookie_cpwd.c_str());
      Unlock(t);
      return;
   }
 
   /*---- custom page accessed by direct URL that used to be under /CS/... ----*/
 
   if (db_find_key(hDB, 0, "/Custom", &hkey) == DB_SUCCESS && dec_path[0]) {
      std::string odb_path;
      std::string value;
      int status;
 
      odb_path = "";
      odb_path += "/Custom/Images/";
      odb_path += dec_path;
      odb_path += "/Background";
 
      status = db_get_value_string(hDB, 0, odb_path.c_str(), 0, &value, FALSE);
 
      //printf("Try custom gif [%s] status %d\n", odb_path.c_str(), status);
 
      if (status == DB_SUCCESS) {
         if (strstr(dec_path, "..")) {
            std::string str;
            str += "Invalid custom gif name \'";
            str += dec_path;
            str += "\' contains \'..\'";
            show_error_404(r, str.c_str());
            return;
         }
 
         Lock(t);
         show_custom_gif(r, dec_path);
         Unlock(t);
         return;
      }
 
      bool found_custom = false;
 
      odb_path = "";
      odb_path += "/Custom/";
      odb_path += dec_path;
 
      status = db_get_value_string(hDB, 0, odb_path.c_str(), 0, &value, FALSE);
 
      //printf("Try [%s] status %d\n", odb_path.c_str(), status);
 
      if (status == DB_SUCCESS) {
         found_custom = true;
      } else {
         odb_path = "";
         odb_path += "/Custom/";
         odb_path += dec_path;
         odb_path += "&";
 
         status = db_get_value_string(hDB, 0, odb_path.c_str(), 0, &value, FALSE);
 
         //printf("Try [%s] status %d\n", odb_path.c_str(), status);
 
         if (status == DB_SUCCESS) {
            found_custom = true;
         } else {
            odb_path = "";
            odb_path += "/Custom/";
            odb_path += dec_path;
            odb_path += "!";
 
            status = db_get_value_string(hDB, 0, odb_path.c_str(), 0, &value, FALSE);
 
            //printf("Try [%s] status %d\n", odb_path.c_str(), status);
 
            if (status == DB_SUCCESS) {
               found_custom = true;
            }
         }
      }
 
      if (found_custom) {
         //printf("custom file: serving [%s] value [%s]\n", dec_path, value.c_str());
         if (strstr(dec_path, "..")) {
            std::string str;
            str += "Invalid custom page name \'";
            str += dec_path;
            str += "\' contains \'..\'";
            show_error_404(r, str.c_str());
            return;
         }
 
         p->setparam("page", dec_path);
         Lock(t);
         show_custom_page(p, r, c->cookie_cpwd.c_str());
         Unlock(t);
         return;
      }
   }
 
   /* new custom pages */
   if (db_find_key(hDB, 0, "/Custom", &hkey) == DB_SUCCESS && dec_path[0]) {
      std::string custom_path;
      status = db_get_value_string(hDB, 0, "/Custom/Path", 0, &custom_path, TRUE);
      if ((status == DB_SUCCESS) && (custom_path.length() > 0)) {
         if (strstr(dec_path, "..")) {
            std::string str;
            str += "Invalid custom file name \'";
            str += dec_path;
            str += "\' contains \'..\'";
            show_error_404(r, str.c_str());
            return;
         }
 
         std::string full_filename = add_custom_path(dec_path);
 
         // if custom file exists, send it (like normal web server)
         if (ss_file_exist(full_filename.c_str())) {
            send_file(r, full_filename);
            return;
         }
      }
   }
 
   /*---- redirect if web page --------------------------------------*/
 
   //if (strlen(command) > 0) {
   //   if (send_resource(r, std::string(command) + ".html", false))
   //      return;
   //}
 
   /*---- serve url as a resource file ------------------------------*/
 
   if (strlen(p->getparam("path")) > 0) {
      if (send_resource(r, p->getparam("path"), false)) {
         return;
      }
   }
 
   /*---- show status -----------------------------------------------*/
 
   if (elog_mode) {
      redirect(r, "EL/");
      return;
   }
 
   /* header */
   r->rsprintf("HTTP/1.1 400 Bad Request\r\n");
   r->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
   r->rsprintf("Content-Type: text/plain; charset=%s\r\n", HTTP_ENCODING);
   r->rsprintf("\r\n");
   r->rsprintf("Error: Invalid URL \"%s\" or query \"%s\" or command \"%s\"\n", p->getparam("path"), p->getparam("query"), command);
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_editable()

BOOL is_editable	(	char *	eq_name,
		char *	var_name
	)

Definition at line 2531 of file mhttpd.cxx.

{
   HNDLE hDB, hkey;
   KEY key;
   char str[256];
   int i, size;
 
   cm_get_experiment_database(&hDB, NULL);
   sprintf(str, "/Equipment/%s/Settings/Editable", eq_name);
   db_find_key(hDB, 0, str, &hkey);
 
   /* if no editable entry found, use default */
   if (!hkey) {
      return (equal_ustring(var_name, "Demand") ||
              equal_ustring(var_name, "Output") || strncmp(var_name, "D_", 2) == 0);
   }
 
   db_get_key(hDB, hkey, &key);
   for (i = 0; i < key.num_values; i++) {
      size = sizeof(str);
      db_get_data_index(hDB, hkey, str, &size, i, TID_STRING);
      if (equal_ustring(var_name, str))
         return TRUE;
   }
   return FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function:

javascript_commands()

void javascript_commands	(	Param *	p,
		Return *	r,
		const char *	cookie_cpwd
	)

Definition at line 4443 of file mhttpd.cxx.

{
   int status;
   int size, i, n, index, type;
   unsigned int t;
   char str[TEXT_SIZE], format[256], facility[256], user[256];
   HNDLE hDB, hkey;
   KEY key;
   char data[TEXT_SIZE];
 
   cm_get_experiment_database(&hDB, NULL);
 
   // process common parameters
 
   const int ENCODING_NONE = 0;
   const int ENCODING_ODB = 1;
   const int ENCODING_XML = 2;
   const int ENCODING_JSON = 3;
 
   std::string cmd_parameter;
   std::string encoding_parameter;
   int encoding = ENCODING_NONE; // default encoding
   bool jsonp = false; // default is no JSONP wrapper
   std::string jsonp_callback; // default is no JSONP
   bool single = false; // single encoding
   bool multiple = false; // multiple encoding
   std::vector<std::string> odb; // multiple odb parameters
   //HNDLE hodb; // ODB handle for single odb parameter
   //std::vector<HNDLE> hodbm; // ODB handle for multiple odb parameter
 
   if (p->isparam("cmd")) {
      cmd_parameter = p->getparam("cmd");
   }
 
   if (p->isparam("encoding")) {
      encoding_parameter = p->getparam("encoding");
   }
 
   if (encoding_parameter.length() > 0) {
      if (starts_with(encoding_parameter, "odb"))
         encoding = ENCODING_ODB;
      else if (starts_with(encoding_parameter, "xml"))
         encoding = ENCODING_XML;
      else if (starts_with(encoding_parameter, "json"))
         encoding = ENCODING_JSON;
   }
 
   if (encoding == ENCODING_JSON) {
      if (p->isparam("callback")) {
         jsonp = true;
         jsonp_callback = p->getparam("callback");
      }
   }
 
   if (p->isparam("odb")) {
      single = true;
      odb.push_back(p->getparam("odb"));
   }
 
   if (p->isparam("odb0")) {
      multiple = true;
      for (int i=0 ; ; i++) {
         char ppath[256];
         sprintf(ppath, "odb%d", i);
         if (!p->isparam(ppath))
            break;
         odb.push_back(p->getparam(ppath));
      }
   }
 
   if (/* DISABLES CODE */ (0)) {
      printf("command [%s], encoding %d [%s], jsonp %d, single %d, multiple %d, odb array size %d\n", cmd_parameter.c_str(), encoding, encoding_parameter.c_str(), jsonp, single, multiple, (int)odb.size());
   }
 
   /* process "jset" command */
   if (equal_ustring(p->getparam("cmd"), "jset")) {
 
      if (*p->getparam("pnam")) {
         std::string ppath;
         ppath += "/Custom/Pwd/";
         ppath += p->getparam("pnam");
         str[0] = 0;
         db_get_value(hDB, 0, ppath.c_str(), str, &size, TID_STRING, TRUE);
         if (!equal_ustring(cookie_cpwd, str)) {
            show_text_header(r);
            r->rsprintf("Invalid password!");
            return;
         }
      }
      mstrlcpy(str, p->getparam("odb"), sizeof(str));
      if (strchr(str, '[')) {
         if (*(strchr(str, '[')+1) == '*')
            index = -1;
         else
            index = atoi(strchr(str, '[')+1);
         *strchr(str, '[') = 0;
      } else
         index = 0;
 
      if (db_find_key(hDB, 0, str, &hkey) == DB_SUCCESS && p->isparam("value")) {
         db_get_key(hDB, hkey, &key);
         memset(data, 0, sizeof(data));
         if (key.item_size <= (int)sizeof(data)) {
            if (index == -1) {
               const char* ptr = p->getparam("value");
               for (i=0 ; ptr != NULL ; i++) {
                  size = sizeof(data);
                  db_sscanf(ptr, data, &size, 0, key.type);
                  if (strchr(data, ','))
                     *strchr(data, ',') = 0;
                  db_set_data_index(hDB, hkey, data, key.item_size, i, key.type);
                  ptr = strchr(ptr, ',');
                  if (ptr != NULL)
                     ptr++;
               }
            } else {
               size = sizeof(data);
               db_sscanf(p->getparam("value"), data, &size, 0, key.type);
 
               /* extend data size for single string if necessary */
               if ((key.type == TID_STRING || key.type == TID_LINK)
                   && (int) strlen(data) + 1 > key.item_size && key.num_values == 1) {
                  key.item_size = strlen(data) + 1;
                  db_set_data(hDB, hkey, data, key.item_size, 1, key.type);
               } else
                  db_set_data_index(hDB, hkey, data, key.item_size, index, key.type);
            }
         }
      } else {
         if (p->isparam("value") && p->isparam("type") && p->isparam("len")) {
            int type = atoi(p->getparam("type"));
            if (type == 0) {
               show_text_header(r);
               r->rsprintf("Invalid type %d!", type);
               return;
            }
            db_create_key(hDB, 0, str, type);
            db_find_key(hDB, 0, str, &hkey);
            if (!hkey) {
               show_text_header(r);
               r->rsprintf("Cannot create \'%s\' type %d", str, type);
               return;
            }
            db_get_key(hDB, hkey, &key);
            memset(data, 0, sizeof(data));
            size = sizeof(data);
            db_sscanf(p->getparam("value"), data, &size, 0, key.type);
            if (key.type == TID_STRING)
               db_set_data(hDB, hkey, data, atoi(p->getparam("len")), 1, TID_STRING);
            else {
               for (i=0 ; i<atoi(p->getparam("len")) ; i++)
                  db_set_data_index(hDB, hkey, data, rpc_tid_size(key.type), i, key.type);
            }
         }
      }
 
      show_text_header(r);
      r->rsprintf("OK");
      return;
   }
 
   /* process "jget" command */
   if (equal_ustring(p->getparam("cmd"), "jget")) {
 
      if (p->isparam("odb")) {
         mstrlcpy(str, p->getparam("odb"), sizeof(str));
         if (strchr(str, '[')) {
            if (*(strchr(str, '[')+1) == '*')
               index = -1;
            else
               index = atoi(strchr(str, '[')+1);
            *strchr(str, '[') = 0;
         } else
            index = 0;
 
         show_text_header(r);
 
         status = db_find_key(hDB, 0, str, &hkey);
 
         if (status == DB_SUCCESS)
            output_key(p, r, hkey, index, p->getparam("format"));
         else
            r->rsputs("<DB_NO_KEY>");
      }
 
      if (p->isparam("odb0")) {
         show_text_header(r);
         for (i=0 ; ; i++) {
            char ppath[256];
            sprintf(ppath, "odb%d", i);
            sprintf(format, "format%d", i);
            if (p->isparam(ppath)) {
               mstrlcpy(str, p->getparam(ppath), sizeof(str));
               if (strchr(str, '[')) {
                  if (*(strchr(str, '[')+1) == '*')
                     index = -1;
                  else
                     index = atoi(strchr(str, '[')+1);
                  *strchr(str, '[') = 0;
               } else
                  index = 0;
               if (i > 0)
                  r->rsputs("$#----#$\n");
               if (db_find_key(hDB, 0, str, &hkey) == DB_SUCCESS)
                  output_key(p, r, hkey, index, p->getparam(format));
               else
                  r->rsputs("<DB_NO_KEY>");
 
            } else
               break;
         }
      }
 
      return;
   }
 
   /* process "jcopy" command */
   if (equal_ustring(p->getparam("cmd"), "jcopy")) {
 
      bool fmt_odb  = false;
      bool fmt_xml  = false;
      bool fmt_json = true;
      bool fmt_jsonp = false;
      int follow_links = 1;
      int save_keys = 1;
      int recurse = 1;
      const char* fmt = NULL;
      const char* jsonp_callback = "callback";
 
      if (p->isparam("encoding")) {
         fmt = p->getparam("encoding");
      } else if (p->isparam("format")) {
         fmt = p->getparam("format");
      }
 
      if (fmt) {
         fmt_odb  = (equal_ustring(fmt, "odb") > 0);
         fmt_xml  = (equal_ustring(fmt, "xml") > 0);
         fmt_json = (strstr(fmt, "json") != NULL);
 
         if (fmt_odb)
            fmt_xml = fmt_json = false;
         if (fmt_xml)
            fmt_odb = fmt_json = false;
         if (fmt_json)
            fmt_odb = fmt_xml = false;
 
         if (fmt_json)
            fmt_jsonp = (strstr(fmt, "-p") != NULL);
         if (fmt_jsonp && p->isparam("callback"))
            jsonp_callback = p->getparam("callback");
         if (fmt_json && strstr(fmt, "-nofollowlinks"))
            follow_links = 0;
         if (fmt_json && strstr(fmt, "-nokeys"))
            save_keys = 2;
         if (fmt_json && strstr(fmt, "-nolastwritten"))
            save_keys = 0;
         if (fmt_json && strstr(fmt, "-norecurse"))
            recurse = 0;
      }
 
      if (p->isparam("odb")) {
         mstrlcpy(str, p->getparam("odb"), sizeof(str));
 
         show_text_header(r);
 
         if (fmt_json)
            status = db_find_link(hDB, 0, str, &hkey);
         else
            status = db_find_key(hDB, 0, str, &hkey);
         if (status == DB_SUCCESS) {
 
            if (fmt_jsonp) {
               r->rsputs(jsonp_callback);
               r->rsputs("(");
            }
 
            int end = 0;
            int bufsize = WEB_BUFFER_SIZE;
            char* buf = (char *)malloc(bufsize);
 
            if (fmt_xml)
               db_copy_xml(hDB, hkey, buf, &bufsize, true);
            else if (fmt_json)
               db_copy_json_obsolete(hDB, hkey, &buf, &bufsize, &end, save_keys, follow_links, recurse);
            else
               db_copy(hDB, hkey, buf, &bufsize, (char *)"");
 
            r->rsputs(buf);
            free(buf);
 
            if (fmt_jsonp) {
               r->rsputs(");\n");
            }
         } else
            r->rsputs("<DB_NO_KEY>");
      }
 
      if (p->isparam("odb0")) {
         show_text_header(r);
         if (fmt_jsonp) {
            r->rsputs(jsonp_callback);
            r->rsputs("(");
         }
         if (fmt_xml) {
            r->rsprintf("<?xml version=\"1.0\" encoding=\"%s\"?>\n", HTTP_ENCODING);
            r->rsputs("<jcopy>\n");
            r->rsputs("<data>\n");
         } else if (fmt_json)
            r->rsputs("[\n");
         else
            r->rsputs("");
         for (int i=0 ; ; i++) {
            char ppath[256];
            sprintf(ppath, "odb%d", i);
            if (!p->isparam(ppath))
               break;
            mstrlcpy(str, p->getparam(ppath), sizeof(str));
 
            if (i > 0) {
               if (fmt_xml)
                  r->rsputs("</data>\n<data>\n");
               else if (fmt_json)
                  r->rsputs(",\n");
               else
                  r->rsputs("$#----#$\n");
            }
 
            if (fmt_json)
               status = db_find_link(hDB, 0, str, &hkey);
            else
               status = db_find_key(hDB, 0, str, &hkey);
            if (status != DB_SUCCESS) {
               if (fmt_xml)
                  r->rsputs("<DB_NO_KEY/>\n");
               else if (fmt_json) {
                  char tmp[256];
                  sprintf(tmp, "{ \"/error\" : %d }\n", status);
                  r->rsputs(tmp);
               } else
                  r->rsputs("<DB_NO_KEY>\n");
               continue;
            }
 
            int end = 0;
            int bufsize = WEB_BUFFER_SIZE;
            char* buf = (char *)malloc(bufsize);
 
            if (fmt_xml) {
               db_copy_xml(hDB, hkey, buf, &bufsize, true);
               const char* s = strstr(buf, "-->");
               if (s)
                  s+=4;
               else
                  s = buf;
               r->rsputs(s);
            } else if (fmt_json) {
               db_copy_json_obsolete(hDB, hkey, &buf, &bufsize, &end, save_keys, follow_links, recurse);
               r->rsputs(buf);
            } else {
               db_copy(hDB, hkey, buf, &bufsize, (char *)"");
               r->rsputs(buf);
            }
 
            free(buf);
         }
 
         if (fmt_xml)
            r->rsputs("</data>\n</jcopy>\n");
         else if (fmt_json)
            r->rsputs("]\n");
         else
            r->rsputs("");
 
         if (fmt_jsonp) {
            r->rsputs(");\n");
         }
      }
      return;
   }
 
   /* process "jkey" command */
   if (equal_ustring(p->getparam("cmd"), "jkey")) {
 
      // test:
      // curl "http://localhost:8080?cmd=jkey&odb0=/runinfo/run+number&odb1=/nonexistant&odb2=/&encoding=json&callback=aaa"
 
      show_text_header(r);
 
      if (jsonp) {
         r->rsputs(jsonp_callback.c_str());
         r->rsputs("(");
      }
 
      if (multiple) {
         switch (encoding) {
         default:
            break;
         case ENCODING_JSON:
            r->rsprintf("[ ");
            break;
         }
      }
 
      for (unsigned i=0; i<odb.size(); i++) {
         status = db_find_key(hDB, 0, odb[i].c_str(), &hkey);
         if (status == DB_SUCCESS)
            status = db_get_key(hDB, hkey, &key);
         switch (encoding) {
         default:
            if (multiple && i>0)
               r->rsputs("$#----#$\n");
            if (status == DB_SUCCESS) {
               r->rsprintf("%s\n", key.name);
               r->rsprintf("TID_%s\n", rpc_tid_name(key.type));
               r->rsprintf("%d\n", key.num_values);
               r->rsprintf("%d\n", key.item_size);
               r->rsprintf("%d\n", key.last_written);
            } else {
               r->rsputs("<DB_NO_KEY>\n");
            }
            break;
         case ENCODING_JSON:
            if (multiple && i>0)
               r->rsprintf(", ");
            if (status == DB_SUCCESS) {
               r->rsprintf("{ ");
               r->rsprintf("\"name\":\"%s\",", key.name);
               r->rsprintf("\"type\":%d,", key.type);
               r->rsprintf("\"type_name\":\"TID_%s\",", rpc_tid_name(key.type));
               r->rsprintf("\"num_values\":%d,", key.num_values);
               r->rsprintf("\"item_size\":%d,", key.item_size);
               r->rsprintf("\"last_written\":%d", key.last_written);
               r->rsprintf(" }");
            } else {
               r->rsprintf("{ \"/error\":%d }", status);
            }
            break;
         }
      }
 
      if (multiple) {
         switch (encoding) {
         default:
            break;
         case ENCODING_JSON:
            r->rsprintf(" ]");
            break;
         }
      }
 
      if (jsonp) {
         r->rsputs(");\n");
      }
 
      return;
   }
 
   /* process "jcreate" command */
   if (equal_ustring(p->getparam("cmd"), "jcreate")) {
 
      // test:
      // curl "http://localhost:8080?cmd=jcreate&odb0=/test/foo&type0=7&odb1=/nonexistant&type1=100&odb2=/test/bar&type2=12&encoding=json&callback=aaa"
      // curl "http://localhost:8080?cmd=jcreate&odb=/test/foo&type=7"
      // curl "http://localhost:8080?cmd=jcreate&odb=/test/foo70&type=7&arraylen=10"
      // curl "http://localhost:8080?cmd=jcreate&odb=/test/foo12s&type=12&strlen=32"
      // curl "http://localhost:8080?cmd=jcreate&odb=/test/foo12s5&type=12&strlen=32&arraylen=5"
      // curl "http://localhost:8080?cmd=jcreate&odb0=/test/foo12s5x&type0=12&strlen0=32&arraylen0=5"
 
 
      show_text_header(r);
 
      if (jsonp) {
         r->rsputs(jsonp_callback.c_str());
         r->rsputs("(");
      }
 
      if (multiple) {
         switch (encoding) {
         default:
         case ENCODING_JSON:
            r->rsprintf("[ ");
            break;
         }
      }
 
      for (unsigned i=0; i<odb.size(); i++) {
         HNDLE hkey = 0;
         int type = 0;
         int arraylength = 0;
         int strlength = 0;
 
         if (single) {
            type = atoi(p->getparam("type"));
            arraylength = atoi(p->getparam("arraylen"));
            strlength = atoi(p->getparam("strlen"));
         }
         else if (multiple) {
            char buf[256];
            sprintf(buf, "type%d", i);
            type = atoi(p->getparam(buf));
            sprintf(buf, "arraylen%d", i);
            arraylength = atoi(p->getparam(buf));
            sprintf(buf, "strlen%d", i);
            strlength = atoi(p->getparam(buf));
         }
 
         status = db_create_key(hDB, 0, odb[i].c_str(), type);
 
         if (status == DB_SUCCESS) {
            status = db_find_link(hDB, 0, odb[i].c_str(), &hkey);
         }
 
         if (status == DB_SUCCESS && hkey && type == TID_STRING && strlength > 0) {
            char* s = (char*)calloc(strlength, 1); // initialized to zero
            status = db_set_data(hDB, hkey, s, strlength, 1, TID_STRING);
            free(s);
         }
 
         if (status == DB_SUCCESS && hkey && arraylength > 1) {
            status = db_set_num_values(hDB, hkey, arraylength);
         }
 
         switch (encoding) {
         default:
         case ENCODING_JSON:
            if (multiple && i>0)
               r->rsprintf(", ");
            r->rsprintf("%d", status);
            break;
         }
      }
 
      if (multiple) {
         switch (encoding) {
         default:
         case ENCODING_JSON:
            r->rsprintf(" ]");
            break;
         }
      }
 
      if (jsonp) {
         r->rsputs(");\n");
      }
 
      return;
   }
 
   /* process "jresize" command */
   if (equal_ustring(p->getparam("cmd"), "jresize")) {
 
      // test:
 
      // curl "http://localhost:8080?cmd=jresize&odb=/test/foo70&arraylen=5"
      // curl "http://localhost:8080?cmd=jresize&odb=/test/foo12s5&arraylen=5"
      // curl "http://localhost:8080?cmd=jresize&odb=/test/foo12s5&strlen=16"
      // curl "http://localhost:8080?cmd=jresize&odb=/test/foo12s5&strlen=30&arraylen=10"
 
      show_text_header(r);
 
      if (jsonp) {
         r->rsputs(jsonp_callback.c_str());
         r->rsputs("(");
      }
 
      if (multiple) {
         switch (encoding) {
         default:
         case ENCODING_JSON:
            r->rsprintf("[ ");
            break;
         }
      }
 
      for (unsigned i=0; i<odb.size(); i++) {
         HNDLE hkey;
         KEY key;
         int arraylength = 0;
         int strlength = 0;
 
         if (single) {
            arraylength = atoi(p->getparam("arraylen"));
            strlength = atoi(p->getparam("strlen"));
         }
         else if (multiple) {
            char buf[256];
            sprintf(buf, "arraylen%d", i);
            arraylength = atoi(p->getparam(buf));
            sprintf(buf, "strlen%d", i);
            strlength = atoi(p->getparam(buf));
         }
 
         status = db_find_key(hDB, 0, odb[i].c_str(), &hkey);
 
         if (status == DB_SUCCESS && hkey) {
            status = db_get_key(hDB, hkey, &key);
         }
 
         if (status == DB_SUCCESS && hkey && key.type == TID_STRING && strlength > 0) {
            int oldsize = key.item_size * key.num_values;
            char* olddata = (char*)malloc(oldsize);
            int size = oldsize;
            status = db_get_data(hDB, hkey, olddata, &size, TID_STRING);
 
            if (status == DB_SUCCESS) {
               int newsize = strlength * key.num_values;
               char* s = (char*)calloc(newsize, 1); // initialized to zero
               for (int k=0; k<key.num_values; k++) {
                  mstrlcpy(s + strlength*k, olddata + key.item_size*k, strlength);
               }
 
               status = db_set_data(hDB, hkey, s, newsize, key.num_values, TID_STRING);
               free(s);
            }
 
            free(olddata);
         }
 
         if (status == DB_SUCCESS && hkey && arraylength > 0) {
            status = db_set_num_values(hDB, hkey, arraylength);
         }
 
         switch (encoding) {
         default:
         case ENCODING_JSON:
            if (multiple && i>0)
               r->rsprintf(", ");
            r->rsprintf("%d", status);
            break;
         }
      }
 
      if (multiple) {
         switch (encoding) {
         default:
         case ENCODING_JSON:
            r->rsprintf(" ]");
            break;
         }
      }
 
      if (jsonp) {
         r->rsputs(");\n");
      }
 
      return;
   }
 
   /* process "jrename" command */
   if (equal_ustring(p->getparam("cmd"), "jrename")) {
 
      // test:
      // curl "http://localhost:8080?cmd=jrename&odb0=/test/foo&type0=7&odb1=/nonexistant&type1=100&odb2=/test/bar&type2=12&encoding=json&callback=aaa"
      // curl "http://localhost:8080?cmd=jrename&odb=/test/foo&name=foofoo"
 
      show_text_header(r);
 
      if (jsonp) {
         r->rsputs(jsonp_callback.c_str());
         r->rsputs("(");
      }
 
      if (multiple) {
         switch (encoding) {
         default:
         case ENCODING_JSON:
            r->rsprintf("[ ");
            break;
         }
      }
 
      for (unsigned i=0; i<odb.size(); i++) {
         const char* name = NULL;
         if (single)
            name = p->getparam("name");
         else if (multiple) {
            char buf[256];
            sprintf(buf, "name%d", i);
            name = p->getparam(buf);
         }
         status = db_find_key(hDB, 0, odb[i].c_str(), &hkey);
         if (status == DB_SUCCESS) {
            status = db_rename_key(hDB, hkey, name);
         }
         switch (encoding) {
         default:
         case ENCODING_JSON:
            if (multiple && i>0)
               r->rsprintf(", ");
            r->rsprintf("%d", status);
            break;
         }
      }
 
      if (multiple) {
         switch (encoding) {
         default:
         case ENCODING_JSON:
            r->rsprintf(" ]");
            break;
         }
      }
 
      if (jsonp) {
         r->rsputs(");\n");
      }
 
      return;
   }
 
   /* process "jlink" command */
   if (equal_ustring(p->getparam("cmd"), "jlink")) {
 
      // test:
      // curl "http://localhost:8080?cmd=jlink&odb=/test/link&dest=/test/foo"
      // curl "http://localhost:8080?cmd=jlink&odb0=/test/link0&dest0=/test/foo&odb1=/test/link1&dest1=/test/foo"
 
      show_text_header(r);
 
      if (jsonp) {
         r->rsputs(jsonp_callback.c_str());
         r->rsputs("(");
      }
 
      if (multiple) {
         switch (encoding) {
         default:
         case ENCODING_JSON:
            r->rsprintf("[ ");
            break;
         }
      }
 
      for (unsigned i=0; i<odb.size(); i++) {
         const char* dest = NULL;
         if (single)
            dest = p->getparam("dest");
         else if (multiple) {
            char buf[256];
            sprintf(buf, "dest%d", i);
            dest = p->getparam(buf);
         }
 
         status = db_create_link(hDB, 0, odb[i].c_str(), dest);
 
         switch (encoding) {
         default:
         case ENCODING_JSON:
            if (multiple && i>0)
               r->rsprintf(", ");
            r->rsprintf("%d", status);
            break;
         }
      }
 
      if (multiple) {
         switch (encoding) {
         default:
         case ENCODING_JSON:
            r->rsprintf(" ]");
            break;
         }
      }
 
      if (jsonp) {
         r->rsputs(");\n");
      }
 
      return;
   }
 
   /* process "jreorder" command */
   if (equal_ustring(p->getparam("cmd"), "jreorder")) {
 
      // test:
      // curl "http://localhost:8080?cmd=jreorder&odb0=/test/foo&index0=0&odb1=/test/bar&index1=1"
      // curl "http://localhost:8080?cmd=jreorder&odb=/test/bar&index=0"
 
      show_text_header(r);
 
      if (jsonp) {
         r->rsputs(jsonp_callback.c_str());
         r->rsputs("(");
      }
 
      if (multiple) {
         switch (encoding) {
         default:
         case ENCODING_JSON:
            r->rsprintf("[ ");
            break;
         }
      }
 
      for (unsigned i=0; i<odb.size(); i++) {
         int index = 0;
         if (single)
            index = atoi(p->getparam("index"));
         else if (multiple) {
            char buf[256];
            sprintf(buf, "index%d", i);
            index = atoi(p->getparam(buf));
         }
 
         status = db_find_key(hDB, 0, odb[i].c_str(), &hkey);
         if (status == DB_SUCCESS) {
            status = db_reorder_key(hDB, hkey, index);
         }
 
         switch (encoding) {
         default:
         case ENCODING_JSON:
            if (multiple && i>0)
               r->rsprintf(", ");
            r->rsprintf("%d", status);
            break;
         }
      }
 
      if (multiple) {
         switch (encoding) {
         default:
         case ENCODING_JSON:
            r->rsprintf(" ]");
            break;
         }
      }
 
      if (jsonp) {
         r->rsputs(");\n");
      }
 
      return;
   }
 
   /* process "jdelete" command */
   if (equal_ustring(p->getparam("cmd"), "jdelete")) {
 
      // test:
      // curl "http://localhost:8080?cmd=jdelete&odb0=/test/foo&odb1=/nonexistant&odb2=/test/bar&encoding=json&callback=aaa"
      // curl "http://localhost:8080?cmd=jdelete&odb=/test/foo"
 
      show_text_header(r);
 
      if (jsonp) {
         r->rsputs(jsonp_callback.c_str());
         r->rsputs("(");
      }
 
      if (multiple) {
         switch (encoding) {
         default:
         case ENCODING_JSON:
            r->rsprintf("[ ");
            break;
         }
      }
 
      for (unsigned i=0; i<odb.size(); i++) {
         BOOL follow_links = 0;
         status = db_find_link(hDB, 0, odb[i].c_str(), &hkey);
         if (status == DB_SUCCESS) {
            status = db_delete_key(hDB, hkey, follow_links);
         }
         switch (encoding) {
         default:
         case ENCODING_JSON:
            if (multiple && i>0)
               r->rsprintf(", ");
            r->rsprintf("%d", status);
            break;
         }
      }
 
      if (multiple) {
         switch (encoding) {
         default:
         case ENCODING_JSON:
            r->rsprintf(" ]");
            break;
         }
      }
 
      if (jsonp) {
         r->rsputs(");\n");
      }
 
      return;
   }
 
   /* process "jmsg" command */
   if (equal_ustring(p->getparam("cmd"), "jmsg")) {
 
      if (p->getparam("f") && *p->getparam("f"))
         mstrlcpy(facility, p->getparam("f"), sizeof(facility));
      else
         mstrlcpy(facility, "midas", sizeof(facility));
 
      n = 1;
      if (p->getparam("n") && *p->getparam("n"))
         n = atoi(p->getparam("n"));
 
      t = 0;
      if (p->getparam("t") && p->getparam("t"))
         t = atoi(p->getparam("t"));
 
      show_text_header(r);
      char* messages = NULL;
      int num_messages = 0;
      cm_msg_retrieve2(facility, t, n, &messages, &num_messages);
      if (messages) {
         r->rsputs(messages);
         free(messages);
      }
      return;
   }
 
   /* process "jgenmsg" command */
   if (equal_ustring(p->getparam("cmd"), "jgenmsg")) {
 
      if (p->getparam("facility") && *p->getparam("facility"))
         mstrlcpy(facility, p->getparam("facility"), sizeof(facility));
      else
         mstrlcpy(facility, "midas", sizeof(facility));
 
      if (p->getparam("user") && *p->getparam("user"))
         mstrlcpy(user, p->getparam("user"), sizeof(user));
      else
         mstrlcpy(user, "javascript_commands", sizeof(user));
 
      if (p->getparam("type") && *p->getparam("type"))
         type = atoi(p->getparam("type"));
      else
         type = MT_INFO;
 
      if (p->getparam("msg") && *p->getparam("msg")) {
         cm_msg1(type, __FILE__, __LINE__, facility, user, "%s", p->getparam("msg"));
      }
 
      show_text_header(r);
      r->rsputs("Message successfully created\n");
      return;
   }
 
   /* process "jalm" command */
   if (equal_ustring(p->getparam("cmd"), "jalm")) {
 
      show_text_header(r);
      std::string alarms;
      al_get_alarms(&alarms);
      r->rsputs(alarms.c_str());
      return;
   }
 
   /* process "jrpc" command */
   if (equal_ustring(p->getparam("cmd"), "jrpc_rev0")) {
      do_jrpc_rev0(p, r);
      return;
   }
 
   /* process "jrpc" command */
   if (equal_ustring(p->getparam("cmd"), "jrpc_rev1")) {
      do_jrpc_rev1(p, r);
      return;
   }
 
   /* process "jrpc" command */
   if (equal_ustring(p->getparam("cmd"), "jrpc")) {
      do_jrpc(p, r);
      return;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

LoadHistPlotFromOdb()

static void LoadHistPlotFromOdb ( MVOdb *  odb, HistPlot *  hp, const char *  group, const char *  panel  )

static

Definition at line 10195 of file mhttpd.cxx.

{
   std::string path = "History/Display/";
   path += group;
   path += "/";
   path += panel;
   
   MVOdb* o = odb->Chdir(path.c_str());
   if (!o) {
      return;
   }
 
   o->RS("Timescale",   &hp->timescale);
   o->RD("Minimum",     &hp->minimum);
   o->RD("Maximum",     &hp->maximum);
   o->RB("Zero ylow",   &hp->zero_ylow);
   o->RB("Log axis",    &hp->log_axis);
   o->RB("Zero ylow",   &hp->zero_ylow);
   o->RB("Show run markers", &hp->show_run_markers);
   o->RB("Show values", &hp->show_values);
   o->RB("Show fill",   &hp->show_fill);
   o->RB("Show factor", &hp->show_factor);
   //o->RB("Enable factor and offset", &hp->enable_factor);
 
   std::vector<std::string> hist_vars;
   std::vector<std::string> hist_formula;
   std::vector<std::string> hist_colour;
   std::vector<std::string> hist_label;
   std::vector<bool>   hist_show_raw_value;
   std::vector<double> hist_factor;
   std::vector<double> hist_offset;
   std::vector<double> hist_voffset;
 
   o->RSA("Variables", &hist_vars);
   o->RSA("Formula",   &hist_formula);
   o->RSA("Colour",    &hist_colour);
   o->RSA("Label",     &hist_label);
   o->RBA("Show raw value", &hist_show_raw_value);
   o->RDA("Factor",    &hist_factor);
   o->RDA("Offset",    &hist_offset);
   o->RDA("VOffset",   &hist_voffset);
 
   // fix broken plots with "factor" all zero. for reasons
   // unknown the new history code has corrupted many
   // history plot definitions like this. K.O.
   {
      bool all_zero = true;
      for (size_t i=0; i<hist_factor.size(); i++) {
         if (hist_factor[i] != 0)
            all_zero = false;
      }
      if (all_zero) {
         for (size_t i=0; i<hist_factor.size(); i++) {
            hist_factor[i] = 1.0;
         }
      }
   }
 
   size_t num = std::max(hist_vars.size(), hist_formula.size());
   num = std::max(num, hist_colour.size());
   num = std::max(num, hist_label.size());
   num = std::max(num, hist_show_raw_value.size());
   num = std::max(num, hist_factor.size());
   num = std::max(num, hist_offset.size());
   num = std::max(num, hist_voffset.size());
 
   hist_vars.resize(num);
   hist_formula.resize(num);
   hist_colour.resize(num);
   hist_label.resize(num);
   hist_show_raw_value.resize(num);
   hist_factor.resize(num, 1.0);
   hist_offset.resize(num, 0.0);
   hist_voffset.resize(num, 0.0);
 
   for (size_t i=0; i<num; i++) {
      HistVar v;
 
      SplitEventAndTagNames(hist_vars[i], v.event_name, v.tag_name);
 
      v.formula = hist_formula[i];
      v.colour  = hist_colour[i];
      v.label   = hist_label[i];
      v.show_raw_value = hist_show_raw_value[i];
      v.factor  = hist_factor[i];
      v.offset  = hist_offset[i];
      v.voffset = hist_voffset[i];
      v.order   = NextHistPlotOrder(*hp);
 
      // one-time migration of factor and offset to formula
      if (hp->enable_factor && v.formula.empty()) {
         if (v.factor!=1 || v.offset!=0 || v.voffset!=0) {
            v.formula = msprintf("%g%+g*(x%+g)", v.offset, v.factor, -v.voffset);
         }
      }
      
      hp->vars.push_back(v);
   }
   
//   printf("Load from ODB %s: ", path.c_str());
//   PrintHistPlot(*hp);
 
   delete o;
}

Here is the call graph for this function:

Here is the caller graph for this function:

LoadHistPlotFromParam()

static void LoadHistPlotFromParam ( HistPlot *  hp, Param *  p  )

static

Definition at line 10300 of file mhttpd.cxx.

{
   hp->timescale        = p->getparam("timescale");
   hp->minimum          = strtod(p->getparam("minimum"), NULL);
   hp->maximum          = strtod(p->getparam("maximum"), NULL);
   hp->zero_ylow        = *p->getparam("zero_ylow");
   hp->log_axis         = *p->getparam("log_axis");
   hp->show_run_markers = *p->getparam("run_markers");
   hp->show_values      = *p->getparam("show_values");
   hp->show_fill        = *p->getparam("show_fill");
   hp->show_factor      = *p->getparam("show_factor");
   //hp->enable_factor    = *p->getparam("enable_factor");
   
   for (int index=0; ; index++) {
      char str[256];
      sprintf(str, "event%d", index);
      
      //printf("param event %d: [%s] [%s] [%d]\n", index, str, p->getparam(str), *p->getparam(str));
      
      if (!p->isparam(str))
         break;
      
      if (*p->getparam(str) == '/') // "/empty"
         continue;
      
      HistVar v;
 
      v.event_name = p->xgetparam(str);
      
      sprintf(str, "var%d", index);
      v.tag_name = p->xgetparam(str);
      
      sprintf(str, "form%d", index);
      v.formula = p->xgetparam(str);
      
      sprintf(str, "col%d", index);
      v.colour = p->xgetparam(str);
      
      sprintf(str, "lab%d", index);
      v.label = p->xgetparam(str);
      
      sprintf(str, "raw%d", index);
      v.show_raw_value = atoi(p->xgetparam(str).c_str());
      
      sprintf(str, "factor%d", index);
      if (p->isparam(str)) {
         v.factor = atof(p->xgetparam(str).c_str());
      } else {
         v.factor = 1.0;
      }
      
      sprintf(str, "offset%d", index);
      v.offset = atof(p->xgetparam(str).c_str());
      
      sprintf(str, "voffset%d", index);
      v.voffset = atof(p->xgetparam(str).c_str());
      
      sprintf(str, "ord%d", index);
      if (p->isparam(str)) {
         v.order = atoi(p->xgetparam(str).c_str());
      } else {
         v.order = NextHistPlotOrder(*hp);
      }
 
      hp->vars.push_back(v);
   }
   
   /* correctly number newly added variables */
   for (size_t index=0; index<hp->vars.size(); index++) {
      if (hp->vars[index].order < 0)
         hp->vars[index].order = NextHistPlotOrder(*hp);
   }
   
//   printf("Load from param:\n");
//   PrintHistPlot(*hp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Lock()

void Lock

(

RequestTrace *

t

)

Definition at line 12240 of file mhttpd.cxx.

{
   gMutex.lock();
   t->fTimeLocked = GetTimeSec();
}

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		const char *	argv[]
	)

Definition at line 16210 of file mhttpd.cxx.

{
   int status;
   int daemon = FALSE;
#ifdef HAVE_MONGOOSE6
   int user_http_port = 0;
   int user_https_port = 0;
#endif
#ifdef HAVE_MONGOOSE616
   bool no_passwords = false;
   bool no_hostlist  = false;
#endif
   const char *myname = "mhttpd";
 
   setbuf(stdout, NULL);
   setbuf(stderr, NULL);
#ifdef SIGPIPE
   /* avoid getting killed by "Broken pipe" signals */
   signal(SIGPIPE, SIG_IGN);
#endif
 
#ifdef HAVE_MONGOOSE6
   //
   // if running setuid-root, unconditionally bind to port 80.
   //
 
   int socket_priviledged_port = -1;
 
#ifdef OS_UNIX
   // in setuid-root mode bind to priviledged port
   if (getuid() != geteuid()) {
      int port80 = 80;
 
      printf("mhttpd is running in setuid-root mode.\n");
 
      socket_priviledged_port = open_listening_socket(port80);
      if (socket_priviledged_port < 0) {
         printf("Cannot open listening socket on TCP port %d, aborting.\n", port80);
         exit(1);
      }
 
      // give up root privilege
      status = setuid(getuid());
      if (status != 0) {
         printf("Cannot give up root privelege, aborting.\n");
         exit(1);
      }
      status = setuid(getuid());
      if (status != 0) {
         printf("Cannot give up root privelege, aborting.\n");
         exit(1);
      }
   }
#endif
#endif
 
   char midas_hostname[256];
   char midas_expt[256];
 
   /* get default from environment */
   cm_get_environment(midas_hostname, sizeof(midas_hostname), midas_expt, sizeof(midas_expt));
 
   /* parse command line parameters */
#ifdef HAVE_MONGOOSE6
   gUserAllowedHosts.clear();
#else
   std::vector<std::string> user_hostlist;
#endif
   for (int i = 1; i < argc; i++) {
      if (argv[i][0] == '-' && argv[i][1] == 'D')
         daemon = TRUE;
      else if (argv[i][0] == '-' && argv[i][1] == 'v')
         verbose = TRUE;
      else if (argv[i][0] == '-' && argv[i][1] == 'E')
         elog_mode = TRUE;
      else if (argv[i][0] == '-' && argv[i][1] == 'H') {
         history_mode = TRUE;
#ifdef HAVE_MONGOOSE6
      } else if (strcmp(argv[i], "--http") == 0) {
         if (argv[i+1]) {
            user_http_port = atoi(argv[i+1]);
         }
      } else if (strcmp(argv[i], "--https") == 0) {
         if (argv[i+1]) {
            user_https_port = atoi(argv[i+1]);
         }
#endif
      } else if (strcmp(argv[i], "--trace-mg") == 0) {
         trace_mg = true;
         trace_mg_recv = true;
         trace_mg_send = true;
      } else if (strcmp(argv[i], "--no-trace-mg-recv") == 0) {
         trace_mg_recv = false;
      } else if (strcmp(argv[i], "--no-trace-mg-send") == 0) {
         trace_mg_send = false;
      } else if (strcmp(argv[i], "--verbose-mg") == 0) {
         verbose_mg = true;
#ifdef HAVE_MONGOOSE616
      } else if (strcmp(argv[i], "--no-multithread") == 0) {
         multithread_mg = false;
      } else if (strcmp(argv[i], "--no-passwords") == 0) {
         no_passwords = true;
      } else if (strcmp(argv[i], "--no-hostlist") == 0) {
         no_hostlist = true;
#endif
      } else if (argv[i][0] == '-') {
         if (i + 1 >= argc || argv[i + 1][0] == '-')
            goto usage;
         if (argv[i][1] == 'h')
            mstrlcpy(midas_hostname, argv[++i], sizeof(midas_hostname));
         else if (argv[i][1] == 'e')
            mstrlcpy(midas_expt, argv[++i], sizeof(midas_hostname));
         else if (argv[i][1] == 'a') {
#ifdef HAVE_MONGOOSE6
            gUserAllowedHosts.push_back(argv[++i]);
#else
            user_hostlist.push_back(argv[++i]);
#endif
         } else if (argv[i][1] == 'p') {
            printf("Option \"-p port_number\" for the old web server is obsolete.\n");
            printf("mongoose web server is the new default, port number is set in ODB or with \"--http port_number\".\n");
            printf("To run the obsolete old web server, please use \"--oldserver\" switch.\n");
            return 1;
         } else {
          usage:
            printf("usage: %s [-h Hostname[:port]] [-e Experiment] [-v] [-D] [-a Hostname]\n\n", argv[0]);
            printf("       -a add hostname to the hostlist of hosts allowed to connect to mhttpd\n");
            printf("       -e experiment to connect to\n");
            printf("       -h connect to midas server (mserver) on given host\n");
            printf("       -v display verbose HTTP communication\n");
            printf("       -D become a daemon\n");
            printf("       -E only display ELog system\n");
            printf("       -H only display history plots\n");
#ifdef HAVE_MONGOOSE6
            printf("       --http port - bind to specified HTTP port (default is ODB \"/Experiment/midas http port\")\n");
            printf("       --https port - bind to specified HTTP port (default is ODB \"/Experiment/midas https port\")\n");
#endif
            printf("       --verbose-mg - trace mongoose web requests\n");
            printf("       --trace-mg - trace mongoose events\n");
            printf("       --no-trace-mg-recv - do not trace mongoose recv events\n");
            printf("       --no-trace-mg-send - dop not trace mongoose send events\n");
#ifdef HAVE_MONGOOSE616
            printf("       --no-multithread - disable mongoose multithreading\n");
            printf("       --no-passwords - disable password protection\n");
            printf("       --no-hostlist - disable access control host list\n");
#endif
            return 0;
         }
      }
   }
 
   if (daemon) {
      printf("Becoming a daemon...\n");
      ss_daemon_init(FALSE);
   }
 
#ifdef OS_LINUX
   /* write PID file */
   FILE *f = fopen("/var/run/mhttpd.pid", "w");
   if (f != NULL) {
      fprintf(f, "%d", ss_getpid());
      fclose(f);
   }
#endif
 
   if (history_mode)
      myname = "mhttpd_history";
 
   /*---- connect to experiment ----*/
   status = cm_connect_experiment1(midas_hostname, midas_expt, myname, NULL,
                                   DEFAULT_ODB_SIZE, DEFAULT_WATCHDOG_TIMEOUT);
   if (status == CM_WRONG_PASSWORD)
      return 1;
   else if (status == DB_INVALID_HANDLE) {
      std::string s = cm_get_error(status);
      puts(s.c_str());
   } else if (status != CM_SUCCESS) {
      std::string s = cm_get_error(status);
      puts(s.c_str());
      return 1;
   }
 
   /* mhttpd needs the watchdog thread until we are sure
    * we do not have any long sleeps anywhere in the mhttpd code.
    * this includes reads from the history files or databases,
    * that can take arbitrary long time */
   cm_start_watchdog_thread();
 
   /* Get ODB handles */
 
   HNDLE hDB;
 
   cm_get_experiment_database(&hDB, NULL);
 
   MVOdb *odb = MakeMidasOdb(hDB);
   gOdb = odb;
 
   /* do ODB record checking */
   if (!check_odb_records(odb)) {
      // check_odb_records() fails with nothing printed to the terminal
      // because mhttpd does not print cm_msg(MERROR, ...) messages to the terminal.
      // At least print something!
      printf("check_odb_records() failed, see messages and midas.log, bye!\n");
      cm_disconnect_experiment();
      return 1;
   }
 
#ifdef HAVE_MONGOOSE6
   if (init_allowed_hosts() != SUCCESS) {
      printf("init_allowed_hosts() failed, see messages and midas.log, bye!\n");
      cm_disconnect_experiment();
      return 1;
   }
 
   if (verbose) {
      if (gAllowedHosts.size() > 0) {
         printf("mhttpd allowed hosts list: ");
         for (unsigned int i=0; i<gAllowedHosts.size(); i++) {
            if (i>0)
               printf(", ");
            printf("%s", gAllowedHosts[i].c_str());
         }
         printf("\n");
      } else {
         printf("mhttpd allowed hosts list is empty\n");
      }
   }
 
   // populate the MIME.types table
   SaveMimetypes(odb->Chdir("WebServer/mime.types", true));
#endif
 
   /* initialize odb entries needed for mhttpd and midas web pages */
   init_mhttpd_odb(odb);
 
   /* initialize menu buttons */
   init_menu_buttons(odb);
 
   /* initialize elog odb entries */
   init_elog_odb();
 
   /* initialize the JSON RPC handlers */
   mjsonrpc_init();
   mjsonrpc_set_std_mutex(&gMutex);
 
   add_rpc_functions();
 
#ifdef HAVE_MONGOOSE6
   status = start_mg(user_http_port, user_https_port, socket_priviledged_port, verbose);
   if (status != SUCCESS) {
      // At least print something!
      printf("could not start the mongoose web server, see messages and midas.log, bye!\n");
      cm_disconnect_experiment();
      return 1;
   }
#endif
   
#ifdef HAVE_MONGOOSE616
 
#ifdef SIGPIPE
#ifdef SIG_IGN
   signal(SIGPIPE, SIG_IGN);
#endif
#endif
 
   if (!gTraceBuf) {
      gTraceBuf = new RequestTraceBuf;
   }
 
   //if (!request_mutex) {
   //   status = ss_mutex_create(&request_mutex, FALSE);
   //   assert(status==SS_SUCCESS || status==SS_CREATED);
   //}
 
   /* establish Ctrl-C handler - will set _abort to TRUE */
   ss_ctrlc_handler(ctrlc_handler);
 
   MVOdb* o = odb->Chdir("WebServer", true);
   status = mongoose_init(o, no_passwords, no_hostlist, user_hostlist);
   if (status != SUCCESS) {
      // At least print something!
      printf("Error: Could not start the mongoose web server, see messages and midas.log, bye!\n");
      cm_disconnect_experiment();
      return 1;
   }
 
   delete o;
#endif
 
#ifdef HAVE_MONGOOSE6
   loop_mg();
   stop_mg();
#endif
 
#ifdef HAVE_MONGOOSE616
   while (!_abort) {
 
      /* cm_yield() is not thread safe, need to take a lock */
 
      //status = ss_mutex_wait_for(request_mutex, 0);
      gMutex.lock();
 
      /* check for shutdown message */
      status = cm_yield(0);
      if (status == RPC_SHUTDOWN)
         break;
 
      gMutex.unlock();
      //status = ss_mutex_release(request_mutex);
 
      //ss_sleep(10);
 
      mongoose_poll(10);
   }
 
   mongoose_cleanup();
#endif
 
   if (gMh) {
      delete gMh;
      gMh = NULL;
      gMhkey = 0;
   }
 
   mjsonrpc_exit();
   cm_disconnect_experiment();
   return 0;
}

Here is the call graph for this function:

mgstr()

static std::string mgstr ( const mg_str *  s )

static

Definition at line 14136 of file mhttpd.cxx.

{
   return std::string(s->p, s->len);
}

Here is the caller graph for this function:

mhttpd_revision()

const char * mhttpd_revision

(

void

)

Definition at line 834 of file mhttpd.cxx.

{
   return cm_get_revision();
}

Here is the call graph for this function:

Here is the caller graph for this function:

mktime_with_dst()

time_t mktime_with_dst

(

const struct tm *

ptms

)

Definition at line 9745 of file mhttpd.cxx.

{
   // this silly stuff is required to correctly handle daylight savings time (Summer time/Winter time)
   // when we fill "struct tm" from user input, we cannot know if daylight savings time is in effect
   // and we do not know how to initialize the value of tms.tm_isdst.
   // This can cause the output of mktime() to be off by one hour.
   // (Rules for daylight savings time are set by national and local govt and in some locations, changes yearly)
   // (There are no locations with 2 hour or half-hour daylight savings that I know of)
   // (Yes, "man mktime" talks about using "tms.tm_isdst = -1")
   //
   // We assume the user is using local time and we convert in two steps:
   //
   // first we convert "struct tm" to "time_t" using mktime() with unknown tm_isdst
   // second we convert "time_t" back to "struct tm" using localtime_r()
   // this fills "tm_isdst" with correct value from the system time zone database
   // then we reset all the time fields (except for sub-minute fields not affected by daylight savings)
   // and call mktime() again, now with the correct value of "tm_isdst".
   // K.O. 2013-09-14
 
   struct tm tms = *ptms;
   struct tm tms2;
   time_t t1 = ss_mktime(&tms);
   localtime_r(&t1, &tms2);
   tms2.tm_year = ptms->tm_year;
   tms2.tm_mon  = ptms->tm_mon;
   tms2.tm_mday = ptms->tm_mday;
   tms2.tm_hour = ptms->tm_hour;
   tms2.tm_min  = ptms->tm_min;
   time_t t2 = ss_mktime(&tms2);
   //printf("t1 %.0f, t2 %.0f, diff %d\n", (double)t1, (double)t2, (int)(t1-t2));
   return t2;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mongoose_passwords_enabled()

static bool mongoose_passwords_enabled ( const struct mg_connection *  nc )

static

Here is the caller graph for this function:

NextHistPlotColour()

static std::string NextHistPlotColour ( const HistPlot &  hp )

static

Definition at line 10116 of file mhttpd.cxx.

{
   const char* const colour[] =
      {
       "#00AAFF", "#FF9000", "#FF00A0", "#00C030",
       "#A0C0D0", "#D0A060", "#C04010", "#807060",
       "#F0C000", "#2090A0", "#D040D0", "#90B000",
       "#B0B040", "#B0B0FF", "#FFA0A0", "#A0FFA0",
       NULL };
 
   for (int i=0; colour[i]; i++) {
      bool in_use = false;
      
      for (size_t j=0; j<hp.vars.size(); j++)
         if (hp.vars[j].colour == colour[i]) {
            in_use = true;
            break;
         }
      
      if (!in_use)
         return colour[i];
   }
   
   return "#808080";
}

Here is the call graph for this function:

Here is the caller graph for this function:

NextHistPlotOrder()

static int NextHistPlotOrder ( const HistPlot &  hp )

static

Definition at line 10142 of file mhttpd.cxx.

{
   int order = 0;
   for (size_t i=0; i<hp.vars.size(); i++)
      if (hp.vars[i].order > order)
         order = hp.vars[i].order;
   return order + 10;
}

Here is the call graph for this function:

Here is the caller graph for this function:

open_resource_file()

bool open_resource_file	(	const char *	filename,
		std::string *	ppath,
		FILE **	pfp
	)

Definition at line 1029 of file mhttpd.cxx.

{
   // resource file names should not start with a directory separator "/"
   // or contain ".." as this will allow them to escape the mhttpd filename "jail"
   // by asking file files names like "../../etc/passwd", etc.
 
   if (strlen(filename) < 1) {
      cm_msg(MERROR, "open_resource_file", "Invalid resource file name \'%s\' is too short",
              filename);
      return false;
   }
 
   if (filename[0] == DIR_SEPARATOR) {
      cm_msg(MERROR, "open_resource_file", "Invalid resource file name \'%s\' starting with \'%c\' which is not allowed",
              filename, DIR_SEPARATOR);
      return false;
   }
 
   if (strstr(filename, "..") != NULL) {
      cm_msg(MERROR, "open_resource_file", "Invalid resource file name \'%s\' containing \'..\' which is not allowed",
             filename);
      return false;
   }
 
   std::vector<std::string> paths = get_resource_paths();
 
   std::vector<std::string> paths_not_found;
 
   for (unsigned i=0; i<paths.size(); i++) {
      std::string path = paths[i];
      if (path.length() < 1)
         continue;
      if (path[0] == '#')
         continue;
 
      // expand env.variables before we add the filename.
      // the filename comes from the URL and if the URL
      // has '$' characters we will try to expand them
      // as an env.variable and maybe escape the file jail.
 
      std::string xpath = cm_expand_env(path.c_str());
 
      if (xpath[xpath.length()-1] != DIR_SEPARATOR)
         xpath += DIR_SEPARATOR_STR;
      xpath += filename;
 
      //printf("path [%s] [%s] [%s]\n", paths[i].c_str(), path.c_str(), xpath.c_str());
 
      FILE* fp = fopen(xpath.c_str(), "r");
      if (fp) {
         struct stat statbuf;
         int status = fstat(fileno(fp), &statbuf);
         if (status != 0) {
            cm_msg(MERROR, "open_resource_file", "Cannot fstat() file \'%s\', error %d (%s)", xpath.c_str(), errno, strerror(errno));
            fclose(fp);
            fp = NULL;
         }
 
         if (statbuf.st_mode & S_IFREG) {
            // good, normal file
            //printf("%s: regular!\n", xpath.c_str());
         //} else if (statbuf.st_mode & S_IFLNK) {
            // symlink
            //printf("%s: symlink!\n", xpath.c_str());
         } else if (statbuf.st_mode & S_IFDIR) {
            cm_msg(MERROR, "open_resource_file", "File \'%s\' for resource \'%s\' is a directory", xpath.c_str(), filename);
            fclose(fp);
            fp = NULL;
         } else {
            cm_msg(MERROR, "open_resource_file", "File \'%s\' for resource \'%s\' is not a regular file, st_mode is 0x%08x", xpath.c_str(), filename, statbuf.st_mode);
            fclose(fp);
            fp = NULL;
         }
 
         if (fp) {
            if (ppath)
               *ppath = xpath;
            if (pfp) {
               *pfp = fp;
            } else {
               fclose(fp);
               fp = NULL;
            }
            //cm_msg(MINFO, "open_resource_file", "Resource file \'%s\' is \'%s\'", filename, xpath.c_str());
            return true;
         }
      }
 
      paths_not_found.push_back(xpath);
   }
 
   std::string s;
   for (unsigned i=0; i<paths_not_found.size(); i++) {
      if (i>0)
         s += ", ";
      s += paths_not_found[i];
   }
 
   cm_msg(MERROR, "open_resource_file", "Cannot find resource file \'%s\', tried %s", filename, s.c_str());
   return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

output_key()

void output_key	(	Param *	p,
		Return *	r,
		HNDLE	hkey,
		int	index,
		const char *	format
	)

Definition at line 4368 of file mhttpd.cxx.

{
   int size, i;
   HNDLE hDB, hsubkey;
   KEY key;
   char data[TEXT_SIZE];
 
   cm_get_experiment_database(&hDB, NULL);
 
   db_get_key(hDB, hkey, &key);
   if (key.type == TID_KEY) {
      for (i=0 ; ; i++) {
         db_enum_key(hDB, hkey, i, &hsubkey);
         if (!hsubkey)
            break;
         output_key(p, r, hsubkey, -1, format);
      }
   } else {
      if (key.item_size <= (int)sizeof(data)) {
         size = sizeof(data);
         db_get_data(hDB, hkey, data, &size, key.type);
         if (index == -1) {
            for (i=0 ; i<key.num_values ; i++) {
               if (p->isparam("name") && atoi(p->getparam("name")) == 1) {
                  if (key.num_values == 1)
                     r->rsprintf("%s:", key.name);
                  else
                     r->rsprintf("%s[%d]:", key.name, i);
               }
               std::string data_str;
               if (format && format[0])
                  data_str = db_sprintff(format, data, key.item_size, i, key.type);
               else
                  data_str = db_sprintf(data, key.item_size, i, key.type);
               r->rsputs(data_str.c_str());
               if (i<key.num_values-1)
                  r->rsputs("\n");
            }
         } else {
            if (p->isparam("name") && atoi(p->getparam("name")) == 1)
               r->rsprintf("%s[%d]:", key.name, index);
            if (index >= key.num_values)
               r->rsputs("<DB_OUT_OF_RANGE>");
            else {
               std::string data_str;
               if (p->isparam("format"))
                  data_str = db_sprintff(p->getparam("format"), data, key.item_size, index, key.type);
               else
                  data_str = db_sprintf(data, key.item_size, index, key.type);
               r->rsputs(data_str.c_str());
            }
         }
         r->rsputs("\n");
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PrintHistPlot()

static void PrintHistPlot ( const HistPlot &  hp )

static

Definition at line 10106 of file mhttpd.cxx.

{
   printf("hist plot: %d variables\n", (int)hp.vars.size());
   printf("timescale: %s, minimum: %f, maximum: %f, zero_ylow: %d, log_axis: %d, show_run_markers: %d, show_values: %d, show_fill: %d, show_factor %d, enable_factor: %d\n", hp.timescale.c_str(), hp.minimum, hp.maximum, hp.zero_ylow, hp.log_axis, hp.show_run_markers, hp.show_values, hp.show_fill, hp.show_factor, hp.enable_factor);
   
   for (size_t i=0; i<hp.vars.size(); i++) {
      printf("var[%d] event [%s][%s] formula [%s], colour [%s] label [%s] show_raw_value %d factor %f offset %f voffset %f order %d\n", (int)i, hp.vars[i].event_name.c_str(), hp.vars[i].tag_name.c_str(), hp.vars[i].formula.c_str(), hp.vars[i].colour.c_str(), hp.vars[i].label.c_str(), hp.vars[i].show_raw_value, hp.vars[i].factor, hp.vars[i].offset , hp.vars[i].voffset, hp.vars[i].order);
   }
}

Here is the call graph for this function:

read_history()

int read_history	(	const HistPlot &	hp,
		int	index,
		int	flags,
		time_t	tstart,
		time_t	tend,
		time_t	scale,
		HistoryData *	data
	)

Definition at line 8356 of file mhttpd.cxx.

{
   //HNDLE hkeypanel, hkeydvar, hkey;
   //KEY key;
   //char path[256];
   //int n_vars;
   int status;
   int debug = 1;
 
   //mstrlcpy(path, group, sizeof(path));
   //mstrlcat(path, "/", sizeof(path));
   //mstrlcat(path, panel, sizeof(path));
 
   //printf("read_history, path %s, index %d, flags 0x%x, start %d, end %d, scale %d, data %p\n", path, index, flags, (int)tstart, (int)tend, (int)scale, data);
 
   /* connect to history */
   MidasHistoryInterface* mh = get_history();
   if (mh == NULL) {
      //r->rsprintf(str, "History is not configured\n");
      return HS_FILE_ERROR;
   }
 
#if 0
   /* check panel name in ODB */
   status = db_find_key(hDB, 0, "/History/Display", &hkey);
   if (!hkey) {
      cm_msg(MERROR, "read_history", "Cannot find \'/History/Display\' in ODB, status %d", status);
      return HS_FILE_ERROR;
   }
 
   /* check panel name in ODB */
   status = db_find_key(hDB, hkey, path, &hkeypanel);
   if (!hkeypanel) {
      cm_msg(MERROR, "read_history", "Cannot find \'%s\' in ODB, status %d", path, status);
      return HS_FILE_ERROR;
   }
 
   status = db_find_key(hDB, hkeypanel, "Variables", &hkeydvar);
   if (!hkeydvar) {
      cm_msg(MERROR, "read_history", "Cannot find \'%s/Variables\' in ODB, status %d", path, status);
      return HS_FILE_ERROR;
   }
 
   db_get_key(hDB, hkeydvar, &key);
   n_vars = key.num_values;
#endif
 
   data->Allocate(hp.vars.size()+2);
 
   data->tstart = tstart;
   data->tend = tend;
   data->scale = scale;
 
   for (size_t i=0; i<hp.vars.size(); i++) {
      if (index != -1 && (size_t)index != i)
         continue;
 
      //char str[256];
      //int size = sizeof(str);
      //status = db_get_data_index(hDB, hkeydvar, str, &size, i, TID_STRING);
      //if (status != DB_SUCCESS) {
      //   cm_msg(MERROR, "read_history", "Cannot read tag %d in panel %s, status %d", i, path, status);
      //   continue;
      //}
 
      /* split varname in event, variable and index: "event/tag[index]" */
 
      //char *p = strchr(str, ':');
      //if (!p)
         //   p = strchr(str, '/');
      //
      //if (!p) {
      //   cm_msg(MERROR, "read_history", "Tag \"%s\" has wrong format in panel \"%s\"", str, path);
      //   continue;
      //}
 
      //*p = 0;
 
      data->odb_index[data->nvars] = i;
      data->event_names[data->nvars] = STRDUP(hp.vars[i].event_name.c_str());
      data->var_names[data->nvars] = STRDUP(hp.vars[i].tag_name.c_str());
      data->var_index[data->nvars] = 0;
 
      char *q = strchr(data->var_names[data->nvars], '[');
      if (q) {
         data->var_index[data->nvars] = atoi(q+1);
         *q = 0;
      }
 
      data->nvars++;
   } // loop over variables
 
   /* write run markes if selected */
   if (flags & READ_HISTORY_RUNMARKER) {
 
      data->event_names[data->nvars+0] = STRDUP("Run transitions");
      data->event_names[data->nvars+1] = STRDUP("Run transitions");
 
      data->var_names[data->nvars+0] = STRDUP("State");
      data->var_names[data->nvars+1] = STRDUP("Run number");
 
      data->var_index[data->nvars+0] = 0;
      data->var_index[data->nvars+1] = 0;
 
      data->odb_index[data->nvars+0] = -1;
      data->odb_index[data->nvars+1] = -2;
 
      data->nvars += 2;
   }
 
   bool get_last_written = false;
 
   if (flags & READ_HISTORY_DATA) {
      status = mh->hs_read(tstart, tend, scale,
                           data->nvars,
                           data->event_names,
                           data->var_names,
                           data->var_index,
                           data->num_entries,
                           data->t,
                           data->v,
                           data->status);
 
      if (debug) {
         printf("read_history: nvars %d, hs_read() status %d\n", data->nvars, status);
         for (int i=0; i<data->nvars; i++) {
            printf("read_history: %d: event [%s], var [%s], index %d, odb index %d, status %d, num_entries %d\n", i, data->event_names[i], data->var_names[i], data->var_index[i], data->odb_index[i], data->status[i], data->num_entries[i]);
         }
      }
 
      if (status != HS_SUCCESS) {
         cm_msg(MERROR, "read_history", "Complete history failure, hs_read() status %d, see messages", status);
         return HS_FILE_ERROR;
      }
 
      for (int i=0; i<data->nvars; i++) {
         if (data->status[i] != HS_SUCCESS || data->num_entries[i] < 1) {
            get_last_written = true;
            break;
         }
      }
   }
 
   if (flags & READ_HISTORY_LAST_WRITTEN)
      get_last_written = true;
 
   if (get_last_written) {
      data->have_last_written = true;
 
      status = mh->hs_get_last_written(
                           tstart,
                           data->nvars,
                           data->event_names,
                           data->var_names,
                           data->var_index,
                           data->last_written);
 
      if (status != HS_SUCCESS) {
         data->have_last_written = false;
      }
   }
 
   return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

read_passwords()

static bool read_passwords ( Auth *  auth )

static

Definition at line 13796 of file mhttpd.cxx.

{
   std::string path;
   FILE *fp;
   int status = find_file_mg("htpasswd.txt", path, &fp, trace_mg||verbose_mg);
 
   auth->passwd_filename = path;
   auth->passwords.clear();
 
   if (status != SUCCESS || fp == NULL) {
      cm_msg(MERROR, "mongoose", "mongoose web server cannot find password file \"%s\"", path.c_str());
      cm_msg(MERROR, "mongoose", "please create password file: touch %s", path.c_str());
      return false;
   }
 
   bool have_realm = false;
   char buf[256];
 
   /*
    * Read passwords file line by line. If should have htdigest format,
    * i.e. each line should be a colon-separated sequence:
    * USER_NAME:DOMAIN_NAME:HA1_HASH_OF_USER_DOMAIN_AND_PASSWORD
    */
   while (fgets(buf, sizeof(buf), fp) != NULL) {
      char f_user[256];
      char f_domain[256];
      char f_ha1[256];
 
      if (sscanf(buf, "%[^:]:%[^:]:%s", f_user, f_domain, f_ha1) == 3) {
         AuthEntry e;
         e.realm = f_domain;
         e.username = f_user;
         e.password = f_ha1;
 
         if (e.realm == auth->realm) {
            have_realm = true;
            auth->passwords.push_back(e);
         }
      }
   }
 
   fclose(fp);
 
   return have_realm;
}

Here is the call graph for this function:

Here is the caller graph for this function:

redirect()

void redirect	(	Return *	r,
		const char *	path
	)

Definition at line 1407 of file mhttpd.cxx.

{
   char str[256];
 
   //printf("redirect to [%s]\n", path);
 
   mstrlcpy(str, path, sizeof(str));
   if (str[0] == 0)
      strcpy(str, "./");
 
   /* redirect */
   r->rsprintf("HTTP/1.1 302 Found\r\n");
   r->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
   r->rsprintf("Content-Type: text/html; charset=%s\r\n", HTTP_ENCODING);
 
   if (strncmp(path, "http:", 5) == 0)
      r->rsprintf("Location: %s\r\n\r\n<html>redir</html>\r\n", str);
   else if (strncmp(path, "https:", 6) == 0)
      r->rsprintf("Location: %s\r\n\r\n<html>redir</html>\r\n", str);
   else {
      r->rsprintf("Location: %s\r\n\r\n<html>redir</html>\r\n", str);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

redirect2()

void redirect2	(	Return *	r,
		const char *	path
	)

Definition at line 1444 of file mhttpd.cxx.

{
   redirect(r, path);
}

Here is the call graph for this function:

Here is the caller graph for this function:

redirect_307()

void redirect_307	(	Return *	r,
		const char *	path
	)

Definition at line 1431 of file mhttpd.cxx.

{
   //printf("redirect_307 to [%s]\n", path);
 
   /* redirect */
   r->rsprintf("HTTP/1.1 307 Temporary Redirect\r\n");
   r->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
   r->rsprintf("Content-Type: text/html; charset=%s\r\n", HTTP_ENCODING);
   r->rsprintf("Location: %s\r\n", path);
   r->rsprintf("\r\n");
   r->rsprintf("<html>redirect to %s</html>\r\n", path);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SaveHistPlotToOdb()

static void SaveHistPlotToOdb ( MVOdb *  odb, const HistPlot &  hp, const char *  group, const char *  panel  )

static

Definition at line 10405 of file mhttpd.cxx.

{
   if (strlen(group) < 1) {
      cm_msg(MERROR, "SaveHistPlotToOdb", "Error: Cannot write history plot to ODB, group \"%s\", panel \"%s\", invalid group name", group, panel);
      return;
   }
 
   if (strlen(panel) < 1) {
      cm_msg(MERROR, "SaveHistPlotToOdb", "Error: Cannot write history plot to ODB, group \"%s\", panel \"%s\", invalid panel name", group, panel);
      return;
   }
   
   std::string path = "History/Display/";
   path += group;
   path += "/";
   path += panel;
 
//   printf("Save to ODB %s: ", path.c_str());
//   PrintHistPlot(hp);
 
   MVOdb* o = odb->Chdir(path.c_str(), true);
   
   o->WS("Timescale", hp.timescale.c_str());
   o->WD("Minimum", hp.minimum);
   o->WD("Maximum", hp.maximum);
   o->WB("Zero ylow", hp.zero_ylow);
   o->WB("Log axis", hp.log_axis);
   o->WB("Show run markers", hp.show_run_markers);
   o->WB("Show values", hp.show_values);
   o->WB("Show fill", hp.show_fill);
   o->WB("Show factor and offset", hp.show_factor);
   //o->WB("Enable factor and offset", hp.enable_factor);
 
   std::vector<std::string> hist_vars;
   std::vector<std::string> hist_formula;
   std::vector<std::string> hist_colour;
   std::vector<std::string> hist_label;
   std::vector<bool>        hist_show_raw_value;
   std::vector<double> hist_factor;
   std::vector<double> hist_offset;
   std::vector<double> hist_voffset;
 
   for (size_t i=0; i<hp.vars.size(); i++) {
      hist_vars.push_back(hp.vars[i].event_name + ":" + hp.vars[i].tag_name);
      hist_formula.push_back(hp.vars[i].formula);
      hist_colour.push_back(hp.vars[i].colour);
      hist_label.push_back(hp.vars[i].label);
      hist_show_raw_value.push_back(hp.vars[i].show_raw_value);
      hist_factor.push_back(hp.vars[i].factor);
      hist_offset.push_back(hp.vars[i].offset);
      hist_voffset.push_back(hp.vars[i].voffset);
   }
 
   if (hp.vars.size() > 0) {
      o->WSA("Variables", hist_vars, 64);
      o->WSA("Formula",   hist_formula, 64);
      o->WSA("Colour",    hist_colour, NAME_LENGTH);
      o->WSA("Label",     hist_label, NAME_LENGTH);
      o->WBA("Show raw value", hist_show_raw_value);
      o->WDA("Factor",    hist_factor);
      o->WDA("Offset",    hist_offset);
      o->WDA("VOffset",   hist_voffset);
   } else {
      o->Delete("Variables");
      o->Delete("Formula");
      o->Delete("Colour");
      o->Delete("Label");
      o->Delete("Show raw value");
      o->Delete("Factor");
      o->Delete("Offset");
      o->Delete("VOffset");
   }
 
   delete o;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SaveMimetypes()

static void SaveMimetypes ( MVOdb *  odb )

static

Definition at line 201 of file mhttpd.cxx.

{
   gMimeTypesOdb = odb;
 
   for (int i=0; gMimetypeTable[i].ext.length() > 0; i++) {
      std::string tmp = gMimetypeTable[i].mimetype;
      gMimeTypesOdb->RS(gMimetypeTable[i].ext.c_str(), &tmp, true);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

search_callback()

INT search_callback	(	HNDLE	hDB,
		HNDLE	hKey,
		KEY *	key,
		INT	level,
		void *	info
	)

Definition at line 1457 of file mhttpd.cxx.

{
   search_data* sinfo = (search_data*)info;
   int i;
   INT size, status;
 
   Return* r = sinfo->r;
   const char* search_name = sinfo->search_name;
 
   /* convert strings to uppercase */
 
   char xstr1[MAX_ODB_PATH];
   for (i = 0; key->name[i]; i++)
      xstr1[i] = toupper(key->name[i]);
   xstr1[i] = 0;
 
   char str2[MAX_ODB_PATH];
   for (i = 0; search_name[i] ; i++)
      str2[i] = toupper(search_name[i]);
   str2[i] = 0;
 
   if (strstr(xstr1, str2) != NULL) {
      char data[10000];
      std::string path = db_get_path(hDB, hKey).substr(1);
      std::string path_encoded = urlEncode(path.c_str());
 
      if (key->type == TID_KEY || key->type == TID_LINK) {
         /* for keys, don't display data value */
         r->rsprintf("<tr><td class=\"ODBkey\"><a href=\"?cmd=odb&odb_path=/%s\">/%s</a></tr>\n", path_encoded.c_str(), path.c_str());
      } else {
         /* strip variable name from path */
         char* p = const_cast<char *>(path.data() + path.length() - 1);
         while (*p && *p != '/')
            *p-- = 0;
         if (*p == '/')
            *p = 0;
 
         /* display single value */
         if (key->num_values == 1) {
            size = sizeof(data);
            status = db_get_data(hDB, hKey, data, &size, key->type);
            std::string data_str;
            if (status == DB_NO_ACCESS)
               data_str = "<no read access>";
            else
               data_str = db_sprintf(data, key->item_size, 0, key->type);
 
            r->rsprintf("<tr><td class=\"ODBkey\">");
            r->rsprintf("<a href=\"?cmd=odb&odb_path=/%s\">/%s/%s</a></td>", path_encoded.c_str(), path.c_str(), key->name);
            r->rsprintf("<td class=\"ODBvalue\">%s</td></tr>\n", data_str.c_str());
         } else {
            /* display first value */
            i = key->num_values;
            if (i > 10)
               i = 11;
            r->rsprintf("<tr><td rowspan=%d class=\"ODBkey\">", i);
            r->rsprintf("<a href=\"?cmd=odb&odb_path=/%s\">/%s/%s\n", path_encoded.c_str(), path.c_str(), key->name);
 
            for (int i = 0; i < key->num_values; i++) {
               size = sizeof(data);
               db_get_data_index(hDB, hKey, data, &size, i, key->type);
 
               std::string data_str = db_sprintf(data, key->item_size, 0, key->type);
 
               if (i > 0)
                  r->rsprintf("<tr>");
 
               r->rsprintf("<td class=\"ODBvalue\">[%d] %s</td></tr>\n", i, data_str.c_str());
 
               if (i > 8) {
                  r->rsprintf("<tr><td class=\"ODBvalue\">... [%d] values ...</td></tr>\n", key->num_values - i - 1);
                  break;
               }
            }
         }
      }
   }
 
   return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

sec_to_label()

void sec_to_label	(	char *	result,
		int	sec,
		int	base,
		int	force_date
	)

Definition at line 7750 of file mhttpd.cxx.

{
   char mon[80];
   time_t t_sec;
 
   t_sec = (time_t) sec;
 
   struct tm tms;
   localtime_r(&t_sec, &tms);
   strcpy(mon, mname[tms.tm_mon]);
   mon[3] = 0;
 
   if (force_date) {
      if (base < 600)
         sprintf(result, "%02d %s %02d %02d:%02d:%02d",
                 tms.tm_mday, mon, tms.tm_year % 100, tms.tm_hour, tms.tm_min,
                 tms.tm_sec);
      else if (base < 3600 * 24)
         sprintf(result, "%02d %s %02d %02d:%02d",
                 tms.tm_mday, mon, tms.tm_year % 100, tms.tm_hour, tms.tm_min);
      else
         sprintf(result, "%02d %s %02d", tms.tm_mday, mon, tms.tm_year % 100);
   } else {
      if (base < 600)
         sprintf(result, "%02d:%02d:%02d", tms.tm_hour, tms.tm_min, tms.tm_sec);
      else if (base < 3600 * 3)
         sprintf(result, "%02d:%02d", tms.tm_hour, tms.tm_min);
      else if (base < 3600 * 24)
         sprintf(result, "%02d %s %02d %02d:%02d",
                 tms.tm_mday, mon, tms.tm_year % 100, tms.tm_hour, tms.tm_min);
      else
         sprintf(result, "%02d %s %02d", tms.tm_mday, mon, tms.tm_year % 100);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

send_file()

bool send_file	(	Return *	r,
		const std::string &	path,
		bool	generate_404 = true
	)

Definition at line 1210 of file mhttpd.cxx.

{
   FILE *fp = fopen(path.c_str(), "rb");
 
   if (!fp) {
      if (generate_404) {
         /* header */
         r->rsprintf("HTTP/1.1 404 Not Found\r\n");
         r->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
         r->rsprintf("Content-Type: text/plain; charset=%s\r\n", HTTP_ENCODING);
         r->rsprintf("\r\n");
         r->rsprintf("Error: Cannot read \"%s\", fopen() errno %d (%s)\n", path.c_str(), errno, strerror(errno));
      }
      return false;
   }
 
   return send_fp(r, path, fp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

send_fp()

bool send_fp	(	Return *	r,
		const std::string &	path,
		FILE *	fp
	)

Definition at line 1164 of file mhttpd.cxx.

{
   assert(fp != NULL);
 
   // send HTTP headers
 
   r->rsprintf("HTTP/1.1 200 Document follows\r\n");
   r->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
   r->rsprintf("Accept-Ranges: bytes\r\n");
 
   // send HTTP cache control headers
 
   time_t now = time(NULL);
   now += (int) (3600 * 24);
   struct tm gmt_tms;
   gmtime_r(&now, &gmt_tms);
   const char* format = "%A, %d-%b-%y %H:%M:%S GMT";
 
   char str[256];
   strftime(str, sizeof(str), format, &gmt_tms);
   r->rsprintf("Expires: %s\r\n", str);
 
   // send Content-Type header
 
   r->rsprintf("Content-Type: %s\r\n", get_content_type(path.c_str()).c_str());
 
   // send Content-Length header
 
   struct stat stat_buf;
   fstat(fileno(fp), &stat_buf);
   int length = stat_buf.st_size;
   r->rsprintf("Content-Length: %d\r\n", length);
 
   // send end of headers
 
   r->rsprintf("\r\n");
 
   // send file data
 
   r->rread(path.c_str(), fileno(fp), length);
 
   fclose(fp);
 
   return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

send_icon()

void send_icon	(	Return *	r,
		const char *	icon
	)

Definition at line 12188 of file mhttpd.cxx.

{
   int length;
   const unsigned char *picon;
   char str[256], format[256];
   time_t now;
 
   if (strstr(icon, "favicon.ico") != 0) {
      length = sizeof(favicon_ico);
      picon = favicon_ico;
   } else if (strstr(icon, "favicon.png") != 0) {
      length = sizeof(favicon_png);
      picon = favicon_png;
   } else
      return;
 
   r->rsprintf("HTTP/1.1 200 Document follows\r\n");
   r->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
   r->rsprintf("Accept-Ranges: bytes\r\n");
 
   /* set expiration time to one day */
   time(&now);
   now += (int) (3600 * 24);
   struct tm gmt_tms;
   gmtime_r(&now, &gmt_tms);
   strcpy(format, "%A, %d-%b-%y %H:%M:%S GMT");
   strftime(str, sizeof(str), format, &gmt_tms);
   r->rsprintf("Expires: %s\r\n", str);
 
   if (equal_ustring(icon, "favicon.ico"))
      r->rsprintf("Content-Type: image/x-icon\r\n");
   else
      r->rsprintf("Content-Type: image/png\r\n");
 
   r->rsprintf("Content-Length: %d\r\n\r\n", length);
 
   r->rmemcpy(picon, length);
}

Here is the call graph for this function:

Here is the caller graph for this function:

send_resource()

bool send_resource	(	Return *	r,
		const std::string &	name,
		bool	generate_404 = true
	)

Definition at line 1229 of file mhttpd.cxx.

{
   std::string path;
   FILE *fp = NULL;
 
   bool found = open_resource_file(name.c_str(), &path, &fp);
 
   if (!found) {
      if (generate_404) {
         /* header */
         r->rsprintf("HTTP/1.1 404 Not Found\r\n");
         r->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
         r->rsprintf("Content-Type: text/plain; charset=%s\r\n", HTTP_ENCODING);
         r->rsprintf("\r\n");
         r->rsprintf("Error: resource file \"%s\" not found, see messages\n", name.c_str());
      }
      return false;
   }
 
   return send_fp(r, path, fp);
}

Here is the call graph for this function:

Here is the caller graph for this function:

sendmail()

INT sendmail	(	const char *	from_host,
		const char *	smtp_host,
		const char *	from,
		const char *	to,
		const char *	subject,
		const char *	text
	)

Definition at line 1253 of file mhttpd.cxx.

{
   struct sockaddr_in bind_addr;
   struct hostent *phe;
   int i, s, strsize, offset;
   char *str, buf[256];
 
   if (verbose)
      printf("\n\nEmail from %s to %s, SMTP host %s:\n", from, to, smtp_host);
 
   /* create a new socket for connecting to remote server */
   s = socket(AF_INET, SOCK_STREAM, 0);
   if (s == -1)
      return -1;
 
   /* connect to remote node port 25 */
   memset(&bind_addr, 0, sizeof(bind_addr));
   bind_addr.sin_family = AF_INET;
   bind_addr.sin_port = htons((short) 25);
 
   phe = gethostbyname(smtp_host);
   if (phe == NULL)
      return -1;
   memcpy((char *) &(bind_addr.sin_addr), phe->h_addr, phe->h_length);
 
   if (connect(s, (const sockaddr*)&bind_addr, sizeof(bind_addr)) < 0) {
      closesocket(s);
      return -1;
   }
 
   strsize = TEXT_SIZE + 1000;
   str = (char*)malloc(strsize);
 
   recv_string(s, str, strsize, 3000);
   if (verbose)
      puts(str);
 
   /* drain server messages */
   do {
      str[0] = 0;
      recv_string(s, str, strsize, 300);
      if (verbose)
         puts(str);
   } while (str[0]);
 
   sprintf(str, "HELO %s\r\n", from_host);
   send(s, str, strlen(str), 0);
   if (verbose)
      puts(str);
   recv_string(s, str, strsize, 3000);
   if (verbose)
      puts(str);
 
   if (strchr(from, '<')) {
      mstrlcpy(buf, strchr(from, '<') + 1, sizeof(buf));
      if (strchr(buf, '>'))
         *strchr(buf, '>') = 0;
   } else
      mstrlcpy(buf, from, sizeof(buf));
 
   sprintf(str, "MAIL FROM: %s\n", buf);
   send(s, str, strlen(str), 0);
   if (verbose)
      puts(str);
   recv_string(s, str, strsize, 3000);
   if (verbose)
      puts(str);
 
   sprintf(str, "RCPT TO: <%s>\r\n", to);
   send(s, str, strlen(str), 0);
   if (verbose)
      puts(str);
   recv_string(s, str, strsize, 3000);
   if (verbose)
      puts(str);
 
   sprintf(str, "DATA\r\n");
   send(s, str, strlen(str), 0);
   if (verbose)
      puts(str);
   recv_string(s, str, strsize, 3000);
   if (verbose)
      puts(str);
 
   sprintf(str, "To: %s\r\nFrom: %s\r\nSubject: %s\r\n", to, from, subject);
   send(s, str, strlen(str), 0);
   if (verbose)
      puts(str);
 
   sprintf(str, "X-Mailer: mhttpd revision %s\r\n", mhttpd_revision());
   send(s, str, strlen(str), 0);
   if (verbose)
      puts(str);
 
   ss_tzset(); // required for localtime_r()
   time_t now;
   time(&now);
   struct tm tms;
   localtime_r(&now, &tms);
   strftime(buf, sizeof(buf), "%a, %d %b %Y %H:%M:%S", &tms);
   offset = (-(int) timezone);
   if (tms.tm_isdst)
      offset += 3600;
   sprintf(str, "Date: %s %+03d%02d\r\n", buf, (int) (offset / 3600),
           (int) ((abs((int) offset) / 60) % 60));
   send(s, str, strlen(str), 0);
   if (verbose)
      puts(str);
 
   sprintf(str, "Content-Type: TEXT/PLAIN; charset=US-ASCII\r\n\r\n");
   send(s, str, strlen(str), 0);
   if (verbose)
      puts(str);
 
   /* analyze text for "." at beginning of line */
   const char* p = text;
   str[0] = 0;
   while (strstr(p, "\r\n.\r\n")) {
      i = (POINTER_T) strstr(p, "\r\n.\r\n") - (POINTER_T) p + 1;
      mstrlcat(str, p, i);
      p += i + 4;
      mstrlcat(str, "\r\n..\r\n", strsize);
   }
   mstrlcat(str, p, strsize);
   mstrlcat(str, "\r\n", strsize);
   send(s, str, strlen(str), 0);
   if (verbose)
      puts(str);
 
   /* send ".<CR>" to signal end of message */
   sprintf(str, ".\r\n");
   send(s, str, strlen(str), 0);
   if (verbose)
      puts(str);
   recv_string(s, str, strsize, 3000);
   if (verbose)
      puts(str);
 
   sprintf(str, "QUIT\n");
   send(s, str, strlen(str), 0);
   if (verbose)
      puts(str);
   recv_string(s, str, strsize, 3000);
   if (verbose)
      puts(str);
 
   closesocket(s);
   free(str);
 
   return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

set_http_trace()

static MJsonNode * set_http_trace ( const MJsonNode *  params )

static

Definition at line 16188 of file mhttpd.cxx.

{
   if (!params) {
      MJSO* doc = MJSO::I();
      doc->D("set new value of mhttpd http_trace");
      doc->P(NULL, MJSON_INT, "new value of http_trace");
      doc->R(NULL, MJSON_INT, "new value of http_trace");
      return doc;
   }
 
   http_trace = params->GetInt();
   return mjsonrpc_make_result("http_trace", MJsonNode::MakeInt(http_trace));
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_cnaf_page()

static void show_cnaf_page ( Param *  p, Return *  rr  )

static

Definition at line 5653 of file mhttpd.cxx.

{
   char str[256];
   int c, n, a, f, d, q, x, r, ia, id, w;
   int i, size, status;
   HNDLE hDB, hrootkey, hsubkey, hkey;
 
   static char client_name[NAME_LENGTH];
   static HNDLE hconn = 0;
 
   cm_get_experiment_database(&hDB, NULL);
 
   /* find FCNA server if not specified */
   if (hconn == 0) {
      /* find client which exports FCNA function */
      status = db_find_key(hDB, 0, "System/Clients", &hrootkey);
      if (status == DB_SUCCESS) {
         for (i = 0;; i++) {
            status = db_enum_key(hDB, hrootkey, i, &hsubkey);
            if (status == DB_NO_MORE_SUBKEYS)
               break;
 
            sprintf(str, "RPC/%d", RPC_CNAF16);
            status = db_find_key(hDB, hsubkey, str, &hkey);
            if (status == DB_SUCCESS) {
               size = sizeof(client_name);
               db_get_value(hDB, hsubkey, "Name", client_name, &size, TID_STRING, TRUE);
               break;
            }
         }
      }
 
      if (client_name[0]) {
         status = cm_connect_client(client_name, &hconn);
         if (status != RPC_SUCCESS)
            hconn = 0;
      }
   }
 
   /* header */
   rr->rsprintf("HTTP/1.1 200 Document follows\r\n");
   rr->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
   rr->rsprintf("Content-Type: text/html; charset=%s\r\n\r\n", HTTP_ENCODING);
 
   rr->rsprintf("<html><head>\n");
   rr->rsprintf("<link rel=\"icon\" href=\"favicon.png\" type=\"image/png\" />\n");
   rr->rsprintf("<link rel=\"stylesheet\" href=\"midas.css\" type=\"text/css\" />\n");
   rr->rsprintf("<link rel=\"stylesheet\" href=\"mhttpd.css\" type=\"text/css\" />\n");
   rr->rsprintf("<title>MIDAS CAMAC interface</title></head>\n");
   rr->rsprintf("<body><form method=\"GET\" action=\"CNAF\">\n\n");
 
   /* title row */
 
   size = sizeof(str);
   str[0] = 0;
   db_get_value(hDB, 0, "/Experiment/Name", str, &size, TID_STRING, TRUE);
 
   rr->rsprintf("<table border=3 cellpadding=1>\n");
   rr->rsprintf("<tr><th colspan=3>MIDAS experiment \"%s\"", str);
 
   if (client_name[0] == 0)
      rr->rsprintf("<th colspan=3 class=\"redLight\">No CAMAC server running</tr>\n");
   else if (hconn == 0)
      rr->rsprintf("<th colspan=3 class=\"redLight\">Cannot connect to %s</tr>\n", client_name);
   else
      rr->rsprintf("<th colspan=3>CAMAC server: %s</tr>\n", client_name);
 
   /* default values */
   c = n = 1;
   a = f = d = q = x = 0;
   r = 1;
   ia = id = w = 0;
 
   /*---- menu buttons ----*/
 
   rr->rsprintf("<tr><td colspan=3>\n");
   rr->rsprintf("<input type=submit name=cmd value=Execute>\n");
 
   rr->rsprintf("<td colspan=3>\n");
   rr->rsprintf("<input type=submit name=cmd value=ODB>\n");
   rr->rsprintf("<input type=submit name=cmd value=Status>\n");
   rr->rsprintf("<input type=submit name=cmd value=Help>\n");
   rr->rsprintf("</tr>\n\n");
 
   /* header */
   rr->rsprintf("<tr><th>N");
   rr->rsprintf("<th>A");
   rr->rsprintf("<th>F");
   rr->rsprintf("<th colspan=3>Data");
 
   /* execute commands */
   size = sizeof(d);
 
   const char* cmd = p->getparam("cmd");
   if (equal_ustring(cmd, "C cycle")) {
      rpc_client_call(hconn, RPC_CNAF16, CNAF_CRATE_CLEAR, 0, 0, 0, 0, 0, &d, &size, &x,
                      &q);
 
      rr->rsprintf("<tr><td colspan=6 class=\"greenLight\">C cycle executed sucessfully</tr>\n");
   } else if (equal_ustring(cmd, "Z cycle")) {
      rpc_client_call(hconn, RPC_CNAF16, CNAF_CRATE_ZINIT, 0, 0, 0, 0, 0, &d, &size, &x,
                      &q);
 
      rr->rsprintf("<tr><td colspan=6 class=\"greenLight\">Z cycle executed sucessfully</tr>\n");
   } else if (equal_ustring(cmd, "Clear inhibit")) {
      rpc_client_call(hconn, RPC_CNAF16, CNAF_INHIBIT_CLEAR, 0, 0, 0, 0, 0, &d, &size, &x,
                      &q);
 
      rr->rsprintf
          ("<tr><td colspan=6 class=\"greenLight\">Clear inhibit executed sucessfully</tr>\n");
   } else if (equal_ustring(cmd, "Set inhibit")) {
      rpc_client_call(hconn, RPC_CNAF16, CNAF_INHIBIT_SET, 0, 0, 0, 0, 0, &d, &size, &x,
                      &q);
 
      rr->rsprintf
          ("<tr><td colspan=6 class=\"greenLight\">Set inhibit executed sucessfully</tr>\n");
   } else if (equal_ustring(cmd, "Execute")) {
      c = atoi(p->getparam("C"));
      n = atoi(p->getparam("N"));
      a = atoi(p->getparam("A"));
      f = atoi(p->getparam("F"));
      r = atoi(p->getparam("R"));
      w = atoi(p->getparam("W"));
      id = atoi(p->getparam("ID"));
      ia = atoi(p->getparam("IA"));
 
      const char* pd = p->getparam("D");
      if (strncmp(pd, "0x", 2) == 0)
         sscanf(pd + 2, "%x", &d);
      else
         d = atoi(p->getparam("D"));
 
      /* limit repeat range */
      if (r == 0)
         r = 1;
      if (r > 100)
         r = 100;
      if (w > 1000)
         w = 1000;
 
      for (i = 0; i < r; i++) {
         status = SUCCESS;
 
         if (hconn) {
            size = sizeof(d);
            status =
                rpc_client_call(hconn, RPC_CNAF24, CNAF, 0, c, n, a, f, &d, &size, &x,
                                &q);
 
            if (status == RPC_NET_ERROR) {
               /* try to reconnect */
               //cm_disconnect_client(hconn, FALSE);
               status = cm_connect_client(client_name, &hconn);
               if (status != RPC_SUCCESS) {
                  hconn = 0;
                  client_name[0] = 0;
               }
 
               if (hconn) {
                  status = rpc_client_call(hconn, RPC_CNAF24, CNAF, 0, c, n, a, f, &d, &size, &x, &q);
               }
            }
         }
 
         if (status != SUCCESS) {
            rr->rsprintf
                ("<tr><td colspan=6 class=\"redLight\">Error executing function, code = %d</tr>",
                 status);
         } else {
            rr->rsprintf("<tr align=center><td>%d", n);
            rr->rsprintf("<td>%d", a);
            rr->rsprintf("<td>%d", f);
            rr->rsprintf("<td colspan=3>%d / 0x%04X  Q%d X%d", d, d, q, x);
         }
 
         d += id;
         a += ia;
 
         if (w > 0)
            ss_sleep(w);
      }
   }
 
   /* input fields */
   rr->rsprintf
       ("<tr align=center><td><input type=text size=3 name=N value=%d>\n",
        n);
   rr->rsprintf("<td><input type=text size=3 name=A value=%d>\n", a);
   rr->rsprintf("<td><input type=text size=3 name=F value=%d>\n", f);
   rr->rsprintf
       ("<td colspan=3><input type=text size=8 name=D value=%d></tr>\n",
        d);
 
   /* control fields */
   rr->rsprintf("<tr><td colspan=2>Repeat");
   rr->rsprintf("<td><input type=text size=3 name=R value=%d>\n", r);
 
   rr->rsprintf
       ("<td align=center colspan=3><input type=submit name=cmd value=\"C cycle\">\n");
   rr->rsprintf("<input type=submit name=cmd value=\"Z cycle\">\n");
 
   rr->rsprintf("<tr><td colspan=2>Repeat delay [ms]");
   rr->rsprintf("<td><input type=text size=3 name=W value=%d>\n", w);
 
   rr->rsprintf
       ("<td align=center colspan=3><input type=submit name=cmd value=\"Set inhibit\">\n");
   rr->rsprintf("<input type=submit name=cmd value=\"Clear inhibit\">\n");
 
   rr->rsprintf("<tr><td colspan=2>Data increment");
   rr->rsprintf("<td><input type=text size=3 name=ID value=%d>\n", id);
 
   rr->rsprintf
       ("<td colspan=3 align=center>Branch <input type=text size=3 name=B value=0>\n");
 
   rr->rsprintf("<tr><td colspan=2>A increment");
   rr->rsprintf("<td><input type=text size=3 name=IA value=%d>\n", ia);
 
   rr->rsprintf
       ("<td colspan=3 align=center>Crate <input type=text size=3 name=C value=%d>\n",
        c);
 
   rr->rsprintf("</table></body>\r\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_custom_file()

void show_custom_file	(	Return *	r,
		const char *	name
	)

Definition at line 3609 of file mhttpd.cxx.

{
   char str[256];
   std::string filename;
   HNDLE hDB;
 
   cm_get_experiment_database(&hDB, NULL);
 
   HNDLE hkey;
   sprintf(str, "/Custom/%s", name);
   db_find_key(hDB, 0, str, &hkey);
 
   if (!hkey) {
      sprintf(str, "/Custom/%s&", name);
      db_find_key(hDB, 0, str, &hkey);
      if (!hkey) {
         sprintf(str, "/Custom/%s!", name);
         db_find_key(hDB, 0, str, &hkey);
      }
   }
 
   if(!hkey){
      sprintf(str,"show_custom_file: Invalid custom page: \"/Custom/%s\" not found in ODB", name);
      show_error_404(r, str);
      return;
   }
 
   int status;
   KEY key;
 
   status = db_get_key(hDB, hkey, &key);
 
   if (status != DB_SUCCESS) {
      char errtext[512];
      sprintf(errtext, "show_custom_file: Error: db_get_key() for \"%s\" status %d", str, status);
      show_error_404(r, errtext);
      return;
   }
 
   int size = key.total_size;
   char* ctext = (char*)malloc(size);
 
   status = db_get_data(hDB, hkey, ctext, &size, TID_STRING);
 
   if (status != DB_SUCCESS) {
      char errtext[512];
      sprintf(errtext, "show_custom_file: Error: db_get_data() for \"%s\" status %d", str, status);
      show_error_404(r, errtext);
      free(ctext);
      return;
   }
 
   filename = add_custom_path(ctext);
 
   free(ctext);
 
   send_file(r, filename, true);
 
   return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_custom_gif()

void show_custom_gif	(	Return *	rr,
		const char *	name
	)

Definition at line 3672 of file mhttpd.cxx.

{
   char str[256], data[256], src[256];
   int i, index, length, status, size, width, height, bgcol, fgcol, bdcol, r, g, b, x, y;
   HNDLE hDB, hkeygif, hkeyroot, hkey, hkeyval;
   double fvalue, ratio;
   KEY key, vkey;
   gdImagePtr im;
   gdGifBuffer gb;
   gdFontPtr pfont;
   FILE *f;
   CGIF_LABEL label;
   CGIF_BAR bar;
 
   cm_get_experiment_database(&hDB, NULL);
 
   /* find image description in ODB */
   sprintf(str, "/Custom/Images/%s", name);
   db_find_key(hDB, 0, str, &hkeygif);
   if (!hkeygif) {
 
      // If we don't have Images directory,
      // then just treat this like any other custom file.
      show_custom_file(rr, name);
      return;
   }
 
   /* load background image */
   std::string filename;
   db_get_value_string(hDB, hkeygif, "Background", 0, &filename, FALSE);
 
   std::string full_filename = add_custom_path(filename);
 
   f = fopen(full_filename.c_str(), "rb");
   if (f == NULL) {
      sprintf(str, "show_custom_gif: Cannot open file \"%s\"", full_filename.c_str());
      show_error_404(rr, str);
      return;
   }
 
   im = gdImageCreateFromGif(f);
   fclose(f);
 
   if (im == NULL) {
      sprintf(str, "show_custom_gif: File \"%s\" is not a GIF image", filename.c_str());
      show_error_404(rr, str);
      return;
   }
 
   cm_get_experiment_database(&hDB, NULL);
 
   /*---- draw labels ----------------------------------------------*/
 
   db_find_key(hDB, hkeygif, "Labels", &hkeyroot);
   if (hkeyroot) {
      for (index = 0;; index++) {
         db_enum_key(hDB, hkeyroot, index, &hkey);
         if (!hkey)
            break;
         db_get_key(hDB, hkey, &key);
 
         size = sizeof(label);
         status = db_get_record1(hDB, hkey, &label, &size, 0, strcomb1(cgif_label_str).c_str());
         if (status != DB_SUCCESS) {
            cm_msg(MERROR, "show_custom_gif", "Cannot open data record for label \"%s\"",
                   key.name);
            continue;
         }
 
         if (label.src[0] == 0) {
            cm_msg(MERROR, "show_custom_gif", "Empty Src key for label \"%s\"", key.name);
            continue;
         }
 
         db_find_key(hDB, 0, label.src, &hkeyval);
         if (!hkeyval) {
            cm_msg(MERROR, "show_custom_gif", "Invalid Src key \"%s\" for label \"%s\"",
                   label.src, key.name);
            continue;
         }
 
         db_get_key(hDB, hkeyval, &vkey);
         size = sizeof(data);
         status = db_get_value(hDB, 0, label.src, data, &size, vkey.type, FALSE);
 
         std::string value;
 
         if (label.format[0]) {
            if (vkey.type == TID_FLOAT)
               value = msprintf(label.format, *(((float *) data)));
            else if (vkey.type == TID_DOUBLE)
               value = msprintf(label.format, *(((double *) data)));
            else if (vkey.type == TID_INT)
               value = msprintf(label.format, *(((INT *) data)));
            else if (vkey.type == TID_BOOL) {
               if (strstr(label.format, "%c"))
                  value = msprintf(label.format, *(((INT *) data)) ? 'y' : 'n');
               else
                  value = msprintf(label.format, *(((INT *) data)));
            } else
               value = db_sprintf(data, size, 0, vkey.type);
         } else
            value = db_sprintf(data, size, 0, vkey.type);
 
         sscanf(label.fgcolor, "%02x%02x%02x", &r, &g, &b);
         fgcol = gdImageColorAllocate(im, r, g, b);
         if (fgcol == -1)
            fgcol = gdImageColorClosest(im, r, g, b);
 
         sscanf(label.bgcolor, "%02x%02x%02x", &r, &g, &b);
         bgcol = gdImageColorAllocate(im, r, g, b);
         if (bgcol == -1)
            bgcol = gdImageColorClosest(im, r, g, b);
 
         /* select font */
         if (equal_ustring(label.font, "Small"))
            pfont = gdFontSmall;
         else if (equal_ustring(label.font, "Medium"))
            pfont = gdFontMediumBold;
         else if (equal_ustring(label.font, "Giant"))
            pfont = gdFontGiant;
         else
            pfont = gdFontMediumBold;
 
         width = value.length() * pfont->w + 5 + 5;
         height = pfont->h + 2 + 2;
 
         if (label.align == 0) {
            /* left */
            gdImageFilledRectangle(im, label.x, label.y, label.x + width,
                                   label.y + height, bgcol);
            gdImageRectangle(im, label.x, label.y, label.x + width, label.y + height,
                             fgcol);
            gdImageString(im, pfont, label.x + 5, label.y + 2, value.c_str(), fgcol);
         } else if (label.align == 1) {
            /* center */
            gdImageFilledRectangle(im, label.x - width / 2, label.y, label.x + width / 2,
                                   label.y + height, bgcol);
            gdImageRectangle(im, label.x - width / 2, label.y, label.x + width / 2,
                             label.y + height, fgcol);
            gdImageString(im, pfont, label.x + 5 - width / 2, label.y + 2, value.c_str(), fgcol);
         } else {
            /* right */
            gdImageFilledRectangle(im, label.x - width, label.y, label.x,
                                   label.y + height, bgcol);
            gdImageRectangle(im, label.x - width, label.y, label.x, label.y + height,
                             fgcol);
            gdImageString(im, pfont, label.x - width + 5, label.y + 2, value.c_str(), fgcol);
         }
      }
   }
 
   /*---- draw bars ------------------------------------------------*/
 
   db_find_key(hDB, hkeygif, "Bars", &hkeyroot);
   if (hkeyroot) {
      for (index = 0;; index++) {
         db_enum_key(hDB, hkeyroot, index, &hkey);
         if (!hkey)
            break;
         db_get_key(hDB, hkey, &key);
 
         size = sizeof(bar);
         status = db_get_record1(hDB, hkey, &bar, &size, 0, strcomb1(cgif_bar_str).c_str());
         if (status != DB_SUCCESS) {
            cm_msg(MERROR, "show_custom_gif", "Cannot open data record for bar \"%s\"",
                   key.name);
            continue;
         }
 
         if (bar.src[0] == 0) {
            cm_msg(MERROR, "show_custom_gif", "Empty Src key for bar \"%s\"", key.name);
            continue;
         }
 
         db_find_key(hDB, 0, bar.src, &hkeyval);
         if (!hkeyval) {
            cm_msg(MERROR, "show_custom_gif", "Invalid Src key \"%s\" for bar \"%s\"",
                   bar.src, key.name);
            continue;
         }
 
         db_get_key(hDB, hkeyval, &vkey);
         size = sizeof(data);
         status = db_get_value(hDB, 0, bar.src, data, &size, vkey.type, FALSE);
         std::string value = db_sprintf(data, size, 0, vkey.type);
         if (equal_ustring(value.c_str(), "NAN"))
            continue;
 
         fvalue = atof(value.c_str());
 
         sscanf(bar.fgcolor, "%02x%02x%02x", &r, &g, &b);
         fgcol = gdImageColorAllocate(im, r, g, b);
         if (fgcol == -1)
            fgcol = gdImageColorClosest(im, r, g, b);
 
         sscanf(bar.bgcolor, "%02x%02x%02x", &r, &g, &b);
         bgcol = gdImageColorAllocate(im, r, g, b);
         if (bgcol == -1)
            bgcol = gdImageColorClosest(im, r, g, b);
 
         sscanf(bar.bdcolor, "%02x%02x%02x", &r, &g, &b);
         bdcol = gdImageColorAllocate(im, r, g, b);
         if (bdcol == -1)
            bdcol = gdImageColorClosest(im, r, g, b);
 
         if (bar.min == bar.max)
            bar.max += 1;
 
         if (bar.logscale) {
            if (fvalue < 1E-20)
               fvalue = 1E-20;
            ratio = (log(fvalue) - log(bar.min)) / (log(bar.max) - log(bar.min));
         } else
            ratio = (fvalue - bar.min) / (bar.max - bar.min);
         if (ratio < 0)
            ratio = 0;
         if (ratio > 1)
            ratio = 1;
 
         if (bar.direction == 0) {
            /* vertical */
            ratio = (bar.height - 2) - ratio * (bar.height - 2);
            r = (int) (ratio + 0.5);
 
            gdImageFilledRectangle(im, bar.x, bar.y, bar.x + bar.width,
                                   bar.y + bar.height, bgcol);
            gdImageRectangle(im, bar.x, bar.y, bar.x + bar.width, bar.y + bar.height,
                             bdcol);
            gdImageFilledRectangle(im, bar.x + 1, bar.y + r + 1, bar.x + bar.width - 1,
                                   bar.y + bar.height - 1, fgcol);
 
            if (bar.axis == 1)
               vaxis(im, gdFontSmall, bdcol, 0, bar.x, bar.y + bar.height, bar.height, -3,
                     -5, -7, -8, 0, bar.min, bar.max, bar.logscale);
            else if (bar.axis == 2)
               vaxis(im, gdFontSmall, bdcol, 0, bar.x + bar.width, bar.y + bar.height,
                     bar.height, 3, 5, 7, 10, 0, bar.min, bar.max, bar.logscale);
 
         } else {
            /* horizontal */
            ratio = ratio * (bar.height - 2);
            r = (int) (ratio + 0.5);
 
            gdImageFilledRectangle(im, bar.x, bar.y, bar.x + bar.height,
                                   bar.y + bar.width, bgcol);
            gdImageRectangle(im, bar.x, bar.y, bar.x + bar.height, bar.y + bar.width,
                             bdcol);
            gdImageFilledRectangle(im, bar.x + 1, bar.y + 1, bar.x + r,
                                   bar.y + bar.width - 1, fgcol);
 
            if (bar.axis == 1)
               haxis(im, gdFontSmall, bdcol, 0, bar.x, bar.y, bar.height, -3, -5, -7, -18,
                     0, bar.min, bar.max);
            else if (bar.axis == 2)
               haxis(im, gdFontSmall, bdcol, 0, bar.x, bar.y + bar.width, bar.height, 3,
                     5, 7, 8, 0, bar.min, bar.max);
         }
      }
   }
 
   /*---- draw fills -----------------------------------------------*/
 
   db_find_key(hDB, hkeygif, "Fills", &hkeyroot);
   if (hkeyroot) {
      for (index = 0;; index++) {
         db_enum_key(hDB, hkeyroot, index, &hkey);
         if (!hkey)
            break;
         db_get_key(hDB, hkey, &key);
 
         size = sizeof(src);
         src[0] = 0;
         db_get_value(hDB, hkey, "Src", src, &size, TID_STRING, TRUE);
 
         if (src[0] == 0) {
            cm_msg(MERROR, "show_custom_gif", "Empty Src key for Fill \"%s\"", key.name);
            continue;
         }
 
         if (!evaluate_src(key.name, src, &fvalue))
            continue;
 
         x = y = 0;
         size = sizeof(x);
         db_get_value(hDB, hkey, "X", &x, &size, TID_INT, TRUE);
         db_get_value(hDB, hkey, "Y", &y, &size, TID_INT, TRUE);
 
         size = sizeof(data);
         status = db_get_value(hDB, hkey, "Limits", data, &size, TID_DOUBLE, FALSE);
         if (status != DB_SUCCESS) {
            cm_msg(MERROR, "show_custom_gif", "No \"Limits\" entry for Fill \"%s\"",
                   key.name);
            continue;
         }
         for (i = 0; i < size / (int) sizeof(double); i++)
            if (*((double *) data + i) > fvalue)
               break;
         if (i > 0)
            i--;
 
         db_find_key(hDB, hkey, "Fillcolors", &hkeyval);
         if (!hkeyval) {
            cm_msg(MERROR, "show_custom_gif", "No \"Fillcolors\" entry for Fill \"%s\"",
                   key.name);
            continue;
         }
 
         size = sizeof(data);
         strcpy(data, "FFFFFF");
         status = db_get_data_index(hDB, hkeyval, data, &size, i, TID_STRING);
         if (status == DB_SUCCESS) {
            sscanf(data, "%02x%02x%02x", &r, &g, &b);
            fgcol = gdImageColorAllocate(im, r, g, b);
            if (fgcol == -1)
               fgcol = gdImageColorClosest(im, r, g, b);
            gdImageFill(im, x, y, fgcol);
         }
      }
   }
 
   /* generate GIF */
   gdImageInterlace(im, 1);
   gdImageGif(im, &gb);
   gdImageDestroy(im);
   length = gb.size;
 
   rr->rsprintf("HTTP/1.1 200 Document follows\r\n");
   rr->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
 
   rr->rsprintf("Content-Type: image/gif\r\n");
   rr->rsprintf("Content-Length: %d\r\n", length);
   rr->rsprintf("Cache-control: private, max-age=0, no-cache\r\n");
   rr->rsprintf("Expires: Fri, 01-Jan-1983 00:00:00 GMT\r\n\r\n");
 
   rr->rmemcpy(gb.data, length);
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_custom_page()

void show_custom_page	(	Param *	pp,
		Return *	r,
		const char *	cookie_cpwd
	)

Definition at line 5419 of file mhttpd.cxx.

{
   int size, n_var, index, edit;
   char keypath[256], type[32], *p, *ps;
   char pwd[256], tail[256];
   HNDLE hDB, hkey;
   KEY key;
   char data[TEXT_SIZE];
 
   std::string path = pp->getparam("page");
 
   if (path[0] == 0) {
      show_error_404(r, "show_custom_page: Invalid custom page: \"page\" parameter is empty");
      return;
   }
 
   if (strstr(path.c_str(), "..")) {
      std::string str;
      str += "Invalid custom page name \'";
      str += path;
      str += "\' contains \'..\'";
      show_error_404(r, str.c_str());
      return;
   }
 
   if (strstr(path.c_str(), ".gif")) {
      show_custom_gif(r, path.c_str());
      return;
   }
 
   if (strchr(path.c_str(), '.')) {
      show_custom_file(r, path.c_str());
      return;
   }
 
   cm_get_experiment_database(&hDB, NULL);
 
   std::string xpath = std::string("/Custom/") + path;
   db_find_key(hDB, 0, xpath.c_str(), &hkey);
   if (!hkey) {
      xpath = std::string("/Custom/") + path + "&";
      db_find_key(hDB, 0, xpath.c_str(), &hkey);
      if (!hkey) {
         xpath = std::string("/Custom/") + path + "!";
         db_find_key(hDB, 0, xpath.c_str(), &hkey);
      }
   }
 
   if (hkey) {
      char* ctext;
      int status;
 
      status = db_get_key(hDB, hkey, &key);
      assert(status == DB_SUCCESS);
      size = key.total_size;
      ctext = (char*)malloc(size);
      status = db_get_data(hDB, hkey, ctext, &size, TID_STRING);
      if (status != DB_SUCCESS) {
         std::string errtext = msprintf("show_custom_page: Error: db_get_data() for \"%s\" status %d", xpath.c_str(), status);
         show_error_404(r, errtext.c_str());
         free(ctext);
         return;
      }
 
      std::string content_type = "text/html";
 
      /* check for link */
      if (std::string(ctext).substr(0, 5) == "?cmd=") {
         redirect(r, ctext);
         free(ctext);
         return;
      }
 
      /* check if filename */
      if (strchr(ctext, '\n') == 0) {
         std::string full_filename = add_custom_path(ctext);
         int fh = open(full_filename.c_str(), O_RDONLY | O_BINARY);
         if (fh < 0) {
            std::string str = msprintf("show_custom_page: Cannot open file \"%s\", open() errno %d (%s)", full_filename.c_str(), errno, strerror(errno));
            show_error_404(r, str.c_str());
            free(ctext);
            return;
         }
         free(ctext);
         ctext = NULL;
         off_t off = lseek(fh, 0, SEEK_END);
         if (off < 0) {
            std::string str = msprintf("show_custom_page: Cannot open file \"%s\", lseek(SEEK_END) errno %d (%s)", full_filename.c_str(), errno, strerror(errno));
            show_error_404(r, str.c_str());
            free(ctext);
            close(fh);
            return;
         }
         size_t size = off;
         lseek(fh, 0, SEEK_SET);
         ctext = (char*)malloc(size+1);
         ssize_t rd = read(fh, ctext, size);
         if (rd > 0) {
            ctext[rd] = 0; // make sure string is zero-terminated
            size = rd;
         } else {
            ctext[0] = 0;
            size = 0;
         }
         close(fh);
 
         content_type = get_content_type(full_filename.c_str());
      }
 
      /* check for valid password */
      if (equal_ustring(pp->getparam("cmd"), "Edit")) {
         p = ps = ctext;
         n_var = 0;
         do {
            char format[256];
 
            p = find_odb_tag(ps, keypath, format, &edit, type, pwd, tail);
            if (p == NULL)
               break;
            ps = strchr(p, '>') + 1;
 
            if (pwd[0] && n_var == atoi(pp->getparam("index"))) {
               char str[256];
               size = NAME_LENGTH;
               mstrlcpy(str, path.c_str(), sizeof(str)); // FIXME: overflows "str"
               if (strlen(str)>0 && str[strlen(str)-1] == '&')
                  str[strlen(str)-1] = 0;
               std::string ppath;
               ppath += "/Custom/Pwd/";
               if (pp->getparam("pnam") && *pp->getparam("pnam")) {
                  ppath += pp->getparam("pnam");
               } else {
                  ppath += str;
               }
               str[0] = 0;
               db_get_value(hDB, 0, ppath.c_str(), str, &size, TID_STRING, TRUE);
               if (!equal_ustring(cookie_cpwd, str)) {
                  show_error_404(r, "show_custom_page: Invalid password!");
                  free(ctext);
                  return;
               } else
                  break;
            }
 
            n_var++;
         } while (p != NULL);
      }
 
      /* process toggle command */
      if (equal_ustring(pp->getparam("cmd"), "Toggle")) {
 
         if (pp->getparam("pnam") && *pp->getparam("pnam")) {
            std::string ppath;
            ppath += "/Custom/Pwd/";
            ppath += pp->getparam("pnam");
            std::string str;
            db_get_value_string(hDB, 0, ppath.c_str(), 0, &str, TRUE, 256);
            if (!equal_ustring(cookie_cpwd, str.c_str())) {
               show_error_404(r, "show_custom_page: Invalid password!");
               free(ctext);
               return;
            }
         }
         std::string podb = pp->getparam("odb");
         std::string::size_type pos = podb.find('[');
         if (pos != std::string::npos) {
            index = atoi(podb.substr(pos+1).c_str());
            podb.resize(pos);
            //printf("found index %d in [%s] [%s]\n", index, pp->getparam("odb"), podb.c_str());
         } else
            index = 0;
 
         if (db_find_key(hDB, 0, podb.c_str(), &hkey)) {
            db_get_key(hDB, hkey, &key);
            memset(data, 0, sizeof(data));
            if (key.item_size <= (int)sizeof(data)) {
               size = sizeof(data);
               db_get_data_index(hDB, hkey, data, &size, index, key.type);
               std::string data_str = db_sprintf(data, size, 0, key.type);
               if (atoi(data_str.c_str()) == 0)
                  db_sscanf("1", data, &size, 0, key.type);
               else
                  db_sscanf("0", data, &size, 0, key.type);
               db_set_data_index(hDB, hkey, data, key.item_size, index, key.type);
            }
         }
 
         /* redirect (so that 'reload' does not toggle again) */
         redirect(r, path.c_str());
         free(ctext);
         return;
      }
 
      /* HTTP header */
      r->rsprintf("HTTP/1.1 200 Document follows\r\n");
      r->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
      r->rsprintf("Content-Type: %s; charset=%s\r\n\r\n", content_type.c_str(), HTTP_ENCODING);
 
      /* interprete text, replace <odb> tags with ODB values */
      p = ps = ctext;
      n_var = 0;
      do {
         char format[256];
         p = find_odb_tag(ps, keypath, format, &edit, type, pwd, tail);
         if (p != NULL)
            *p = 0;
         r->rsputs(ps);
 
         if (p == NULL)
            break;
         ps = strchr(p + 1, '>') + 1;
 
         show_odb_tag(pp, r, path.c_str(), keypath, format, n_var, edit, type, pwd, tail);
         n_var++;
 
      } while (p != NULL);
 
      if (equal_ustring(pp->getparam("cmd"), "Set") || pp->isparam("cbi")) {
         /* redirect (so that 'reload' does not change value) */
         r->reset();
         redirect(r, path.c_str());
      }
 
      free(ctext);
      ctext = NULL;
   } else {
      std::string str = msprintf("Invalid custom page: Page \"%s\" not found in ODB", path.c_str());
      show_error_404(r, str.c_str());
      return;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_elog_attachment()

void show_elog_attachment	(	Param *	p,
		Return *	r,
		const char *	path
	)

Definition at line 2483 of file mhttpd.cxx.

{
   HNDLE hDB;
   int size;
   int status;
   char file_name[256];
 
   cm_get_experiment_database(&hDB, NULL);
   file_name[0] = 0;
   if (hDB > 0) {
      size = sizeof(file_name);
      memset(file_name, 0, size);
 
      status = db_get_value(hDB, 0, "/Logger/Elog dir", file_name, &size, TID_STRING, FALSE);
      if (status != DB_SUCCESS)
         db_get_value(hDB, 0, "/Logger/Data dir", file_name, &size, TID_STRING, TRUE);
 
      if (file_name[0] != 0)
         if (file_name[strlen(file_name) - 1] != DIR_SEPARATOR)
            mstrlcat(file_name, DIR_SEPARATOR_STR, sizeof(file_name));
   }
   mstrlcat(file_name, path, sizeof(file_name));
 
   int fh = open(file_name, O_RDONLY | O_BINARY);
   if (fh > 0) {
      lseek(fh, 0, SEEK_END);
      int length = TELL(fh);
      lseek(fh, 0, SEEK_SET);
 
      r->rsprintf("HTTP/1.1 200 Document follows\r\n");
      r->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
      r->rsprintf("Accept-Ranges: bytes\r\n");
      //r->rsprintf("Content-disposition: attachment; filename=%s\r\n", path);
 
      r->rsprintf("Content-Type: %s\r\n", get_content_type(file_name).c_str());
 
      r->rsprintf("Content-Length: %d\r\n\r\n", length);
 
      r->rread(file_name, fh, length);
 
      close(fh);
   }
 
   return;
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_eqtable_page()

void show_eqtable_page	(	Param *	pp,
		Return *	r,
		int	refresh
	)

Definition at line 2558 of file mhttpd.cxx.

{
   int i, j, k, colspan, size, n_var, i_edit, i_set, line;
   char eq_name[32], group[32];
   char group_name[MAX_GROUPS][32], data[256], style[80];
   HNDLE hDB;
   char odb_path[256];
 
   cm_get_experiment_database(&hDB, NULL);
 
   /* check if variable to edit */
   i_edit = -1;
   if (equal_ustring(pp->getparam("cmd"), "Edit"))
      i_edit = atoi(pp->getparam("index"));
 
   /* check if variable to set */
   i_set = -1;
   if (equal_ustring(pp->getparam("cmd"), "Set"))
      i_set = atoi(pp->getparam("index"));
 
   /* get equipment and group */
   if (pp->getparam("eq"))
      mstrlcpy(eq_name, pp->getparam("eq"), sizeof(eq_name));
   mstrlcpy(group, "All", sizeof(group));
   if (pp->getparam("group") && *pp->getparam("group"))
      mstrlcpy(group, pp->getparam("group"), sizeof(group));
 
#if 0
   /* check for "names" in settings */
   if (eq_name[0]) {
      sprintf(str, "/Equipment/%s/Settings", eq_name);
      HNDLE hkeyset;
      db_find_key(hDB, 0, str, &hkeyset);
      HNDLE hkeynames = 0;
      if (hkeyset) {
         for (i = 0;; i++) {
            db_enum_link(hDB, hkeyset, i, &hkeynames);
 
            if (!hkeynames)
               break;
 
            KEY key;
            db_get_key(hDB, hkeynames, &key);
 
            if (strncmp(key.name, "Names", 5) == 0)
               break;
         }
      }
 
      /* redirect if no names found */
      if (!hkeyset || !hkeynames) {
         /* redirect */
         sprintf(str, "?cmd=odb&odb_path=/Equipment/%s/Variables", eq_name);
         redirect(r, str);
         return;
      }
   }
#endif
 
   show_header(r, "MIDAS slow control", "", group, i_edit == -1 ? refresh : 0);
   r->rsprintf("<script type=\"text/javascript\" src=\"midas.js\"></script>\n");
   r->rsprintf("<script type=\"text/javascript\" src=\"mhttpd.js\"></script>\n");
   r->rsprintf("<script type=\"text/javascript\" src=\"obsolete.js\"></script>\n");
   show_navigation_bar(r, "SC");
 
   /*---- menu buttons ----*/
 
   r->rsprintf("<tr><td colspan=15>\n");
 
   if (equal_ustring(pp->getparam("cmd"), "Edit"))
      r->rsprintf("<input type=submit name=cmd value=Set>\n");
 
   r->rsprintf("</tr>\n\n");
   r->rsprintf("</table>");  //end header table
 
   r->rsprintf("<table class=\"ODBtable\" style=\"max-width:700px;\">");  //body table
 
   /*---- enumerate SC equipment ----*/
 
   r->rsprintf("<tr><td class=\"subStatusTitle\" colspan=15><i>Equipment:</i> &nbsp;&nbsp;\n");
 
   HNDLE hkeyeqroot;
   db_find_key(hDB, 0, "/Equipment", &hkeyeqroot);
   if (hkeyeqroot)
      for (i = 0;; i++) {
         HNDLE hkeyeq;
         db_enum_link(hDB, hkeyeqroot, i, &hkeyeq);
 
         if (!hkeyeq)
            break;
 
         KEY eqkey;
         db_get_key(hDB, hkeyeq, &eqkey);
 
         HNDLE hkeyset;
         db_find_key(hDB, hkeyeq, "Settings", &hkeyset);
         if (hkeyset) {
            for (j = 0;; j++) {
               HNDLE hkeynames;
               db_enum_link(hDB, hkeyset, j, &hkeynames);
 
               if (!hkeynames)
                  break;
 
               KEY key;
               db_get_key(hDB, hkeynames, &key);
 
               if (strncmp(key.name, "Names", 5) == 0) {
                  if (equal_ustring(eq_name, eqkey.name))
                     r->rsprintf("<b>%s</b> &nbsp;&nbsp;", eqkey.name);
                  else {
                     r->rsprintf("<a href=\"?cmd=eqtable&eq=%s\">%s</a> &nbsp;&nbsp;", urlEncode(eqkey.name).c_str(), eqkey.name);
                  }
                  break;
               }
            }
         }
      }
   r->rsprintf("</tr>\n");
 
   if (!eq_name[0]) {
      r->rsprintf("</table>");
      return;
   }
 
   /*---- display SC ----*/
 
   n_var = 0;
   std::string names_path = msprintf("/Equipment/%s/Settings/Names", eq_name);
   HNDLE hkeyeqnames;
   db_find_key(hDB, 0, names_path.c_str(), &hkeyeqnames);
 
   if (hkeyeqnames) {
 
      /*---- single name array ----*/
      r->rsprintf("<tr><td colspan=15><i>Groups:</i> &nbsp;&nbsp;");
 
      /* "all" group */
      if (equal_ustring(group, "All"))
         r->rsprintf("<b>All</b> &nbsp;&nbsp;");
      else
         r->rsprintf("<a href=\"?cmd=eqtable&eq=%s\">All</a> &nbsp;&nbsp;", urlEncode(eq_name).c_str());
 
      /* collect groups */
 
      memset(group_name, 0, sizeof(group_name));
      KEY key;
      db_get_key(hDB, hkeyeqnames, &key);
 
      for (int level = 0; ; level++) {
         bool next_level = false;
         for (i = 0; i < key.num_values; i++) {
            char name_str[256];
            size = sizeof(name_str);
            db_get_data_index(hDB, hkeyeqnames, name_str, &size, i, TID_STRING);
 
            char *s = strchr(name_str, '%');
            for (int k=0; s && k<level; k++)
               s = strchr(s+1, '%');
 
            if (s) {
               *s = 0;
               if (strchr(s+1, '%'))
                   next_level = true;
 
               //printf("try group [%s] name [%s], level %d, %d\n", name_str, s+1, level, next_level);
 
               for (j = 0; j < MAX_GROUPS; j++) {
                  if (equal_ustring(group_name[j], name_str) || group_name[j][0] == 0)
                     break;
               }
               if (group_name[j][0] == 0)
                  mstrlcpy(group_name[j], name_str, sizeof(group_name[0]));
            }
         }
 
         if (!next_level)
            break;
      }
 
      for (i = 0; i < MAX_GROUPS && group_name[i][0]; i++) {
         if (equal_ustring(group_name[i], group))
            r->rsprintf("<b>%s</b> &nbsp;&nbsp;", group_name[i]);
         else {
            r->rsprintf("<a href=\"?cmd=eqtable&eq=%s&group=%s\">%s</a> &nbsp;&nbsp;", urlEncode(eq_name).c_str(), urlEncode(group_name[i]).c_str(), group_name[i]);
         }
      }
 
      r->rsprintf("<i>ODB:</i> &nbsp;&nbsp;");
      r->rsprintf("<a href=\"?cmd=odb&odb_path=Equipment/%s/Common\">Common</a> &nbsp;&nbsp;", urlEncode(eq_name).c_str());
      r->rsprintf("<a href=\"?cmd=odb&odb_path=Equipment/%s/Settings\">Settings</a> &nbsp;&nbsp;", urlEncode(eq_name).c_str());
      r->rsprintf("<a href=\"?cmd=odb&odb_path=Equipment/%s/Variables\">Variables</a> &nbsp;&nbsp;", urlEncode(eq_name).c_str());
      r->rsprintf("</tr>\n");
 
      /* count variables */
      std::string vars_path = msprintf("/Equipment/%s/Variables", eq_name);
      HNDLE hkeyvar;
      db_find_key(hDB, 0, vars_path.c_str(), &hkeyvar);
      if (!hkeyvar) {
         r->rsprintf("</table>");
         return;
      }
      for (i = 0;; i++) {
         HNDLE hkey;
         db_enum_link(hDB, hkeyvar, i, &hkey);
         if (!hkey)
            break;
      }
 
      if (i == 0 || i > 15) {
         r->rsprintf("</table>");
         return;
      }
 
      /* title row */
      colspan = 15 - i;
      r->rsprintf("<tr class=\"subStatusTitle\"><th colspan=%d>Names", colspan);
 
      /* display entries for this group */
      for (int i = 0;; i++) {
         HNDLE hkey;
         db_enum_link(hDB, hkeyvar, i, &hkey);
 
         if (!hkey)
            break;
 
         KEY key;
         db_get_key(hDB, hkey, &key);
         r->rsprintf("<th>%s", key.name);
      }
 
      r->rsprintf("</tr>\n");
 
      /* data for current group */
      std::string names_path = msprintf("/Equipment/%s/Settings/Names", eq_name);
      int num_values = 0;
      HNDLE hnames_key;
      db_find_key(hDB, 0, names_path.c_str(), &hnames_key);
      if (hnames_key) {
         KEY names_key;
         db_get_key(hDB, hnames_key, &names_key);
         num_values = names_key.num_values;
      }
      for (int i = 0; i < num_values; i++) {
         char names_str[256];
         size = sizeof(names_str);
         db_get_data_index(hDB, hnames_key, names_str, &size, i, TID_STRING);
 
         char name[NAME_LENGTH+32];
         mstrlcpy(name, names_str, sizeof(name));
 
         //printf("group [%s], name [%s], str [%s]\n", group, name, names_str);
 
         if (!equal_ustring(group, "All")) {
            // check if name starts with the name of the group we want to display
            char *s = strstr(name, group);
            if (s != name)
               continue;
            if (name[strlen(group)] != '%')
               continue;
         }
 
         if (strlen(name) < 1)
            sprintf(name, "[%d]", i);
 
         if (i % 2 == 0)
            r->rsprintf("<tr class=\"ODBtableEven\"><td colspan=%d><nobr>%s</nobr>", colspan, name);
         else
            r->rsprintf("<tr class=\"ODBtableOdd\"><td colspan=%d><nobr>%s</nobr>", colspan, name);
 
         for (int j = 0;; j++) {
            HNDLE hkey;
            db_enum_link(hDB, hkeyvar, j, &hkey);
            if (!hkey)
               break;
 
            KEY varkey;
            db_get_key(hDB, hkey, &varkey);
 
            /* check if "variables" array is shorter than the "names" array */
            if (i >= varkey.num_values)
               continue;
 
            size = sizeof(data);
            db_get_data_index(hDB, hkey, data, &size, i, varkey.type);
            std::string data_str = db_sprintf(data, varkey.item_size, 0, varkey.type);
 
            if (is_editable(eq_name, varkey.name)) {
               if (n_var == i_set) {
                  /* set value */
                  char str[256];
                  mstrlcpy(str, pp->getparam("value"), sizeof(str));
                  db_sscanf(str, data, &size, 0, varkey.type);
                  db_set_data_index(hDB, hkey, data, size, i, varkey.type);
 
                  /* redirect (so that 'reload' does not reset value) */
                  r->reset();
                  redirect(r, group);
                  return;
               }
               if (n_var == i_edit) {
                  r->rsprintf("<td align=center>");
                  r->rsprintf("<input type=text size=10 maxlenth=80 name=value value=\"%s\">\n", data_str.c_str());
                  r->rsprintf("<input type=submit size=20 name=cmd value=Set>\n");
                  r->rsprintf("<input type=hidden name=index value=%d>\n", i_edit);
                  n_var++;
               } else {
                  sprintf(odb_path, "Equipment/%s/Variables/%s[%d]", eq_name, varkey.name, i);
                  r->rsprintf("<td align=center>");
                  r->rsprintf("<a href=\"#\" onClick=\"ODBInlineEdit(this.parentNode,\'%s\', 0);return false;\" >%s</a>", odb_path, data_str.c_str());
                  n_var++;
               }
            } else
               r->rsprintf("<td align=center>%s", data_str.c_str());
         }
 
         r->rsprintf("</tr>\n");
      }
   } else {
      /*---- multiple name arrays ----*/
      r->rsprintf("<tr><td colspan=15><i>Groups:</i> ");
 
      /* "all" group */
      if (equal_ustring(group, "All"))
         r->rsprintf("<b>All</b> &nbsp;&nbsp;");
      else
         r->rsprintf("<a href=\"?cmd=eqtable&eq=%s\">All</a> &nbsp;&nbsp;", eq_name);
 
      /* groups from Variables tree */
 
      std::string vars_path = msprintf("/Equipment/%s/Variables", eq_name);
      HNDLE hkeyvar;
      db_find_key(hDB, 0, vars_path.c_str(), &hkeyvar);
 
      if (hkeyvar) {
         for (int i = 0;; i++) {
            HNDLE hkey;
            db_enum_link(hDB, hkeyvar, i, &hkey);
 
            if (!hkey)
               break;
 
            KEY key;
            db_get_key(hDB, hkey, &key);
 
            if (equal_ustring(key.name, group)) {
               r->rsprintf("<b>%s</b> &nbsp;&nbsp;", key.name);
            } else {
               r->rsprintf("<a href=\"?cmd=eqtable&eq=%s&group=%s\">%s</a> &nbsp;&nbsp;", urlEncode(eq_name).c_str(), urlEncode(key.name).c_str(), key.name);
            }
         }
      }
 
      r->rsprintf("<i>ODB:</i> &nbsp;&nbsp;");
      r->rsprintf("<a href=\"?cmd=odb&odb_path=Equipment/%s/Common\">Common</a> &nbsp;&nbsp;", urlEncode(eq_name).c_str());
      r->rsprintf("<a href=\"?cmd=odb&odb_path=Equipment/%s/Settings\">Settings</a> &nbsp;&nbsp;", urlEncode(eq_name).c_str());
      r->rsprintf("<a href=\"?cmd=odb&odb_path=Equipment/%s/Variables\">Variables</a> &nbsp;&nbsp;", urlEncode(eq_name).c_str());
      r->rsprintf("</tr>\n");
 
      /* enumerate variable arrays */
      line = 0;
      for (i = 0;; i++) {
         HNDLE hkey;
         db_enum_link(hDB, hkeyvar, i, &hkey);
 
         if (line % 2 == 0)
            mstrlcpy(style, "ODBtableEven", sizeof(style));
         else
            mstrlcpy(style, "ODBtableOdd", sizeof(style));
 
         if (!hkey)
            break;
 
         KEY varkey;
         db_get_key(hDB, hkey, &varkey);
 
         if (!equal_ustring(group, "All") && !equal_ustring(varkey.name, group))
            continue;
 
         /* title row */
         r->rsprintf("<tr class=\"subStatusTitle\"><th colspan=9>Names<th>%s</tr>\n", varkey.name);
 
         if (varkey.type == TID_KEY) {
            HNDLE hkeyroot = hkey;
 
            /* enumerate subkeys */
            for (j = 0;; j++) {
               db_enum_key(hDB, hkeyroot, j, &hkey);
               if (!hkey)
                  break;
 
               KEY key;
               db_get_key(hDB, hkey, &key);
 
               if (key.type == TID_KEY) {
                  /* for keys, don't display data value */
                  r->rsprintf("<tr class=\"%s\"><td colspan=9>%s<br></tr>\n", style, key.name);
               } else {
                  /* display single value */
                  if (key.num_values == 1) {
                     size = sizeof(data);
                     db_get_data(hDB, hkey, data, &size, key.type);
 
                     std::string data_str = db_sprintf(data, key.item_size, 0, key.type);
                     std::string hex_str = db_sprintfh(data, key.item_size, 0, key.type);
 
                     if (data_str.empty() || equal_ustring(data_str.c_str(), "<NULL>")) {
                        data_str = "(empty)";
                        hex_str  = "";
                     }
 
                     if (strcmp(data_str.c_str(), hex_str.c_str()) != 0 && hex_str[0])
                        r->rsprintf
                            ("<tr class=\"%s\" ><td colspan=9>%s<td align=center>%s (%s)<br></tr>\n",
                             style, key.name, data_str.c_str(), hex_str.c_str());
                     else
                        r->rsprintf("<tr class=\"%s\"><td colspan=9>%s<td align=center>%s<br></tr>\n",
                                    style, key.name, data_str.c_str());
                     line++;
                  } else {
                     /* display first value */
                     r->rsprintf("<tr class=\"%s\"><td colspan=9 rowspan=%d>%s\n", style, key.num_values,
                              key.name);
 
                     for (k = 0; k < key.num_values; k++) {
                        size = sizeof(data);
                        db_get_data_index(hDB, hkey, data, &size, k, key.type);
                        std::string data_str = db_sprintf(data, key.item_size, 0, key.type);
                        std::string hex_str = db_sprintfh(data, key.item_size, 0, key.type);
 
                        if (data_str.empty() || equal_ustring(data_str.c_str(), "<NULL>")) {
                           data_str = "(empty)";
                           hex_str  = "";
                        }
 
                        if (k > 0)
                           r->rsprintf("<tr>");
 
                        if (strcmp(data_str.c_str(), hex_str.c_str()) != 0 && hex_str[0])
                           r->rsprintf("<td>[%d] %s (%s)<br></tr>\n", k, data_str.c_str(), hex_str.c_str());
                        else
                           r->rsprintf("<td>[%d] %s<br></tr>\n", k, data_str.c_str());
                        line++;
                     }
                  }
               }
            }
         } else {
            /* data for current group */
            std::string names_path = msprintf("/Equipment/%s/Settings/Names %s", eq_name, varkey.name);
            HNDLE hkeyset;
            db_find_key(hDB, 0, names_path.c_str(), &hkeyset);
            KEY key;
            if (hkeyset)
               db_get_key(hDB, hkeyset, &key);
 
            if (varkey.num_values > 1000)
               r->rsprintf("<tr class=\"%s\"><td colspan=9>%s<td align=center><i>... %d values ...</i>",
                        style, varkey.name, varkey.num_values);
            else {
               for (j = 0; j < varkey.num_values; j++) {
 
                  if (line % 2 == 0)
                     mstrlcpy(style, "ODBtableEven", sizeof(style));
                  else
                     mstrlcpy(style, "ODBtableOdd", sizeof(style));
 
                  char name[NAME_LENGTH+32];
                  if (hkeyset && j<key.num_values) {
                     size = sizeof(name);
                     db_get_data_index(hDB, hkeyset, name, &size, j, TID_STRING);
                  } else {
                     sprintf(name, "%s[%d]", varkey.name, j);
                  }
 
                  if (strlen(name) < 1) {
                     sprintf(name, "%s[%d]", varkey.name, j);
                  }
 
                  r->rsprintf("<tr class=\"%s\"><td colspan=9>%s", style, name);
 
                  size = sizeof(data);
                  db_get_data_index(hDB, hkey, data, &size, j, varkey.type);
                  std::string data_str = db_sprintf(data, varkey.item_size, 0, varkey.type);
 
                  if (is_editable(eq_name, varkey.name)) {
                     if (n_var == i_set) {
                        /* set value */
                        char str[256];
                        mstrlcpy(str, pp->getparam("value"), sizeof(str));
                        db_sscanf(str, data, &size, 0, varkey.type);
                        db_set_data_index(hDB, hkey, data, size, j, varkey.type);
 
                        /* redirect (so that 'reload' does not reset value) */
                        r->reset();
                        sprintf(str, "%s", group);
                        redirect(r, str);
                        return;
                     }
                     if (n_var == i_edit) {
                        r->rsprintf("<td align=center><input type=text size=10 maxlenth=80 name=value value=\"%s\">\n", data_str.c_str());
                        r->rsprintf("<input type=submit size=20 name=cmd value=Set></tr>\n");
                        r->rsprintf("<input type=hidden name=index value=%d>\n", i_edit);
                        r->rsprintf("<input type=hidden name=cmd value=Set>\n");
                        n_var++;
                     } else {
                        sprintf(odb_path, "Equipment/%s/Variables/%s[%d]", eq_name, varkey.name, j);
 
                        r->rsprintf("<td align=cernter>");
                        r->rsprintf("<a href=\"#\" onClick=\"ODBInlineEdit(this.parentNode,\'%s\', 0);return false;\" >%s</a>", odb_path, data_str.c_str());
                        n_var++;
                     }
 
                  } else
                     r->rsprintf("<td align=center>%s\n", data_str.c_str());
                  r->rsprintf("</tr>\n");
                  line++;
               }
            }
 
            r->rsprintf("</tr>\n");
         }
      }
   }
 
   r->rsprintf("</table>\n");
   r->rsprintf("</div>\n"); // closing for <div id="mmain">
   r->rsprintf("</form>\n");
   r->rsprintf("</body></html>\r\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_error()

void show_error	(	Return *	r,
		const char *	error
	)

Definition at line 1839 of file mhttpd.cxx.

{
   /* header */
   r->rsprintf("HTTP/1.1 200 Document follows\r\n");
   r->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
   r->rsprintf("Content-Type: text/html; charset=%s\r\n\r\n", HTTP_ENCODING);
 
   r->rsprintf("<html><head>\n");
   r->rsprintf("<link rel=\"stylesheet\" href=\"mhttpd.css\" type=\"text/css\" />\n");
   r->rsprintf("<title>MIDAS error</title></head>\n");
   r->rsprintf("<body><H1>%s</H1></body></html>\n", error);
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_error_404()

void show_error_404	(	Return *	r,
		const char *	error
	)

Definition at line 1854 of file mhttpd.cxx.

{
   /* header */
   r->rsprintf("HTTP/1.1 404 Not Found\r\n");
   r->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
   r->rsprintf("Content-Type: text/plain\r\n");
   r->rsprintf("\r\n");
 
   r->rsprintf("MIDAS error: %s\n", error);
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_find_page()

void show_find_page	(	Return *	r,
		const char *	value
	)

Definition at line 7567 of file mhttpd.cxx.

{
   HNDLE hDB, hkey;
 
   cm_get_experiment_database(&hDB, NULL);
 
   if (value[0] == 0) {
      /* without value, show find dialog */
      show_header(r, "Find value", "GET", "", 0);
 
      //end header:
      r->rsprintf("</table>");
 
      //find dialog:
      r->rsprintf("<table class=\"dialogTable\">");
 
      r->rsprintf("<tr><th colspan=2>Find string in Online Database</tr>\n");
      r->rsprintf("<tr><td>Enter substring (case insensitive)\n");
 
      r->rsprintf("<td><input type=\"text\" size=\"20\" maxlength=\"80\" name=\"value\">\n");
      r->rsprintf("</tr>");
 
      r->rsprintf("<tr><td align=center colspan=2>");
      r->rsprintf("<input type=submit name=cmd value=Find>");
      r->rsprintf("<input type=submit name=cmd value=Cancel>");
      r->rsprintf("</tr>");
      r->rsprintf("</table>");
 
      r->rsprintf("<input type=hidden name=cmd value=Find>");
 
      r->rsprintf("</div>\n"); // closing for <div id="mmain">
      r->rsprintf("</form>\n");
      r->rsprintf("</body></html>\r\n");
   } else {
      show_header(r, "Search results", "GET", "", 0);
 
      r->rsprintf("<table class=\"mtable\">\n");
      r->rsprintf("<tr><th colspan=2 class=\"mtableheader\">");
      r->rsprintf("Results of search for substring \"%s\"</tr>\n", value);
      r->rsprintf("<tr><th class=\"titlerow\">Key<th>Value</tr>\n");
 
      /* start from root */
      db_find_key(hDB, 0, "", &hkey);
      assert(hkey);
 
      /* scan tree, call "search_callback" for each key */
      search_data data;
      data.r = r;
      data.search_name = value;
 
      db_scan_tree(hDB, hkey, 0, search_callback, (void *)&data);
 
      r->rsprintf("</table>");
      r->rsprintf("</div>\n"); // closing for <div id="mmain">
      r->rsprintf("</form>\n");
      r->rsprintf("</body></html>\r\n");
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_header()

void show_header	(	Return *	r,
		const char *	title,
		const char *	method,
		const char *	path,
		int	refresh
	)

Definition at line 1779 of file mhttpd.cxx.

{
   HNDLE hDB;
   time_t now;
   char str[256];
 
   cm_get_experiment_database(&hDB, NULL);
 
   /* header */
   r->rsprintf("HTTP/1.1 200 Document follows\r\n");
   r->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
   r->rsprintf("Cache-control: private, max-age=0, no-cache\r\n");
   r->rsprintf("Expires: Fri, 01 Jan 1983 00:00:00 GMT\r\n");
   r->rsprintf("Content-Type: text/html; charset=%s\r\n\r\n", HTTP_ENCODING);
 
   r->rsprintf("<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\n");
   r->rsprintf("<html><head>\n");
 
   /* style sheet */
   r->rsprintf("<link rel=\"icon\" href=\"favicon.png\" type=\"image/png\" />\n");
   r->rsprintf("<link rel=\"stylesheet\" href=\"mhttpd.css\" type=\"text/css\" />\n");
   r->rsprintf("<link rel=\"stylesheet\" href=\"midas.css\" type=\"text/css\" />\n");
 
   /* auto refresh */
   if (refresh > 0)
      r->rsprintf("<meta http-equiv=\"Refresh\" content=\"%02d\">\n", refresh);
 
   r->rsprintf("<title>%s</title></head>\n", title);
 
   mstrlcpy(str, path, sizeof(str));
   urlEncode(str, sizeof(str));
 
   if (equal_ustring(method, "POST"))
      r->rsprintf
          ("<body><form name=\"form1\" method=\"POST\" action=\"%s\" enctype=\"multipart/form-data\">\n\n",
           str);
   else if (equal_ustring(method, "GET"))
      r->rsprintf("<body><form name=\"form1\" method=\"GET\" action=\"%s\">\n\n", str);
 
   /* title row */
 
   std::string exptname;
   db_get_value_string(hDB, 0, "/Experiment/Name", 0, &exptname, TRUE);
   time(&now);
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_help_page()

void show_help_page	(	Return *	r,
		const char *	dec_path
	)

Definition at line 1540 of file mhttpd.cxx.

{
   const char *s;
   char str[256];
   int status;
 
   show_header(r, "Help", "", "./", 0);
   r->rsprintf("<script type=\"text/javascript\" src=\"midas.js\"></script>\n");
   r->rsprintf("<script type=\"text/javascript\" src=\"mhttpd.js\"></script>\n");
   show_navigation_bar(r, "Help");
 
   r->rsprintf("<table class=\"mtable\" style=\"width: 95%%\">\n");
   r->rsprintf("  <tr>\n");
   r->rsprintf("    <td class=\"mtableheader\">MIDAS Help Page</td>\n");
   r->rsprintf("  </tr>\n");
   r->rsprintf("  <tr>\n");
   r->rsprintf("    <td>\n");
   r->rsprintf("      <table>\n");
 
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">Documentation:</td>\n");
   r->rsprintf("          <td style=\"text-align:left;\"><a href=\"https://midas.triumf.ca\">https://midas.triumf.ca</a></td>\n");
   r->rsprintf("        </tr>\n");
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">Discussion Forum:</td>\n");
   r->rsprintf("          <td style=\"text-align:left;\"><a href=\"https://midas.triumf.ca/forum/\">https://midas.triumf.ca/forum/</a></td>\n");
   r->rsprintf("        </tr>\n");
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">Code:</td>\n");
   r->rsprintf("          <td style=\"text-align:left;\"><a href=\"https://bitbucket.org/tmidas/midas/\">https://bitbucket.org/tmidas/midas/</a></td>\n");
   r->rsprintf("        </tr>\n");
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">Report a bug:</td>\n");
   r->rsprintf("          <td style=\"text-align:left;\"><a href=\"https://bitbucket.org/tmidas/midas/issues/\">https://bitbucket.org/tmidas/midas/issues/</a></td>\n");
   r->rsprintf("        </tr>\n");
 
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">Version:</td>\n");
   r->rsprintf("          <td style=\"text-align:left;\">%s</td>\n", cm_get_version());
   r->rsprintf("        </tr>\n");
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">Revision:</td>\n");
   std::string rev = cm_get_revision();
   std::string url = "https://bitbucket.org/tmidas/midas/commits/";
   // rev format looks like this:
   // Fri Nov 24 10:15:54 2017 -0800 - midas-2017-07-c-171-gb8928d5c-dirty on branch develop
   // -gXXX is the commit hash
   // -dirty should be removed from the hash url, if present
   // " " before "on branch" should be removed from the hash url
   std::string::size_type pos = rev.find("-g");
   if (pos != std::string::npos) {
      std::string hash = rev.substr(pos+2);
      pos = hash.find("-dirty");
      if (pos != std::string::npos) {
         hash = hash.substr(0, pos);
      }
      pos = hash.find(" ");
      if (pos != std::string::npos) {
         hash = hash.substr(0, pos);
      }
      url += hash;
      r->rsprintf("          <td style=\"text-align:left;\"><a href=\"%s\">%s</a></td>\n", url.c_str(), rev.c_str());
   } else {
      r->rsprintf("          <td style=\"text-align:left;\">%s</td>\n", rev.c_str());
   }
   r->rsprintf("        </tr>\n");
 
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">MIDASSYS:</td>\n");
   s = getenv("MIDASSYS");
   if (!s) s = "(unset)";
   mstrlcpy(str, s, sizeof(str));
   r->rsprintf("          <td style=\"text-align:left;\">%s</td>\n", str);
   r->rsprintf("        </tr>\n");
 
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">mhttpd current directory:</td>\n");
   std::string cwd = ss_getcwd();
   r->rsprintf("          <td style=\"text-align:left;\">%s</td>\n", cwd.c_str());
   r->rsprintf("        </tr>\n");
 
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">Exptab file:</td>\n");
   r->rsprintf("          <td style=\"text-align:left;\">%s</td>\n", cm_get_exptab_filename().c_str());
   r->rsprintf("        </tr>\n");
 
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">Experiment:</td>\n");
   r->rsprintf("          <td style=\"text-align:left;\">%s</td>\n", cm_get_experiment_name().c_str());
   r->rsprintf("        </tr>\n");
 
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">Experiment directory:</td>\n");
   r->rsprintf("          <td style=\"text-align:left;\">%s</td>\n", cm_get_path().c_str());
   r->rsprintf("        </tr>\n");
 
   STRING_LIST list;
   status = cm_msg_facilities(&list);
 
   if (status == CM_SUCCESS) {
      if (list.size() == 1) {
         r->rsprintf("        <tr>\n");
         r->rsprintf("          <td style=\"text-align:right;\">System logfile:</td>\n");
         std::string s;
         cm_msg_get_logfile("midas", 0, &s, NULL, NULL);
         r->rsprintf("          <td style=\"text-align:left;\">%s</td>\n", s.c_str());
         r->rsprintf("        </tr>\n");
      } else {
         r->rsprintf("        <tr>\n");
         r->rsprintf("          <td style=\"text-align:right;\">Logfiles:</td>\n");
         r->rsprintf("          <td style=\"text-align:left;\">\n");
         for (unsigned i=0 ; i<list.size() ; i++) {
            if (i>0)
               r->rsputs("<br />\n");
            std::string s;
            cm_msg_get_logfile(list[i].c_str(), 0, &s, NULL, NULL);
            r->rsputs(s.c_str());
         }
         r->rsprintf("\n          </td>\n");
         r->rsprintf("        </tr>\n");
      }
   }
 
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">Image history:</td>\n");
   r->rsprintf("          <td style=\"text-align:left;\">%s</td>\n", cm_get_history_path("IMAGE").c_str());
   r->rsprintf("        </tr>\n");
 
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">Resource paths:</td>\n");
   r->rsprintf("          <td style=\"text-align:left;\">");
   std::vector<std::string> resource_paths = get_resource_paths();
   for (unsigned i=0; i<resource_paths.size(); i++) {
      if (i>0)
         r->rsputs("<br>");
      r->rsputs(resource_paths[i].c_str());
      std::string exp = cm_expand_env(resource_paths[i].c_str());
      //printf("%d %d [%s] [%s]\n", resource_paths[i].length(), exp.length(), resource_paths[i].c_str(), exp.c_str());
      if (exp != resource_paths[i]) {
         r->rsputs(" (");
         r->rsputs(exp.c_str());
         r->rsputs(")");
      }
   }
   r->rsprintf("          </td>\n");
   r->rsprintf("        </tr>\n");
 
   std::string path;
 
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">midas.css:</td>\n");
   if (open_resource_file("midas.css", &path, NULL))
      r->rsprintf("          <td style=\"text-align:left;\">%s</td>\n", path.c_str());
   else
      r->rsprintf("          <td style=\"text-align:left;\">NOT FOUND</td>\n");
   r->rsprintf("        </tr>\n");
 
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">midas.js:</td>\n");
   if (open_resource_file("midas.js", &path, NULL))
      r->rsprintf("          <td style=\"text-align:left;\">%s</td>\n", path.c_str());
   else
      r->rsprintf("          <td style=\"text-align:left;\">NOT FOUND</td>\n");
   r->rsprintf("        </tr>\n");
 
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">controls.js:</td>\n");
   if (open_resource_file("controls.js", &path, NULL))
      r->rsprintf("          <td style=\"text-align:left;\">%s</td>\n", path.c_str());
   else
      r->rsprintf("          <td style=\"text-align:left;\">NOT FOUND</td>\n");
   r->rsprintf("        </tr>\n");
 
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">mhttpd.js:</td>\n");
   if (open_resource_file("mhttpd.js", &path, NULL))
      r->rsprintf("          <td style=\"text-align:left;\">%s</td>\n", path.c_str());
   else
      r->rsprintf("          <td style=\"text-align:left;\">NOT FOUND</td>\n");
   r->rsprintf("        </tr>\n");
 
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">obsolete.js:</td>\n");
   if (open_resource_file("obsolete.js", &path, NULL))
      r->rsprintf("          <td style=\"text-align:left;\">%s</td>\n", path.c_str());
   else
      r->rsprintf("          <td style=\"text-align:left;\">NOT FOUND</td>\n");
   r->rsprintf("        </tr>\n");
 
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">Obsolete mhttpd.css:</td>\n");
   if (open_resource_file("mhttpd.css", &path, NULL))
      r->rsprintf("          <td style=\"text-align:left;\">%s</td>\n", path.c_str());
   else
      r->rsprintf("          <td style=\"text-align:left;\">NOT FOUND</td>\n");
   r->rsprintf("        </tr>\n");
 
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">JSON-RPC schema:</td>\n");
   r->rsprintf("          <td style=\"text-align:left;\"><a href=\"?mjsonrpc_schema\">json format</a> or <a href=\"?mjsonrpc_schema_text\">text table format</a></td>\n");
   r->rsprintf("        </tr>\n");
 
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">JavaScript examples:</td>\n");
   r->rsprintf("          <td style=\"text-align:left;\"><a href=\"?cmd=example\">example.html</a></td>\n");
   r->rsprintf("        </tr>\n");
 
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">Custom page example:</td>\n");
   r->rsprintf("          <td style=\"text-align:left;\"><a href=\"?cmd=custom_example\">custom_example.html</a></td>\n");
   r->rsprintf("        </tr>\n");
 
   r->rsprintf("        <tr>\n");
   r->rsprintf("          <td style=\"text-align:right;\">MPlot custom plot examples:</td>\n");
   r->rsprintf("          <td style=\"text-align:left;\"><a href=\"?cmd=plot_example\">plot_example.html</a></td>\n");
   r->rsprintf("        </tr>\n");
 
   r->rsprintf("      </table>\n");
   r->rsprintf("    </td>\n");
   r->rsprintf("  </tr>\n");
   r->rsprintf("</table>\n");
 
   r->rsprintf("<table class=\"mtable\" style=\"width: 95%%\">\n");
   r->rsprintf("  <tr>\n");
   r->rsprintf("    <td class=\"mtableheader\">Contributions</td>\n");
   r->rsprintf("  </tr>\n");
   r->rsprintf("  <tr>\n");
   r->rsprintf("    <td>\n");
   r->rsprintf("Pierre-Andre&nbsp;Amaudruz - Sergio&nbsp;Ballestrero - Suzannah&nbsp;Daviel - Peter&nbsp;Green - Qing&nbsp;Gu - Greg&nbsp;Hackman - Gertjan&nbsp;Hofman - Paul&nbsp;Knowles - Exaos&nbsp;Lee - Thomas&nbsp;Lindner - Shuoyi&nbsp;Ma - Rudi&nbsp;Meier - Bill&nbsp;Mills - Glenn&nbsp;Moloney - Dave&nbsp;Morris - John&nbsp;M&nbsp;O'Donnell - Konstantin&nbsp;Olchanski - Chris&nbsp;Pearson - Renee&nbsp;Poutissou - Stefan&nbsp;Ritt - Zaher&nbsp;Salman - Ryu&nbsp;Sawada - Tamsen&nbsp;Schurman - Ben&nbsp;Smith - Andreas&nbsp;Suter - Jan&nbsp;M.&nbsp;Wouters - Piotr&nbsp;Adam&nbsp;Zolnierczuk\n");
   r->rsprintf("    </td>\n");
   r->rsprintf("  </tr>\n");
   r->rsprintf("</table>\n");
 
   r->rsprintf("</div></form>\n");
   r->rsprintf("</body></html>\r\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_hist_config_page()

void show_hist_config_page	(	MVOdb *	odb,
		Param *	p,
		Return *	r,
		const char *	hgroup,
		const char *	hpanel
	)

Definition at line 10519 of file mhttpd.cxx.

{
   int status;
   int max_display_events = 20;
   int max_display_tags = 200;
   char str[256], hcmd[256];
 
   odb->RI("History/MaxDisplayEvents", &max_display_events, true);
   odb->RI("History/MaxDisplayTags", &max_display_tags, true);
 
   mstrlcpy(hcmd, p->getparam("hcmd"), sizeof(hcmd));
 
   if (equal_ustring(hcmd, "Clear history cache")) {
      //printf("clear history cache!\n");
      strcpy(hcmd, "Refresh");
      MidasHistoryInterface *mh = get_history();
      if (mh)
         mh->hs_clear_cache();
   }
 
   //printf("cmd [%s]\n", cmd);
   //printf("cmdx [%s]\n", p->getparam("cmdx"));
 
   HistPlot hp;
 
   if (equal_ustring(hcmd, "refresh") || equal_ustring(hcmd, "save")) {
      LoadHistPlotFromParam(&hp, p);
      DeleteHistPlotDeleted(hp);
   } else {
      LoadHistPlotFromOdb(odb, &hp, hgroup, hpanel);
   }
 
   SortHistPlotVars(hp);
 
   if (strlen(p->getparam("seln")) > 0)
      AddHistPlotSelectedParam(hp, p);
 
   //hp->Print();
 
   if (hcmd[0] && equal_ustring(hcmd, "save")) {
      SaveHistPlotToOdb(odb, hp, hgroup, hpanel);
 
      if (p->getparam("redir") && *p->getparam("redir"))
         redirect(r, p->getparam("redir"));
      else {
         sprintf(str, "?cmd=oldhistory&group=%s&panel=%s", hgroup, hpanel);
         redirect(r, str);
      }
      return;
   }
 
   show_header(r, "History Config", "GET", "", 0);
   r->rsprintf("</table>");  //close header table
 
   r->rsprintf("<table class=\"mtable\">"); //open main table
 
   r->rsprintf("<tr><th colspan=11 class=\"subStatusTitle\">History Panel \"%s\" / \"%s\"</th></tr>\n", hgroup, hpanel);
 
   /* menu buttons */
   r->rsprintf("<tr><td colspan=11>\n");
 
   r->rsprintf("<input type=button value=Refresh ");
   r->rsprintf("onclick=\"document.form1.hcmd.value='Refresh';document.form1.submit()\">\n");
 
   r->rsprintf("<input type=button value=Save ");
   r->rsprintf("onclick=\"document.form1.hcmd.value='Save';document.form1.submit()\">\n");
 
   {
   r->rsprintf("<input type=button value=Cancel ");
   std::string url = "?cmd=oldhistory&group=";
   url += hgroup;
   url += "&panel=";
   url += hpanel;
   url += "&hcmd=Cancel";
   if (p->getparam("redir")) {
      url += "&redir=";
      url += urlEncode(p->getparam("redir"));
   }
   r->rsprintf("onclick=\"window.location.search='%s'\">\n", url.c_str());
   }
   {
   r->rsprintf("<input type=button value=\"Edit in ODB\"");
   std::string url = "?cmd=odb&odb_path=";
   url += "/History/Display/";
   url += urlEncode(hgroup);
   url += "/";
   url += urlEncode(hpanel);
   r->rsprintf("onclick=\"window.location.search='%s'\">\n", url.c_str());
   }
   {
   r->rsprintf("<input type=button value=\"Edit in new editor\"");
   std::string url = "?cmd=hs_edit";
   url += "&group=";
   url += urlEncode(hgroup);
   url += "&panel=";
   url += urlEncode(hpanel);
   if (p->getparam("redir")) {
      url += "&redir=";
      url += urlEncode(p->getparam("redir"));
   }
   r->rsprintf("onclick=\"window.location.search='%s'\">\n", url.c_str());
   }
   r->rsprintf("<input type=button value=\"Clear history cache\"");
   r->rsprintf("onclick=\"document.form1.hcmd.value='Clear history cache';document.form1.submit()\">\n");
   r->rsprintf("<input type=button value=\"Delete panel\"");
   r->rsprintf("onclick=\"window.location.search='?cmd=oldhistory&group=%s&panel=%s&hcmd=Delete%%20panel'\">\n", hgroup, hpanel);
   r->rsprintf("</td></tr>\n");
 
   r->rsprintf("<tr><td colspan=11>\n");
 
   /* sort_vars */
   int sort_vars = *p->getparam("sort_vars");
   r->rsprintf("<input type=checkbox %s name=sort_vars value=1 onclick=\"this.form.submit();\">Sort variable names", sort_vars?"checked":"");
 
   /* old_vars */
   int old_vars = *p->getparam("old_vars");
   r->rsprintf("&nbsp;&nbsp;<input type=checkbox %s name=old_vars value=1 onclick=\"this.form.submit();\">Show deleted and renamed variables", old_vars?"checked":"");
 
   if (hp.show_factor)
      r->rsprintf("&nbsp;&nbsp;<input type=checkbox checked name=show_factor value=1 onclick=\"document.form1.hcmd.value='Refresh';document.form1.submit()\">");
   else
      r->rsprintf("&nbsp;&nbsp;<input type=checkbox name=show_factor value=1 onclick=\"document.form1.hcmd.value='Refresh';document.form1.submit()\">");
   r->rsprintf("Show&nbsp;factor&nbsp;and&nbsp;offset\n");
 
   /* hidden command for refresh */
   r->rsprintf("<input type=hidden name=cmd value=Oldhistory>\n");
   r->rsprintf("<input type=hidden name=hcmd value=Refresh>\n");
   r->rsprintf("<input type=hidden name=panel value=\"%s\">\n", hpanel);
   r->rsprintf("<input type=hidden name=group value=\"%s\">\n", hgroup);
 
   if (p->getparam("redir") && *p->getparam("redir"))
      r->rsprintf("<input type=hidden name=redir value=\"%s\">\n", p->getparam("redir"));
 
   r->rsprintf("</td></tr>\n");
 
   r->rsprintf("<tr><td colspan=4 style='text-align:right'>Time scale (in units 'm', 'h', 'd'):</td>\n");
   r->rsprintf("<td colspan=3><input type=text size=12 name=timescale value=%s></td><td colspan=4></td></tr>\n", hp.timescale.c_str());
 
   r->rsprintf("<tr><td colspan=4 style='text-align:right'>Minimum (set to '-inf' for autoscale):</td>\n");
   r->rsprintf("<td colspan=3><input type=text size=12 name=minimum value=%f></td><td colspan=4></td></tr>\n", hp.minimum);
 
   r->rsprintf("<tr><td colspan=4 style='text-align:right'>Maximum (set to 'inf' for autoscale):</td>\n");
   r->rsprintf("<td colspan=3><input type=text size=12 name=maximum value=%f></td><td colspan=4></td></tr>\n", hp.maximum);
 
   r->rsprintf("<tr><td colspan=11>");
   
   if (hp.zero_ylow)
      r->rsprintf("<input type=checkbox checked name=zero_ylow value=1>");
   else
      r->rsprintf("<input type=checkbox name=zero_ylow value=1>");
   r->rsprintf("Zero&nbsp;Y;&nbsp;axis\n");
 
   if (hp.log_axis)
      r->rsprintf("<input type=checkbox checked name=log_axis value=1>");
   else
      r->rsprintf("<input type=checkbox name=log_axis value=1>");
   r->rsprintf("Logarithmic&nbsp;Y&nbsp;axis\n");
 
   if (hp.show_run_markers)
      r->rsprintf("&nbsp;&nbsp;<input type=checkbox checked name=run_markers value=1>");
   else
      r->rsprintf("&nbsp;&nbsp;<input type=checkbox name=run_markers value=1>");
   r->rsprintf("Show&nbsp;run&nbsp;markers\n");
 
   if (hp.show_values)
      r->rsprintf("&nbsp;&nbsp;<input type=checkbox checked name=show_values value=1>");
   else
      r->rsprintf("&nbsp;&nbsp;<input type=checkbox name=show_values value=1>");
   r->rsprintf("Show&nbsp;values&nbsp;of&nbsp;variables\n");
 
   if (hp.show_fill)
      r->rsprintf("&nbsp;&nbsp;<input type=checkbox checked name=show_fill value=1>");
   else
      r->rsprintf("&nbsp;&nbsp;<input type=checkbox name=show_fill value=1>");
   r->rsprintf("Show&nbsp;graph&nbsp;fill\n");
 
   r->rsprintf("</td></tr>\n");
 
   /*---- events and variables ----*/
 
   /* get display event name */
 
   MidasHistoryInterface* mh = get_history();
   if (mh == NULL) {
      r->rsprintf(str, "History is not configured\n");
      return;
   }
 
   time_t t = time(NULL);
 
   if (old_vars)
      t = 0;
 
   std::vector<std::string> events;
 
   if (!old_vars)
      hs_read_event_list(&events);
 
   if (events.size() == 0)
      mh->hs_get_events(t, &events);
 
#if 0
   for (unsigned i=0; i<events.size(); i++)
      printf("event %d: \"%s\"\n", i, events[i].c_str());
#endif
 
   // has to be sorted or equipment name code below would not work
   //std::sort(events.begin(), events.end(), cmp_events);
   std::sort(events.begin(), events.end(), cmp_events1);
 
   if (strlen(p->getparam("cmdx")) > 0) {
      r->rsprintf("<tr><th colspan=8 class=\"subStatusTitle\">List of available history variables</th></tr>\n");
      r->rsprintf("<tr><th colspan=1>Sel<th colspan=1>Equipment<th colspan=1>Event<th colspan=1>Variable</tr>\n");
 
      std::string cmdx = p->xgetparam("cmdx");
      std::string xeqname;
 
      int i=0;
      for (unsigned e=0; e<events.size(); e++) {
         std::string eqname;
         eqname = events[e].substr(0, events[e].find("/"));
 
         if (eqname.length() < 1)
            eqname = events[e];
 
         bool once = false;
         if (eqname != xeqname)
            once = true;
 
         std::string qcmd = "Expand " + eqname;
 
         //printf("param [%s] is [%s]\n", qcmd.c_str(), p->getparam(qcmd.c_str()));
 
         bool collapsed = true;
 
         if (cmdx == qcmd)
            collapsed = false;
 
         if (strlen(p->getparam(qcmd.c_str())) > 0)
            collapsed = false;
 
         if (collapsed) {
            if (eqname == xeqname)
               continue;
 
            r->rsprintf("<tr align=left>\n");
            r->rsprintf("<td></td>\n");
            r->rsprintf("<td>%s</td>\n", eqname.c_str());
            r->rsprintf("<td><input type=submit name=cmdx value=\"%s\"></td>\n", qcmd.c_str());
            r->rsprintf("<td>%s</td>\n", "");
            r->rsprintf("</tr>\n");
            xeqname = eqname;
            continue;
         }
 
         if (once)
            r->rsprintf("<tr><input type=hidden name=\"%s\" value=%d></tr>\n", qcmd.c_str(), 1);
 
         std::string rcmd = "Expand " + events[e];
 
         //printf("param [%s] is [%s]\n", rcmd.c_str(), p->getparam(rcmd.c_str()));
 
         collapsed = true;
 
         if (cmdx == rcmd)
            collapsed = false;
 
         if (strlen(p->getparam(rcmd.c_str())) > 0)
            collapsed = false;
 
         if (collapsed) {
            r->rsprintf("<tr align=left>\n");
            r->rsprintf("<td></td>\n");
            r->rsprintf("<td>%s</td>\n", eqname.c_str());
            r->rsprintf("<td>%s</td>\n", events[e].c_str());
            r->rsprintf("<td><input type=submit name=cmdx value=\"%s\"></td>\n", rcmd.c_str());
            r->rsprintf("</tr>\n");
            continue;
         }
 
         r->rsprintf("<tr><input type=hidden name=\"%s\" value=%d></tr>\n", rcmd.c_str(), 1);
 
         xeqname = eqname;
 
         std::vector<TAG> tags;
 
         status = mh->hs_get_tags(events[e].c_str(), t, &tags);
 
         if (status == HS_SUCCESS && tags.size() > 0) {
 
            if (sort_vars)
               std::sort(tags.begin(), tags.end(), cmp_tags);
 
            for (unsigned v=0; v<tags.size(); v++) {
 
               for (unsigned j=0; j<tags[v].n_data; j++) {
                  char tagname[256];
 
                  if (tags[v].n_data == 1)
                     sprintf(tagname, "%s", tags[v].name);
                  else
                     sprintf(tagname, "%s[%d]", tags[v].name, j);
 
        bool checked = false;
#if 0
        for (int index=0; index<MAX_VARS; index++) {
          if (equal_ustring(vars[index].event_name, events[e].c_str()) && equal_ustring(vars[index].var_name, tagname)) {
            checked = true;
            break;
          }
        }
#endif
 
        r->rsprintf("<tr align=left>\n");
        r->rsprintf("<td><input type=checkbox %s name=\"sel%d\" value=\"%s:%s\"></td>\n", checked?"checked":"", i++, events[e].c_str(), tagname);
        r->rsprintf("<td>%s</td>\n", eqname.c_str());
        r->rsprintf("<td>%s</td>\n", events[e].c_str());
        r->rsprintf("<td>%s</td>\n", tagname);
        r->rsprintf("</tr>\n");
          }
       }
    }
      }
 
      r->rsprintf("<tr>\n");
      r->rsprintf("<td></td>\n");
      r->rsprintf("<td>\n");
      r->rsprintf("<input type=hidden name=seln value=%d>\n", i);
      r->rsprintf("<input type=submit value=\"Add Selected\">\n");
      r->rsprintf("</td>\n");
      r->rsprintf("</tr>\n");
   }
 
   r->rsprintf("<tr><td colspan=11 style='text-align:left'>New history: displayed_value = formula(history_value)</td></tr>\n");
   r->rsprintf("<tr><td colspan=11 style='text-align:left'>Old history: displayed_value = offset + factor*(history_value - voffset)</td></tr>\n");
   r->rsprintf("<tr><td colspan=11 style='text-align:left'>Formula format: \"3*x+4\", \"10*Math.sin(x)\", etc. all javascript math functions can be used</td></tr>\n");
   r->rsprintf("<tr><td colspan=11 style='text-align:left'>To display the raw history value instead of computed formula or offset value, check the \"raw\" checkbox</td></tr>\n");
   r->rsprintf("<tr><td colspan=11 style='text-align:left'>To reorder entries: enter new ordering in the \"order\" column and press \"refresh\"</td></tr>\n");
   r->rsprintf("<tr><td colspan=11 style='text-align:left'>To delete entries: enter \"-1\" or leave blank the \"order\" column and press \"refresh\"</td></tr>\n");
 
   r->rsprintf("<tr>\n");
   r->rsprintf("<th>Col<th>Event<th>Variable<th>Formula<th>Colour<th>Label<th>Raw<th>Order");
   if (hp.show_factor) {
      r->rsprintf("<th>Factor<th>Offset<th>VOffset");
   }
   r->rsprintf("</tr>\n");
 
   //print_vars(vars);
 
   size_t nvars = hp.vars.size();
   for (size_t index = 0; index <= nvars; index++) {
 
      r->rsprintf("<tr>");
 
      if (index < nvars) {
         if (hp.vars[index].colour.empty())
            hp.vars[index].colour = NextHistPlotColour(hp);
         r->rsprintf("<td style=\"background-color:%s\">&nbsp;<td>\n", hp.vars[index].colour.c_str());
      } else {
         r->rsprintf("<td>&nbsp;<td>\n");
      }
 
      /* event and variable selection */
 
      r->rsprintf("<select name=\"event%d\" size=1 onChange=\"document.form1.submit()\">\n", (int)index);
 
      /* enumerate events */
 
      /* empty option */
      r->rsprintf("<option value=\"/empty\">&lt;empty&gt;\n");
 
      if (index==nvars) { // last "empty" entry
         for (unsigned e=0; e<events.size(); e++) {
            const char *p = events[e].c_str();
            r->rsprintf("<option value=\"%s\">%s\n", p, p);
         }
      } else if ((int)events.size() > max_display_events) { // too many events
         r->rsprintf("<option selected value=\"%s\">%s\n", hp.vars[index].event_name.c_str(), hp.vars[index].event_name.c_str());
         r->rsprintf("<option>(%d events omitted)\n", (int)events.size());
      } else { // show all events
         bool found = false;
         for (unsigned e=0; e<events.size(); e++) {
            const char *s = "";
            const char *p = events[e].c_str();
            if (equal_ustring(hp.vars[index].event_name.c_str(), p)) {
               s = "selected";
               found = true;
            }
            r->rsprintf("<option %s value=\"%s\">%s\n", s, p, p);
         }
         if (!found) {
            const char *p = hp.vars[index].event_name.c_str();
            r->rsprintf("<option selected value=\"%s\">%s\n", p, p);
         }
      }
 
      r->rsprintf("</select></td>\n");
 
      //if (hp.vars[index].order <= 0)
      //   hp.vars[index].order = (index+1)*10;
 
      if (index < nvars) {
         bool found_tag = false;
         std::string selected_tag = hp.vars[index].tag_name;
 
         r->rsprintf("<td><select name=\"var%d\">\n", (int)index);
 
         std::vector<TAG> tags;
 
         status = mh->hs_get_tags(hp.vars[index].event_name.c_str(), t, &tags);
 
         if (status == HS_SUCCESS && tags.size() > 0) {
 
            if (/* DISABLES CODE */ (0)) {
               printf("Compare %d\n", cmp_names("AAA", "BBB"));
               printf("Compare %d\n", cmp_names("BBB", "AAA"));
               printf("Compare %d\n", cmp_names("AAA", "AAA"));
               printf("Compare %d\n", cmp_names("A", "AAA"));
               printf("Compare %d\n", cmp_names("A111", "A1"));
               printf("Compare %d\n", cmp_names("A111", "A2"));
               printf("Compare %d\n", cmp_names("A111", "A222"));
               printf("Compare %d\n", cmp_names("A111a", "A111b"));
            }
 
            if (sort_vars)
               std::sort(tags.begin(), tags.end(), cmp_tags);
 
            if (/* DISABLES CODE */ (0)) {
               printf("Event [%s] %d tags\n", hp.vars[index].event_name.c_str(), (int)tags.size());
 
               for (unsigned v=0; v<tags.size(); v++) {
                 printf("tag[%d] [%s]\n", v, tags[v].name);
               }
            }
 
            unsigned count_tags = 0;
            for (unsigned v=0; v<tags.size(); v++)
               count_tags += tags[v].n_data;
 
            //printf("output %d option tags\n", count_tags);
 
            if ((int)count_tags < max_display_tags) {
               for (unsigned v=0; v<tags.size(); v++) {
 
                 for (unsigned j=0; j<tags[v].n_data; j++) {
                    std::string tagname;
 
                    if (tags[v].n_data == 1)
                       tagname = tags[v].name;
                    else {
                       char buf[256];
                       sprintf(buf, "[%d]", j);
                       tagname = std::string(tags[v].name) + buf;
                    }
 
                    if (equal_ustring(selected_tag.c_str(), tagname.c_str())) {
                       r->rsprintf("<option selected value=\"%s\">%s\n", tagname.c_str(), tagname.c_str());
                       found_tag = true;
                    }
                    else
                       r->rsprintf("<option value=\"%s\">%s\n", tagname.c_str(), tagname.c_str());
 
                    //printf("%d [%s] [%s] [%s][%s] %d\n", (int)index, vars[index].event_name, tagname, vars[index].var_name, selected_var, found_var);
                 }
               }
            }
         }
 
         if (!found_tag)
            if (hp.vars[index].tag_name.length() > 0)
               r->rsprintf("<option selected value=\"%s\">%s\n", hp.vars[index].tag_name.c_str(), hp.vars[index].tag_name.c_str());
 
         r->rsprintf("</select></td>\n");
         r->rsprintf("<td><input type=text size=15 maxlength=256 name=\"form%d\" value=%s></td>\n", (int)index, hp.vars[index].formula.c_str());
         r->rsprintf("<td><input type=text size=8 maxlength=10 name=\"col%d\" value=%s></td>\n", (int)index, hp.vars[index].colour.c_str());
         r->rsprintf("<td><input type=text size=8 maxlength=%d name=\"lab%d\" value=\"%s\"></td>\n", NAME_LENGTH, (int)index, hp.vars[index].label.c_str());
         if (hp.vars[index].show_raw_value)
            r->rsprintf("<td><input type=checkbox checked name=\"raw%d\" value=1></td>", (int)index);
         else
            r->rsprintf("<td><input type=checkbox name=\"raw%d\" value=1></td>", (int)index);
         r->rsprintf("<td><input type=text size=3 maxlength=32 name=\"ord%d\" value=\"%d\"></td>\n", (int)index, hp.vars[index].order);
         if (hp.show_factor) {
            r->rsprintf("<td><input type=text size=6 maxlength=32 name=\"factor%d\" value=\"%g\"></td>\n", (int)index, hp.vars[index].factor);
            r->rsprintf("<td><input type=text size=6 maxlength=32 name=\"offset%d\" value=\"%g\"></td>\n", (int)index, hp.vars[index].offset);
            r->rsprintf("<td><input type=text size=6 maxlength=32 name=\"voffset%d\" value=\"%g\"></td>\n", (int)index, hp.vars[index].voffset);
         } else {
            r->rsprintf("<input type=hidden name=\"factor%d\" value=\"%f\">\n", (int)index, hp.vars[index].factor);
            r->rsprintf("<input type=hidden name=\"offset%d\" value=\"%f\">\n", (int)index, hp.vars[index].offset);
            r->rsprintf("<input type=hidden name=\"voffset%d\" value=\"%f\">\n", (int)index, hp.vars[index].voffset);
         }
      } else {
         r->rsprintf("<td colspan=2><input type=submit name=cmdx value=\"List all variables\"></td>\n");
      }
 
      r->rsprintf("</tr>\n");
   }
 
   r->rsprintf("</table>\n");
   //r->rsprintf("</form>\n");
   r->rsprintf("</div>\n"); // closing for <div id="mmain">
   r->rsprintf("</form>\n");
   r->rsprintf("</body></html>\r\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_hist_page()

void show_hist_page	(	MVOdb *	odb,
		Param *	p,
		Return *	r,
		const char *	dec_path,
		char *	buffer,
		int *	buffer_size,
		int	refresh
	)

Definition at line 11262 of file mhttpd.cxx.

{
   HNDLE hDB, hkey, hikeyp, hkeyp, hkeybutton;
   KEY key, ikey;
   int i, j, k, scale, index, width, size, status, labels;
   char hgroup[256], hpanel[256], hcmd[256];
   const char def_button[][NAME_LENGTH] = { "10m", "1h", "3h", "12h", "24h", "3d", "7d" };
 
   cm_get_experiment_database(&hDB, NULL);
 
   hcmd[0] = hgroup[0] = hpanel[0] = 0;
 
   if (p->getparam("group") && *p->getparam("group"))
      mstrlcpy(hgroup, p->getparam("group"), sizeof(hgroup));
   if (p->getparam("panel") && *p->getparam("panel"))
      mstrlcpy(hpanel, p->getparam("panel"), sizeof(hpanel));
   if (p->getparam("hcmd") && *p->getparam("hcmd"))
      mstrlcpy(hcmd, p->getparam("hcmd"), sizeof(hcmd));
 
   if (equal_ustring(hcmd, "Reset")) {
      std::string redir;
      //sprintf(str, "?cmd=oldhistory&group=%s&panel=%s", hgroup, hpanel);
      redir += "?cmd=oldhistory&group=";
      redir += hgroup;
      redir += "&panel=";
      redir += hpanel;
      redirect(r, redir.c_str());
      return;
   }
 
   if (equal_ustring(hcmd, "Query")) {
      show_query_page(p, r);
      return;
   }
 
   if (equal_ustring(hcmd, "Cancel")) {
      //sprintf(str, "?cmd=oldhistory&group=%s&panel=%s", hgroup, hpanel);
      if (p->getparam("redir") && *p->getparam("redir"))
         redirect(r, p->getparam("redir"));
      else {
         std::string redir;
         redir += "?cmd=oldhistory&group=";
         redir += hgroup;
         redir += "&panel=";
         redir += hpanel;
         redirect(r, redir.c_str());
      }
      return;
   }
 
   if (equal_ustring(hcmd, "Config") ||
       equal_ustring(hcmd, "Save")
       || equal_ustring(hcmd, "Clear history cache")
       || equal_ustring(hcmd, "Refresh")) {
 
      show_hist_config_page(odb, p, r, hgroup, hpanel);
      return;
   }
 
   if (equal_ustring(hcmd, "New")) {
      show_header(r, "History", "GET", "", 0);
 
      r->rsprintf("<table class=\"dialogTable\">");
      r->rsprintf("<tr><th class=\"subStatusTitle\" colspan=2>New History Item</th><tr>");
      r->rsprintf("<tr><td align=center colspan=2>\n");
      r->rsprintf("Select group: &nbsp;&nbsp;");
      r->rsprintf("<select id=\"group\" name=\"group\">\n");
 
      /* list existing groups */
      db_find_key(hDB, 0, "/History/Display", &hkey);
      if (hkey) {
         for (i = 0;; i++) {
            db_enum_link(hDB, hkey, i, &hkeyp);
 
            if (!hkeyp)
               break;
 
            db_get_key(hDB, hkeyp, &key);
            if (equal_ustring(hgroup, key.name))
               r->rsprintf("<option selected>%s</option>\n", key.name);
            else
               r->rsprintf("<option>%s</option>\n", key.name);
         }
      }
      if (!hkey || i == 0)
         r->rsprintf("<option>Default</option>\n");
      r->rsprintf("</select><p>\n");
 
      r->rsprintf("Or enter new group name: &nbsp;&nbsp;");
      r->rsprintf("<input type=text size=15 maxlength=31 id=new_group name=new_group>\n");
 
      r->rsprintf("<tr><td align=center colspan=2>\n");
      r->rsprintf("<br>Panel name: &nbsp;&nbsp;");
      r->rsprintf("<input type=text size=15 maxlength=31 id=panel name=panel><br><br>\n");
      r->rsprintf("</td></tr>\n");
 
      r->rsprintf("<tr><td align=center colspan=2>");
      std::string str = "?cmd=oldhistory&hcmd=createnew";
      str += "&new_group='+document.getElementById('new_group').value+'";
      str += "&group='+document.getElementById('group').value+'";
      str += "&panel='+document.getElementById('panel').value+'";
      r->rsprintf("<input type=button value=Submit onclick=\"window.location.search='%s'\">\n", str.c_str());
      r->rsprintf("</td></tr>\n");
 
      r->rsprintf("</table>\r\n");
      r->rsprintf("</div>\n"); // closing for <div id="mmain">
      r->rsprintf("</form>\n");
      r->rsprintf("</body></html>\r\n");
      return;
   }
 
   if (equal_ustring(hcmd, "Delete Panel")) {
      std::string path;
      //sprintf(str, "/History/Display/%s/%s", hgroup, hpanel);
      path += "/History/Display/";
      path += hgroup;
      path += "/";
      path += hpanel;
      if (db_find_key(hDB, 0, path.c_str(), &hkey)==DB_SUCCESS)
         db_delete_key(hDB, hkey, FALSE);
 
      redirect(r, "?cmd=oldhistory");
      return;
   }
 
   if (equal_ustring(hcmd, "createnew")) {
 
      /* strip leading/trailing spaces */
      while (hpanel[0] == ' ') {
         char str[256];
         mstrlcpy(str, hpanel+1, sizeof(str));
         mstrlcpy(hpanel, str, sizeof(hpanel));
      }
      while (strlen(hpanel)> 1 && hpanel[strlen(hpanel)-1] == ' ')
         hpanel[strlen(hpanel)-1] = 0;
 
      /* use new group if present */
      if (p->isparam("new_group") && *p->getparam("new_group"))
         mstrlcpy(hgroup, p->getparam("new_group"), sizeof(hgroup));
 
      /* configure that panel */
      show_hist_config_page(odb, p, r, hgroup, hpanel);
      return;
   }
 
   const char* pscale = p->getparam("scale");
   if (pscale == NULL || *pscale == 0)
      pscale = p->getparam("hscale");
   const char* pwidth = p->getparam("width");
   if (pwidth == NULL || *pwidth == 0)
      pwidth = p->getparam("hwidth");
   const char* pheight = p->getparam("height");
   if (pheight == NULL || *pheight == 0)
      pheight = p->getparam("hheight");
   const char* pindex = p->getparam("index");
   if (pindex == NULL || *pindex == 0)
      pindex = p->getparam("hindex");
 
   labels = 1;
   if (*p->getparam("labels") && atoi(p->getparam("labels")) == 0)
      labels = 0;
 
   std::string bgcolor = "FFFFFF";
   if (*p->getparam("bgcolor"))
      bgcolor = p->xgetparam("bgcolor");
 
   std::string fgcolor = "000000";
   if (*p->getparam("fgcolor"))
      fgcolor = p->xgetparam("fgcolor");
 
   std::string gridcolor = "A0A0A0";
   if (*p->getparam("gcolor"))
      gridcolor = p->xgetparam("gcolor");
 
   /* evaluate scale and offset */
 
   time_t endtime = 0;
   if (p->isparam("time"))
      endtime = string_to_time(p->getparam("time"));
   else if (p->isparam("htime"))
      endtime = string_to_time(p->getparam("htime"));
 
   if (pscale && *pscale)
      scale = time_to_sec(pscale);
   else
      scale = 0;
 
   index = -1;
   if (pindex && *pindex)
      index = atoi(pindex);
 
#ifdef BROKEN
   if (equal_ustring(hcmd, "Create ELog")) {
      std::string xurl;
      status = db_get_value_string(hDB, 0, "/Elog/URL", 0, &xurl, FALSE);
      if (status == DB_SUCCESS) {
         char url[256];
         get_elog_url(url, sizeof(url));
 
         /*---- use external ELOG ----*/
         fsize = 100000;
         char* fbuffer = (char*)M_MALLOC(fsize);
         assert(fbuffer != NULL);
 
         int width = 640;
         int height = 400;
 
         if (equal_ustring(pmag, "Large")) {
            width = 1024;
            height = 768;
         } else if (equal_ustring(pmag, "Small")) {
            width = 320;
            height = 200;
         } else if (atoi(pmag) > 0) {
            width = atoi(pmag);
            height = 200;
         }
 
         printf("hereA\n");
         generate_hist_graph(odb, r, hgroup, hpanel, fbuffer, &fsize, width, height, endtime, scale, index, labels, bgcolor.c_str(), fgcolor.c_str(), gridcolor.c_str());
 
         /* save temporary file */
         std::string dir;
         db_get_value_string(hDB, 0, "/Elog/Logbook Dir", 0, &dir, TRUE);
         if (dir.length() > 0 && dir[dir.length()-1] != DIR_SEPARATOR)
            dir += DIR_SEPARATOR_STR;
 
         time_t now = time(NULL);
         localtime_r(&now, &tms);
 
         std::string file_name = msprintf("%02d%02d%02d_%02d%02d%02d_%s.gif",
                  tms.tm_year % 100, tms.tm_mon + 1, tms.tm_mday,
                  tms.tm_hour, tms.tm_min, tms.tm_sec, hpanel);
         std::string fname = dir + file_name;
 
         /* save attachment */
         fh = open(fname.c_str(), O_CREAT | O_RDWR | O_BINARY, 0644);
         if (fh < 0) {
            cm_msg(MERROR, "show_hist_page", "Cannot write attachment file \"%s\", open() errno %d (%s)", fname.c_str(), errno, strerror(errno));
         } else {
            int wr = write(fh, fbuffer, fsize);
            if (wr != fsize) {
               cm_msg(MERROR, "show_hist_page", "Cannot write attachment file \"%s\", write(%d) returned %d, errno %d (%s)", fname.c_str(), fsize, wr, errno, strerror(errno));
            }
            close(fh);
         }
 
         /* redirect to ELOG */
         if (strlen(url) > 1 && url[strlen(url)-1] != '/')
            mstrlcat(url, "/", sizeof(url));
         mstrlcat(url, "?cmd=New&fa=", sizeof(url));
         mstrlcat(url, file_name, sizeof(url));
         redirect(r, url);
 
         M_FREE(fbuffer);
         return;
 
      } else {
         /*---- use internal ELOG ----*/
         std::string str = msprintf("\\HS\\%s.gif", hpanel);
         if (p->getparam("hscale") && *p->getparam("hscale"))
            str += msprintf("?scale=%s", p->getparam("hscale"));
         if (p->getparam("htime") && *p->getparam("htime")) {
            if (strchr(str.c_str(), '?'))
               str += "&";
            else
               str += "?";
            str += msprintf("time=%s", p->getparam("htime"));
         }
         //if (p->getparam("hoffset") && *p->getparam("hoffset")) {
         //   if (strchr(str, '?'))
         //      mstrlcat(str, "&", sizeof(str));
         //   else
         //      mstrlcat(str, "?", sizeof(str));
         //   sprintf(str + strlen(str), "offset=%s", p->getparam("hoffset"));
         //}
         if (p->getparam("hwidth") && *p->getparam("hwidth")) {
            if (strchr(str.c_str(), '?'))
               str += "&";
            else
               str += "?";
            str += msprintf("width=%s", p->getparam("hwidth"));
         }
         if (p->getparam("hindex") && *p->getparam("hindex")) {
            if (strchr(str.c_str(), '?'))
               str += "&";
            else
               str += "?";
            str += msprintf("index=%s", p->getparam("hindex"));
         }
 
         show_elog_new(r, hpanel, NULL, FALSE, str.c_str(), "../../EL/");
         return;
      }
   }
#endif
 
   if (equal_ustring(hcmd, "Export")) {
      export_hist(odb, r, hgroup, hpanel, endtime, scale, index, labels);
      return;
   }
 
   if (strstr(dec_path, ".gif")) {
      int width =  640;
      int height = 400;
      if (equal_ustring(pwidth, "Large")) {
         width = 1024;
         height = 768;
      } else if (equal_ustring(pwidth, "Small")) {
         width = 320;
         height = 200;
      } else if (atoi(pwidth) > 0) {
         width = atoi(pwidth);
         if (atoi(pheight) > 0)
            height = atoi(pheight);
         else
            height = (int)(0.625 * width);
      }
 
      //printf("dec_path [%s], buf %p, %p, width %d, height %d, endtime %ld, scale %d, index %d, labels %d\n", dec_path, buffer, buffer_size, width, height, endtime, scale, index, labels);
 
      generate_hist_graph(odb, r, hgroup, hpanel, buffer, buffer_size, width, height, endtime, scale, index, labels, bgcolor.c_str(), fgcolor.c_str(), gridcolor.c_str());
 
      return;
   }
 
   if (history_mode && index < 0)
      return;
 
   time_t now = time(NULL);
 
   /* evaluate offset shift */
   if (equal_ustring(p->getparam("shift"), "leftmaxall")) {
      if (endtime == 0)
         endtime = now;
      time_t last_written = 0;
      status = get_hist_last_written(odb, hgroup, hpanel, endtime, index, 1, &last_written);
      if (status == HS_SUCCESS)
         endtime = last_written + scale/2;
   }
 
   if (equal_ustring(p->getparam("shift"), "leftmax")) {
      if (endtime == 0)
         endtime = now;
      time_t last_written = 0;
      status = get_hist_last_written(odb, hgroup, hpanel, endtime, index, 0, &last_written);
      if (status == HS_SUCCESS)
         if (last_written != endtime)
            endtime = last_written + scale/2;
   }
 
   if (equal_ustring(p->getparam("shift"), "left")) {
      if (endtime == 0)
         endtime = now;
      endtime -= scale/2;
      //offset -= scale / 2;
   }
 
   if (equal_ustring(p->getparam("shift"), "right")) {
      if (endtime == 0)
         endtime = now;
      endtime += scale/2;
      if (endtime > now)
         endtime = now;
   }
 
   if (equal_ustring(p->getparam("shift"), "rightmax")) {
      endtime = 0;
   }
 
   if (equal_ustring(p->getparam("shift"), "zoomin")) {
      if (endtime == 0)
         endtime = now;
      endtime -= scale / 4;
      scale /= 2;
   }
 
   if (equal_ustring(p->getparam("shift"), "zoomout")) {
      if (endtime == 0)
         endtime = now;
      endtime += scale / 2;
      if (endtime > now)
         endtime = now;
      scale *= 2;
   }
 
   int xrefresh = refresh;
   if (endtime != 0)
      xrefresh = 0;
   show_header(r, hpanel, "GET", "", xrefresh);
 
   r->rsprintf("<script type=\"text/javascript\" src=\"midas.js\"></script>\n");
   r->rsprintf("<script type=\"text/javascript\" src=\"mhttpd.js\"></script>\n");
   show_navigation_bar(r, "History");
 
   r->rsprintf("<table class=\"mtable\">");
   r->rsprintf("<tr><th class=\"mtableheader\" colspan=2>History</th></tr>");
 
   {
      /* check if panel exists */
      std::string path;
      //sprintf(str, "/History/Display/%s/%s", hgroup, hpanel);
      path += "/History/Display/";
      path += hgroup;
      path += "/";
      path += hpanel;
      status = db_find_key(hDB, 0, path.c_str(), &hkey);
      if (status != DB_SUCCESS && !equal_ustring(hpanel, "All") && !equal_ustring(hpanel,"")) {
         r->rsprintf("<h1>Error: History panel \"%s\" in group \"%s\" does not exist</h1>\n", hpanel, hgroup);
         r->rsprintf("</table>\r\n");
         r->rsprintf("</div>\n"); // closing for <div id="mmain">
         r->rsprintf("</form>\n");
         r->rsprintf("</body></html>\r\n");
         return;
      }
   }
 
   /* define hidden field for parameters */
   if (pscale && *pscale)
      r->rsprintf("<input type=hidden name=hscale id=hscale value=%d>\n", scale);
   else {
      /* if no scale and offset given, get it from default */
      if (hpanel[0] && !equal_ustring(hpanel, "All") && hgroup[0]) {
         std::string path;
         path += "/History/Display/";
         path += hgroup;
         path += "/";
         path += hpanel;
         path += "/Timescale";
 
         std::string scalestr = "1h";
         status = db_get_value_string(hDB, 0, path.c_str(), 0, &scalestr, TRUE);
         if (status != DB_SUCCESS) {
            /* delete old integer key */
            db_find_key(hDB, 0, path.c_str(), &hkey);
            if (hkey)
               db_delete_key(hDB, hkey, FALSE);
 
            scalestr = "1h";
            db_get_value_string(hDB, 0, path.c_str(), 0, &scalestr, TRUE);
         }
 
         r->rsprintf("<input type=hidden name=hscale id=hscale value=%s>\n", scalestr.c_str());
         scale = time_to_sec(scalestr.c_str());
      }
   }
 
   if (endtime != 0)
      r->rsprintf("<input type=hidden name=htime id=htime value=%s>\n", time_to_string(endtime).c_str());
   if (pwidth && *pwidth)
      r->rsprintf("<input type=hidden name=hwidth id=hwidth value=%s>\n", pwidth);
   if (pheight && *pheight)
      r->rsprintf("<input type=hidden name=hheight id=hheight value=%s>\n", pheight);
   if (pindex && *pindex)
      r->rsprintf("<input type=hidden name=hindex id=hindex value=%s>\n", pindex);
 
   r->rsprintf("</td></tr>\n");
 
   if (hgroup[0] == 0) {
      /* "New" button */
      r->rsprintf("<tr><td colspan=2><input type=\"button\" name=\"New\" value=\"New\" ");
      r->rsprintf("onClick=\"window.location.href='?cmd=oldhistory&hcmd=New'\"></td></tr>\n");
 
      /* links for history panels */
      r->rsprintf("<tr><td colspan=2 style=\"text-align:left;\">\n");
      if (!hpanel[0])
         r->rsprintf("<b>Please select panel:</b><br>\n");
 
      /* table for panel selection */
      r->rsprintf("<table class=\"historyTable\">");
 
      /* "All" link */
      r->rsprintf("<tr><td colspan=2 class=\"titleCell\">\n");
      if (equal_ustring(hgroup, "All"))
         r->rsprintf("All &nbsp;&nbsp;");
      else
         r->rsprintf("<a href=\"?cmd=oldhistory&group=All\">ALL</a>\n");
      r->rsprintf("</td></tr>\n");
 
      /* Setup History table links */
      db_find_key(hDB, 0, "/History/Display", &hkey);
      if (!hkey) {
         /* create default panel */
         char str[256];
         strcpy(str, "System:Trigger per sec.");
         strcpy(str + 2 * NAME_LENGTH, "System:Trigger kB per sec.");
         db_set_value(hDB, 0, "/History/Display/Default/Trigger rate/Variables", str, 64, 2, TID_STRING);
         strcpy(str, "1h");
         db_set_value(hDB, 0, "/History/Display/Default/Trigger rate/Time Scale", str, NAME_LENGTH, 1, TID_STRING);
 
         strcpy(str, "1h");
         db_set_value(hDB, 0, "/History/Display/Default/Trigger rate/Timescale", str, NAME_LENGTH, 1, TID_STRING);
         i = 1;
         db_set_value(hDB, 0, "/History/Display/Default/Trigger rate/Zero ylow", &i, sizeof(BOOL), 1, TID_BOOL);
         i = 1;
         db_set_value(hDB, 0, "/History/Display/Default/Trigger rate/Show run markers", &i, sizeof(BOOL), 1, TID_BOOL);
 
         strcpy(str, "");
         db_set_value(hDB, 0, "/History/Display/Default/Trigger rate/Formula", str, 64, 1, TID_STRING);
         db_set_value_index(hDB, 0, "/History/Display/Default/Trigger rate/Formula", str, 64, 1, TID_STRING, FALSE);
      }
 
      db_find_key(hDB, 0, "/History/Display", &hkey);
      if (hkey) {
         for (i = 0;; i++) {
            db_enum_link(hDB, hkey, i, &hkeyp);
 
            if (!hkeyp)
               break;
 
            // Group key
            db_get_key(hDB, hkeyp, &key);
 
            char enc_name[256];
            mstrlcpy(enc_name, key.name, sizeof(enc_name));
            urlEncode(enc_name, sizeof(enc_name));
 
            if (equal_ustring(hpanel, key.name))
               r->rsprintf("<tr><td class=\"titleCell\">%s</td>\n<td>", key.name);
            else
               r->rsprintf("<tr><td class=\"titleCell\"><a href=\"?cmd=oldhistory&group=%s\">%s</a></td>\n<td>", enc_name, key.name);
 
            for (j = 0;; j++) {
               // scan items
               db_enum_link(hDB, hkeyp, j, &hikeyp);
 
               if (!hikeyp) {
                  r->rsprintf("</tr>");
                  break;
               }
               // Item key
               db_get_key(hDB, hikeyp, &ikey);
 
               char enc_iname[256];
               mstrlcpy(enc_iname, ikey.name, sizeof(enc_iname));
               urlEncode(enc_iname, sizeof(enc_iname));
 
               if (equal_ustring(hpanel, ikey.name))
                  r->rsprintf("<small><b>%s</b></small> &nbsp;", ikey.name);
               else
                  r->rsprintf("<small><a href=\"?cmd=oldhistory&group=%s&panel=%s\">%s</a></small> &nbsp;\n", enc_name, enc_iname, ikey.name);
            }
         }
      }
 
      r->rsprintf("</table></tr>\n");
 
   } else {
      int found = 0;
 
      /* show drop-down selectors */
      r->rsprintf("<tr><td colspan=2>\n");
 
      r->rsprintf("Group:\n");
 
      r->rsprintf("<select title=\"Select group\" id=\"fgroup\" onChange=\"window.location.search='?cmd=oldhistory&group='+document.getElementById('fgroup').value;\">\n");
 
      db_find_key(hDB, 0, "/History/Display", &hkey);
      if (hkey) {
         hkeyp = 0;
         for (i = 0;; i++) {
            db_enum_link(hDB, hkey, i, &hikeyp);
 
            if (!hikeyp)
               break;
 
            if (i == 0)
               hkeyp = hikeyp;
 
            // Group key
            db_get_key(hDB, hikeyp, &key);
 
            if (equal_ustring(key.name, hgroup)) {
               r->rsprintf("<option selected value=\"%s\">%s\n", key.name, key.name);
               hkeyp = hikeyp;
            } else
               r->rsprintf("<option value=\"%s\">%s\n", key.name, key.name);
         }
 
         if (equal_ustring("ALL", hgroup)) {
            r->rsprintf("<option selected value=\"%s\">%s\n", "ALL", "ALL");
         } else {
            r->rsprintf("<option value=\"%s\">%s\n", "ALL", "ALL");
         }
 
         r->rsprintf("</select>\n");
         r->rsprintf("&nbsp;&nbsp;Panel:\n");
         r->rsprintf("<select title=\"Select panel\" id=\"fpanel\" ");
         r->rsprintf("onChange=\"window.location.search='?cmd=oldhistory&group='+document.getElementById('fgroup').value+");
         r->rsprintf("'&panel='+document.getElementById('fpanel').value;\">\n");
 
         found = 0;
         if (hkeyp) {
            for (i = 0;; i++) {
               // scan panels
               db_enum_link(hDB, hkeyp, i, &hikeyp);
 
               if (!hikeyp)
                  break;
 
               // Item key
               db_get_key(hDB, hikeyp, &key);
 
               if (equal_ustring(hpanel, key.name)) {
                  r->rsprintf("<option selected value=\"%s\">%s\n", key.name, key.name);
                  found = 1;
               } else
                  r->rsprintf("<option value=\"%s\">%s\n", key.name, key.name);
            }
         }
 
         if (found)
            r->rsprintf("<option value=\"\">- all -\n");
         else
            r->rsprintf("<option selected value=\"\">- all -\n");
 
         r->rsprintf("</select>\n");
      }
 
      r->rsprintf("<noscript>\n");
      r->rsprintf("<input type=submit value=\"Go\">\n");
      r->rsprintf("</noscript>\n");
 
      r->rsprintf("&nbsp;&nbsp;<input type=\"button\" name=\"New\" value=\"New\" ");
      r->rsprintf("onClick=\"window.location.href='?cmd=oldhistory&hcmd=New&group=%s'\">\n", hgroup);
 
      r->rsprintf("<input type=\"button\" name=\"Cmd\" value=\"Reset\" onClick=\"window.location.href='?cmd=oldhistory&hcmd=Reset&group=%s&panel=%s'\">\n", hgroup, hpanel);
 
      r->rsprintf("<input type=\"button\" name=\"Cmd\" value=\"Query\" onClick=\"window.location.href='?cmd=oldhistory&hcmd=Query&group=%s&panel=%s'\">\n", hgroup, hpanel);
 
      double xendtime = endtime;
      if (xendtime == 0)
         xendtime = now;
      double xstarttime = xendtime - scale;
      
      r->rsprintf("<input type=\"button\" name=\"Cmd\" value=\"New history\" onClick=\"window.location.href='?cmd=history&group=%s&panel=%s&A=%.0f&B=%.0f'\">\n", hgroup, hpanel, xstarttime, xendtime);
 
      r->rsprintf("</td></tr>\n");
   }
 
   //printf("hgroup [%s] hpanel [%s]\n", hgroup, hpanel);
 
   /* check if whole group should be displayed */
   if (hgroup[0] && !equal_ustring(hgroup, "ALL") && hpanel[0] == 0) {
      std::string strwidth = "Small";
      db_get_value_string(hDB, 0, "/History/Display Settings/Width Group", 0, &strwidth, TRUE);
 
      std::string path;
      path += "/History/Display/";
      path += hgroup;
      db_find_key(hDB, 0, path.c_str(), &hkey);
      if (hkey) {
         for (i = 0 ;; i++) {     // scan group
            db_enum_link(hDB, hkey, i, &hikeyp);
 
            if (!hikeyp)
               break;
 
            db_get_key(hDB, hikeyp, &key);
 
            char enc_name[256];
            mstrlcpy(enc_name, key.name, sizeof(enc_name));
            urlEncode(enc_name, sizeof(enc_name));
 
            std::string ref;
            ref += "graph.gif?width=";
            ref += strwidth;
            ref += "&cmd=oldhistory&group=";
            ref += hgroup;
            ref += "&panel=";
            ref += enc_name;
 
            std::string ref2;
            ref2 += "?cmd=oldhistory&group=";
            ref2 += hgroup;
            ref2 += "&panel=";
            ref2 += enc_name;
 
            if (endtime != 0) {
               char tmp[256];
               sprintf(tmp, "time=%s&scale=%d", time_to_string(endtime).c_str(), scale);
               ref += "&";
               ref += tmp;
               ref2 += "?";
               ref2 += tmp;
            }
 
            if (i % 2 == 0)
               r->rsprintf("<tr><td><a href=\"%s\"><img src=\"%s\"></a>\n", ref2.c_str(), ref.c_str());
            else
               r->rsprintf("<td><a href=\"%s\"><img src=\"%s\"></a></tr>\n", ref2.c_str(), ref.c_str());
         }
 
      } else {
         r->rsprintf("Group \"%s\" not found", hgroup);
      }
   }
 
   /* image panel */
   else if (hpanel[0] && !equal_ustring(hpanel, "All")) {
      /* navigation links */
      r->rsprintf("<tr><td>\n");
 
      std::string path;
      path += "/History/Display/";
      path += hgroup;
      path += "/";
      path += hpanel;
      path += "/Buttons";
      db_find_key(hDB, 0, path.c_str(), &hkeybutton);
      if (hkeybutton == 0) {
         /* create default buttons */
         db_create_key(hDB, 0, path.c_str(), TID_STRING);
         status = db_find_key(hDB, 0, path.c_str(), &hkeybutton);
         if (status != DB_SUCCESS || !hkey) {
            cm_msg(MERROR, "show_hist_page", "Cannot create history panel with invalid ODB path \"%s\"", path.c_str());
            return;
         }
         db_set_data(hDB, hkeybutton, def_button, sizeof(def_button), 7, TID_STRING);
      }
 
      r->rsprintf("<script>\n");
      r->rsprintf("function histDisp(p) {\n");
      r->rsprintf("  var params = '?cmd=oldhistory&group=%s&panel=%s';\n", hgroup, hpanel);
      r->rsprintf("  params += '&'+p;\n");
      r->rsprintf("  if (document.getElementById(\'hscale\') !== null)\n");
      r->rsprintf("    params += '&hscale='+document.getElementById(\'hscale\').value;\n");
      r->rsprintf("  if (document.getElementById(\'htime\') !== null)\n");
      r->rsprintf("    params += '&htime='+document.getElementById(\'htime\').value;\n");
      r->rsprintf("  if (document.getElementById(\'hwdith\') !== null)\n");
      r->rsprintf("    params += '&hwidth='+document.getElementById(\'hwidth\').value;\n");
      r->rsprintf("  if (document.getElementById(\'hindex\') !== null)\n");
      r->rsprintf("    params += '&hindex='+document.getElementById(\'hindex\').value;\n");
      r->rsprintf("  window.location.search = params;\n");
      r->rsprintf("}\n\n");
      r->rsprintf("</script>\n");
 
      db_get_key(hDB, hkeybutton, &key);
 
      for (i = 0; i < key.num_values; i++) {
         char str[256];
         size = sizeof(str);
         db_get_data_index(hDB, hkeybutton, str, &size, i, TID_STRING);
         r->rsprintf("<input type=\"button\" title=\"display last %s\" value=%s onclick=\"histDisp('scale=%s')\">\n", str, str, str);
      }
 
      r->rsprintf("<input type=\"button\" value=\"<<<\" title=\"go back in time to last available data for all variables on the plot\" onclick=\"histDisp('shift=leftmaxall')\">");
      r->rsprintf("<input type=\"button\" value=\"<<\" title=\"go back in time to last available data\" onclick=\"histDisp('shift=leftmax')\">");
      r->rsprintf("<input type=\"button\" value=\"<\" title=\"go back in time\" onclick=\"histDisp('shift=left')\">");
 
      r->rsprintf("<input type=\"button\" value=\" + \" title=\"zoom in\" onclick=\"histDisp('shift=zoomin')\">");
      r->rsprintf("<input type=\"button\" value=\" - \" title=\"zoom out\" onclick=\"histDisp('shift=zoomout')\">");
 
      if (endtime != 0) {
         r->rsprintf("<input type=\"button\" value=\">\" title=\"go forward in time\" onclick=\"histDisp('shift=right')\">");
         r->rsprintf("<input type=\"button\" value=\">>\" title=\"go to currently updated fresh data\" onclick=\"histDisp('shift=rightmax')\">");
      }
 
      r->rsprintf("<td>\n");
      r->rsprintf("<input type=\"button\" value=\"Large\" title=\"large display\" onclick=\"histDisp('width=Large')\">\n");
      r->rsprintf("<input type=\"button\" value=\"Small\" title=\"large display\" onclick=\"histDisp('width=Small')\">\n");
      r->rsprintf("<input type=\"button\" value=\"Create Elog\" title=\"large display\" onclick=\"histDisp('hcmd=Create Elog')\">\n");
      r->rsprintf("<input type=\"button\" value=\"Config\" title=\"large display\" onclick=\"histDisp('hcmd=Config')\">\n");
      r->rsprintf("<input type=\"button\" value=\"Export\" title=\"large display\" onclick=\"histDisp('hcmd=Export')\">\n");
      r->rsprintf("</tr>\n");
 
      char paramstr[256];
 
      paramstr[0] = 0;
      sprintf(paramstr + strlen(paramstr), "&scale=%d", scale);
      if (endtime != 0)
         sprintf(paramstr + strlen(paramstr), "&time=%s", time_to_string(endtime).c_str());
      if (pwidth && *pwidth)
         sprintf(paramstr + strlen(paramstr), "&width=%s", pwidth);
      else {
         std::string wi = "640";
         db_get_value_string(hDB, 0, "/History/Display Settings/Width Individual", 0, &wi, TRUE);
         sprintf(paramstr + strlen(paramstr), "&width=%s", wi.c_str());
      }
      if (pheight && *pheight)
         sprintf(paramstr + strlen(paramstr), "&height=%s", pheight);
 
      /* define image map */
      r->rsprintf("<map name=\"%s\">\r\n", hpanel);
 
      if (!(pindex && *pindex)) {
         std::string path;
         path += "/History/Display/";
         path += hgroup;
         path += "/";
         path += hpanel;
         path += "/Variables";
         db_find_key(hDB, 0, path.c_str(), &hkey);
         if (hkey) {
            db_get_key(hDB, hkey, &key);
 
            for (i = 0; i < key.num_values; i++) {
               std::string ref;
               //if (paramstr[0]) {
               //   sprintf(ref, "?cmd=oldhistory&group=%s&panel=%s&%s&index=%d", hgroup, hpanel, paramstr, i);
               //} else {
               //   sprintf(ref, "?cmd=oldhistory&group=%s&panel=%s&index=%d", hgroup, hpanel, i);
               //}
 
               ref += "?cmd=oldhistory&group=";
               ref += hgroup;
               ref += "&panel=";
               ref += hpanel;
               if (paramstr[0]) {
                  ref += "&";
                  ref += paramstr;
               }
               ref += "&index=";
               ref += toString(i);
 
               r->rsprintf("  <area shape=rect coords=\"%d,%d,%d,%d\" href=\"%s\">\r\n", 30, 31 + 23 * i, 150, 30 + 23 * i + 17, ref.c_str());
            }
         }
      } else {
         std::string ref = "?cmd=oldhistory&group=";
         ref += hgroup;
         ref += "&panel=";
         ref += hpanel;
 
         if (paramstr[0]) {
            ref += "&";
            ref += paramstr;
         }
 
         if (equal_ustring(pwidth, "Large"))
            width = 1024;
         else if (equal_ustring(pwidth, "Small"))
            width = 320;
         else if (atoi(pwidth) > 0)
            width = atoi(pwidth);
         else
            width = 640;
 
         r->rsprintf("  <area shape=rect coords=\"%d,%d,%d,%d\" href=\"%s\">\r\n", 0, 0, width, 20, ref.c_str());
      }
 
      r->rsprintf("</map>\r\n");
 
      /* Display individual panels */
      if (pindex && *pindex)
         sprintf(paramstr + strlen(paramstr), "&index=%s", pindex);
 
      std::string ref;
      //sprintf(ref, "graph.gif?cmd=oldhistory&group=%s&panel=%s%s", hgroup, hpanel, paramstr);
      ref += "graph.gif?cmd=oldhistory&group=";
      ref += hgroup;
      ref += "&panel=";
      ref += hpanel;
      ref += paramstr;
 
      /* put reference to graph */
      r->rsprintf("<tr><td colspan=2><img src=\"%s\" usemap=\"#%s\"></tr>\n", ref.c_str(), hpanel);
   }
 
   else if (equal_ustring(hgroup, "All")) {
      /* Display all panels */
      db_find_key(hDB, 0, "/History/Display", &hkey);
      if (hkey)
         for (i = 0, k = 0;; i++) {     // scan Groups
            db_enum_link(hDB, hkey, i, &hkeyp);
 
            if (!hkeyp)
               break;
 
            db_get_key(hDB, hkeyp, &key);
 
            char enc_group_name[256];
            mstrlcpy(enc_group_name, key.name, sizeof(enc_group_name));
            urlEncode(enc_group_name, sizeof(enc_group_name));
 
            for (j = 0;; j++, k++) {
               // scan items
               db_enum_link(hDB, hkeyp, j, &hikeyp);
 
               if (!hikeyp)
                  break;
 
               db_get_key(hDB, hikeyp, &ikey);
 
               char enc_panel_name[256];
               mstrlcpy(enc_panel_name, ikey.name, sizeof(enc_panel_name));
               urlEncode(enc_panel_name, sizeof(enc_panel_name));
 
               std::string ref;
               ref += "graph.gif?width=Small";
               ref += "&cmd=oldhistory&group=";
               ref += enc_group_name;
               ref += "&panel=";
               ref += enc_panel_name;
 
               std::string ref2;
               ref2 += "?cmd=oldhistory&group=";
               ref2 += enc_group_name;
               ref2 += "&panel=";
               ref2 += enc_panel_name;
 
               if (endtime != 0) {
                  char tmp[256];
                  sprintf(tmp, "time=%s&scale=%d", time_to_string(endtime).c_str(), scale);
                  ref += "&";
                  ref += tmp;
                  ref2 += "&";
                  ref2 += tmp;
               }
 
               if (k % 2 == 0)
                  r->rsprintf("<tr><td><a href=\"%s\"><img src=\"%s\"></a>\n", ref2.c_str(), ref.c_str());
               else
                  r->rsprintf("<td><a href=\"%s\"><img src=\"%s\"></a></tr>\n", ref2.c_str(), ref.c_str());
            }                   // items loop
         }                      // Groups loop
   }                            // All
   r->rsprintf("</table>\r\n");
   r->rsprintf("</div>\n"); // closing for <div id="mmain">
   r->rsprintf("</form>\n");
   r->rsprintf("</body></html>\r\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_navigation_bar()

void show_navigation_bar	(	Return *	r,
		const char *	cur_page
	)

Definition at line 1867 of file mhttpd.cxx.

{
   r->rsprintf("<script>\n");
   r->rsprintf("window.addEventListener(\"load\", function(e) { mhttpd_init('%s', 1000); });\n", cur_page);
   r->rsprintf("</script>\n");
 
   r->rsprintf("<!-- header and side navigation will be filled in mhttpd_init -->\n");
   r->rsprintf("<div id=\"mheader\"></div>\n");
   r->rsprintf("<div id=\"msidenav\"></div>\n");
   r->rsprintf("<div id=\"mmain\">\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_odb_page()

void show_odb_page	(	Param *	pp,
		Return *	r,
		const char *	dec_path,
		int	write_access
	)

Definition at line 6793 of file mhttpd.cxx.

{
   int keyPresent, size, status, line, link_index;
   char colspan;
   char style[32];
   HNDLE hDB, hkey, hkeyroot;
   KEY key;
   DWORD delta;
 
   cm_get_experiment_database(&hDB, NULL);
 
   //printf("path [%s]\n", dec_path);
 
   if (strcmp(dec_path, "root") == 0) {
      dec_path = "";
   }
 
   char xdecpath[256];
   mstrlcpy(xdecpath, dec_path, sizeof(xdecpath));
   if (strrchr(xdecpath, '/'))
      mstrlcpy(xdecpath, strrchr(xdecpath, '/')+1, sizeof(xdecpath));
   if (xdecpath[0] == 0)
      mstrlcpy(xdecpath, "root", sizeof(xdecpath));
   show_header(r, "MIDAS online database", "", xdecpath, 0);
 
   /* use javascript file */
   r->rsprintf("<script type=\"text/javascript\" src=\"midas.js\"></script>\n");
   r->rsprintf("<script type=\"text/javascript\" src=\"mhttpd.js\"></script>\n");
   r->rsprintf("<script type=\"text/javascript\" src=\"obsolete.js\"></script>\n");
   r->rsprintf("<script type=\"text/javascript\" src=\"controls.js\"></script>\n");
 
   /* find key via path */
   status = db_find_key(hDB, 0, dec_path, &hkeyroot);
   if (status != DB_SUCCESS) {
      r->rsprintf("Error: cannot find key %s<P>\n", dec_path);
      r->rsprintf("</body></html>\r\n");
      return;
   }
 
   char xdec_path[MAX_ODB_PATH];
 
   /* if key is not of type TID_KEY, cut off key name */
   db_get_key(hDB, hkeyroot, &key);
   if (key.type != TID_KEY) {
      mstrlcpy(xdec_path, dec_path, sizeof(xdec_path));
      
      /* strip variable name from path */
      char* p = xdec_path + strlen(xdec_path) - 1;
      while (*p && *p != '/')
         *p-- = 0;
      if (*p == '/')
         *p = 0;
 
      status = db_find_key(hDB, 0, xdec_path, &hkeyroot);
      if (status != DB_SUCCESS) {
         r->rsprintf("Error: cannot find key %s<P>\n", xdec_path);
         r->rsprintf("</body></html>\r\n");
         return;
      }
 
      dec_path = xdec_path;
   }
 
   //mstrlcpy(enc_path, dec_path, enc_path_size);
   //urlEncode(enc_path, enc_path_size);
 
   std::string odbpath = db_get_path(hDB, hkeyroot);
 
   /*---- navigation bar ----*/
 
   colspan = 7;
 
   if (elog_mode) {
      r->rsprintf("<table class=\"mtableheader\">\n");
      r->rsprintf("<tr><td colspan=%d>\n", colspan);
      r->rsprintf("<input type=button value=ELog onclick=\"self.location=\'?cmd=Alarms\';\">\n");
      r->rsprintf("</td></tr></table>\n\n");
   } else
      show_navigation_bar(r, "ODB");
 
   /*---- begin ODB directory table ----*/
 
   r->rsprintf("<table class=\"mtable\" style=\"border-spacing:0px;\">\n");
   r->rsprintf("<tr><th colspan=%d class=\"mtableheader\">Online Database Browser</tr>\n", colspan);
   //buttons:
   if(!elog_mode){
      r->rsprintf("<tr><td colspan=%d>\n", colspan);
      r->rsprintf("<input type=button value=Find onclick=\"self.location=\'?cmd=Find\';\">\n");
      r->rsprintf("<input type=button value=Create onclick=\"dlgShow('dlgCreate')\">\n");
      r->rsprintf("<input type=button value=Link   onclick=\"dlgShow('dlgLink')\">\n");
      r->rsprintf("<input type=button value=Delete onclick=\"dlgShow('dlgDelete')\">\n");
      r->rsprintf("<input type=button value=\"Create Elog from this page\" onclick=\"self.location=\'?cmd=Create Elog from this page&odb_path=%s\';\">\n", urlEncode(odbpath.c_str()).c_str());
      r->rsprintf("<input type=button value=\"Show open records\" onclick=\"self.location=\'?cmd=odb_sor&odb_path=%s\';\">\n", urlEncode(odbpath.c_str()).c_str());
      r->rsprintf("<input type=button value=\"Show ODB clients\" onclick=\"self.location=\'?cmd=odb_scl\';\">\n");
      r->rsprintf("</td></tr>\n");
   }
 
   /*---- Build the Delete dialog------------------------------------*/
 
   std::string dd = "";
 
   dd += "<!-- Demo dialog -->\n";
   dd += "<div id=\"dlgDelete\" class=\"dlgFrame\">\n";
   dd += "<div class=\"dlgTitlebar\">Delete ODB entry</div>\n";
   dd += "<div class=\"dlgPanel\">\n";
   dd += "<div id=odbpath>";
   dd += "\"";
   dd += MJsonNode::Encode(odbpath.c_str());
   dd += "\"";
   dd += "</div>\n";
   dd += "<div><br></div>\n";
 
   dd += "<table class=\"dialogTable\">\n";
   dd += "<th colspan=2>Delete ODB entries:</th>\n";
 
   std::vector<std::string> delete_list;
 
   int count_delete = 0;
 
   /*---- ODB display -----------------------------------------------*/
 
   /* display root key */
   r->rsprintf("<tr><td colspan=%d class='ODBpath'><b>", colspan);
   r->rsprintf("<a href=\"?cmd=oldodb\">/</a> \n");
 
   std::string enc_root_path;
 
   /*---- display path ----*/
   {
      const char* p = dec_path;
      while (*p) {
         std::string pd;
         while (*p && *p != '/')
            pd += *p++;
         
         enc_root_path += urlEncode(pd.c_str());
         
         if (pd.length() > 0)
            r->rsprintf("<a href=\"?cmd=oldodb&odb_path=%s\">%s</a>\n / ", enc_root_path.c_str(), pd.c_str());
         
         enc_root_path += "/";
         if (*p == '/')
            p++;
      }
   }
 
   r->rsprintf("</b></tr>\n");
 
   /* enumerate subkeys */
   keyPresent = 0;
   for(int scan=0; scan<2; scan++){
      if(scan==1 && keyPresent==1) {
         r->rsprintf("<tr class=\"titleRow\">\n");
         r->rsprintf("<th class=\"ODBkey\">Key</th>\n");
         r->rsprintf("<th class=\"ODBvalue\">Value&nbsp;");
         r->rsprintf("<script type=\"text/javascript\">\n");
         r->rsprintf("function expand()\n");
         r->rsprintf("{\n");
         r->rsprintf("  var n = document.getElementsByName('ext');\n");
         r->rsprintf("  for (i=0 ; i<n.length ; i++) {\n");
         r->rsprintf("    if (n[i].style.display == 'none')\n");
         r->rsprintf("       n[i].style.display = 'table-cell';\n");
         r->rsprintf("    else\n");
         r->rsprintf("       n[i].style.display = 'none';\n");
         r->rsprintf("  }\n");
         r->rsprintf("  if (document.getElementById('expp').expflag === true) {\n");
         r->rsprintf("    document.getElementById('expp').expflag = false;\n");
         r->rsprintf("    document.getElementById('expp').innerHTML = '&#x21E5;';\n");
         r->rsprintf("  } else {\n");
         r->rsprintf("    document.getElementById('expp').expflag = true;\n");
         r->rsprintf("    document.getElementById('expp').innerHTML = '&#x21E4;';\n");
         r->rsprintf("  }\n");
         r->rsprintf("}\n");
         r->rsprintf("</script>");
         r->rsprintf("<div style=\"display:inline;float:right\"><a id=\"expp\"href=\"#\" onClick=\"expand();return false;\">&#x21E5;</div>");
         r->rsprintf("</th>\n");
         r->rsprintf("<th class=\"ODBvalue\" name=\"ext\" style=\"display:none\">Type</th>\n");
         r->rsprintf("<th class=\"ODBvalue\" name=\"ext\" style=\"display:none\">#Val</th>\n");
         r->rsprintf("<th class=\"ODBvalue\" name=\"ext\" style=\"display:none\">Size</th>\n");
         r->rsprintf("<th class=\"ODBvalue\" name=\"ext\" style=\"display:none\">Written</th>\n");
         r->rsprintf("<th class=\"ODBvalue\" name=\"ext\" style=\"display:none\">Mode</th>\n");
         r->rsprintf("</tr>\n");
      }
      line = 0;
      for (int i = 0;; i++) {
         db_enum_link(hDB, hkeyroot, i, &hkey);
         if (!hkey)
            break;
         db_get_link(hDB, hkey, &key);
 
         if (scan == 0) {
            delete_list.push_back(key.name);
         }
 
         if (line % 2 == 0)
            mstrlcpy(style, "ODBtableEven", sizeof(style));
         else
            mstrlcpy(style, "ODBtableOdd", sizeof(style));
 
         std::string keyname = key.name;
         std::string enc_keyname = urlEncode(key.name);
 
         std::string enc_full_path = enc_root_path + enc_keyname;
 
         std::string odb_path = dec_path;
         if (odb_path.length() > 0 && odb_path[odb_path.length() - 1] != '/')
            odb_path += "/";
         odb_path += key.name;
 
         /* resolve links */
         std::string enc_link_ref;
         char link_name[MAX_ODB_PATH];
         link_name[0] = 0;
         status = DB_SUCCESS;
         if (key.type == TID_LINK) {
            size = sizeof(link_name);
            db_get_link_data(hDB, hkey, link_name, &size, TID_LINK);
 
            status = db_find_key(hDB, 0, link_name, &hkey);
 
            if (status == DB_SUCCESS)
               db_get_key(hDB, hkey, &key);
 
            //sprintf(link_ref, "?cmd=Set&odb_path=%s", full_path);
            enc_link_ref = "?cmd=Set&odb_path=";
            enc_link_ref += enc_full_path;
 
            if (status == DB_SUCCESS && link_name[0] == 0) {
               // fake the case when an empty link somehow resolves
               sprintf(link_name, "%s", "(empty)");
            }
         }
 
         std::string enc_ref;
 
         if (link_name[0]) {
            if (enc_root_path.back() == '/' && link_name[0] == '/') {
               //sprintf(ref, "?cmd=Set&odb_path=%s%s", root_path, link_name+1);
               enc_ref = "";
               enc_ref += "?cmd=Set&odb_path=";
               enc_ref += enc_root_path;
               enc_ref += urlEncode(link_name + 1);
            } else {
               //sprintf(ref, "?cmd=Set&odb_path=%s%s", root_path, link_name);
               enc_ref = "";
               enc_ref += "?cmd=Set&odb_path=";
               enc_ref += enc_root_path;
               enc_ref += urlEncode(link_name);
            }
         } else {
            //sprintf(ref, "?cmd=Set&odb_path=%s", full_path);
            enc_ref = "";
            enc_ref += "?cmd=Set&odb_path=";
            enc_ref += enc_full_path;
         }
 
         if (status != DB_SUCCESS) {
            if (scan == 1) {
               r->rsprintf("<tr><td class=\"yellowLight\">");
               r->rsprintf("%s <i>&rarr; <a href=\"%s\">%s</a></i><td><b><div style=\"color:red\">&lt;cannot resolve link&gt;</div></b></tr>\n", keyname.c_str(), enc_link_ref.c_str(), link_name[0]?link_name:"(empty)");
            }
         } else {
 
            if (key.type == TID_KEY && scan == 0) {
               /* for keys, don't display data value */
               r->rsprintf("<tr><td colspan=%d class=\"ODBdirectory\"><a href=\"?cmd=oldodb&odb_path=%s\">&#x25B6 %s</a>\n", colspan, enc_full_path.c_str(), keyname.c_str());
               if (link_name[0])
                  r->rsprintf("<i>&rarr; <a href=\"%s\">%s</a></i>", enc_link_ref.c_str(), link_name);
               r->rsprintf("</tr>\n");
            } else if(key.type != TID_KEY && scan == 1) {
 
               if (strchr(link_name, '['))
                  link_index = atoi(strchr(link_name, '[')+1);
               else
                  link_index = -1;
 
               /* display single value */
               if (key.num_values == 1 || link_index != -1) {
                  char data[TEXT_SIZE];
                  size = sizeof(data);
                  db_get_data(hDB, hkey, data, &size, key.type);
 
                  std::string data_str;
 
                  if (link_index != -1)
                     data_str = db_sprintf(data, key.item_size, link_index, key.type);
                  else
                     data_str = db_sprintf(data, key.item_size, 0, key.type);
 
                  if (key.type == TID_STRING) {
                     if (size == sizeof(data)) {
                        data_str += "...(truncated)";
                     }
                  }
 
                  std::string hex_str;
 
                  if (key.type != TID_STRING) {
                     if (link_index != -1)
                        hex_str = db_sprintfh(data, key.item_size, link_index, key.type);
                     else
                        hex_str = db_sprintfh(data, key.item_size, 0, key.type);
                  }
 
                  if (data_str.empty() || equal_ustring(data_str.c_str(), "<NULL>")) {
                     data_str = "(empty)";
                     hex_str  = "";
                  }
 
                  r->rsprintf("<tr>\n");
                  if (strcmp(data_str.c_str(), hex_str.c_str()) != 0 && hex_str[0]) {
                     if (link_name[0]) {
                        r->rsprintf("<td class=\"ODBkey\">\n");
                        r->rsprintf("%s <i>&rarr; ", keyname.c_str());
                        r->rsprintf("<a href=\"%s\">%s</a></i>\n", enc_link_ref.c_str(), link_name);
                        r->rsprintf("<td class=\"%s\">\n", style);
                        if (!write_access)
                           r->rsprintf("%s (%s)", data_str.c_str(), hex_str.c_str());
                        else {
                           r->rsprintf("<a href=\"%s\" onClick=\"ODBInlineEdit(this.parentNode,\'%s\');return false;\" ", enc_ref.c_str(), odb_path.c_str());
                           r->rsprintf("onFocus=\"ODBInlineEdit(this.parentNode,\'%s\');\">%s (%s)</a>\n", odb_path.c_str(), data_str.c_str(), hex_str.c_str());
                        }
                     } else {
                        r->rsprintf("<td class=\"ODBkey\">\n");
                        r->rsprintf("%s<td class=\"%s\">", keyname.c_str(), style);
                        if (!write_access)
                           r->rsprintf("%s (%s)", data_str.c_str(), hex_str.c_str());
                        else {
                           r->rsprintf("<a href=\"%s\" onClick=\"ODBInlineEdit(this.parentNode,\'%s\');return false;\" ", enc_ref.c_str(), odb_path.c_str());
                           r->rsprintf("onFocus=\"ODBInlineEdit(this.parentNode,\'%s\');\">%s (%s)</a>\n", odb_path.c_str(), data_str.c_str(), hex_str.c_str());
                        }
                     }
                  } else {
                     if (strchr(data_str.c_str(), '\n')) {
                        if (link_name[0]) {
                           r->rsprintf("<td class=\"ODBkey\">");
                           r->rsprintf("%s <i>&rarr; <a href=\"%s\">%s</a></i><td class=\"ODBvalue\">", keyname.c_str(), enc_link_ref.c_str(), link_name);
                        } else
                           r->rsprintf("<td class=\"ODBkey\">%s<td class=\"%s\">", keyname.c_str(), style);
                        r->rsprintf("\n<pre>");
                        strencode3(r, data_str.c_str());
                        r->rsprintf("</pre>");
                        if (strlen(data) > data_str.length())
                           r->rsprintf("<i>... (%d bytes total)<p>\n", (int)strlen(data));
 
                        r->rsprintf("<a href=\"%s\">Edit</a>\n", enc_ref.c_str());
                     } else {
                        if (link_name[0]) {
                           r->rsprintf("<td class=\"ODBkey\">\n");
                           r->rsprintf("%s <i>&rarr; <a href=\"%s\">%s</a></i><td class=\"%s\">", keyname.c_str(), enc_link_ref.c_str(), link_name, style);
                           if (!write_access)
                              strencode(r, data_str.c_str());
                           else {
                              r->rsprintf("<a href=\"%s\" onClick=\"ODBInlineEdit(this.parentNode,\'%s\');return false;\" ", enc_ref.c_str(), odb_path.c_str());
                              r->rsprintf("onFocus=\"ODBInlineEdit(this.parentNode,\'%s\');\">", odb_path.c_str());
                              strencode(r, data_str.c_str());
                              r->rsprintf("</a>\n");
                           }
                        } else {
                           r->rsprintf("<td class=\"ODBkey\">%s<td class=\"%s\">", keyname.c_str(), style);
                           if (!write_access) {
                              strencode(r, data_str.c_str());
                           } else {
                              r->rsprintf("<a href=\"%s\" onClick=\"ODBInlineEdit(this.parentNode,\'%s\');return false;\" ", enc_ref.c_str(), odb_path.c_str());
                              r->rsprintf("onFocus=\"ODBInlineEdit(this.parentNode,\'%s\');\">", odb_path.c_str());
                              strencode(r, data_str.c_str());
                              r->rsprintf("</a>\n");
                           }
                        }
                     }
                  }
 
                  /* extended key information */
                  r->rsprintf("<td class=\"ODBkey\" name=\"ext\" style=\"display:none\">");
                  r->rsprintf("%s", rpc_tid_name(key.type));
                  r->rsprintf("</td>\n");
 
                  r->rsprintf("<td class=\"ODBkey\" name=\"ext\" style=\"display:none\">");
                  r->rsprintf("%d", key.num_values);
                  r->rsprintf("</td>\n");
 
                  r->rsprintf("<td class=\"ODBkey\" name=\"ext\" style=\"display:none\">");
                  r->rsprintf("%d", key.item_size);
                  r->rsprintf("</td>\n");
 
                  r->rsprintf("<td class=\"ODBkey\" name=\"ext\" style=\"display:none\">");
                  db_get_key_time(hDB, hkey, &delta);
                  if (delta < 60)
                     r->rsprintf("%ds", delta);
                  else if (delta < 3600)
                     r->rsprintf("%1.0lfm", delta / 60.0);
                  else if (delta < 86400)
                     r->rsprintf("%1.0lfh", delta / 3600.0);
                  else if (delta < 86400 * 99)
                     r->rsprintf("%1.0lfd", delta / 86400.0);
                  else
                     r->rsprintf(">99d");
                  r->rsprintf("</td>\n");
 
                  r->rsprintf("<td class=\"ODBkey\" name=\"ext\" style=\"display:none\">");
                  if (key.access_mode & MODE_READ)
                     r->rsprintf("R");
                  if (key.access_mode & MODE_WRITE)
                     r->rsprintf("W");
                  if (key.access_mode & MODE_DELETE)
                     r->rsprintf("D");
                  if (key.access_mode & MODE_EXCLUSIVE)
                     r->rsprintf("E");
                  r->rsprintf("</td>\n");
 
                  line++;
                  r->rsprintf("</tr>\n");
               } else { /* display array value */
                  /* check for exceeding length */
                  if (key.num_values > 1000 && !pp->isparam("all"))
                     r->rsprintf("<tr><td class=\"ODBkey\">%s<td class=\"%s\"><span style=\"font-style: italic\"><a href=\"?cmd=oldodb&odb_path=%s&all=1\">... %d values ...</a></span>\n", keyname.c_str(), style, enc_full_path.c_str(), key.num_values);
                  else {
                     /* display first value */
                     if (link_name[0])
                        r->rsprintf("<tr><td class=\"ODBkey\" rowspan=%d>%s<br><i>&rarr; <a href=\"%s\">%s</a></i>\n", key.num_values, keyname.c_str(), enc_link_ref.c_str(), link_name);
                     else
                        r->rsprintf("<tr><td class=\"ODBkey\" rowspan=%d>%s\n", key.num_values, keyname.c_str());
 
                     for (int j = 0; j < key.num_values; j++) {
                        if (line % 2 == 0)
                           mstrlcpy(style, "ODBtableEven", sizeof(style));
                        else
                           mstrlcpy(style, "ODBtableOdd", sizeof(style));
 
                        char data[TEXT_SIZE];
                        size = sizeof(data);
                        db_get_data_index(hDB, hkey, data, &size, j, key.type);
                        std::string data_str = db_sprintf(data, key.item_size, 0, key.type);
 
                        std::string hex_str;
                        if (key.type == TID_STRING || key.type == TID_LINK) {
                           hex_str = "";
                        } else {
                           hex_str = db_sprintfh(data, key.item_size, 0, key.type);
                        }
 
                        if (key.type == TID_STRING) {
                           if (size == sizeof(data)) {
                              data_str += "...(truncated)";
                           }
                        }
 
                        if (data_str.empty() || equal_ustring(data_str.c_str(), "<NULL>")) {
                           data_str = "(empty)";
                           hex_str  = "";
                        }
 
                        //sprintf(ref, "?cmd=Set&odb_path=%s&index=%d", full_path, j);
                        enc_ref = "";
                        enc_ref += "?cmd=Set&odb_path=";
                        enc_ref += enc_full_path;
                        enc_ref += "&index=";
                        enc_ref += toString(j);
 
                        std::string tmpstr;
                        //sprintf(str, "%s[%d]", odb_path, j);
                        tmpstr += odb_path;
                        tmpstr += "[";
                        tmpstr += toString(j);
                        tmpstr += "]";
 
                        if (j > 0)
                           r->rsprintf("<tr>");
 
                        r->rsprintf("<td class=\"%s\">[%d]&nbsp;", style, j);
                        if (!write_access)
                           r->rsprintf("<a href=\"%s\">", enc_ref.c_str());
                        else {
                           r->rsprintf("<a href=\"%s\" onClick=\"ODBInlineEdit(this.parentNode,\'%s\');return false;\" ", enc_ref.c_str(), tmpstr.c_str());
                           r->rsprintf("onFocus=\"ODBInlineEdit(this.parentNode,\'%s\');\">", tmpstr.c_str());
                        }
                        if (strcmp(data_str.c_str(), hex_str.c_str()) != 0 && hex_str[0])
                           r->rsprintf("%s (%s)</a>\n", data_str.c_str(), hex_str.c_str());
                        else
                           r->rsprintf("%s</a>\n", data_str.c_str());
 
                        if (j == 0) {
                           /* extended key information */
                           r->rsprintf("<td class=\"ODBkey\" name=\"ext\" style=\"display:none\" rowspan=%d>", key.num_values);
                           r->rsprintf("%s", rpc_tid_name(key.type));
                           r->rsprintf("</td>\n");
 
                           r->rsprintf("<td class=\"ODBkey\" name=\"ext\" style=\"display:none\" rowspan=%d>", key.num_values);
                           r->rsprintf("%d", key.num_values);
                           r->rsprintf("</td>\n");
 
                           r->rsprintf("<td class=\"ODBkey\" name=\"ext\" style=\"display:none\" rowspan=%d>", key.num_values);
                           r->rsprintf("%d", key.item_size);
                           r->rsprintf("</td>\n");
 
                           r->rsprintf("<td class=\"ODBkey\" name=\"ext\" style=\"display:none\" rowspan=%d>", key.num_values);
                           db_get_key_time(hDB, hkey, &delta);
                           if (delta < 60)
                              r->rsprintf("%ds", delta);
                           else if (delta < 3600)
                              r->rsprintf("%1.0lfm", delta / 60.0);
                           else if (delta < 86400)
                              r->rsprintf("%1.0lfh", delta / 3600.0);
                           else if (delta < 86400 * 99)
                              r->rsprintf("%1.0lfh", delta / 86400.0);
                           else
                              r->rsprintf(">99d");
                           r->rsprintf("</td>\n");
 
                           r->rsprintf("<td class=\"ODBkey\" name=\"ext\" style=\"display:none\" rowspan=%d>", key.num_values);
                           if (key.access_mode & MODE_READ)
                              r->rsprintf("R");
                           if (key.access_mode & MODE_WRITE)
                              r->rsprintf("W");
                           if (key.access_mode & MODE_DELETE)
                              r->rsprintf("D");
                           if (key.access_mode & MODE_EXCLUSIVE)
                              r->rsprintf("E");
                           r->rsprintf("</td>\n");
                        }
                        line++;
                     }
 
                     r->rsprintf("</tr>\n");
                  }
               }
            } else if(key.type != TID_KEY){
               keyPresent = 1;  //flag that we've seen a key on the first pass, and should therefore write the Key / Value headline
            }
         }
      }
   }
   r->rsprintf("</table>\n");
   r->rsprintf("</div>\n"); // <div id="mmain">
 
   /*---- Build the Delete dialog------------------------------------*/
 
   std::sort(delete_list.begin(), delete_list.end());
 
   for (unsigned i=0; i<delete_list.size(); i++) {
      std::string name = delete_list[i];
 
      dd += "<tr><td style=\"text-align:left;\" align=left><input align=left type=checkbox id=delete";
      dd += toString(count_delete++);
      dd += " value=\'";
      dd += "\"";
      dd += MJsonNode::Encode(name.c_str());
      dd += "\"";
      dd += "\'>";
      dd += name;
      dd += "</input></td></tr>\n";
   }
 
   dd += "</table>\n";
   dd += "<input type=button value=Delete onClick='mhttpd_delete_page_handle_delete(event);'>\n";
   dd += "<input type=button value=Cancel onClick='mhttpd_delete_page_handle_cancel(event);'>\n";
   dd += "</div>\n";
   dd += "</div>\n";
 
   r->rsputs(dd.c_str());
 
   /*---- Build the Create dialog------------------------------------*/
 
   std::string cd = "";
 
   cd += "<!-- Demo dialog -->\n";
   cd += "<div id=\"dlgCreate\" class=\"dlgFrame\">\n";
   cd += "<div class=\"dlgTitlebar\">Create ODB entry</div>\n";
   cd += "<div class=\"dlgPanel\">\n";
   cd += "<br />\n";
   cd += "<div id=odbpath>";
   cd += "\"";
   cd += MJsonNode::Encode(odbpath.c_str());
   cd += "\"";
   cd += "</div>\n";
   cd += "<div><br></div>\n";
 
   cd += "<table class=\"dialogTable\">\n";
   cd += "<th colspan=2>Create ODB entry:</th>\n";
   cd += "<tr>";
   cd += "<td>Type";
   cd += "<td>";
   cd += "<select type=text size=1 id=create_tid name=type>";
   cd += "<option value=7>Integer (32-bit)";
   cd += "<option value=9>Float (4 Bytes)";
   cd += "<option value=12>String";
   cd += "<option selected value=15>Subdirectory";
   cd += "<option value=1>Byte";
   cd += "<option value=2>Signed byte";
   cd += "<option value=3>Character (8-bit)";
   cd += "<option value=4>Word (16-bit)";
   cd += "<option value=5>Short integer (16-bit)";
   cd += "<option value=6>Double Word (32-bit)";
   cd += "<option value=8>Boolean";
   cd += "<option value=10>Double float (8 Bytes)";
   //cd += "<option value=16>Symbolic link";
   cd += "</select>";
   cd += "</tr>\n";
   cd += "<tr><td>Name<td><input type=text size=31 maxlength=31 id=create_name name=value></tr>\n";
   cd += "<tr><td>Array size<td><input type=text size=31 maxlength=31 id=create_array_length name=index value=1></tr>\n";
   cd += "<tr><td>String length<td><input type=text size=31 maxlength=31 id=create_strlen name=strlen value=32></tr>\n";
   cd += "</table>\n";
   cd += "<input type=button value=Create onClick='mhttpd_create_page_handle_create(event);'>\n";
   cd += "<input type=button value=Cancel onClick='mhttpd_create_page_handle_cancel(event);'>\n";
   cd += "</div>\n";
   cd += "</div>\n";
 
   r->rsputs(cd.c_str());
 
   /*---- Build the Link dialog------------------------------------*/
 
   std::string ld = "";
 
   ld += "<!-- Demo dialog -->\n";
   ld += "<div id=\"dlgLink\" class=\"dlgFrame\">\n";
   ld += "<div class=\"dlgTitlebar\">Create a link to an ODB entry</div>\n";
   ld += "<div class=\"dlgPanel\">\n";
   ld += "<br />\n";
   ld += "<div id=link_odbpath>";
   ld += "\"";
   ld += MJsonNode::Encode(odbpath.c_str());
   ld += "\"";
   ld += "</div>\n";
   ld += "<div><br></div>\n";
 
   ld += "<table class=\"dialogTable\">\n";
   ld += "<th colspan=2>Create a link to an ODB entry:</th>\n";
   ld += "<tr><td>Name<td><input type=text size=31 maxlength=31 id=link_name name=value></tr>\n";
   ld += "<tr><td>Link target<td><input type=text size=31 maxlength=256 id=link_target name=target></tr>\n";
   ld += "</table>\n";
   ld += "<input type=button value=Link onClick='mhttpd_link_page_handle_link(event);'>\n";
   ld += "<input type=button value=Cancel onClick='mhttpd_link_page_handle_cancel(event);'>\n";
   ld += "</div>\n";
   ld += "</div>\n";
 
   r->rsputs(ld.c_str());
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_odb_tag()

void show_odb_tag	(	Param *	pp,
		Return *	r,
		const char *	path,
		const char *	keypath1,
		const char *	format,
		int	n_var,
		int	edit,
		char *	type,
		char *	pwd,
		char *	tail
	)

Definition at line 3275 of file mhttpd.cxx.

{
   int size, index, i_edit, i_set;
   char data[TEXT_SIZE], full_keypath[256], keypath[256], *p;
   HNDLE hDB, hkey;
   KEY key;
 
   /* check if variable to edit */
   i_edit = -1;
   if (equal_ustring(pp->getparam("cmd"), "Edit"))
      i_edit = atoi(pp->getparam("index"));
 
   /* check if variable to set */
   i_set = -1;
   if (equal_ustring(pp->getparam("cmd"), "Set"))
      i_set = atoi(pp->getparam("index"));
 
   /* check if path contains index */
   mstrlcpy(full_keypath, keypath1, sizeof(full_keypath));
   mstrlcpy(keypath, keypath1, sizeof(keypath));
   index = 0;
 
   if (strchr(keypath, '[') && strchr(keypath, ']')) {
      for (p = strchr(keypath, '[') + 1; *p && *p != ']'; p++)
         if (!isdigit(*p))
            break;
 
      if (*p && *p == ']') {
         index = atoi(strchr(keypath, '[') + 1);
         *strchr(keypath, '[') = 0;
      }
   }
 
   cm_get_experiment_database(&hDB, NULL);
   db_find_key(hDB, 0, keypath, &hkey);
   if (!hkey)
      r->rsprintf("<b>Key \"%s\" not found in ODB</b>\n", keypath);
   else {
      db_get_key(hDB, hkey, &key);
      size = sizeof(data);
      db_get_data_index(hDB, hkey, data, &size, index, key.type);
 
      std::string data_str;
      if (format && strlen(format)>0)
         data_str = db_sprintff(format, data, key.item_size, 0, key.type);
      else
         data_str= db_sprintf(data, key.item_size, 0, key.type);
 
      if (equal_ustring(type, "checkbox")) {
 
         if (pp->isparam("cbi"))
            i_set = atoi(pp->getparam("cbi"));
         if (n_var == i_set) {
            /* toggle state */
            if (key.type == TID_BOOL) {
               if (data_str[0] == 'y')
                  data_str = "n";
               else
                  data_str = "y";
            } else {
               if (atoi(data_str.c_str()) > 0)
                  data_str = "0";
               else
                  data_str = "1";
            }
 
            db_sscanf(data_str.c_str(), data, &size, 0, key.type);
            db_set_data_index(hDB, hkey, data, size, index, key.type);
         }
 
         std::string options;
         if (data_str[0] == 'y' || atoi(data_str.c_str()) > 0)
            options += "checked ";
         if (!edit)
            options += "disabled ";
         else {
            if (edit == 1) {
               options += "onClick=\"o=document.createElement('input');o.type='hidden';o.name='cbi';o.value='";
               options += msprintf("%d", n_var);
               options += "';document.form1.appendChild(o);";
               options += "document.form1.submit();\" ";
            }
         }
 
         if (tail[0])
            options += tail;
 
         r->rsprintf("<input type=\"checkbox\" %s>\n", options.c_str());
 
      } else { // checkbox
 
         if (edit == 1) {
            if (n_var == i_set) {
               /* set value */
               char str[256];
               mstrlcpy(str, pp->getparam("value"), sizeof(str));
               db_sscanf(str, data, &size, 0, key.type);
               db_set_data_index(hDB, hkey, data, size, index, key.type);
 
               /* read back value */
               size = sizeof(data);
               db_get_data_index(hDB, hkey, data, &size, index, key.type);
               data_str = db_sprintf(data, key.item_size, 0, key.type);
            }
 
            if (n_var == i_edit) {
               r->rsprintf("<input type=text size=10 maxlength=80 name=value value=\"%s\">\n", data_str.c_str());
               r->rsprintf("<input type=submit size=20 name=cmd value=Set>\n");
               r->rsprintf("<input type=hidden name=index value=%d>\n", n_var);
               r->rsprintf("<input type=hidden name=cmd value=Set>\n");
            } else {
               if (edit == 2) {
                  /* edit handling through user supplied JavaScript */
                  r->rsprintf("<a href=\"#\" %s>", tail);
               } else {
                  /* edit handling through form submission */
                  if (pwd[0]) {
                     r->rsprintf("<a onClick=\"promptpwd('%s?cmd=Edit&index=%d&pnam=%s')\" href=\"#\">", path, n_var, pwd);
                  } else {
                     r->rsprintf("<a href=\"%s?cmd=Edit&index=%d\" %s>", path, n_var, tail);
                  }
               }
 
               r->rsputs(data_str.c_str());
               r->rsprintf("</a>");
            }
         } else if (edit == 2) {
            r->rsprintf("<a href=\"#\" onclick=\"ODBEdit('%s')\">\n", full_keypath);
            r->rsputs(data_str.c_str());
            r->rsprintf("</a>");
         }
           else
              r->rsputs(data_str.c_str());
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_password_page()

void show_password_page	(	Return *	r,
		const char *	dec_path,
		const char *	password
	)

Definition at line 6702 of file mhttpd.cxx.

{
   r->rsprintf("HTTP/1.1 200 Document follows\r\n");
   r->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
   r->rsprintf("Content-Type: text/html; charset=%s\r\n\r\n", HTTP_ENCODING);
 
   r->rsprintf("<html><head>\n");
   r->rsprintf("<link rel=\"icon\" href=\"favicon.png\" type=\"image/png\" />\n");
   r->rsprintf("<link rel=\"stylesheet\" href=\"midas.css\" type=\"text/css\" />\n");
   r->rsprintf("<link rel=\"stylesheet\" href=\"mhttpd.css\" type=\"text/css\" />\n");
   r->rsprintf("<title>Enter password</title></head><body>\n\n");
 
   r->rsprintf("<form method=\"GET\" action=\".\">\n\n");
 
   /*---- page header ----*/
   r->rsprintf("<table class=\"headerTable\"><tr><td></td><tr></table>\n");
 
   r->rsprintf("<table class=\"dialogTable\">\n");  //main table
   if (password[0])
      r->rsprintf("<tr><th class=\"redLight\">Wrong password!</tr>\n");
 
   r->rsprintf("<tr><th>Please enter password</tr>\n");
   r->rsprintf("<tr><td align=center><input type=password name=pwd></tr>\n");
   r->rsprintf("<tr><td align=center><input type=submit value=Submit></tr>");
 
   r->rsprintf("</table>\n");
 
   r->rsprintf("</div>\n"); // closing for <div id="mmain">
   r->rsprintf("</form>\n");
   r->rsprintf("</body></html>\r\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_query_page()

void show_query_page	(	Param *	p,
		Return *	r
	)

Definition at line 9791 of file mhttpd.cxx.

{
   int i;
   HNDLE hDB;
 
   if (p->getparam("m1") && *p->getparam("m1")) {
      struct tm tms;
      memset(&tms, 0, sizeof(struct tm));
 
      tms.tm_year = atoi(p->getparam("y1")) % 100;
 
      std::string m1 = p->getparam("m1");
      for (i = 0; i < 12; i++)
         if (equal_ustring(m1.c_str(), mname[i]))
            break;
      if (i == 12)
         i = 0;
 
      tms.tm_mon = i;
      tms.tm_mday = atoi(p->getparam("d1"));
      tms.tm_hour = atoi(p->getparam("h1"));
 
      if (tms.tm_year < 90)
         tms.tm_year += 100;
 
      time_t ltime_start = mktime_with_dst(&tms);
 
      memset(&tms, 0, sizeof(struct tm));
      tms.tm_year = atoi(p->getparam("y2")) % 100;
 
      std::string m2 = p->getparam("m2");
      for (i = 0; i < 12; i++)
         if (equal_ustring(m2.c_str(), mname[i]))
            break;
      if (i == 12)
         i = 0;
 
      tms.tm_mon = i;
      tms.tm_mday = atoi(p->getparam("d2"));
      tms.tm_hour = atoi(p->getparam("h2"));
 
      if (tms.tm_year < 90)
         tms.tm_year += 100;
 
      time_t ltime_end = mktime_with_dst(&tms);
 
      if (ltime_end == ltime_start)
         ltime_end += 3600 * 24;
 
      std::string redir;
      redir += "?cmd=oldhistory&";
      redir += add_param_to_url("group", p->getparam("group"));
      redir += "&";
      redir += add_param_to_url("panel", p->getparam("panel"));
      redir += "&";
      redir += add_param_to_url("scale", toString((int)(ltime_end - ltime_start)).c_str());
      redir += "&";
      redir += add_param_to_url("time", time_to_string(ltime_end).c_str());
      if (p->isparam("hindex")) {
         redir += "&";
         redir += add_param_to_url("index", p->getparam("hindex"));
      }
      redirect(r, redir.c_str());
      return;
   }
 
   cm_get_experiment_database(&hDB, NULL);
   show_header(r, "History", "GET", "", 0);
 
   /* set the times */
 
   time_t now = time(NULL);
 
   time_t starttime = now - 3600 * 24;
   time_t endtime = now;
   bool full_day = true;
 
   if (p->isparam("htime")) {
      endtime = string_to_time(p->getparam("htime"));
 
      if (p->isparam("hscale")) {
         starttime = endtime - atoi(p->getparam("hscale"));
         full_day = false;
      } else {
         starttime = endtime - 3600 * 24;
         full_day = false;
      }
   }
 
   /* menu buttons */
   r->rsprintf("<tr><td colspan=2>\n");
   r->rsprintf("<input type=hidden name=cmd value=OldHistory>\n");
   r->rsprintf("<input type=submit name=hcmd value=Query>\n");
   r->rsprintf("<input type=submit name=hcmd value=Cancel>\n");
   if (p->isparam("group"))
      r->rsprintf("<input type=hidden name=group value=\"%s\">\n", p->getparam("group"));
   if (p->isparam("panel"))
      r->rsprintf("<input type=hidden name=panel value=\"%s\">\n", p->getparam("panel"));
   if (p->isparam("htime"))
      r->rsprintf("<input type=hidden name=htime value=\"%s\">\n", p->getparam("htime"));
   if (p->isparam("hscale"))
      r->rsprintf("<input type=hidden name=hscale value=\"%s\">\n", p->getparam("hscale"));
   if (p->isparam("hindex"))
      r->rsprintf("<input type=hidden name=hindex value=\"%s\">\n", p->getparam("hindex"));
   r->rsprintf("</tr>\n\n");
   r->rsprintf("</table>");  //end header
 
   r->rsprintf("<table class=\"dialogTable\">");  //main table
 
   struct tm tms;
   localtime_r(&starttime, &tms);
   tms.tm_year += 1900;
 
   r->rsprintf("<tr><td nowrap>Start date:</td>");
 
   r->rsprintf("<td>Month: <select name=\"m1\">\n");
   r->rsprintf("<option value=\"\">\n");
   for (i = 0; i < 12; i++)
      if (i == tms.tm_mon)
         r->rsprintf("<option selected value=\"%s\">%s\n", mname[i], mname[i]);
      else
         r->rsprintf("<option value=\"%s\">%s\n", mname[i], mname[i]);
   r->rsprintf("</select>\n");
 
   r->rsprintf("&nbsp;Day: <select name=\"d1\">");
   r->rsprintf("<option selected value=\"\">\n");
   for (i = 0; i < 31; i++)
      if (i + 1 == tms.tm_mday)
         r->rsprintf("<option selected value=%d>%d\n", i + 1, i + 1);
      else
         r->rsprintf("<option value=%d>%d\n", i + 1, i + 1);
   r->rsprintf("</select>\n");
 
   int start_hour = tms.tm_hour;
   if (full_day)
      start_hour = 0;
 
   r->rsprintf("&nbsp;Hour: <input type=\"text\" size=5 maxlength=5 name=\"h1\" value=\"%d\">", start_hour);
 
   r->rsprintf("&nbsp;Year: <input type=\"text\" size=5 maxlength=5 name=\"y1\" value=\"%d\">", tms.tm_year);
   r->rsprintf("</td></tr>\n");
 
   r->rsprintf("<tr><td nowrap>End date:</td>");
 
   localtime_r(&endtime, &tms);
   tms.tm_year += 1900;
 
   r->rsprintf("<td>Month: <select name=\"m2\">\n");
   r->rsprintf("<option value=\"\">\n");
   for (i = 0; i < 12; i++)
      if (i == tms.tm_mon)
         r->rsprintf("<option selected value=\"%s\">%s\n", mname[i], mname[i]);
      else
         r->rsprintf("<option value=\"%s\">%s\n", mname[i], mname[i]);
   r->rsprintf("</select>\n");
 
   r->rsprintf("&nbsp;Day: <select name=\"d2\">");
   r->rsprintf("<option selected value=\"\">\n");
   for (i = 0; i < 31; i++)
      if (i + 1 == tms.tm_mday)
         r->rsprintf("<option selected value=%d>%d\n", i + 1, i + 1);
      else
         r->rsprintf("<option value=%d>%d\n", i + 1, i + 1);
   r->rsprintf("</select>\n");
 
   int end_hour = tms.tm_hour;
   if (full_day)
      end_hour = 24;
 
   r->rsprintf("&nbsp;Hour: <input type=\"text\" size=5 maxlength=5 name=\"h2\" value=\"%d\">", end_hour);
 
   r->rsprintf("&nbsp;Year: <input type=\"text\" size=5 maxlength=5 name=\"y2\" value=\"%d\">", tms.tm_year);
   r->rsprintf("</td></tr>\n");
 
   r->rsprintf("</table>\n");
   r->rsprintf("</div>\n"); // closing for <div id="mmain">
   r->rsprintf("</form>\n");
   r->rsprintf("</body></html>\r\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_set_page()

void show_set_page	(	Param *	pp,
		Return *	r,
		const char *	group,
		int	index,
		const char *	value
	)

Definition at line 7433 of file mhttpd.cxx.

{
   int status, size;
   HNDLE hDB, hkey;
   KEY key;
   char data[TEXT_SIZE];
 
   std::string odb_path = pp->getparam("odb_path");
 
   //printf("show_set_page: odb_path [%s] group [%s] index %d value [%s]\n", odb_path.c_str(), group, index, value);
 
   cm_get_experiment_database(&hDB, NULL);
 
   /* show set page if no value is given */
   if (!pp->isparam("value") && !*pp->getparam("text")) {
      status = db_find_link(hDB, 0, odb_path.c_str(), &hkey);
      if (status != DB_SUCCESS) {
         r->rsprintf("Error: cannot find key %s<P>\n", odb_path.c_str());
         return;
      }
      db_get_link(hDB, hkey, &key);
 
      show_header(r, "Set value", "POST", "", 0);
      //close header:
      r->rsprintf("</table>");
 
      //main table:
      r->rsprintf("<table class=\"dialogTable\">");
 
      if (index > 0)
         r->rsprintf("<input type=hidden name=index value=\"%d\">\n", index);
      else
         index = 0;
 
      if (group[0])
         r->rsprintf("<input type=hidden name=group value=\"%s\">\n", group);
 
      r->rsprintf("<input type=hidden name=odb_path value=\"%s\">\n", odb_path.c_str());
 
      std::string data_str1 = rpc_tid_name(key.type);
      std::string str1;
      if (key.num_values > 1) {
         data_str1 += msprintf("[%d]", key.num_values);
         str1 = msprintf("%s[%d]", odb_path.c_str(), index);
      } else
         str1 = odb_path.c_str();
 
      r->rsprintf("<tr><th colspan=2>Set new value - type = %s</tr>\n", data_str1.c_str());
      r->rsprintf("<tr><td>%s<td>\n", str1.c_str());
 
      /* set current value as default */
      size = sizeof(data);
      db_get_link_data(hDB, hkey, data, &size, key.type);
      std::string data_str = db_sprintf(data, key.item_size, index, key.type);
 
      if (equal_ustring(data_str.c_str(), "<NULL>"))
         data_str = "";
 
      if (strchr(data_str.c_str(), '\n') != NULL) {
         r->rsprintf("<textarea rows=20 cols=80 name=\"text\">\n");
         strencode3(r, data);
         r->rsprintf("</textarea>\n");
      } else {
         size = 20;
         if ((int) data_str.length() > size)
            size = data_str.length() + 3;
         if (size > 80)
            size = 80;
 
         r->rsprintf("<input type=\"text\" size=%d maxlength=256 name=\"value\" value=\"", size);
         strencode(r, data_str.c_str());
         r->rsprintf("\">\n");
      }
 
      r->rsprintf("</tr>\n");
 
      r->rsprintf("<tr><td align=center colspan=2>");
      r->rsprintf("<input type=submit name=cmd value=Set>");
      r->rsprintf("<input type=submit name=cmd value=Cancel>");
      r->rsprintf("</tr>");
      r->rsprintf("</table>");
 
      r->rsprintf("<input type=hidden name=cmd value=Set>\n");
 
      r->rsprintf("</div>\n"); // closing for <div id="mmain">
      r->rsprintf("</form>\n");
      r->rsprintf("</body></html>\r\n");
      return;
   } else {
      /* set value */
 
      status = db_find_link(hDB, 0, odb_path.c_str(), &hkey);
      if (status != DB_SUCCESS) {
         r->rsprintf("Error: cannot find key %s<P>\n", odb_path.c_str());
         return;
      }
      db_get_link(hDB, hkey, &key);
 
      memset(data, 0, sizeof(data));
 
      if (pp->getparam("text") && *pp->getparam("text"))
         mstrlcpy(data, pp->getparam("text"), sizeof(data));
      else
         db_sscanf(value, data, &size, 0, key.type);
 
      if (index < 0)
         index = 0;
 
      /* extend data size for single string if necessary */
      if ((key.type == TID_STRING || key.type == TID_LINK)
          && (int) strlen(data) + 1 > key.item_size && key.num_values == 1)
         key.item_size = strlen(data) + 1;
 
      if (key.item_size == 0)
         key.item_size = rpc_tid_size(key.type);
 
      if (key.num_values > 1)
         status = db_set_link_data_index(hDB, hkey, data, key.item_size, index, key.type);
      else
         status = db_set_link_data(hDB, hkey, data, key.item_size, 1, key.type);
 
      if (status == DB_NO_ACCESS)
         r->rsprintf("<h2>Write access not allowed</h2>\n");
 
      redirect(r, "");
 
      return;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

show_text_header()

void show_text_header

(

Return *

r

)

Definition at line 1827 of file mhttpd.cxx.

{
   r->rsprintf("HTTP/1.1 200 Document follows\r\n");
   r->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
   r->rsprintf("Access-Control-Allow-Origin: *\r\n");
   r->rsprintf("Cache-control: private, max-age=0, no-cache\r\n");
   r->rsprintf("Expires: Fri, 01 Jan 1983 00:00:00 GMT\r\n");
   r->rsprintf("Content-Type: text/plain; charset=%s\r\n\r\n", HTTP_ENCODING);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SortHistPlotVars()

static void SortHistPlotVars ( HistPlot &  hp )

static

Definition at line 10498 of file mhttpd.cxx.

{
   /* sort variables according to "hist_order" */
   
   bool need_sort = false;
   for (size_t i=1; i<hp.vars.size(); i++) {
      if (hp.vars[i-1].order >= hp.vars[i].order) {
         need_sort = true;
      }
   }
   
   if (need_sort) {
      /* sort variables by order */
      std::sort(hp.vars.begin(), hp.vars.end(), cmp_vars);
      
      /* renumber the variables according to the new sorted order */
      for (size_t index=0; index<hp.vars.size(); index++)
         hp.vars[index].order = (index+1)*10;
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SplitEventAndTagNames()

static void SplitEventAndTagNames ( std::string  var_name, std::string &  event_name, std::string &  tag_name  )

static

Definition at line 10151 of file mhttpd.cxx.

                                                                                                  {
   event_name = "";
   tag_name = "";
 
   std::vector<size_t> colons;
 
   for (size_t i = 0; i < var_name.size(); i++) {
      if (var_name[i] == ':') {
         colons.push_back(i);
      }
   }
 
   if (colons.size() == 0) {
      // No colons - leave the tag name empty
      event_name = var_name;
   } else { 
      size_t split_pos;
      size_t slash_pos = var_name.find("/");
      bool uses_per_variable_naming = (slash_pos != std::string::npos);
 
      if (uses_per_variable_naming && colons.size() % 2 == 1) {
         size_t middle_colon_pos = colons[colons.size() / 2];
         std::string slash_to_mid = var_name.substr(slash_pos + 1, middle_colon_pos - slash_pos - 1);
         std::string mid_to_end = var_name.substr(middle_colon_pos + 1);
 
         if (slash_to_mid == mid_to_end) {
            // Special case - we have a string of the form Beamlime/GS2:FC1:GS2:FC1.
            // Logger has already warned people that having colons in the equipment/event 
            // names is a bad idea, so we only need to worry about them in the tag name.
            split_pos = middle_colon_pos;
         } else {
            // We have a string of the form Beamlime/Demand:GS2:FC1. Split at the first colon.
            split_pos = colons[0];
         }
      } else {
         // Normal case - split at the fist colon.
         split_pos = colons[0];
      }
 
      event_name = var_name.substr(0, split_pos);
      tag_name = var_name.substr(split_pos + 1);
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

starts_with()

bool starts_with	(	const std::string &	s1,
		const char *	s2
	)

Definition at line 4427 of file mhttpd.cxx.

{
   if (s1.length() < strlen(s2))
      return false;
   return (strncasecmp(s1.c_str(), s2, strlen(s2)) == 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

strencode()

void strencode	(	Return *	r,
		const char *	text
	)

Definition at line 2019 of file mhttpd.cxx.

{
   size_t len = strlen(text);
   for (size_t i = 0; i < len; i++) {
      switch (text[i]) {
      case '\n':
         r->rsprintf("<br>\n");
         break;
      case '<':
         r->rsprintf("&lt;");
         break;
      case '>':
         r->rsprintf("&gt;");
         break;
      case '&':
         r->rsprintf("&amp;");
         break;
      case '\"':
         r->rsprintf("&quot;");
         break;
      default:
         r->rsprintf("%c", text[i]);
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

strencode2()

std::string strencode2

(

const char *

text

)

Definition at line 2047 of file mhttpd.cxx.

{
   std::string b;
   size_t len = strlen(text);
   for (size_t i = 0; i < len; i++) {
      switch (text[i]) {
      case '\n':
         b += "<br>\n";
         break;
      case '<':
         b += "&lt;";
         break;
      case '>':
         b += "&gt;";
         break;
      case '&':
         b += "&amp;";
         break;
      case '\"':
         b += "&quot;";
         break;
      default:
         b += text[i];
         break;
      }
   }
   return b;
}

Here is the call graph for this function:

Here is the caller graph for this function:

strencode3()

void strencode3	(	Return *	r,
		const char *	text
	)

Definition at line 2078 of file mhttpd.cxx.

{
   size_t len = strlen(text);
   for (size_t i = 0; i < len; i++) {
      switch (text[i]) {
      case '<':
         r->rsprintf("&lt;");
         break;
      case '>':
         r->rsprintf("&gt;");
         break;
      case '&':
         r->rsprintf("&amp;");
         break;
      case '\"':
         r->rsprintf("&quot;");
         break;
      default:
         r->rsprintf("%c", text[i]);
      }
   }
}

Here is the call graph for this function:

Here is the caller graph for this function:

strencode4()

void strencode4	(	Return *	r,
		const char *	text
	)

Definition at line 2103 of file mhttpd.cxx.

{
   size_t len = strlen(text);
   for (size_t i = 0; i < len; i++) {
      switch (text[i]) {
         case '\n':
            r->rsprintf("<br>\n");
            break;
         case '<':
            r->rsprintf("&lt;");
            break;
         case '>':
            r->rsprintf("&gt;");
            break;
         case '&':
            r->rsprintf("&amp;");
            break;
         case '\"':
            r->rsprintf("&quot;");
            break;
         case ' ':
            r->rsprintf("&nbsp;");
            break;
         default:
            r->rsprintf("%c", text[i]);
      }
   }
}

Here is the call graph for this function:

string_to_time()

time_t string_to_time

(

const char *

str

)

Definition at line 8117 of file mhttpd.cxx.

{
   time_t t = 0;
   for (; *str != 0; str++) {
      if (*str < '0')
         break;
      if (*str > '9')
         break;
      t *= 10;
      t += *str - '0';
   }
   return t;
}

Here is the call graph for this function:

Here is the caller graph for this function:

stristr()

char * stristr	(	const char *	str,
		const char *	pattern
	)

Definition at line 339 of file mhttpd.cxx.

{
   char c1, c2, *ps, *pp;
 
   if (str == NULL || pattern == NULL)
      return NULL;
 
   while (*str) {
      ps = (char *) str;
      pp = (char *) pattern;
      c1 = *ps;
      c2 = *pp;
      if (toupper(c1) == toupper(c2)) {
         while (*pp) {
            c1 = *ps;
            c2 = *pp;
 
            if (toupper(c1) != toupper(c2))
               break;
 
            ps++;
            pp++;
         }
 
         if (!*pp)
            return (char *) str;
      }
      str++;
   }
 
   return NULL;
}

Here is the call graph for this function:

submit_elog()

void submit_elog	(	MVOdb *	odb,
		Param *	pp,
		Return *	r,
		Attachment *	a
	)

Definition at line 2248 of file mhttpd.cxx.

{
   char path[256], path1[256];
   char mail_to[256], mail_from[256], mail_list[256],
       smtp_host[256], tag[80], mail_param[1000];
   char *p, *pitem;
   HNDLE hDB, hkey;
   char att_file[3][256];
   int fh, size, n_mail;
   char mhttpd_full_url[256];
 
   cm_get_experiment_database(&hDB, NULL);
   mstrlcpy(att_file[0], pp->getparam("attachment0"), sizeof(att_file[0]));
   mstrlcpy(att_file[1], pp->getparam("attachment1"), sizeof(att_file[1]));
   mstrlcpy(att_file[2], pp->getparam("attachment2"), sizeof(att_file[2]));
 
   /* check for valid attachment files */
   for (int i = 0; i < 3; i++) {
      char str[256];
      sprintf(str, "attachment%d", i);
      //printf("submit_elog: att %d, [%s] param [%s], size %d\n", i, str, pp->getparam(str), a->_attachment_size[i]);
      if (pp->getparam(str) && *pp->getparam(str) && a->attachment_size[i] == 0) {
         /* replace '\' by '/' */
         mstrlcpy(path, pp->getparam(str), sizeof(path));
         mstrlcpy(path1, path, sizeof(path1));
         while (strchr(path, '\\'))
            *strchr(path, '\\') = '/';
 
         /* check if valid ODB tree */
         if (db_find_key(hDB, 0, path, &hkey) == DB_SUCCESS) {
            std::string bout;
            gen_odb_attachment(r, path, bout);
            int bufsize = bout.length()+1;
            char* buf = (char*)M_MALLOC(bufsize);
            memcpy(buf, bout.c_str(), bufsize);
            mstrlcpy(att_file[i], path, sizeof(att_file[0]));
            mstrlcat(att_file[i], ".html", sizeof(att_file[0]));
            a->attachment_buffer[i] = buf;
            a->attachment_size[i] = bufsize;
         }
         /* check if local file */
         else if ((fh = open(path1, O_RDONLY | O_BINARY)) >= 0) {
            size = lseek(fh, 0, SEEK_END);
            char* buf = (char*)M_MALLOC(size);
            lseek(fh, 0, SEEK_SET);
            int rd = read(fh, buf, size);
            if (rd < 0)
               rd = 0;
            close(fh);
            mstrlcpy(att_file[i], path, sizeof(att_file[0]));
            a->attachment_buffer[i] = buf;
            a->attachment_size[i] = rd;
         } else if (strncmp(path, "/HS/", 4) == 0) {
            char* buf = (char*)M_MALLOC(100000);
            size = 100000;
            mstrlcpy(str, path + 4, sizeof(str));
            if (strchr(str, '?')) {
               p = strchr(str, '?') + 1;
               p = strtok(p, "&");
               while (p != NULL) {
                  pitem = p;
                  p = strchr(p, '=');
                  if (p != NULL) {
                     *p++ = 0;
                     urlDecode(pitem); // parameter name
                     urlDecode(p); // parameter value
 
                     pp->setparam(pitem, p);
 
                     p = strtok(NULL, "&");
                  }
               }
               *strchr(str, '?') = 0;
            }
            show_hist_page(odb, pp, r, "image.gif", buf, &size, 0);
            mstrlcpy(att_file[i], str, sizeof(att_file[0]));
            a->attachment_buffer[i] = buf;
            a->attachment_size[i] = size;
            pp->unsetparam("scale");
            pp->unsetparam("offset");
            pp->unsetparam("width");
            pp->unsetparam("index");
         } else {
            r->rsprintf("HTTP/1.1 200 Document follows\r\n");
            r->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
            r->rsprintf("Content-Type: text/html; charset=%s\r\n\r\n", HTTP_ENCODING);
 
            r->rsprintf("<html><head>\n");
            r->rsprintf("<link rel=\"icon\" href=\"favicon.png\" type=\"image/png\" />\n");
            r->rsprintf("<link rel=\"stylesheet\" href=\"midas.css\" type=\"text/css\" />\n");
            r->rsprintf("<link rel=\"stylesheet\" href=\"mhttpd.css\" type=\"text/css\" />\n");
            r->rsprintf("<title>ELog Error</title></head>\n");
            r->rsprintf("<i>Error: Attachment file <i>%s</i> not valid.</i><p>\n", pp->getparam(str));
            r->rsprintf("Please go back and enter a proper filename (use the <b>Browse</b> button).\n");
            r->rsprintf("<body></body></html>\n");
            return;
         }
      }
   }
 
   int edit = atoi(pp->getparam("edit"));
   //printf("submit_elog: edit [%s] %d, orig [%s]\n", pp->getparam("edit"), edit, pp->getparam("orig"));
 
   tag[0] = 0;
   if (edit) {
      mstrlcpy(tag, pp->getparam("orig"), sizeof(tag));
   }
 
   int status = el_submit(atoi(pp->getparam("run")),
                          pp->getparam("author"),
                          pp->getparam("type"),
                          pp->getparam("system"),
                          pp->getparam("subject"),
                          pp->getparam("text"),
                          pp->getparam("orig"),
                          *pp->getparam("html") ? "HTML" : "plain",
                          att_file[0], a->attachment_buffer[0], a->attachment_size[0],
                          att_file[1], a->attachment_buffer[1], a->attachment_size[1],
                          att_file[2], a->attachment_buffer[2], a->attachment_size[2],
                          tag, sizeof(tag));
 
   //printf("el_submit status %d, tag [%s]\n", status, tag);
 
   if (status != EL_SUCCESS) {
      cm_msg(MERROR, "submit_elog", "el_submit() returned status %d", status);
   }
 
   /* supersede host name with "/Elog/Host name" */
   std::string elog_host_name;
   db_get_value_string(hDB, 0, "/Elog/Host name", 0, &elog_host_name, TRUE);
 
   // K.O. FIXME: we cannot guess the Elog URL like this because
   // we do not know if access is through a proxy or redirect
   // we do not know if it's http: or https:, etc. Better
   // to read the whole "mhttpd_full_url" string from ODB.
   sprintf(mhttpd_full_url, "http://%s/", elog_host_name.c_str());
 
   /* check for mail submissions */
   mail_param[0] = 0;
   n_mail = 0;
 
   for (int index = 0; index <= 1; index++) {
      std::string str;
      str += "/Elog/Email ";
      if (index == 0)
         str += pp->getparam("type");
      else
         str += pp->getparam("system");
 
      if (db_find_key(hDB, 0, str.c_str(), &hkey) == DB_SUCCESS) {
         size = sizeof(mail_list);
         db_get_data(hDB, hkey, mail_list, &size, TID_STRING);
 
         if (db_find_key(hDB, 0, "/Elog/SMTP host", &hkey) != DB_SUCCESS) {
            show_error(r, "No SMTP host defined under /Elog/SMTP host");
            return;
         }
         size = sizeof(smtp_host);
         db_get_data(hDB, hkey, smtp_host, &size, TID_STRING);
 
         p = strtok(mail_list, ",");
         while (1) {
            mstrlcpy(mail_to, p, sizeof(mail_to));
 
            std::string exptname;
            db_get_value_string(hDB, 0, "/Experiment/Name", 0, &exptname, TRUE);
 
            sprintf(mail_from, "MIDAS %s <MIDAS@%s>", exptname.c_str(), elog_host_name.c_str());
 
            std::string mail_text;
            mail_text += "A new entry has been submitted by ";
            mail_text += pp->getparam("author");
            mail_text += "\n";
            mail_text += "\n";
 
            mail_text += "Experiment : ";
            mail_text += exptname.c_str();
            mail_text += "\n";
 
            mail_text += "Type       : ";
            mail_text += pp->getparam("type");
            mail_text += "\n";
 
            mail_text += "System     : ";
            mail_text += pp->getparam("system");
            mail_text += "\n";
 
            mail_text += "Subject    : ";
            mail_text += pp->getparam("subject");
            mail_text += "\n";
 
            mail_text += "Link       : ";
            mail_text += mhttpd_full_url;
            mail_text += "/EL/";
            mail_text += tag;
            mail_text += "\n";
 
            mail_text += "\n";
 
            mail_text += pp->getparam("text");
            mail_text += "\n";
 
            sendmail(elog_host_name.c_str(), smtp_host, mail_from, mail_to, pp->getparam("type"), mail_text.c_str());
 
            if (mail_param[0] == 0)
               mstrlcpy(mail_param, "?", sizeof(mail_param));
            else
               mstrlcat(mail_param, "&", sizeof(mail_param));
            sprintf(mail_param + strlen(mail_param), "mail%d=%s", n_mail++, mail_to);
 
            p = strtok(NULL, ",");
            if (!p)
               break;
            while (*p == ' ')
               p++;
         }
      }
   }
 
   r->rsprintf("HTTP/1.1 302 Found\r\n");
   r->rsprintf("Server: MIDAS HTTP %s\r\n", mhttpd_revision());
 
   //if (mail_param[0])
   //   r->rsprintf("Location: ../EL/%s?%s\n\n<html>redir</html>\r\n", tag, mail_param + 1);
   //else
   //   r->rsprintf("Location: ../EL/%s\n\n<html>redir</html>\r\n", tag);
 
   if (mail_param[0])
      r->rsprintf("Location: ?cmd=Show+elog&tag=%s&%s\n\n<html>redir</html>\r\n", tag, mail_param + 1);
   else
      r->rsprintf("Location: ?cmd=Show+elog&tag=%s\n\n<html>redir</html>\r\n", tag);
}

Here is the call graph for this function:

Here is the caller graph for this function:

taxis()

void taxis	(	gdImagePtr	im,
		gdFont *	font,
		int	col,
		int	gcol,
		int	x1,
		int	y1,
		int	width,
		int	xr,
		int	minor,
		int	major,
		int	text,
		int	label,
		int	grid,
		double	xmin,
		double	xmax
	)

Definition at line 7785 of file mhttpd.cxx.

{
   int dx, x_act, label_dx, major_dx, x_screen, maxwidth;
   int tick_base, major_base, label_base, xs, xl;
   char str[80];
   const int base[] = { 1, 5, 10, 60, 300, 600, 1800, 3600, 3600 * 6, 3600 * 12, 3600 * 24, 0 };
   time_t ltime;
   int force_date, d1, d2;
   struct tm tms;
 
   if (xmax <= xmin || width <= 0)
      return;
 
   /* force date display if xmax not today */
   ltime = ss_time();
   localtime_r(&ltime, &tms);
   d1 = tms.tm_mday;
   ltime = (time_t) xmax;
   localtime_r(&ltime, &tms);
   d2 = tms.tm_mday;
   force_date = (d1 != d2);
 
   /* use 5 pixel as min tick distance */
   dx = (int) ((xmax - xmin) / (double) (width / 5) + 0.5);
 
   for (tick_base = 0; base[tick_base]; tick_base++) {
      if (base[tick_base] > dx)
         break;
   }
   if (!base[tick_base])
      tick_base--;
   dx = base[tick_base];
 
   if (base[tick_base + 1])
      major_base = tick_base + 1;
   else
      major_base = tick_base;
   major_dx = base[major_base];
 
   if (base[major_base + 1])
      label_base = major_base + 1;
   else
      label_base = major_base;
   label_dx = base[label_base];
 
   do {
      sec_to_label(str, (int) (xmin + 0.5), label_dx, force_date);
      maxwidth = font->h / 2 * strlen(str);
 
      /* increasing label_dx, if labels would overlap */
      if (maxwidth > 0.7 * label_dx / (xmax - xmin) * width) {
         if (base[label_base + 1])
            label_dx = base[++label_base];
         else
            label_dx += 3600 * 24;
      } else
         break;
   } while (1);
 
   x_act =
       (int) floor((double) (xmin - ss_timezone()) / label_dx) * label_dx + ss_timezone();
 
   gdImageLine(im, x1, y1, x1 + width, y1, col);
 
   do {
      x_screen = (int) ((x_act - xmin) / (xmax - xmin) * width + x1 + 0.5);
      xs = (int) (x_screen + 0.5);
 
      if (x_screen > x1 + width + 0.001)
         break;
 
      if (x_screen >= x1) {
         if ((x_act - ss_timezone()) % major_dx == 0) {
            if ((x_act - ss_timezone()) % label_dx == 0) {
               /* label tick mark */
               gdImageLine(im, xs, y1, xs, y1 + text, col);
 
               /* grid line */
               if (grid != 0 && xs > x1 && xs < x1 + width)
                  gdImageLine(im, xs, y1, xs, y1 + grid, col);
 
               /* label */
               if (label != 0) {
                  sec_to_label(str, x_act, label_dx, force_date);
 
                  /* if labels at edge, shift them in */
                  xl = (int) xs - font->w * strlen(str) / 2;
                  if (xl < 0)
                     xl = 0;
                  if (xl + font->w * (int) strlen(str) > xr)
                     xl = xr - font->w * strlen(str);
                  gdImageString(im, font, xl, y1 + label, str, col);
               }
            } else {
               /* major tick mark */
               gdImageLine(im, xs, y1, xs, y1 + major, col);
 
               /* grid line */
               if (grid != 0 && xs > x1 && xs < x1 + width)
                  gdImageLine(im, xs, y1 - 1, xs, y1 + grid, gcol);
            }
 
         } else
            /* minor tick mark */
            gdImageLine(im, xs, y1, xs, y1 + minor, col);
 
      }
 
      x_act += dx;
 
      /* supress 1.23E-17 ... */
      if (fabs((double)x_act) < dx / 100)
         x_act = 0;
 
   } while (1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

time_to_sec()

int time_to_sec

(

const char *

str

)

Definition at line 8092 of file mhttpd.cxx.

{
   double s;
 
   s = atof(str);
   switch (str[strlen(str) - 1]) {
   case 'm':
   case 'M':
      s *= 60;
      break;
   case 'h':
   case 'H':
      s *= 3600;
      break;
   case 'd':
   case 'D':
      s *= 3600 * 24;
      break;
   }
 
   return (int) s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

time_to_string()

std::string time_to_string

(

time_t

t

)

Definition at line 8133 of file mhttpd.cxx.

{
   char buf[256];
   sprintf(buf, "%.0f", (double)t);
   return buf;
}

Here is the call graph for this function:

Here is the caller graph for this function:

toString()

static std::string toString ( int  i )

static

Definition at line 55 of file mhttpd.cxx.

{
   char buf[256];
   sprintf(buf, "%d", i);
   return buf;
}

Here is the call graph for this function:

Here is the caller graph for this function:

try_file_mg()

int try_file_mg	(	const char *	try_dir,
		const char *	filename,
		std::string &	path,
		FILE **	fpp,
		bool	trace
	)

Definition at line 13639 of file mhttpd.cxx.

{
   if (fpp)
      *fpp = NULL;
   if (!try_dir)
      return SS_FILE_ERROR;
   if (strlen(try_dir) < 1)
      return SS_FILE_ERROR;
 
   path = try_dir;
   if (path[path.length()-1] != DIR_SEPARATOR)
      path += DIR_SEPARATOR_STR;
   path += filename;
 
   FILE* fp = fopen(path.c_str(), "r");
 
   if (trace) {
      if (fp)
         printf("file \"%s\": OK!\n", path.c_str());
      else
         printf("file \"%s\": not found.\n", path.c_str());
   }
 
   if (!fp)
      return SS_FILE_ERROR;
   else if (fpp)
      *fpp = fp;
   else
      fclose(fp);
 
   return SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Unlock()

void Unlock

(

RequestTrace *

t

)

Definition at line 12246 of file mhttpd.cxx.

{
   t->fTimeUnlocked = GetTimeSec();
   gMutex.unlock();
}

Here is the call graph for this function:

Here is the caller graph for this function:

urlDecode()

static void urlDecode ( char *  p )

static

Definition at line 880 of file mhttpd.cxx.

{
   //char *px = p;
   char *pD, str[3];
   int i;
 
   //printf("URL decode: [%s] --> ", p);
 
   pD = p;
   while (*p) {
      if (*p == '%') {
         /* Escape: next 2 chars are hex representation of the actual character */
         p++;
         if (isxdigit(p[0]) && isxdigit(p[1])) {
            str[0] = p[0];
            str[1] = p[1];
            str[2] = 0;
            sscanf(str, "%02X", &i);
 
            *pD++ = (char) i;
            p += 2;
         } else
            *pD++ = '%';
      } else if (*p == '+') {
         /* convert '+' to ' ' */
         *pD++ = ' ';
         p++;
      } else {
         *pD++ = *p++;
      }
   }
   *pD = '\0';
 
   //printf("[%s]\n", px);
}

Here is the call graph for this function:

Here is the caller graph for this function:

UrlDecode()

static std::string UrlDecode ( const char *  p )

static

Definition at line 841 of file mhttpd.cxx.

{
   std::string s;
 
   //printf("URL decode: [%s] --> ", p);
 
   while (*p) {
      if (*p == '%') {
         /* Escape: next 2 chars are hex representation of the actual character */
         p++;
         if (isxdigit(p[0]) && isxdigit(p[1])) {
            int i = 0;
            char str[3];
            str[0] = p[0];
            str[1] = p[1];
            str[2] = 0;
            sscanf(str, "%02X", &i);
 
            s += (char) i;
            p += 2;
         } else
            s += '%';
      } else if (*p == '+') {
         /* convert '+' to ' ' */
         s += ' ';
         p++;
      } else {
         s += *p++;
      }
   }
 
   //printf("[%s]\n", s.c_str());
 
   return s;
}

Here is the call graph for this function:

Here is the caller graph for this function:

urlEncode() [1/2]

static void urlEncode ( char *  ps, int  ps_size  )

static

Definition at line 919 of file mhttpd.cxx.

{
   char *pd, *p;
   int len = strlen(ps);
   char *str = (char*)malloc(len*3 + 10); // at worst, each input character is expanded into 3 output characters
 
   pd = str;
   p = ps;
   while (*p) {
      if (isalnum(*p)) {
         *pd++ = *p++;
      } else {
         sprintf(pd, "%%%02X", (*p)&0xFF);
         pd += 3;
         p++;
      }
   }
   *pd = '\0';
 
   if (/* DISABLES CODE */ (0)) {
      printf("urlEncode [");
      for (p=ps; *p!=0; p++)
         printf("0x%02x ", (*p)&0xFF);
      printf("]\n");
 
      printf("urlEncode [%s] -> [%s]\n", ps, str);
   }
 
   mstrlcpy(ps, str, ps_size);
   free(str);
}

Here is the call graph for this function:

Here is the caller graph for this function:

urlEncode() [2/2]

static std::string urlEncode ( const char *  text )

static

Definition at line 955 of file mhttpd.cxx.

{
   std::string encoded;
 
   const char* p = text;
   while (*p) {
      if (isalnum(*p)) {
         encoded += *p++;
      } else {
         char buf[16];
         sprintf(buf, "%%%02X", (*p)&0xFF);
         encoded += buf;
         p++;
      }
   }
 
   if (/* DISABLES CODE */ (0)) {
      printf("urlEncode [");
      for (p=text; *p!=0; p++)
         printf("0x%02x ", (*p)&0xFF);
      printf("]\n");
 
      printf("urlEncode [%s] -> [%s]\n", text, encoded.c_str());
   }
 
   return encoded;
}

Here is the call graph for this function:

vaxis()

int vaxis	(	gdImagePtr	im,
		gdFont *	font,
		int	col,
		int	gcol,
		int	x1,
		int	y1,
		int	width,
		int	minor,
		int	major,
		int	text,
		int	label,
		int	grid,
		double	ymin,
		double	ymax,
		BOOL	logaxis
	)

Definition at line 7906 of file mhttpd.cxx.

{
   double dy, int_dy, frac_dy, y_act, label_dy, major_dy, y_screen, y_next;
   int tick_base, major_base, label_base, n_sig1, n_sig2, ys, max_width;
   int last_label_y;
   char str[80];
   const double base[] = { 1, 2, 5, 10, 20, 50, 100, 200, 500, 1000 };
 
   if (ymax <= ymin || width <= 0)
      return 0;
 
   // data type "double" only has about 15 significant digits, if difference between ymax and ymin is less than 10 significant digits, bailout! Otherwise code below goes into infinite loop
   if (fabs(ymax - ymin) <= 1e-10)
      return 0;
 
   if (logaxis) {
      dy = pow(10, floor(log(ymin) / LN10));
      label_dy = dy;
      major_dy = dy * 10;
      n_sig1 = 4;
   } else {
      dy = (ymax - ymin) / (double) (width / 5);
 
      frac_dy = modf(log(dy) / LN10, &int_dy);
      if (frac_dy < 0) {
         frac_dy += 1;
         int_dy -= 1;
      }
 
      tick_base = frac_dy < LOG2 ? 1 : frac_dy < LOG5 ? 2 : 3;
      major_base = label_base = tick_base + 1;
 
      /* rounding up of dy, label_dy */
      dy = pow(10, int_dy) * base[tick_base];
      major_dy = pow(10, int_dy) * base[major_base];
      label_dy = major_dy;
 
      /* number of significant digits */
      if (ymin == 0)
         n_sig1 = 0;
      else
         n_sig1 =
             (int) floor(log(fabs(ymin)) / LN10) -
             (int) floor(log(fabs(label_dy)) / LN10) + 1;
 
      if (ymax == 0)
         n_sig2 = 0;
      else
         n_sig2 =
             (int) floor(log(fabs(ymax)) / LN10) -
             (int) floor(log(fabs(label_dy)) / LN10) + 1;
 
      n_sig1 = MAX(n_sig1, n_sig2);
      n_sig1 = MAX(n_sig1, 4);
 
      /* increasing label_dy, if labels would overlap */
      while (label_dy / (ymax - ymin) * width < 1.5 * font->h) {
         label_base++;
         label_dy = pow(10, int_dy) * base[label_base];
         if (label_base % 3 == 2 && major_base % 3 == 1) {
            major_base++;
            major_dy = pow(10, int_dy) * base[major_base];
         }
      }
   }
 
   max_width = 0;
   y_act = floor(ymin / dy) * dy;
 
   if (x1 != 0 || y1 != 0)
      gdImageLine(im, x1, y1, x1, y1 - width, col);
 
   last_label_y = y1 + 2 * font->h;
 
   do {
      if (logaxis)
         y_screen = y1 - (log(y_act) - log(ymin)) / (log(ymax) - log(ymin)) * width;
      else
         y_screen = y1 - (y_act - ymin) / (ymax - ymin) * width;
      ys = (int) (y_screen + 0.5);
 
      if (y_screen < y1 - width - 0.001)
         break;
 
      if (y_screen <= y1 + 0.001) {
         if (fabs(floor(y_act / major_dy + 0.5) - y_act / major_dy) <
             dy / major_dy / 10.0) {
            if (fabs(floor(y_act / label_dy + 0.5) - y_act / label_dy) <
                dy / label_dy / 10.0) {
               if (x1 != 0 || y1 != 0) {
                  /* label tick mark */
                  gdImageLine(im, x1, ys, x1 + text, ys, col);
 
                  /* grid line */
                  if (grid != 0 && y_screen < y1 && y_screen > y1 - width) {
                     if (grid > 0)
                        gdImageLine(im, x1 + 1, ys, x1 + grid, ys, gcol);
                     else
                        gdImageLine(im, x1 - 1, ys, x1 + grid, ys, gcol);
                  }
 
                  /* label */
                  if (label != 0) {
                     sprintf(str, "%1.*lG", n_sig1, y_act);
                     if (label < 0)
                        gdImageString(im, font, x1 + label - font->w * strlen(str),
                                      ys - font->h / 2, str, col);
                     else
                        gdImageString(im, font, x1 + label, ys - font->h / 2, str, col);
 
                     last_label_y = ys - font->h / 2;
                  }
               } else {
                  sprintf(str, "%1.*lG", n_sig1, y_act);
                  max_width = MAX(max_width, (int) (font->w * strlen(str)));
               }
            } else {
               if (x1 != 0 || y1 != 0) {
                  /* major tick mark */
                  gdImageLine(im, x1, ys, x1 + major, ys, col);
 
                  /* grid line */
                  if (grid != 0 && y_screen < y1 && y_screen > y1 - width)
                     gdImageLine(im, x1, ys, x1 + grid, ys, col);
               }
            }
            if (logaxis) {
               dy *= 10;
               major_dy *= 10;
               label_dy *= 10;
            }
 
         } else {
            if (x1 != 0 || y1 != 0) {
               /* minor tick mark */
               gdImageLine(im, x1, ys, x1 + minor, ys, col);
            }
 
            /* for logaxis, also put labes on minor tick marks */
            if (logaxis) {
               if (label != 0) {
                  if (x1 != 0 || y1 != 0) {
                     /* calculate position of next major label */
                     y_next = pow(10, floor(log(y_act) / LN10) + 1);
                     y_screen =
                         (int) (y1 -
                                (log(y_next) - log(ymin)) / (log(ymax) -
                                                             log(ymin)) * width + 0.5);
 
                     if (ys + font->h / 2 < last_label_y
                         && ys - font->h / 2 > y_screen + font->h / 2) {
                        sprintf(str, "%1.*lG", n_sig1, y_act);
                        if (label < 0)
                           gdImageString(im, font, x1 + label - font->w * strlen(str),
                                         ys - font->h / 2, str, col);
                        else
                           gdImageString(im, font, x1 + label, ys - font->h / 2, str,
                                         col);
                     }
 
                     last_label_y = ys - font->h / 2;
                  } else {
                     sprintf(str, "%1.*lG", n_sig1, y_act);
                     max_width = MAX(max_width, (int) (font->w * strlen(str)));
                  }
               }
            }
         }
      }
 
      y_act += dy;
 
      /* supress 1.23E-17 ... */
      if (fabs(y_act) < dy / 100)
         y_act = 0;
 
   } while (1);
 
   return max_width + abs(label);
}

Here is the call graph for this function:

Here is the caller graph for this function:

xdb_find_key()

static int xdb_find_key ( HNDLE  hDB, HNDLE  dir, const char *  str, HNDLE *  hKey, int  tid, int  size  )

static

Definition at line 10078 of file mhttpd.cxx.

{
   int status = db_find_key(hDB, dir, str, hKey);
   if (status == DB_SUCCESS)
      return status;
 
   db_create_key(hDB, dir, str, tid);
   status = db_find_key(hDB, dir, str, hKey);
   if (status != DB_SUCCESS || !*hKey) {
      cm_msg(MERROR, "xdb_find_key", "Invalid ODB path \"%s\"", str);
      str = "bad_xdb_find_key";
      db_create_key(hDB, dir, str, tid);
      db_find_key(hDB, dir, str, hKey);
   }
   assert(*hKey);
 
   if (tid == TID_STRING) {
      db_set_data_index(hDB, *hKey, "", size, 0, TID_STRING);
   }
 
   return status;
}

Here is the call graph for this function:

xdb_get_data_index()

int xdb_get_data_index	(	HNDLE	hDB,
		const char *	str,
		void *	value,
		int	size,
		int	index,
		int	tid
	)

Definition at line 10062 of file mhttpd.cxx.

{
   HNDLE hKey;
   int status = db_find_key(hDB, 0, str, &hKey);
   if (status != DB_SUCCESS)
      return status;
 
   KEY key;
   db_get_key(hDB, hKey, &key);
   if (index >= key.num_values)
      return DB_OUT_OF_RANGE;
 
   status = db_get_data_index(hDB, hKey, value, &size, index, tid);
   return status;
}

Here is the call graph for this function:

xmg_check_nonce()

static int xmg_check_nonce ( const char *  nonce )

static

Definition at line 13775 of file mhttpd.cxx.

                                              {
  unsigned long now = (unsigned long) time(NULL);
  unsigned long val = (unsigned long) strtoul(nonce, NULL, 16);
  return now < val || now - val < 3600;
}

Here is the call graph for this function:

Here is the caller graph for this function:

xmg_http_send_digest_auth_request()

static void xmg_http_send_digest_auth_request ( struct mg_connection *  c, const char *  domain  )

static

Definition at line 13786 of file mhttpd.cxx.

                                                                 {
  mg_printf(c,
            "HTTP/1.1 401 Unauthorized\r\n"
            "WWW-Authenticate: Digest qop=\"auth\", "
            "realm=\"%s\", nonce=\"%lu\"\r\n"
            "Content-Length: 0\r\n\r\n",
            domain, (unsigned long) time(NULL));
}

Here is the call graph for this function:

Here is the caller graph for this function:

xmg_mkmd5resp()

static void xmg_mkmd5resp ( const char *  method, size_t  method_len, const char *  uri, size_t  uri_len, const char *  ha1, size_t  ha1_len, const char *  nonce, size_t  nonce_len, const char *  nc, size_t  nc_len, const char *  cnonce, size_t  cnonce_len, const char *  qop, size_t  qop_len, char *  resp  )

static

Definition at line 13754 of file mhttpd.cxx.

                                                                      {
  static const char colon[] = ":";
  static const size_t one = 1;
  char ha2[33];
 
  cs_md5(ha2, method, method_len, colon, one, uri, uri_len, NULL);
  cs_md5(resp, ha1, ha1_len, colon, one, nonce, nonce_len, colon, one, nc,
         nc_len, colon, one, cnonce, cnonce_len, colon, one, qop, qop_len,
         colon, one, ha2, sizeof(ha2) - 1, NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

_abort

std::atomic_bool _abort {false}

Definition at line 13451 of file mhttpd.cxx.

{false};

cgif_bar_str

const char* cgif_bar_str[]

static

Initial value:

= {
   "Src = STRING : [256] ",
   "X = INT : 0",
   "Y = INT : 0",
   "Width = INT : 10",
   "Height = INT : 100",
   "Direction = INT : 0",
   "Axis = INT : 1",
   "Logscale = BOOL : n",
   "Min = DOUBLE : 0",
   "Max = DOUBLE : 10",
   "FGColor = STRING : [8] 000000",
   "BGColor = STRING : [8] FFFFFF",
   "BDColor = STRING : [8] 808080",
   NULL
}

Definition at line 3468 of file mhttpd.cxx.

                                    {
   "Src = STRING : [256] ",
   "X = INT : 0",
   "Y = INT : 0",
   "Width = INT : 10",
   "Height = INT : 100",
   "Direction = INT : 0",
   "Axis = INT : 1",
   "Logscale = BOOL : n",
   "Min = DOUBLE : 0",
   "Max = DOUBLE : 10",
   "FGColor = STRING : [8] 000000",
   "BGColor = STRING : [8] FFFFFF",
   "BDColor = STRING : [8] 808080",
   NULL
};

cgif_label_str

const char* cgif_label_str[]

static

Initial value:

= {
   "Src = STRING : [256] ",
   "Format = STRING : [32] %1.1f",
   "Font = STRING : [32] Medium",
   "X = INT : 0",
   "Y = INT : 0",
   "Align = INT : 0",
   "FGColor = STRING : [8] 000000",
   "BGColor = STRING : [8] FFFFFF",
   NULL
}

Definition at line 3428 of file mhttpd.cxx.

                                      {
   "Src = STRING : [256] ",
   "Format = STRING : [32] %1.1f",
   "Font = STRING : [32] Medium",
   "X = INT : 0",
   "Y = INT : 0",
   "Align = INT : 0",
   "FGColor = STRING : [8] 000000",
   "BGColor = STRING : [8] FFFFFF",
   NULL
};

default_system_list

const char default_system_list[20][NAME_LENGTH]

static

Initial value:

= {
   "General",
   "DAQ",
   "Detector",
   "Electronics",
   "Target",
   "Beamline"
}

Definition at line 114 of file mhttpd.cxx.

                                                         {
   "General",
   "DAQ",
   "Detector",
   "Electronics",
   "Target",
   "Beamline"
};

default_type_list

const char default_type_list[20][NAME_LENGTH]

static

Initial value:

= {
   "Routine",
   "Shift summary",
   "Minor error",
   "Severe error",
   "Fix",
   "Question",
   "Info",
   "Modification",
   "Reply",
   "Alarm",
   "Test",
   "Other"
}

Definition at line 99 of file mhttpd.cxx.

                                                       {
   "Routine",
   "Shift summary",
   "Minor error",
   "Severe error",
   "Fix",
   "Question",
   "Info",
   "Modification",
   "Reply",
   "Alarm",
   "Test",
   "Other"
};

elog_mode

BOOL elog_mode = FALSE

static

Definition at line 92 of file mhttpd.cxx.

favicon_ico

const unsigned char favicon_ico[]

Definition at line 280 of file mhttpd.cxx.

                                    {
   0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x10, 0x10,
   0x10, 0x00, 0x01, 0x00, 0x04, 0x00, 0x28, 0x01,
   0x00, 0x00, 0x16, 0x00, 0x00, 0x00, 0x28, 0x00,
   0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x20, 0x00,
   0x00, 0x00, 0x01, 0x00, 0x04, 0x00, 0x00, 0x00,
   0x00, 0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xB4, 0x0F,
   0x0A, 0x00, 0x5C, 0x86, 0x4C, 0x00, 0x2F, 0x5E,
   0x1A, 0x00, 0xBF, 0xD3, 0xD7, 0x00, 0x29, 0x17,
   0x8D, 0x00, 0x50, 0xA7, 0xA4, 0x00, 0x59, 0x57,
   0x7F, 0x00, 0xC6, 0xA3, 0xAC, 0x00, 0xFC, 0xFE,
   0xFC, 0x00, 0x28, 0x12, 0x53, 0x00, 0x58, 0x7D,
   0x72, 0x00, 0xC4, 0x3A, 0x34, 0x00, 0x3C, 0x3D,
   0x69, 0x00, 0xC5, 0xB6, 0xB9, 0x00, 0x94, 0x92,
   0x87, 0x00, 0x7E, 0x7A, 0xAA, 0x00, 0x88, 0x88,
   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x81, 0x22,
   0xD8, 0x88, 0x88, 0x88, 0xF6, 0xD8, 0x82, 0x22,
   0xE8, 0x88, 0x88, 0x8D, 0x44, 0x98, 0x82, 0x22,
   0xA8, 0x88, 0x88, 0x8F, 0x44, 0x48, 0x82, 0x22,
   0x25, 0x76, 0x67, 0x55, 0x44, 0xF8, 0x88, 0x88,
   0x3A, 0xC9, 0x9C, 0x53, 0x83, 0x88, 0x88, 0x88,
   0x8D, 0x99, 0x99, 0x38, 0x88, 0x88, 0x88, 0x88,
   0x88, 0x99, 0x9C, 0x88, 0x88, 0x88, 0x88, 0x88,
   0x88, 0xF9, 0x9D, 0x88, 0x88, 0x88, 0x88, 0x88,
   0x88, 0x8A, 0x58, 0x88, 0x88, 0x88, 0x88, 0x88,
   0x88, 0x85, 0xD8, 0x88, 0x88, 0x88, 0x88, 0x88,
   0x88, 0xEA, 0xAE, 0x88, 0x88, 0x88, 0x88, 0x88,
   0x88, 0x00, 0x0B, 0x88, 0x88, 0x88, 0x88, 0x88,
   0x88, 0x70, 0x0D, 0x88, 0x88, 0x88, 0x88, 0x88,
   0x88, 0x87, 0xD8, 0x88, 0x88, 0x88, 0x88, 0x88,
   0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

favicon_png

const unsigned char favicon_png[]

Definition at line 215 of file mhttpd.cxx.

                                    {
   0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A,
   0x00, 0x00, 0x00, 0x0D, 0x49, 0x48, 0x44, 0x52,
   0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x10,
   0x08, 0x02, 0x00, 0x00, 0x00, 0x90, 0x91, 0x68,
   0x36, 0x00, 0x00, 0x00, 0x07, 0x74, 0x49, 0x4D,
   0x45, 0x07, 0xD4, 0x0B, 0x1A, 0x08, 0x37, 0x07,
   0x0D, 0x7F, 0x16, 0x5C, 0x00, 0x00, 0x00, 0x09,
   0x70, 0x48, 0x59, 0x73, 0x00, 0x00, 0x2E, 0x23,
   0x00, 0x00, 0x2E, 0x23, 0x01, 0x78, 0xA5, 0x3F,
   0x76, 0x00, 0x00, 0x00, 0x04, 0x67, 0x41, 0x4D,
   0x41, 0x00, 0x00, 0xB1, 0x8F, 0x0B, 0xFC, 0x61,
   0x05, 0x00, 0x00, 0x01, 0x7D, 0x49, 0x44, 0x41,
   0x54, 0x78, 0xDA, 0x63, 0xFC, 0xFF, 0xFF, 0x3F,
   0x03, 0x29, 0x80, 0x09, 0xAB, 0xE8, 0xD2, 0x65,
   0x77, 0x36, 0x6F, 0x7E, 0x8A, 0x5D, 0xC7, 0x7F,
   0x0C, 0x30, 0x67, 0xEE, 0x0D, 0x56, 0xCE, 0xCD,
   0x5C, 0xBC, 0x3B, 0xB6, 0x6D, 0x7F, 0x81, 0x29,
   0xCB, 0x88, 0xE6, 0x24, 0x20, 0x57, 0x50, 0x7C,
   0xDD, 0xCF, 0x1F, 0x6C, 0x40, 0xCB, 0xB5, 0xB5,
   0x05, 0xCF, 0x1C, 0xB7, 0x42, 0xB3, 0x80, 0x05,
   0x8D, 0xCF, 0xC8, 0xC8, 0x58, 0x5A, 0x2A, 0xFB,
   0xF6, 0x4D, 0x37, 0x1B, 0xAB, 0xA0, 0xB4, 0x4C,
   0x0A, 0x51, 0x4E, 0x02, 0x82, 0x85, 0xCB, 0x12,
   0x0E, 0x1D, 0xAB, 0xC7, 0x2A, 0xC5, 0x82, 0x69,
   0xC4, 0xAF, 0x5F, 0x7F, 0x1E, 0x3F, 0xF8, 0xCD,
   0xCB, 0xF1, 0xF5, 0xEF, 0xDF, 0x7F, 0xCC, 0xCC,
   0x4C, 0x84, 0x6D, 0x98, 0x59, 0xD5, 0xEB, 0xCF,
   0xA5, 0x16, 0xC4, 0xAB, 0x71, 0x72, 0xCB, 0x21,
   0x4C, 0x59, 0x74, 0x03, 0x5E, 0x3F, 0x7F, 0xB3,
   0x6B, 0xD6, 0x22, 0x46, 0xA6, 0x7F, 0x0C, 0x0C,
   0x7F, 0xD7, 0x75, 0x4D, 0xFB, 0xF1, 0xFD, 0x27,
   0x81, 0x78, 0xB8, 0x7D, 0xE9, 0x0A, 0xCB, 0xFF,
   0xDF, 0x4C, 0x8C, 0x8C, 0x40, 0xF6, 0xAD, 0x4B,
   0x67, 0x1F, 0xDE, 0xBD, 0x8B, 0x45, 0x03, 0x3C,
   0x60, 0x8F, 0x9D, 0xD8, 0xB3, 0xEB, 0x74, 0xB5,
   0x90, 0x26, 0x07, 0x03, 0x48, 0xE4, 0x3F, 0x8F,
   0xF6, 0xFF, 0x1B, 0x0F, 0x9A, 0x1E, 0x3E, 0x3A,
   0xFB, 0xF3, 0xDB, 0x8F, 0xB7, 0x0F, 0x9E, 0x43,
   0x83, 0xF1, 0xCF, 0xDF, 0x3F, 0x8A, 0x29, 0xCE,
   0x3F, 0x7F, 0xFD, 0xFC, 0xCF, 0xF0, 0xDF, 0x98,
   0xE9, 0xB5, 0x8F, 0xBD, 0x8A, 0x3C, 0x6F, 0xEC,
   0xB9, 0x2D, 0x47, 0xFE, 0xFC, 0xFF, 0x6F, 0x16,
   0x6C, 0xF3, 0xEC, 0xD3, 0x1C, 0x2E, 0x96, 0xEF,
   0xBF, 0xAB, 0x7E, 0x32, 0x7D, 0xE2, 0x10, 0xCE,
   0x88, 0xF4, 0x69, 0x2B, 0x60, 0xFC, 0xF4, 0xF5,
   0x97, 0x78, 0x8A, 0x36, 0xD8, 0x44, 0x86, 0x18,
   0x0D, 0xD7, 0x29, 0x95, 0x13, 0xD8, 0xD9, 0x58,
   0xE1, 0x0E, 0xF8, 0xF1, 0xF3, 0xDB, 0xC6, 0xD6,
   0xEC, 0x5F, 0x53, 0x8E, 0xBF, 0xFE, 0xC3, 0x70,
   0x93, 0x8D, 0x6D, 0xDA, 0xCB, 0x0B, 0x4C, 0x3F,
   0xFF, 0xFC, 0xFA, 0xCF, 0x0C, 0xB4, 0x09, 0x84,
   0x54, 0xD5, 0x74, 0x91, 0x55, 0x03, 0x01, 0x07,
   0x3B, 0x97, 0x96, 0x6E, 0xC8, 0x17, 0xFE, 0x7F,
   0x4F, 0xF8, 0xFE, 0xBC, 0x95, 0x16, 0x60, 0x62,
   0x62, 0x64, 0xE1, 0xE6, 0x60, 0x73, 0xD1, 0xB2,
   0x7A, 0xFA, 0xE2, 0xF1, 0xDF, 0x3F, 0xFF, 0xC4,
   0x78, 0x44, 0x31, 0xA3, 0x45, 0x2B, 0xD0, 0xE3,
   0xF6, 0xD9, 0xE3, 0x2F, 0x2E, 0x9D, 0x29, 0xA9,
   0xAC, 0x07, 0xA6, 0x03, 0xF4, 0xB4, 0x44, 0x10,
   0x00, 0x00, 0x75, 0x65, 0x12, 0xB0, 0x49, 0xFF,
   0x3F, 0x68, 0x00, 0x00, 0x00, 0x00, 0x49, 0x45,
   0x4E, 0x44, 0xAE, 0x42, 0x60, 0x82
};

gAllowedHosts

std::vector<std::string> gAllowedHosts

static

Definition at line 13463 of file mhttpd.cxx.

gAuthMg

Auth* gAuthMg = NULL

static

Definition at line 13752 of file mhttpd.cxx.

gDoReloadHistory

bool gDoReloadHistory = false

static

Definition at line 8143 of file mhttpd.cxx.

gDoSetupHistoryWatch

bool gDoSetupHistoryWatch = true

static

Definition at line 8142 of file mhttpd.cxx.

gMh

MidasHistoryInterface* gMh = NULL

static

Definition at line 8152 of file mhttpd.cxx.

gMhkey

HNDLE gMhkey = 0

static

Definition at line 8153 of file mhttpd.cxx.

gMimeTypesOdb

MVOdb* gMimeTypesOdb = NULL

static

Definition at line 177 of file mhttpd.cxx.

gMimetypeTable

const MimetypeTableEntry gMimetypeTable[]

Definition at line 128 of file mhttpd.cxx.

                                            {
   { ".ASC",   "text/plain" },
   { ".CSS",   "text/css"   },
   { ".CSV",   "text/csv"   },
   { ".HTM",   "text/html"  },
   { ".HTML",  "text/html"  },
   { ".TXT",   "text/plain" },
 
   { ".BMP",   "image/bmp"     },
   { ".GIF",   "image/gif"     },
   { ".ICO",   "image/x-icon"  },
   { ".JPEG",  "image/jpeg"    },
   { ".JPG",   "image/jpeg"    },
   { ".PNG",   "image/png"     },
   { ".SVG",   "image/svg+xml" },
   { ".TIF",   "image/tiff"    },
   { ".TIFF",  "image/tiff"    },
 
   { ".MID",   "audio/midi"    },
   { ".MP3",   "audio/mpeg"    },
   { ".OGA",   "audio/ogg"     },
   { ".OGG",   "audio/ogg"     },
   { ".WAV",   "audio/wav"     },
 
   { ".BIN",   "application/octet-stream" },
   { ".BZ",    "application/x-bzip"       },
   { ".BZ2",   "application/x-bzip2"      },
   { ".DOC",   "application/msword"       },
   { ".EPS",   "application/postscript"   },
   { ".GZ",    "application/gzip"         },
   { ".JS",    "application/javascript"   },
   { ".JSON",  "application/json"         },
   { ".MJS",   "application/javascript"   },
   { ".PDF",   "application/pdf"          },
   { ".PHP",   "application/x-httpd-php"  },
   { ".RTF",   "application/rtf"          },
   { ".PS",    "application/postscript"   },
   { ".ROOT",  "application/octet-stream" },
   { ".XLS",   "application/x-msexcel"    },
   { ".XML",   "application/xml"          },
   { ".ZIP",   "application/zip"          },
 
   { ".ODP",   "application/vnd.oasis.opendocument.presentation" },
   { ".ODS",   "application/vnd.oasis.opendocument.spreadsheet"  },
   { ".ODT",   "application/vnd.oasis.opendocument.text"         },
 
   { "", "" }
};

gMutex

std::mutex gMutex

static

Definition at line 45 of file mhttpd.cxx.

gOdb

MVOdb* gOdb = NULL

static

Definition at line 46 of file mhttpd.cxx.

gTraceBuf

RequestTraceBuf* gTraceBuf = NULL

static

Definition at line 504 of file mhttpd.cxx.

history_mode

BOOL history_mode = FALSE

static

Definition at line 93 of file mhttpd.cxx.

http_trace

int http_trace = 0

static

Definition at line 433 of file mhttpd.cxx.

mname

const char* mname[]

extern

Definition at line 144 of file midas.cxx.

                      {
        "January",
        "February",
        "March",
        "April",
        "May",
        "June",
        "July",
        "August",
        "September",
        "October",
        "November",
        "December"
};

trace_mg

bool trace_mg = false

static

Definition at line 13705 of file mhttpd.cxx.

trace_mg_recv

bool trace_mg_recv = false

static

Definition at line 13706 of file mhttpd.cxx.

trace_mg_send

bool trace_mg_send = false

static

Definition at line 13707 of file mhttpd.cxx.

verbose

BOOL verbose = FALSE

static

Definition at line 94 of file mhttpd.cxx.

verbose_mg

bool verbose_mg = false

static

Definition at line 13704 of file mhttpd.cxx.