自学教程：C++ zbx_tcp_strerror函数代码示例

int	connect_to_server(zbx_sock_t *sock, int timeout, int retry_interval){	int	res, lastlogtime, now;	zabbix_log(LOG_LEVEL_DEBUG, "In connect_to_server() [%s]:%d [timeout:%d]",			CONFIG_SERVER, CONFIG_SERVER_PORT, timeout);	if (FAIL == (res = zbx_tcp_connect(sock, CONFIG_SOURCE_IP, CONFIG_SERVER, CONFIG_SERVER_PORT, timeout)))	{		if (0 == retry_interval)		{			zabbix_log(LOG_LEVEL_WARNING, "Unable to connect to the server [%s]:%d [%s]",					CONFIG_SERVER, CONFIG_SERVER_PORT, zbx_tcp_strerror());		}		else		{			zabbix_log(LOG_LEVEL_WARNING, "Unable to connect to the server [%s]:%d [%s]. Will retry every %d second(s)",					CONFIG_SERVER, CONFIG_SERVER_PORT, zbx_tcp_strerror(), retry_interval);			lastlogtime = (int)time(NULL);			while (FAIL == (res = zbx_tcp_connect(sock, CONFIG_SOURCE_IP, CONFIG_SERVER, CONFIG_SERVER_PORT, timeout)))			{				now = (int)time(NULL);				if (60 <= now - lastlogtime)				{					zabbix_log(LOG_LEVEL_WARNING, "Still unable to connect...");					lastlogtime = now;				}				sleep(retry_interval);			}			zabbix_log(LOG_LEVEL_WARNING, "Connection restored.");		}	}	return res;}

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

/****************************************************************************** *                                                                            * * 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;}

/* * Example: telnet.run["ls /"] */static int	telnet_run(DC_ITEM *item, AGENT_RESULT *result, const char *encoding){	const char	*__function_name = "telnet_run";	zbx_sock_t	s;	int		ret = NOTSUPPORTED, flags;	zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);	if (FAIL == zbx_tcp_connect(&s, CONFIG_SOURCE_IP, item->interface.addr, item->interface.port, 0))	{		SET_MSG_RESULT(result, zbx_dsprintf(NULL, "cannot connect to TELNET server: %s", zbx_tcp_strerror()));		goto close;	}	flags = fcntl(s.socket, F_GETFL);	if (0 == (flags & O_NONBLOCK))		fcntl(s.socket, F_SETFL, flags | O_NONBLOCK);	if (FAIL == telnet_login(s.socket, item->username, item->password, result))		goto tcp_close;	if (FAIL == telnet_execute(s.socket, item->params, result, encoding))		goto tcp_close;	ret = SUCCEED;tcp_close:	zbx_tcp_close(&s);close:	zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));	return ret;}

/****************************************************************************** *                                                                            * * Function: ja_connect_to_port                                               * *                                                                            * * Purpose: connection to the specified port on the host                      * *                                                                            * * Parameters: s            (in)  - socket identification information         * *             host         (in)  - host name                                 * *             inner_job_id (in)  - inner job id                              * *             txn          (in)  - transaction instruction                   * *                                                                            * * Return value: SUCCEED - normal end                                         * *               FAIL    - an error occurred                                  * *                                                                            * * Comments:                                                                  * *                                                                            * ******************************************************************************/int ja_connect_to_port(zbx_sock_t * s, const char *host, const zbx_uint64_t inner_job_id, int txn){    int ret;    char host_ip[128];    zbx_uint64_t hostid;    int port;    const char *__function_name = "ja_connect_to_port";    zabbix_log(LOG_LEVEL_DEBUG, "In %s() host: %s", __function_name, host);    hostid = ja_host_getip(host, host_ip, inner_job_id, &port, txn);    if (hostid == 0) {        return FAIL;    }    port = ja_host_getport(hostid, 1);    zabbix_log(LOG_LEVEL_DEBUG, "In %s() connect the host. source_ip: %s, host_ip: %s, port: %d, timeout: %d",               __function_name, CONFIG_SOURCE_IP, host_ip, port, CONFIG_TIMEOUT);    ret = zbx_tcp_connect(s, CONFIG_SOURCE_IP, host_ip, port, CONFIG_TIMEOUT);    if (ret == FAIL) {        ja_log("JACONNECT300001", 0, NULL, inner_job_id, __function_name, zbx_tcp_strerror(),               host_ip, port, CONFIG_SOURCE_IP, CONFIG_TIMEOUT);    }    return ret;}

