static int zbx_execute_script_on_agent(DC_HOST *host, const char *command, char **result,
char *error, size_t max_error_len)
{
const char *__function_name = "zbx_execute_script_on_agent";
int ret;
AGENT_RESULT agent_result;
char *param, *port = NULL;
DC_ITEM item;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
*error = '\0';
memset(&item, 0, sizeof(item));
memcpy(&item.host, host, sizeof(item.host));
if (SUCCEED != (ret = DCconfig_get_interface_by_type(&item.interface, host->hostid, INTERFACE_TYPE_AGENT)))
{
zbx_snprintf(error, max_error_len, "Whatap agent interface is not defined for host [%s]", host->host);
goto fail;
}
port = zbx_strdup(port, item.interface.port_orig);
substitute_simple_macros(NULL, NULL, NULL, NULL, &host->hostid, NULL, NULL, &port, MACRO_TYPE_COMMON, NULL, 0);
if (SUCCEED != (ret = is_ushort(port, &item.interface.port)))
{
zbx_snprintf(error, max_error_len, "Invalid port number [%s]", item.interface.port_orig);
goto fail;
}
param = zbx_dyn_escape_string(command, "\"");
item.key = zbx_dsprintf(item.key, "system.run[\"%s\",\"%s\"]", param, NULL == result ? "nowait" : "wait");
item.value_type = ITEM_VALUE_TYPE_TEXT;
zbx_free(param);
init_result(&agent_result);
alarm(CONFIG_TIMEOUT);
if (SUCCEED != (ret = get_value_agent(&item, &agent_result)))
{
if (ISSET_MSG(&agent_result))
zbx_strlcpy(error, agent_result.msg, max_error_len);
ret = FAIL;
}
else if (NULL != result && ISSET_TEXT(&agent_result))
*result = zbx_strdup(*result, agent_result.text);
alarm(0);
free_result(&agent_result);
zbx_free(item.key);
fail:
zbx_free(port);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
static int calcitem_parse_expression(DC_ITEM *dc_item, expression_t *exp,
char *error, int max_error_len)
{
const char *__function_name = "calcitem_parse_expression";
char *e, *f, *func = NULL, *params = NULL;
int functionid, exp_alloc = 128, exp_offset = 0, ret;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() expression:'%s'", __function_name, dc_item->params_orig);
assert(dc_item);
assert(exp);
exp->exp = zbx_malloc(exp->exp, exp_alloc);
for (e = dc_item->params_orig; '\0' != *e; e++)
{
if (NULL != strchr(" \t\r\n", *e))
continue;
f = e;
if (FAIL == parse_function(&e, &func, ¶ms))
{
e = f;
calcitem_exp_addchr(&exp->exp, &exp_alloc, &exp_offset, 128, *f);
continue;
}
else
e--;
functionid = calcitem_add_function(exp, func, params);
zabbix_log(LOG_LEVEL_DEBUG, "%s() functionid:%d function:'%s(%s)'",
__function_name, functionid, func, params);
func = NULL;
params = NULL;
zbx_snprintf_alloc(&exp->exp, &exp_alloc, &exp_offset, 16, "{%d}", functionid);
}
calcitem_exp_addchr(&exp->exp, &exp_alloc, &exp_offset, 1, '\0');
zabbix_log(LOG_LEVEL_DEBUG, "%s() expression:'%s'", __function_name, exp->exp);
if (FAIL == (ret = substitute_simple_macros(NULL, NULL, NULL, dc_item, NULL,
&exp->exp, MACRO_TYPE_ITEM_EXPRESSION, error, max_error_len)))
ret = NOTSUPPORTED;
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
/******************************************************************************
* *
* Function: zbx_ipmi_port_expand_macros *
* *
* Purpose: expands user macros in IPMI port value and converts the result to *
* to unsigned short value *
* *
* Parameters: hostid - [IN] the host identifier *
* port_orig - [IN] the original port value *
* port - [OUT] the resulting port value *
* error - [OUT] the error message *
* *
* Return value: SUCCEED - the value was converted successfully *
* FAIL - otherwise *
* *
******************************************************************************/
int zbx_ipmi_port_expand_macros(zbx_uint64_t hostid, const char *port_orig, unsigned short *port, char **error)
{
char *tmp;
int ret = SUCCEED;
tmp = zbx_strdup(NULL, port_orig);
substitute_simple_macros(NULL, NULL, NULL, NULL, &hostid, NULL, NULL, NULL, NULL,
&tmp, MACRO_TYPE_COMMON, NULL, 0);
if (FAIL == is_ushort(tmp, port) || 0 == *port)
{
*error = zbx_dsprintf(*error, "Invalid port value \"%s\"", port_orig);
ret = FAIL;
}
zbx_free(tmp);
return ret;
}
static int zbx_execute_ipmi_command(DC_HOST *host, const char *command, char *error, size_t max_error_len)
{
const char *__function_name = "zbx_execute_ipmi_command";
int val, ret;
char *port = NULL;
DC_ITEM item;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
*error = '\0';
memset(&item, 0, sizeof(item));
memcpy(&item.host, host, sizeof(item.host));
if (SUCCEED != (ret = DCconfig_get_interface_by_type(&item.interface, host->hostid, INTERFACE_TYPE_IPMI)))
{
zbx_snprintf(error, max_error_len, "IPMI interface is not defined for host [%s]", host->host);
goto fail;
}
port = zbx_strdup(port, item.interface.port_orig);
substitute_simple_macros(NULL, NULL, NULL, NULL, &host->hostid, NULL, NULL, &port, MACRO_TYPE_COMMON, NULL, 0);
if (SUCCEED != (ret = is_ushort(port, &item.interface.port)))
{
zbx_snprintf(error, max_error_len, "invalid port number [%s]", item.interface.port_orig);
goto fail;
}
if (SUCCEED == (ret = parse_ipmi_command(command, item.ipmi_sensor, &val, error, max_error_len)))
{
if (SUCCEED != (ret = set_ipmi_control_value(&item, val, error, max_error_len)))
ret = FAIL;
}
fail:
zbx_free(port);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
/******************************************************************************
* *
* Function: zbx_execute_script *
* *
* Purpose: executing user scripts or remote commands *
* *
* Return value: SUCCEED - processed successfully *
* FAIL - an error occurred *
* TIMEOUT_ERROR - a timeout occurred *
* *
* Comments: !!! always call 'zbx_script_clean' function after *
* 'zbx_execute_script' to clear allocated memory *
* *
******************************************************************************/
int zbx_execute_script(DC_HOST *host, zbx_script_t *script, char **result, char *error, size_t max_error_len)
{
const char *__function_name = "zbx_execute_script";
int ret = FAIL;
zbx_uint64_t groupid;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
*error = '\0';
switch (script->type)
{
case ZBX_SCRIPT_TYPE_CUSTOM_SCRIPT:
dos2unix(script->command); /* CR+LF (Windows) => LF (Unix) */
switch (script->execute_on)
{
case ZBX_SCRIPT_EXECUTE_ON_AGENT:
ret = zbx_execute_script_on_agent(host, script->command, result,
error, max_error_len);
break;
case ZBX_SCRIPT_EXECUTE_ON_SERVER:
ret = zbx_execute(script->command, result, error, max_error_len,
CONFIG_TRAPPER_TIMEOUT);
break;
default:
zbx_snprintf(error, max_error_len, "Invalid 'Execute on' option [%d]",
(int)script->execute_on);
}
break;
case ZBX_SCRIPT_TYPE_IPMI:
#ifdef HAVE_OPENIPMI
if (SUCCEED == (ret = zbx_execute_ipmi_command(host, script->command, error, max_error_len)))
{
if (NULL != result)
*result = zbx_strdup(*result, "IPMI command successfully executed");
}
#else
zbx_strlcpy(error, "Support for IPMI commands was not compiled in", max_error_len);
#endif
break;
case ZBX_SCRIPT_TYPE_SSH:
#ifdef HAVE_SSH2
substitute_simple_macros(NULL, NULL, NULL, NULL, &host->hostid, NULL, NULL,
&script->publickey, MACRO_TYPE_COMMON, NULL, 0);
substitute_simple_macros(NULL, NULL, NULL, NULL, &host->hostid, NULL, NULL,
&script->privatekey, MACRO_TYPE_COMMON, NULL, 0);
/* break; is not missing here */
#else
zbx_strlcpy(error, "Support for SSH script was not compiled in", max_error_len);
break;
#endif
case ZBX_SCRIPT_TYPE_TELNET:
substitute_simple_macros(NULL, NULL, NULL, NULL, &host->hostid, NULL, NULL,
&script->username, MACRO_TYPE_COMMON, NULL, 0);
substitute_simple_macros(NULL, NULL, NULL, NULL, &host->hostid, NULL, NULL,
&script->password, MACRO_TYPE_COMMON, NULL, 0);
ret = zbx_execute_script_on_terminal(host, script, result, error, max_error_len);
break;
case ZBX_SCRIPT_TYPE_GLOBAL_SCRIPT:
if (SUCCEED != DBget_script_by_scriptid(script->scriptid, script, &groupid))
{
zbx_snprintf(error, max_error_len,
"Unknown Script ID [" ZBX_FS_UI64 "]", script->scriptid);
break;
}
if (SUCCEED == check_script_permissions(groupid, host->hostid, error, max_error_len))
{
substitute_simple_macros(NULL, NULL, NULL, NULL, NULL, host, NULL,
&script->command, MACRO_TYPE_SCRIPT, NULL, 0);
ret = zbx_execute_script(host, script, result, error, max_error_len); /* recursion */
}
break;
default:
zbx_snprintf(error, max_error_len, "Invalid command type [%d]", (int)script->type);
}
if (SUCCEED != ret && NULL != result)
*result = zbx_strdup(*result, "");
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
static int zbx_execute_script_on_terminal(DC_HOST *host, zbx_script_t *script, char **result,
char *error, size_t max_error_len)
{
const char *__function_name = "zbx_execute_script_on_terminal";
int ret;
AGENT_RESULT agent_result;
DC_ITEM item;
int (*function)();
#ifdef HAVE_SSH2
assert(ZBX_SCRIPT_TYPE_SSH == script->type || ZBX_SCRIPT_TYPE_TELNET == script->type);
#else
assert(ZBX_SCRIPT_TYPE_TELNET == script->type);
#endif
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
*error = '\0';
memset(&item, 0, sizeof(item));
memcpy(&item.host, host, sizeof(item.host));
if (SUCCEED != (ret = DCconfig_get_interface_by_type(&item.interface, host->hostid, INTERFACE_TYPE_AGENT)))
{
zbx_snprintf(error, max_error_len, "Whatap agent interface is not defined for host [%s]", host->host);
goto fail;
}
switch (script->type)
{
case ZBX_SCRIPT_TYPE_SSH:
item.authtype = script->authtype;
item.publickey = script->publickey;
item.privatekey = script->privatekey;
/* break; is not missing here */
case ZBX_SCRIPT_TYPE_TELNET:
item.username = script->username;
item.password = script->password;
break;
}
substitute_simple_macros(NULL, NULL, NULL, NULL, &host->hostid, NULL, NULL,
&script->port, MACRO_TYPE_COMMON, NULL, 0);
if ('\0' != *script->port && SUCCEED != (ret = is_ushort(script->port, NULL)))
{
zbx_snprintf(error, max_error_len, "Invalid port number [%s]", script->port);
goto fail;
}
#ifdef HAVE_SSH2
if (ZBX_SCRIPT_TYPE_SSH == script->type)
{
item.key = zbx_dsprintf(item.key, "ssh.run[,,%s]", script->port);
function = get_value_ssh;
}
else
{
#endif
item.key = zbx_dsprintf(item.key, "telnet.run[,,%s]", script->port);
function = get_value_telnet;
#ifdef HAVE_SSH2
}
#endif
item.value_type = ITEM_VALUE_TYPE_TEXT;
item.params = zbx_strdup(item.params, script->command);
init_result(&agent_result);
alarm(CONFIG_TIMEOUT);
if (SUCCEED != (ret = function(&item, &agent_result)))
{
if (ISSET_MSG(&agent_result))
zbx_strlcpy(error, agent_result.msg, max_error_len);
ret = FAIL;
}
else if (NULL != result && ISSET_TEXT(&agent_result))
*result = zbx_strdup(*result, agent_result.text);
alarm(0);
free_result(&agent_result);
zbx_free(item.params);
zbx_free(item.key);
fail:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
static int calcitem_parse_expression(DC_ITEM *dc_item, expression_t *exp, char *error, int max_error_len)
{
const char *__function_name = "calcitem_parse_expression";
char *e, *f, *func = NULL, *params = NULL;
size_t exp_alloc = 128, exp_offset = 0, len;
int functionid, ret;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() expression:'%s'", __function_name, dc_item->params);
assert(dc_item);
assert(exp);
exp->exp = zbx_malloc(exp->exp, exp_alloc);
for (e = dc_item->params; '\0' != *e; e++)
{
if (SUCCEED != is_function_char(*e))
{
zbx_chrcpy_alloc(&exp->exp, &exp_alloc, &exp_offset, *e);
continue;
}
if ((0 == strncmp("and", e, len = 3) || 0 == strncmp("not", e, 3) || 0 == strncmp("or", e, len = 2)) &&
NULL != strchr("()" ZBX_WHITESPACE, e[len]))
{
zbx_strncpy_alloc(&exp->exp, &exp_alloc, &exp_offset, e, len);
e += len - 1;
continue;
}
f = e;
if (SUCCEED != parse_function(&e, &func, ¶ms))
{
e = f;
zbx_chrcpy_alloc(&exp->exp, &exp_alloc, &exp_offset, *f);
continue;
}
else
e--;
functionid = calcitem_add_function(exp, func, params);
zabbix_log(LOG_LEVEL_DEBUG, "%s() functionid:%d function:'%s(%s)'",
__function_name, functionid, func, params);
func = NULL;
params = NULL;
zbx_snprintf_alloc(&exp->exp, &exp_alloc, &exp_offset, "{%d}", functionid);
}
zabbix_log(LOG_LEVEL_DEBUG, "%s() expression:'%s'", __function_name, exp->exp);
if (FAIL == (ret = substitute_simple_macros(NULL, NULL, NULL, NULL, NULL, &dc_item->host, NULL, NULL,
&exp->exp, MACRO_TYPE_ITEM_EXPRESSION, error, max_error_len)))
ret = NOTSUPPORTED;
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
/******************************************************************************
* *
* Function: process_httptests *
* *
* Purpose: process httptests *
* *
* Parameters: now - current timestamp *
* *
* Return value: *
* *
* Author: Alexei Vladishev *
* *
* Comments: always SUCCEED *
* *
******************************************************************************/
int process_httptests(int httppoller_num, int now)
{
const char *__function_name = "process_httptests";
DB_RESULT result;
DB_ROW row;
zbx_httptest_t httptest;
DC_HOST host;
int httptests_count = 0;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
/* create macro cache to use in http tests */
zbx_vector_ptr_pair_create(&httptest.macros);
result = DBselect(
"select h.hostid,h.host,h.name,t.httptestid,t.name,t.variables,t.agent,"
"t.authentication,t.http_user,t.http_password,t.http_proxy,t.retries"
" from httptest t,hosts h"
" where t.hostid=h.hostid"
" and t.nextcheck<=%d"
" and " ZBX_SQL_MOD(t.httptestid,%d) "=%d"
" and t.status=%d"
" and h.proxy_hostid is null"
" and h.status=%d"
" and (h.maintenance_status=%d or h.maintenance_type=%d)"
ZBX_SQL_NODE,
now,
CONFIG_HTTPPOLLER_FORKS, httppoller_num - 1,
HTTPTEST_STATUS_MONITORED,
HOST_STATUS_MONITORED,
HOST_MAINTENANCE_STATUS_OFF, MAINTENANCE_TYPE_NORMAL,
DBand_node_local("t.httptestid"));
while (NULL != (row = DBfetch(result)))
{
ZBX_STR2UINT64(host.hostid, row[0]);
strscpy(host.host, row[1]);
strscpy(host.name, row[2]);
ZBX_STR2UINT64(httptest.httptest.httptestid, row[3]);
httptest.httptest.name = row[4];
httptest.httptest.variables = zbx_strdup(NULL, row[5]);
substitute_simple_macros(NULL, NULL, NULL, NULL, NULL, &host, NULL,
&httptest.httptest.variables, MACRO_TYPE_HTTPTEST_FIELD, NULL, 0);
httptest.httptest.agent = zbx_strdup(NULL, row[6]);
substitute_simple_macros(NULL, NULL, NULL, NULL, &host.hostid, NULL, NULL,
&httptest.httptest.agent, MACRO_TYPE_COMMON, NULL, 0);
if (HTTPTEST_AUTH_NONE != (httptest.httptest.authentication = atoi(row[7])))
{
httptest.httptest.http_user = zbx_strdup(NULL, row[8]);
substitute_simple_macros(NULL, NULL, NULL, NULL, &host.hostid, NULL, NULL,
&httptest.httptest.http_user, MACRO_TYPE_COMMON, NULL, 0);
httptest.httptest.http_password = zbx_strdup(NULL, row[9]);
substitute_simple_macros(NULL, NULL, NULL, NULL, &host.hostid, NULL, NULL,
&httptest.httptest.http_password, MACRO_TYPE_COMMON, NULL, 0);
}
httptest.httptest.http_proxy = zbx_strdup(NULL, row[10]);
substitute_simple_macros(NULL, NULL, NULL, NULL, &host.hostid, NULL, NULL,
&httptest.httptest.http_proxy, MACRO_TYPE_COMMON, NULL, 0);
httptest.httptest.retries = atoi(row[11]);
/* add httptest varriables to the current test macro cache */
http_process_variables(&httptest, httptest.httptest.variables, NULL, NULL);
process_httptest(&host, &httptest);
zbx_free(httptest.httptest.http_proxy);
if (HTTPTEST_AUTH_NONE != httptest.httptest.authentication)
{
zbx_free(httptest.httptest.http_password);
zbx_free(httptest.httptest.http_user);
}
zbx_free(httptest.httptest.agent);
zbx_free(httptest.httptest.variables);
/* clear the macro cache used in this http test */
httptest_remove_macros(&httptest);
httptests_count++; /* performance metric */
}
/* destroy the macro cache used in http tests */
zbx_vector_ptr_pair_destroy(&httptest.macros);
DBfree_result(result);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
return httptests_count;
}
/******************************************************************************
* *
* Function: lld_filter_load *
* *
* Purpose: loads lld filter data *
* *
* Parameters: filter - [IN] the lld filter *
* lld_ruleid - [IN] the lld rule id *
* error - [OUT] the error description *
* *
******************************************************************************/
static int lld_filter_load(lld_filter_t *filter, zbx_uint64_t lld_ruleid, char **error)
{
DB_RESULT result;
DB_ROW row;
lld_condition_t *condition;
DC_ITEM item;
int errcode, ret = SUCCEED;
DCconfig_get_items_by_itemids(&item, &lld_ruleid, &errcode, 1);
if (SUCCEED != errcode)
{
*error = zbx_dsprintf(*error, "Invalid discovery rule ID [" ZBX_FS_UI64 "].",
lld_ruleid);
ret = FAIL;
goto out;
}
result = DBselect(
"select item_conditionid,macro,value"
" from item_condition"
" where itemid=" ZBX_FS_UI64,
lld_ruleid);
while (NULL != (row = DBfetch(result)))
{
condition = zbx_malloc(NULL, sizeof(lld_condition_t));
ZBX_STR2UINT64(condition->id, row[0]);
condition->macro = zbx_strdup(NULL, row[1]);
condition->regexp = zbx_strdup(NULL, row[2]);
zbx_vector_ptr_create(&condition->regexps);
zbx_vector_ptr_append(&filter->conditions, condition);
if ('@' == *condition->regexp)
{
DCget_expressions_by_name(&condition->regexps, condition->regexp + 1);
if (0 == condition->regexps.values_num)
{
*error = zbx_dsprintf(*error, "Global regular expression \"%s\" does not exist.",
condition->regexp + 1);
ret = FAIL;
break;
}
}
else
{
substitute_simple_macros(NULL, NULL, NULL, NULL, NULL, NULL, &item, NULL,
&condition->regexp, MACRO_TYPE_LLD_FILTER, NULL, 0);
}
}
DBfree_result(result);
if (SUCCEED != ret)
lld_conditions_free(&filter->conditions);
else if (CONDITION_EVAL_TYPE_AND_OR == filter->evaltype)
zbx_vector_ptr_sort(&filter->conditions, lld_condition_compare_by_macro);
out:
DCconfig_clean_items(&item, &errcode, 1);
return ret;
}
/******************************************************************************
* *
* Function: lld_process_discovery_rule *
* *
* Purpose: add or update items, triggers and graphs for discovery item *
* *
* Parameters: lld_ruleid - [IN] discovery item identificator from database *
* value - [IN] received value from agent *
* *
******************************************************************************/
void lld_process_discovery_rule(zbx_uint64_t lld_ruleid, char *value, zbx_timespec_t *ts)
{
const char *__function_name = "lld_process_discovery_rule";
DB_RESULT result;
DB_ROW row;
zbx_uint64_t hostid = 0;
char *discovery_key = NULL, *filter = NULL, *error = NULL, *db_error = NULL, *error_esc;
unsigned char state = 0;
unsigned short lifetime;
zbx_vector_ptr_t lld_rows;
char *sql = NULL;
size_t sql_alloc = 128, sql_offset = 0;
const char *sql_start = "update items set ", *sql_continue = ",";
zabbix_log(LOG_LEVEL_DEBUG, "In %s() itemid:" ZBX_FS_UI64, __function_name, lld_ruleid);
zbx_vector_ptr_create(&lld_rows);
sql = zbx_malloc(sql, sql_alloc);
result = DBselect(
"select hostid,key_,state,filter,error,lifetime"
" from items"
" where itemid=" ZBX_FS_UI64,
lld_ruleid);
if (NULL != (row = DBfetch(result)))
{
char *lifetime_str;
ZBX_STR2UINT64(hostid, row[0]);
discovery_key = zbx_strdup(discovery_key, row[1]);
state = (unsigned char)atoi(row[2]);
filter = zbx_strdup(filter, row[3]);
db_error = zbx_strdup(db_error, row[4]);
lifetime_str = zbx_strdup(NULL, row[5]);
substitute_simple_macros(NULL, NULL, NULL, NULL, &hostid, NULL, NULL,
&lifetime_str, MACRO_TYPE_COMMON, NULL, 0);
if (SUCCEED != is_ushort(lifetime_str, &lifetime))
{
zabbix_log(LOG_LEVEL_WARNING, "cannot process lost resources for the discovery rule \"%s:%s\":"
" \"%s\" is not a valid value",
zbx_host_string(hostid), discovery_key, lifetime_str);
lifetime = 3650; /* max value for the field */
}
zbx_free(lifetime_str);
}
else
zabbix_log(LOG_LEVEL_WARNING, "invalid discovery rule ID [" ZBX_FS_UI64 "]", lld_ruleid);
DBfree_result(result);
if (0 == hostid)
goto clean;
if (SUCCEED != lld_rows_get(value, filter, &lld_rows, &error))
goto error;
error = zbx_strdup(error, "");
lld_update_items(hostid, lld_ruleid, &lld_rows, &error, lifetime, ts->sec);
lld_update_triggers(hostid, lld_ruleid, &lld_rows, &error);
lld_update_graphs(hostid, lld_ruleid, &lld_rows, &error);
lld_update_hosts(lld_ruleid, &lld_rows, &error, lifetime, ts->sec);
if (ITEM_STATE_NOTSUPPORTED == state)
{
zabbix_log(LOG_LEVEL_WARNING, "discovery rule [" ZBX_FS_UI64 "][%s] became supported",
lld_ruleid, zbx_host_key_string(lld_ruleid));
add_event(0, EVENT_SOURCE_INTERNAL, EVENT_OBJECT_LLDRULE, lld_ruleid, ts, ITEM_STATE_NORMAL,
NULL, NULL, 0, 0);
process_events();
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "%sstate=%d", sql_start, ITEM_STATE_NORMAL);
sql_start = sql_continue;
}
error:
if (NULL != error && 0 != strcmp(error, db_error))
{
error_esc = DBdyn_escape_string_len(error, ITEM_ERROR_LEN);
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, "%serror='%s'", sql_start, error_esc);
sql_start = sql_continue;
zbx_free(error_esc);
}
if (sql_start == sql_continue)
{
zbx_snprintf_alloc(&sql, &sql_alloc, &sql_offset, " where itemid=" ZBX_FS_UI64, lld_ruleid);
DBbegin();
DBexecute("%s", sql);
DBcommit();
}
clean:
zbx_free(error);
zbx_free(db_error);
zbx_free(filter);
zbx_free(discovery_key);
zbx_free(sql);
zbx_vector_ptr_clean(&lld_rows, (zbx_mem_free_func_t)lld_row_free);
zbx_vector_ptr_destroy(&lld_rows);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
/******************************************************************************
* *
* Function: get_values *
* *
* Purpose: retrieve values of metrics from monitored hosts *
* *
* Parameters: *
* *
* Return value: *
* *
* Author: Alexei Vladishev *
* *
* Comments: always SUCCEED *
* *
******************************************************************************/
static int get_values(unsigned char poller_type)
{
const char *__function_name = "get_values";
DC_ITEM items[MAX_REACHABLE_ITEMS];
AGENT_RESULT agent;
zbx_uint64_t *ids = NULL, *snmpids = NULL, *ipmiids = NULL;
int ids_alloc = 0, snmpids_alloc = 0, ipmiids_alloc = 0,
ids_num = 0, snmpids_num = 0, ipmiids_num = 0,
i, now, num, res;
static char *key = NULL, *ipmi_ip = NULL, *params = NULL,
*username = NULL, *publickey = NULL, *privatekey = NULL,
*password = NULL, *snmp_community = NULL, *snmp_oid = NULL,
*snmpv3_securityname = NULL, *snmpv3_authpassphrase = NULL,
*snmpv3_privpassphrase = NULL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
num = DCconfig_get_poller_items(poller_type, items, ZBX_POLLER_TYPE_UNREACHABLE != poller_type
? MAX_REACHABLE_ITEMS : MAX_UNREACHABLE_ITEMS);
for (i = 0; i < num; i++)
{
zbx_free(key);
key = strdup(items[i].key_orig);
substitute_simple_macros(NULL, NULL, NULL, &items[i], NULL,
&key, MACRO_TYPE_ITEM_KEY, NULL, 0);
items[i].key = key;
switch (items[i].type)
{
case ITEM_TYPE_SNMPv3:
zbx_free(snmpv3_securityname);
zbx_free(snmpv3_authpassphrase);
zbx_free(snmpv3_privpassphrase);
snmpv3_securityname = strdup(items[i].snmpv3_securityname_orig);
snmpv3_authpassphrase = strdup(items[i].snmpv3_authpassphrase_orig);
snmpv3_privpassphrase = strdup(items[i].snmpv3_privpassphrase_orig);
substitute_simple_macros(NULL, NULL, NULL, &items[i], NULL,
&snmpv3_securityname, MACRO_TYPE_ITEM_FIELD, NULL, 0);
substitute_simple_macros(NULL, NULL, NULL, &items[i], NULL,
&snmpv3_authpassphrase, MACRO_TYPE_ITEM_FIELD, NULL, 0);
substitute_simple_macros(NULL, NULL, NULL, &items[i], NULL,
&snmpv3_privpassphrase, MACRO_TYPE_ITEM_FIELD, NULL, 0);
items[i].snmpv3_securityname = snmpv3_securityname;
items[i].snmpv3_authpassphrase = snmpv3_authpassphrase;
items[i].snmpv3_privpassphrase = snmpv3_privpassphrase;
case ITEM_TYPE_SNMPv1:
case ITEM_TYPE_SNMPv2c:
zbx_free(snmp_community);
zbx_free(snmp_oid);
snmp_community = strdup(items[i].snmp_community_orig);
snmp_oid = strdup(items[i].snmp_oid_orig);
substitute_simple_macros(NULL, NULL, NULL, &items[i], NULL,
&snmp_community, MACRO_TYPE_ITEM_FIELD, NULL, 0);
substitute_simple_macros(NULL, NULL, NULL, &items[i], NULL,
&snmp_oid, MACRO_TYPE_ITEM_FIELD, NULL, 0);
items[i].snmp_community = snmp_community;
items[i].snmp_oid = snmp_oid;
break;
case ITEM_TYPE_IPMI:
zbx_free(ipmi_ip);
ipmi_ip = strdup(items[i].host.ipmi_ip_orig);
substitute_simple_macros(NULL, NULL, NULL, &items[i], NULL,
&ipmi_ip, MACRO_TYPE_HOST_IPMI_IP, NULL, 0);
items[i].host.ipmi_ip = ipmi_ip;
break;
case ITEM_TYPE_DB_MONITOR:
zbx_free(params);
params = strdup(items[i].params_orig);
substitute_simple_macros(NULL, NULL, NULL, &items[i], NULL,
¶ms, MACRO_TYPE_ITEM_FIELD, NULL, 0);
items[i].params = params;
break;
case ITEM_TYPE_SSH:
zbx_free(username);
zbx_free(publickey);
zbx_free(privatekey);
zbx_free(password);
zbx_free(params);
username = strdup(items[i].username_orig);
publickey = strdup(items[i].publickey_orig);
privatekey = strdup(items[i].privatekey_orig);
password = strdup(items[i].password_orig);
params = strdup(items[i].params_orig);
substitute_simple_macros(NULL, NULL, NULL, &items[i], NULL,
&username, MACRO_TYPE_ITEM_FIELD, NULL, 0);
substitute_simple_macros(NULL, NULL, NULL, &items[i], NULL,
&publickey, MACRO_TYPE_ITEM_FIELD, NULL, 0);
substitute_simple_macros(NULL, NULL, NULL, &items[i], NULL,
&privatekey, MACRO_TYPE_ITEM_FIELD, NULL, 0);
substitute_simple_macros(NULL, NULL, NULL, &items[i], NULL,
&password, MACRO_TYPE_ITEM_FIELD, NULL, 0);
substitute_simple_macros(NULL, NULL, NULL, &items[i], NULL,
¶ms, MACRO_TYPE_ITEM_FIELD, NULL, 0);
items[i].username = username;
items[i].publickey = publickey;
items[i].privatekey = privatekey;
items[i].password = password;
items[i].params = params;
break;
case ITEM_TYPE_TELNET:
zbx_free(username);
zbx_free(password);
zbx_free(params);
username = strdup(items[i].username_orig);
password = strdup(items[i].password_orig);
params = strdup(items[i].params_orig);
substitute_simple_macros(NULL, NULL, NULL, &items[i], NULL,
&username, MACRO_TYPE_ITEM_FIELD, NULL, 0);
substitute_simple_macros(NULL, NULL, NULL, &items[i], NULL,
&password, MACRO_TYPE_ITEM_FIELD, NULL, 0);
substitute_simple_macros(NULL, NULL, NULL, &items[i], NULL,
¶ms, MACRO_TYPE_ITEM_FIELD, NULL, 0);
items[i].username = username;
items[i].password = password;
items[i].params = params;
break;
}
/* Skip unreachable hosts but do not break the loop. */
switch (items[i].type)
{
case ITEM_TYPE_ZABBIX:
if (SUCCEED == uint64_array_exists(ids, ids_num, items[i].host.hostid))
{
DCrequeue_unreachable_item(items[i].itemid);
zabbix_log(LOG_LEVEL_DEBUG, "Zabbix Host " ZBX_FS_UI64 " is unreachable. Skipping [%s]",
items[i].host.hostid, items[i].key_orig);
continue;
}
break;
case ITEM_TYPE_SNMPv1:
case ITEM_TYPE_SNMPv2c:
case ITEM_TYPE_SNMPv3:
if (SUCCEED == uint64_array_exists(snmpids, snmpids_num, items[i].host.hostid))
{
DCrequeue_unreachable_item(items[i].itemid);
zabbix_log(LOG_LEVEL_DEBUG, "SNMP Host " ZBX_FS_UI64 " is unreachable. Skipping [%s]",
items[i].host.hostid, items[i].key_orig);
continue;
}
break;
case ITEM_TYPE_IPMI:
if (SUCCEED == uint64_array_exists(ipmiids, ipmiids_num, items[i].host.hostid))
{
DCrequeue_unreachable_item(items[i].itemid);
zabbix_log(LOG_LEVEL_DEBUG, "IPMI Host " ZBX_FS_UI64 " is unreachable. Skipping [%s]",
items[i].host.hostid, items[i].key_orig);
continue;
}
break;
default:
/* nothing to do */;
}
init_result(&agent);
res = get_value(&items[i], &agent);
now = time(NULL);
if (res == SUCCEED)
{
activate_host(&items[i], now);
dc_add_history(items[i].itemid, items[i].value_type, &agent, now,
ITEM_STATUS_ACTIVE, NULL, 0, NULL, 0, 0, 0, 0);
DCrequeue_reachable_item(items[i].itemid, ITEM_STATUS_ACTIVE, now);
}
else if (res == NOTSUPPORTED || res == AGENT_ERROR)
{
activate_host(&items[i], now);
dc_add_history(items[i].itemid, items[i].value_type, NULL, now,
ITEM_STATUS_NOTSUPPORTED, agent.msg, 0, NULL, 0, 0, 0, 0);
DCrequeue_reachable_item(items[i].itemid, ITEM_STATUS_NOTSUPPORTED, now);
}
else if (res == NETWORK_ERROR)
{
deactivate_host(&items[i], now, agent.msg);
switch (items[i].type)
{
case ITEM_TYPE_ZABBIX:
uint64_array_add(&ids, &ids_alloc, &ids_num, items[i].host.hostid, 1);
break;
case ITEM_TYPE_SNMPv1:
case ITEM_TYPE_SNMPv2c:
case ITEM_TYPE_SNMPv3:
uint64_array_add(&snmpids, &snmpids_alloc, &snmpids_num, items[i].host.hostid, 1);
break;
case ITEM_TYPE_IPMI:
uint64_array_add(&ipmiids, &ipmiids_alloc, &ipmiids_num, items[i].host.hostid, 1);
break;
default:
/* nothing to do */;
}
DCrequeue_unreachable_item(items[i].itemid);
}
else
{
zbx_error("unknown response code returned: %d", res);
assert(0);
}
free_result(&agent);
}
zbx_free(key);
zbx_free(ipmi_ip);
zbx_free(params);
zbx_free(username);
zbx_free(publickey);
zbx_free(privatekey);
zbx_free(password);
zbx_free(snmp_community);
zbx_free(snmp_oid);
zbx_free(snmpv3_securityname);
zbx_free(snmpv3_authpassphrase);
zbx_free(snmpv3_privpassphrase);
zbx_free(ids);
zbx_free(snmpids);
zbx_free(ipmiids);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
return num;
}
/******************************************************************************
* *
* Function: execute_script *
* *
* Purpose: executing command *
* *
* Parameters: *
* *
* Return value: SUCCEED - processed successfully *
* FAIL - an error occurred *
* *
* Author: Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static int execute_script(zbx_uint64_t scriptid, zbx_uint64_t hostid, char **result)
{
char *p, *command, error[MAX_STRING_LEN];
int ret = FAIL;
DC_HOST host;
#ifdef HAVE_OPENIPMI
DB_RESULT db_result;
DB_ROW db_row;
DC_ITEM item;
int val;
#endif
zabbix_log(LOG_LEVEL_DEBUG, "In execute_script() scriptid:" ZBX_FS_UI64
" hostid:" ZBX_FS_UI64, scriptid, hostid);
if (FAIL == DCget_host_by_hostid(&host, hostid))
{
*result = zbx_dsprintf(*result, "NODE %d: Unknown Host ID [" ZBX_FS_UI64 "]",
CONFIG_NODEID, hostid);
return ret;
}
if (NULL == (command = get_command_by_scriptid(scriptid)))
{
*result = zbx_dsprintf(*result, "NODE %d: Unknown Script ID [" ZBX_FS_UI64 "]",
CONFIG_NODEID, scriptid);
return ret;
}
substitute_simple_macros(NULL, NULL, &host, NULL, NULL,
&command, MACRO_TYPE_SCRIPT, NULL, 0);
zabbix_log(LOG_LEVEL_WARNING, "NODE %d: Executing command: '%s'",
CONFIG_NODEID, command);
p = command;
while (*p == ' ' && *p != '\0')
p++;
#ifdef HAVE_OPENIPMI
if (0 == strncmp(p, "IPMI", 4))
{
db_result = DBselect(
"select hostid,host,useip,ip,dns,port,useipmi,ipmi_ip,ipmi_port,ipmi_authtype,"
"ipmi_privilege,ipmi_username,ipmi_password"
" from hosts"
" where hostid=" ZBX_FS_UI64
DB_NODE,
hostid,
DBnode_local("hostid"));
if (NULL != (db_row = DBfetch(db_result)))
{
memset(&item, 0, sizeof(item));
ZBX_STR2UINT64(item.host.hostid, db_row[0]);
zbx_strlcpy(item.host.host, db_row[1], sizeof(item.host.host));
item.host.useip = (unsigned char)atoi(db_row[2]);
zbx_strlcpy(item.host.ip, db_row[3], sizeof(item.host.ip));
zbx_strlcpy(item.host.dns, db_row[4], sizeof(item.host.dns));
item.host.port = (unsigned short)atoi(db_row[5]);
if (1 == atoi(db_row[6]))
{
zbx_strlcpy(item.host.ipmi_ip_orig, db_row[7], sizeof(item.host.ipmi_ip));
item.host.ipmi_port = (unsigned short)atoi(db_row[8]);
item.host.ipmi_authtype = atoi(db_row[9]);
item.host.ipmi_privilege = atoi(db_row[10]);
zbx_strlcpy(item.host.ipmi_username, db_row[11], sizeof(item.host.ipmi_username));
zbx_strlcpy(item.host.ipmi_password, db_row[12], sizeof(item.host.ipmi_password));
}
if (SUCCEED == (ret = parse_ipmi_command(p, item.ipmi_sensor, &val)))
{
if (SUCCEED == (ret = set_ipmi_control_value(&item, val, error, sizeof(error))))
{
*result = zbx_dsprintf(*result, "NODE %d: IPMI command successfully executed",
CONFIG_NODEID);
}
else
{
*result = zbx_dsprintf(*result, "NODE %d: Cannot execute IPMI command: %s",
CONFIG_NODEID, error);
}
}
else
{
*result = zbx_dsprintf(*result, "NODE %d: Cannot parse IPMI command",
CONFIG_NODEID);
}
}
else
{
*result = zbx_dsprintf(*result, "NODE %d: Unknown Host ID [" ZBX_FS_UI64 "]",
CONFIG_NODEID, hostid);
}
DBfree_result(db_result);
}
else
{
#endif /* HAVE_OPENIPMI */
if (SUCCEED != (ret = zbx_execute(p, result, error, sizeof(error), CONFIG_TRAPPER_TIMEOUT)))
*result = zbx_dsprintf(*result, "NODE %d: Cannot execute command: %s", CONFIG_NODEID, error);
#ifdef HAVE_OPENIPMI
}
#endif
zbx_free(command);
return ret;
}
/******************************************************************************
* *
* Function: discover_service *
* *
* Purpose: check if service is available and update database *
* *
* Parameters: service type, ip address, port number *
* *
* Author: Alexei Vladishev *
* *
******************************************************************************/
static int discover_service(DB_DCHECK *dcheck, char *ip, int port, char *value)
{
const char *__function_name = "discover_service";
int ret = SUCCEED;
char key[MAX_STRING_LEN], error[ITEM_ERROR_LEN_MAX];
const char *service = NULL;
AGENT_RESULT result;
DC_ITEM item;
ZBX_FPING_HOST host;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
init_result(&result);
*value = '\0';
switch (dcheck->type)
{
case SVC_SSH:
service = "ssh";
break;
case SVC_LDAP:
service = "ldap";
break;
case SVC_SMTP:
service = "smtp";
break;
case SVC_FTP:
service = "ftp";
break;
case SVC_HTTP:
service = "http";
break;
case SVC_POP:
service = "pop";
break;
case SVC_NNTP:
service = "nntp";
break;
case SVC_IMAP:
service = "imap";
break;
case SVC_TCP:
service = "tcp";
break;
case SVC_HTTPS:
service = "https";
break;
case SVC_TELNET:
service = "telnet";
break;
case SVC_AGENT:
case SVC_SNMPv1:
case SVC_SNMPv2c:
case SVC_SNMPv3:
case SVC_ICMPPING:
break;
default:
ret = FAIL;
break;
}
if (SUCCEED == ret)
{
alarm(CONFIG_TIMEOUT);
switch (dcheck->type)
{
/* simple checks */
case SVC_SSH:
case SVC_LDAP:
case SVC_SMTP:
case SVC_FTP:
case SVC_HTTP:
case SVC_POP:
case SVC_NNTP:
case SVC_IMAP:
case SVC_TCP:
case SVC_HTTPS:
case SVC_TELNET:
zbx_snprintf(key, sizeof(key), "net.tcp.service[%s,%s,%d]", service, ip, port);
if (SUCCEED != process(key, 0, &result) || NULL == GET_UI64_RESULT(&result) ||
0 == result.ui64)
{
ret = FAIL;
}
break;
/* agent and SNMP checks */
case SVC_AGENT:
case SVC_SNMPv1:
case SVC_SNMPv2c:
case SVC_SNMPv3:
memset(&item, 0, sizeof(DC_ITEM));
strscpy(item.key_orig, dcheck->key_);
item.key = item.key_orig;
item.interface.useip = 1;
item.interface.addr = ip;
item.interface.port = port;
item.value_type = ITEM_VALUE_TYPE_STR;
switch (dcheck->type)
{
case SVC_SNMPv1:
item.type = ITEM_TYPE_SNMPv1;
break;
case SVC_SNMPv2c:
item.type = ITEM_TYPE_SNMPv2c;
break;
case SVC_SNMPv3:
item.type = ITEM_TYPE_SNMPv3;
break;
default:
item.type = ITEM_TYPE_ZABBIX;
break;
}
if (SVC_AGENT == dcheck->type)
{
if (SUCCEED == get_value_agent(&item, &result) && NULL != GET_STR_RESULT(&result))
zbx_strlcpy(value, result.str, DSERVICE_VALUE_LEN_MAX);
else
ret = FAIL;
}
else
#ifdef HAVE_SNMP
{
item.snmp_community = strdup(dcheck->snmp_community);
item.snmp_oid = strdup(dcheck->key_);
substitute_simple_macros(NULL, NULL, NULL, NULL, NULL, NULL,
&item.snmp_community, MACRO_TYPE_ITEM_FIELD, NULL, 0);
substitute_key_macros(&item.snmp_oid, NULL, NULL, NULL,
MACRO_TYPE_SNMP_OID, NULL, 0);
if (ITEM_TYPE_SNMPv3 == item.type)
{
item.snmpv3_securityname = strdup(dcheck->snmpv3_securityname);
item.snmpv3_securitylevel = dcheck->snmpv3_securitylevel;
item.snmpv3_authpassphrase = strdup(dcheck->snmpv3_authpassphrase);
item.snmpv3_privpassphrase = strdup(dcheck->snmpv3_privpassphrase);
substitute_simple_macros(NULL, NULL, NULL, NULL, NULL, NULL,
&item.snmpv3_securityname, MACRO_TYPE_ITEM_FIELD, NULL, 0);
substitute_simple_macros(NULL, NULL, NULL, NULL, NULL, NULL,
&item.snmpv3_authpassphrase, MACRO_TYPE_ITEM_FIELD, NULL, 0);
substitute_simple_macros(NULL, NULL, NULL, NULL, NULL, NULL,
&item.snmpv3_privpassphrase, MACRO_TYPE_ITEM_FIELD, NULL, 0);
}
if (SUCCEED == get_value_snmp(&item, &result) && NULL != GET_STR_RESULT(&result))
zbx_strlcpy(value, result.str, DSERVICE_VALUE_LEN_MAX);
else
ret = FAIL;
zbx_free(item.snmp_community);
zbx_free(item.snmp_oid);
if (ITEM_TYPE_SNMPv3 == item.type)
{
zbx_free(item.snmpv3_securityname);
zbx_free(item.snmpv3_authpassphrase);
zbx_free(item.snmpv3_privpassphrase);
}
}
#else
ret = FAIL;
#endif /* HAVE_SNMP */
if (FAIL == ret && ISSET_MSG(&result))
{
zabbix_log(LOG_LEVEL_DEBUG, "discovery: item [%s] error: %s",
item.key, result.msg);
}
break;
case SVC_ICMPPING:
memset(&host, 0, sizeof(host));
host.addr = strdup(ip);
if (SUCCEED != do_ping(&host, 1, 3, 0, 0, 0, error, sizeof(error)) || 0 == host.rcv)
ret = FAIL;
zbx_free(host.addr);
break;
default:
break;
}
alarm(0);
}
free_result(&result);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
/******************************************************************************
* *
* Function: check_trigger_condition *
* *
* Purpose: check if event matches single condition *
* *
* Parameters: event - trigger event to check *
* (event->source == EVENT_SOURCE_TRIGGERS) *
* condition - condition for matching *
* *
* Return value: SUCCEED - matches, FAIL - otherwise *
* *
* Author: Alexei Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static int check_trigger_condition(DB_EVENT *event, DB_CONDITION *condition)
{
const char *__function_name = "check_trigger_condition";
DB_RESULT result;
DB_ROW row;
zbx_uint64_t condition_value;
int nodeid;
char *tmp_str = NULL;
int ret = FAIL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (condition->conditiontype == CONDITION_TYPE_HOST_GROUP)
{
ZBX_STR2UINT64(condition_value, condition->value);
result = DBselect(
"select distinct hg.groupid"
" from hosts_groups hg,hosts h,items i,functions f,triggers t"
" where hg.hostid=h.hostid"
" and h.hostid=i.hostid"
" and i.itemid=f.itemid"
" and f.triggerid=t.triggerid"
" and t.triggerid=" ZBX_FS_UI64
" and hg.groupid=" ZBX_FS_UI64,
event->objectid,
condition_value);
switch (condition->operator)
{
case CONDITION_OPERATOR_EQUAL:
if (NULL != DBfetch(result))
ret = SUCCEED;
break;
case CONDITION_OPERATOR_NOT_EQUAL:
if (NULL == DBfetch(result))
ret = SUCCEED;
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator,
condition->conditionid);
}
DBfree_result(result);
}
else if (condition->conditiontype == CONDITION_TYPE_HOST_TEMPLATE)
{
zbx_uint64_t hostid, triggerid;
ZBX_STR2UINT64(condition_value, condition->value);
switch (condition->operator)
{
case CONDITION_OPERATOR_EQUAL:
case CONDITION_OPERATOR_NOT_EQUAL:
triggerid = event->objectid;
do
{
result = DBselect(
"select distinct i.hostid,t.templateid"
" from items i,functions f,triggers t"
" where i.itemid=f.itemid"
" and f.triggerid=t.templateid"
" and t.triggerid=" ZBX_FS_UI64,
triggerid);
if (NULL != (row = DBfetch(result)))
{
ZBX_STR2UINT64(hostid, row[0]);
ZBX_STR2UINT64(triggerid, row[1]);
if (hostid == condition_value)
{
ret = SUCCEED;
break;
}
}
else
triggerid = 0;
DBfree_result(result);
} while (SUCCEED != ret && 0 != triggerid);
if (CONDITION_OPERATOR_NOT_EQUAL == condition->operator)
ret = (SUCCEED == ret) ? FAIL : SUCCEED;
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator,
condition->conditionid);
}
}
else if (condition->conditiontype == CONDITION_TYPE_HOST)
{
ZBX_STR2UINT64(condition_value, condition->value);
switch (condition->operator)
{
case CONDITION_OPERATOR_EQUAL:
case CONDITION_OPERATOR_NOT_EQUAL:
result = DBselect(
"select distinct i.hostid"
" from items i,functions f,triggers t"
" where i.itemid=f.itemid"
" and f.triggerid=t.triggerid"
" and t.triggerid=" ZBX_FS_UI64
" and i.hostid=" ZBX_FS_UI64,
event->objectid,
condition_value);
if (NULL != DBfetch(result))
ret = SUCCEED;
DBfree_result(result);
if (CONDITION_OPERATOR_NOT_EQUAL == condition->operator)
ret = (SUCCEED == ret) ? FAIL : SUCCEED;
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator, condition->conditionid);
}
}
else if (condition->conditiontype == CONDITION_TYPE_TRIGGER)
{
zbx_uint64_t triggerid;
ZBX_STR2UINT64(condition_value, condition->value);
switch (condition->operator)
{
case CONDITION_OPERATOR_EQUAL:
case CONDITION_OPERATOR_NOT_EQUAL:
if (event->objectid == condition_value)
ret = SUCCEED;
/* Processing of templated triggers */
else
{
for (triggerid = event->objectid; 0 != triggerid && FAIL == ret;)
{
result = DBselect(
"select templateid"
" from triggers"
" where triggerid=" ZBX_FS_UI64,
triggerid);
if (NULL == (row = DBfetch(result)))
triggerid = 0;
else
{
ZBX_STR2UINT64(triggerid, row[0]);
if (triggerid == condition_value)
ret = SUCCEED;
}
DBfree_result(result);
}
}
if (CONDITION_OPERATOR_NOT_EQUAL == condition->operator)
ret = (SUCCEED == ret) ? FAIL : SUCCEED;
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator, condition->conditionid);
}
}
else if (condition->conditiontype == CONDITION_TYPE_TRIGGER_NAME)
{
tmp_str = zbx_strdup(tmp_str, event->trigger.description);
substitute_simple_macros(event, NULL, NULL, NULL, NULL, &tmp_str, MACRO_TYPE_TRIGGER_DESCRIPTION, NULL, 0);
switch (condition->operator)
{
case CONDITION_OPERATOR_LIKE:
if (NULL != strstr(tmp_str, condition->value))
ret = SUCCEED;
break;
case CONDITION_OPERATOR_NOT_LIKE:
if (NULL == strstr(tmp_str, condition->value))
ret = SUCCEED;
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator,
condition->conditionid);
}
zbx_free(tmp_str);
}
else if (condition->conditiontype == CONDITION_TYPE_TRIGGER_SEVERITY)
{
condition_value = atoi(condition->value);
switch (condition->operator)
{
case CONDITION_OPERATOR_EQUAL:
if (event->trigger.priority == condition_value)
ret = SUCCEED;
break;
case CONDITION_OPERATOR_NOT_EQUAL:
if (event->trigger.priority != condition_value)
ret = SUCCEED;
break;
case CONDITION_OPERATOR_MORE_EQUAL:
if (event->trigger.priority >= condition_value)
ret = SUCCEED;
break;
case CONDITION_OPERATOR_LESS_EQUAL:
if (event->trigger.priority <= condition_value)
ret = SUCCEED;
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator,
condition->conditionid);
}
}
else if (condition->conditiontype == CONDITION_TYPE_TRIGGER_VALUE)
{
condition_value = atoi(condition->value);
switch (condition->operator)
{
case CONDITION_OPERATOR_EQUAL:
if (event->value == condition_value)
ret = SUCCEED;
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator,
condition->conditionid);
}
}
else if (condition->conditiontype == CONDITION_TYPE_TIME_PERIOD)
{
switch (condition->operator)
{
case CONDITION_OPERATOR_IN:
if (SUCCEED == check_time_period(condition->value, (time_t)NULL))
ret = SUCCEED;
break;
case CONDITION_OPERATOR_NOT_IN:
if (FAIL == check_time_period(condition->value, (time_t)NULL))
ret = SUCCEED;
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator,
condition->conditionid);
}
}
else if (condition->conditiontype == CONDITION_TYPE_MAINTENANCE)
{
switch (condition->operator) {
case CONDITION_OPERATOR_IN:
result = DBselect(
"select count(*)"
" from hosts h,items i,functions f,triggers t"
" where h.hostid=i.hostid"
" and h.maintenance_status=%d"
" and i.itemid=f.itemid"
" and f.triggerid=t.triggerid"
" and t.triggerid=" ZBX_FS_UI64,
HOST_MAINTENANCE_STATUS_ON,
event->objectid);
if (NULL != (row = DBfetch(result)) && FAIL == DBis_null(row[0]) && 0 != atoi(row[0]))
ret = SUCCEED;
DBfree_result(result);
break;
case CONDITION_OPERATOR_NOT_IN:
result = DBselect(
"select count(*)"
" from hosts h,items i,functions f,triggers t"
" where h.hostid=i.hostid"
" and h.maintenance_status=%d"
" and i.itemid=f.itemid"
" and f.triggerid=t.triggerid"
" and t.triggerid=" ZBX_FS_UI64,
HOST_MAINTENANCE_STATUS_OFF,
event->objectid);
if (NULL != (row = DBfetch(result)) && FAIL == DBis_null(row[0]) && 0 != atoi(row[0]))
ret = SUCCEED;
DBfree_result(result);
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator,
condition->conditionid);
}
}
else if (condition->conditiontype == CONDITION_TYPE_NODE)
{
nodeid = get_nodeid_by_id(event->objectid);
condition_value = atoi(condition->value);
switch (condition->operator) {
case CONDITION_OPERATOR_EQUAL:
if (nodeid == condition_value)
ret = SUCCEED;
break;
case CONDITION_OPERATOR_NOT_EQUAL:
if (nodeid != condition_value)
ret = SUCCEED;
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator,
condition->conditionid);
}
}
else if (condition->conditiontype == CONDITION_TYPE_EVENT_ACKNOWLEDGED)
{
result = DBselect(
"select acknowledged"
" from events"
" where acknowledged=%d"
" and eventid=" ZBX_FS_UI64,
atoi(condition->value),
event->eventid);
switch (condition->operator)
{
case CONDITION_OPERATOR_EQUAL:
if (NULL != (row = DBfetch(result)))
ret = SUCCEED;
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator,
condition->conditionid);
}
DBfree_result(result);
}
else if (condition->conditiontype == CONDITION_TYPE_APPLICATION)
{
result = DBselect(
"select distinct a.name"
" from applications a,items_applications i,functions f,triggers t"
" where a.applicationid=i.applicationid"
" and i.itemid=f.itemid"
" and f.triggerid=t.triggerid"
" and t.triggerid=" ZBX_FS_UI64,
event->objectid);
switch (condition->operator) {
case CONDITION_OPERATOR_EQUAL:
while (NULL != (row = DBfetch(result)))
{
if (0 == strcmp(row[0], condition->value))
{
ret = SUCCEED;
break;
}
}
break;
case CONDITION_OPERATOR_LIKE:
while (NULL != (row = DBfetch(result)))
{
if (NULL != strstr(row[0], condition->value))
{
ret = SUCCEED;
break;
}
}
break;
case CONDITION_OPERATOR_NOT_LIKE:
ret = SUCCEED;
while (NULL != (row = DBfetch(result)))
{
if (NULL != strstr(row[0], condition->value))
{
ret = FAIL;
break;
}
}
break;
default:
zabbix_log(LOG_LEVEL_ERR, "Unsupported operator [%d] for condition id [" ZBX_FS_UI64 "]",
condition->operator,
condition->conditionid);
}
DBfree_result(result);
}
else
{
zabbix_log(LOG_LEVEL_ERR, "Unsupported condition type [%d] for condition id [" ZBX_FS_UI64 "]",
condition->conditiontype,
condition->conditionid);
}
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
static void execute_commands(DB_EVENT *event, zbx_uint64_t actionid, zbx_uint64_t operationid, int esc_step)
{
const char *__function_name = "execute_commands";
DB_RESULT result;
DB_ROW row;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
result = DBselect(
"select distinct h.hostid,h.host,o.type,o.scriptid,o.execute_on,o.port"
",o.authtype,o.username,o.password,o.publickey,o.privatekey,o.command"
#ifdef HAVE_OPENIPMI
",h.ipmi_authtype,h.ipmi_privilege,h.ipmi_username,h.ipmi_password"
#endif
" from opcommand o,opcommand_grp og,hosts_groups hg,hosts h"
" where o.operationid=og.operationid"
" and og.groupid=hg.groupid"
" and hg.hostid=h.hostid"
" and o.operationid=" ZBX_FS_UI64
" and h.status=%d"
" union "
"select distinct h.hostid,h.host,o.type,o.scriptid,o.execute_on,o.port"
",o.authtype,o.username,o.password,o.publickey,o.privatekey,o.command"
#ifdef HAVE_OPENIPMI
",h.ipmi_authtype,h.ipmi_privilege,h.ipmi_username,h.ipmi_password"
#endif
" from opcommand o,opcommand_hst oh,hosts h"
" where o.operationid=oh.operationid"
" and oh.hostid=h.hostid"
" and o.operationid=" ZBX_FS_UI64
" and h.status=%d"
" union "
"select distinct 0,null,o.type,o.scriptid,o.execute_on,o.port"
",o.authtype,o.username,o.password,o.publickey,o.privatekey,o.command"
#ifdef HAVE_OPENIPMI
",0,2,null,null"
#endif
" from opcommand o,opcommand_hst oh"
" where o.operationid=oh.operationid"
" and o.operationid=" ZBX_FS_UI64
" and oh.hostid is null",
operationid, HOST_STATUS_MONITORED,
operationid, HOST_STATUS_MONITORED,
operationid);
while (NULL != (row = DBfetch(result)))
{
int rc = SUCCEED;
char error[ALERT_ERROR_LEN_MAX];
DC_HOST host;
zbx_script_t script;
zbx_alert_status_t status;
*error = '\0';
memset(&host, 0, sizeof(host));
zbx_script_init(&script);
ZBX_STR2UINT64(host.hostid, row[0]);
if (0 != host.hostid)
{
strscpy(host.host, row[1]);
#ifdef HAVE_OPENIPMI
host.ipmi_authtype = (signed char)atoi(row[12]);
host.ipmi_privilege = (unsigned char)atoi(row[13]);
strscpy(host.ipmi_username, row[14]);
strscpy(host.ipmi_password, row[15]);
#endif
}
else
rc = get_dynamic_hostid(event, &host, error, sizeof(error));
script.type = (unsigned char)atoi(row[2]);
if (ZBX_SCRIPT_TYPE_GLOBAL_SCRIPT != script.type)
{
script.command = zbx_strdup(script.command, row[11]);
substitute_simple_macros(event, NULL, NULL, NULL, NULL, NULL,
&script.command, MACRO_TYPE_MESSAGE, NULL, 0);
}
if (SUCCEED == rc)
{
switch (script.type)
{
case ZBX_SCRIPT_TYPE_CUSTOM_SCRIPT:
script.execute_on = (unsigned char)atoi(row[4]);
break;
case ZBX_SCRIPT_TYPE_SSH:
script.authtype = (unsigned char)atoi(row[6]);
script.publickey = zbx_strdup(script.publickey, row[9]);
script.privatekey = zbx_strdup(script.privatekey, row[10]);
/* break; is not missing here */
case ZBX_SCRIPT_TYPE_TELNET:
script.port = zbx_strdup(script.port, row[5]);
script.username = zbx_strdup(script.username, row[7]);
script.password = zbx_strdup(script.password, row[8]);
break;
case ZBX_SCRIPT_TYPE_GLOBAL_SCRIPT:
ZBX_DBROW2UINT64(script.scriptid, row[3]);
break;
}
rc = zbx_execute_script(&host, &script, NULL, error, sizeof(error));
}
status = (SUCCEED != rc ? ALERT_STATUS_FAILED : ALERT_STATUS_SENT);
add_command_alert(&host, event->eventid, actionid, esc_step, script.command, status, error);
zbx_script_clean(&script);
}
DBfree_result(result);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
/******************************************************************************
* *
* Function: process_httptest *
* *
* Purpose: process single scenario of http test *
* *
* Parameters: *
* *
* Return value: *
* *
* Author: Alexei Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static void process_httptest(DC_HOST *host, zbx_httptest_t *httptest)
{
const char *__function_name = "process_httptest";
DB_RESULT result;
DB_ROW row;
DB_HTTPSTEP httpstep;
char *err_str = NULL;
int lastfailedstep;
zbx_timespec_t ts;
zbx_httpstat_t stat;
double speed_download = 0;
int speed_download_num = 0;
#ifdef HAVE_LIBCURL
int err;
char auth[HTTPTEST_HTTP_USER_LEN_MAX + HTTPTEST_HTTP_PASSWORD_LEN_MAX];
CURL *easyhandle = NULL;
#endif
zabbix_log(LOG_LEVEL_DEBUG, "In %s() httptestid:" ZBX_FS_UI64 " name:'%s'",
__function_name, httptest->httptest.httptestid, httptest->httptest.name);
lastfailedstep = 0;
result = DBselect(
"select httpstepid,no,name,url,timeout,posts,required,status_codes,variables"
" from httpstep"
" where httptestid=" ZBX_FS_UI64
" order by no",
httptest->httptest.httptestid);
#ifdef HAVE_LIBCURL
if (NULL == (easyhandle = curl_easy_init()))
{
err_str = zbx_strdup(err_str, "cannot initialize cURL library");
goto clean;
}
if (CURLE_OK != (err = curl_easy_setopt(easyhandle, CURLOPT_PROXY, httptest->httptest.http_proxy)) ||
CURLE_OK != (err = curl_easy_setopt(easyhandle, CURLOPT_COOKIEFILE, "")) ||
CURLE_OK != (err = curl_easy_setopt(easyhandle, CURLOPT_USERAGENT, httptest->httptest.agent)) ||
CURLE_OK != (err = curl_easy_setopt(easyhandle, CURLOPT_FOLLOWLOCATION, 1L)) ||
CURLE_OK != (err = curl_easy_setopt(easyhandle, CURLOPT_WRITEFUNCTION, WRITEFUNCTION2)) ||
CURLE_OK != (err = curl_easy_setopt(easyhandle, CURLOPT_HEADERFUNCTION, HEADERFUNCTION2)) ||
CURLE_OK != (err = curl_easy_setopt(easyhandle, CURLOPT_SSL_VERIFYPEER, 0L)) ||
CURLE_OK != (err = curl_easy_setopt(easyhandle, CURLOPT_SSL_VERIFYHOST, 0L)))
{
err_str = zbx_strdup(err_str, curl_easy_strerror(err));
goto clean;
}
while (NULL != (row = DBfetch(result)))
{
/* NOTE: do not break or return from this block! */
/* process_step_data() call is required! */
ZBX_STR2UINT64(httpstep.httpstepid, row[0]);
httpstep.httptestid = httptest->httptest.httptestid;
httpstep.no = atoi(row[1]);
httpstep.name = row[2];
httpstep.url = zbx_strdup(NULL, row[3]);
substitute_simple_macros(NULL, NULL, NULL, NULL, NULL, host, NULL,
&httpstep.url, MACRO_TYPE_HTTPTEST_FIELD, NULL, 0);
httpstep.timeout = atoi(row[4]);
httpstep.posts = zbx_strdup(NULL, row[5]);
substitute_simple_macros(NULL, NULL, NULL, NULL, NULL, host, NULL,
&httpstep.posts, MACRO_TYPE_HTTPTEST_FIELD, NULL, 0);
httpstep.required = zbx_strdup(NULL, row[6]);
substitute_simple_macros(NULL, NULL, NULL, NULL, NULL, host, NULL,
&httpstep.required, MACRO_TYPE_HTTPTEST_FIELD, NULL, 0);
httpstep.status_codes = zbx_strdup(NULL, row[7]);
substitute_simple_macros(NULL, NULL, NULL, NULL, &host->hostid, NULL, NULL,
&httpstep.status_codes, MACRO_TYPE_COMMON, NULL, 0);
httpstep.variables = row[8];
memset(&stat, 0, sizeof(stat));
http_substitute_variables(httptest, &httpstep.url);
http_substitute_variables(httptest, &httpstep.posts);
zabbix_log(LOG_LEVEL_DEBUG, "%s() use step \"%s\"", __function_name, httpstep.name);
if (CURLE_OK != (err = curl_easy_setopt(easyhandle, CURLOPT_POSTFIELDS, httpstep.posts)))
{
err_str = zbx_strdup(err_str, curl_easy_strerror(err));
goto httpstep_error;
}
if ('\0' != *httpstep.posts)
zabbix_log(LOG_LEVEL_DEBUG, "%s() use post \"%s\"", __function_name, httpstep.posts);
if (CURLE_OK != (err = curl_easy_setopt(easyhandle, CURLOPT_POST, '\0' != *httpstep.posts ? 1L : 0L)))
{
err_str = zbx_strdup(err_str, curl_easy_strerror(err));
goto httpstep_error;
}
if (HTTPTEST_AUTH_NONE != httptest->httptest.authentication)
{
long curlauth = 0;
zabbix_log(LOG_LEVEL_DEBUG, "%s() setting HTTPAUTH [%d]",
__function_name, httptest->httptest.authentication);
zabbix_log(LOG_LEVEL_DEBUG, "%s() setting USERPWD for authentication", __function_name);
switch (httptest->httptest.authentication)
{
case HTTPTEST_AUTH_BASIC:
curlauth = CURLAUTH_BASIC;
break;
case HTTPTEST_AUTH_NTLM:
curlauth = CURLAUTH_NTLM;
break;
default:
THIS_SHOULD_NEVER_HAPPEN;
break;
}
zbx_snprintf(auth, sizeof(auth), "%s:%s", httptest->httptest.http_user,
httptest->httptest.http_password);
if (CURLE_OK != (err = curl_easy_setopt(easyhandle, CURLOPT_HTTPAUTH, curlauth)) ||
CURLE_OK != (err = curl_easy_setopt(easyhandle, CURLOPT_USERPWD, auth)))
{
err_str = zbx_strdup(err_str, curl_easy_strerror(err));
goto httpstep_error;
}
}
zabbix_log(LOG_LEVEL_DEBUG, "%s() go to URL \"%s\"", __function_name, httpstep.url);
if (CURLE_OK != (err = curl_easy_setopt(easyhandle, CURLOPT_TIMEOUT, (long)httpstep.timeout)) ||
CURLE_OK != (err = curl_easy_setopt(easyhandle, CURLOPT_URL, httpstep.url)))
{
err_str = zbx_strdup(err_str, curl_easy_strerror(err));
goto httpstep_error;
}
/* try to retrieve page several times depending on number of retries */
do
{
memset(&page, 0, sizeof(page));
if (CURLE_OK == (err = curl_easy_perform(easyhandle)))
break;
}
while (0 != --httptest->httptest.retries);
if (CURLE_OK == err)
{
char *var_err_str = NULL;
/* first get the data that is needed even if step fails */
if (CURLE_OK != (err = curl_easy_getinfo(easyhandle, CURLINFO_RESPONSE_CODE, &stat.rspcode)))
{
err_str = zbx_strdup(err_str, curl_easy_strerror(err));
}
else if ('\0' != *httpstep.status_codes &&
FAIL == int_in_list(httpstep.status_codes, stat.rspcode))
{
err_str = zbx_strdup(err_str, "status code did not match");
}
if (CURLE_OK != (err = curl_easy_getinfo(easyhandle, CURLINFO_TOTAL_TIME, &stat.total_time)) &&
NULL == err_str)
{
err_str = zbx_strdup(err_str, curl_easy_strerror(err));
}
if (CURLE_OK != (err = curl_easy_getinfo(easyhandle, CURLINFO_SPEED_DOWNLOAD,
&stat.speed_download)) && NULL == err_str)
{
err_str = zbx_strdup(err_str, curl_easy_strerror(err));
}
else
{
speed_download += stat.speed_download;
speed_download_num++;
}
/* required pattern */
if (NULL == err_str && '\0' != *httpstep.required && NULL == zbx_regexp_match(page.data,
httpstep.required, NULL))
{
err_str = zbx_strdup(err_str, "required pattern not found");
}
/* variables defined in scenario */
if (NULL == err_str && FAIL == http_process_variables(httptest, httptest->httptest.variables,
page.data, &var_err_str))
{
char *variables;
variables = string_replace(httptest->httptest.variables, "\r\n", " ");
err_str = zbx_dsprintf(err_str, "error in scenario variables \"%s\": %s",
variables, var_err_str);
zbx_free(variables);
}
/* variables defined in a step */
if (NULL == err_str && FAIL == http_process_variables(httptest, httpstep.variables, page.data,
&var_err_str))
{
char *variables;
variables = string_replace(httpstep.variables, "\r\n", " ");
err_str = zbx_dsprintf(err_str, "error in step variables \"%s\": %s",
variables, var_err_str);
zbx_free(variables);
}
zbx_free(var_err_str);
}
else
err_str = zbx_strdup(err_str, curl_easy_strerror(err));
zbx_free(page.data);
httpstep_error:
zbx_free(httpstep.status_codes);
zbx_free(httpstep.required);
zbx_free(httpstep.posts);
zbx_free(httpstep.url);
zbx_timespec(&ts);
process_step_data(httpstep.httpstepid, &stat, &ts);
if (NULL != err_str)
{
lastfailedstep = httpstep.no;
break;
}
}
clean:
curl_easy_cleanup(easyhandle);
#else
err_str = zbx_strdup(err_str, "cURL library is required for Web monitoring support");
#endif /* HAVE_LIBCURL */
zbx_timespec(&ts);
if (NULL != err_str)
{
if (0 == lastfailedstep)
{
/* we are here either because cURL initialization failed */
/* or we have been compiled without cURL library */
lastfailedstep = 1;
if (NULL != (row = DBfetch(result)))
{
ZBX_STR2UINT64(httpstep.httpstepid, row[0]);
httpstep.name = row[2];
memset(&stat, 0, sizeof(stat));
process_step_data(httpstep.httpstepid, &stat, &ts);
}
else
THIS_SHOULD_NEVER_HAPPEN;
}
zabbix_log(LOG_LEVEL_WARNING, "cannot process step \"%s\" of web scenario \"%s\" on host \"%s\": %s",
httpstep.name, httptest->httptest.name, host->name, err_str);
}
DBfree_result(result);
DBexecute("update httptest set nextcheck=%d+delay where httptestid=" ZBX_FS_UI64,
ts.sec, httptest->httptest.httptestid);
if (0 != speed_download_num)
speed_download /= speed_download_num;
process_test_data(httptest->httptest.httptestid, lastfailedstep, speed_download, err_str, &ts);
zbx_free(err_str);
dc_flush_history();
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
static void add_message_alert(DB_ESCALATION *escalation, DB_EVENT *event, DB_ACTION *action,
zbx_uint64_t userid, zbx_uint64_t mediatypeid, const char *subject, const char *message)
{
const char *__function_name = "add_message_alert";
DB_RESULT result;
DB_ROW row;
zbx_uint64_t alertid;
int now, severity, medias = 0;
char *subject_dyn, *message_dyn, *sendto_esc, *subject_esc, *message_esc, *error_esc;
char error[MAX_STRING_LEN];
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
subject_dyn = zbx_strdup(NULL, subject);
message_dyn = zbx_strdup(NULL, message);
substitute_simple_macros(event, &userid, NULL, NULL, NULL, NULL, &subject_dyn, MACRO_TYPE_MESSAGE, NULL, 0);
substitute_simple_macros(event, &userid, NULL, NULL, NULL, NULL, &message_dyn, MACRO_TYPE_MESSAGE, NULL, 0);
now = time(NULL);
subject_esc = DBdyn_escape_string_len(subject_dyn, ALERT_SUBJECT_LEN);
message_esc = DBdyn_escape_string_len(message_dyn, ALERT_MESSAGE_LEN);
zbx_free(subject_dyn);
zbx_free(message_dyn);
if (0 == mediatypeid)
{
result = DBselect(
"select m.mediatypeid,m.sendto,m.severity,m.period,mt.status"
" from media m,media_type mt"
" where m.mediatypeid=mt.mediatypeid"
" and m.active=%d"
" and m.userid=" ZBX_FS_UI64,
MEDIA_STATUS_ACTIVE, userid);
}
else
{
result = DBselect(
"select m.mediatypeid,m.sendto,m.severity,m.period,mt.status"
" from media m,media_type mt"
" where m.mediatypeid=mt.mediatypeid"
" and m.active=%d"
" and m.userid=" ZBX_FS_UI64
" and m.mediatypeid=" ZBX_FS_UI64,
MEDIA_STATUS_ACTIVE, userid, mediatypeid);
}
while (NULL != (row = DBfetch(result)))
{
medias = 1;
ZBX_STR2UINT64(mediatypeid, row[0]);
severity = atoi(row[2]);
zabbix_log(LOG_LEVEL_DEBUG, "Trigger severity [%d] Media severity [%d] Period [%s]",
(int)event->trigger.priority, severity, row[3]);
if (((1 << event->trigger.priority) & severity) == 0)
{
zabbix_log(LOG_LEVEL_DEBUG, "Won't send message (severity)");
continue;
}
if (FAIL == check_time_period(row[3], (time_t)NULL))
{
zabbix_log(LOG_LEVEL_DEBUG, "Won't send message (period)");
continue;
}
alertid = DBget_maxid("alerts");
sendto_esc = DBdyn_escape_string_len(row[1], ALERT_SENDTO_LEN);
if (MEDIA_TYPE_STATUS_ACTIVE == atoi(row[4]))
{
DBexecute("insert into alerts (alertid,actionid,eventid,userid,clock"
",mediatypeid,sendto,subject,message,status,alerttype,esc_step)"
" values (" ZBX_FS_UI64 "," ZBX_FS_UI64 "," ZBX_FS_UI64 "," ZBX_FS_UI64 ",%d"
"," ZBX_FS_UI64 ",'%s','%s','%s',%d,%d,%d)",
alertid,
action->actionid,
event->eventid,
userid,
now,
mediatypeid,
sendto_esc,
subject_esc,
message_esc,
ALERT_STATUS_NOT_SENT,
ALERT_TYPE_MESSAGE,
escalation->esc_step);
}
else
{
error_esc = DBdyn_escape_string("Media type disabled");
DBexecute("insert into alerts (alertid,actionid,eventid,userid,clock"
",mediatypeid,sendto,subject,message,status,alerttype,esc_step,error)"
" values (" ZBX_FS_UI64 "," ZBX_FS_UI64 "," ZBX_FS_UI64 "," ZBX_FS_UI64 ",%d"
"," ZBX_FS_UI64 ",'%s','%s','%s',%d,%d,%d,'%s')",
alertid,
action->actionid,
event->eventid,
userid,
now,
mediatypeid,
sendto_esc,
subject_esc,
message_esc,
ALERT_STATUS_FAILED,
ALERT_TYPE_MESSAGE,
escalation->esc_step,
error_esc);
zbx_free(error_esc);
}
zbx_free(sendto_esc);
}
DBfree_result(result);
if (0 == medias)
{
zbx_snprintf(error, sizeof(error), "No media defined for user \"%s\"",
zbx_user_string(userid));
alertid = DBget_maxid("alerts");
error_esc = DBdyn_escape_string(error);
DBexecute("insert into alerts (alertid,actionid,eventid,userid,retries,clock"
",subject,message,status,alerttype,error,esc_step)"
" values (" ZBX_FS_UI64 "," ZBX_FS_UI64 "," ZBX_FS_UI64 "," ZBX_FS_UI64 ",%d,%d"
",'%s','%s',%d,%d,'%s',%d)",
alertid,
action->actionid,
event->eventid,
userid,
ALERT_MAX_RETRIES,
now,
subject_esc,
message_esc,
ALERT_STATUS_FAILED,
ALERT_TYPE_MESSAGE,
error_esc,
escalation->esc_step);
zbx_free(error_esc);
}
zbx_free(subject_esc);
zbx_free(message_esc);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
/******************************************************************************
* *
* Function: process_proxy *
* *
* Purpose: retrieve values of metrics from monitored hosts *
* *
* Parameters: *
* *
* Return value: *
* *
* Author: Alexei Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static int process_proxy(void)
{
const char *__function_name = "process_proxy";
DC_PROXY proxy;
int num, i, ret;
struct zbx_json j;
struct zbx_json_parse jp, jp_data;
zbx_socket_t s;
char *answer = NULL, *port = NULL;
time_t now;
unsigned char update_nextcheck;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (0 == (num = DCconfig_get_proxypoller_hosts(&proxy, 1)))
goto exit;
now = time(NULL);
zbx_json_init(&j, 512 * 1024);
for (i = 0; i < num; i++)
{
update_nextcheck = 0;
if (proxy.proxy_config_nextcheck <= now)
update_nextcheck |= 0x01;
if (proxy.proxy_data_nextcheck <= now)
update_nextcheck |= 0x02;
proxy.addr = proxy.addr_orig;
port = zbx_strdup(port, proxy.port_orig);
substitute_simple_macros(NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
&port, MACRO_TYPE_COMMON, NULL, 0);
if (FAIL == is_ushort(port, &proxy.port))
{
zabbix_log(LOG_LEVEL_ERR, "invalid proxy \"%s\" port: \"%s\"", proxy.host, port);
goto network_error;
}
if (proxy.proxy_config_nextcheck <= now)
{
char *error = NULL;
zbx_json_clean(&j);
zbx_json_addstring(&j, ZBX_PROTO_TAG_REQUEST,
ZBX_PROTO_VALUE_PROXY_CONFIG, ZBX_JSON_TYPE_STRING);
zbx_json_addobject(&j, ZBX_PROTO_TAG_DATA);
if (SUCCEED != (ret = get_proxyconfig_data(proxy.hostid, &j, &error)))
{
zabbix_log(LOG_LEVEL_ERR, "cannot collect configuration data for proxy \"%s\": %s",
proxy.host, error);
zbx_free(error);
goto network_error;
}
if (SUCCEED == (ret = connect_to_proxy(&proxy, &s, CONFIG_TRAPPER_TIMEOUT)))
{
zabbix_log(LOG_LEVEL_WARNING, "sending configuration data to proxy \"%s\" at \"%s\","
" datalen " ZBX_FS_SIZE_T,
proxy.host, get_ip_by_socket(&s), (zbx_fs_size_t)j.buffer_size);
if (SUCCEED == (ret = send_data_to_proxy(&proxy, &s, j.buffer)))
{
char *error = NULL;
if (SUCCEED != (ret = zbx_recv_response(&s, 0, &error)))
{
zabbix_log(LOG_LEVEL_WARNING, "cannot send configuration data to proxy"
" \"%s\" at \"%s\": %s",
proxy.host, get_ip_by_socket(&s), error);
}
zbx_free(error);
}
disconnect_proxy(&s);
}
if (SUCCEED != ret)
goto network_error;
}
if (proxy.proxy_data_nextcheck <= now)
{
if (SUCCEED == get_data_from_proxy(&proxy,
ZBX_PROTO_VALUE_HOST_AVAILABILITY, &answer))
{
if (SUCCEED == zbx_json_open(answer, &jp))
process_host_availability(&jp);
zbx_free(answer);
}
else
goto network_error;
retry_history:
if (SUCCEED == get_data_from_proxy(&proxy,
ZBX_PROTO_VALUE_HISTORY_DATA, &answer))
{
if (SUCCEED == zbx_json_open(answer, &jp))
{
process_hist_data(NULL, &jp, proxy.hostid, NULL, 0);
if (SUCCEED == zbx_json_brackets_by_name(&jp, ZBX_PROTO_TAG_DATA, &jp_data))
{
if (ZBX_MAX_HRECORDS <= zbx_json_count(&jp_data))
{
zbx_free(answer);
goto retry_history;
}
}
}
zbx_free(answer);
}
else
goto network_error;
retry_dhistory:
if (SUCCEED == get_data_from_proxy(&proxy,
ZBX_PROTO_VALUE_DISCOVERY_DATA, &answer))
{
if (SUCCEED == zbx_json_open(answer, &jp))
{
process_dhis_data(&jp);
if (SUCCEED == zbx_json_brackets_by_name(&jp, ZBX_PROTO_TAG_DATA, &jp_data))
{
if (ZBX_MAX_HRECORDS <= zbx_json_count(&jp_data))
{
zbx_free(answer);
goto retry_dhistory;
}
}
}
zbx_free(answer);
}
else
goto network_error;
retry_autoreg_host:
if (SUCCEED == get_data_from_proxy(&proxy,
ZBX_PROTO_VALUE_AUTO_REGISTRATION_DATA, &answer))
{
if (SUCCEED == zbx_json_open(answer, &jp))
{
process_areg_data(&jp, proxy.hostid);
if (SUCCEED == zbx_json_brackets_by_name(&jp, ZBX_PROTO_TAG_DATA, &jp_data))
{
if (ZBX_MAX_HRECORDS <= zbx_json_count(&jp_data))
{
zbx_free(answer);
goto retry_autoreg_host;
}
}
}
zbx_free(answer);
}
else
goto network_error;
}
DBbegin();
update_proxy_lastaccess(proxy.hostid);
DBcommit();
network_error:
DCrequeue_proxy(proxy.hostid, update_nextcheck);
}
zbx_free(port);
zbx_json_free(&j);
exit:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
return num;
}
