/******************************************************************************
* *
* Function: zbx_read_from_pipe *
* *
* Purpose: read data from pipe *
* *
* Parameters: hRead - [IN] a handle to the device *
* buf - [IN/OUT] a pointer to the buffer *
* buf_size - [IN] buffer size *
* timeout_ms - [IN] timeout in milliseconds *
* *
* Return value: SUCCEED or TIMEOUT_ERROR if timeout reached *
* *
* Author: Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static int zbx_read_from_pipe(HANDLE hRead, char **buf, size_t buf_size, int timeout_ms)
{
DWORD in_buf_size, read_bytes;
struct _timeb start_time, current_time;
_ftime(&start_time);
while (0 != PeekNamedPipe(hRead, NULL, 0, NULL, &in_buf_size, NULL))
{
if (0 != in_buf_size)
{
if (0 != ReadFile(hRead, *buf, MIN(in_buf_size, buf_size), &read_bytes, NULL))
{
*buf += read_bytes;
if (0 == (buf_size -= read_bytes))
break;
}
continue;
}
_ftime(¤t_time);
if (zbx_get_timediff_ms(&start_time, ¤t_time) >= timeout_ms)
return TIMEOUT_ERROR;
Sleep(20);
}
return SUCCEED;
}
/******************************************************************************
* *
* Function: zbx_read_from_pipe *
* *
* Purpose: read data from pipe *
* *
* Parameters: hRead - [IN] a handle to the device *
* buf - [IN/OUT] a pointer to the buffer *
* buf_size - [IN] buffer size *
* offset - [IN/OUT] current position in the buffer *
* timeout_ms - [IN] timeout in milliseconds *
* *
* Return value: SUCCEED, FAIL or TIMEOUT_ERROR if timeout reached *
* *
* Author: Alexander Vladishev *
* *
******************************************************************************/
static int zbx_read_from_pipe(HANDLE hRead, char **buf, size_t *buf_size, size_t *offset, int timeout_ms)
{
DWORD in_buf_size, read_bytes;
struct _timeb start_time, current_time;
char tmp_buf[PIPE_BUFFER_SIZE];
_ftime(&start_time);
while (0 != PeekNamedPipe(hRead, NULL, 0, NULL, &in_buf_size, NULL))
{
_ftime(¤t_time);
if (zbx_get_timediff_ms(&start_time, ¤t_time) >= timeout_ms)
return TIMEOUT_ERROR;
if (MAX_EXECUTE_OUTPUT_LEN <= *offset + in_buf_size)
{
zabbix_log(LOG_LEVEL_ERR, "command output exceeded limit of %d KB",
MAX_EXECUTE_OUTPUT_LEN / ZBX_KIBIBYTE);
return FAIL;
}
if (0 != in_buf_size)
{
if (0 == ReadFile(hRead, tmp_buf, sizeof(tmp_buf) - 1, &read_bytes, NULL))
{
zabbix_log(LOG_LEVEL_ERR, "cannot read command output: %s",
strerror_from_system(GetLastError()));
return FAIL;
}
if (NULL != buf)
{
tmp_buf[read_bytes] = '\0';
zbx_strcpy_alloc(buf, buf_size, offset, tmp_buf);
}
in_buf_size = 0;
continue;
}
Sleep(20); /* milliseconds */
}
return SUCCEED;
}
/******************************************************************************
* *
* Function: zbx_waitpid *
* *
* Purpose: this function waits for process to change state *
* *
* Parameters: pid - [IN] child process PID *
* *
* Return value: on success, PID is returned. On error, *
* -1 is returned, and errno is set appropriately *
* *
* Author: Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
static int zbx_waitpid(pid_t pid)
{
const char *__function_name = "zbx_waitpid";
int rc, status;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
do
{
#ifdef WCONTINUED
static int wcontinued = WCONTINUED;
retry:
if (-1 == (rc = waitpid(pid, &status, WUNTRACED | wcontinued)))
{
if (EINVAL == errno && 0 != wcontinued)
{
wcontinued = 0;
goto retry;
}
#else
if (-1 == (rc = waitpid(pid, &status, WUNTRACED)))
{
#endif
zabbix_log(LOG_LEVEL_DEBUG, "%s() waitpid failure: %s", __function_name, strerror(errno));
goto exit;
}
if (WIFEXITED(status))
zabbix_log(LOG_LEVEL_DEBUG, "%s() exited, status:%d", __function_name, WEXITSTATUS(status));
else if (WIFSIGNALED(status))
zabbix_log(LOG_LEVEL_DEBUG, "%s() killed by signal %d", __function_name, WTERMSIG(status));
else if (WIFSTOPPED(status))
zabbix_log(LOG_LEVEL_DEBUG, "%s() stopped by signal %d", __function_name, WSTOPSIG(status));
#ifdef WIFCONTINUED
else if (WIFCONTINUED(status))
zabbix_log(LOG_LEVEL_DEBUG, "%s() continued", __function_name);
#endif
}
while (!WIFEXITED(status) && !WIFSIGNALED(status));
exit:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%d", __function_name, rc);
return rc;
}
#endif /* _WINDOWS */
/******************************************************************************
* *
* Function: zbx_execute *
* *
* Purpose: this function executes a script and returns result from stdout *
* *
* Parameters: command - [IN] command for execution *
* buffer - [OUT] buffer for output, if NULL - ignored *
* error - [OUT] error string if function fails *
* max_error_len - [IN] length of error buffer *
* *
* Return value: SUCCEED if processed successfully, FAIL - otherwise *
* *
* Author: Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
int zbx_execute(const char *command, char **buffer, char *error, size_t max_error_len, int timeout)
{
#ifdef _WINDOWS
STARTUPINFO si = {0};
PROCESS_INFORMATION pi = {0};
SECURITY_ATTRIBUTES sa;
HANDLE hWrite = NULL, hRead = NULL;
char *cmd = NULL;
LPTSTR wcmd = NULL;
struct _timeb start_time, current_time;
#else /* not _WINDOWS */
pid_t pid;
int fd;
#endif /* _WINDOWS */
char *p = NULL;
size_t buf_size = MAX_BUFFER_LEN;
int ret = SUCCEED;
assert(timeout);
if (NULL != buffer)
{
*buffer = p = zbx_realloc(*buffer, buf_size);
buf_size--; /* '\0' */
}
#ifdef _WINDOWS
/* set the bInheritHandle flag so pipe handles are inherited */
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.bInheritHandle = TRUE;
sa.lpSecurityDescriptor = NULL;
/* create a pipe for the child process's STDOUT */
if (0 == CreatePipe(&hRead, &hWrite, &sa, 0))
{
zbx_snprintf(error, max_error_len, "Unable to create pipe [%s]", strerror_from_system(GetLastError()));
ret = FAIL;
goto lbl_exit;
}
/* fill in process startup info structure */
memset(&si, 0, sizeof(STARTUPINFO));
si.cb = sizeof(STARTUPINFO);
si.dwFlags = STARTF_USESTDHANDLES;
si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
si.hStdOutput = hWrite;
si.hStdError = hWrite;
cmd = zbx_dsprintf(cmd, "cmd /C \"%s\"", command);
wcmd = zbx_utf8_to_unicode(cmd);
/* create new process */
if (0 == CreateProcess(NULL, wcmd, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi))
{
zbx_snprintf(error, max_error_len, "Unable to create process: '%s' [%s]",
cmd, strerror_from_system(GetLastError()));
ret = FAIL;
goto lbl_exit;
}
CloseHandle(hWrite);
hWrite = NULL;
_ftime(&start_time);
timeout *= 1000;
if (NULL != buffer)
{
if (SUCCEED == (ret = zbx_read_from_pipe(hRead, &p, buf_size, timeout)))
*p = '\0';
}
if (TIMEOUT_ERROR != ret)
{
_ftime(¤t_time);
if (0 < (timeout -= zbx_get_timediff_ms(&start_time, ¤t_time)))
{
if (WAIT_TIMEOUT == WaitForSingleObject(pi.hProcess, timeout))
ret = TIMEOUT_ERROR;
}
}
/* wait for child process to exit */
if (TIMEOUT_ERROR == ret)
{
zbx_strlcpy(error, "Timeout while executing a shell script", max_error_len);
ret = FAIL;
}
/* terminate child process */
TerminateProcess(pi.hProcess, 0);
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
CloseHandle(hRead);
hRead = NULL;
lbl_exit:
if (NULL != hWrite)
{
CloseHandle(hWrite);
hWrite = NULL;
}
if (NULL != hRead)
{
CloseHandle(hRead);
hRead = NULL;
}
zbx_free(cmd);
zbx_free(wcmd);
#else /* not _WINDOWS */
alarm(timeout);
if (-1 != (fd = zbx_popen(&pid, command)))
{
int rc = 0;
if (NULL != buffer)
{
while (0 < (rc = read(fd, p, buf_size)))
{
p += rc;
if (0 == (buf_size -= rc))
break;
}
*p = '\0';
}
close(fd);
if (-1 == rc)
{
if (EINTR == errno)
zbx_strlcpy(error, "Timeout while executing a shell script", max_error_len);
else
zbx_strlcpy(error, strerror(errno), max_error_len);
kill(pid, SIGTERM);
zbx_waitpid(pid);
ret = FAIL;
}
else
{
if (-1 == zbx_waitpid(pid))
{
if (EINTR == errno)
zbx_strlcpy(error, "Timeout while executing a shell script", max_error_len);
else
zbx_strlcpy(error, strerror(errno), max_error_len);
kill(pid, SIGTERM);
zbx_waitpid(pid);
ret = FAIL;
}
}
}
else
{
zbx_strlcpy(error, strerror(errno), max_error_len);
ret = FAIL;
}
alarm(0);
#endif /* _WINDOWS */
if (FAIL == ret && NULL != buffer)
zbx_free(*buffer);
return ret;
}
/******************************************************************************
* *
* Function: zbx_waitpid *
* *
* Purpose: this function waits for process to change state *
* *
* Parameters: pid - [IN] child process PID *
* *
* Return value: on success, PID is returned. On error, *
* -1 is returned, and errno is set appropriately *
* *
* Author: Alexander Vladishev *
* *
******************************************************************************/
static int zbx_waitpid(pid_t pid)
{
const char *__function_name = "zbx_waitpid";
int rc, status;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
do
{
#ifdef WCONTINUED
static int wcontinued = WCONTINUED;
retry:
if (-1 == (rc = waitpid(pid, &status, WUNTRACED | wcontinued)))
{
if (EINVAL == errno && 0 != wcontinued)
{
wcontinued = 0;
goto retry;
}
#else
if (-1 == (rc = waitpid(pid, &status, WUNTRACED)))
{
#endif
zabbix_log(LOG_LEVEL_DEBUG, "%s() waitpid failure: %s", __function_name, zbx_strerror(errno));
goto exit;
}
if (WIFEXITED(status))
zabbix_log(LOG_LEVEL_DEBUG, "%s() exited, status:%d", __function_name, WEXITSTATUS(status));
else if (WIFSIGNALED(status))
zabbix_log(LOG_LEVEL_DEBUG, "%s() killed by signal %d", __function_name, WTERMSIG(status));
else if (WIFSTOPPED(status))
zabbix_log(LOG_LEVEL_DEBUG, "%s() stopped by signal %d", __function_name, WSTOPSIG(status));
#ifdef WIFCONTINUED
else if (WIFCONTINUED(status))
zabbix_log(LOG_LEVEL_DEBUG, "%s() continued", __function_name);
#endif
}
while (!WIFEXITED(status) && !WIFSIGNALED(status));
exit:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%d", __function_name, rc);
return rc;
}
#endif /* _WINDOWS */
/******************************************************************************
* *
* Function: zbx_execute *
* *
* Purpose: this function executes a script and returns result from stdout *
* *
* Parameters: command - [IN] command for execution *
* buffer - [OUT] buffer for output, if NULL - ignored *
* error - [OUT] error string if function fails *
* max_error_len - [IN] length of error buffer *
* *
* Return value: SUCCEED if processed successfully, TIMEOUT_ERROR if *
* timeout occurred or FAIL otherwise *
* *
* Author: Alexander Vladishev *
* *
******************************************************************************/
int zbx_execute(const char *command, char **buffer, char *error, size_t max_error_len, int timeout)
{
size_t buf_size = PIPE_BUFFER_SIZE, offset = 0;
int ret = FAIL;
#ifdef _WINDOWS
STARTUPINFO si;
PROCESS_INFORMATION pi;
SECURITY_ATTRIBUTES sa;
HANDLE job = NULL, hWrite = NULL, hRead = NULL;
char *cmd = NULL;
wchar_t *wcmd = NULL;
struct _timeb start_time, current_time;
#else
pid_t pid;
int fd;
#endif
*error = '\0';
if (NULL != buffer)
{
*buffer = zbx_realloc(*buffer, buf_size);
**buffer = '\0';
}
#ifdef _WINDOWS
/* set the bInheritHandle flag so pipe handles are inherited */
sa.nLength = sizeof(SECURITY_ATTRIBUTES);
sa.bInheritHandle = TRUE;
sa.lpSecurityDescriptor = NULL;
/* create a pipe for the child process's STDOUT */
if (0 == CreatePipe(&hRead, &hWrite, &sa, 0))
{
zbx_snprintf(error, max_error_len, "unable to create a pipe: %s", strerror_from_system(GetLastError()));
goto close;
}
/* create a new job where the script will be executed */
if (0 == (job = CreateJobObject(&sa, NULL)))
{
zbx_snprintf(error, max_error_len, "unable to create a job: %s", strerror_from_system(GetLastError()));
goto close;
}
/* fill in process startup info structure */
memset(&si, 0, sizeof(STARTUPINFO));
si.cb = sizeof(STARTUPINFO);
si.dwFlags = STARTF_USESTDHANDLES;
si.hStdInput = GetStdHandle(STD_INPUT_HANDLE);
si.hStdOutput = hWrite;
si.hStdError = hWrite;
/* use cmd command to support scripts */
cmd = zbx_dsprintf(cmd, "cmd /C \"%s\"", command);
wcmd = zbx_utf8_to_unicode(cmd);
/* create the new process */
if (0 == CreateProcess(NULL, wcmd, NULL, NULL, TRUE, CREATE_SUSPENDED, NULL, NULL, &si, &pi))
{
zbx_snprintf(error, max_error_len, "unable to create process [%s]: %s",
cmd, strerror_from_system(GetLastError()));
goto close;
}
CloseHandle(hWrite);
hWrite = NULL;
/* assign the new process to the created job */
if (0 == AssignProcessToJobObject(job, pi.hProcess))
{
zbx_snprintf(error, max_error_len, "unable to assign process [%s] to a job: %s",
cmd, strerror_from_system(GetLastError()));
if (0 == TerminateProcess(pi.hProcess, 0))
{
zabbix_log(LOG_LEVEL_ERR, "failed to terminate [%s]: %s",
cmd, strerror_from_system(GetLastError()));
}
}
else if (-1 == ResumeThread(pi.hThread))
{
zbx_snprintf(error, max_error_len, "unable to assign process [%s] to a job: %s",
cmd, strerror_from_system(GetLastError()));
}
else
ret = SUCCEED;
if (FAIL == ret)
goto close;
_ftime(&start_time);
timeout *= 1000;
ret = zbx_read_from_pipe(hRead, buffer, &buf_size, &offset, timeout);
if (TIMEOUT_ERROR != ret)
{
_ftime(¤t_time);
if (0 < (timeout -= zbx_get_timediff_ms(&start_time, ¤t_time)) &&
WAIT_TIMEOUT == WaitForSingleObject(pi.hProcess, timeout))
{
ret = TIMEOUT_ERROR;
}
}
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
close:
if (NULL != job)
{
/* terminate the child process and it's childs */
if (0 == TerminateJobObject(job, 0))
zabbix_log(LOG_LEVEL_ERR, "failed to terminate job [%s]: %s", cmd, strerror_from_system(GetLastError()));
CloseHandle(job);
}
if (NULL != hWrite)
CloseHandle(hWrite);
if (NULL != hRead)
CloseHandle(hRead);
zbx_free(cmd);
zbx_free(wcmd);
#else /* not _WINDOWS */
alarm(timeout);
if (-1 != (fd = zbx_popen(&pid, command)))
{
int rc;
char tmp_buf[PIPE_BUFFER_SIZE];
while (0 < (rc = read(fd, tmp_buf, sizeof(tmp_buf) - 1)) && MAX_EXECUTE_OUTPUT_LEN > offset + rc)
{
if (NULL != buffer)
{
tmp_buf[rc] = '\0';
zbx_strcpy_alloc(buffer, &buf_size, &offset, tmp_buf);
}
}
close(fd);
if (-1 == rc || -1 == zbx_waitpid(pid))
{
if (EINTR == errno)
ret = TIMEOUT_ERROR;
else
zbx_snprintf(error, max_error_len, "zbx_waitpid() failed: %s", zbx_strerror(errno));
/* kill the whole process group, pid must be the leader */
if (-1 == kill(-pid, SIGTERM))
zabbix_log(LOG_LEVEL_ERR, "failed to kill [%s]: %s", command, zbx_strerror(errno));
zbx_waitpid(pid);
}
else if (MAX_EXECUTE_OUTPUT_LEN <= offset + rc)
{
zabbix_log(LOG_LEVEL_ERR, "command output exceeded limit of %d KB",
MAX_EXECUTE_OUTPUT_LEN / ZBX_KIBIBYTE);
}
else
ret = SUCCEED;
}
else
zbx_strlcpy(error, zbx_strerror(errno), max_error_len);
alarm(0);
#endif /* _WINDOWS */
if (TIMEOUT_ERROR == ret)
zbx_strlcpy(error, "Timeout while executing a shell script.", max_error_len);
else if ('\0' != *error)
zabbix_log(LOG_LEVEL_WARNING, "%s", error);
if (SUCCEED != ret && NULL != buffer)
zbx_free(*buffer);
return ret;
}
