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_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());
}
/******************************************************************************
* *
* Function: send_proxyhistory *
* *
* Purpose: send history data to a Zabbix server *
* *
* Parameters: *
* *
* Return value: *
* *
* Author: Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static void send_proxyhistory(zbx_sock_t *sock)
{
const char *__function_name = "send_proxyhistory";
struct zbx_json j;
zbx_uint64_t lastid;
int records;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);
zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA);
records = proxy_get_hist_data(&j, &lastid);
zbx_json_close(&j);
zbx_json_adduint64(&j, ZBX_PROTO_TAG_CLOCK, (int)time(NULL));
if (FAIL == zbx_tcp_send_to(sock, j.buffer, CONFIG_TIMEOUT))
zabbix_log(LOG_LEVEL_WARNING, "Error while sending availability of hosts. %s",
zbx_tcp_strerror());
else if (SUCCEED == zbx_recv_response(sock, NULL, 0, CONFIG_TIMEOUT) && 0 != records)
proxy_set_hist_lastid(lastid);
zbx_json_free(&j);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
/******************************************************************************
* *
* Function: *
* *
* Purpose: *
* *
* Parameters: *
* *
* Return value: *
* *
* Comments: *
* *
******************************************************************************/
void reply_jobnetstatusrq_response(zbx_sock_t * sock, int ret,
JOBARG_JOBNET_INFO * ji, char *message)
{
struct zbx_json json;
/*JSON Data */
zbx_json_init(&json, ZBX_JSON_STAT_BUF_LEN);
zbx_json_addstring(&json, JA_PROTO_TAG_KIND,
JA_PROTO_VALUE_JOBNETSTATUSRQ_RES,
ZBX_JSON_TYPE_STRING);
zbx_json_adduint64(&json, JA_PROTO_TAG_VERSION, JA_PROTO_VALUE_VERSION_1); /*data version */
zbx_json_addstring(&json, JA_PROTO_TAG_SERVERID, serverid,
ZBX_JSON_TYPE_STRING);
zbx_json_addobject(&json, JA_PROTO_TAG_DATA);
zbx_json_adduint64(&json, JA_PROTO_TAG_RESULT, FAIL == ret ? 1 : 0);
if (ret != FAIL) {
zbx_json_addstring(&json, JA_PROTO_TAG_JOBNETID, ji->jobnetid,
ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, JA_PROTO_TAG_JOBNETNAME, ji->jobnetname,
ZBX_JSON_TYPE_STRING);
zbx_json_adduint64(&json, JA_PROTO_TAG_SCHEDULEDTIME,
ji->scheduled_time);
zbx_json_adduint64(&json, JA_PROTO_TAG_STARTTIME, ji->start_time);
zbx_json_adduint64(&json, JA_PROTO_TAG_ENDTIME, ji->end_time);
zbx_json_adduint64(&json, JA_PROTO_TAG_JOBNETRUNTYPE,
ji->jobnetruntype);
zbx_json_adduint64(&json, JA_PROTO_TAG_JOBNETSTATUS,
ji->jobnetstatus);
zbx_json_adduint64(&json, JA_PROTO_TAG_JOBSTATUS, ji->jobstatus);
zbx_json_addstring(&json, JA_PROTO_TAG_LASTEXITCD, ji->lastexitcd,
ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, JA_PROTO_TAG_LASTSTDOUT, ji->laststdout,
ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, JA_PROTO_TAG_LASTSTDERR, ji->laststderr,
ZBX_JSON_TYPE_STRING);
} else {
zbx_json_addstring(&json, JA_PROTO_TAG_MESSAGE, message,
ZBX_JSON_TYPE_STRING);
}
zbx_json_close(&json);
zbx_json_close(&json);
zabbix_log(LOG_LEVEL_DEBUG, "JSON before sending [%s]", json.buffer);
if (FAIL == (ret = zbx_tcp_send_to(sock, json.buffer, CONFIG_TIMEOUT))) {
zbx_free(ji->jobnetid);
zbx_free(ji->jobnetname);
ja_log("JATRAPPER200038", 0, NULL, 0, zbx_tcp_strerror());
ret = NETWORK_ERROR;
}
zbx_free(ji->jobnetid);
zbx_free(ji->jobnetname);
zbx_json_free(&json);
}
/******************************************************************************
* *
* Function: send_host_availability *
* *
* Purpose: send hosts availability data from proxy *
* *
******************************************************************************/
void send_host_availability(zbx_socket_t *sock)
{
const char *__function_name = "send_host_availability";
struct zbx_json j;
int ret = FAIL, ts;
char *error = NULL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (SUCCEED != check_access_passive_proxy(sock, ZBX_DO_NOT_SEND_RESPONSE, "host availability data request"))
{
/* do not send any reply to server in this case as the server expects host availability data */
goto out1;
}
zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);
/* if there are no host availability changes we still have to send empty data in response */
if (SUCCEED != get_host_availability_data(&j, &ts))
{
zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA);
zbx_json_close(&j);
}
zabbix_log(LOG_LEVEL_DEBUG, "%s() [%s]", __function_name, j.buffer);
if (SUCCEED != zbx_tcp_send_to(sock, j.buffer, CONFIG_TIMEOUT))
{
error = zbx_strdup(error, zbx_socket_strerror());
goto out;
}
if (SUCCEED != zbx_recv_response(sock, CONFIG_TIMEOUT, &error))
goto out;
zbx_set_availability_diff_ts(ts);
ret = SUCCEED;
out:
if (SUCCEED != ret)
{
zabbix_log(LOG_LEVEL_WARNING, "cannot send host availability data to server at \"%s\": %s",
sock->peer, error);
}
zbx_json_free(&j);
zbx_free(error);
out1:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
/******************************************************************************
* *
* Function: send_proxyhistory *
* *
* Purpose: send history data to a Zabbix server *
* *
******************************************************************************/
static void send_proxyhistory(zbx_socket_t *sock, zbx_timespec_t *ts)
{
const char *__function_name = "send_proxyhistory";
struct zbx_json j;
zbx_uint64_t lastid;
int records, ret = FAIL;
char *error = NULL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (SUCCEED != check_access_passive_proxy(sock, ZBX_DO_NOT_SEND_RESPONSE, "history data request"))
{
/* do not send any reply to server in this case as the server expects history data */
goto out1;
}
zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);
zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA);
records = proxy_get_hist_data(&j, &lastid);
zbx_json_close(&j);
zbx_json_adduint64(&j, ZBX_PROTO_TAG_CLOCK, ts->sec);
zbx_json_adduint64(&j, ZBX_PROTO_TAG_NS, ts->ns);
if (SUCCEED != zbx_tcp_send_to(sock, j.buffer, CONFIG_TIMEOUT))
{
error = zbx_strdup(error, zbx_socket_strerror());
goto out;
}
if (SUCCEED != zbx_recv_response(sock, CONFIG_TIMEOUT, &error))
goto out;
if (0 != records)
proxy_set_hist_lastid(lastid);
ret = SUCCEED;
out:
if (SUCCEED != ret)
zabbix_log(LOG_LEVEL_WARNING, "cannot send history data to server at \"%s\": %s", sock->peer, error);
zbx_json_free(&j);
zbx_free(error);
out1:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
/******************************************************************************
* *
* Function: send_proxyconfig *
* *
* Purpose: send configuration tables to the proxy from server *
* (for active proxies) *
* *
* Author: Alexander Vladishev *
* *
******************************************************************************/
void send_proxyconfig(zbx_socket_t *sock, struct zbx_json_parse *jp)
{
const char *__function_name = "send_proxyconfig";
zbx_uint64_t proxy_hostid;
char host[HOST_HOST_LEN_MAX], *error = NULL;
struct zbx_json j;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (SUCCEED != get_active_proxy_id(jp, &proxy_hostid, host, sock, &error))
{
zbx_send_response(sock, FAIL, error, CONFIG_TIMEOUT);
zabbix_log(LOG_LEVEL_WARNING, "cannot parse proxy configuration data request from active proxy at"
" \"%s\": %s", sock->peer, error);
goto out;
}
update_proxy_lastaccess(proxy_hostid);
zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);
if (SUCCEED != get_proxyconfig_data(proxy_hostid, &j, &error))
{
zbx_send_response(sock, FAIL, error, CONFIG_TIMEOUT);
zabbix_log(LOG_LEVEL_WARNING, "cannot collect configuration data for proxy \"%s\" at \"%s\": %s",
host, sock->peer, error);
goto clean;
}
zabbix_log(LOG_LEVEL_WARNING, "sending configuration data to proxy \"%s\" at \"%s\", datalen " ZBX_FS_SIZE_T,
host, sock->peer, (zbx_fs_size_t)j.buffer_size);
zabbix_log(LOG_LEVEL_DEBUG, "%s", j.buffer);
if (SUCCEED != zbx_tcp_send_to(sock, j.buffer, CONFIG_TRAPPER_TIMEOUT))
{
zabbix_log(LOG_LEVEL_WARNING, "cannot send configuration data to proxy \"%s\" at \"%s\": %s",
host, sock->peer, zbx_socket_strerror());
}
clean:
zbx_json_free(&j);
out:
zbx_free(error);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
/******************************************************************************
* *
* Function: send_areg_data *
* *
* Purpose: send auto-registration data from proxy to a server *
* *
* Author: Alexander Vladishev *
* *
******************************************************************************/
void send_areg_data(zbx_sock_t *sock)
{
const char *__function_name = "send_areg_data";
struct zbx_json j;
zbx_uint64_t lastid;
int records;
char *info = NULL, *error = NULL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
zbx_json_init(&j, ZBX_JSON_STAT_BUF_LEN);
zbx_json_addarray(&j, ZBX_PROTO_TAG_DATA);
records = proxy_get_areg_data(&j, &lastid);
zbx_json_close(&j);
zbx_json_adduint64(&j, ZBX_PROTO_TAG_CLOCK, (int)time(NULL));
if (SUCCEED != zbx_tcp_send_to(sock, j.buffer, CONFIG_TIMEOUT))
{
zabbix_log(LOG_LEVEL_WARNING, "error while sending auto-registration data to server: %s",
zbx_tcp_strerror());
goto out;
}
if (SUCCEED != zbx_recv_response(sock, &info, CONFIG_TIMEOUT, &error))
{
zabbix_log(LOG_LEVEL_WARNING, "sending auto-registration data to server: error:\"%s\", info:\"%s\"",
ZBX_NULL2EMPTY_STR(error), ZBX_NULL2EMPTY_STR(info));
goto out;
}
if (0 != records)
proxy_set_areg_lastid(lastid);
out:
zbx_json_free(&j);
zbx_free(info);
zbx_free(error);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
/******************************************************************************
* *
* Function: *
* *
* Purpose: *
* *
* Parameters: *
* *
* Return value: *
* *
* Comments: *
* *
******************************************************************************/
static void jatraper_reply(zbx_sock_t * sock, ja_telegram_object * obj)
{
char *data;
const char *__function_name = "jatraper_reply";
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
json_object_object_add(obj->response, JA_PROTO_TAG_KIND,
json_object_new_string("response"));
json_object_object_add(obj->response, JA_PROTO_TAG_VERSION,
json_object_new_int(JA_PROTO_TELE_VERSION));
json_object_object_add(obj->response, JA_PROTO_TAG_SERVERID,
json_object_new_string(serverid));
data = (char *) json_object_to_json_string(obj->response);
zabbix_log(LOG_LEVEL_DEBUG, "In %s() %s", __function_name, data);
if (zbx_tcp_send_to(sock, data, CONFIG_TIMEOUT) == FAIL) {
ja_log("JATRAPPER200038", 0, NULL, 0, zbx_tcp_strerror());
}
}
/******************************************************************************
* *
* Function: *
* *
* Purpose: *
* *
* Parameters: *
* *
* Return value: *
* *
* Comments: *
* *
******************************************************************************/
int ja_tcp_send(zbx_sock_t * s, int timeout, json_object * json)
{
int ret;
char *data;
const char *__function_name = "ja_tcp_send";
if (json == NULL)
return FAIL;
data = (char *) json_object_to_json_string(json);
zabbix_log(LOG_LEVEL_DEBUG, "In %s() data: %s", __function_name, data);
ret = zbx_tcp_send_to(s, data, timeout);
if (ret == FAIL) {
zabbix_log(LOG_LEVEL_ERR, "In %s() error: %s", __function_name,
zbx_tcp_strerror());
}
return ret;
}
/******************************************************************************
* *
* Function: *
* *
* Purpose: *
* *
* Parameters: *
* *
* Return value: *
* *
* Comments: *
* *
******************************************************************************/
int ja_tcp_send_to(zbx_sock_t * s, ja_job_object * job, int timeout)
{
int ret;
char *data;
const char *__function_name = "ja_tcp_send_to";
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
data = ja_telegram_to(job);
if (data == NULL) {
zabbix_log(LOG_LEVEL_ERR, "In %s() message: %s", __function_name,
job->message);
return FAIL;
}
zabbix_log(LOG_LEVEL_DEBUG, "In %s() %s", __function_name, data);
ret = zbx_tcp_send_to(s, data, timeout);
if (ret == FAIL) {
zabbix_log(LOG_LEVEL_ERR, "In %s() error: %s", __function_name,
zbx_tcp_strerror());
}
zbx_free(data);
return ret;
}
/******************************************************************************
* *
* Function: *
* *
* Purpose: *
* *
* Parameters: *
* *
* Return value: *
* *
* Comments: *
* *
******************************************************************************/
void reply_jobnetrun_response(zbx_sock_t * sock, int ret, char *message)
{
struct zbx_json json;
/*JSON Data */
zbx_json_init(&json, ZBX_JSON_STAT_BUF_LEN);
zbx_json_addstring(&json, JA_PROTO_TAG_KIND,
JA_PROTO_VALUE_JOBNETRUN_RES, ZBX_JSON_TYPE_STRING);
zbx_json_adduint64(&json, JA_PROTO_TAG_VERSION, JA_PROTO_VALUE_VERSION_1); /*data version */
zbx_json_addstring(&json, JA_PROTO_TAG_SERVERID, serverid,
ZBX_JSON_TYPE_STRING);
zbx_json_addobject(&json, JA_PROTO_TAG_DATA);
zbx_json_adduint64(&json, JA_PROTO_TAG_RESULT, FAIL == ret ? 1 : 0);
zbx_json_addstring(&json, JA_PROTO_TAG_MESSAGE, message,
ZBX_JSON_TYPE_STRING);
zbx_json_close(&json);
zbx_json_close(&json);
zabbix_log(LOG_LEVEL_DEBUG, "JSON before sending [%s]", json.buffer);
if (FAIL == (ret = zbx_tcp_send_to(sock, json.buffer, CONFIG_TIMEOUT))) {
ja_log("JATRAPPER200038", 0, NULL, 0, zbx_tcp_strerror());
ret = NETWORK_ERROR;
}
zbx_json_free(&json);
}