/****************************************************************************** *                                                                            * * 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: send_proxyconfig                                                 * *                                                                            * * Purpose: send configuration tables to the proxy                            * *                                                                            * * Parameters:                                                                * *                                                                            * * Return value:  SUCCEED - processed successfully                            * *                FAIL - an error occurred                                    * *                                                                            * * Author: Aleksander Vladishev                                               * *                                                                            * * Comments:                                                                  * *                                                                            * ******************************************************************************/int	send_proxyconfig(zbx_sock_t *sock, struct zbx_json_parse *jp){	zbx_uint64_t	proxy_hostid;	struct zbx_json	j;	int		res = FAIL;	zabbix_log(LOG_LEVEL_DEBUG, "In send_proxyconfig()");	if (FAIL == get_proxy_id(jp, &proxy_hostid))		goto exit;	update_proxy_lastaccess(proxy_hostid);	zbx_json_init(&j, 512*1024);	if (SUCCEED == (res = get_proxyconfig_data(proxy_hostid, &j))) {		zabbix_log(LOG_LEVEL_WARNING, "Sending configuration data to proxy. Datalen %d",				(int)j.buffer_size);		zabbix_log(LOG_LEVEL_DEBUG, "%s",				j.buffer);		if (FAIL == (res = zbx_tcp_send(sock, j.buffer)))			zabbix_log(LOG_LEVEL_WARNING, "Error while sending configuration. %s",					zbx_tcp_strerror());	}	zbx_json_free(&j);exit:	return res;}

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

int	connect_to_node(int nodeid, zbx_sock_t *sock){	DB_RESULT	result;	DB_ROW		row;	unsigned short	port;	int		res = FAIL;	zabbix_log(LOG_LEVEL_DEBUG, "In connect_to_node(nodeid:%d)", nodeid);	result = DBselect("select ip,port from nodes where nodeid=%d", nodeid);	if (NULL != (row = DBfetch(result)))	{		port = (unsigned short)atoi(row[1]);		if (SUCCEED == zbx_tcp_connect(sock, CONFIG_SOURCE_IP, row[0], port, 0))			res = SUCCEED;		else			zabbix_log(LOG_LEVEL_ERR, "NODE %d: Unable to connect to Node [%d] error: %s",					CONFIG_NODEID, nodeid, zbx_tcp_strerror());	}	else		zabbix_log(LOG_LEVEL_ERR, "NODE %d: Node [%d] is unknown", CONFIG_NODEID, nodeid);	DBfree_result(result);	return res;}

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

