static void process_listener(zbx_sock_t *s)
{
AGENT_RESULT result;
char *command;
char **value = NULL;
int ret;
if (SUCCEED == (ret = zbx_tcp_recv_to(s, &command, CONFIG_TIMEOUT)))
{
zbx_rtrim(command, "\r\n");
zabbix_log(LOG_LEVEL_DEBUG, "Requested [%s]", command);
init_result(&result);
process(command, 0, &result);
if (NULL == (value = GET_TEXT_RESULT(&result)))
value = GET_MSG_RESULT(&result);
if (NULL != value)
{
zabbix_log(LOG_LEVEL_DEBUG, "Sending back [%s]", *value);
ret = zbx_tcp_send_to(s, *value, CONFIG_TIMEOUT);
}
free_result(&result);
}
if (FAIL == ret)
zabbix_log(LOG_LEVEL_DEBUG, "Process listener error: %s", zbx_tcp_strerror());
}
static void process_listener(zbx_socket_t *s)
{
AGENT_RESULT result;
char **value = NULL;
int ret;
if (SUCCEED == (ret = zbx_tcp_recv_to(s, CONFIG_TIMEOUT)))
{
zbx_rtrim(s->buffer, "\r\n");
zabbix_log(LOG_LEVEL_DEBUG, "Requested [%s]", s->buffer);
init_result(&result);
if (SUCCEED == process(s->buffer, PROCESS_WITH_ALIAS, &result))
{
if (NULL != (value = GET_TEXT_RESULT(&result)))
{
zabbix_log(LOG_LEVEL_DEBUG, "Sending back [%s]", *value);
ret = zbx_tcp_send_to(s, *value, CONFIG_TIMEOUT);
}
}
else
{
value = GET_MSG_RESULT(&result);
if (NULL != value)
{
static char *buffer = NULL;
static size_t buffer_alloc = 256;
size_t buffer_offset = 0;
zabbix_log(LOG_LEVEL_DEBUG, "Sending back [" ZBX_NOTSUPPORTED ": %s]", *value);
if (NULL == buffer)
buffer = (char *)zbx_malloc(buffer, buffer_alloc);
zbx_strncpy_alloc(&buffer, &buffer_alloc, &buffer_offset,
ZBX_NOTSUPPORTED, ZBX_CONST_STRLEN(ZBX_NOTSUPPORTED));
buffer_offset++;
zbx_strcpy_alloc(&buffer, &buffer_alloc, &buffer_offset, *value);
ret = zbx_tcp_send_bytes_to(s, buffer, buffer_offset, CONFIG_TIMEOUT);
}
else
{
zabbix_log(LOG_LEVEL_DEBUG, "Sending back [" ZBX_NOTSUPPORTED "]");
ret = zbx_tcp_send_to(s, ZBX_NOTSUPPORTED, CONFIG_TIMEOUT);
}
}
free_result(&result);
}
if (FAIL == ret)
zabbix_log(LOG_LEVEL_DEBUG, "Process listener error: %s", zbx_socket_strerror());
}
static void process_active_checks(char *server, unsigned short port)
{
register int i, s_count, p_count;
char **pvalue;
int now, send_err = SUCCEED, ret;
unsigned long timestamp;
char *source = NULL;
char *value = NULL;
unsigned short severity;
long lastlogsize;
char params[MAX_STRING_LEN];
char filename[MAX_STRING_LEN];
char pattern[MAX_STRING_LEN];
AGENT_RESULT result;
zabbix_log( LOG_LEVEL_DEBUG, "In process_active_checks('%s',%u)",server, port);
init_result(&result);
now = (int)time(NULL);
for(i=0; NULL != active_metrics[i].key && SUCCEED == send_err; i++)
{
if(active_metrics[i].nextcheck > now) continue;
if(active_metrics[i].status != ITEM_STATUS_ACTIVE) continue;
/* Special processing for log files */
if(strncmp(active_metrics[i].key,"log[",4) == 0)
{
do{ /* simple try realization */
if (parse_command(active_metrics[i].key, NULL, 0, params, MAX_STRING_LEN) != 2)
break;
if (num_param(params) > 2)
break;
if (get_param(params, 1, filename, sizeof(filename)) != 0)
break;
if (get_param(params, 2, pattern, sizeof(pattern)) != 0)
*pattern = '\0';
s_count = 0;
p_count = 0;
lastlogsize = active_metrics[i].lastlogsize;
while (SUCCEED == (ret = process_log(filename, &lastlogsize, &value))) {
if (!value) /* EOF */
break;
if (SUCCEED == regexp_match_ex(regexps, regexps_num, value, pattern, ZBX_CASE_SENSITIVE)) {
send_err = process_value(
server,
port,
CONFIG_HOSTNAME,
active_metrics[i].key_orig,
value,
&lastlogsize,
NULL,
NULL,
NULL
);
s_count++;
}
p_count++;
zbx_free(value);
if (SUCCEED == send_err)
active_metrics[i].lastlogsize = lastlogsize;
else
lastlogsize = active_metrics[i].lastlogsize;
/* Do not flood ZABBIX server if file grows too fast */
if(s_count >= (MAX_LINES_PER_SECOND * active_metrics[i].refresh)) break;
/* Do not flood local system if file grows too fast */
if(p_count >= (4 * MAX_LINES_PER_SECOND * active_metrics[i].refresh)) break;
}
if( FAIL == ret )
{
active_metrics[i].status = ITEM_STATUS_NOTSUPPORTED;
zabbix_log( LOG_LEVEL_WARNING, "Active check [%s] is not supported. Disabled.",
active_metrics[i].key);
send_err = process_value(
server,
port,
CONFIG_HOSTNAME,
active_metrics[i].key_orig,
"ZBX_NOTSUPPORTED",
&active_metrics[i].lastlogsize,
NULL,
NULL,
NULL
);
}
}while(0); /* simple try realization */
}
/* Special processing for eventlog */
else if(strncmp(active_metrics[i].key,"eventlog[",9) == 0)
{
do{ /* simple try realization */
if (parse_command(active_metrics[i].key, NULL, 0, params, MAX_STRING_LEN) != 2)
break;
if (num_param(params) > 2)
break;
if (get_param(params, 1, filename, sizeof(filename)) != 0)
break;
if (get_param(params, 2, pattern, sizeof(pattern)) != 0)
*pattern = '\0';
s_count = 0;
p_count = 0;
lastlogsize = active_metrics[i].lastlogsize;
while (SUCCEED == (ret = process_eventlog(filename, &lastlogsize,
×tamp, &source, &severity, &value)))
{
if (!value) /* EOF */
break;
if (SUCCEED == regexp_match_ex(regexps, regexps_num, value, pattern, ZBX_CASE_SENSITIVE)) {
send_err = process_value(
server,
port,
CONFIG_HOSTNAME,
active_metrics[i].key_orig,
value,
&lastlogsize,
×tamp,
source,
&severity
);
s_count++;
}
p_count++;
zbx_free(source);
zbx_free(value);
if (SUCCEED == send_err)
active_metrics[i].lastlogsize = lastlogsize;
else
lastlogsize = active_metrics[i].lastlogsize;
/* Do not flood ZABBIX server if file grows too fast */
if(s_count >= (MAX_LINES_PER_SECOND * active_metrics[i].refresh)) break;
/* Do not flood local system if file grows too fast */
if(p_count >= (4 * MAX_LINES_PER_SECOND * active_metrics[i].refresh)) break;
}
if( FAIL == ret )
{
active_metrics[i].status = ITEM_STATUS_NOTSUPPORTED;
zabbix_log( LOG_LEVEL_WARNING, "Active check [%s] is not supported. Disabled.",
active_metrics[i].key);
send_err = process_value(
server,
port,
CONFIG_HOSTNAME,
active_metrics[i].key_orig,
"ZBX_NOTSUPPORTED",
&active_metrics[i].lastlogsize,
NULL,
NULL,
NULL
);
}
}while(0); /* simple try realization NOTE: never loop */
}
else
{
process(active_metrics[i].key, 0, &result);
if( NULL == (pvalue = GET_TEXT_RESULT(&result)) )
pvalue = GET_MSG_RESULT(&result);
if(pvalue)
{
zabbix_log( LOG_LEVEL_DEBUG, "For key [%s] received value [%s]", active_metrics[i].key, *pvalue);
send_err = process_value(
server,
port,
CONFIG_HOSTNAME,
active_metrics[i].key_orig,
*pvalue,
NULL,
NULL,
NULL,
NULL
);
if( 0 == strcmp(*pvalue,"ZBX_NOTSUPPORTED") )
{
active_metrics[i].status = ITEM_STATUS_NOTSUPPORTED;
zabbix_log( LOG_LEVEL_WARNING, "Active check [%s] is not supported. Disabled.", active_metrics[i].key);
}
}
free_result(&result);
}
active_metrics[i].nextcheck = (int)time(NULL)+active_metrics[i].refresh;
}
}
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: 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();
}
int main(int argc, char **argv)
{
char ch;
int task = ZBX_TASK_START;
char *TEST_METRIC = NULL;
zbx_sock_t s_in;
zbx_sock_t s_out;
int ret;
char **value, *command;
AGENT_RESULT result;
progname = get_program_name(argv[0]);
/* parse the command-line */
while ((char)EOF != (ch = (char)zbx_getopt_long(argc, argv, "c:hVpt:", longopts, NULL)))
{
switch (ch)
{
case 'c':
CONFIG_FILE = strdup(zbx_optarg);
break;
case 'h':
help();
exit(FAIL);
break;
case 'V':
version();
#ifdef _AIX
tl_version();
#endif
exit(FAIL);
break;
case 'p':
if (task == ZBX_TASK_START)
task = ZBX_TASK_PRINT_SUPPORTED;
break;
case 't':
if (task == ZBX_TASK_START)
{
task = ZBX_TASK_TEST_METRIC;
TEST_METRIC = strdup(zbx_optarg);
}
break;
default:
usage();
exit(FAIL);
break;
}
}
if (NULL == CONFIG_FILE)
CONFIG_FILE = DEFAULT_CONFIG_FILE;
/* load configuration */
if (ZBX_TASK_PRINT_SUPPORTED == task || ZBX_TASK_TEST_METRIC == task)
zbx_load_config(ZBX_CFG_FILE_OPTIONAL);
else
zbx_load_config(ZBX_CFG_FILE_REQUIRED);
/* metrics should be initialized before loading user parameters */
init_metrics();
/* user parameters */
load_user_parameters(CONFIG_USER_PARAMETERS);
/* aliases */
load_aliases(CONFIG_ALIASES);
zbx_free_config();
/* do not create debug files */
zabbix_open_log(LOG_TYPE_SYSLOG, LOG_LEVEL_EMPTY, NULL);
switch (task)
{
case ZBX_TASK_TEST_METRIC:
case ZBX_TASK_PRINT_SUPPORTED:
if (ZBX_TASK_TEST_METRIC == task)
test_parameter(TEST_METRIC);
else
test_parameters();
zabbix_close_log();
free_metrics();
alias_list_free();
exit(SUCCEED);
break;
default:
/* do nothing */
break;
}
signal(SIGINT, child_signal_handler);
signal(SIGTERM, child_signal_handler);
signal(SIGQUIT, child_signal_handler);
signal(SIGALRM, child_signal_handler);
alarm(CONFIG_TIMEOUT);
zbx_tcp_init(&s_in, (ZBX_SOCKET)fileno(stdin));
zbx_tcp_init(&s_out, (ZBX_SOCKET)fileno(stdout));
if (SUCCEED == (ret = zbx_tcp_check_security(&s_in, CONFIG_HOSTS_ALLOWED, 0)))
{
if (SUCCEED == (ret = zbx_tcp_recv(&s_in, &command)))
{
zbx_rtrim(command, "\r\n");
zabbix_log(LOG_LEVEL_DEBUG, "Requested [%s]", command);
init_result(&result);
process(command, 0, &result);
if (NULL == (value = GET_TEXT_RESULT(&result)))
value = GET_MSG_RESULT(&result);
if (NULL != value)
{
zabbix_log(LOG_LEVEL_DEBUG, "Sending back [%s]", *value);
ret = zbx_tcp_send(&s_out, *value);
}
free_result(&result);
}
if (FAIL == ret)
zabbix_log(LOG_LEVEL_DEBUG, "Processing error: %s", zbx_tcp_strerror());
}
fflush(stdout);
alarm(0);
zabbix_close_log();
free_metrics();
alias_list_free();
return SUCCEED;
}
int get_value(DB_ITEM *item, AGENT_RESULT *result)
{
int res = FAIL;
zabbix_log(LOG_LEVEL_DEBUG, "In get_value(key:%s)",
item->key);
switch (item->type) {
case ITEM_TYPE_ZABBIX:
alarm(CONFIG_TIMEOUT);
res = get_value_agent(item, result);
alarm(0);
if (SUCCEED != res && GET_MSG_RESULT(result))
zabbix_log(LOG_LEVEL_WARNING, "Item [%s] error: %s",
zbx_host_key_string_by_item(item),
result->msg);
break;
case ITEM_TYPE_SNMPv1:
case ITEM_TYPE_SNMPv2c:
case ITEM_TYPE_SNMPv3:
#ifdef HAVE_SNMP
alarm(CONFIG_TIMEOUT);
res = get_value_snmp(item, result);
alarm(0);
#else
SET_MSG_RESULT(result, strdup("Support of SNMP parameters was not compiled in"));
res = NOTSUPPORTED;
#endif
if (SUCCEED != res && GET_MSG_RESULT(result))
zabbix_log(LOG_LEVEL_WARNING, "Item [%s] error: %s",
zbx_host_key_string_by_item(item),
result->msg);
break;
case ITEM_TYPE_IPMI:
#ifdef HAVE_OPENIPMI
res = get_value_ipmi(item, result);
#else
SET_MSG_RESULT(result, strdup("Support of IPMI parameters was not compiled in"));
res = NOTSUPPORTED;
#endif
break;
case ITEM_TYPE_SIMPLE:
alarm(CONFIG_TIMEOUT);
res = get_value_simple(item, result);
alarm(0);
break;
case ITEM_TYPE_INTERNAL:
alarm(CONFIG_TIMEOUT);
res = get_value_internal(item, result);
alarm(0);
break;
case ITEM_TYPE_DB_MONITOR:
alarm(CONFIG_TIMEOUT);
res = get_value_db(item, result);
alarm(0);
if (SUCCEED != res && GET_MSG_RESULT(result))
zabbix_log(LOG_LEVEL_WARNING, "Item [%s] error: %s",
zbx_host_key_string_by_item(item),
result->msg);
break;
case ITEM_TYPE_AGGREGATE:
alarm(CONFIG_TIMEOUT);
res = get_value_aggregate(item, result);
alarm(0);
break;
case ITEM_TYPE_EXTERNAL:
alarm(CONFIG_TIMEOUT);
res = get_value_external(item, result);
alarm(0);
if (SUCCEED != res && GET_MSG_RESULT(result))
zabbix_log(LOG_LEVEL_WARNING, "Item [%s] error: %s",
zbx_host_key_string_by_item(item),
result->msg);
break;
default:
zabbix_log(LOG_LEVEL_WARNING, "Not supported item type:%d",
item->type);
zabbix_syslog("Not supported item type:%d",
item->type);
res = NOTSUPPORTED;
}
zabbix_log(LOG_LEVEL_DEBUG, "End get_value()");
return res;
}
int main(int argc, char **argv)
{
char ch;
int task = ZBX_TASK_START;
char *TEST_METRIC = NULL;
zbx_sock_t s_in;
zbx_sock_t s_out;
int ret;
char **value, *command;
AGENT_RESULT result;
memset(&result, 0, sizeof(AGENT_RESULT));
progname = get_program_name(argv[0]);
/* Parse the command-line. */
while ((ch = (char)zbx_getopt_long(argc, argv, "c:hVpt:", longopts, NULL)) != (char)EOF)
switch (ch)
{
case 'c':
CONFIG_FILE = strdup(zbx_optarg);
break;
case 'h':
help();
exit(-1);
break;
case 'V':
version();
#ifdef _AIX
tl_version();
#endif /* _AIX */
exit(-1);
break;
case 'p':
if (task == ZBX_TASK_START)
task = ZBX_TASK_PRINT_SUPPORTED;
break;
case 't':
if (task == ZBX_TASK_START)
{
task = ZBX_TASK_TEST_METRIC;
TEST_METRIC = strdup(zbx_optarg);
}
break;
default:
task = ZBX_TASK_SHOW_USAGE;
break;
}
if (CONFIG_FILE == NULL)
CONFIG_FILE = DEFAULT_CONFIG_FILE;
init_metrics();
if (ZBX_TASK_START == task)
{
load_config();
load_user_parameters(0);
}
/* Do not create debug files */
zabbix_open_log(LOG_TYPE_SYSLOG, LOG_LEVEL_EMPTY, NULL);
switch (task)
{
case ZBX_TASK_PRINT_SUPPORTED:
load_user_parameters(1);
test_parameters();
exit(-1);
break;
case ZBX_TASK_TEST_METRIC:
load_user_parameters(1);
test_parameter(TEST_METRIC, PROCESS_TEST);
exit(-1);
break;
case ZBX_TASK_SHOW_USAGE:
usage();
exit(-1);
break;
}
signal(SIGINT, child_signal_handler);
signal(SIGTERM, child_signal_handler);
signal(SIGQUIT, child_signal_handler);
signal(SIGALRM, child_signal_handler);
alarm(CONFIG_TIMEOUT);
zbx_tcp_init(&s_in, (ZBX_SOCKET)fileno(stdin));
zbx_tcp_init(&s_out, (ZBX_SOCKET)fileno(stdout));
if( SUCCEED == (ret = zbx_tcp_check_security(&s_in, CONFIG_HOSTS_ALLOWED, 0)) )
{
if( SUCCEED == (ret = zbx_tcp_recv(&s_in, &command)) )
{
zbx_rtrim(command, "\r\n");
zabbix_log(LOG_LEVEL_DEBUG, "Requested [%s]", command);
init_result(&result);
process(command, 0, &result);
if( NULL == (value = GET_TEXT_RESULT(&result)) )
value = GET_MSG_RESULT(&result);
if(value)
{
zabbix_log(LOG_LEVEL_DEBUG, "Sending back [%s]", *value);
ret = zbx_tcp_send(&s_out, *value);
}
free_result(&result);
}
if( FAIL == ret )
{
zabbix_log(LOG_LEVEL_DEBUG, "Processing error: %s", zbx_tcp_strerror());
}
}
fflush(stdout);
free_metrics();
alias_list_free();
alarm(0);
zabbix_close_log();
return SUCCEED;
}