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); }