/* entry point to parse the log line by line */
int
parse_log (GLog ** logger, char *tail, int n)
{
FILE *fp = NULL;
char line[LINE_BUFFER];
int i = 0, test = -1 == n ? 0 : 1;
if (conf.date_format == NULL || *conf.date_format == '\0')
FATAL ("No date format was found on your conf file.");
if (conf.log_format == NULL || *conf.log_format == '\0')
FATAL ("No log format was found on your conf file.");
if (tail != NULL) {
if (process_log ((*logger), tail, test))
return 1;
return 0;
}
if (conf.ifile == NULL) {
fp = stdin;
(*logger)->piping = 1;
}
/* make sure we can open the log (if not reading from stdin) */
if (!(*logger)->piping && (fp = fopen (conf.ifile, "r")) == NULL)
FATAL ("%s", strerror (errno));
while (fgets (line, LINE_BUFFER, fp) != NULL) {
if (n >= 0 && i++ == n)
break;
if (process_log ((*logger), line, test)) {
if (!(*logger)->piping)
fclose (fp);
return 1;
}
}
/* definitely not portable! */
if ((*logger)->piping)
freopen ("/dev/tty", "r", stdin);
if (!(*logger)->piping)
fclose (fp);
return 0;
}
/* log_worker() - Worker thread processing the log_buf buffer. */
static int log_worker(void *p)
{
int ret = 0;
if (log_buf == NULL) {
ret = -EFAULT;
goto err_kthread;
}
while (!kthread_should_stop()) {
if (log_buf->write_pos == log_pos)
schedule_timeout_interruptible(MAX_SCHEDULE_TIMEOUT);
switch (log_buf->version) {
case 2:
log_pos = process_log();
break;
default:
MCDRV_DBG_ERROR(mcd, "Unknown Mobicore log data");
log_pos = log_buf->write_pos;
/*
* Stop the thread as we have no idea what
* happens next
*/
ret = -EFAULT;
goto err_kthread;
}
}
err_kthread:
MCDRV_DBG(mcd, "Logging thread stopped!");
thread_err = ret;
/*
* Wait until the next kthread_stop() is called, if it was already
* called we just slip through, if there is an error signal it and
* wait to get the signal
*/
set_current_state(TASK_INTERRUPTIBLE);
while (!kthread_should_stop()) {
schedule();
set_current_state(TASK_INTERRUPTIBLE);
}
set_current_state(TASK_RUNNING);
return ret;
}
static void process_active_checks(char *server, unsigned short port)
{
register int i, s_count, p_count;
char **pvalue;
int now, send_err = SUCCEED, ret;
unsigned long timestamp;
char *source = NULL;
char *value = NULL;
unsigned short severity;
long lastlogsize;
char params[MAX_STRING_LEN];
char filename[MAX_STRING_LEN];
char pattern[MAX_STRING_LEN];
AGENT_RESULT result;
zabbix_log( LOG_LEVEL_DEBUG, "In process_active_checks('%s',%u)",server, port);
init_result(&result);
now = (int)time(NULL);
for(i=0; NULL != active_metrics[i].key && SUCCEED == send_err; i++)
{
if(active_metrics[i].nextcheck > now) continue;
if(active_metrics[i].status != ITEM_STATUS_ACTIVE) continue;
/* Special processing for log files */
if(strncmp(active_metrics[i].key,"log[",4) == 0)
{
do{ /* simple try realization */
if (parse_command(active_metrics[i].key, NULL, 0, params, MAX_STRING_LEN) != 2)
break;
if (num_param(params) > 2)
break;
if (get_param(params, 1, filename, sizeof(filename)) != 0)
break;
if (get_param(params, 2, pattern, sizeof(pattern)) != 0)
*pattern = '\0';
s_count = 0;
p_count = 0;
lastlogsize = active_metrics[i].lastlogsize;
while (SUCCEED == (ret = process_log(filename, &lastlogsize, &value))) {
if (!value) /* EOF */
break;
if (SUCCEED == regexp_match_ex(regexps, regexps_num, value, pattern, ZBX_CASE_SENSITIVE)) {
send_err = process_value(
server,
port,
CONFIG_HOSTNAME,
active_metrics[i].key_orig,
value,
&lastlogsize,
NULL,
NULL,
NULL
);
s_count++;
}
p_count++;
zbx_free(value);
if (SUCCEED == send_err)
active_metrics[i].lastlogsize = lastlogsize;
else
lastlogsize = active_metrics[i].lastlogsize;
/* Do not flood ZABBIX server if file grows too fast */
if(s_count >= (MAX_LINES_PER_SECOND * active_metrics[i].refresh)) break;
/* Do not flood local system if file grows too fast */
if(p_count >= (4 * MAX_LINES_PER_SECOND * active_metrics[i].refresh)) break;
}
if( FAIL == ret )
{
active_metrics[i].status = ITEM_STATUS_NOTSUPPORTED;
zabbix_log( LOG_LEVEL_WARNING, "Active check [%s] is not supported. Disabled.",
active_metrics[i].key);
send_err = process_value(
server,
port,
CONFIG_HOSTNAME,
active_metrics[i].key_orig,
"ZBX_NOTSUPPORTED",
&active_metrics[i].lastlogsize,
NULL,
NULL,
NULL
);
}
}while(0); /* simple try realization */
}
/* Special processing for eventlog */
else if(strncmp(active_metrics[i].key,"eventlog[",9) == 0)
{
do{ /* simple try realization */
if (parse_command(active_metrics[i].key, NULL, 0, params, MAX_STRING_LEN) != 2)
break;
if (num_param(params) > 2)
break;
if (get_param(params, 1, filename, sizeof(filename)) != 0)
break;
if (get_param(params, 2, pattern, sizeof(pattern)) != 0)
*pattern = '\0';
s_count = 0;
p_count = 0;
lastlogsize = active_metrics[i].lastlogsize;
while (SUCCEED == (ret = process_eventlog(filename, &lastlogsize,
×tamp, &source, &severity, &value)))
{
if (!value) /* EOF */
break;
if (SUCCEED == regexp_match_ex(regexps, regexps_num, value, pattern, ZBX_CASE_SENSITIVE)) {
send_err = process_value(
server,
port,
CONFIG_HOSTNAME,
active_metrics[i].key_orig,
value,
&lastlogsize,
×tamp,
source,
&severity
);
s_count++;
}
p_count++;
zbx_free(source);
zbx_free(value);
if (SUCCEED == send_err)
active_metrics[i].lastlogsize = lastlogsize;
else
lastlogsize = active_metrics[i].lastlogsize;
/* Do not flood ZABBIX server if file grows too fast */
if(s_count >= (MAX_LINES_PER_SECOND * active_metrics[i].refresh)) break;
/* Do not flood local system if file grows too fast */
if(p_count >= (4 * MAX_LINES_PER_SECOND * active_metrics[i].refresh)) break;
}
if( FAIL == ret )
{
active_metrics[i].status = ITEM_STATUS_NOTSUPPORTED;
zabbix_log( LOG_LEVEL_WARNING, "Active check [%s] is not supported. Disabled.",
active_metrics[i].key);
send_err = process_value(
server,
port,
CONFIG_HOSTNAME,
active_metrics[i].key_orig,
"ZBX_NOTSUPPORTED",
&active_metrics[i].lastlogsize,
NULL,
NULL,
NULL
);
}
}while(0); /* simple try realization NOTE: never loop */
}
else
{
process(active_metrics[i].key, 0, &result);
if( NULL == (pvalue = GET_TEXT_RESULT(&result)) )
pvalue = GET_MSG_RESULT(&result);
if(pvalue)
{
zabbix_log( LOG_LEVEL_DEBUG, "For key [%s] received value [%s]", active_metrics[i].key, *pvalue);
send_err = process_value(
server,
port,
CONFIG_HOSTNAME,
active_metrics[i].key_orig,
*pvalue,
NULL,
NULL,
NULL,
NULL
);
if( 0 == strcmp(*pvalue,"ZBX_NOTSUPPORTED") )
{
active_metrics[i].status = ITEM_STATUS_NOTSUPPORTED;
zabbix_log( LOG_LEVEL_WARNING, "Active check [%s] is not supported. Disabled.", active_metrics[i].key);
}
}
free_result(&result);
}
active_metrics[i].nextcheck = (int)time(NULL)+active_metrics[i].refresh;
}
}
int main(int argc, char* argv[])
{
pid_t pid;
long long period, budget, exec;
char* token;
struct sched_attr dl_attr;
int ret;
unsigned int flags = 0;
struct sigaction sa;
struct itimerval timer;
memset(&task, 0, sizeof(task));
memset(&task_rst, 0, sizeof(task_rst));
ret = atexit(bye);
if (ret != 0)
{
perror("atexit");
exit(1);
}
if (argc >= 3)
{
pid = getpid();
printf("%d\t===pid===\n", (int)pid);
printf("lock pages in memory\n");
ret = mlockall(MCL_CURRENT | MCL_FUTURE);
if (ret < 0)
{
perror("mlockall");
exit(1);
}
token = strtok(argv[1], ":");
period = strtoll(token, NULL, 10);
token = strtok(NULL, ":");
budget = strtoll(token, NULL, 10);
token = strtok(NULL, ":");
exec = strtoll(token, NULL, 10);
printf("period = %lld ns, budget = %lld ns, exec = %lld ns\n", period, budget, exec);
if (exec == 0)
{
pure_overhead = 1;
}
else
{
pure_overhead = 0;
}
//duration is a must
duration = atoi(argv[2]);
clock_gettime(CLOCK_REALTIME, &task_rst.t_exit);
memcpy((void*)&task_rst.t_middle, (void*)&task_rst.t_exit, sizeof(task_rst.t_middle));
task_rst.t_exit.tv_sec = task_rst.t_exit.tv_sec + duration;
task_rst.t_middle.tv_sec = task_rst.t_middle.tv_sec + duration / 2;//set halfway timestamp
if (argc >= 4)
{
g_log = atoi(argv[3]);
}
if (argc >= 5)
{
g_scheduler = atoi(argv[4]);
}
//set deadline scheduling
pid = 0;
assert(period >= budget && budget >= exec);
// task_rst.dl_period = usec_to_timespec(period);
// task_rst.dl_budget = usec_to_timespec(budget);
// task_rst.dl_exec = usec_to_timespec(exec);
task_rst.dl_period = nsec_to_timespec((unsigned long long)period);
task_rst.dl_budget = nsec_to_timespec((unsigned long long)budget);
task_rst.dl_exec = nsec_to_timespec((unsigned long long)exec);
dl_attr.size = sizeof(dl_attr);
dl_attr.sched_flags = 0;
dl_attr.sched_policy = SCHED_DEADLINE;
dl_attr.sched_priority = 0;
dl_attr.sched_runtime = timespec_to_nsec(&task_rst.dl_budget);
dl_attr.sched_deadline = timespec_to_nsec(&task_rst.dl_period);
dl_attr.sched_period = timespec_to_nsec(&task_rst.dl_period);
task_rst.correct_cnt =(int)((int64_t)(duration * 1E9) / timespec_to_nsec(&task_rst.dl_period));
task_rst.i_corrent_whole_thread_runtime = (int64_t)task_rst.correct_cnt * timespec_to_nsec(&task_rst.dl_exec);
if (g_scheduler == 0)
{
printf("using sched_deadline\n");
ret = sched_setattr(pid, &dl_attr, flags);
if (ret != 0)
{
perror("sched_setattr");
exit(1);
}
}
else if (g_scheduler == 1)
{
printf("using cfs\n");
}
else
{
printf("not implemented\n");
exit(1);
}
#if 0
memset(&sa, 0, sizeof(sa));
sa.sa_handler = &signal_handler;
sigaction(SIGALRM, &sa, NULL);
sigaction(SIGINT, &sa, NULL);
timer.it_value.tv_sec = dl_period.tv_sec;
timer.it_value.tv_usec = dl_period.tv_nsec / 1000;
timer.it_interval.tv_sec = dl_period.tv_sec;
timer.it_interval.tv_usec = dl_period.tv_nsec / 1000;
setitimer(ITIMER_REAL, &timer, NULL);
#endif
struct timespec t_exec;
clock_gettime(CLOCK_REALTIME, &task.t_period);
task.t_period = timespec_add(&task.t_period, &task_rst.dl_period);//start from next period
task.t_deadline = timespec_add(&task.t_period, &task_rst.dl_period);
clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &task.t_period, NULL);
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &task_rst.t_whole_thread_start);
while(1)
{
clock_gettime(CLOCK_REALTIME, &task.t_begin);
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &task.t_thread_start);
t_exec = timespec_add(&task.t_thread_start, &task_rst.dl_exec);
if (!pure_overhead)
{
busy_wait(&t_exec, &task.t_deadline);
}
clock_gettime(CLOCK_THREAD_CPUTIME_ID, &task.t_thread_finish);
clock_gettime(CLOCK_REALTIME, &task.t_end);
task.t_thread_run = timespec_sub(&task.t_thread_finish, &task.t_thread_start);
task.t_thread_remain = timespec_sub(&t_exec, &task.t_thread_finish);
task.t_diff = timespec_sub(&task.t_end, &task.t_begin);
task.t_slack = timespec_sub(&task.t_deadline, &task.t_end);
task.t_offset = timespec_sub(&task.t_begin, &task.t_period);
process_log(&task, &task_rst);
task.t_period = timespec_add(&task.t_period, &task_rst.dl_period);
task.t_deadline = timespec_add(&task.t_deadline, &task_rst.dl_period);
//check total test time
struct timespec t_now;
clock_gettime(CLOCK_REALTIME, &t_now);
if (duration && timespec_lower(&task_rst.t_exit, &t_now))
{
print_result_exit(&t_now, &task, &task_rst);
}
clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &task.t_period, NULL);
}
}
else
{
printf("usage: rt_task <period>:<budget>:<exec> <duration> [<log_switch>] [<scheduler>]\n");
}
return 0;
}
static void process_active_checks(char *server, unsigned short port)
{
const char *__function_name = "process_active_checks";
register int i, s_count, p_count;
char **pvalue;
int now, send_err = SUCCEED, ret;
char *value = NULL, *item_value = NULL;
zbx_uint64_t lastlogsize;
int mtime;
char params[MAX_STRING_LEN], filename[MAX_STRING_LEN];
char pattern[MAX_STRING_LEN], output_template[MAX_STRING_LEN];
/* checks `log', `eventlog', `logrt' may contain parameter, which overrides CONFIG_MAX_LINES_PER_SECOND */
char maxlines_persec_str[16];
int maxlines_persec;
#ifdef _WINDOWS
unsigned long timestamp, logeventid;
unsigned short severity;
char key_severity[MAX_STRING_LEN], str_severity[32] /* for `regex_match_ex' */;
char key_source[MAX_STRING_LEN], *provider = NULL, *source = NULL;
char key_logeventid[MAX_STRING_LEN], str_logeventid[8] /* for `regex_match_ex' */;
OSVERSIONINFO versionInfo;
zbx_uint64_t keywords;
EVT_HANDLE eventlog6_render_context = NULL;
EVT_HANDLE eventlog6_query = NULL;
zbx_uint64_t eventlog6_firstid = 0;
zbx_uint64_t eventlog6_lastid = 0;
#endif
char encoding[32];
char tmp[16];
AGENT_RESULT result;
zabbix_log(LOG_LEVEL_DEBUG, "In %s('%s',%hu)", __function_name, server, port);
init_result(&result);
now = (int)time(NULL);
for (i = 0; NULL != active_metrics[i].key && SUCCEED == send_err; i++)
{
if (active_metrics[i].nextcheck > now)
continue;
if (ITEM_STATE_NORMAL != active_metrics[i].state)
continue;
/* special processing for log files without rotation */
if (0 == strncmp(active_metrics[i].key, "log[", 4))
{
ret = FAIL;
do
{
/* simple try realization */
if (ZBX_COMMAND_WITH_PARAMS != parse_command(active_metrics[i].key, NULL, 0,
params, sizeof(params)))
{
break;
}
if (6 < num_param(params))
break;
if (0 != get_param(params, 1, filename, sizeof(filename)))
break;
if (0 != get_param(params, 2, pattern, sizeof(pattern)))
*pattern = '\0';
if (0 != get_param(params, 3, encoding, sizeof(encoding)))
*encoding = '\0';
zbx_strupper(encoding);
if (0 != get_param(params, 4, maxlines_persec_str, sizeof(maxlines_persec_str)) ||
'\0' == *maxlines_persec_str)
maxlines_persec = CONFIG_MAX_LINES_PER_SECOND;
else if (MIN_VALUE_LINES > (maxlines_persec = atoi(maxlines_persec_str)) ||
MAX_VALUE_LINES < maxlines_persec)
break;
if (0 != get_param(params, 5, tmp, sizeof(tmp)))
*tmp = '\0';
if ('\0' == *tmp || 0 == strcmp(tmp, "all"))
active_metrics[i].skip_old_data = 0;
else if (0 != strcmp(tmp, "skip"))
break;
if (0 != get_param(params, 6, output_template, sizeof(output_template)))
*output_template = '\0';
s_count = 0;
p_count = 0;
lastlogsize = active_metrics[i].lastlogsize;
while (SUCCEED == (ret = process_log(filename, &lastlogsize, &value, encoding,
active_metrics[i].skip_old_data)))
{
active_metrics[i].skip_old_data = 0;
/* End of file. The file could become empty, must save `lastlogsize'. */
if (NULL == value)
{
active_metrics[i].lastlogsize = lastlogsize;
break;
}
if (SUCCEED == regexp_sub_ex(®exps, value, pattern, ZBX_CASE_SENSITIVE,
output_template, &item_value))
{
send_err = process_value(server, port, CONFIG_HOSTNAME,
active_metrics[i].key_orig, item_value, &lastlogsize,
NULL, NULL, NULL, NULL, NULL, 1);
zbx_free(item_value);
s_count++;
}
p_count++;
zbx_free(value);
if (SUCCEED == send_err)
active_metrics[i].lastlogsize = lastlogsize;
else
{
/* buffer is full, stop processing active checks */
/* till the buffer is cleared */
lastlogsize = active_metrics[i].lastlogsize;
goto ret;
}
/* do not flood Zabbix server if file grows too fast */
if (s_count >= (maxlines_persec * active_metrics[i].refresh))
break;
/* do not flood local system if file grows too fast */
if (p_count >= (4 * maxlines_persec * active_metrics[i].refresh))
break;
} /* while processing a log */
}
while (0); /* simple try realization */
if (FAIL == ret)
{
active_metrics[i].state = ITEM_STATE_NOTSUPPORTED;
zabbix_log(LOG_LEVEL_WARNING, "active check \"%s\" is not supported",
active_metrics[i].key);
process_value(server, port, CONFIG_HOSTNAME, active_metrics[i].key_orig, NULL,
&active_metrics[i].lastlogsize, NULL, NULL, NULL, NULL, NULL, 0);
}
}
/* special processing for log files with rotation */
else if (0 == strncmp(active_metrics[i].key, "logrt[", 6))
{
ret = FAIL;
do
{
/* simple try realization */
if (ZBX_COMMAND_WITH_PARAMS != parse_command(active_metrics[i].key, NULL, 0,
params, sizeof(params)))
{
break;
}
if (6 < num_param(params))
break;
if (0 != get_param(params, 1, filename, sizeof(filename)))
break;
if (0 != get_param(params, 2, pattern, sizeof(pattern)))
*pattern = '\0';
if (0 != get_param(params, 3, encoding, sizeof(encoding)))
*encoding = '\0';
zbx_strupper(encoding);
if (0 != get_param(params, 4, maxlines_persec_str, sizeof(maxlines_persec_str)) ||
'\0' == *maxlines_persec_str)
maxlines_persec = CONFIG_MAX_LINES_PER_SECOND;
else if (MIN_VALUE_LINES > (maxlines_persec = atoi(maxlines_persec_str)) ||
MAX_VALUE_LINES < maxlines_persec)
break;
if (0 != get_param(params, 5, tmp, sizeof(tmp)))
*tmp = '\0';
if ('\0' == *tmp || 0 == strcmp(tmp, "all"))
active_metrics[i].skip_old_data = 0;
else if (0 != strcmp(tmp, "skip"))
break;
if (0 != get_param(params, 6, output_template, sizeof(output_template)))
*output_template = '\0';
s_count = 0;
p_count = 0;
lastlogsize = active_metrics[i].lastlogsize;
mtime = active_metrics[i].mtime;
while (SUCCEED == (ret = process_logrt(filename, &lastlogsize, &mtime, &value,
encoding, active_metrics[i].skip_old_data)))
{
active_metrics[i].skip_old_data = 0;
/* End of file. The file could become empty,*/
/* must save `lastlogsize' and `mtime'. */
if (NULL == value)
{
active_metrics[i].lastlogsize = lastlogsize;
active_metrics[i].mtime = mtime;
break;
}
if (SUCCEED == regexp_sub_ex(®exps, value, pattern, ZBX_CASE_SENSITIVE,
output_template, &item_value))
{
send_err = process_value(server, port, CONFIG_HOSTNAME,
active_metrics[i].key_orig, item_value, &lastlogsize,
&mtime, NULL, NULL, NULL, NULL, 1);
zbx_free(item_value);
s_count++;
}
p_count++;
zbx_free(value);
if (SUCCEED == send_err)
{
active_metrics[i].lastlogsize = lastlogsize;
active_metrics[i].mtime = mtime;
}
else
{
/* buffer is full, stop processing active checks */
/* till the buffer is cleared */
lastlogsize = active_metrics[i].lastlogsize;
mtime = active_metrics[i].mtime;
goto ret;
}
/* do not flood Zabbix server if file grows too fast */
if (s_count >= (maxlines_persec * active_metrics[i].refresh))
break;
/* do not flood local system if file grows too fast */
if (p_count >= (4 * maxlines_persec * active_metrics[i].refresh))
break;
} /* while processing a log */
}
while (0); /* simple try realization */
if (FAIL == ret)
{
active_metrics[i].state = ITEM_STATE_NOTSUPPORTED;
zabbix_log(LOG_LEVEL_WARNING, "active check \"%s\" is not supported",
active_metrics[i].key);
process_value(server, port, CONFIG_HOSTNAME, active_metrics[i].key_orig, NULL,
&active_metrics[i].lastlogsize, &active_metrics[i].mtime,
NULL, NULL, NULL, NULL, 0);
}
}
/* special processing for eventlog */
else if (0 == strncmp(active_metrics[i].key, "eventlog[", 9))
{
ret = FAIL;
#ifdef _WINDOWS
do
{
/* simple try realization */
if (ZBX_COMMAND_WITH_PARAMS != parse_command(active_metrics[i].key, NULL, 0,
params, sizeof(params)))
{
break;
}
if (7 < num_param(params))
break;
if (0 != get_param(params, 1, filename, sizeof(filename)))
break;
if (0 != get_param(params, 2, pattern, sizeof(pattern)))
*pattern = '\0';
if (0 != get_param(params, 3, key_severity, sizeof(key_severity)))
*key_severity = '\0';
if (0 != get_param(params, 4, key_source, sizeof(key_source)))
*key_source = '\0';
if (0 != get_param(params, 5, key_logeventid, sizeof(key_logeventid)))
*key_logeventid = '\0';
if (0 != get_param(params, 6, maxlines_persec_str, sizeof(maxlines_persec_str)) ||
'\0' == *maxlines_persec_str)
maxlines_persec = CONFIG_MAX_LINES_PER_SECOND;
else if (MIN_VALUE_LINES > (maxlines_persec = atoi(maxlines_persec_str)) ||
MAX_VALUE_LINES < maxlines_persec)
break;
if (0 != get_param(params, 7, tmp, sizeof(tmp)))
*tmp = '\0';
if ('\0' == *tmp || 0 == strcmp(tmp, "all"))
active_metrics[i].skip_old_data = 0;
else if (0 != strcmp(tmp, "skip"))
break;
s_count = 0;
p_count = 0;
lastlogsize = active_metrics[i].lastlogsize;
versionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&versionInfo);
if (versionInfo.dwMajorVersion >= 6) /* Windows Vista, 7 or Server 2008 */
{
__try
{
if (SUCCEED != initialize_eventlog6(filename, &lastlogsize,
&eventlog6_firstid, &eventlog6_lastid,
&eventlog6_render_context, &eventlog6_query))
{
finalize_eventlog6(&eventlog6_render_context, &eventlog6_query);
break;
}
while (SUCCEED == (ret = process_eventlog6(filename, &lastlogsize,
×tamp, &provider, &source, &severity, &value,
&logeventid, &eventlog6_firstid, &eventlog6_lastid,
&eventlog6_render_context, &eventlog6_query,
&keywords, active_metrics[i].skip_old_data)))
{
active_metrics[i].skip_old_data = 0;
/* End of file. */
/* The eventlog could become empty, must save `lastlogsize'. */
if (NULL == value)
{
active_metrics[i].lastlogsize = lastlogsize;
break;
}
switch (severity)
{
case WINEVENT_LEVEL_LOG_ALWAYS:
case WINEVENT_LEVEL_INFO:
if (0 != (keywords &
WINEVENT_KEYWORD_AUDIT_FAILURE))
{
severity = ITEM_LOGTYPE_FAILURE_AUDIT;
strscpy(str_severity, AUDIT_FAILURE);
break;
}
else if (0 != (keywords &
WINEVENT_KEYWORD_AUDIT_SUCCESS))
{
severity = ITEM_LOGTYPE_SUCCESS_AUDIT;
strscpy(str_severity, AUDIT_SUCCESS);
break;
}
else
severity = ITEM_LOGTYPE_INFORMATION;
strscpy(str_severity, INFORMATION_TYPE);
break;
case WINEVENT_LEVEL_WARNING:
severity = ITEM_LOGTYPE_WARNING;
strscpy(str_severity, WARNING_TYPE);
break;
case WINEVENT_LEVEL_ERROR:
severity = ITEM_LOGTYPE_ERROR;
strscpy(str_severity, ERROR_TYPE);
break;
case WINEVENT_LEVEL_CRITICAL:
severity = ITEM_LOGTYPE_CRITICAL;
strscpy(str_severity, CRITICAL_TYPE);
break;
case WINEVENT_LEVEL_VERBOSE:
severity = ITEM_LOGTYPE_VERBOSE;
strscpy(str_severity, VERBOSE_TYPE);
break;
}
zbx_snprintf(str_logeventid, sizeof(str_logeventid), "%lu",
logeventid);
if (SUCCEED == regexp_match_ex(®exps, value, pattern, ZBX_CASE_SENSITIVE) &&
SUCCEED == regexp_match_ex(®exps, str_severity, key_severity,
ZBX_IGNORE_CASE) &&
SUCCEED == regexp_match_ex(®exps, provider, key_source,
ZBX_IGNORE_CASE) &&
SUCCEED == regexp_match_ex(®exps, str_logeventid,
key_logeventid, ZBX_CASE_SENSITIVE))
{
send_err = process_value(server, port, CONFIG_HOSTNAME,
active_metrics[i].key_orig, value, &lastlogsize,
NULL, ×tamp, provider, &severity, &logeventid, 1);
s_count++;
}
p_count++;
zbx_free(source);
zbx_free(provider);
zbx_free(value);
if (SUCCEED == send_err)
active_metrics[i].lastlogsize = lastlogsize;
else
{
/* buffer is full, stop processing active checks*/
/* till the buffer is cleared */
lastlogsize = active_metrics[i].lastlogsize;
goto ret;
}
/* do not flood Zabbix server if file grows too fast */
if (s_count >= (maxlines_persec * active_metrics[i].refresh))
break;
/* do not flood local system if file grows too fast */
if (p_count >= (4 * maxlines_persec * active_metrics[i].refresh))
break;
} /* while processing an eventlog */
finalize_eventlog6(&eventlog6_render_context, &eventlog6_query);
}
__except (DelayLoadDllExceptionFilter(GetExceptionInformation()))
{
zabbix_log(LOG_LEVEL_WARNING, "failed to process eventlog");
break;
}
}
else if (versionInfo.dwMajorVersion < 6) /* Windows versions before Vista */
{
while (SUCCEED == (ret = process_eventlog(filename, &lastlogsize,
×tamp, &source, &severity, &value, &logeventid,
active_metrics[i].skip_old_data)))
{
active_metrics[i].skip_old_data = 0;
/* End of file. */
/* The eventlog could become empty, must save `lastlogsize'. */
if (NULL == value)
{
active_metrics[i].lastlogsize = lastlogsize;
break;
}
switch (severity)
{
case EVENTLOG_SUCCESS:
case EVENTLOG_INFORMATION_TYPE:
severity = ITEM_LOGTYPE_INFORMATION;
strscpy(str_severity, INFORMATION_TYPE);
break;
case EVENTLOG_WARNING_TYPE:
severity = ITEM_LOGTYPE_WARNING;
strscpy(str_severity, WARNING_TYPE);
break;
case EVENTLOG_ERROR_TYPE:
severity = ITEM_LOGTYPE_ERROR;
strscpy(str_severity, ERROR_TYPE);
break;
case EVENTLOG_AUDIT_FAILURE:
severity = ITEM_LOGTYPE_FAILURE_AUDIT;
strscpy(str_severity, AUDIT_FAILURE);
break;
case EVENTLOG_AUDIT_SUCCESS:
severity = ITEM_LOGTYPE_SUCCESS_AUDIT;
strscpy(str_severity, AUDIT_SUCCESS);
break;
}
zbx_snprintf(str_logeventid, sizeof(str_logeventid), "%lu", logeventid);
if (SUCCEED == regexp_match_ex(®exps, value, pattern, ZBX_CASE_SENSITIVE) &&
SUCCEED == regexp_match_ex(®exps, str_severity, key_severity,
ZBX_IGNORE_CASE) &&
SUCCEED == regexp_match_ex(®exps, source, key_source,
ZBX_IGNORE_CASE) &&
SUCCEED == regexp_match_ex(®exps, str_logeventid,
key_logeventid, ZBX_CASE_SENSITIVE))
{
send_err = process_value(server, port, CONFIG_HOSTNAME,
active_metrics[i].key_orig, value, &lastlogsize,
NULL, ×tamp, source, &severity, &logeventid, 1);
s_count++;
}
p_count++;
zbx_free(source);
zbx_free(value);
if (SUCCEED == send_err)
active_metrics[i].lastlogsize = lastlogsize;
else
{
/* buffer is full, stop processing active checks */
/* till the buffer is cleared */
lastlogsize = active_metrics[i].lastlogsize;
goto ret;
}
/* do not flood Zabbix server if file grows too fast */
if (s_count >= (maxlines_persec * active_metrics[i].refresh))
break;
/* do not flood local system if file grows too fast */
if (p_count >= (4 * maxlines_persec * active_metrics[i].refresh))
break;
} /* while processing an eventlog */
}
break;
}
while (0); /* simple try realization */
#endif /* _WINDOWS */
if (FAIL == ret)
{
active_metrics[i].state = ITEM_STATE_NOTSUPPORTED;
zabbix_log(LOG_LEVEL_WARNING, "active check \"%s\" is not supported",
active_metrics[i].key);
process_value(server, port, CONFIG_HOSTNAME, active_metrics[i].key_orig, NULL,
&active_metrics[i].lastlogsize, NULL, NULL, NULL, NULL, NULL, 0);
}
}
int processOperator(Drawing d, char *op) {
int res = 0;
// Look for which operator it is and then process it
for (int i = 0; i < N_OPS_AVAILABLE; i++) {
if (strlen(op) == strlen(OPS_AVAILABLE[i]) && strcmp(op, OPS_AVAILABLE[i]) == 0) {
switch (i) {
case 0:
res = process_sum(d->stack);
break;
case 1:
res = process_subtraction(d->stack);
break;
case 2:
res = process_multiplication(d->stack);
break;
case 3:
res = process_division(d->stack);
break;
case 4:
res = process_pi(d->stack);
break;
case 5:
res = process_sin(d->stack);
break;
case 6:
res = process_cos(d->stack);
break;
case 7:
res = process_deg(d->stack);
break;
case 8:
res = process_cm(d->stack);
break;
case 9:
res = process_mm(d->stack);
break;
case 10:
res = process_pt(d->stack);
break;
case 11:
res = process_copy(d->stack);
break;
case 12:
res = process_translate(d->stack);
break;
case 13:
res = process_mtranslate(d->stack);
break;
case 14:
res = process_rotate(d->stack);
break;
case 15:
res = process_mrotate(d->stack);
break;
case 16:
res = process_line(d);
break;
case 17:
res = process_circle(d);
break;
case 18:
res = process_fillcircle(d);
break;
case 19:
res = process_show(d->stack);
break;
case 20:
res = process_tan(d->stack);
break;
case 21:
res = process_arcsin(d->stack);
break;
case 22:
res = process_arccos(d->stack);
break;
case 23:
res = process_arctan(d->stack);
break;
case 24:
res = process_eraseline(d);
break;
case 25:
res = process_e(d->stack);
break;
case 26:
res = process_lg(d->stack);
break;
case 27:
res = process_ln(d->stack);
break;
case 28:
res = process_log(d->stack);
break;
case 29:
res = process_abs(d->stack);
break;
default:
res = throw_error(op, PROCESSOR_ERROR_ILEGAL_OP);
break;
}
break;
}
}
return res;
}
