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

char	*get_ip_by_socket(zbx_sock_t *s){	ZBX_SOCKADDR	sa;	ZBX_SOCKLEN_T	sz = sizeof(sa);	static char	host[64];	char		*error_message = NULL;	if (ZBX_TCP_ERROR == getpeername(s->socket, (struct sockaddr*)&sa, &sz))	{		error_message = strerror_from_system(zbx_sock_last_error());		zbx_set_tcp_strerror("connection rejected, getpeername() failed: %s", error_message);		goto out;	}#if defined(HAVE_IPV6)	if (0 != zbx_getnameinfo((struct sockaddr *)&sa, host, sizeof(host), NULL, 0, NI_NUMERICHOST))	{		error_message = strerror_from_system(zbx_sock_last_error());		zbx_set_tcp_strerror("connection rejected, getnameinfo() failed: %s", error_message);	}#else	zbx_snprintf(host, sizeof(host), "%s", inet_ntoa(sa.sin_addr));#endifout:	if (NULL != error_message)	{		zabbix_log(LOG_LEVEL_WARNING, "Cannot get socket IP address: %s", error_message);		strscpy(host, "unknown IP");	}	return host;}

int	NET_TCP_LISTEN(AGENT_REQUEST *request, AGENT_RESULT *result){	MIB_TCPTABLE	*pTcpTable = NULL;	DWORD		dwSize, dwRetVal;	int		i, ret = SYSINFO_RET_FAIL;	unsigned short	port;	char		*port_str;	if (1 < request->nparam)	{		SET_MSG_RESULT(result, zbx_strdup(NULL, "Too many parameters."));		return SYSINFO_RET_FAIL;	}	port_str = get_rparam(request, 0);	if (NULL == port_str || SUCCEED != is_ushort(port_str, &port))	{		SET_MSG_RESULT(result, zbx_strdup(NULL, "Invalid first parameter."));		return SYSINFO_RET_FAIL;	}	dwSize = sizeof(MIB_TCPTABLE);	pTcpTable = (MIB_TCPTABLE *)zbx_malloc(pTcpTable, dwSize);	/* Make an initial call to GetTcpTable to	   get the necessary size into the dwSize variable */	if (ERROR_INSUFFICIENT_BUFFER == (dwRetVal = GetTcpTable(pTcpTable, &dwSize, TRUE)))		pTcpTable = (MIB_TCPTABLE *)zbx_realloc(pTcpTable, dwSize);	/* Make a second call to GetTcpTable to get	   the actual data we require */	if (NO_ERROR == (dwRetVal = GetTcpTable(pTcpTable, &dwSize, TRUE)))	{		for (i = 0; i < (int)pTcpTable->dwNumEntries; i++)		{			if (MIB_TCP_STATE_LISTEN == pTcpTable->table[i].dwState &&					port == ntohs((u_short)pTcpTable->table[i].dwLocalPort))			{				SET_UI64_RESULT(result, 1);				break;			}		}		ret = SYSINFO_RET_OK;	}	else	{		zabbix_log(LOG_LEVEL_DEBUG, "GetTcpTable failed with error: %s", strerror_from_system(dwRetVal));		SET_MSG_RESULT(result, zbx_dsprintf(NULL, "Cannot obtain system information: %s",				strerror_from_system(dwRetVal)));		goto clean;	}	if (!ISSET_UI64(result))		SET_UI64_RESULT(result, 0);clean:	zbx_free(pTcpTable);	return ret;}

char	*get_ip_by_socket(zbx_sock_t *s){#if defined(HAVE_IPV6)	struct		sockaddr_storage sa;#else	ZBX_SOCKADDR	sa;#endif	socklen_t	sz;	static char	buffer[64];	zabbix_log( LOG_LEVEL_DEBUG, "In get_ip_by_socket()");	*buffer = '/0';	sz = sizeof(sa);	if (ZBX_TCP_ERROR == getpeername(s->socket, (struct sockaddr*)&sa, &sz))	{		zbx_set_tcp_strerror("Connection rejected. getpeername failed [%s]",				strerror_from_system(zbx_sock_last_error()));		return buffer;	}#if defined(HAVE_IPV6)	if (0 != getnameinfo((struct sockaddr*)&sa, sizeof(sa), buffer, sizeof(buffer), NULL, 0, NI_NUMERICHOST))	{		zbx_set_tcp_strerror("Connection rejected. getnameinfo failed [%s] ",				strerror_from_system(zbx_sock_last_error()));	}#else	zbx_snprintf(buffer, sizeof(buffer), "%s", inet_ntoa(sa.sin_addr));#endif	return buffer;}

/* get handles of eventlog */static int	zbx_get_handle_eventlog6(const wchar_t *wsource, zbx_uint64_t *lastlogsize, EVT_HANDLE *query){	const char	*__function_name = "zbx_get_handle_eventlog6";	wchar_t		*event_query = NULL;	DWORD		status = 0;	char		*tmp_str = NULL;	int		ret = FAIL;	zabbix_log(LOG_LEVEL_DEBUG, "In %s(), previous lastlogsize:" ZBX_FS_UI64, __function_name, *lastlogsize);	/* start building the query */	tmp_str = zbx_dsprintf(NULL, "Event/System[EventRecordID>" ZBX_FS_UI64 "]", *lastlogsize);	event_query = zbx_utf8_to_unicode(tmp_str);	/* create massive query for an event on a local computer*/	*query = EvtQuery(NULL, wsource, event_query, EvtQueryChannelPath);	if (NULL == *query)	{		if (ERROR_EVT_CHANNEL_NOT_FOUND == (status = GetLastError()))			zabbix_log(LOG_LEVEL_WARNING, "EvtQuery channel missed:%s", strerror_from_system(status));		else			zabbix_log(LOG_LEVEL_WARNING, "EvtQuery failed:%s", strerror_from_system(status));		goto out;	}	ret = SUCCEED;out:	zbx_free(tmp_str);	zbx_free(event_query);	zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));	return ret;}

