static int db_odbc_select(DC_ITEM *item, AGENT_REQUEST *request, AGENT_RESULT *result)
{
const char *__function_name = "db_odbc_select";
int ret = NOTSUPPORTED;
ZBX_ODBC_DBH dbh;
ZBX_ODBC_ROW row;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() query:'%s'", __function_name, item->params);
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))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, get_last_odbc_strerror()));
goto out;
}
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);
out:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
/******************************************************************************
* *
* Function: set_item_value *
* *
* Purpose: set item value for an SNMP Trap item *
* *
* Author: Rudolfs Kreicbergs *
* *
******************************************************************************/
static void set_item_value(DC_ITEM *item, char *trap, zbx_timespec_t *ts)
{
AGENT_RESULT value;
int timestamp = 0;
init_result(&value);
if (SUCCEED == set_result_type(&value, item->value_type, item->data_type, trap))
{
if (ITEM_VALUE_TYPE_LOG == item->value_type)
calc_timestamp(trap, ×tamp, item->logtimefmt);
dc_add_history(item->itemid, item->value_type, item->flags, &value,
ts, ITEM_STATUS_ACTIVE, NULL, timestamp, NULL, 0, 0, 0, 0);
}
else
{
dc_add_history(item->itemid, item->value_type, item->flags, NULL,
ts, ITEM_STATUS_NOTSUPPORTED, value.msg, 0, NULL, 0, 0, 0, 0);
}
free_result(&value);
}
ConstMethod::ConstMethod(int byte_code_size,
InlineTableSizes* sizes,
MethodType method_type,
int size) {
NoSafepointVerifier no_safepoint;
init_fingerprint();
set_constants(NULL);
set_stackmap_data(NULL);
set_code_size(byte_code_size);
set_constMethod_size(size);
set_inlined_tables_length(sizes); // sets _flags
set_method_type(method_type);
assert(this->size() == size, "wrong size for object");
set_name_index(0);
set_signature_index(0);
set_constants(NULL);
set_max_stack(0);
set_max_locals(0);
set_method_idnum(0);
set_size_of_parameters(0);
set_result_type(T_VOID);
}
/******************************************************************************
* *
* Function: get_value_agent *
* *
* Purpose: retrieve data from Zabbix agent *
* *
* Parameters: item - item we are interested in *
* *
* Return value: SUCCEED - data successfully retrieved and stored in result *
* and result_str (as string) *
* NETWORK_ERROR - network related error occurred *
* NOTSUPPORTED - item not supported by the agent *
* AGENT_ERROR - uncritical error on agent side occurred *
* FAIL - otherwise *
* *
* Author: Alexei Vladishev *
* *
* Comments: error will contain error message *
* *
******************************************************************************/
int get_value_agent(DC_ITEM *item, AGENT_RESULT *result)
{
const char *__function_name = "get_value_agent";
zbx_socket_t s;
char buffer[MAX_STRING_LEN];
int ret = SUCCEED;
ssize_t received_len;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() host:'%s' addr:'%s' key:'%s'",
__function_name, item->host.host, item->interface.addr, item->key);
if (SUCCEED == (ret = zbx_tcp_connect(&s, CONFIG_SOURCE_IP, item->interface.addr, item->interface.port, 0)))
{
zbx_snprintf(buffer, sizeof(buffer), "%s\n", item->key);
zabbix_log(LOG_LEVEL_DEBUG, "Sending [%s]", buffer);
/* send requests using old protocol */
if (SUCCEED != zbx_tcp_send_raw(&s, buffer))
ret = NETWORK_ERROR;
else if (FAIL != (received_len = zbx_tcp_recv_ext(&s, ZBX_TCP_READ_UNTIL_CLOSE, 0)))
ret = SUCCEED;
else
ret = TIMEOUT_ERROR;
}
else
ret = NETWORK_ERROR;
if (SUCCEED == ret)
{
zbx_rtrim(s.buffer, " \r\n");
zbx_ltrim(s.buffer, " ");
zabbix_log(LOG_LEVEL_DEBUG, "get value from agent result: '%s'", s.buffer);
if (0 == strcmp(s.buffer, ZBX_NOTSUPPORTED))
{
/* 'ZBX_NOTSUPPORTED\0<error message>' */
if (sizeof(ZBX_NOTSUPPORTED) < s.read_bytes)
zbx_snprintf(buffer, sizeof(buffer), "%s", s.buffer + sizeof(ZBX_NOTSUPPORTED));
else
zbx_snprintf(buffer, sizeof(buffer), "Not supported by Zabbix Agent");
SET_MSG_RESULT(result, strdup(buffer));
ret = NOTSUPPORTED;
}
else if (0 == strcmp(s.buffer, ZBX_ERROR))
{
zbx_snprintf(buffer, sizeof(buffer), "Zabbix Agent non-critical error");
SET_MSG_RESULT(result, strdup(buffer));
ret = AGENT_ERROR;
}
else if (0 == received_len)
{
zbx_snprintf(buffer, sizeof(buffer), "Received empty response from Zabbix Agent at [%s]."
" Assuming that agent dropped connection because of access permissions.",
item->interface.addr);
SET_MSG_RESULT(result, strdup(buffer));
ret = NETWORK_ERROR;
}
else if (SUCCEED != set_result_type(result, item->value_type, item->data_type, s.buffer))
ret = NOTSUPPORTED;
}
else
{
zbx_snprintf(buffer, sizeof(buffer), "Get value from agent failed: %s",
zbx_socket_strerror());
SET_MSG_RESULT(result, strdup(buffer));
}
zbx_tcp_close(&s);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
/******************************************************************************
* *
* 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: 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";
#ifdef HAVE_ODBC
ZBX_ODBC_DBH dbh;
ZBX_ODBC_ROW row;
char *db_dsn = NULL, *db_user = NULL, *db_pass = NULL, *db_sql = NULL;
#endif
int ret = NOTSUPPORTED;
init_result(result);
zabbix_log(LOG_LEVEL_DEBUG, "In %s() key_orig:'%s'", __function_name, item->key_orig);
#ifdef HAVE_ODBC
#define DB_ODBC_SELECT_KEY "db.odbc.select["
if (0 == strncmp(item->key, DB_ODBC_SELECT_KEY, strlen(DB_ODBC_SELECT_KEY)))
{
db_dsn = get_param_value(item->params, "DSN");
db_user = get_param_value(item->params, "user");
db_pass = get_param_value(item->params, "password");
db_sql = get_param_value(item->params, "sql");
if (SUCCEED == odbc_DBconnect(&dbh, db_dsn, db_user, db_pass, CONFIG_TIMEOUT))
{
if (NULL != odbc_DBselect(&dbh, db_sql))
{
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()));
zbx_free(db_dsn);
zbx_free(db_user);
zbx_free(db_pass);
zbx_free(db_sql);
}
#undef DB_ODBC_SELECT_KEY
#endif /* HAVE_ODBC */
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
static int parse_response(DC_ITEM *items, AGENT_RESULT *results, int *errcodes, int num,
char *response, char *error, int max_error_len)
{
const char *p;
struct zbx_json_parse jp, jp_data, jp_row;
char *value = NULL;
size_t value_alloc = 0;
int i, ret = GATEWAY_ERROR;
if (SUCCEED == zbx_json_open(response, &jp))
{
if (SUCCEED != zbx_json_value_by_name_dyn(&jp, ZBX_PROTO_TAG_RESPONSE, &value, &value_alloc))
{
zbx_snprintf(error, max_error_len, "No '%s' tag in received JSON", ZBX_PROTO_TAG_RESPONSE);
goto exit;
}
if (0 == strcmp(value, ZBX_PROTO_VALUE_SUCCESS))
{
if (SUCCEED != zbx_json_brackets_by_name(&jp, ZBX_PROTO_TAG_DATA, &jp_data))
{
zbx_strlcpy(error, "Cannot open data array in received JSON", max_error_len);
goto exit;
}
p = NULL;
for (i = 0; i < num; i++)
{
if (SUCCEED != errcodes[i])
continue;
if (NULL == (p = zbx_json_next(&jp_data, p)))
{
zbx_strlcpy(error, "Not all values included in received JSON", max_error_len);
goto exit;
}
if (SUCCEED != zbx_json_brackets_open(p, &jp_row))
{
zbx_strlcpy(error, "Cannot open value object in received JSON", max_error_len);
goto exit;
}
if (SUCCEED == zbx_json_value_by_name_dyn(&jp_row, ZBX_PROTO_TAG_VALUE, &value, &value_alloc))
{
if (SUCCEED == set_result_type(&results[i],
items[i].value_type, items[i].data_type, value))
errcodes[i] = SUCCEED;
else
errcodes[i] = NOTSUPPORTED;
}
else if (SUCCEED == zbx_json_value_by_name_dyn(&jp_row, ZBX_PROTO_TAG_ERROR, &value, &value_alloc))
{
SET_MSG_RESULT(&results[i], zbx_strdup(NULL, value));
errcodes[i] = NOTSUPPORTED;
}
else
{
SET_MSG_RESULT(&results[i], zbx_strdup(NULL, "Cannot get item value or error message"));
errcodes[i] = AGENT_ERROR;
}
}
ret = SUCCEED;
}
else if (0 == strcmp(value, ZBX_PROTO_VALUE_FAILED))
{
if (SUCCEED == zbx_json_value_by_name(&jp, ZBX_PROTO_TAG_ERROR, error, max_error_len))
ret = NETWORK_ERROR;
else
zbx_strlcpy(error, "Cannot get error message describing reasons for failure", max_error_len);
goto exit;
}
else
{
zbx_snprintf(error, max_error_len, "Bad '%s' tag value '%s' in received JSON",
ZBX_PROTO_TAG_RESPONSE, value);
goto exit;
}
}
else
{
zbx_strlcpy(error, "Cannot open received JSON", max_error_len);
goto exit;
}
exit:
zbx_free(value);
return ret;
}
/******************************************************************************
* *
* Function: process_data *
* *
* Purpose: process new item value *
* *
* Parameters: sockfd - descriptor of agent-server socket connection *
* server - server name *
* key - item's key *
* value - new value of server:key *
* lastlogsize - if key=log[*], last size of log file *
* *
* Return value: SUCCEED - new value processed sucesfully *
* FAIL - otherwise *
* *
* Author: Alexei Vladishev *
* *
* Comments: for trapper server process *
* *
******************************************************************************/
static void process_mass_data(zbx_sock_t *sock, zbx_uint64_t proxy_hostid, AGENT_VALUE *values, int value_num,
int *processed, time_t proxy_timediff)
{
AGENT_RESULT agent;
DB_RESULT result;
DB_ROW row;
DB_ITEM item;
char host_esc[MAX_STRING_LEN], key_esc[MAX_STRING_LEN];
static char *sql = NULL;
static int sql_allocated = 65536;
int sql_offset = 0, i;
zabbix_log(LOG_LEVEL_DEBUG, "In process_mass_data()");
if (NULL == sql)
sql = zbx_malloc(sql, sql_allocated);
DCinit_nextchecks();
zbx_snprintf_alloc(&sql, &sql_allocated, &sql_offset, 2048,
"select %s where h.hostid=i.hostid and h.proxy_hostid=" ZBX_FS_UI64
" and h.status=%d and i.status in (%d,%d)",
ZBX_SQL_ITEM_SELECT,
proxy_hostid,
HOST_STATUS_MONITORED,
ITEM_STATUS_ACTIVE, ITEM_STATUS_NOTSUPPORTED);
if (proxy_hostid == 0)
{
zbx_snprintf_alloc(&sql, &sql_allocated, &sql_offset, 64,
" and i.type in (%d,%d)",
ITEM_TYPE_TRAPPER,
ITEM_TYPE_ZABBIX_ACTIVE);
}
else
{
zbx_snprintf_alloc(&sql, &sql_allocated, &sql_offset, 64,
" and i.type in (%d,%d,%d,%d,%d,%d,%d,%d,%d,%d)",
ITEM_TYPE_ZABBIX,
ITEM_TYPE_SNMPv1,
ITEM_TYPE_TRAPPER,
ITEM_TYPE_SIMPLE,
ITEM_TYPE_SNMPv2c,
ITEM_TYPE_SNMPv3,
ITEM_TYPE_ZABBIX_ACTIVE,
ITEM_TYPE_HTTPTEST,
ITEM_TYPE_EXTERNAL,
ITEM_TYPE_IPMI);
}
zbx_snprintf_alloc(&sql, &sql_allocated, &sql_offset, 8, " and (");
for (i = 0; i < value_num; i++)
{
DBescape_string(values[i].host_name, host_esc, sizeof(host_esc));
DBescape_string(values[i].key, key_esc, sizeof(key_esc));
zbx_snprintf_alloc(&sql, &sql_allocated, &sql_offset, 512,
"(h.host='%s' and i.key_='%s') or ",
host_esc,
key_esc);
}
sql_offset -= 4;
zbx_snprintf_alloc(&sql, &sql_allocated, &sql_offset, 128, ")" DB_NODE,
DBnode_local("h.hostid"));
result = DBselect("%s", sql);
while (NULL != (row = DBfetch(result))) {
DBget_item_from_db(&item, row);
if (item.type == ITEM_TYPE_ZABBIX_ACTIVE && FAIL == zbx_tcp_check_security(sock, item.trapper_hosts, 1))
continue;
if (item.maintenance_status == HOST_MAINTENANCE_STATUS_ON && item.maintenance_type == MAINTENANCE_TYPE_NODATA &&
item.maintenance_from <= values[i].clock)
continue;
for (i = 0; i < value_num; i++)
{
if (0 == strcmp(item.host_name, values[i].host_name) && 0 == strcmp(item.key_orig, values[i].key)) {
/* zabbix_log(LOG_LEVEL_DEBUG, "Processing [%s@%s: \"%s\"]",
item.key,
item.host_name,
values[i].value);*/
if (0 == strcmp(values[i].value, "ZBX_NOTSUPPORTED"))
{
zabbix_log(LOG_LEVEL_WARNING, "Active parameter [%s] is not supported by agent on host [%s]",
item.key_orig,
item.host_name);
zabbix_syslog("Active parameter [%s] is not supported by agent on host [%s]",
item.key_orig,
item.host_name);
DCadd_nextcheck(&item, values[i].clock, proxy_timediff, "Not supported by ZABBIX agent");
if (NULL != processed)
(*processed)++;
}
else
{
if (0 == strncmp(item.key, "log[", 4) || 0 == strncmp(item.key, "eventlog[", 9))
{
item.lastlogsize = values[i].lastlogsize;
item.timestamp = values[i].timestamp;
calc_timestamp(values[i].value, &item.timestamp, item.logtimefmt);
item.eventlog_severity = values[i].severity;
item.eventlog_source = values[i].source;
/* zabbix_log(LOG_LEVEL_DEBUG, "Value [%s] Lastlogsize [%s] Timestamp [%s]",
values[i].value,
item.lastlogsize,
item.timestamp);*/
}
init_result(&agent);
if (SUCCEED == set_result_type(&agent, item.value_type, item.data_type, values[i].value))
{
if (0 == CONFIG_DBSYNCER_FORKS)
DBbegin();
switch (zbx_process) {
case ZBX_PROCESS_SERVER:
process_new_value(&item, &agent, values[i].clock);
break;
case ZBX_PROCESS_PROXY:
proxy_process_new_value(&item, &agent, values[i].clock);
break;
}
if (0 == CONFIG_DBSYNCER_FORKS)
DBcommit();
if (NULL != processed)
(*processed)++;
/* only for screen Administration|Queue */
if (item.type != ITEM_TYPE_TRAPPER && item.type != ITEM_TYPE_HTTPTEST &&
item.value_type != ITEM_VALUE_TYPE_LOG &&
0 != strcmp(item.key, SERVER_STATUS_KEY) &&
0 != strcmp(item.key, SERVER_ICMPPING_KEY) &&
0 != strcmp(item.key, SERVER_ICMPPINGSEC_KEY) &&
0 != strcmp(item.key, SERVER_ZABBIXLOG_KEY))
DCadd_nextcheck(&item, values[i].clock, proxy_timediff, NULL);
}
else
{
if (GET_MSG_RESULT(&agent))
zabbix_log(LOG_LEVEL_WARNING, "Item [%s] error: %s",
zbx_host_key_string_by_item(&item),
agent.msg);
}
free_result(&agent);
}
}
}
}
DBfree_result(result);
DCflush_nextchecks();
}
/******************************************************************************
* *
* Function: get_value_external *
* *
* Purpose: retrieve data from script executed on Zabbix server *
* *
* 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: Mike Nestor, rewritten by Alexander Vladishev *
* *
******************************************************************************/
int get_value_external(DC_ITEM *item, AGENT_RESULT *result)
{
const char *__function_name = "get_value_external";
char key[MAX_STRING_LEN], params[MAX_STRING_LEN], error[ITEM_ERROR_LEN_MAX],
*cmd = NULL, *buf = NULL;
size_t cmd_alloc = ZBX_KIBIBYTE, cmd_offset = 0;
int rc, ret = NOTSUPPORTED;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() key:'%s'", __function_name, item->key_orig);
if (ZBX_COMMAND_ERROR == (rc = parse_command(item->key, key, sizeof(key), params, sizeof(params))))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Key is badly formatted"));
goto notsupported;
}
cmd = zbx_malloc(cmd, cmd_alloc);
zbx_snprintf_alloc(&cmd, &cmd_alloc, &cmd_offset, "%s/%s", CONFIG_EXTERNALSCRIPTS, key);
if (-1 == access(cmd, X_OK))
{
SET_MSG_RESULT(result, zbx_dsprintf(NULL, "%s: %s", cmd, zbx_strerror(errno)));
goto notsupported;
}
if (ZBX_COMMAND_WITH_PARAMS == rc)
{
int i, n;
char param[MAX_STRING_LEN], *param_esc;
if (0 == (n = num_param(params)))
{
SET_MSG_RESULT(result, zbx_strdup(NULL, "Key is badly formatted"));
goto notsupported;
}
for (i = 1; i <= n; i++)
{
if (0 != get_param(params, i, param, sizeof(param)))
{
THIS_SHOULD_NEVER_HAPPEN;
*param = '\0';
}
param_esc = zbx_dyn_escape_string(param, "\"\\");
zbx_snprintf_alloc(&cmd, &cmd_alloc, &cmd_offset, " \"%s\"", param_esc);
zbx_free(param_esc);
}
}
if (SUCCEED == zbx_execute(cmd, &buf, error, sizeof(error), CONFIG_TIMEOUT))
{
zbx_rtrim(buf, ZBX_WHITESPACE);
if (SUCCEED == set_result_type(result, item->value_type, item->data_type, buf))
ret = SUCCEED;
zbx_free(buf);
}
else
SET_MSG_RESULT(result, zbx_strdup(NULL, error));
notsupported:
zbx_free(cmd);
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;
}
/******************************************************************************
* *
* Function: get_value_agent *
* *
* Purpose: retrieve data from ZABBIX agent *
* *
* Parameters: item - item we are interested in *
* *
* Return value: SUCCEED - data successfully retrieved and stored in result *
* and result_str (as string) *
* NETWORK_ERROR - network related error occurred *
* NOTSUPPORTED - item not supported by the agent *
* AGENT_ERROR - uncritical error on agent side occurred *
* FAIL - otherwise *
* *
* Author: Alexei Vladishev *
* *
* Comments: error will contain error message *
* *
******************************************************************************/
int get_value_agent(DB_ITEM *item, AGENT_RESULT *result)
{
zbx_sock_t s;
char *addr, *buf, buffer[MAX_STRING_LEN];
int ret = SUCCEED;
init_result(result);
addr = (item->useip == 1) ? item->host_ip : item->host_dns;
zabbix_log( LOG_LEVEL_DEBUG, "In get_value_agent(host:%s,addr:%s,key:%s)",
item->host_name,
addr,
item->key);
if (SUCCEED == (ret = zbx_tcp_connect(&s, CONFIG_SOURCE_IP, addr, item->port, 0)))
{
zbx_snprintf(buffer, sizeof(buffer), "%s\n", item->key);
zabbix_log(LOG_LEVEL_DEBUG, "Sending [%s]", buffer);
/* Send requests using old protocol */
if (SUCCEED == (ret = zbx_tcp_send_raw(&s, buffer)))
ret = zbx_tcp_recv_ext(&s, &buf, ZBX_TCP_READ_UNTIL_CLOSE);
}
if (SUCCEED == ret)
{
zbx_rtrim(buf, " \r\n");
zbx_ltrim(buf, " ");
zabbix_log(LOG_LEVEL_DEBUG, "Get value from agent result: '%s'", buf);
if (0 == strcmp(buf, "ZBX_NOTSUPPORTED"))
{
zbx_snprintf(buffer, sizeof(buffer), "Not supported by ZABBIX agent");
SET_MSG_RESULT(result, strdup(buffer));
ret = NOTSUPPORTED;
}
else if (0 == strcmp(buf, "ZBX_ERROR"))
{
zbx_snprintf(buffer, sizeof(buffer), "ZABBIX agent non-critical error");
SET_MSG_RESULT(result, strdup(buffer));
ret = AGENT_ERROR;
}
else if ('\0' == *buf) /* The section should be improved */
{
zbx_snprintf(buffer, sizeof(buffer), "Got empty string from [%s]. Assuming that agent dropped connection because of access permissions",
item->useip ? item->host_ip : item->host_dns);
SET_MSG_RESULT(result, strdup(buffer));
ret = NETWORK_ERROR;
}
else if (SUCCEED != set_result_type(result, item->value_type, item->data_type, buf))
ret = NOTSUPPORTED;
}
else
{
zbx_snprintf(buffer, sizeof(buffer), "Get value from agent failed: %s",
zbx_tcp_strerror());
SET_MSG_RESULT(result, strdup(buffer));
ret = NETWORK_ERROR;
}
zbx_tcp_close(&s);
return ret;
}