ZBX_THREAD_ENTRY(listener_thread, args){	int		ret, local_request_failed = 0;	zbx_sock_t	s;	assert(args);	assert(((zbx_thread_args_t *)args)->args);	process_type = ((zbx_thread_args_t *)args)->process_type;	server_num = ((zbx_thread_args_t *)args)->server_num;	process_num = ((zbx_thread_args_t *)args)->process_num;	zabbix_log(LOG_LEVEL_INFORMATION, "%s #%d started [%s #%d]", get_daemon_type_string(daemon_type),			server_num, get_process_type_string(process_type), process_num);	memcpy(&s, (zbx_sock_t *)((zbx_thread_args_t *)args)->args, sizeof(zbx_sock_t));	zbx_free(args);	while (ZBX_IS_RUNNING())	{		zbx_setproctitle("listener #%d [waiting for connection]", process_num);		if (SUCCEED == (ret = zbx_tcp_accept(&s)))		{			local_request_failed = 0;     /* reset consecutive errors counter */			zbx_setproctitle("listener #%d [processing request]", process_num);			if (SUCCEED == (ret = zbx_tcp_check_security(&s, CONFIG_HOSTS_ALLOWED, 0)))				process_listener(&s);			zbx_tcp_unaccept(&s);		}		if (SUCCEED == ret || EINTR == zbx_sock_last_error())			continue;		zabbix_log(LOG_LEVEL_DEBUG, "failed to accept an incoming connection: %s", zbx_tcp_strerror());		if (local_request_failed++ > 1000)		{			zabbix_log(LOG_LEVEL_WARNING, "too many failures to accept an incoming connection");			local_request_failed = 0;		}		if (ZBX_IS_RUNNING())			zbx_sleep(1);	}#ifdef _WINDOWS	ZBX_DO_EXIT();	zbx_thread_exit(EXIT_SUCCESS);#endif}

ZBX_THREAD_ENTRY(listener_thread, args){	int		ret, local_request_failed = 0;	zbx_sock_t	s;	assert(args);	assert(((zbx_thread_args_t *)args)->args);	zabbix_log(LOG_LEVEL_WARNING, "agent #%d started [listener]", ((zbx_thread_args_t *)args)->thread_num);	memcpy(&s, (zbx_sock_t *)((zbx_thread_args_t *)args)->args, sizeof(zbx_sock_t));	zbx_free(args);	while (ZBX_IS_RUNNING())	{		zbx_setproctitle("listener [waiting for connection]");		if (SUCCEED == (ret = zbx_tcp_accept(&s)))		{			local_request_failed = 0;     /* reset consecutive errors counter */			zbx_setproctitle("listener [processing request]");			zabbix_log(LOG_LEVEL_DEBUG, "Processing request.");			if (SUCCEED == (ret = zbx_tcp_check_security(&s, CONFIG_HOSTS_ALLOWED, 0)))				process_listener(&s);			zbx_tcp_unaccept(&s);		}		if (SUCCEED == ret)			continue;		zabbix_log(LOG_LEVEL_DEBUG, "Listener error: %s", zbx_tcp_strerror());		if (local_request_failed++ > 1000)		{			zabbix_log(LOG_LEVEL_WARNING, "Too many consecutive errors on accept() call.");			local_request_failed = 0;		}		if (ZBX_IS_RUNNING())			zbx_sleep(1);	}#ifdef _WINDOWS	zabbix_log(LOG_LEVEL_INFORMATION, "zabbix_agentd listener stopped");	ZBX_DO_EXIT();	zbx_thread_exit(0);#endif}

static int	send_data_to_server(zbx_sock_t *sock, const char *data){	int	res;	zabbix_log(LOG_LEVEL_DEBUG, "In send_data_to_server() [%s]", data);	if (FAIL == (res = zbx_tcp_send(sock, data)))		zabbix_log(LOG_LEVEL_ERR, "Error while sending data to the server [%s]", zbx_tcp_strerror());	return res;}

ZBX_THREAD_ENTRY(listener_thread, pSock){	int 		ret,		local_request_failed = 0;	zbx_sock_t	s;	assert(pSock);	zbx_setproctitle("listener waiting for connection");	zabbix_log( LOG_LEVEL_INFORMATION, "zabbix_agentd listener started");	memcpy(&s, ((zbx_sock_t *)pSock), sizeof(zbx_sock_t));	while(ZBX_IS_RUNNING)	{		if( SUCCEED == (ret = zbx_tcp_accept(&s)) )		{			local_request_failed = 0;     /* Reset consecutive errors counter */						zbx_setproctitle("processing request");			zabbix_log(LOG_LEVEL_DEBUG, "Processing request.");			if( SUCCEED == (ret = zbx_tcp_check_security(&s, CONFIG_HOSTS_ALLOWED, 0)) )			{				process_listener(&s);			}			zbx_tcp_unaccept(&s);		}		zbx_setproctitle("listener waiting for connection");		if( SUCCEED == ret )	continue;		zabbix_log(LOG_LEVEL_DEBUG, "Listener error: %s", zbx_tcp_strerror());		if (local_request_failed++ > 1000)		{			zabbix_log( LOG_LEVEL_WARNING, "Too many consecutive errors on accept() call.");			local_request_failed = 0;		}		if(ZBX_IS_RUNNING)			zbx_sleep(1);			}	zabbix_log( LOG_LEVEL_INFORMATION, "zabbix_agentd listener stopped");	ZBX_DO_EXIT();	zbx_tread_exit(0);}

static void	process_listener(zbx_sock_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;				if (NULL == buffer)					buffer = 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				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_tcp_strerror());}

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

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

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	send_data_to_node(int nodeid, zbx_sock_t *sock, const char *data){	int	res;	if (FAIL == (res = zbx_tcp_send(sock, data)))	{		zabbix_log(LOG_LEVEL_ERR, "NODE %d: Error while sending data to Node [%d] error: %s",				CONFIG_NODEID, nodeid, zbx_tcp_strerror());	}	else		zabbix_log(LOG_LEVEL_DEBUG, "NODE %d: Sending [%s] to Node [%d]",				CONFIG_NODEID, data, nodeid);	return res;}

/****************************************************************************** *                                                                            * * Function:                                                                  * *                                                                            * * Purpose:                                                                   * *                                                                            * * Parameters:                                                                * *                                                                            * * Return value:                                                              * *                                                                            * * Comments:                                                                  * *                                                                            * ******************************************************************************/int ja_tcp_recv_to(zbx_sock_t * s, ja_job_object * job, int timeout){    int ret, cnt=0;    char *data;    const char *__function_name = "ja_tcp_recv_to";    zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);    // 2016/01/07 Park.iggy ADD    /* ORG    ret = zbx_tcp_recv_to(s, &data, timeout);    if (ret == FAIL) {        zbx_snprintf(job->message, sizeof(job->message), "%s",                     zbx_tcp_strerror());        goto error;    }    */    while((ret = zbx_tcp_recv_to(s, &data, timeout+15)) == FAIL){    	if(cnt >= 1)    		break;    	cnt++;    }    if (ret == FAIL) {    	zbx_snprintf(job->message, sizeof(job->message), "%s",                     zbx_tcp_strerror());        goto error;    }    //Park.iggy END    zabbix_log(LOG_LEVEL_DEBUG, "In %s() %s", __function_name, data);    if (strlen(data) == 0) {        zbx_snprintf(job->message, sizeof(job->message),                     "received data is null");        goto error;    }    zbx_rtrim(data, "/r/n");    ret = ja_telegram_from(data, job);  error:    if (ret == FAIL) {        zabbix_log(LOG_LEVEL_ERR, "In %s() message: %s", __function_name,                   job->message);    }    return ret;}

int	tcp_expect(const char *host, unsigned short port, int timeout, const char *request,		int (*validate_func)(const char *), const char *sendtoclose, int *value_int){	zbx_sock_t	s;	const char	*buf;	int		net, val = ZBX_TCP_EXPECT_OK;	*value_int = 0;	if (SUCCEED != (net = zbx_tcp_connect(&s, CONFIG_SOURCE_IP, host, port, timeout)))		goto out;	if (NULL != request)		net = zbx_tcp_send_raw(&s, request);	if (NULL != validate_func && SUCCEED == net)	{		val = ZBX_TCP_EXPECT_FAIL;		while (NULL != (buf = zbx_tcp_recv_line(&s)))		{			val = validate_func(buf);			if (ZBX_TCP_EXPECT_OK == val)				break;			if (ZBX_TCP_EXPECT_FAIL == val)			{				zabbix_log(LOG_LEVEL_DEBUG, "TCP expect content error, received [%s]", buf);				break;			}		}	}	if (NULL != sendtoclose && SUCCEED == net && ZBX_TCP_EXPECT_OK == val)		zbx_tcp_send_raw(&s, sendtoclose);	if (SUCCEED == net && ZBX_TCP_EXPECT_OK == val)		*value_int = 1;	zbx_tcp_close(&s);out:	if (SUCCEED != net)		zabbix_log(LOG_LEVEL_DEBUG, "TCP expect network error: %s", zbx_tcp_strerror());	return SYSINFO_RET_OK;}

int	connect_to_server(zbx_sock_t *sock, int timeout){	int	res;	zabbix_log(LOG_LEVEL_DEBUG, "In connect_to_server() [%s]:%d [timeout:%d]",			CONFIG_SERVER,			CONFIG_SERVER_PORT,			timeout);	if (FAIL == (res = zbx_tcp_connect(sock, CONFIG_SOURCE_IP, CONFIG_SERVER, CONFIG_SERVER_PORT, timeout)))		zabbix_log(LOG_LEVEL_ERR, "Unable connect to the server [%s]:%d [%s]",				CONFIG_SERVER,				CONFIG_SERVER_PORT,				zbx_tcp_strerror());	return res;}

/****************************************************************************** *                                                                            * * Function: send_proxyconfig                                                 * *                                                                            * * Purpose: send configuration tables to the proxy from server                * *          (for active proxies)                                              * *                                                                            * * Author: Alexander Vladishev                                                * *                                                                            * ******************************************************************************/void	send_proxyconfig(zbx_sock_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, &error))	{		zbx_send_response(sock, FAIL, error, CONFIG_TIMEOUT);		zabbix_log(LOG_LEVEL_WARNING, "proxy configuration request from active proxy on /"%s/" failed: %s",				get_ip_by_socket(sock), 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 proxy configuration: %s", error);		goto clean;	}	zabbix_log(LOG_LEVEL_WARNING, "sending configuration data to proxy /"%s/", datalen " ZBX_FS_SIZE_T,			host, (zbx_fs_size_t)j.buffer_size);	zabbix_log(LOG_LEVEL_DEBUG, "%s", j.buffer);	alarm(CONFIG_TIMEOUT);	if (SUCCEED != zbx_tcp_send(sock, j.buffer))		zabbix_log(LOG_LEVEL_WARNING, "cannot send configuration: %s", zbx_tcp_strerror());	alarm(0);clean:	zbx_json_free(&j);out:	zbx_free(error);	zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);}

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

/****************************************************************************** *                                                                            * * 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:                                                                  * *                                                                            * ******************************************************************************/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:                                                                  * *                                                                            * ******************************************************************************/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());    }}