/******************************************************************************
* *
* Function: get_value_db *
* *
* Purpose: retrieve data from database *
* *
* Parameters: item - item we are interested in *
* *
* Return value: SUCCEED - data successfully retrieved and stored in result *
* NOTSUPPORTED - requested item is not supported *
* *
* Author: Eugene Grigorjev *
* *
******************************************************************************/
int get_value_db(DC_ITEM *item, AGENT_RESULT *result)
{
const char *__function_name = "get_value_db";
AGENT_REQUEST request;
int ret = NOTSUPPORTED;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() key_orig:'%s'", __function_name, item->key_orig);
init_request(&request);
if (SUCCEED == parse_item_key(item->key, &request))
{
if (0 == strcmp(request.key, "db.odbc.select"))
ret = db_odbc_select(item, &request, result);
else if (0 == strcmp(request.key, "db.odbc.discovery"))
ret = db_odbc_discovery(item, &request, result);
else
SET_MSG_RESULT(result, zbx_strdup(NULL, "Unsupported item key for this item type."));
}
else
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid item parameter format."));
free_request(&request);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
int get_value_simple(DC_ITEM *item, AGENT_RESULT *result)
{
const char *__function_name = "get_value_simple";
AGENT_REQUEST request;
vmfunc_t vmfunc;
int ret = NOTSUPPORTED;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() key_orig:'%s' addr:'%s'",
__function_name, item->key_orig, item->interface.addr);
init_request(&request);
parse_item_key(item->key, &request);
request.lastlogsize = item->lastlogsize;
if (0 == strcmp(request.key, "net.tcp.service"))
{
if (SYSINFO_RET_OK == check_service(&request, item->interface.addr, result, 0))
ret = SUCCEED;
}
else if (0 == strcmp(request.key, "net.tcp.service.perf"))
{
if (SYSINFO_RET_OK == check_service(&request, item->interface.addr, result, 1))
ret = SUCCEED;
}
else if (SUCCEED == get_vmware_function(request.key, &vmfunc))
{
if (NULL != vmfunc)
{
if (SYSINFO_RET_OK == vmfunc(&request, item->username, item->password, result))
ret = SUCCEED;
}
else
SET_MSG_RESULT(result, zbx_strdup(NULL, "Support for VMware checks was not compiled in."));
}
else
{
/* it will execute item from a loadable module if any */
if (SUCCEED == process(item->key, PROCESS_MODULE_COMMAND, result))
ret = SUCCEED;
}
if (NOTSUPPORTED == ret && !ISSET_MSG(result))
SET_MSG_RESULT(result, zbx_strdup(NULL, "Simple check is not supported."));
free_request(&request);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
int get_value_ssh(DC_ITEM *item, AGENT_RESULT *result)
{
AGENT_REQUEST request;
int ret = NOTSUPPORTED;
const char *port, *encoding, *dns;
init_request(&request);
if (SUCCEED != parse_item_key(item->key, &request))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid item key format."));
goto out;
}
if (0 != strcmp(SSH_RUN_KEY, get_rkey(&request)))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Unsupported item key for this item type."));
goto out;
}
if (4 < get_rparams_num(&request))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters."));
goto out;
}
if (NULL != (dns = get_rparam(&request, 1)) && '\0' != *dns)
{
strscpy(item->interface.dns_orig, dns);
item->interface.addr = item->interface.dns_orig;
}
if (NULL != (port = get_rparam(&request, 2)) && '\0' != *port)
{
if (FAIL == is_ushort(port, &item->interface.port))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid third parameter."));
goto out;
}
}
else
item->interface.port = ZBX_DEFAULT_SSH_PORT;
encoding = get_rparam(&request, 3);
ret = ssh_run(item, result, ZBX_NULL2EMPTY_STR(encoding));
out:
free_request(&request);
return ret;
}
/******************************************************************************
* *
* Function: zbx_itemkey_extract_global_regexps *
* *
* Purpose: extract global regular expression names from item key *
* *
* Parameters: key - [IN] the item key to parse *
* regexps - [OUT] the extracted regular expression names *
* *
******************************************************************************/
static void zbx_itemkey_extract_global_regexps(const char *key, zbx_vector_str_t *regexps)
{
#define ZBX_KEY_LOG 1
#define ZBX_KEY_EVENTLOG 2
AGENT_REQUEST request;
int item_key;
const char *param;
if (0 == strncmp(key, "log[", 4) || 0 == strncmp(key, "logrt[", 6))
item_key = ZBX_KEY_LOG;
else if (0 == strncmp(key, "eventlog[", 9))
item_key = ZBX_KEY_EVENTLOG;
else
return;
init_request(&request);
if(SUCCEED != parse_item_key(key, &request))
goto out;
/* "params" parameter */
if (NULL != (param = get_rparam(&request, 1)) && '@' == *param)
zbx_vector_str_append_uniq(regexps, param + 1);
if (ZBX_KEY_EVENTLOG == item_key)
{
/* "severity" parameter */
if (NULL != (param = get_rparam(&request, 2)) && '@' == *param)
zbx_vector_str_append_uniq(regexps, param + 1);
/* "source" parameter */
if (NULL != (param = get_rparam(&request, 3)) && '@' == *param)
zbx_vector_str_append_uniq(regexps, param + 1);
/* "logeventid" parameter */
if (NULL != (param = get_rparam(&request, 4)) && '@' == *param)
zbx_vector_str_append_uniq(regexps, param + 1);
}
out:
free_request(&request);
}
/******************************************************************************
* *
* Function: process_trap_for_interface *
* *
* Purpose: add trap to all matching items for the specified interface *
* *
* Return value: SUCCEED - a matching item was found *
* FAIL - no matching item was found (including fallback items) *
* *
* Author: Rudolfs Kreicbergs *
* *
******************************************************************************/
static int process_trap_for_interface(zbx_uint64_t interfaceid, char *trap, zbx_timespec_t *ts)
{
DC_ITEM *items = NULL;
const char *regex;
char error[ITEM_ERROR_LEN_MAX];
size_t num, i;
int ret = FAIL, fb = -1, *lastclocks = NULL, *errcodes = NULL;
zbx_uint64_t *itemids = NULL;
unsigned char *states = NULL;
AGENT_RESULT *results = NULL;
AGENT_REQUEST request;
zbx_vector_ptr_t regexps;
zbx_vector_ptr_create(®exps);
num = DCconfig_get_snmp_items_by_interfaceid(interfaceid, &items);
itemids = zbx_malloc(itemids, sizeof(zbx_uint64_t) * num);
states = zbx_malloc(states, sizeof(unsigned char) * num);
lastclocks = zbx_malloc(lastclocks, sizeof(int) * num);
errcodes = zbx_malloc(errcodes, sizeof(int) * num);
results = zbx_malloc(results, sizeof(AGENT_RESULT) * num);
for (i = 0; i < num; i++)
{
init_result(&results[i]);
errcodes[i] = FAIL;
items[i].key = zbx_strdup(items[i].key, items[i].key_orig);
if (SUCCEED != substitute_key_macros(&items[i].key, NULL, &items[i], NULL,
MACRO_TYPE_ITEM_KEY, error, sizeof(error)))
{
SET_MSG_RESULT(&results[i], zbx_strdup(NULL, error));
errcodes[i] = NOTSUPPORTED;
continue;
}
if (0 == strcmp(items[i].key, "snmptrap.fallback"))
{
fb = i;
continue;
}
init_request(&request);
if (SUCCEED != parse_item_key(items[i].key, &request))
goto next;
if (0 != strcmp(get_rkey(&request), "snmptrap"))
goto next;
if (1 < get_rparams_num(&request))
goto next;
if (NULL != (regex = get_rparam(&request, 0)))
{
if ('@' == *regex)
{
DCget_expressions_by_name(®exps, regex + 1);
if (0 == regexps.values_num)
{
SET_MSG_RESULT(&results[i], zbx_dsprintf(NULL,
"Global regular expression \"%s\" does not exist.", regex + 1));
errcodes[i] = NOTSUPPORTED;
goto next;
}
}
if (SUCCEED != regexp_match_ex(®exps, trap, regex, ZBX_CASE_SENSITIVE))
goto next;
}
if (SUCCEED == set_result_type(&results[i], items[i].value_type, items[i].data_type, trap))
errcodes[i] = SUCCEED;
else
errcodes[i] = NOTSUPPORTED;
ret = SUCCEED;
next:
free_request(&request);
}
if (FAIL == ret && -1 != fb)
{
if (SUCCEED == set_result_type(&results[fb], items[fb].value_type, items[fb].data_type, trap))
errcodes[fb] = SUCCEED;
else
errcodes[fb] = NOTSUPPORTED;
ret = SUCCEED;
}
for (i = 0; i < num; i++)
{
switch (errcodes[i])
{
case SUCCEED:
if (ITEM_VALUE_TYPE_LOG == items[i].value_type)
{
calc_timestamp(results[i].log->value, &results[i].log->timestamp,
items[i].logtimefmt);
}
items[i].state = ITEM_STATE_NORMAL;
dc_add_history(items[i].itemid, items[i].value_type, items[i].flags, &results[i],
ts, items[i].state, NULL);
itemids[i] = items[i].itemid;
states[i] = items[i].state;
lastclocks[i] = ts->sec;
break;
case NOTSUPPORTED:
items[i].state = ITEM_STATE_NOTSUPPORTED;
dc_add_history(items[i].itemid, items[i].value_type, items[i].flags, NULL,
ts, items[i].state, results[i].msg);
itemids[i] = items[i].itemid;
states[i] = items[i].state;
lastclocks[i] = ts->sec;
break;
}
zbx_free(items[i].key);
free_result(&results[i]);
}
zbx_free(results);
DCrequeue_items(itemids, states, lastclocks, NULL, NULL, errcodes, num);
zbx_free(errcodes);
zbx_free(lastclocks);
zbx_free(states);
zbx_free(itemids);
DCconfig_clean_items(items, NULL, num);
zbx_free(items);
zbx_regexp_clean_expressions(®exps);
zbx_vector_ptr_destroy(®exps);
dc_flush_history();
return ret;
}
/******************************************************************************
* *
* Function: process *
* *
* Purpose: execute agent check *
* *
* Parameters: in_command - item key *
* flags - PROCESS_LOCAL_COMMAND, allow execution of system.run *
* PROCESS_MODULE_COMMAND, execute item from a module *
* *
* Return value: SUCCEED - successful execution *
* NOTSUPPORTED - item key is not supported or other error *
* result - contains item value or error message *
* *
******************************************************************************/
int process(const char *in_command, unsigned flags, AGENT_RESULT *result)
{
int ret = NOTSUPPORTED;
ZBX_METRIC *command = NULL;
AGENT_REQUEST request;
init_result(result);
init_request(&request);
if (SUCCEED != parse_item_key(zbx_alias_get(in_command), &request))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid item key format."));
goto notsupported;
}
/* system.run is not allowed by default except for getting hostname for daemons */
if (1 != CONFIG_ENABLE_REMOTE_COMMANDS && 0 == (flags & PROCESS_LOCAL_COMMAND) &&
0 == strcmp(request.key, "system.run"))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Remote commands are not enabled."));
goto notsupported;
}
for (command = commands; NULL != command->key; command++)
{
if (0 == strcmp(command->key, request.key))
break;
}
/* item key not found */
if (NULL == command->key)
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Unsupported item key."));
goto notsupported;
}
/* expected item from a module */
if (0 != (flags & PROCESS_MODULE_COMMAND) && 0 == (command->flags & CF_MODULE))
goto notsupported;
/* command does not accept parameters but was called with parameters */
if (0 == (command->flags & CF_HAVEPARAMS) && 0 != request.nparam)
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Item does not allow parameters."));
goto notsupported;
}
if (0 != (command->flags & CF_USERPARAMETER))
{
if (0 != (command->flags & CF_HAVEPARAMS))
{
char *parameters = NULL, error[MAX_STRING_LEN];
if (FAIL == replace_param(command->test_param, &request, ¶meters, error, sizeof(error)))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, error));
goto notsupported;
}
free_request_params(&request);
add_request_param(&request, parameters);
}
else
{
free_request_params(&request);
add_request_param(&request, zbx_strdup(NULL, command->test_param));
}
}
if (SYSINFO_RET_OK != command->function(&request, result))
{
/* "return NOTSUPPORTED;" would be more appropriate here for preserving original error */
/* message in "result" but would break things relying on ZBX_NOTSUPPORTED message. */
if (0 != (command->flags & CF_MODULE) && 0 == ISSET_MSG(result))
SET_MSG_RESULT(result, zbx_strdup(NULL, "Item is not supported."));
goto notsupported;
}
ret = SUCCEED;
notsupported:
free_request(&request);
return ret;
}
void zbx_mock_test_entry(void **state)
{
AGENT_REQUEST request;
AGENT_RESULT param_result;
zbx_mock_error_t error;
const char *init_param;
zbx_mock_handle_t param_handle;
const char *expected_param_value_string, *expected_return_string;
zbx_uint64_t expected_param_value = 0;
int expected_result = FAIL, actual_result = FAIL;
ZBX_UNUSED(state);
if (ZBX_MOCK_SUCCESS != (error = zbx_mock_out_parameter("return", ¶m_handle)) ||
ZBX_MOCK_SUCCESS != (error = zbx_mock_string(param_handle,&expected_return_string)))
{
fail_msg("Cannot get expected 'return' parameter from test case data: %s",
zbx_mock_error_string(error));
}
else
{
if (0 == strcmp("SYSINFO_RET_OK", expected_return_string))
expected_result = SYSINFO_RET_OK;
else if (0 == strcmp("SYSINFO_RET_FAIL", expected_return_string))
expected_result = SYSINFO_RET_FAIL;
else
fail_msg("Get unexpected 'return' parameter from test case data: %s", expected_return_string);
}
if (ZBX_MOCK_SUCCESS != (error = zbx_mock_in_parameter("param", ¶m_handle)) ||
ZBX_MOCK_SUCCESS != (error = zbx_mock_string(param_handle, &init_param)))
{
fail_msg("Cannot get input 'param' from test case data: %s", zbx_mock_error_string(error));
}
if (ZBX_MOCK_SUCCESS != (error = zbx_mock_out_parameter("result", ¶m_handle)) ||
ZBX_MOCK_SUCCESS != (error = zbx_mock_string(param_handle, &expected_param_value_string)))
{
fail_msg("Cannot get expected 'result' parameters from test case data: %s",
zbx_mock_error_string(error));
}
else
{
if (FAIL == is_uint64(expected_param_value_string, &expected_param_value) &&
SYSINFO_RET_OK == expected_result)
{
fail_msg("Cannot get expected numeric parameter from test case data: %s",
expected_param_value_string);
}
}
init_request(&request);
init_result(¶m_result);
if (SUCCEED != parse_item_key(init_param, &request))
fail_msg("Cannot parse item key: %s", init_param);
if (expected_result != (actual_result = NET_IF_IN(&request,¶m_result)))
{
fail_msg("Got %s instead of %s as a result.", zbx_sysinfo_ret_string(actual_result),
zbx_sysinfo_ret_string(expected_result));
}
if (SYSINFO_RET_OK == expected_result)
{
if (NULL == GET_UI64_RESULT(¶m_result) || expected_param_value != *GET_UI64_RESULT(¶m_result))
{
if (NULL != GET_UI64_RESULT(¶m_result))
{
fail_msg("Got '" ZBX_FS_UI64 "' instead of '%s' as a value.",
*GET_UI64_RESULT(¶m_result), expected_param_value_string);
}
else
fail_msg("Got 'NULL' instead of '%s' as a value.", expected_param_value_string);
}
}
else /* SYSINFO_RET_FAIL == expected_result */
{
if (NULL == GET_MSG_RESULT(¶m_result) ||
0 != strcmp(expected_param_value_string, *GET_MSG_RESULT(¶m_result)))
{
fail_msg("Got '%s' instead of '%s' as a value.",
(NULL != GET_MSG_RESULT(¶m_result) ?
*GET_MSG_RESULT(¶m_result) : "NULL"),
expected_param_value_string);
}
}
free_request(&request);
free_result(¶m_result);
}
/******************************************************************************
* *
* Function: get_value_aggregate *
* *
* Purpose: retrieve data from Zabbix server (aggregate items) *
* *
* Parameters: item - item we are interested in *
* *
* Return value: SUCCEED - data successfully retrieved and stored in result *
* and result_str (as string) *
* NOTSUPPORTED - requested item is not supported *
* *
* Author: Alexei Vladishev *
* *
******************************************************************************/
int get_value_aggregate(DC_ITEM *item, AGENT_RESULT *result)
{
const char *__function_name = "get_value_aggregate";
AGENT_REQUEST request;
int ret = NOTSUPPORTED;
const char *tmp, *groups, *itemkey, *funcp = NULL;
int grp_func, item_func, params_num;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() key:'%s'", __function_name, item->key_orig);
init_request(&request);
if (ITEM_VALUE_TYPE_FLOAT != item->value_type && ITEM_VALUE_TYPE_UINT64 != item->value_type)
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Value type must be Numeric for aggregate items"));
goto out;
}
if (SUCCEED != parse_item_key(item->key, &request))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid item key format."));
goto out;
}
if (0 == strcmp(get_rkey(&request), "grpmin"))
{
grp_func = ZBX_VALUE_FUNC_MIN;
}
else if (0 == strcmp(get_rkey(&request), "grpavg"))
{
grp_func = ZBX_VALUE_FUNC_AVG;
}
else if (0 == strcmp(get_rkey(&request), "grpmax"))
{
grp_func = ZBX_VALUE_FUNC_MAX;
}
else if (0 == strcmp(get_rkey(&request), "grpsum"))
{
grp_func = ZBX_VALUE_FUNC_SUM;
}
else
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid item key."));
goto out;
}
params_num = get_rparams_num(&request);
if (3 > params_num || params_num > 4)
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid number of parameters."));
goto out;
}
groups = get_rparam(&request, 0);
itemkey = get_rparam(&request, 1);
tmp = get_rparam(&request, 2);
if (0 == strcmp(tmp, "min"))
item_func = ZBX_VALUE_FUNC_MIN;
else if (0 == strcmp(tmp, "avg"))
item_func = ZBX_VALUE_FUNC_AVG;
else if (0 == strcmp(tmp, "max"))
item_func = ZBX_VALUE_FUNC_MAX;
else if (0 == strcmp(tmp, "sum"))
item_func = ZBX_VALUE_FUNC_SUM;
else if (0 == strcmp(tmp, "count"))
item_func = ZBX_VALUE_FUNC_COUNT;
else if (0 == strcmp(tmp, "last"))
item_func = ZBX_VALUE_FUNC_LAST;
else
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid third parameter."));
goto out;
}
if (4 == params_num)
{
funcp = get_rparam(&request, 3);
}
else if (3 == params_num && ZBX_VALUE_FUNC_LAST != item_func)
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid number of parameters."));
goto out;
}
if (SUCCEED != evaluate_aggregate(item, result, grp_func, groups, itemkey, item_func, funcp))
goto out;
ret = SUCCEED;
out:
free_request(&request);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
/******************************************************************************
* *
* Function: get_value_db *
* *
* Purpose: retrieve data from database *
* *
* Parameters: item - item we are interested in *
* *
* Return value: SUCCEED - data successfully retrieved and stored in result *
* NOTSUPPORTED - requested item is not supported *
* *
* Author: Eugene Grigorjev *
* *
* Comments: *
* *
******************************************************************************/
int get_value_db(DC_ITEM *item, AGENT_RESULT *result)
{
const char *__function_name = "get_value_db";
ZBX_ODBC_DBH dbh;
ZBX_ODBC_ROW row;
AGENT_REQUEST request;
int ret = NOTSUPPORTED;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() key_orig:'%s'", __function_name, item->key_orig);
init_request(&request);
if (SUCCEED != parse_item_key(item->key, &request))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Key is badly formatted."));
goto out;
}
if (0 != strcmp(request.key, "db.odbc.select"))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Item key is not supported."));
goto out;
}
if (2 != request.nparam)
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid number of parameters."));
goto out;
}
if (SUCCEED == odbc_DBconnect(&dbh, request.params[1], item->username, item->password, CONFIG_TIMEOUT))
{
if (NULL != odbc_DBselect(&dbh, item->params))
{
if (NULL != (row = odbc_DBfetch(&dbh)))
{
if (NULL == row[0])
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "SQL query returned NULL value."));
}
else if (SUCCEED == set_result_type(result, item->value_type, item->data_type, row[0]))
{
ret = SUCCEED;
}
}
else
{
const char *last_error = get_last_odbc_strerror();
if ('\0' != *last_error)
SET_MSG_RESULT(result, zbx_strdup(NULL, last_error));
else
SET_MSG_RESULT(result, zbx_strdup(NULL, "SQL query returned empty result."));
}
}
else
SET_MSG_RESULT(result, zbx_strdup(NULL, get_last_odbc_strerror()));
odbc_DBclose(&dbh);
}
else
SET_MSG_RESULT(result, zbx_strdup(NULL, get_last_odbc_strerror()));
out:
free_request(&request);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
int get_value_simple(DC_ITEM *item, AGENT_RESULT *result, zbx_vector_ptr_t *add_results)
{
AGENT_REQUEST request;
vmfunc_t vmfunc;
int ret = NOTSUPPORTED;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() key_orig:'%s' addr:'%s'", __func__, item->key_orig, item->interface.addr);
init_request(&request);
if (SUCCEED != parse_item_key(item->key, &request))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid item key format."));
goto out;
}
request.lastlogsize = item->lastlogsize;
if (0 == strcmp(request.key, "net.tcp.service") || 0 == strcmp(request.key, "net.udp.service"))
{
if (SYSINFO_RET_OK == check_service(&request, item->interface.addr, result, 0))
ret = SUCCEED;
}
else if (0 == strcmp(request.key, "net.tcp.service.perf") || 0 == strcmp(request.key, "net.udp.service.perf"))
{
if (SYSINFO_RET_OK == check_service(&request, item->interface.addr, result, 1))
ret = SUCCEED;
}
else if (SUCCEED == get_vmware_function(request.key, &vmfunc))
{
if (NULL != vmfunc)
{
if (0 == get_process_type_forks(ZBX_PROCESS_TYPE_VMWARE))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "No \"vmware collector\" processes started."));
goto out;
}
if (SYSINFO_RET_OK == vmfunc(&request, item->username, item->password, result))
ret = SUCCEED;
}
else
SET_MSG_RESULT(result, zbx_strdup(NULL, "Support for VMware checks was not compiled in."));
}
else if (0 == strcmp(request.key, ZBX_VMWARE_PREFIX "eventlog"))
{
#if defined(HAVE_LIBXML2) && defined(HAVE_LIBCURL)
if (SYSINFO_RET_OK == check_vcenter_eventlog(&request, item, result, add_results))
ret = SUCCEED;
#else
ZBX_UNUSED(add_results);
SET_MSG_RESULT(result, zbx_strdup(NULL, "Support for VMware checks was not compiled in."));
#endif
}
else
{
/* it will execute item from a loadable module if any */
if (SUCCEED == process(item->key, PROCESS_MODULE_COMMAND, result))
ret = SUCCEED;
}
if (NOTSUPPORTED == ret && !ISSET_MSG(result))
SET_MSG_RESULT(result, zbx_strdup(NULL, "Simple check is not supported."));
out:
free_request(&request);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __func__, zbx_result_string(ret));
return ret;
}