char	*get_ip_by_socket(zbx_sock_t *s){	ZBX_SOCKADDR	sa;	ZBX_SOCKLEN_T	sz;	static char	buffer[64];	*buffer = '/0';	sz = sizeof(sa);	if (ZBX_TCP_ERROR == getpeername(s->socket, (struct sockaddr*)&sa, &sz))	{		zbx_set_tcp_strerror("connection rejected, getpeername() failed: %s",				strerror_from_system(zbx_sock_last_error()));		return buffer;	}#if defined(HAVE_IPV6)	if (0 != getnameinfo((struct sockaddr*)&sa, sizeof(sa), buffer, sizeof(buffer), NULL, 0, NI_NUMERICHOST))	{		zbx_set_tcp_strerror("connection rejected, getnameinfo() failed: %s",				strerror_from_system(zbx_sock_last_error()));	}#else	zbx_snprintf(buffer, sizeof(buffer), "%s", inet_ntoa(sa.sin_addr));#endif	return buffer;}

int	zbx_tcp_connect(zbx_sock_t *s, const char *source_ip, const char *ip, unsigned short port, int timeout){	ZBX_SOCKADDR	servaddr_in, source_addr;	struct hostent	*hp;	ZBX_TCP_START();	zbx_tcp_clean(s);	if (NULL == (hp = gethostbyname(ip)))	{#if defined(_WINDOWS)		zbx_set_tcp_strerror("gethostbyname() failed for '%s': %s", ip, strerror_from_system(WSAGetLastError()));#elif defined(HAVE_HSTRERROR)		zbx_set_tcp_strerror("gethostbyname() failed for '%s': [%d] %s", ip, h_errno, hstrerror(h_errno));#else		zbx_set_tcp_strerror("gethostbyname() failed for '%s': [%d]", ip, h_errno);#endif		return FAIL;	}	servaddr_in.sin_family		= AF_INET;	servaddr_in.sin_addr.s_addr	= ((struct in_addr *)(hp->h_addr))->s_addr;	servaddr_in.sin_port		= htons(port);	if (ZBX_SOCK_ERROR == (s->socket = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0)))	{		zbx_set_tcp_strerror("cannot create socket [[%s]:%d]: %s", ip, port, strerror_from_system(zbx_sock_last_error()));		return FAIL;	}#if !defined(_WINDOWS) && !SOCK_CLOEXEC	fcntl(s->socket, F_SETFD, FD_CLOEXEC);#endif	if (NULL != source_ip)	{		source_addr.sin_family		= AF_INET;		source_addr.sin_addr.s_addr	= inet_addr(source_ip);		source_addr.sin_port		= 0;		if (ZBX_TCP_ERROR == bind(s->socket, (struct sockaddr *)&source_addr, sizeof(source_addr)))		{			zbx_set_tcp_strerror("bind() failed: %s", strerror_from_system(zbx_sock_last_error()));			return FAIL;		}	}	if (0 != timeout)		zbx_tcp_timeout_set(s, timeout);	if (ZBX_TCP_ERROR == connect(s->socket, (struct sockaddr *)&servaddr_in, sizeof(servaddr_in)))	{		zbx_set_tcp_strerror("cannot connect to [[%s]:%d]: %s", ip, port, strerror_from_system(zbx_sock_last_error()));		zbx_tcp_close(s);		return FAIL;	}	return SUCCEED;}

/* expand the string message from a specific event handler */static char	*expand_message6(const wchar_t *pname, EVT_HANDLE event){	const char	*__function_name = "expand_message6";	wchar_t		*pmessage = NULL;	EVT_HANDLE	provider = NULL;	DWORD		require = 0;	char		*out_message = NULL;	char		*tmp_pname = NULL;	zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);	if (NULL == (provider = EvtOpenPublisherMetadata(NULL, pname, NULL, 0, 0)))	{		tmp_pname = zbx_unicode_to_utf8(pname);		zabbix_log(LOG_LEVEL_DEBUG, "provider '%s' could not be opened: %s",				strerror_from_system(GetLastError()), tmp_pname);		zbx_free(tmp_pname);		goto out;	}	if (TRUE != EvtFormatMessage(provider, event, 0, 0, NULL, EvtFormatMessageEvent, 0, NULL, &require))	{		if (ERROR_INSUFFICIENT_BUFFER == GetLastError())		{			DWORD	error = ERROR_SUCCESS;			pmessage = zbx_malloc(pmessage, sizeof(WCHAR) * require);			if (TRUE != EvtFormatMessage(provider, event, 0, 0, NULL, EvtFormatMessageEvent, require,					pmessage, &require))			{				error = GetLastError();			}			if (ERROR_SUCCESS == error || ERROR_EVT_UNRESOLVED_VALUE_INSERT == error ||					ERROR_EVT_UNRESOLVED_PARAMETER_INSERT == error ||					ERROR_EVT_MAX_INSERTS_REACHED == error)			{				out_message = zbx_unicode_to_utf8(pmessage);			}			else			{				zabbix_log(LOG_LEVEL_DEBUG, "%s() cannot format message: %s", __function_name,						strerror_from_system(error));				goto out;			}		}	}out:	if (NULL != provider)		EvtClose(provider);	zbx_free(pmessage);	zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, out_message);	/* should be freed */	return out_message;}

int	zbx_tcp_accept(zbx_sock_t *s){	struct sockaddr_storage	serv_addr;	fd_set			sock_set;	ZBX_SOCKET		accepted_socket;	socklen_t		nlen;	int			i, n = 0;	zbx_tcp_unaccept(s);	FD_ZERO(&sock_set);	/* For connection orientated protocols, we will handle the	   packets comprising a connection collectively.  For datagram	   protocols, we have to handle each datagram individually.	   Check to see if we have any sockets remaining to be served	   from previous time through this loop.  If not, call select()	   to wait for a connection request or a datagram to arrive. */	for(i = 0; i < s->num_socks; i++) {#if !defined(_WINDOWS)		if(s->sockets[i] > n)			n = s->sockets[i];#endif		if(FD_ISSET(s->sockets[i], &sock_set))			break;	}	if(i == s->num_socks) {		for (i = 0; i < s->num_socks; i++)			FD_SET(s->sockets[i], &sock_set);		if(select(n + 1, &sock_set, 0, 0, 0) == ZBX_TCP_ERROR) {			zbx_set_tcp_strerror("select() failed with error %d: %s", zbx_sock_last_error(), strerror_from_system(zbx_sock_last_error()));			return	FAIL;		}	}	for (i = 0; i < s->num_socks; i++) {		if (FD_ISSET(s->sockets[i], &sock_set)) {			FD_CLR(s->sockets[i], &sock_set);			break;		}	}	/* Since this socket was returned by the select(), we know we	   have a connection waiting and that this accept() won't block.*/	nlen = sizeof(serv_addr);	if((accepted_socket = (ZBX_SOCKET)accept(s->sockets[i], (struct sockaddr *)&serv_addr, &nlen)) == ZBX_SOCK_ERROR) {		zbx_set_tcp_strerror("accept() failed with error %d: %s", zbx_sock_last_error(), strerror_from_system(zbx_sock_last_error()));		return FAIL;	}	s->socket2	= s->socket;		/* remember main socket */	s->socket	= accepted_socket;	/* replace socket to accepted */	s->accepted	= 1;	return SUCCEED;}

int zbx_tcp_listen(	zbx_sock_t	*s,	const char	*listen_ip,	unsigned short	listen_port	){	ZBX_SOCKADDR	serv_addr;	int		on, res = FAIL;	ZBX_TCP_START();	zbx_tcp_clean(s);	if(ZBX_SOCK_ERROR == (s->socket = socket(AF_INET,SOCK_STREAM,0)))	{		zbx_set_tcp_strerror("Cannot create socket [%s:%u] [%s]", listen_ip, listen_port, strerror_from_system(zbx_sock_last_error()));		goto out;	}	/* Enable address reuse */	/* This is to immediately use the address even if it is in TIME_WAIT state */	/* http://www-128.ibm.com/developerworks/linux/library/l-sockpit/index.html */	on = 1;	if( -1 == setsockopt(s->socket, SOL_SOCKET, SO_REUSEADDR, (void *)&on, sizeof(on) ))	{		zbx_set_tcp_strerror("Cannot setsockopt SO_REUSEADDR [%s]", strerror_from_system(zbx_sock_last_error()));	}	/* Create socket	Fill in local address structure */	memset(&serv_addr, 0, sizeof(ZBX_SOCKADDR));	serv_addr.sin_family		= AF_INET;	serv_addr.sin_addr.s_addr	= listen_ip ? inet_addr(listen_ip) : htonl(INADDR_ANY);	serv_addr.sin_port		= htons((unsigned short)listen_port);	/* Bind socket */	if (ZBX_SOCK_ERROR == bind(s->socket,(struct sockaddr *)&serv_addr,sizeof(ZBX_SOCKADDR)) )	{		zbx_set_tcp_strerror("Cannot bind to port %u for server %s. Error [%s]. Another zabbix_agentd already running ?",				listen_port,				listen_ip ? listen_ip : "[ANY]",				strerror_from_system(zbx_sock_last_error()));		goto out;	}	if( ZBX_SOCK_ERROR == listen(s->socket, SOMAXCONN) )	{		zbx_set_tcp_strerror("Listen failed. [%s]", strerror_from_system(zbx_sock_last_error()));		goto out;	}	res = SUCCEED;out:	return res;}

int	zbx_tcp_connect(zbx_sock_t *s, const char *source_ip, const char *ip, unsigned short port, int timeout){	ZBX_SOCKADDR	servaddr_in, source_addr;	struct hostent	*hp;	ZBX_TCP_START();	zbx_tcp_clean(s);	if (NULL == (hp = zbx_gethost(ip)))		return FAIL;	servaddr_in.sin_family		= AF_INET;	servaddr_in.sin_addr.s_addr	= ((struct in_addr *)(hp->h_addr))->s_addr;	servaddr_in.sin_port		= htons(port);	if (ZBX_SOCK_ERROR == (s->socket = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0)))	{		zbx_set_tcp_strerror("Cannot create socket [%s:%d] [%s]", ip, port, strerror_from_system(zbx_sock_last_error()));		return FAIL;	}#if !defined(_WINDOWS) && defined(HAVE_FCNTL_H) && !SOCK_CLOEXEC	fcntl(s->socket, F_SETFD, FD_CLOEXEC);#endif	if (NULL != source_ip)	{		source_addr.sin_family		= AF_INET;		source_addr.sin_addr.s_addr	= inet_addr(source_ip);		source_addr.sin_port		= 0;		if (ZBX_TCP_ERROR == bind(s->socket, (struct sockaddr *)&source_addr, sizeof(ZBX_SOCKADDR)))		{			zbx_set_tcp_strerror("bind() failed with error %d: %s/n",					zbx_sock_last_error(),					strerror_from_system(zbx_sock_last_error()));			return FAIL;		}	}	if (0 != timeout)		zbx_tcp_timeout_set(s, timeout);	if (ZBX_TCP_ERROR == connect(s->socket, (struct sockaddr *)&servaddr_in, sizeof(ZBX_SOCKADDR)))	{		zbx_set_tcp_strerror("Cannot connect to [%s:%d] [%s]", ip, port, strerror_from_system(zbx_sock_last_error()));		zbx_tcp_close(s);		return FAIL;	}	return SUCCEED;}

int	ZabbixCreateService(const char *path, int multiple_agents){#define MAX_CMD_LEN	MAX_PATH * 2	SC_HANDLE		mgr, service;	SERVICE_DESCRIPTION	sd;	TCHAR			cmdLine[MAX_CMD_LEN];	LPTSTR			wservice_name;	DWORD			code;	int			ret = FAIL;	if (FAIL == svc_OpenSCManager(&mgr))		return ret;	svc_get_command_line(path, multiple_agents, cmdLine, MAX_CMD_LEN);	wservice_name = zbx_utf8_to_unicode(ZABBIX_SERVICE_NAME);	if (NULL == (service = CreateService(mgr, wservice_name, wservice_name, GENERIC_READ, SERVICE_WIN32_OWN_PROCESS,			SERVICE_AUTO_START, SERVICE_ERROR_NORMAL, cmdLine, NULL, NULL, NULL, NULL, NULL)))	{		if (ERROR_SERVICE_EXISTS == (code = GetLastError()))			zbx_error("ERROR: service [%s] already exists", ZABBIX_SERVICE_NAME);		else			zbx_error("ERROR: cannot create service [%s]: %s", ZABBIX_SERVICE_NAME, strerror_from_system(code));	}	else	{		zbx_error("service [%s] installed successfully", ZABBIX_SERVICE_NAME);		CloseServiceHandle(service);		ret = SUCCEED;		/* update the service description */		if (SUCCEED == svc_OpenService(mgr, &service, SERVICE_CHANGE_CONFIG))		{			sd.lpDescription = TEXT("Provides system monitoring");			if (0 == ChangeServiceConfig2(service, SERVICE_CONFIG_DESCRIPTION, &sd))				zbx_error("service description update failed: %s", strerror_from_system(GetLastError()));			CloseServiceHandle(service);		}	}	zbx_free(wservice_name);	CloseServiceHandle(mgr);	if (SUCCEED == ret)		ret = svc_install_event_source(path);	return ret;}

int	zbx_tcp_send_ext(zbx_sock_t *s, const char *data, unsigned char flags, int timeout){	zbx_uint64_t	len64;	ssize_t		i = 0, written = 0;	int		ret = SUCCEED;	ZBX_TCP_START();	if (0 != timeout)		zbx_tcp_timeout_set(s, timeout);	if( flags & ZBX_TCP_NEW_PROTOCOL )	{		/* Write header */		if( ZBX_TCP_ERROR == ZBX_TCP_WRITE(s->socket, ZBX_TCP_HEADER, ZBX_TCP_HEADER_LEN))		{			zbx_set_tcp_strerror("ZBX_TCP_WRITE() failed [%s]", strerror_from_system(zbx_sock_last_error()));			ret = FAIL;			goto cleanup;		}		len64 = (zbx_uint64_t)strlen(data);		len64 = zbx_htole_uint64(len64);		/* Write data length */		if( ZBX_TCP_ERROR == ZBX_TCP_WRITE(s->socket, (char *) &len64, sizeof(len64)) )		{			zbx_set_tcp_strerror("ZBX_TCP_WRITE() failed [%s]", strerror_from_system(zbx_sock_last_error()));			ret = FAIL;			goto cleanup;		}	}	while(written < (ssize_t)strlen(data))	{		if( ZBX_TCP_ERROR == (i = ZBX_TCP_WRITE(s->socket, data+written,(int)(strlen(data)-written))) )		{			zbx_set_tcp_strerror("ZBX_TCP_WRITE() failed [%s]", strerror_from_system(zbx_sock_last_error()));			ret = FAIL;			goto cleanup;		}		written += i;	}cleanup:	if (0 != timeout)		zbx_tcp_timeout_cleanup(s);	return ret;}

int	SYSTEM_HOSTNAME(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result){#ifdef _WINDOWS	DWORD	dwSize = 256;	TCHAR	computerName[256];	char	buffer[256];	int	netbios, ret;	WSADATA sockInfo;	if (1 < num_param(param))		return SYSINFO_RET_FAIL;	if (0 != get_param(param, 1, buffer, sizeof(buffer)))		*buffer = '/0';	if ('/0' == *buffer || 0 == strcmp(buffer, "netbios"))		netbios = 1;	else if (0 == strcmp(buffer, "host"))		netbios = 0;	else		return SYSINFO_RET_FAIL;	if (1 == netbios)	{		/* Buffer size is chosen large enough to contain any DNS name, not just MAX_COMPUTERNAME_LENGTH + 1 */		/* characters. MAX_COMPUTERNAME_LENGTH is usually less than 32, but it varies among systems, so we  */		/* cannot use the constant in a precompiled Windows agent, which is expected to work on any system. */		if (0 == GetComputerName(computerName, &dwSize))			zabbix_log(LOG_LEVEL_ERR, "GetComputerName() failed: %s", strerror_from_system(GetLastError()));		else			SET_STR_RESULT(result, zbx_unicode_to_utf8(computerName));	}	else	{		if (0 != (ret = WSAStartup(MAKEWORD(2, 2), &sockInfo)))			zabbix_log(LOG_LEVEL_ERR, "WSAStartup() failed: %s", strerror_from_system(ret));		else if (SUCCEED != gethostname(buffer, sizeof(buffer)))			zabbix_log(LOG_LEVEL_ERR, "gethostname() failed: %s", strerror_from_system(WSAGetLastError()));		else			SET_STR_RESULT(result, zbx_strdup(NULL, buffer));	}	if (ISSET_STR(result))		return SYSINFO_RET_OK;	else		return SYSINFO_RET_FAIL;#else	return EXECUTE_STR(cmd, "hostname", flags, result);#endif}

/****************************************************************************** *                                                                            * * Function: zbx_tcp_timeout_set                                              * *                                                                            * * Purpose: set timeout for socket operations                                 * *                                                                            * * Parameters: s       - [IN] socket descriptor                               * *             timeout - [IN] timeout, in seconds                             * *                                                                            * * Author: Alexander Vladishev                                                * *                                                                            * ******************************************************************************/static void	zbx_tcp_timeout_set(zbx_sock_t *s, int timeout){	s->timeout = timeout;#if defined(_WINDOWS)	timeout *= 1000;	if (ZBX_TCP_ERROR == setsockopt(s->socket, SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout, sizeof(timeout)))		zbx_set_tcp_strerror("setsockopt() failed: %s", strerror_from_system(zbx_sock_last_error()));	if (ZBX_TCP_ERROR == setsockopt(s->socket, SOL_SOCKET, SO_SNDTIMEO, (const char *)&timeout, sizeof(timeout)))		zbx_set_tcp_strerror("setsockopt() failed: %s", strerror_from_system(zbx_sock_last_error()));#else	alarm(timeout);#endif}

/****************************************************************************** *                                                                            * * Function: zbx_tcp_accept                                                   * *                                                                            * * Purpose: permits an incoming connection attempt on a socket                * *                                                                            * * Return value: SUCCEED - success                                            * *               FAIL - an error occurred                                     * *                                                                            * * Author: Eugene Grigorjev, Aleksandrs Saveljevs                             * *                                                                            * ******************************************************************************/int	zbx_tcp_accept(zbx_sock_t *s){	ZBX_SOCKADDR	serv_addr;	fd_set		sock_set;	ZBX_SOCKET	accepted_socket;	ZBX_SOCKLEN_T	nlen;	int		i, n = 0;	zbx_tcp_unaccept(s);	FD_ZERO(&sock_set);	for (i = 0; i < s->num_socks; i++)	{		FD_SET(s->sockets[i], &sock_set);#if !defined(_WINDOWS)		if (s->sockets[i] > n)			n = s->sockets[i];#endif	}	if (ZBX_TCP_ERROR == select(n + 1, &sock_set, NULL, NULL, NULL))	{		zbx_set_tcp_strerror("select() failed: %s", strerror_from_system(zbx_sock_last_error()));		return FAIL;	}	for (i = 0; i < s->num_socks; i++)	{		if (FD_ISSET(s->sockets[i], &sock_set))			break;	}	/* Since this socket was returned by select(), we know we have */	/* a connection waiting and that this accept() will not block. */	nlen = sizeof(serv_addr);	if (ZBX_SOCK_ERROR == (accepted_socket = (ZBX_SOCKET)accept(s->sockets[i], (struct sockaddr *)&serv_addr, &nlen)))	{		zbx_set_tcp_strerror("accept() failed: %s", strerror_from_system(zbx_sock_last_error()));		return FAIL;	}	s->socket_orig	= s->socket;		/* remember main socket */	s->socket	= accepted_socket;	/* replace socket to accepted */	s->accepted	= 1;	return SUCCEED;}

/****************************************************************************** *                                                                            * * Function: zbx_thread_start                                                 * *                                                                            * * Purpose: Start the handled function as "thread"                            * *                                                                            * * Parameters: "thread" handle                                                * *                                                                            * * Return value: returns a handle to the newly created "thread",              * *               ZBX_THREAD_ERROR on an error                                 * *                                                                            * * Author: Eugene Grigorjev                                                   * *                                                                            * * Comments: The zbx_thread_exit must be called from the handler!             * *                                                                            * ******************************************************************************/ZBX_THREAD_HANDLE	zbx_thread_start(ZBX_THREAD_ENTRY_POINTER(handler), zbx_thread_args_t *thread_args){	ZBX_THREAD_HANDLE	thread = ZBX_THREAD_HANDLE_NULL;#ifdef _WINDOWS	unsigned		thrdaddr;	/* NOTE: _beginthreadex returns 0 on failure, rather than 1 */	if (0 == (thread = (ZBX_THREAD_HANDLE)_beginthreadex(NULL, 0, handler, thread_args, 0, &thrdaddr)))	{		zabbix_log(LOG_LEVEL_CRIT, "failed to create a thread: %s", strerror_from_system(GetLastError()));		thread = (ZBX_THREAD_HANDLE)ZBX_THREAD_ERROR;	}#else	if (0 == (thread = zbx_child_fork()))	/* child process */	{		(*handler)(thread_args);		/* The zbx_thread_exit must be called from the handler. */		/* And in normal case the program will never reach this point. */		zbx_thread_exit(EXIT_SUCCESS);		/* program will never reach this point */	}	else if (-1 == thread)	{		zbx_error("failed to fork: %s", zbx_strerror(errno));		thread = (ZBX_THREAD_HANDLE)ZBX_THREAD_ERROR;	}#endif	return thread;}

int	ZabbixStopService(){	SC_HANDLE	mgr, service;	SERVICE_STATUS	status;	int		ret = FAIL;	if (FAIL == svc_OpenSCManager(&mgr))		return ret;	if (SUCCEED == svc_OpenService(mgr, &service, SERVICE_STOP))	{		if (0 != ControlService(service, SERVICE_CONTROL_STOP, &status))		{			zbx_error("service [%s] stopped successfully", ZABBIX_SERVICE_NAME);			ret = SUCCEED;		}		else		{			zbx_error("ERROR: cannot stop service [%s]: %s",					ZABBIX_SERVICE_NAME, strerror_from_system(GetLastError()));		}		CloseServiceHandle(service);	}	CloseServiceHandle(mgr);	return ret;}

int	ZabbixStartService(){	SC_HANDLE	mgr, service;	int		ret = FAIL;	if (FAIL == svc_OpenSCManager(&mgr))		return ret;	if (SUCCEED == svc_OpenService(mgr, &service, SERVICE_START))	{		if (0 != StartService(service, 0, NULL))		{			zbx_error("service [%s] started successfully", ZABBIX_SERVICE_NAME);			ret = SUCCEED;		}		else		{			zbx_error("ERROR: cannot start service [%s]: %s",					ZABBIX_SERVICE_NAME, strerror_from_system(GetLastError()));		}		CloseServiceHandle(service);	}	CloseServiceHandle(mgr);	return ret;}

int	ZabbixRemoveService(){	SC_HANDLE	mgr, service;	int		ret = FAIL;	if (FAIL == svc_OpenSCManager(&mgr))		return ret;	if (SUCCEED == svc_OpenService(mgr, &service, DELETE))	{		if (0 != DeleteService(service))		{			zbx_error("service [%s] uninstalled successfully", ZABBIX_SERVICE_NAME);			ret = SUCCEED;		}		else		{			zbx_error("ERROR: cannot remove service [%s]: %s",					ZABBIX_SERVICE_NAME, strerror_from_system(GetLastError()));		}		CloseServiceHandle(service);	}	CloseServiceHandle(mgr);	if (SUCCEED == ret)		ret = svc_RemoveEventSource();	return ret;}

/****************************************************************************** *                                                                            * * Function:                                                                  * *                                                                            * * Purpose:                                                                   * *                                                                            * * Parameters:                                                                * *                                                                            * * Return value:                                                              * *                                                                            * * Comments:                                                                  * *                                                                            * ******************************************************************************/int ja_tcp_accept(zbx_sock_t * s){    ZBX_SOCKADDR serv_addr;    ZBX_SOCKLEN_T nlen;    const char *__function_name = "ja_tcp_accept";    zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);    zbx_tcp_unaccept(s);    nlen = sizeof(serv_addr);    if (ZBX_SOCK_ERROR ==        (s->socket =         (ZBX_SOCKET) accept(s->sockets[0], (struct sockaddr *) &serv_addr,                             &nlen))) {        if (zbx_sock_last_error() == EINTR)            return SUCCEED;        zabbix_log(LOG_LEVEL_WARNING, "accept() failed: %s %d",                   strerror_from_system(zbx_sock_last_error()),                   zbx_sock_last_error());        return FAIL;    }    s->socket_orig = ZBX_SOCK_ERROR;    s->accepted = 1;    return SUCCEED;}

/****************************************************************************** *                                                                            * * Function: zbx_mutex_unlock                                                 * *                                                                            * * Purpose: Unlock the mutex                                                  * *                                                                            * * Parameters: mutex - handle of mutex                                        * *                                                                            * * Return value:                                                              * *                                                                            * * Author: Eugene Grigorjev, Alexander Vladishev                              * *                                                                            * * Comments:                                                                  * *                                                                            * ******************************************************************************/void	__zbx_mutex_unlock(const char *filename, int line, ZBX_MUTEX *mutex){#if defined(_WINDOWS)	if (!*mutex)		return;	if (0 == ReleaseMutex(*mutex))	{		zbx_error("[file:'%s',line:%d] Unlock failed [%s]",				filename, line, strerror_from_system(GetLastError()));		exit(FAIL);	}#else /* not _WINDOWS */	struct sembuf	sem_unlock = { *mutex, 1, SEM_UNDO };	if (!*mutex)		return;	while (-1 == semop(ZBX_SEM_LIST_ID, &sem_unlock, 1))	{		if (EINTR != errno)		{			zbx_error("[file:'%s',line:%d] Lock failed [%s]",					filename, line, strerror(errno));			exit(FAIL);		}	}#endif /* _WINDOWS */}

/****************************************************************************** *                                                                            * * Function: zbx_mutex_unlock                                                 * *                                                                            * * Purpose: Unlock the mutex                                                  * *                                                                            * * Parameters: mutex - handle of mutex                                        * *                                                                            * * Author: Eugene Grigorjev, Alexander Vladishev                              * *                                                                            * ******************************************************************************/void	__zbx_mutex_unlock(const char *filename, int line, ZBX_MUTEX *mutex){#ifndef _WINDOWS	struct sembuf	sem_unlock;#endif	if (ZBX_MUTEX_NULL == *mutex)		return;#ifdef _WINDOWS	if (0 == ReleaseMutex(*mutex))	{		zbx_error("[file:'%s',line:%d] unlock failed: %s",				filename, line, strerror_from_system(GetLastError()));		exit(EXIT_FAILURE);	}#else	sem_unlock.sem_num = *mutex;	sem_unlock.sem_op = 1;	sem_unlock.sem_flg = SEM_UNDO;	while (-1 == semop(ZBX_SEM_LIST_ID, &sem_unlock, 1))	{		if (EINTR != errno)		{			zbx_error("[file:'%s',line:%d] unlock failed: %s", filename, line, zbx_strerror(errno));			exit(EXIT_FAILURE);		}	}#endif}

/****************************************************************************** *                                                                            * * Function: zbx_mutex_lock                                                   * *                                                                            * * Purpose: Waits until the mutex is in the signalled state                   * *                                                                            * * Parameters: mutex - handle of mutex                                        * *                                                                            * * Author: Eugene Grigorjev, Alexander Vladishev                              * *                                                                            * ******************************************************************************/void	__zbx_mutex_lock(const char *filename, int line, ZBX_MUTEX *mutex){#ifndef _WINDOWS	struct sembuf	sem_lock;#endif	if (ZBX_MUTEX_NULL == *mutex)		return;#ifdef _WINDOWS	if (WAIT_OBJECT_0 != WaitForSingleObject(*mutex, INFINITE))	{		zbx_error("[file:'%s',line:%d] lock failed: %s",				filename, line, strerror_from_system(GetLastError()));		exit(EXIT_FAILURE);	}#else	sem_lock.sem_num = *mutex;	sem_lock.sem_op = -1;	sem_lock.sem_flg = SEM_UNDO;	while (-1 == semop(ZBX_SEM_LIST_ID, &sem_lock, 1))	{		if (EINTR != errno)		{			zbx_error("[file:'%s',line:%d] lock failed: %s", filename, line, zbx_strerror(errno));			exit(EXIT_FAILURE);		}	}#endif}

/****************************************************************************** *                                                                            * * Function: zbx_mutex_lock                                                   * *                                                                            * * Purpose: Waits until the mutex is in the signalled state                   * *                                                                            * * Parameters: mutex - handle of mutex                                        * *                                                                            * * Return value:                                                              * *                                                                            * * Author: Eugene Grigorjev, Alexander Vladishev                              * *                                                                            * * Comments:                                                                  * *                                                                            * ******************************************************************************/void	__zbx_mutex_lock(const char *filename, int line, ZBX_MUTEX *mutex){#if defined(_WINDOWS)	if (!*mutex)		return;	if (WAIT_OBJECT_0 != WaitForSingleObject(*mutex, INFINITE))	{		zbx_error("[file:'%s',line:%d] Lock failed [%s]",				filename, line, strerror_from_system(GetLastError()));		exit(FAIL);	}#else /* not _WINDOWS */	struct sembuf	sem_lock = { *mutex, -1, SEM_UNDO };	if (!*mutex)		return;	while (-1 == semop(ZBX_SEM_LIST_ID, &sem_lock, 1))	{		if (EINTR != errno)		{			zbx_error("[file:'%s',line:%d] Lock failed [%s]",					filename, line, strerror(errno));			exit(FAIL);		}	}#endif /* _WINDOWS */}

static int	telnet_waitsocket(ZBX_SOCKET socket_fd, int mode){	const char	*__function_name = "telnet_waitsocket";	struct timeval	tv;	int		rc;	fd_set		fd, *readfd = NULL, *writefd = NULL;	zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);	tv.tv_sec = 0;	tv.tv_usec = 100000;	/* 1/10 sec */	FD_ZERO(&fd);	FD_SET(socket_fd, &fd);	if (WAIT_READ == mode)		readfd = &fd;	else		writefd = &fd;	rc = select((int)(socket_fd + 1), readfd, writefd, NULL, &tv);	if (ZBX_TCP_ERROR == rc)	{		zabbix_log(LOG_LEVEL_DEBUG, "%s() rc:%d errno:%d error:[%s]", __function_name, rc,				zbx_sock_last_error(), strerror_from_system(zbx_sock_last_error()));	}	zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%d", __function_name, rc);	return rc;}

static int	svc_install_event_source(const char *path){	HKEY	hKey;	DWORD	dwTypes = EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE;	wchar_t	execName[MAX_PATH];	wchar_t	regkey[256], *wevent_source;	svc_get_fullpath(path, execName, MAX_PATH);	wevent_source = zbx_utf8_to_unicode(ZABBIX_EVENT_SOURCE);	StringCchPrintf(regkey, ARRSIZE(regkey), EVENTLOG_REG_PATH TEXT("System//%s"), wevent_source);	zbx_free(wevent_source);	if (ERROR_SUCCESS != RegCreateKeyEx(HKEY_LOCAL_MACHINE, regkey, 0, NULL, REG_OPTION_NON_VOLATILE,			KEY_SET_VALUE, NULL, &hKey, NULL))	{		zbx_error("unable to create registry key: %s", strerror_from_system(GetLastError()));		return FAIL;	}	RegSetValueEx(hKey, TEXT("TypesSupported"), 0, REG_DWORD, (BYTE *)&dwTypes, sizeof(DWORD));	RegSetValueEx(hKey, TEXT("EventMessageFile"), 0, REG_EXPAND_SZ, (BYTE *)execName,			(DWORD)(wcslen(execName) + 1) * sizeof(wchar_t));	RegCloseKey(hKey);	zbx_error("event source [%s] installed successfully", ZABBIX_EVENT_SOURCE);	return SUCCEED;}

static ssize_t	telnet_socket_write(ZBX_SOCKET socket_fd, const void *buf, size_t count){	const char	*__function_name = "telnet_socket_write";	ssize_t		rc;	int		error;	zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);	while (ZBX_TCP_ERROR == (rc = ZBX_TCP_WRITE(socket_fd, buf, count)))	{		error = zbx_sock_last_error();	/* zabbix_log() resets the error code */		zabbix_log(LOG_LEVEL_DEBUG, "%s() rc:%d errno:%d error:[%s]",				__function_name, rc, error, strerror_from_system(error));#ifdef _WINDOWS		if (WSAEWOULDBLOCK == error)#else		if (EAGAIN == error)#endif		{			telnet_waitsocket(socket_fd, WAIT_WRITE);			continue;		}		break;	}	zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%d", __function_name, rc);	return rc;}

/* expand the string message from a specific event handler */static char *expand_message6(const wchar_t *pname, EVT_HANDLE event){	const char	*__function_name = "expand_message6";	wchar_t		*pmessage = NULL;	EVT_HANDLE	provider = NULL;	DWORD		require = 0;	char		*out_message = NULL;	char		*tmp_pname = NULL;	zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);	if (NULL == (provider = EvtOpenPublisherMetadata(NULL, pname, NULL, 0, 0)))	{		tmp_pname = zbx_unicode_to_utf8(pname);		zabbix_log(LOG_LEVEL_DEBUG, "provider '%s' could not be opened: %s",				strerror_from_system(GetLastError()), tmp_pname);		zbx_free(tmp_pname);		goto finish;	}	if (TRUE != EvtFormatMessage(provider, event, 0, 0, NULL, EvtFormatMessageEvent, 0, NULL, &require) )	{		if (ERROR_INSUFFICIENT_BUFFER == GetLastError())		{			pmessage = zbx_malloc(pmessage, sizeof(WCHAR) * require);			if (TRUE != EvtFormatMessage(provider, event, 0, 0, NULL, EvtFormatMessageEvent,					require, pmessage, &require))			{				zabbix_log(LOG_LEVEL_DEBUG, "formatting message failed: %s",						strerror_from_system(GetLastError()));				goto finish;			}			out_message = zbx_unicode_to_utf8(pmessage);		}	}finish:	if (NULL != provider)		EvtClose(provider);	zbx_free(pmessage);	zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, out_message);	/* should be freed*/	return out_message;}

static int	svc_OpenSCManager(SC_HANDLE *mgr){	if (NULL != (*mgr = OpenSCManager(NULL, NULL, GENERIC_WRITE)))		return SUCCEED;	zbx_error("ERROR: cannot connect to Service Manager: %s", strerror_from_system(GetLastError()));	return FAIL;}

int	NET_TCP_LISTEN(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result){	MIB_TCPTABLE	*pTcpTable = NULL;	DWORD		dwSize, dwRetVal;	int		i, ret = SYSINFO_RET_FAIL;	unsigned short	port;	char		tmp[8];	assert(result);	init_result(result);	if (num_param(param) > 1)		return SYSINFO_RET_FAIL;	if (0 != get_param(param, 1, tmp, sizeof(tmp)))		return SYSINFO_RET_FAIL;	if (SUCCEED != is_ushort(tmp, &port))		return SYSINFO_RET_FAIL;	dwSize = sizeof(MIB_TCPTABLE);	pTcpTable = (MIB_TCPTABLE *)zbx_malloc(pTcpTable, dwSize);	/* Make an initial call to GetTcpTable to	   get the necessary size into the dwSize variable */	if (ERROR_INSUFFICIENT_BUFFER == (dwRetVal = GetTcpTable(pTcpTable, &dwSize, TRUE)))		pTcpTable = (MIB_TCPTABLE *)zbx_realloc(pTcpTable, dwSize);	/* Make a second call to GetTcpTable to get	   the actual data we require */	if (NO_ERROR == (dwRetVal = GetTcpTable(pTcpTable, &dwSize, TRUE)))	{		for (i = 0; i < (int)pTcpTable->dwNumEntries; i++)		{			if (MIB_TCP_STATE_LISTEN == pTcpTable->table[i].dwState &&					port == ntohs((u_short)pTcpTable->table[i].dwLocalPort))			{				SET_UI64_RESULT(result, 1);				break;			}		}		ret = SYSINFO_RET_OK;	}	else	{		zabbix_log(LOG_LEVEL_DEBUG, "GetTcpTable failed with error: %s", strerror_from_system(dwRetVal));		goto clean;	}	if (!ISSET_UI64(result))		SET_UI64_RESULT(result, 0);clean:	zbx_free(pTcpTable);	return ret;}