void process_trapper_child(zbx_sock_t *sock)
{
char *data;
/* suseconds_t is not defined under HP-UX */
/* struct timeval tv;
suseconds_t msec;
gettimeofday(&tv, NULL);
msec = tv.tv_usec;*/
alarm(ZABBIX_TRAPPER_TIMEOUT);
if(zbx_tcp_recv(sock, &data) != SUCCEED)
{
alarm(0);
return;
}
process_trap(sock, data, sizeof(data));
alarm(0);
/* gettimeofday(&tv, NULL);
zabbix_log( LOG_LEVEL_DEBUG, "Trap processed in " ZBX_FS_DBL " seconds",
(double)(tv.tv_usec-msec)/1000000 );*/
}
static void process_listener(zbx_sock_t *s)
{
AGENT_RESULT result;
char *command;
char **value = NULL;
int ret;
if( SUCCEED == (ret = zbx_tcp_recv(s, &command)) )
{
zbx_rtrim(command, "\r\n\0");
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, *value);
}
free_result(&result);
}
if( FAIL == ret )
{
zabbix_log(LOG_LEVEL_DEBUG, "Process listener error: %s", zbx_tcp_strerror());
}
}
int check_ntp(char *host, unsigned short port, int timeout, int *value_int)
{
zbx_sock_t s;
int ret;
char *buf = NULL, packet[NTP_PACKET_MIN];
ntp_data data;
*value_int = 0;
if (SUCCEED == (ret = zbx_tcp_connect(&s, CONFIG_SOURCE_IP, host, port, timeout)))
{
make_packet(&data);
pack_ntp((unsigned char *)packet, sizeof(packet), &data);
if (SUCCEED == (ret = zbx_tcp_send_raw(&s, packet)))
{
if (SUCCEED == (ret = zbx_tcp_recv(&s, &buf)))
{
unpack_ntp(&data, (unsigned char *)buf, (int)strlen(buf));
*value_int = (0 < data.receive ? (int)(data.receive - ZBX_JAN_1970_IN_SEC) : 0);
}
}
zbx_tcp_close(&s);
}
if (FAIL == ret)
zabbix_log(LOG_LEVEL_DEBUG, "NTP check error: %s", zbx_tcp_strerror());
return SYSINFO_RET_OK;
}
static int check_ssh(const char *host, unsigned short port, int timeout, int *value_int)
{
int ret;
zbx_sock_t s;
char send_buf[MAX_STRING_LEN], *recv_buf, *ssh_server, *ssh_proto;
*value_int = 0;
if (SUCCEED == (ret = zbx_tcp_connect(&s, CONFIG_SOURCE_IP, host, port, timeout)))
{
if (SUCCEED == (ret = zbx_tcp_recv(&s, &recv_buf)))
{
if (0 == strncmp(recv_buf, "SSH", 3))
{
ssh_server = ssh_proto = recv_buf + 4;
ssh_server += strspn(ssh_proto, "0123456789-. ");
ssh_server[-1] = '\0';
zbx_snprintf(send_buf, sizeof(send_buf), "SSH-%s-%s\n", ssh_proto, "zabbix_agent");
*value_int = 1;
}
else
zbx_snprintf(send_buf, sizeof(send_buf), "0\n");
ret = zbx_tcp_send_raw(&s, send_buf);
}
zbx_tcp_close(&s);
}
if (FAIL == ret)
zabbix_log(LOG_LEVEL_DEBUG, "SSH check error: %s", zbx_tcp_strerror());
return SYSINFO_RET_OK;
}
/******************************************************************************
* *
* Function: send_to_node *
* *
* Purpose: send configuration changes to required node *
* *
* Parameters: *
* *
* Return value: SUCCESS - processed succesfully *
* FAIL - an error occured *
* *
* Author: Alexei Vladishev *
* *
* Comments: *
* *
******************************************************************************/
int send_to_node(char *name, int dest_nodeid, int nodeid, char *data)
{
char ip[MAX_STRING_LEN];
int port;
int ret = FAIL;
DB_RESULT result;
DB_ROW row;
zbx_sock_t sock;
char *answer;
zabbix_log( LOG_LEVEL_WARNING, "NODE: Sending %s to node %s:%d datalen %d",
name,
CONFIG_MASTER_IP, CONFIG_MASTER_PORT,
strlen(data));
/* zabbix_log( LOG_LEVEL_WARNING, "Data [%s]", data);*/
if( FAIL == zbx_tcp_connect(&sock, CONFIG_MASTER_IP, CONFIG_MASTER_PORT, 0, NULL))
{
zabbix_log(LOG_LEVEL_DEBUG, "Unable to connect to Node [%s:%d] error: %s", CONFIG_MASTER_IP, CONFIG_MASTER_PORT, zbx_tcp_strerror());
return FAIL;
}
if( FAIL == zbx_tcp_send(&sock, data))
{
zabbix_log( LOG_LEVEL_WARNING, "Error while sending data to Node [%s:%d]",
CONFIG_MASTER_IP, CONFIG_MASTER_PORT);
zbx_tcp_close(&sock);
return FAIL;
}
if( FAIL == zbx_tcp_recv(&sock, &answer))
{
zabbix_log( LOG_LEVEL_WARNING, "Error while receiving answer from Node [%s:%d]",
CONFIG_MASTER_IP, CONFIG_MASTER_PORT);
zbx_tcp_close(&sock);
return FAIL;
}
zabbix_log( LOG_LEVEL_DEBUG, "Answer [%s]",
answer);
if(strcmp(answer,"OK") == 0)
{
zabbix_log( LOG_LEVEL_DEBUG, "OK");
ret = SUCCEED;
}
else
{
zabbix_log( LOG_LEVEL_WARNING, "NOT OK");
}
zbx_tcp_close(&sock);
return ret;
}
int zbx_module_unifi_proxy(AGENT_REQUEST *request, AGENT_RESULT *result)
{
int ret;
int i, p, np;
zbx_sock_t s;
char send_buf[MAX_STRING_LEN];
*send_buf='\0';
np = request->nparam;
if (9 < request->nparam)
{
/* set optional error message */
SET_MSG_RESULT(result, strdup("So much parameters given."));
return SYSINFO_RET_FAIL;
}
// make request string by concatenate all params
for (i=0; i < np; i++)
{
strcat(send_buf, get_rparam(request, i));
p=strlen(send_buf);
send_buf[p]=(i < (np-1)) ? ',' : '\n';
send_buf[p+1]='\0';
}
// Connect to UniFi Proxy
// item_timeout or (item_timeout-1) ?
if (SUCCEED == (ret = zbx_tcp_connect(&s, CONFIG_SOURCE_IP, UNIFI_PROXY_SERVER, UNIFI_PROXY_PORT, CONFIG_TIMEOUT)))
{
// Send request
if (SUCCEED == (ret = zbx_tcp_send_raw(&s, send_buf)))
{
// Recive answer from UniFi Proxy
if (SUCCEED == (ret = zbx_tcp_recv(&s))) {
zbx_rtrim(s.buffer, "\r\n");
SET_STR_RESULT(result, strdup(s.buffer));
}
}
zbx_tcp_close(&s);
}
if (FAIL == ret)
{
zabbix_log(LOG_LEVEL_DEBUG, "%s: communication error: %s", ZBX_MODULE_NAME, zbx_tcp_strerror());
SET_MSG_RESULT(result, strdup(zbx_tcp_strerror()));
return SYSINFO_RET_FAIL;
}
return SYSINFO_RET_OK;
}
static int recv_data_from_server(zbx_sock_t *sock)
{
int res;
zabbix_log(LOG_LEVEL_DEBUG, "In recv_data_from_server()");
if (FAIL == (res = zbx_tcp_recv(sock)))
zabbix_log(LOG_LEVEL_ERR, "Error while receiving answer from server [%s]", zbx_tcp_strerror());
else
zabbix_log(LOG_LEVEL_DEBUG, "Received [%s] from server", sock->buffer);
return res;
}
/*
* 0 - NOT OK
* 1 - OK
* */
int tcp_expect(
const char *host,
unsigned short port,
const char *request,
const char *expect,
const char *sendtoclose,
int *value_int
)
{
zbx_sock_t s;
char *buf;
int ret;
assert(value_int);
*value_int = 0;
if (SUCCEED == (ret = zbx_tcp_connect(&s, CONFIG_SOURCE_IP, host, port, 3/*alarm!!!*/))) {
if( NULL == request )
{
*value_int = 1;
}
else if( SUCCEED == (ret = zbx_tcp_send_raw(&s, request)) )
{
if( NULL == expect )
{
*value_int = 1;
}
else if( SUCCEED == (ret = zbx_tcp_recv(&s, &buf)) )
{
if( 0 == strncmp(buf, expect, strlen(expect)) )
{
*value_int = 1;
}
}
if(SUCCEED == ret && NULL != sendtoclose)
{
/* ret = (skip errors) */ zbx_tcp_send_raw(&s, sendtoclose);
}
}
}
zbx_tcp_close(&s);
if( FAIL == ret )
{
zabbix_log(LOG_LEVEL_DEBUG, "TCP expect error: %s", zbx_tcp_strerror());
}
return SYSINFO_RET_OK;
}
/******************************************************************************
* *
* Function: send_script *
* *
* Purpose: sending command to slave node *
* *
* Return value: SUCCEED - processed successfully *
* FAIL - an error occurred *
* *
******************************************************************************/
static int send_script(int nodeid, const char *data, char **result)
{
DB_RESULT db_result;
DB_ROW db_row;
int ret = FAIL;
zbx_sock_t sock;
char *answer;
zabbix_log(LOG_LEVEL_DEBUG, "In send_script(nodeid:%d)", nodeid);
db_result = DBselect(
"select ip,port"
" from nodes"
" where nodeid=%d",
nodeid);
if (NULL != (db_row = DBfetch(db_result)))
{
if (SUCCEED == (ret = zbx_tcp_connect(&sock, CONFIG_SOURCE_IP,
db_row[0], atoi(db_row[1]), CONFIG_TRAPPER_TIMEOUT)))
{
if (FAIL == (ret = zbx_tcp_send(&sock, data)))
{
*result = zbx_dsprintf(*result, "NODE %d: Error while sending data to Node [%d]: %s.",
CONFIG_NODEID, nodeid, zbx_tcp_strerror());
goto exit_sock;
}
if (SUCCEED == (ret = zbx_tcp_recv(&sock, &answer)))
*result = zbx_dsprintf(*result, "%s", answer);
else
*result = zbx_dsprintf(*result,
"NODE %d: Error while receiving data from Node [%d]: %s.",
CONFIG_NODEID, nodeid, zbx_tcp_strerror());
exit_sock:
zbx_tcp_close(&sock);
}
else
*result = zbx_dsprintf(*result, "NODE %d: Unable to connect to Node [%d]: %s.",
CONFIG_NODEID, nodeid, zbx_tcp_strerror());
}
else
*result = zbx_dsprintf(*result, "NODE %d: Unknown Node ID [%d].",
CONFIG_NODEID, nodeid);
DBfree_result(db_result);
return ret;
}
int recv_data_from_node(int nodeid, zbx_sock_t *sock, char **data)
{
int res;
if (FAIL == (res = zbx_tcp_recv(sock, data)))
{
zabbix_log(LOG_LEVEL_ERR, "NODE %d: Error while receiving answer from Node [%d] error: %s",
CONFIG_NODEID, nodeid, zbx_tcp_strerror());
}
else
zabbix_log(LOG_LEVEL_DEBUG, "NODE %d: Receiving [%s] from Node [%d]",
CONFIG_NODEID, *data, nodeid);
return res;
}
int check_ntp(char *host, unsigned short port, int *value_int)
{
zbx_sock_t s;
int ret;
char *buf = NULL;
ntp_data data;
char packet[NTP_PACKET_MIN];
assert(value_int);
*value_int = 0;
if (SUCCEED == (ret = zbx_tcp_connect(&s, CONFIG_SOURCE_IP, host, port, 0))) {
make_packet(&data);
pack_ntp((unsigned char*)packet, sizeof(packet), &data);
if( SUCCEED == (ret = zbx_tcp_send_raw(&s, packet)) )
{
if( SUCCEED == (ret = zbx_tcp_recv(&s, &buf)) )
{
unpack_ntp(&data, (unsigned char *)buf, (int)strlen(buf));
#if OFF
/* local time */ *value_int = time(NULL);
#else
/* server time */ *value_int = (data.receive > 0) ? (int)(data.receive - ZBX_JAN_1970_IN_SEC) : 0;
#endif
}
}
}
zbx_tcp_close(&s);
if( FAIL == ret )
{
zabbix_log(LOG_LEVEL_DEBUG, "NTP check error: %s", zbx_tcp_strerror());
}
return SYSINFO_RET_OK;
}
static int recv_data_from_proxy(DC_PROXY *proxy, zbx_socket_t *sock)
{
const char *__function_name = "recv_data_from_proxy";
int ret;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (FAIL == (ret = zbx_tcp_recv(sock)))
{
zabbix_log(LOG_LEVEL_ERR, "cannot obtain data from proxy \"%s\": %s", proxy->host,
zbx_socket_strerror());
}
else
zabbix_log(LOG_LEVEL_DEBUG, "obtained data from proxy \"%s\": %s", proxy->host, sock->buffer);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
/*
* 0 - NOT OK
* 1 - OK
* */
int tcp_expect(const char *host, unsigned short port, int timeout, const char *request,
const char *expect, const char *sendtoclose, int *value_int)
{
zbx_sock_t s;
char *buf;
int net, val = SUCCEED;
*value_int = 0;
if (SUCCEED == (net = zbx_tcp_connect(&s, CONFIG_SOURCE_IP, host, port, timeout)))
{
if (NULL != request)
net = zbx_tcp_send_raw(&s, request);
if (NULL != expect && SUCCEED == net)
{
if (SUCCEED == (net = zbx_tcp_recv(&s, &buf)))
{
if (0 != strncmp(buf, expect, strlen(expect)))
{
val = FAIL;
}
}
}
if (NULL != sendtoclose && SUCCEED == net && SUCCEED == val)
zbx_tcp_send_raw(&s, sendtoclose);
if (SUCCEED == net && SUCCEED == val)
*value_int = 1;
zbx_tcp_close(&s);
}
if (FAIL == net)
zabbix_log(LOG_LEVEL_DEBUG, "TCP expect network error: %s", zbx_tcp_strerror());
if (FAIL == val)
zabbix_log(LOG_LEVEL_DEBUG, "TCP expect content error: expected [%s] received [%s]", expect, buf);
return SYSINFO_RET_OK;
}
static ZBX_THREAD_ENTRY(send_value, args)
{
ZBX_THREAD_SENDVAL_ARGS *sentdval_args;
zbx_sock_t sock;
char *answer = NULL;
int tcp_ret, ret = FAIL;
assert(args);
assert(((zbx_thread_args_t *)args)->args);
sentdval_args = (ZBX_THREAD_SENDVAL_ARGS *)((zbx_thread_args_t *)args)->args;
#if !defined(_WINDOWS)
signal(SIGINT, send_signal_handler);
signal(SIGTERM, send_signal_handler);
signal(SIGQUIT, send_signal_handler);
signal(SIGALRM, send_signal_handler);
#endif
if (SUCCEED == (tcp_ret = zbx_tcp_connect(&sock, CONFIG_SOURCE_IP, sentdval_args->server, sentdval_args->port, GET_SENDER_TIMEOUT)))
{
if (SUCCEED == (tcp_ret = zbx_tcp_send(&sock, sentdval_args->json.buffer)))
{
if (SUCCEED == (tcp_ret = zbx_tcp_recv(&sock, &answer)))
{
zabbix_log(LOG_LEVEL_DEBUG, "answer [%s]", answer);
if (NULL == answer || SUCCEED != check_response(answer))
zabbix_log(LOG_LEVEL_WARNING, "incorrect answer from server [%s]", answer);
else
ret = SUCCEED;
}
}
zbx_tcp_close(&sock);
}
if (FAIL == tcp_ret)
zabbix_log(LOG_LEVEL_DEBUG, "send value error: %s", zbx_tcp_strerror());
zbx_thread_exit(ret);
}
/******************************************************************************
* *
* Function: send_buffer *
* *
* Purpose: Send value stgored in the buffer to ZABBIX server *
* *
* Parameters: host - IP or Hostname of ZABBIX server *
* port - port number *
* *
* Return value: returns SUCCEED on succesfull parsing, *
* FAIL on other cases *
* *
* Author: Alexei Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static int send_buffer(
const char *host,
unsigned short port
)
{
zbx_sock_t s;
char *buf = NULL;
int ret = SUCCEED;
struct zbx_json json;
int i;
static int lastsent = 0;
int now;
zabbix_log( LOG_LEVEL_DEBUG, "In send_buffer('%s','%d')",
host, port);
zabbix_log( LOG_LEVEL_DEBUG, "Values in the buffer %d Max %d",
buffer.count,
CONFIG_BUFFER_SIZE);
now = (int)time(NULL);
if(buffer.count < CONFIG_BUFFER_SIZE && now-lastsent < CONFIG_BUFFER_SEND)
{
zabbix_log( LOG_LEVEL_DEBUG, "Will not send now. Now %d lastsent %d < %d",
now,
lastsent,
CONFIG_BUFFER_SEND);
return ret;
}
if(buffer.count < 1)
{
return ret;
}
zbx_json_init(&json, ZBX_JSON_STAT_BUF_LEN);
zbx_json_addstring(&json, ZBX_PROTO_TAG_REQUEST, ZBX_PROTO_VALUE_AGENT_DATA, ZBX_JSON_TYPE_STRING);
zbx_json_addarray(&json, ZBX_PROTO_TAG_DATA);
for(i=0;i<buffer.count;i++)
{
zbx_json_addobject(&json, NULL);
zbx_json_addstring(&json, ZBX_PROTO_TAG_HOST, buffer.data[i].host, ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, ZBX_PROTO_TAG_KEY, buffer.data[i].key, ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, ZBX_PROTO_TAG_VALUE, buffer.data[i].value, ZBX_JSON_TYPE_STRING);
if (buffer.data[i].lastlogsize)
zbx_json_adduint64(&json, ZBX_PROTO_TAG_LOGLASTSIZE, buffer.data[i].lastlogsize);
if (buffer.data[i].timestamp)
zbx_json_adduint64(&json, ZBX_PROTO_TAG_LOGTIMESTAMP, buffer.data[i].timestamp);
if (buffer.data[i].source)
zbx_json_addstring(&json, ZBX_PROTO_TAG_LOGSOURCE, buffer.data[i].source, ZBX_JSON_TYPE_STRING);
if (buffer.data[i].severity)
zbx_json_adduint64(&json, ZBX_PROTO_TAG_LOGSEVERITY, buffer.data[i].severity);
zbx_json_adduint64(&json, ZBX_PROTO_TAG_CLOCK, buffer.data[i].clock);
zbx_json_close(&json);
}
zbx_json_close(&json);
zbx_json_adduint64(&json, ZBX_PROTO_TAG_CLOCK, (int)time(NULL));
if (SUCCEED == (ret = zbx_tcp_connect(&s, CONFIG_SOURCE_IP, host, port, MIN(buffer.count*CONFIG_TIMEOUT, 60)))) {
zabbix_log(LOG_LEVEL_DEBUG, "JSON before sending [%s]",
json.buffer);
ret = zbx_tcp_send(&s, json.buffer);
if( SUCCEED == ret )
{
if( SUCCEED == (ret = zbx_tcp_recv(&s, &buf)) )
{
zabbix_log(LOG_LEVEL_DEBUG, "JSON back [%s]",
buf);
if( !buf || check_response(buf) != SUCCEED )
{
zabbix_log(LOG_LEVEL_DEBUG, "NOT OK");
}
else
{
zabbix_log(LOG_LEVEL_DEBUG, "OK");
}
} else
zabbix_log(LOG_LEVEL_DEBUG, "Send value error: [recv] %s", zbx_tcp_strerror());
} else
zabbix_log(LOG_LEVEL_DEBUG, "Send value error: [send] %s", zbx_tcp_strerror());
zbx_tcp_close(&s);
} else
zabbix_log(LOG_LEVEL_DEBUG, "Send value error: [connect] %s", zbx_tcp_strerror());
zbx_json_free(&json);
if(SUCCEED == ret)
{
/* free buffer */
for(i=0;i<buffer.count;i++)
{
if(buffer.data[i].host != NULL) zbx_free(buffer.data[i].host);
if(buffer.data[i].key != NULL) zbx_free(buffer.data[i].key);
if(buffer.data[i].value != NULL) zbx_free(buffer.data[i].value);
if(buffer.data[i].source != NULL) zbx_free(buffer.data[i].source);
}
buffer.count = 0;
}
if(SUCCEED == ret) lastsent = now;
return ret;
}
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;
}
/******************************************************************************
* *
* Function: send_buffer *
* *
* Purpose: Send value stored in the buffer to Zabbix server *
* *
* Parameters: host - IP or Hostname of Zabbix server *
* port - port number *
* *
* Return value: returns SUCCEED on successful parsing, *
* FAIL on other cases *
* *
* Author: Alexei Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static int send_buffer(const char *host, unsigned short port)
{
const char *__function_name = "send_buffer";
struct zbx_json json;
ZBX_ACTIVE_BUFFER_ELEMENT *el;
zbx_sock_t s;
char *buf = NULL;
int ret = SUCCEED, i, now;
zbx_timespec_t ts;
const char *err_send_step = "";
zabbix_log(LOG_LEVEL_DEBUG, "In %s() host:'%s' port:%d values:%d/%d",
__function_name, host, port, buffer.count, CONFIG_BUFFER_SIZE);
if (0 == buffer.count)
goto ret;
now = (int)time(NULL);
if (CONFIG_BUFFER_SIZE / 2 > buffer.pcount && CONFIG_BUFFER_SIZE > buffer.count &&
CONFIG_BUFFER_SEND > now - buffer.lastsent)
{
zabbix_log(LOG_LEVEL_DEBUG, "Will not send now. Now %d lastsent %d < %d",
now, buffer.lastsent, CONFIG_BUFFER_SEND);
goto ret;
}
zbx_json_init(&json, ZBX_JSON_STAT_BUF_LEN);
zbx_json_addstring(&json, ZBX_PROTO_TAG_REQUEST, ZBX_PROTO_VALUE_AGENT_DATA, ZBX_JSON_TYPE_STRING);
zbx_json_addarray(&json, ZBX_PROTO_TAG_DATA);
for (i = 0; i < buffer.count; i++)
{
el = &buffer.data[i];
zbx_json_addobject(&json, NULL);
zbx_json_addstring(&json, ZBX_PROTO_TAG_HOST, el->host, ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, ZBX_PROTO_TAG_KEY, el->key, ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, ZBX_PROTO_TAG_VALUE, el->value, ZBX_JSON_TYPE_STRING);
if (0 != el->lastlogsize)
zbx_json_adduint64(&json, ZBX_PROTO_TAG_LOGLASTSIZE, el->lastlogsize);
if (el->mtime)
zbx_json_adduint64(&json, ZBX_PROTO_TAG_MTIME, el->mtime);
if (el->timestamp)
zbx_json_adduint64(&json, ZBX_PROTO_TAG_LOGTIMESTAMP, el->timestamp);
if (el->source)
zbx_json_addstring(&json, ZBX_PROTO_TAG_LOGSOURCE, el->source, ZBX_JSON_TYPE_STRING);
if (el->severity)
zbx_json_adduint64(&json, ZBX_PROTO_TAG_LOGSEVERITY, el->severity);
if (el->logeventid)
zbx_json_adduint64(&json, ZBX_PROTO_TAG_LOGEVENTID, el->logeventid);
zbx_json_adduint64(&json, ZBX_PROTO_TAG_CLOCK, el->ts.sec);
zbx_json_adduint64(&json, ZBX_PROTO_TAG_NS, el->ts.ns);
zbx_json_close(&json);
}
zbx_json_close(&json);
zbx_timespec(&ts);
zbx_json_adduint64(&json, ZBX_PROTO_TAG_CLOCK, ts.sec);
zbx_json_adduint64(&json, ZBX_PROTO_TAG_NS, ts.ns);
if (SUCCEED == (ret = zbx_tcp_connect(&s, CONFIG_SOURCE_IP, host, port,
MIN(buffer.count * CONFIG_TIMEOUT, 60))))
{
zabbix_log(LOG_LEVEL_DEBUG, "JSON before sending [%s]", json.buffer);
if (SUCCEED == (ret = zbx_tcp_send(&s, json.buffer)))
{
if (SUCCEED == zbx_tcp_recv(&s, &buf))
{
zabbix_log(LOG_LEVEL_DEBUG, "JSON back [%s]", buf);
if (NULL == buf || SUCCEED != check_response(buf))
zabbix_log(LOG_LEVEL_DEBUG, "NOT OK");
else
zabbix_log(LOG_LEVEL_DEBUG, "OK");
}
else
err_send_step = "[recv] ";
}
else
err_send_step = "[send] ";
zbx_tcp_close(&s);
}
else
err_send_step = "[connect] ";
zbx_json_free(&json);
if (SUCCEED == ret)
{
/* free buffer */
for (i = 0; i < buffer.count; i++)
{
el = &buffer.data[i];
zbx_free(el->host);
zbx_free(el->key);
zbx_free(el->value);
zbx_free(el->source);
}
buffer.count = 0;
buffer.pcount = 0;
buffer.lastsent = now;
if (0 != buffer.first_error)
{
zabbix_log(LOG_LEVEL_WARNING, "active check data upload to [%s:%hu] is working again",
host, port);
buffer.first_error = 0;
}
}
else
{
if (0 == buffer.first_error)
{
zabbix_log(LOG_LEVEL_WARNING, "active check data upload to [%s:%hu] started to fail (%s%s)",
host, port, err_send_step, zbx_tcp_strerror());
buffer.first_error = now;
}
zabbix_log(LOG_LEVEL_DEBUG, "send value error: %s %s", err_send_step, zbx_tcp_strerror());
}
ret:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
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;
}
void get_values_java(unsigned char request, DC_ITEM *items, AGENT_RESULT *results, int *errcodes, int num)
{
const char *__function_name = "get_values_java";
zbx_sock_t s;
struct zbx_json json;
char error[MAX_STRING_LEN];
char *buffer = NULL;
int i, j, err = SUCCEED;
zabbix_log(LOG_LEVEL_DEBUG, "In %s() host:'%s' addr:'%s' num:%d",
__function_name, items[0].host.host, items[0].interface.addr, num);
for (j = 0; j < num; j++) /* locate first supported item */
{
if (SUCCEED == errcodes[j])
break;
}
if (j == num) /* all items already NOTSUPPORTED (with invalid key or port) */
goto out;
zbx_json_init(&json, ZBX_JSON_STAT_BUF_LEN);
if (NULL == CONFIG_JAVA_GATEWAY || '\0' == *CONFIG_JAVA_GATEWAY)
{
err = GATEWAY_ERROR;
strscpy(error, "JavaGateway configuration parameter not set or empty");
goto exit;
}
if (ZBX_JAVA_GATEWAY_REQUEST_INTERNAL == request)
{
zbx_json_addstring(&json, ZBX_PROTO_TAG_REQUEST, ZBX_PROTO_VALUE_JAVA_GATEWAY_INTERNAL, ZBX_JSON_TYPE_STRING);
}
else if (ZBX_JAVA_GATEWAY_REQUEST_JMX == request)
{
for (i = j + 1; i < num; i++)
{
if (SUCCEED != errcodes[i])
continue;
if (0 != strcmp(items[j].interface.addr, items[i].interface.addr) ||
items[j].interface.port != items[i].interface.port ||
0 != strcmp(items[j].username, items[i].username) ||
0 != strcmp(items[j].password, items[i].password))
{
err = GATEWAY_ERROR;
strscpy(error, "Java poller received items with different connection parameters");
goto exit;
}
}
zbx_json_addstring(&json, ZBX_PROTO_TAG_REQUEST, ZBX_PROTO_VALUE_JAVA_GATEWAY_JMX, ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&json, ZBX_PROTO_TAG_CONN, items[j].interface.addr, ZBX_JSON_TYPE_STRING);
zbx_json_adduint64(&json, ZBX_PROTO_TAG_PORT, items[j].interface.port);
if ('\0' != *items[j].username)
zbx_json_addstring(&json, ZBX_PROTO_TAG_USERNAME, items[j].username, ZBX_JSON_TYPE_STRING);
if ('\0' != *items[j].password)
zbx_json_addstring(&json, ZBX_PROTO_TAG_PASSWORD, items[j].password, ZBX_JSON_TYPE_STRING);
}
else
assert(0);
zbx_json_addarray(&json, ZBX_PROTO_TAG_KEYS);
for (i = 0; i < num; i++)
{
if (SUCCEED != errcodes[i])
continue;
zbx_json_addstring(&json, NULL, items[i].key, ZBX_JSON_TYPE_STRING);
}
zbx_json_close(&json);
if (SUCCEED == (err = zbx_tcp_connect(&s, CONFIG_SOURCE_IP,
CONFIG_JAVA_GATEWAY, CONFIG_JAVA_GATEWAY_PORT, CONFIG_TIMEOUT)))
{
zabbix_log(LOG_LEVEL_DEBUG, "JSON before sending [%s]", json.buffer);
if (SUCCEED == (err = zbx_tcp_send(&s, json.buffer)))
{
if (SUCCEED == (err = zbx_tcp_recv(&s, &buffer)))
{
zabbix_log(LOG_LEVEL_DEBUG, "JSON back [%s]", buffer);
err = parse_response(items, results, errcodes, num, buffer, error, sizeof(error));
}
}
zbx_tcp_close(&s);
}
zbx_json_free(&json);
if (FAIL == err)
{
strscpy(error, zbx_tcp_strerror());
err = GATEWAY_ERROR;
}
exit:
if (NETWORK_ERROR == err || GATEWAY_ERROR == err)
{
zabbix_log(LOG_LEVEL_DEBUG, "Getting Java values failed: %s", error);
for (i = 0; i < num; i++)
{
if (SUCCEED != errcodes[i])
continue;
if (!ISSET_MSG(&results[i]))
{
SET_MSG_RESULT(&results[i], zbx_strdup(NULL, error));
errcodes[i] = err;
}
}
}
out:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
