string cConfigItem::getJson() {
JsonExport json;
json.add("name", config_name);
json.add("type", getTypeName());
if(subtype.length()) {
json.add("subtype", subtype);
}
if(description.length()) {
json.add("description", description);
}
if(help.length()) {
json.add("help", help);
}
json.add("set", set);
json.add("value", json_encode(getValueStr()));
json.add("default", json_encode(defaultValueStr));
json.add("group", group_name);
json.add("level", level);
json.add("minor", minor);
list<sMapValue> menuItems = getMenuItems();
if(menuItems.size()) {
ostringstream outStr;
int counter = 0;
for(list<sMapValue>::iterator iter = menuItems.begin(); iter != menuItems.end(); iter++) {
if(counter) {
outStr << ';';
}
outStr << iter->str << ':' << iter->value;
++counter;
}
json.add("menu", json_encode(outStr.str()));
}
return(json.getJson());
}
void Channel::send(const char *type, const char *content, bool encoded){
if(strcmp(type, "data") == 0){
std::string new_content;
if(encoded){
new_content = content;
}else{
new_content = json_encode(content);
}
LinkedList<Subscriber *>::Iterator it = subs.iterator();
while(Subscriber *sub = it.next()){
sub->send_chunk(this->seq_next, type, new_content.c_str());
}
msg_list.push_back(new_content);
seq_next ++;
if(msg_list.size() >= ServerConfig::channel_buffer_size * 1.5){
std::vector<std::string>::iterator it;
it = msg_list.end() - ServerConfig::channel_buffer_size;
msg_list.assign(it, msg_list.end());
log_trace("resize msg_list to %d, seq_next: %d", msg_list.size(), seq_next);
}
}else{
LinkedList<Subscriber *>::Iterator it = subs.iterator();
while(Subscriber *sub = it.next()){
sub->send_chunk(this->seq_next, type, content);
}
}
}
static int log_failure_fmt_msg(pool *p, const unsigned char *fmt,
const char *event_name, char **msg, size_t *msg_len, int flags) {
int res;
char errstr[256], *json = NULL;
void *obj = NULL;
obj = json_mkobject();
res = log_failure_mkmsg(flags, p, fmt, obj, log_failure_mkjson);
if (!json_check(obj, errstr)) {
pr_log_debug(DEBUG3, MOD_LOG_FAILURE_VERSION
": JSON structural problems: %s", errstr);
errno = EINVAL;
json_delete(obj);
return -1;
}
json = json_encode(obj);
pr_trace_msg(trace_channel, 3, "generated JSON payload: %s", json);
*msg_len = strlen(json);
*msg = palloc(p, *payload_len);
memcpy(*payload, json, *payload_len);
/* To avoid a memory leak via malloc(3), we have to explicitly call free(3)
* on the returned JSON string. Which is why we duplicate it out of the
* given memory pool, for use outside of this function.
*/
free(json);
json_delete(obj);
return 0;
}
void encode_and_compare(JsonNode *node, std::string expected)
{
char *encoded;
encoded = json_encode(node);
STRCMP_EQUAL(expected.c_str(), encoded);
free(encoded);
}
/** @internal Serialize to string */
static char *l_pack_json(lua_State *L, int top)
{
JsonNode *root = l_pack_elem(L, top);
if (!root) {
return NULL;
}
char *result = json_encode(root);
json_delete(root);
return result;
}
static int lencode(lua_State *L) {
char *str = json_encode(L);
if(str == NULL) {
LOG_ERROR("null");
return 0;
}
lua_pushstring(L, str);
free(str);
return 1;
}
// Private JSON encoder function to be used as a Lua closure
static int JsonEncodePrivate(lua_State *L) {
JsonNode *json = LuaValueToJson(L);
char *str = json_encode(json);
if (!str) {
free(json);
lua_pushnil(L);
return 1;
}
lua_pushstring(L, str);
json_delete(json);
free(str);
return 1;
}
int
main (int argc, char **argv)
{
FILE *f;
char *infile, *outfile, buf[1000], jsonstr[10000];
struct json *inp_json, *outp_json;
if (argc != 2)
usage ();
infile = argv[1];
if ((f = fopen (infile, "r")) == NULL) {
fprintf (stderr, "error opening file\n");
return (1);
}
memset (&jsonstr, 0, sizeof jsonstr);
while (fgets (buf, sizeof buf, f) != NULL) {
sprintf (jsonstr, "%s%s", jsonstr, buf);
}
inp_json = json_decode (jsonstr);
fclose (f);
outp_json = json_dup (inp_json);
if (strcmp (json_objref_str (inp_json, "first"), "1") == 0) {
init (outp_json);
} else {
alert ();
rerun (outp_json);
}
outfile = json_objref_str (inp_json, "outfile");
if ((f = fopen (outfile, "w")) == NULL) {
fprintf (stderr, "error opening %s for writing: %m\n", outfile);
return (1);
}
char *newjson;
newjson = json_encode (outp_json);
fwrite (newjson, 1, strlen (newjson), f);
fwrite ("\n", 1, 1, f);
fclose (f);
return (0);
}
string RecordArrayField::getJson() {
switch(tf) {
case tf_int:
return(intToString(i));
case tf_time:
return('"' + sqlDateTimeString(i) + '"');
case tf_string:
if(s) {
return('"' + json_encode(s) + '"');
}
case tf_na:
return("null");
}
return("null");
}
void sourcedrop_share(Share_Data *sd)
{
Ecore_Con_Url *request_url = NULL;
char post_data[BUFFER_SIZE_MAX];
const char *json_encoded = NULL;
char *url_encoded = NULL;
EINA_SAFETY_ON_NULL_RETURN(sd);
json_encoded = json_encode(sd->name, sd->content);
request_url = ecore_con_url_new(SOURCEDROP_URL);
url_encoded = url_encode(json_encoded);
snprintf(post_data, (sizeof(post_data) - 1), "data=%s", url_encoded);
free(url_encoded);
ecore_con_url_data_set(request_url, (void*)sd);
ecore_con_url_post(request_url, (void*)post_data, sizeof(post_data), "application/x-www-form-urlencoded");
}
char* combineJObjs(JsonNode** objs, int nObjs)
{
char* szRet;
int idx;
JsonNode* arrayRet = json_mkarray();
for (idx = 0; idx < nObjs; idx++) {
JsonNode* temp = *(objs + idx);
json_append_element(arrayRet, *(objs + idx));
}
szRet = json_encode(arrayRet);
json_delete(arrayRet);
return szRet;
}
static void should_be_(const JsonNode *node, const char *name, const char *expected)
{
char errmsg[256];
char *encoded;
if (!json_check(node, errmsg)) {
fail("Invariants check failed: %s", errmsg);
return;
}
encoded = json_encode(node);
if (strcmp(encoded, expected) == 0)
pass("%s is %s", name, expected);
else
fail("%s should be %s, but is actually %s", name, expected, encoded);
free(encoded);
}
/**
* Retrieve address hint for given name.
*
* Input: name
* Output: { address1, address2, ... }
*/
static char* hint_get(void *env, struct kr_module *module, const char *args)
{
struct kr_zonecut *hints = module->data;
knot_dname_t key[KNOT_DNAME_MAXLEN];
pack_t *pack = NULL;
if (knot_dname_from_str(key, args, sizeof(key))) {
pack = kr_zonecut_find(hints, key);
}
if (!pack || pack->len == 0) {
return NULL;
}
char *result = NULL;
JsonNode *root = pack_addrs(pack);
if (root) {
result = json_encode(root);
json_delete(root);
}
return result;
}
/*
* Encode ["nr", "val"] into a JSON format string in allocated memory.
* "options" can be JSON_JS or zero;
* Returns NULL when out of memory.
*/
char_u *
json_encode_nr_expr(int nr, typval_T *val, int options)
{
typval_T listtv;
typval_T nrtv;
char_u *text;
nrtv.v_type = VAR_NUMBER;
nrtv.vval.v_number = nr;
if (rettv_list_alloc(&listtv) == FAIL)
return NULL;
if (list_append_tv(listtv.vval.v_list, &nrtv) == FAIL
|| list_append_tv(listtv.vval.v_list, val) == FAIL)
{
list_unref(listtv.vval.v_list);
return NULL;
}
text = json_encode(&listtv, options);
list_unref(listtv.vval.v_list);
return text;
}
char *json_store(map_t p) {
struct {
map_t map, first;
bool group;
} tree[D_MAP_MAX_TREE];
map_t fs;
char *buf, *name, *value, *comma;
uint32_t cur, size, quote;
bool group, after, match;
if (!p->child) {
return strdup("{}");
}
buf = NULL;
name = NULL;
value = NULL;
size = 0;
cur = 0;
comma = "";
tree[cur].map = p;
tree[cur].first = p;
tree[cur].group = false;
while(1) {
p = tree[cur].map;
group = tree[cur].group;
if (!p) {
if (!cur)
break;
cur--;
if (!(buf = realloc(buf, size + 2)))
stderror("realloc");
if (group)
size += sprintf(buf + size, "]");
else
size += sprintf(buf + size, "}");
comma = ",";
p = tree[cur].map;
group = tree[cur].group;
if (group) {
for (p = p->next; p; p = p->next) {
if (!strcmp(tree[cur].first->name, p->name))
break;
}
tree[cur].map = p;
} else {
tree[cur].map = p->next;
}
continue;
}
if (!p->name)
name = NULL;
else if (!(name = json_encode(p->name, strlen(p->name))))
goto error;
if (!p->value)
value = NULL;
else if (!(value = json_encode(p->value, strlen(p->value))))
goto error;
quote = !(p->type == D_MAP_TYPE_UNESCAPED);
match = false;
if (!group) {
after = false;
for (fs = tree[cur].first; fs; fs = fs->next) {
if (fs == p)
after = true;
else if (p->name && !strcmp(fs->name, p->name)) {
match = true;
break;
}
}
if (match) {
if (!after) {
tree[cur].map = p->next;
goto next;
}
if (cur + 1 >= D_MAP_MAX_TREE)
goto error;
cur++;
tree[cur].map = p;
tree[cur].first = p;
tree[cur].group = true;
}
}
if (p->child) {
if (!(buf = realloc(buf, size + (name ? strlen(name) : 0) + 7)))
stderror("realloc");
if (!cur || group) {
size += sprintf(buf + size, "%s%s{", comma, (match ? "[" : ""));
} else {
size += sprintf(buf + size, "%s\"%s\":%s{", comma, (name ? name : ""),
(match ? "[" : ""));
}
comma = "";
if (cur + 1 >= D_MAP_MAX_TREE)
goto error;
cur++;
tree[cur].map = p->child;
tree[cur].first = p->child;
tree[cur].group = false;
}
else {
if (name) {
if (!(buf = realloc(buf, size + strlen(name) +
(value ? strlen(value) : 0) + 8)))
stderror("realloc");
if (group) {
size += sprintf(buf + size, "%s%s%s%s", comma,
(quote ? "\"" : ""), (value ? value : ""),
(quote ? "\"" : ""));
} else {
size += sprintf(buf + size, "%s\"%s\":%s%s%s%s", comma,
name, (match ? "[" : ""),
(quote ? "\"" : ""), (value ? value : ""),
(quote ? "\"" : ""));
}
comma = ",";
}
if (group) {
for (p = p->next; p; p = p->next) {
if (!strcmp(tree[cur].first->name, p->name))
break;
}
tree[cur].map = p;
} else {
tree[cur].map = p->next;
}
}
next:
if (name)
free(name);
name = NULL;
if (value)
free(value);
value = NULL;
}
return buf;
error:
if (name)
free(name);
if (value)
free(value);
if (buf)
free(buf);
return NULL;
}
void display_notifications(void) {
char *temp_buffer;
char *error_text = NULL;
char date_time[MAX_DATETIME_LENGTH];
char alert_level[MAX_INPUT_BUFFER];
char alert_level_class[MAX_INPUT_BUFFER];
char contact_name[MAX_INPUT_BUFFER];
char service_name[MAX_INPUT_BUFFER];
char host_name[MAX_INPUT_BUFFER];
char method_name[MAX_INPUT_BUFFER];
char displayed_host_name[MAX_INPUT_BUFFER];
char displayed_service_desc[MAX_INPUT_BUFFER];
int show_entry;
int total_notifications = 0;
int displayed_entries = 0;
int notification_detail_type = NOTIFICATION_SERVICE_CRITICAL;
int status = READLOG_OK;
int odd = 0;
int json_start = TRUE;
host *temp_host = NULL;
service *temp_service = NULL;
hostgroup *temp_hostgroup = NULL;
servicegroup *temp_servicegroup = NULL;
logentry *temp_entry = NULL;
logentry *entry_list = NULL;
logfilter *filter_list = NULL;
if (query_type == DISPLAY_HOSTGROUPS) {
temp_hostgroup = find_hostgroup(query_hostgroup_name);
if (temp_hostgroup == NULL) {
print_generic_error_message("There are no host groups with this name defined.", NULL, 0);
return;
}
/* make sure the user is authorized to view this hostgroup */
if (show_partial_hostgroups == FALSE && is_authorized_for_hostgroup(temp_hostgroup, ¤t_authdata) == FALSE) {
print_generic_error_message("It appears as though you do not have permission to view information for the host group you requested...", "If you believe this is an error, check the HTTP server authentication requirements for accessing this CGI and check the authorization options in your CGI configuration file.", 0);
return;
}
}
if (query_type == DISPLAY_SERVICEGROUPS) {
temp_servicegroup = find_servicegroup(query_servicegroup_name);
if (temp_servicegroup == NULL) {
print_generic_error_message("There are no service groups with this name defined.", NULL, 0);
return;
}
/* make sure the user is authorized to view this servicegroup */
if (show_partial_servicegroups == FALSE && is_authorized_for_servicegroup(temp_servicegroup, ¤t_authdata) == FALSE) {
print_generic_error_message("It appears as though you do not have permission to view information for the service group you requested...", "If you believe this is an error, check the HTTP server authentication requirements for accessing this CGI and check the authorization options in your CGI configuration file.", 0);
return;
}
}
add_log_filter(&filter_list, LOGENTRY_HOST_NOTIFICATION, LOGFILTER_INCLUDE);
add_log_filter(&filter_list, LOGENTRY_SERVICE_NOTIFICATION, LOGFILTER_INCLUDE);
/* scan the log file for notification data */
status = get_log_entries(&entry_list, &filter_list, &error_text, NULL, reverse, ts_start, ts_end);
free_log_filters(&filter_list);
/* dealing with errors */
if (status == READLOG_ERROR_WARNING) {
if (error_text != NULL) {
print_generic_error_message(error_text, NULL, 0);
my_free(error_text);
} else
print_generic_error_message("Unkown error!", NULL, 0);
}
if (status == READLOG_ERROR_MEMORY)
print_generic_error_message("Out of memory...", "showing all I could get!", 0);
if (status == READLOG_ERROR_FATAL) {
if (error_text != NULL) {
print_generic_error_message(error_text, NULL, 0);
my_free(error_text);
}
return;
/* now we start displaying the notification entries */
} else {
if (content_type == JSON_CONTENT) {
if (status != READLOG_OK)
printf(",\n");
printf("\"notifications\": [\n");
} else if (content_type == CSV_CONTENT) {
printf("%sHOST%s%s", csv_data_enclosure, csv_data_enclosure, csv_delimiter);
printf("%sSERVICE%s%s", csv_data_enclosure, csv_data_enclosure, csv_delimiter);
printf("%sTYPE%s%s", csv_data_enclosure, csv_data_enclosure, csv_delimiter);
printf("%sTIME%s%s", csv_data_enclosure, csv_data_enclosure, csv_delimiter);
printf("%sCONTACT%s%s", csv_data_enclosure, csv_data_enclosure, csv_delimiter);
printf("%sNOTIFICATION_COMMAND%s%s", csv_data_enclosure, csv_data_enclosure, csv_delimiter);
printf("%sINFORMATION%s\n", csv_data_enclosure, csv_data_enclosure);
} else {
printf("<table border='0' class='notifications' align='center'>\n");
/* add export to csv, json, link */
printf("<tr><td colspan='7'>");
printf("<table width='100%%' cellspacing='0' cellpadding='0'><tr><td width='33%%'></td><td width='33%%' nowrap>");
printf("<div class='page_selector'>\n");
printf("<div id='page_navigation_copy'></div>");
page_limit_selector(result_start);
printf("</div>\n");
printf("</td><td width='33%%' align='right' style='padding-right:2px'>\n");
printf("<div class='csv_export_link'>");
print_export_link(CSV_CONTENT, NOTIFICATIONS_CGI, NULL);
print_export_link(JSON_CONTENT, NOTIFICATIONS_CGI, NULL);
print_export_link(HTML_CONTENT, NOTIFICATIONS_CGI, NULL);
printf("</div></td></tr></table>");
printf("<tr>\n");
printf("<th class='notifications'>Host</th>\n");
printf("<th class='notifications'>Service</th>\n");
printf("<th class='notifications'>Type</th>\n");
printf("<th class='notifications'>Time</th>\n");
printf("<th class='notifications'>Contact</th>\n");
printf("<th class='notifications'>Notification Command</th>\n");
printf("<th class='notifications'>Information</th>\n");
printf("</tr>\n");
}
/* check all entries */
for (temp_entry = entry_list; temp_entry != NULL; temp_entry = temp_entry->next) {
/* get the date/time */
get_time_string(&temp_entry->timestamp, date_time, (int)sizeof(date_time), SHORT_DATE_TIME);
strip(date_time);
/* get the contact name */
temp_buffer = (char *)strtok(temp_entry->entry_text, ":");
temp_buffer = (char *)strtok(NULL, ";");
snprintf(contact_name, sizeof(contact_name), "%s", (temp_buffer == NULL) ? "" : temp_buffer + 1);
contact_name[sizeof(contact_name) - 1] = '\x0';
/* get the host name */
temp_buffer = (char *)strtok(NULL, ";");
snprintf(host_name, sizeof(host_name), "%s", (temp_buffer == NULL) ? "" : temp_buffer);
host_name[sizeof(host_name) - 1] = '\x0';
/* get the service name */
service_name[0] = '\x0';
if (temp_entry->type == LOGENTRY_SERVICE_NOTIFICATION) {
temp_buffer = (char *)strtok(NULL, ";");
snprintf(service_name, sizeof(service_name), "%s", (temp_buffer == NULL) ? "" : temp_buffer);
service_name[sizeof(service_name) - 1] = '\x0';
}
/* get the alert level */
temp_buffer = (char *)strtok(NULL, ";");
snprintf(alert_level, sizeof(alert_level), "%s", (temp_buffer == NULL) ? "" : temp_buffer);
alert_level[sizeof(alert_level) - 1] = '\x0';
if (temp_entry->type == LOGENTRY_SERVICE_NOTIFICATION) {
if (!strcmp(alert_level, "CRITICAL")) {
notification_detail_type = NOTIFICATION_SERVICE_CRITICAL;
strcpy(alert_level_class, "CRITICAL");
} else if (!strcmp(alert_level, "WARNING")) {
notification_detail_type = NOTIFICATION_SERVICE_WARNING;
strcpy(alert_level_class, "WARNING");
} else if (!strcmp(alert_level, "RECOVERY") || !strcmp(alert_level, "OK")) {
strcpy(alert_level, "OK");
notification_detail_type = NOTIFICATION_SERVICE_RECOVERY;
strcpy(alert_level_class, "OK");
} else if (strstr(alert_level, "CUSTOM (")) {
notification_detail_type = NOTIFICATION_SERVICE_CUSTOM;
strcpy(alert_level_class, "CUSTOM");
} else if (strstr(alert_level, "ACKNOWLEDGEMENT (")) {
notification_detail_type = NOTIFICATION_SERVICE_ACK;
strcpy(alert_level_class, "ACKNOWLEDGEMENT");
} else if (strstr(alert_level, "FLAPPINGSTART (")) {
strcpy(alert_level, "FLAPPING START");
notification_detail_type = NOTIFICATION_SERVICE_FLAP;
strcpy(alert_level_class, "UNKNOWN");
} else if (strstr(alert_level, "FLAPPINGSTOP (")) {
strcpy(alert_level, "FLAPPING STOP");
notification_detail_type = NOTIFICATION_SERVICE_FLAP;
strcpy(alert_level_class, "UNKNOWN");
} else {
strcpy(alert_level, "UNKNOWN");
notification_detail_type = NOTIFICATION_SERVICE_UNKNOWN;
strcpy(alert_level_class, "UNKNOWN");
}
} else {
if (!strcmp(alert_level, "DOWN")) {
strncpy(alert_level, "HOST DOWN", sizeof(alert_level));
strcpy(alert_level_class, "HOSTDOWN");
notification_detail_type = NOTIFICATION_HOST_DOWN;
} else if (!strcmp(alert_level, "UNREACHABLE")) {
strncpy(alert_level, "HOST UNREACHABLE", sizeof(alert_level));
strcpy(alert_level_class, "HOSTUNREACHABLE");
notification_detail_type = NOTIFICATION_HOST_UNREACHABLE;
} else if (!strcmp(alert_level, "RECOVERY") || !strcmp(alert_level, "UP")) {
strncpy(alert_level, "HOST UP", sizeof(alert_level));
strcpy(alert_level_class, "HOSTUP");
notification_detail_type = NOTIFICATION_HOST_RECOVERY;
} else if (strstr(alert_level, "CUSTOM (")) {
strcpy(alert_level_class, "HOSTCUSTOM");
notification_detail_type = NOTIFICATION_HOST_CUSTOM;
} else if (strstr(alert_level, "ACKNOWLEDGEMENT (")) {
strcpy(alert_level_class, "HOSTACKNOWLEDGEMENT");
notification_detail_type = NOTIFICATION_HOST_ACK;
} else if (strstr(alert_level, "FLAPPINGSTART (")) {
strcpy(alert_level, "FLAPPING START");
strcpy(alert_level_class, "UNKNOWN");
notification_detail_type = NOTIFICATION_HOST_FLAP;
} else if (strstr(alert_level, "FLAPPINGSTOP (")) {
strcpy(alert_level, "FLAPPING STOP");
strcpy(alert_level_class, "UNKNOWN");
notification_detail_type = NOTIFICATION_HOST_FLAP;
}
}
/* get the method name */
temp_buffer = (char *)strtok(NULL, ";");
snprintf(method_name, sizeof(method_name), "%s", (temp_buffer == NULL) ? "" : temp_buffer);
method_name[sizeof(method_name) - 1] = '\x0';
/* move to the informational message */
temp_buffer = strtok(NULL, ";");
show_entry = FALSE;
/* if we're searching by contact, filter out unwanted contact */
if (query_type == DISPLAY_CONTACTS) {
if (find_all == TRUE)
show_entry = TRUE;
else if (!strcmp(query_contact_name, contact_name))
show_entry = TRUE;
}
/* search host */
else if (query_type == DISPLAY_HOSTS) {
if (find_all == TRUE)
show_entry = TRUE;
else if (!strcmp(query_host_name, host_name))
show_entry = TRUE;
}
/* searching service */
else if (query_type == DISPLAY_SERVICES) {
if (!strcmp(query_host_name, host_name) && !strcmp(query_svc_description, service_name))
show_entry = TRUE;
}
/* Set TRUE here, get's checked later on */
else if (query_type == DISPLAY_HOSTGROUPS || query_type == DISPLAY_SERVICEGROUPS) {
show_entry = TRUE;
}
if (show_entry == TRUE) {
if (notification_options == NOTIFICATION_ALL)
show_entry = TRUE;
else if (notification_options == NOTIFICATION_HOST_ALL && temp_entry->type == LOGENTRY_HOST_NOTIFICATION)
show_entry = TRUE;
else if (notification_options == NOTIFICATION_SERVICE_ALL && temp_entry->type == LOGENTRY_SERVICE_NOTIFICATION)
show_entry = TRUE;
else if (notification_detail_type & notification_options)
show_entry = TRUE;
else
show_entry = FALSE;
}
/* make sure user has authorization to view this notification */
temp_host = find_host(host_name);
if (temp_entry->type == LOGENTRY_SERVICE_NOTIFICATION)
temp_service = find_service(host_name, service_name);
if (temp_host != NULL) {
snprintf(displayed_host_name, sizeof(displayed_host_name), "%s", (temp_host->display_name != NULL && content_type == HTML_CONTENT) ? temp_host->display_name : temp_host->name);
displayed_host_name[sizeof(displayed_host_name) - 1] = '\x0';
if (temp_entry->type == LOGENTRY_HOST_NOTIFICATION) {
if (is_authorized_for_host(temp_host, ¤t_authdata) == FALSE)
show_entry = FALSE;
else if (query_type == DISPLAY_HOSTGROUPS && is_host_member_of_hostgroup(temp_hostgroup, temp_host) == FALSE)
show_entry = FALSE;
else if (query_type == DISPLAY_SERVICEGROUPS && is_host_member_of_servicegroup(temp_servicegroup, temp_host) == FALSE)
show_entry = FALSE;
} else {
if (temp_service != NULL) {
snprintf(displayed_service_desc, sizeof(displayed_service_desc), "%s", (temp_service->display_name != NULL && content_type == HTML_CONTENT) ? temp_service->display_name : temp_service->description);
displayed_service_desc[sizeof(displayed_service_desc) - 1] = '\x0';
if (is_authorized_for_service(temp_service, ¤t_authdata) == FALSE)
show_entry = FALSE;
else if (query_type == DISPLAY_HOSTGROUPS && is_host_member_of_hostgroup(temp_hostgroup, temp_host) == FALSE)
show_entry = FALSE;
else if (query_type == DISPLAY_SERVICEGROUPS && is_service_member_of_servicegroup(temp_servicegroup, temp_service) == FALSE)
show_entry = FALSE;
} else {
if (is_authorized_for_all_services(¤t_authdata) == FALSE)
show_entry = FALSE;
snprintf(displayed_service_desc, sizeof(displayed_service_desc), "%s", service_name);
displayed_service_desc[sizeof(displayed_service_desc) - 1] = '\x0';
}
}
} else {
if (temp_entry->type == LOGENTRY_HOST_NOTIFICATION) {
if (is_authorized_for_all_hosts(¤t_authdata) == FALSE)
show_entry = FALSE;
} else {
if (is_authorized_for_all_services(¤t_authdata) == FALSE)
show_entry = FALSE;
snprintf(displayed_service_desc, sizeof(displayed_service_desc), "%s", service_name);
displayed_service_desc[sizeof(displayed_service_desc) - 1] = '\x0';
}
snprintf(displayed_host_name, sizeof(displayed_host_name), "%s", host_name);
displayed_host_name[sizeof(displayed_host_name) - 1] = '\x0';
}
if (show_entry == TRUE) {
if (result_limit != 0 && (((total_notifications + 1) < result_start) || (total_notifications >= ((result_start + result_limit) - 1)))) {
total_notifications++;
continue;
}
displayed_entries++;
total_notifications++;
if (odd)
odd = 0;
else
odd = 1;
if (content_type == JSON_CONTENT) {
if (json_start == FALSE)
printf(",\n");
printf("{\"host_name\": \"%s\", ", json_encode(temp_host->name));
printf("\"host_display_name\": \"%s\", ", (temp_host->display_name != NULL) ? json_encode(temp_host->display_name) : json_encode(temp_host->name));
if (temp_entry->type == LOGENTRY_SERVICE_NOTIFICATION) {
printf("\"service_description\": \"%s\", ", json_encode(temp_service->description));
printf("\"service_display_name\": \"%s\", ", (temp_service->display_name != NULL) ? json_encode(temp_service->display_name) : json_encode(temp_service->description));
} else {
printf("\"service_description\": null, ");
printf("\"service_display_name\": null, ");
}
printf("\"type\": \"%s\", ", alert_level);
printf("\"time\": \"%s\", ", date_time);
printf("\"contact\": \"%s\", ", json_encode(contact_name));
printf("\"notification_command\": \"%s\", ", json_encode(method_name));
printf("\"information\": \"%s\"}", json_encode(escape_newlines(temp_buffer)));
} else if (content_type == CSV_CONTENT) {
printf("%s%s%s%s", csv_data_enclosure, displayed_host_name, csv_data_enclosure, csv_delimiter);
if (temp_entry->type == LOGENTRY_SERVICE_NOTIFICATION)
printf("%s%s%s%s", csv_data_enclosure, displayed_service_desc, csv_data_enclosure, csv_delimiter);
else
printf("%sN/A%s%s", csv_data_enclosure, csv_data_enclosure, csv_delimiter);
printf("%s%s%s%s", csv_data_enclosure, alert_level, csv_data_enclosure, csv_delimiter);
printf("%s%s%s%s", csv_data_enclosure, date_time, csv_data_enclosure, csv_delimiter);
printf("%s%s%s%s", csv_data_enclosure, contact_name, csv_data_enclosure, csv_delimiter);
printf("%s%s%s%s", csv_data_enclosure, method_name, csv_data_enclosure, csv_delimiter);
printf("%s%s%s\n", csv_data_enclosure, escape_newlines(temp_buffer), csv_data_enclosure);
} else {
printf("<tr class='notifications%s'>\n", (odd) ? "Even" : "Odd");
if (temp_host != NULL)
printf("<td class='notifications%s'><a href='%s?type=%d&host=%s'>%s</a></td>\n", (odd) ? "Even" : "Odd", EXTINFO_CGI, DISPLAY_HOST_INFO, url_encode(host_name), displayed_host_name);
else
printf("<td class='notifications%s'>%s</td>\n", (odd) ? "Even" : "Odd", displayed_host_name);
if (temp_entry->type == LOGENTRY_SERVICE_NOTIFICATION) {
if (temp_service != NULL) {
printf("<td class='notifications%s'><a href='%s?type=%d&host=%s", (odd) ? "Even" : "Odd", EXTINFO_CGI, DISPLAY_SERVICE_INFO, url_encode(host_name));
printf("&service=%s'>%s</a></td>\n", url_encode(service_name), displayed_service_desc);
} else
printf("<td class='notifications%s'>%s</td>\n", (odd) ? "Even" : "Odd", displayed_service_desc);
} else
printf("<td class='notifications%s'>N/A</td>\n", (odd) ? "Even" : "Odd");
printf("<td class='notifications%s'>%s</td>\n", alert_level_class, alert_level);
printf("<td class='notifications%s'>%s</td>\n", (odd) ? "Even" : "Odd", date_time);
printf("<td class='notifications%s'><a href='%s?type=contacts#%s'>%s</a></td>\n", (odd) ? "Even" : "Odd", CONFIG_CGI, url_encode(contact_name), contact_name);
printf("<td class='notifications%s'><a href='%s?type=commands#%s'>%s</a></td>\n", (odd) ? "Even" : "Odd", CONFIG_CGI, url_encode(method_name), method_name);
printf("<td class='notifications%s'>%s</td>\n", (odd) ? "Even" : "Odd", html_encode(temp_buffer, FALSE));
printf("</tr>\n");
}
if (json_start == TRUE)
json_start = FALSE;
}
}
}
free_log_entries(&entry_list);
if (content_type != CSV_CONTENT && content_type != JSON_CONTENT) {
printf("</table>\n");
if (total_notifications == 0) {
printf("<div class='errorMessage' style='text-align:center;'>No notifications have been recorded");
if (find_all == FALSE) {
if (query_type == DISPLAY_SERVICES)
printf(" for this service");
else if (query_type == DISPLAY_CONTACTS)
printf(" for this contact");
else
printf(" for this host");
}
printf(" in log files for selected date.</div>");
}
page_num_selector(result_start, total_notifications, displayed_entries);
} else if (content_type == JSON_CONTENT) {
printf("\n]\n");
}
return;
}
static json_t *
lisp_to_json_toplevel_1 (Lisp_Object lisp)
{
json_t *json;
ptrdiff_t count;
if (VECTORP (lisp))
{
ptrdiff_t size = ASIZE (lisp);
json = json_check (json_array ());
count = SPECPDL_INDEX ();
record_unwind_protect_ptr (json_release_object, json);
for (ptrdiff_t i = 0; i < size; ++i)
{
int status
= json_array_append_new (json, lisp_to_json (AREF (lisp, i)));
if (status == -1)
json_out_of_memory ();
}
eassert (json_array_size (json) == size);
}
else if (HASH_TABLE_P (lisp))
{
struct Lisp_Hash_Table *h = XHASH_TABLE (lisp);
json = json_check (json_object ());
count = SPECPDL_INDEX ();
record_unwind_protect_ptr (json_release_object, json);
for (ptrdiff_t i = 0; i < HASH_TABLE_SIZE (h); ++i)
if (!NILP (HASH_HASH (h, i)))
{
Lisp_Object key = json_encode (HASH_KEY (h, i));
/* We can't specify the length, so the string must be
null-terminated. */
check_string_without_embedded_nulls (key);
const char *key_str = SSDATA (key);
/* Reject duplicate keys. These are possible if the hash
table test is not `equal'. */
if (json_object_get (json, key_str) != NULL)
wrong_type_argument (Qjson_value_p, lisp);
int status = json_object_set_new (json, key_str,
lisp_to_json (HASH_VALUE (h, i)));
if (status == -1)
{
/* A failure can be caused either by an invalid key or
by low memory. */
json_check_utf8 (key);
json_out_of_memory ();
}
}
}
else if (NILP (lisp))
return json_check (json_object ());
else if (CONSP (lisp))
{
Lisp_Object tail = lisp;
json = json_check (json_object ());
count = SPECPDL_INDEX ();
record_unwind_protect_ptr (json_release_object, json);
bool is_plist = !CONSP (XCAR (tail));
FOR_EACH_TAIL (tail)
{
const char *key_str;
Lisp_Object value;
Lisp_Object key_symbol;
if (is_plist)
{
key_symbol = XCAR (tail);
tail = XCDR (tail);
CHECK_CONS (tail);
value = XCAR (tail);
if (EQ (tail, li.tortoise)) circular_list (lisp);
}
else
{
Lisp_Object pair = XCAR (tail);
CHECK_CONS (pair);
key_symbol = XCAR (pair);
value = XCDR (pair);
}
CHECK_SYMBOL (key_symbol);
Lisp_Object key = SYMBOL_NAME (key_symbol);
/* We can't specify the length, so the string must be
null-terminated. */
check_string_without_embedded_nulls (key);
key_str = SSDATA (key);
/* In plists, ensure leading ":" in keys is stripped. It
will be reconstructed later in `json_to_lisp'.*/
if (is_plist && ':' == key_str[0] && key_str[1])
{
key_str = &key_str[1];
}
/* Only add element if key is not already present. */
if (json_object_get (json, key_str) == NULL)
{
int status
= json_object_set_new (json, key_str, lisp_to_json (value));
if (status == -1)
json_out_of_memory ();
}
}
CHECK_LIST_END (tail, lisp);
}
else
/* shows all hosts that are causing network outages */
void display_network_outages(void) {
int number_of_problem_hosts = 0;
int number_of_blocking_problem_hosts = 0;
hostoutagesort *temp_hostoutagesort;
hostoutage *temp_hostoutage;
hoststatus *temp_hoststatus;
affected_host * temp_affected_host;
int odd = 0;
char *bg_class = "";
char *status = "";
int days;
int hours;
int minutes;
int seconds;
int total_comments;
time_t t;
time_t current_time;
char state_duration[48];
int total_entries = 0;
int json_start = TRUE;
/* find all hosts that are causing network outages */
find_hosts_causing_outages();
/* calculate outage effects */
calculate_outage_effects();
/* sort the outage list by severity */
sort_hostoutages();
/* count the number of top-level hosts that are down and the ones that are actually blocking children hosts */
for (temp_hostoutage = hostoutage_list; temp_hostoutage != NULL; temp_hostoutage = temp_hostoutage->next) {
number_of_problem_hosts++;
if (temp_hostoutage->affected_child_hosts > 1)
number_of_blocking_problem_hosts++;
}
if (content_type == JSON_CONTENT) {
printf("\"中断\": [\n");
} else if (content_type == CSV_CONTENT) {
printf("%s严重性%s%s",csv_data_enclosure,csv_data_enclosure,csv_delimiter);
printf("%s主机%s%s",csv_data_enclosure,csv_data_enclosure,csv_delimiter);
printf("%s状态%s%s",csv_data_enclosure,csv_data_enclosure,csv_delimiter);
printf("%s备注%s%s",csv_data_enclosure,csv_data_enclosure,csv_delimiter);
printf("%s状态持续时间%s%s",csv_data_enclosure,csv_data_enclosure,csv_delimiter);
printf("%s受影响的主机%s%s",csv_data_enclosure,csv_data_enclosure,csv_delimiter);
printf("%s受影响的服务%s\n",csv_data_enclosure,csv_data_enclosure);
} else {
/* display the problem hosts... */
printf("<TABLE BORDER=0 CELLSPACING=0 CELLPADDING=0 align='center'><TR><TD WIDTH='33%%'></TD><TD WIDTH='33%%'><DIV CLASS='dataTitle'>阻塞中断</DIV><TD WIDTH='33%%'>");
/* add export to csv link */
printf("<DIV style='padding-right:6px;' class='csv_export_link'>");
print_export_link(CSV_CONTENT, OUTAGES_CGI, NULL);
print_export_link(JSON_CONTENT, OUTAGES_CGI, NULL);
print_export_link(HTML_CONTENT, OUTAGES_CGI, NULL);
printf("</DIV></TD></TR></TABLE>\n");
printf("<TABLE BORDER=0 CLASS='data'>\n");
printf("<TR>\n");
printf("<TH CLASS='data'>严重性</TH><TH CLASS='data'>主机</TH><TH CLASS='data'>状态</TH><TH CLASS='data'>备注</TH><TH CLASS='data'>状态持续时间</TH><TH CLASS='data'># 受影响的主机</TH><TH CLASS='data'># 受影响的服务</TH><TH CLASS='data'>动作</TH>\n");
printf("</TR>\n");
}
for (temp_hostoutagesort = hostoutagesort_list; temp_hostoutagesort != NULL; temp_hostoutagesort = temp_hostoutagesort->next) {
temp_hostoutage = temp_hostoutagesort->outage;
if (temp_hostoutage == NULL)
continue;
/* skip hosts that are not blocking anyone */
if (temp_hostoutage->affected_child_hosts <= 1)
continue;
temp_hoststatus = find_hoststatus(temp_hostoutage->hst->name);
if (temp_hoststatus == NULL)
continue;
/* make sure we only caught valid state types */
if (temp_hoststatus->status != HOST_DOWN && temp_hoststatus->status != HOST_UNREACHABLE)
continue;
total_entries++;
if (odd == 0) {
odd = 1;
bg_class = "dataOdd";
} else {
odd = 0;
bg_class = "dataEven";
}
if (temp_hoststatus->status == HOST_UNREACHABLE)
status = "不可达";
else if (temp_hoststatus->status == HOST_DOWN)
status = "宕机";
if (content_type == JSON_CONTENT) {
// always add a comma, except for the first line
if (json_start == FALSE)
printf(",\n");
json_start = FALSE;
printf("{ \"严重性\": %d, ", temp_hostoutage->severity);
printf(" \"主机名称\": \"%s\", ", json_encode(temp_hostoutage->hst->name));
printf(" \"主机显示名称\": \"%s\", ", (temp_hostoutage->hst->display_name != NULL) ? json_encode(temp_hostoutage->hst->display_name) : json_encode(temp_hostoutage->hst->name));
printf(" \"状态\": \"%s\", ", status);
} else if (content_type == CSV_CONTENT) {
printf("%s%d%s%s", csv_data_enclosure, temp_hostoutage->severity, csv_data_enclosure, csv_delimiter);
printf("%s%s%s%s", csv_data_enclosure, temp_hostoutage->hst->name, csv_data_enclosure, csv_delimiter);
printf("%s%s%s%s", csv_data_enclosure, status, csv_data_enclosure, csv_delimiter);
} else {
printf("<TR CLASS='%s'>\n", bg_class);
printf("<TD CLASS='%s'>%d</TD>\n", bg_class, temp_hostoutage->severity);
printf("<TD CLASS='%s'><A HREF='%s?type=%d&host=%s'>%s</A></TD>\n", bg_class, EXTINFO_CGI, DISPLAY_HOST_INFO, url_encode(temp_hostoutage->hst->name), (temp_hostoutage->hst->display_name != NULL) ? temp_hostoutage->hst->display_name : temp_hostoutage->hst->name);
printf("<TD CLASS='host%s'>%s</TD>\n", status, status);
}
total_comments = number_of_host_comments(temp_hostoutage->hst->name);
if (content_type == JSON_CONTENT) {
printf(" \"备注\": %d, ", total_comments);
} else if (content_type == CSV_CONTENT) {
printf("%s%d%s%s", csv_data_enclosure, total_comments, csv_data_enclosure, csv_delimiter);
} else {
if (total_comments > 0)
print_comment_icon(temp_hostoutage->hst->name, NULL);
else
printf("<TD CLASS='%s'>无</TD>\n", bg_class);
}
current_time = time(NULL);
if (temp_hoststatus->last_state_change == (time_t)0)
t = current_time - program_start;
else
t = current_time - temp_hoststatus->last_state_change;
get_time_breakdown((unsigned long)t, &days, &hours, &minutes, &seconds);
snprintf(state_duration, sizeof(state_duration) - 1, "%2d日 %2d时 %2d分 %2d秒%s", days, hours, minutes, seconds, (temp_hoststatus->last_state_change == (time_t)0) ? "+" : "");
state_duration[sizeof(state_duration)-1] = '\x0';
if (content_type == JSON_CONTENT) {
printf(" \"状态持续时间\": \"%s\", ", state_duration);
printf(" \"受影响的主机\": %d, ", temp_hostoutage->affected_child_hosts);
printf(" \"受影响的服务\": %d }\n", temp_hostoutage->affected_child_services);
} else if (content_type == CSV_CONTENT) {
printf("%s%s%s%s", csv_data_enclosure, state_duration, csv_data_enclosure, csv_delimiter);
printf("%s%d%s%s", csv_data_enclosure, temp_hostoutage->affected_child_hosts, csv_data_enclosure, csv_delimiter);
printf("%s%d%s\n", csv_data_enclosure, temp_hostoutage->affected_child_services, csv_data_enclosure);
} else {
printf("<TD CLASS='%s'>%s</TD>\n", bg_class, state_duration);
printf("<TD CLASS='%s'>%d</TD>\n", bg_class, temp_hostoutage->affected_child_hosts);
printf("<TD CLASS='%s'>%d</TD>\n", bg_class, temp_hostoutage->affected_child_services);
printf("<TD CLASS='%s'>", bg_class);
printf("<A HREF='%s?host=%s'><IMG SRC='%s%s' BORDER=0 ALT='查看该主机的状态详情' TITLE='查看该主机的状态详情'></A>\n", STATUS_CGI, url_encode(temp_hostoutage->hst->name), url_images_path, STATUS_DETAIL_ICON);
#ifdef USE_STATUSMAP
printf("<A HREF='%s?host=%s'><IMG SRC='%s%s' BORDER=0 ALT='查看该主机以及子主机的状态图' TITLE='查看该主机以及子主机的状态图'></A>\n", STATUSMAP_CGI, url_encode(temp_hostoutage->hst->name), url_images_path, STATUSMAP_ICON);
#endif
#ifdef USE_TRENDS
printf("<A HREF='%s?host=%s'><IMG SRC='%s%s' BORDER=0 ALT='查看该主机趋势' TITLE='查看该主机趋势'></A>\n", TRENDS_CGI, url_encode(temp_hostoutage->hst->name), url_images_path, TRENDS_ICON);
#endif
printf("<A HREF='%s?host=%s'><IMG SRC='%s%s' BORDER=0 ALT='查看该主机的警告历史' TITLE='查看该主机的警告历史'></A>\n", HISTORY_CGI, url_encode(temp_hostoutage->hst->name), url_images_path, HISTORY_ICON);
printf("<A HREF='%s?host=%s'><IMG SRC='%s%s' BORDER=0 ALT='查看该主机的通知' TITLE='查看该主机的通知'></A>\n", NOTIFICATIONS_CGI, url_encode(temp_hostoutage->hst->name), url_images_path, NOTIFICATION_ICON);
/* add Link to acknowledge all affected hosts */
printf("<a href='%s?cmd_typ=%d&host=%s", CMD_CGI, CMD_ACKNOWLEDGE_HOST_PROBLEM, url_encode(temp_hostoutage->hst->name));
for (temp_affected_host = temp_hostoutage->affected_hosts; temp_affected_host != NULL; temp_affected_host = temp_affected_host->next)
printf("&host=%s", url_encode(temp_affected_host->host_name));
printf("'><img src='%s%s' border=0 ALT='确认所有受影响的的主机' TITLE='确认所有受影响的的主机'></a>\n", url_images_path, ACKNOWLEDGEMENT_ICON);
printf("</TD>\n");
printf("</TR>\n");
}
}
if (content_type != CSV_CONTENT && content_type != JSON_CONTENT) {
printf("</TABLE>\n");
if (total_entries == 0)
printf("<DIV CLASS='itemTotalsTitle'>显示%d阻塞中断</DIV>\n", total_entries);
} else if (content_type == JSON_CONTENT) {
printf("\n]\n");
}
/* free memory allocated to the host outage list */
free_hostoutage_list();
free_hostoutagesort_list();
return;
}
/* shows all hosts that are causing network outages */
void display_network_outages(void) {
int number_of_problem_hosts = 0;
int number_of_blocking_problem_hosts = 0;
hostoutagesort *temp_hostoutagesort;
hostoutage *temp_hostoutage;
hoststatus *temp_hoststatus;
affected_host * temp_affected_host;
int odd = 0;
char *bg_class = "";
char *status = "";
int days;
int hours;
int minutes;
int seconds;
int total_comments;
time_t t;
time_t current_time;
char state_duration[48];
int total_entries = 0;
int json_start = TRUE;
/* find all hosts that are causing network outages */
find_hosts_causing_outages();
/* calculate outage effects */
calculate_outage_effects();
/* sort the outage list by severity */
sort_hostoutages();
/* count the number of top-level hosts that are down and the ones that are actually blocking children hosts */
for (temp_hostoutage = hostoutage_list; temp_hostoutage != NULL; temp_hostoutage = temp_hostoutage->next) {
number_of_problem_hosts++;
if (temp_hostoutage->affected_child_hosts > 1)
number_of_blocking_problem_hosts++;
}
if (content_type == JSON_CONTENT) {
printf("\"outages\": [\n");
} else if (content_type == CSV_CONTENT) {
printf("%sSEVERITY%s%s", csv_data_enclosure, csv_data_enclosure, csv_delimiter);
printf("%sHOST%s%s", csv_data_enclosure, csv_data_enclosure, csv_delimiter);
printf("%sSTATE%s%s", csv_data_enclosure, csv_data_enclosure, csv_delimiter);
printf("%sNOTES%s%s", csv_data_enclosure, csv_data_enclosure, csv_delimiter);
printf("%sSTATE_DURATION%s%s", csv_data_enclosure, csv_data_enclosure, csv_delimiter);
printf("%sHOSTS_AFFECTED%s%s", csv_data_enclosure, csv_data_enclosure, csv_delimiter);
printf("%sSERVICES_AFFECTED%s\n", csv_data_enclosure, csv_data_enclosure);
} else {
/* display the problem hosts... */
printf("<table border='0' cellspacing='0' cellpadding='0' align='center'><tr><td width='33%%'></td><td width='33%%'><div class='dataTitle'>Blocking Outages</div><td width='33%%'>");
/* add export to csv link */
printf("<div style='padding-right:6px;' class='csv_export_link'>");
print_export_link(CSV_CONTENT, OUTAGES_CGI, NULL);
print_export_link(JSON_CONTENT, OUTAGES_CGI, NULL);
print_export_link(HTML_CONTENT, OUTAGES_CGI, NULL);
printf("</div></td></tr></table>\n");
printf("<table border='0' class='data'>\n");
printf("<tr>\n");
printf("<th class='data'>Severity</th><th class='data'>Host</th><th class='data'>State</th><th class='data'>Notes</th><th class='data'>State Duration</th><th class='data'># Hosts Affected</th><th class='data'># Services Affected</th><th class='data'>Actions</th>\n");
printf("</tr>\n");
}
for (temp_hostoutagesort = hostoutagesort_list; temp_hostoutagesort != NULL; temp_hostoutagesort = temp_hostoutagesort->next) {
temp_hostoutage = temp_hostoutagesort->outage;
if (temp_hostoutage == NULL)
continue;
/* skip hosts that are not blocking anyone */
if (temp_hostoutage->affected_child_hosts <= 1)
continue;
temp_hoststatus = find_hoststatus(temp_hostoutage->hst->name);
if (temp_hoststatus == NULL)
continue;
/* make sure we only caught valid state types */
if (temp_hoststatus->status != HOST_DOWN && temp_hoststatus->status != HOST_UNREACHABLE)
continue;
total_entries++;
if (odd == 0) {
odd = 1;
bg_class = "dataOdd";
} else {
odd = 0;
bg_class = "dataEven";
}
if (temp_hoststatus->status == HOST_UNREACHABLE)
status = "UNREACHABLE";
else if (temp_hoststatus->status == HOST_DOWN)
status = "DOWN";
if (content_type == JSON_CONTENT) {
// always add a comma, except for the first line
if (json_start == FALSE)
printf(",\n");
json_start = FALSE;
printf("{ \"severity\": %d, ", temp_hostoutage->severity);
printf(" \"host_name\": \"%s\", ", json_encode(temp_hostoutage->hst->name));
printf(" \"host_display_name\": \"%s\", ", (temp_hostoutage->hst->display_name != NULL) ? json_encode(temp_hostoutage->hst->display_name) : json_encode(temp_hostoutage->hst->name));
printf(" \"state\": \"%s\", ", status);
} else if (content_type == CSV_CONTENT) {
printf("%s%d%s%s", csv_data_enclosure, temp_hostoutage->severity, csv_data_enclosure, csv_delimiter);
printf("%s%s%s%s", csv_data_enclosure, temp_hostoutage->hst->name, csv_data_enclosure, csv_delimiter);
printf("%s%s%s%s", csv_data_enclosure, status, csv_data_enclosure, csv_delimiter);
} else {
printf("<tr class='%s'>\n", bg_class);
printf("<td class='%s'>%d</td>\n", bg_class, temp_hostoutage->severity);
printf("<td class='%s'><a href='%s?type=%d&host=%s'>%s</a></td>\n", bg_class, EXTINFO_CGI, DISPLAY_HOST_INFO, url_encode(temp_hostoutage->hst->name), (temp_hostoutage->hst->display_name != NULL) ? temp_hostoutage->hst->display_name : temp_hostoutage->hst->name);
printf("<td class='host%s'>%s</td>\n", status, status);
}
total_comments = number_of_host_comments(temp_hostoutage->hst->name);
if (content_type == JSON_CONTENT) {
printf(" \"notes\": %d, ", total_comments);
} else if (content_type == CSV_CONTENT) {
printf("%s%d%s%s", csv_data_enclosure, total_comments, csv_data_enclosure, csv_delimiter);
} else {
if (total_comments > 0)
print_comment_icon(temp_hostoutage->hst->name, NULL);
else
printf("<td class='%s'>N/A</td>\n", bg_class);
}
current_time = time(NULL);
if (temp_hoststatus->last_state_change == (time_t)0)
t = current_time - program_start;
else
t = current_time - temp_hoststatus->last_state_change;
get_time_breakdown((unsigned long)t, &days, &hours, &minutes, &seconds);
snprintf(state_duration, sizeof(state_duration) - 1, "%2dd %2dh %2dm %2ds%s", days, hours, minutes, seconds, (temp_hoststatus->last_state_change == (time_t)0) ? "+" : "");
state_duration[sizeof(state_duration)-1] = '\x0';
if (content_type == JSON_CONTENT) {
printf(" \"state_duration\": \"%s\", ", state_duration);
printf(" \"hosts_affected\": %d, ", temp_hostoutage->affected_child_hosts);
printf(" \"services_affected\": %d }\n", temp_hostoutage->affected_child_services);
} else if (content_type == CSV_CONTENT) {
printf("%s%s%s%s", csv_data_enclosure, state_duration, csv_data_enclosure, csv_delimiter);
printf("%s%d%s%s", csv_data_enclosure, temp_hostoutage->affected_child_hosts, csv_data_enclosure, csv_delimiter);
printf("%s%d%s\n", csv_data_enclosure, temp_hostoutage->affected_child_services, csv_data_enclosure);
} else {
printf("<td class='%s'>%s</td>\n", bg_class, state_duration);
printf("<td class='%s'>%d</td>\n", bg_class, temp_hostoutage->affected_child_hosts);
printf("<td class='%s'>%d</td>\n", bg_class, temp_hostoutage->affected_child_services);
printf("<td class='%s'>", bg_class);
printf("<a href='%s?host=%s'><img src='%s%s' border='0' alt='View status detail for this host' title='View status detail for this host'></a>\n", STATUS_CGI, url_encode(temp_hostoutage->hst->name), url_images_path, STATUS_DETAIL_ICON);
#ifdef USE_STATUSMAP
printf("<a href='%s?host=%s'><img src='%s%s' border='0' alt='View status map for this host and its children' title='View status map for this host and its children'></a>\n", STATUSMAP_CGI, url_encode(temp_hostoutage->hst->name), url_images_path, STATUSMAP_ICON);
#endif
#ifdef USE_TRENDS
printf("<a href='%s?host=%s'><img src='%s%s' border='0' alt='View trends for this host' title='View trends for this host'></a>\n", TRENDS_CGI, url_encode(temp_hostoutage->hst->name), url_images_path, TRENDS_ICON);
#endif
printf("<a href='%s?host=%s'><img src='%s%s' border='0' alt='View alert history for this host' title='View alert history for this host'></a>\n", HISTORY_CGI, url_encode(temp_hostoutage->hst->name), url_images_path, HISTORY_ICON);
printf("<a href='%s?host=%s'><img src='%s%s' border='0' alt='View notifications for this host' title='View notifications for this host'></a>\n", NOTIFICATIONS_CGI, url_encode(temp_hostoutage->hst->name), url_images_path, NOTIFICATION_ICON);
/* add Link to acknowledge all affected hosts */
printf("<a href='%s?cmd_typ=%d&host=%s", CMD_CGI, CMD_ACKNOWLEDGE_HOST_PROBLEM, url_encode(temp_hostoutage->hst->name));
for (temp_affected_host = temp_hostoutage->affected_hosts; temp_affected_host != NULL; temp_affected_host = temp_affected_host->next)
printf("&host=%s", url_encode(temp_affected_host->host_name));
printf("'><img src='%s%s' border='0' alt='Acknowledge All Affected Hosts' title='Acknowledge All Affected Hosts'></a>\n", url_images_path, ACKNOWLEDGEMENT_ICON);
printf("</td>\n");
printf("</tr>\n");
}
}
if (content_type != CSV_CONTENT && content_type != JSON_CONTENT) {
printf("</table>\n");
if (total_entries == 0)
printf("<div class='itemTotalsTitle'>%d Blocking Outages Displayed</div>\n", total_entries);
} else if (content_type == JSON_CONTENT) {
printf("\n]\n");
}
/* free memory allocated to the host outage list */
free_hostoutage_list();
free_hostoutagesort_list();
return;
}
void display_logentries() {
char image[MAX_INPUT_BUFFER];
char image_alt[MAX_INPUT_BUFFER];
char last_message_date[MAX_INPUT_BUFFER] = "";
char current_message_date[MAX_INPUT_BUFFER] = "";
char date_time[MAX_DATETIME_LENGTH];
char *error_text = NULL;
int status = READLOG_OK;
int i = 0;
int user_has_seen_something = FALSE;
int json_start = TRUE;
int total_entries = 0;
int displayed_entries = 0;
struct tm *time_ptr = NULL;
logentry *entry_list = NULL;
logentry *temp_entry = NULL;
logfilter *filter_list = NULL;
/* Add default filters */
if (showlog_initial_states == FALSE) {
add_log_filter(&filter_list, LOGENTRY_SERVICE_INITIAL_STATE, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_HOST_INITIAL_STATE, LOGFILTER_EXCLUDE);
}
if (showlog_current_states == FALSE) {
add_log_filter(&filter_list, LOGENTRY_SERVICE_CURRENT_STATE, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_HOST_CURRENT_STATE, LOGFILTER_EXCLUDE);
}
/* Add requested filters */
if (show_notifications == FALSE) {
add_log_filter(&filter_list, LOGENTRY_HOST_NOTIFICATION, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_SERVICE_NOTIFICATION, LOGFILTER_EXCLUDE);
}
if (show_host_status == FALSE) {
add_log_filter(&filter_list, LOGENTRY_HOST_UP, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_HOST_DOWN, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_HOST_UNREACHABLE, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_HOST_RECOVERY, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_PASSIVE_HOST_CHECK, LOGFILTER_EXCLUDE);
}
if (show_service_status == FALSE) {
add_log_filter(&filter_list, LOGENTRY_SERVICE_OK, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_SERVICE_WARNING, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_SERVICE_CRITICAL, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_SERVICE_UNKNOWN, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_SERVICE_RECOVERY, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_PASSIVE_SERVICE_CHECK, LOGFILTER_EXCLUDE);
}
if (show_external_commands == FALSE)
add_log_filter(&filter_list, LOGENTRY_EXTERNAL_COMMAND, LOGFILTER_EXCLUDE);
if (show_system_messages == FALSE) {
add_log_filter(&filter_list, LOGENTRY_SYSTEM_WARNING, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_STARTUP, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_SHUTDOWN, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_BAILOUT, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_RESTART, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_LOG_ROTATION, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_AUTOSAVE, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_IDOMOD, LOGFILTER_EXCLUDE);
}
if (show_event_handler == FALSE) {
add_log_filter(&filter_list, LOGENTRY_SERVICE_EVENT_HANDLER, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_HOST_EVENT_HANDLER, LOGFILTER_EXCLUDE);
}
if (show_flapping == FALSE) {
add_log_filter(&filter_list, LOGENTRY_SERVICE_FLAPPING_STARTED, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_SERVICE_FLAPPING_STOPPED, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_SERVICE_FLAPPING_DISABLED, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_HOST_FLAPPING_STARTED, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_HOST_FLAPPING_STOPPED, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_HOST_FLAPPING_DISABLED, LOGFILTER_EXCLUDE);
}
if (show_downtime == FALSE) {
add_log_filter(&filter_list, LOGENTRY_SERVICE_DOWNTIME_STARTED, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_SERVICE_DOWNTIME_STOPPED, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_SERVICE_DOWNTIME_CANCELLED, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_HOST_DOWNTIME_STARTED, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_HOST_DOWNTIME_STOPPED, LOGFILTER_EXCLUDE);
add_log_filter(&filter_list, LOGENTRY_HOST_DOWNTIME_CANCELLED, LOGFILTER_EXCLUDE);
}
/* scan the log file for archived state data */
status = get_log_entries(&entry_list, &filter_list, &error_text, query_string, reverse, ts_start, ts_end);
free_log_filters(&filter_list);
/* dealing with errors */
if (status == READLOG_ERROR_WARNING) {
if (error_text != NULL) {
print_generic_error_message(error_text, NULL, 0);
my_free(error_text);
} else
print_generic_error_message("Unkown error!", NULL, 0);
}
if (status == READLOG_ERROR_MEMORY)
print_generic_error_message("Out of memory...", "showing all I could get!", 0);
if (status == READLOG_ERROR_FATAL) {
if (error_text != NULL) {
print_generic_error_message(error_text, NULL, 0);
my_free(error_text);
}
user_has_seen_something = TRUE;
/* now we start displaying the log entries */
} else {
if (content_type == JSON_CONTENT) {
display_timebreaks = FALSE;
if (status != READLOG_OK)
printf(",\n");
printf("\"log_entries\": [\n");
} else if (content_type == CSV_CONTENT) {
display_timebreaks = FALSE;
printf("%sTimestamp%s%s", csv_data_enclosure, csv_data_enclosure, csv_delimiter);
printf("%sDate Time%s%s", csv_data_enclosure, csv_data_enclosure, csv_delimiter);
printf("%sLog Entry%s\n", csv_data_enclosure, csv_data_enclosure);
} else {
/* add export to csv, json, link */
printf("<table width='100%%' cellspacing=0 cellpadding=0 border=0><tr><td width='33%%'></td><td width='33%%' align=center nowrap>");
printf("<div class='page_selector' id='log_page_selector'>\n");
printf("<div id='page_navigation_copy'></div>");
page_limit_selector(result_start);
printf("</div>\n");
printf("</td><td width='33%%' align='right'>\n");
printf("<div class='csv_export_link' style='margin-right:1em;'>");
print_export_link(CSV_CONTENT, SHOWLOG_CGI, NULL);
print_export_link(JSON_CONTENT, SHOWLOG_CGI, NULL);
print_export_link(HTML_CONTENT, SHOWLOG_CGI, NULL);
printf("</div></td></tr></table>");
printf("</div>\n");
printf("<DIV CLASS='logEntries'>\n");
}
for (temp_entry = entry_list; temp_entry != NULL; temp_entry = temp_entry->next) {
if (result_limit != 0 && (((total_entries + 1) < result_start) || (total_entries >= ((result_start + result_limit) - 1)))) {
total_entries++;
continue;
}
total_entries++;
displayed_entries++;
/* set the correct icon and icon alt text for current log entry */
if (temp_entry->type == LOGENTRY_STARTUP) {
strcpy(image, START_ICON);
strcpy(image_alt, START_ICON_ALT);
} else if (temp_entry->type == LOGENTRY_SHUTDOWN || temp_entry->type == LOGENTRY_BAILOUT) {
strcpy(image, STOP_ICON);
strcpy(image_alt, STOP_ICON_ALT);
} else if (temp_entry->type == LOGENTRY_RESTART) {
strcpy(image, RESTART_ICON);
strcpy(image_alt, RESTART_ICON_ALT);
} else if (temp_entry->type == LOGENTRY_HOST_DOWN) {
strcpy(image, HOST_DOWN_ICON);
strcpy(image_alt, HOST_DOWN_ICON_ALT);
} else if (temp_entry->type == LOGENTRY_HOST_UNREACHABLE) {
strcpy(image, HOST_UNREACHABLE_ICON);
strcpy(image_alt, HOST_UNREACHABLE_ICON_ALT);
} else if (temp_entry->type == LOGENTRY_HOST_RECOVERY || temp_entry->type == LOGENTRY_HOST_UP) {
strcpy(image, HOST_UP_ICON);
strcpy(image_alt, HOST_UP_ICON_ALT);
} else if (temp_entry->type == LOGENTRY_HOST_NOTIFICATION) {
strcpy(image, HOST_NOTIFICATION_ICON);
strcpy(image_alt, HOST_NOTIFICATION_ICON_ALT);
} else if (temp_entry->type == LOGENTRY_SERVICE_CRITICAL) {
strcpy(image, CRITICAL_ICON);
strcpy(image_alt, CRITICAL_ICON_ALT);
} else if (temp_entry->type == LOGENTRY_SERVICE_WARNING) {
strcpy(image, WARNING_ICON);
strcpy(image_alt, WARNING_ICON_ALT);
} else if (temp_entry->type == LOGENTRY_SERVICE_UNKNOWN) {
strcpy(image, UNKNOWN_ICON);
strcpy(image_alt, UNKNOWN_ICON_ALT);
} else if (temp_entry->type == LOGENTRY_SERVICE_RECOVERY || temp_entry->type == LOGENTRY_SERVICE_OK) {
strcpy(image, OK_ICON);
strcpy(image_alt, OK_ICON_ALT);
} else if (temp_entry->type == LOGENTRY_SERVICE_NOTIFICATION) {
strcpy(image, NOTIFICATION_ICON);
strcpy(image_alt, NOTIFICATION_ICON_ALT);
} else if (temp_entry->type == LOGENTRY_SERVICE_EVENT_HANDLER) {
strcpy(image, SERVICE_EVENT_ICON);
strcpy(image_alt, SERVICE_EVENT_ICON_ALT);
} else if (temp_entry->type == LOGENTRY_HOST_EVENT_HANDLER) {
strcpy(image, HOST_EVENT_ICON);
strcpy(image_alt, HOST_EVENT_ICON_ALT);
} else if (temp_entry->type == LOGENTRY_EXTERNAL_COMMAND) {
strcpy(image, EXTERNAL_COMMAND_ICON);
strcpy(image_alt, EXTERNAL_COMMAND_ICON_ALT);
} else if (temp_entry->type == LOGENTRY_PASSIVE_SERVICE_CHECK) {
strcpy(image, PASSIVE_ICON);
strcpy(image_alt, "Passive Service Check");
} else if (temp_entry->type == LOGENTRY_PASSIVE_HOST_CHECK) {
strcpy(image, PASSIVE_ICON);
strcpy(image_alt, "Passive Host Check");
} else if (temp_entry->type == LOGENTRY_LOG_ROTATION) {
strcpy(image, LOG_ROTATION_ICON);
strcpy(image_alt, LOG_ROTATION_ICON_ALT);
} else if (temp_entry->type == LOGENTRY_ACTIVE_MODE) {
strcpy(image, ACTIVE_ICON);
strcpy(image_alt, ACTIVE_ICON_ALT);
} else if (temp_entry->type == LOGENTRY_STANDBY_MODE) {
strcpy(image, STANDBY_ICON);
strcpy(image_alt, STANDBY_ICON_ALT);
} else if (temp_entry->type == LOGENTRY_SERVICE_FLAPPING_STARTED) {
strcpy(image, FLAPPING_ICON);
strcpy(image_alt, "Service started flapping");
} else if (temp_entry->type == LOGENTRY_SERVICE_FLAPPING_STOPPED) {
strcpy(image, FLAPPING_ICON);
strcpy(image_alt, "Service stopped flapping");
} else if (temp_entry->type == LOGENTRY_SERVICE_FLAPPING_DISABLED) {
strcpy(image, FLAPPING_ICON);
strcpy(image_alt, "Service flap detection disabled");
} else if (temp_entry->type == LOGENTRY_HOST_FLAPPING_STARTED) {
strcpy(image, FLAPPING_ICON);
strcpy(image_alt, "Host started flapping");
} else if (temp_entry->type == LOGENTRY_HOST_FLAPPING_STOPPED) {
strcpy(image, FLAPPING_ICON);
strcpy(image_alt, "Host stopped flapping");
} else if (temp_entry->type == LOGENTRY_HOST_FLAPPING_DISABLED) {
strcpy(image, FLAPPING_ICON);
strcpy(image_alt, "Host flap detection disabled");
} else if (temp_entry->type == LOGENTRY_SERVICE_DOWNTIME_STARTED) {
strcpy(image, DOWNTIME_ICON);
strcpy(image_alt, "Service entered a period of scheduled downtime");
} else if (temp_entry->type == LOGENTRY_SERVICE_DOWNTIME_STOPPED) {
strcpy(image, DOWNTIME_ICON);
strcpy(image_alt, "Service exited a period of scheduled downtime");
} else if (temp_entry->type == LOGENTRY_SERVICE_DOWNTIME_CANCELLED) {
strcpy(image, DOWNTIME_ICON);
strcpy(image_alt, "Service scheduled downtime has been cancelled");
} else if (temp_entry->type == LOGENTRY_HOST_DOWNTIME_STARTED) {
strcpy(image, DOWNTIME_ICON);
strcpy(image_alt, "Host entered a period of scheduled downtime");
} else if (temp_entry->type == LOGENTRY_HOST_DOWNTIME_STOPPED) {
strcpy(image, DOWNTIME_ICON);
strcpy(image_alt, "Host exited a period of scheduled downtime");
} else if (temp_entry->type == LOGENTRY_HOST_DOWNTIME_CANCELLED) {
strcpy(image, DOWNTIME_ICON);
strcpy(image_alt, "Host scheduled downtime has been cancelled");
} else if (temp_entry->type == LOGENTRY_IDOMOD) {
strcpy(image, DATABASE_ICON);
strcpy(image_alt, "IDOMOD Information");
} else if (temp_entry->type == LOGENTRY_NPCDMOD) {
strcpy(image, STATS_ICON);
strcpy(image_alt, "NPCDMOD Information");
} else if (temp_entry->type == LOGENTRY_AUTOSAVE) {
strcpy(image, AUTOSAVE_ICON);
strcpy(image_alt, "Auto-save retention data");
} else if (temp_entry->type == LOGENTRY_SYSTEM_WARNING) {
strcpy(image, DAEMON_WARNING_ICON);
strcpy(image_alt, "Icinga warning message");
} else {
strcpy(image, INFO_ICON);
strcpy(image_alt, INFO_ICON_ALT);
}
time_ptr = localtime(&temp_entry->timestamp);
strftime(current_message_date, sizeof(current_message_date), "%B %d, %Y %H:00", time_ptr);
current_message_date[sizeof(current_message_date) - 1] = '\x0';
if (strcmp(last_message_date, current_message_date) != 0 && display_timebreaks == TRUE) {
printf("</DIV>\n");
printf("<BR>\n");
printf("<DIV>\n");
printf("<table border=0 width=99%% CLASS='dateTimeBreak' align=center><tr>");
printf("<td width=40%%><hr width=100%%></td>");
printf("<td align=center CLASS='dateTimeBreak'>%s</td>", current_message_date);
printf("<td width=40%%><hr width=100%%></td>");
printf("</tr></table>\n");
printf("</DIV>\n");
printf("<BR><DIV CLASS='logEntries'>\n");
strncpy(last_message_date, current_message_date, sizeof(last_message_date));
last_message_date[sizeof(last_message_date) - 1] = '\x0';
}
get_time_string(&temp_entry->timestamp, date_time, (int)sizeof(date_time), SHORT_DATE_TIME);
strip(date_time);
/* preparing logentries for json and csv output */
if (content_type == CSV_CONTENT || content_type == JSON_CONTENT) {
for (i = 0; i < strlen(temp_entry->entry_text) - 1; i++)
*(temp_entry->entry_text + i) = *(temp_entry->entry_text + i + 1);
temp_entry->entry_text[strlen(temp_entry->entry_text) - 1] = '\x0';
}
/* displays log entry depending on requested content type */
if (content_type == JSON_CONTENT) {
// always add a comma, except for the first line
if (json_start == FALSE)
printf(",\n");
json_start = FALSE;
printf("{ \"timestamp\": %lu, ", temp_entry->timestamp);
printf(" \"date_time\": \"%s\", ", date_time);
printf(" \"log_entry\": \"%s\"}", json_encode(temp_entry->entry_text));
} else if (content_type == CSV_CONTENT) {
printf("%s%lu%s%s", csv_data_enclosure, temp_entry->timestamp, csv_data_enclosure, csv_delimiter);
printf("%s%s%s%s", csv_data_enclosure, date_time, csv_data_enclosure, csv_delimiter);
printf("%s%s%s\n", csv_data_enclosure, temp_entry->entry_text, csv_data_enclosure);
} else {
if (display_frills == TRUE)
printf("<img align=left src='%s%s' alt='%s' title='%s'>", url_images_path, image, image_alt, image_alt);
printf("[%s] %s", date_time, (temp_entry->entry_text == NULL) ? "" : html_encode(temp_entry->entry_text, FALSE));
if (enable_splunk_integration == TRUE) {
printf(" ");
display_splunk_generic_url(temp_entry->entry_text, 2);
}
printf("<br clear=all>\n");
}
user_has_seen_something = TRUE;
}
if (content_type != CSV_CONTENT && content_type != JSON_CONTENT) {
if (user_has_seen_something == TRUE) {
printf("</DIV><hr>\n");
page_num_selector(result_start, total_entries, displayed_entries);
} else {
printf("<script type='text/javascript'>document.getElementById('log_page_selector').style.display='none';</script>");
}
} else if (content_type == JSON_CONTENT)
printf("\n]\n");
}
free_log_entries(&entry_list);
if (user_has_seen_something == FALSE && content_type != CSV_CONTENT && content_type != JSON_CONTENT)
printf("<DIV CLASS='warningMessage'>No log entries found!</DIV>");
return;
}
