void zbx_mock_test_entry(void **state)
{
#define ZBX_TCP_HEADER_DATALEN_LEN 13
char *buffer;
zbx_socket_t s;
ssize_t received;
int expected_ret;
ZBX_UNUSED(state);
zbx_mock_assert_result_eq("zbx_tcp_connect() return code", SUCCEED,
zbx_tcp_connect(&s, NULL, "127.0.0.1", 10050, 0, ZBX_TCP_SEC_UNENCRYPTED, NULL, NULL));
expected_ret = zbx_mock_str_to_return_code(zbx_mock_get_parameter_string("out.return"));
received = zbx_tcp_recv_ext(&s, 0);
if (FAIL == expected_ret)
{
zbx_mock_assert_result_eq("zbx_tcp_recv_ext() return code", FAIL, received);
zbx_tcp_close(&s);
return;
}
zbx_mock_assert_result_eq("zbx_tcp_recv_ext() return code", SUCCEED, SUCCEED_OR_FAIL(received));
zbx_mock_assert_uint64_eq("Received bytes", zbx_mock_get_parameter_uint64("out.bytes"), received);
if (0 == received)
return;
buffer = zbx_yaml_assemble_binary_sequence("out.fragments", received);
if (0 != memcmp(buffer + ZBX_TCP_HEADER_DATALEN_LEN, s.buffer, received - ZBX_TCP_HEADER_DATALEN_LEN))
fail_msg("Received message mismatch expected");
zbx_tcp_close(&s);
zbx_free(buffer);
#undef ZBX_TCP_HEADER_DATALEN_LEN
}
static int get_http_page(const char *host, const char *path, unsigned short port, char *buffer, int max_buffer_len)
{
int ret;
char *recv_buffer;
char request[MAX_STRING_LEN];
zbx_sock_t s;
if (SUCCEED == (ret = zbx_tcp_connect(&s, CONFIG_SOURCE_IP, host, port, CONFIG_TIMEOUT)))
{
zbx_snprintf(request, sizeof(request),
"GET /%s HTTP/1.1\r\n"
"Host: %s\r\n"
"Connection: close\r\n"
"\r\n",
path, host);
if (SUCCEED == (ret = zbx_tcp_send_raw(&s, request)))
{
if (SUCCEED == (ret = SUCCEED_OR_FAIL(zbx_tcp_recv_ext(&s, &recv_buffer, ZBX_TCP_READ_UNTIL_CLOSE, 0))))
{
if (NULL != buffer)
zbx_strlcpy(buffer, recv_buffer, max_buffer_len);
}
}
zbx_tcp_close(&s);
}
if (FAIL == ret)
{
zabbix_log(LOG_LEVEL_DEBUG, "HTTP get error: %s", zbx_tcp_strerror());
return SYSINFO_RET_FAIL;
}
return SYSINFO_RET_OK;
}
/******************************************************************************
* *
* 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_sock_t s;
char *buf, 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 == (ret = zbx_tcp_send_raw(&s, buffer)))
ret = SUCCEED_OR_FAIL(received_len = zbx_tcp_recv_ext(&s, &buf, ZBX_TCP_READ_UNTIL_CLOSE, 0));
}
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 == 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, 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;
}
/******************************************************************************
* *
* Function: refresh_active_checks *
* *
* Purpose: Retrieve from Zabbix server list of active checks *
* *
* Parameters: host - IP or Hostname of Zabbix server *
* port - port of Zabbix server *
* *
* Return value: returns SUCCEED on successful parsing, *
* FAIL on other cases *
* *
* Author: Eugene Grigorjev, Alexei Vladishev (new json protocol) *
* *
* Comments: *
* *
******************************************************************************/
static int refresh_active_checks(const char *host, unsigned short port)
{
const char *__function_name = "refresh_active_checks";
zbx_sock_t s;
char *buf;
int ret;
struct zbx_json json;
static int last_ret = SUCCEED;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() host:'%s' port:%hu", __function_name, host, port);
zbx_json_init(&json, ZBX_JSON_STAT_BUF_LEN);
zbx_json_addstring(&json, ZBX_PROTO_TAG_REQUEST, ZBX_PROTO_VALUE_GET_ACTIVE_CHECKS, ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, ZBX_PROTO_TAG_HOST, CONFIG_HOSTNAME, ZBX_JSON_TYPE_STRING);
if (NULL != CONFIG_HOST_METADATA)
{
zbx_json_addstring(&json, ZBX_PROTO_TAG_HOST_METADATA, CONFIG_HOST_METADATA, ZBX_JSON_TYPE_STRING);
}
else if (NULL != CONFIG_HOST_METADATA_ITEM)
{
char **value;
AGENT_RESULT result;
init_result(&result);
if (SUCCEED == process(CONFIG_HOST_METADATA_ITEM, PROCESS_LOCAL_COMMAND, &result) &&
NULL != (value = GET_STR_RESULT(&result)) && NULL != *value)
{
if (SUCCEED != zbx_is_utf8(*value))
{
zabbix_log(LOG_LEVEL_WARNING, "cannot get host metadata using \"%s\" item specified by"
" \"HostMetadataItem\" configuration parameter: returned value is not"
" an UTF-8 string", CONFIG_HOST_METADATA_ITEM);
}
else
{
if (HOST_METADATA_LEN < zbx_strlen_utf8(*value))
{
size_t bytes;
zabbix_log(LOG_LEVEL_WARNING, "the returned value of \"%s\" item specified by"
" \"HostMetadataItem\" configuration parameter is too long,"
" using first %d characters", CONFIG_HOST_METADATA_ITEM,
HOST_METADATA_LEN);
bytes = zbx_strlen_utf8_n(*value, HOST_METADATA_LEN);
(*value)[bytes] = '\0';
}
zbx_json_addstring(&json, ZBX_PROTO_TAG_HOST_METADATA, *value, ZBX_JSON_TYPE_STRING);
}
}
else
zabbix_log(LOG_LEVEL_WARNING, "cannot get host metadata using \"%s\" item specified by"
" \"HostMetadataItem\" configuration parameter", CONFIG_HOST_METADATA_ITEM);
free_result(&result);
}
if (NULL != CONFIG_LISTEN_IP)
{
char *p;
if (NULL != (p = strchr(CONFIG_LISTEN_IP, ',')))
*p = '\0';
zbx_json_addstring(&json, ZBX_PROTO_TAG_IP, CONFIG_LISTEN_IP, ZBX_JSON_TYPE_STRING);
if (NULL != p)
*p = ',';
}
if (ZBX_DEFAULT_AGENT_PORT != CONFIG_LISTEN_PORT)
zbx_json_adduint64(&json, ZBX_PROTO_TAG_PORT, CONFIG_LISTEN_PORT);
if (SUCCEED == (ret = zbx_tcp_connect(&s, CONFIG_SOURCE_IP, host, port, CONFIG_TIMEOUT)))
{
zabbix_log(LOG_LEVEL_DEBUG, "sending [%s]", json.buffer);
if (SUCCEED == (ret = zbx_tcp_send(&s, json.buffer)))
{
zabbix_log(LOG_LEVEL_DEBUG, "before read");
if (SUCCEED == (ret = SUCCEED_OR_FAIL(zbx_tcp_recv_ext(&s, &buf, ZBX_TCP_READ_UNTIL_CLOSE, 0))))
{
zabbix_log(LOG_LEVEL_DEBUG, "got [%s]", buf);
if (SUCCEED != last_ret)
{
zabbix_log(LOG_LEVEL_WARNING, "active check configuration update from [%s:%hu]"
" is working again", host, port);
}
parse_list_of_checks(buf, host, port);
}
}
zbx_tcp_close(&s);
}
if (SUCCEED != ret && SUCCEED == last_ret)
{
zabbix_log(LOG_LEVEL_WARNING,
"active check configuration update from [%s:%hu] started to fail (%s)",
host, port, zbx_tcp_strerror());
}
last_ret = ret;
zbx_json_free(&json);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
