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));
#endif
out:
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;
}