/******************************************************************************
* *
* 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_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 */
}
static int php_sysvsem_semop(PHP_MUTEX *sem_ptr, int acquire)
{
struct sembuf sop;
assert(sem_ptr);
if (-1 == sem_ptr->semid)
return PHP_MUTEX_OK;
if (!acquire && sem_ptr->count == 0)
{
zbx_error("SysV semaphore (id %d) is not currently acquired.", sem_ptr->semid);
return PHP_MUTEX_ERROR;
}
sop.sem_num = SYSVSEM_SEM;
sop.sem_op = (acquire ? -1 : 1);
sop.sem_flg = SEM_UNDO;
while (-1 == semop(sem_ptr->semid, &sop, 1))
{
if (EINTR != errno)
{
zbx_error("php_sysvsem_semop: failed to %s semaphore (id %d): %s",
(acquire ? "acquire" : "release"), sem_ptr->semid, strerror(errno));
return PHP_MUTEX_ERROR;
}
}
sem_ptr->count -= (acquire ? -1 : 1);
return PHP_MUTEX_OK;
}
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;
}
/******************************************************************************
* *
* 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 */
}
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;
}
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 zbx_sigusr_send(int flags)
{
int ret = FAIL;
char error[256];
#ifdef HAVE_SIGQUEUE
pid_t pid;
if (SUCCEED == read_pid_file(CONFIG_PID_FILE, &pid, error, sizeof(error)))
{
union sigval s;
s.ZBX_SIVAL_INT = flags;
if (-1 != sigqueue(pid, SIGUSR1, s))
{
zbx_error("command sent successfully");
ret = SUCCEED;
}
else
{
zbx_snprintf(error, sizeof(error), "cannot send command to PID [%d]: %s",
(int)pid, zbx_strerror(errno));
}
}
#else
zbx_snprintf(error, sizeof(error), "operation is not supported on the given operating system");
#endif
if (SUCCEED != ret)
zbx_error("%s", error);
return ret;
}
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;
}
/******************************************************************************
* *
* 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
}
static int
parse_cfg_object(const char *cfg_file,struct cfg_line *cfg)
{
DIR *dir;
size_t cfg_len;
char *path;
struct stat sb;
struct dirent *d;
int result = SUCCEED, len;
if (stat(cfg_file, &sb) == -1) {
zbx_error("%s: %s\n", cfg_file, strerror(errno));
return FAIL;
}
if (!S_ISDIR(sb.st_mode))
return parse_cfg_file(cfg_file, cfg);
if ((dir = opendir(cfg_file)) == NULL) {
zbx_error("%s: %s\n", cfg_file, strerror(errno));
return FAIL;
}
while((d = readdir(dir)) != NULL) {
if (d->d_name[0] == '.') {
continue;
}
len = strlen (d->d_name);
if (len < 5 || strncmp (d->d_name + (len - 5), ".conf", 5))
continue;
cfg_len = strlen(cfg_file) + len + 2;
path = (char *) malloc(sizeof(char) * cfg_len);
if (path == NULL) {
result = FAIL;
break;
}
zbx_snprintf(path, cfg_len, "%s/%s", cfg_file, d->d_name);
if (d->d_type == DT_REG && parse_cfg_file(path, cfg) == FAIL) {
result = FAIL;
free(path);
break;
}
free(path);
}
if (closedir(dir) == -1) {
zbx_error("%s: %s\n", cfg_file, strerror(errno));
return FAIL;
}
return result;
}
int create_pid_file(const char *pidfile)
{
int fd;
struct stat buf;
struct flock fl;
fl.l_type = F_WRLCK;
fl.l_whence = SEEK_SET;
fl.l_start = 0;
fl.l_len = 0;
fl.l_pid = getpid();
/* check if pid file already exists */
if (0 == stat(pidfile, &buf))
{
if (-1 == (fd = open(pidfile, O_WRONLY | O_APPEND)))
{
zbx_error("cannot open PID file [%s]: %s", pidfile, zbx_strerror(errno));
return FAIL;
}
if (-1 == fcntl(fd, F_SETLK, &fl))
{
close(fd);
zbx_error("Is this process already running? Could not lock PID file [%s]: %s",
pidfile, zbx_strerror(errno));
return FAIL;
}
close(fd);
}
/* open pid file */
if (NULL == (fpid = fopen(pidfile, "w")))
{
zbx_error("cannot create PID file [%s]: %s", pidfile, zbx_strerror(errno));
return FAIL;
}
/* lock file */
if (-1 != (fdpid = fileno(fpid)))
{
fcntl(fdpid, F_SETLK, &fl);
fcntl(fdpid, F_SETFD, FD_CLOEXEC);
}
/* write pid to file */
fprintf(fpid, "%d", (int)getpid());
fflush(fpid);
return SUCCEED;
}
int php_sem_remove(PHP_MUTEX *sem_ptr)
{
union semun un;
struct semid_ds buf;
struct sembuf sop[2];
int opcnt = 1;
assert(sem_ptr);
if (-1 == sem_ptr->semid)
return PHP_MUTEX_OK;
/* Decrement the usage count. */
sop[0].sem_num = SYSVSEM_USAGE;
sop[0].sem_op = -1;
sop[0].sem_flg = SEM_UNDO;
if (sem_ptr->count)
{
sop[1].sem_num = SYSVSEM_SEM;
sop[1].sem_op = sem_ptr->count;
sop[1].sem_flg = SEM_UNDO;
opcnt++;
}
if (-1 == semop(sem_ptr->semid, sop, opcnt))
{
zbx_error("php_sem_remove: failed for (id %d): %s",
sem_ptr->semid, strerror(errno));
return PHP_MUTEX_ERROR;
}
un.buf = &buf;
if (-1 == semctl(sem_ptr->semid, 0, IPC_STAT, un))
{
zbx_error("php_sem_remove: SysV semaphore (id %d) does not (any longer) exist", sem_ptr->semid);
return PHP_MUTEX_ERROR;
}
if (-1 == semctl(sem_ptr->semid, 0, IPC_RMID, un))
{
/* zbx_error("php_sem_remove: failed for SysV sempphore (id %d): %s", sem_ptr->semid, strerror(errno)); */
return PHP_MUTEX_ERROR;
}
sem_ptr->semid = -1;
return PHP_MUTEX_OK;
}
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;
}
static int parse_cfg_object(const char *cfg_file, struct cfg_line *cfg, int level, int strict)
{
#ifdef _WINDOWS
return __parse_cfg_file(cfg_file, cfg, level, ZBX_CFG_FILE_REQUIRED, strict);
#else
DIR *dir;
struct stat sb;
struct dirent *d;
char *incl_file = NULL;
int result = SUCCEED;
if (-1 == stat(cfg_file, &sb))
{
zbx_error("%s: %s\n", cfg_file, zbx_strerror(errno));
return FAIL;
}
if (!S_ISDIR(sb.st_mode))
return __parse_cfg_file(cfg_file, cfg, level, ZBX_CFG_FILE_REQUIRED, strict);
if (NULL == (dir = opendir(cfg_file)))
{
zbx_error("%s: %s\n", cfg_file, zbx_strerror(errno));
return FAIL;
}
while (NULL != (d = readdir(dir)))
{
incl_file = zbx_dsprintf(incl_file, "%s/%s", cfg_file, d->d_name);
if (-1 == stat(incl_file, &sb) || !S_ISREG(sb.st_mode))
continue;
if (FAIL == __parse_cfg_file(incl_file, cfg, level, ZBX_CFG_FILE_REQUIRED, strict))
{
result = FAIL;
break;
}
}
zbx_free(incl_file);
if (-1 == closedir(dir))
{
zbx_error("%s: %s\n", cfg_file, zbx_strerror(errno));
return FAIL;
}
return result;
#endif
}
/******************************************************************************
* *
* Function: parse_rtc_options *
* *
* Purpose: parse runtime control options and create a runtime control *
* message *
* *
* Parameters: opt - [IN] the command line argument *
* daemon_type - [IN] the daemon type *
* message - [OUT] the message containing options for log *
* level change or cache reload *
* *
* Return value: SUCCEED - the message was created successfully *
* FAIL - an error occurred *
* *
******************************************************************************/
int parse_rtc_options(const char *opt, unsigned char daemon_type, int *message)
{
int scope, data, command;
if (0 == strncmp(opt, ZBX_LOG_LEVEL_INCREASE, ZBX_CONST_STRLEN(ZBX_LOG_LEVEL_INCREASE)))
{
command = ZBX_RTC_LOG_LEVEL_INCREASE;
if (SUCCEED != parse_log_level_options(opt, ZBX_CONST_STRLEN(ZBX_LOG_LEVEL_INCREASE), &scope, &data))
return FAIL;
}
else if (0 == strncmp(opt, ZBX_LOG_LEVEL_DECREASE, ZBX_CONST_STRLEN(ZBX_LOG_LEVEL_DECREASE)))
{
command = ZBX_RTC_LOG_LEVEL_DECREASE;
if (SUCCEED != parse_log_level_options(opt, ZBX_CONST_STRLEN(ZBX_LOG_LEVEL_DECREASE), &scope, &data))
return FAIL;
}
else if (ZBX_DAEMON_TYPE_AGENT != daemon_type && 0 == strcmp(opt, ZBX_CONFIG_CACHE_RELOAD))
{
command = ZBX_RTC_CONFIG_CACHE_RELOAD;
scope = 0;
data = 0;
}
else
{
zbx_error("invalid runtime control option: %s", opt);
return FAIL;
}
*message = ZBX_RTC_MAKE_MESSAGE(command, scope, data);
return SUCCEED;
}
int init_perf_collector(int multithreaded)
{
const char *__function_name = "init_perf_collector";
int ret = FAIL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (0 != multithreaded)
{
if (ZBX_MUTEX_ERROR == zbx_mutex_create_force(&perfstat_access, ZBX_MUTEX_PERFSTAT))
{
zbx_error("cannot create mutex for performance counters");
exit(EXIT_FAILURE);
}
}
if (ERROR_SUCCESS != zbx_PdhOpenQuery(__function_name, &ppsd.pdh_query))
goto out;
ppsd.nextcheck = time(NULL) + UNSUPPORTED_REFRESH_PERIOD;
ret = SUCCEED;
out:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
/******************************************************************************
* *
* 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;
}
/******************************************************************************
* *
* Function: init_collector_data *
* *
* Purpose: Allocate memory for collector *
* *
* Author: Eugene Grigorjev *
* *
* Comments: Unix version allocates memory as shared. *
* *
******************************************************************************/
void init_collector_data()
{
const char *__function_name = "init_collector_data";
int cpu_count;
size_t sz, sz_cpu;
#ifndef _WINDOWS
key_t shm_key;
#endif
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
cpu_count = zbx_get_cpu_num();
sz = sizeof(ZBX_COLLECTOR_DATA);
#ifdef _WINDOWS
sz_cpu = sizeof(PERF_COUNTER_DATA *) * (cpu_count + 1);
collector = zbx_malloc(collector, sz + sz_cpu);
memset(collector, 0, sz + sz_cpu);
collector->cpus.cpu_counter = (PERF_COUNTER_DATA **)(collector + 1);
collector->cpus.count = cpu_count;
#else
sz_cpu = sizeof(ZBX_SINGLE_CPU_STAT_DATA) * (cpu_count + 1);
if (-1 == (shm_key = zbx_ftok(CONFIG_FILE, ZBX_IPC_COLLECTOR_ID)))
{
zabbix_log(LOG_LEVEL_CRIT, "cannot create IPC key for collector");
exit(EXIT_FAILURE);
}
if (-1 == (shm_id = zbx_shmget(shm_key, sz + sz_cpu)))
{
zabbix_log(LOG_LEVEL_CRIT, "cannot allocate shared memory for collector");
exit(EXIT_FAILURE);
}
if ((void *)(-1) == (collector = shmat(shm_id, NULL, 0)))
{
zabbix_log(LOG_LEVEL_CRIT, "cannot attach shared memory for collector: %s", zbx_strerror(errno));
exit(EXIT_FAILURE);
}
collector->cpus.cpu = (ZBX_SINGLE_CPU_STAT_DATA *)(collector + 1);
collector->cpus.count = cpu_count;
collector->diskstat_shmid = NONEXISTENT_SHMID;
if (ZBX_MUTEX_ERROR == zbx_mutex_create_force(&diskstats_lock, ZBX_MUTEX_DISKSTATS))
{
zbx_error("cannot create mutex for disk statistics collector");
exit(EXIT_FAILURE);
}
#endif
#ifdef _AIX
memset(&collector->vmstat, 0, sizeof(collector->vmstat));
#endif
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
void zbx_create_sqlite3_mutex(const char *dbname)
{
if (ZBX_MUTEX_ERROR == php_sem_get(&sqlite_access, dbname))
{
zbx_error("cannot create mutex for SQLite3");
exit(FAIL);
}
}
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;
}
/******************************************************************************
* *
* Function: get_serveractive_hosts *
* *
* Purpose: parse string like IP<:port>,[IPv6]<:port> *
* *
******************************************************************************/
static void get_serveractive_hosts(char *active_hosts)
{
char *l = active_hosts, *r;
int rc = SUCCEED;
do
{
char *host = NULL;
unsigned short port;
if (NULL != (r = strchr(l, ',')))
*r = '\0';
if (SUCCEED != parse_serveractive_element(l, &host, &port, (unsigned short)ZBX_DEFAULT_SERVER_PORT))
goto fail;
rc = add_activechk_host(host, port);
zbx_free(host);
if (SUCCEED != rc)
goto fail;
if (NULL != r)
{
*r = ',';
l = r + 1;
}
}
while (NULL != r);
return;
fail:
if (SUCCEED != rc)
zbx_error("error parsing a \"ServerActive\" option: address \"%s\" specified more than once", l);
else
zbx_error("error parsing a \"ServerActive\" option: address \"%s\" is invalid", l);
if (NULL != r)
*r = ',';
exit(EXIT_FAILURE);
}
/******************************************************************************
* *
* Function: zbx_shmget *
* *
* Purpose: Create block of shared memory *
* *
* Parameters: key - IPC key *
* size - size *
* *
* Return value: If the function succeeds, then return SHM ID *
* -1 on an error *
* *
* Author: Alexei Vladishev *
* *
* Comments: *
* *
******************************************************************************/
int zbx_shmget(key_t key, size_t size)
{
int shm_id, ret = SUCCEED;
if (-1 != (shm_id = shmget(key, size, IPC_CREAT | IPC_EXCL | 0600)))
return shm_id;
/* if shared memory block exists, try to remove and re-create it */
if (EEXIST == errno)
{
/* get ID of existing memory */
if (-1 == (shm_id = shmget(key, 0 /* get reference */, 0600)))
{
zbx_error("cannot attach to existing shared memory: %s", zbx_strerror(errno));
ret = FAIL;
}
zabbix_log(LOG_LEVEL_DEBUG, "zbx_shmget() removing existing shm_id:%d", shm_id);
if (SUCCEED == ret && -1 == shmctl(shm_id, IPC_RMID, 0))
{
zbx_error("cannot remove existing shared memory: %s", zbx_strerror(errno));
ret = FAIL;
}
if (SUCCEED == ret && -1 == (shm_id = shmget(key, size, IPC_CREAT | IPC_EXCL | 0600)))
{
zabbix_log(LOG_LEVEL_CRIT, "cannot allocate shared memory of size " ZBX_FS_SIZE_T ": %s",
(zbx_fs_size_t)size, zbx_strerror(errno));
ret = FAIL;
}
}
else
{
zabbix_log(LOG_LEVEL_CRIT, "cannot allocate shared memory of size " ZBX_FS_SIZE_T ": %s",
(zbx_fs_size_t)size, zbx_strerror(errno));
ret = FAIL;
}
return (ret == SUCCEED) ? shm_id : -1;
}
/******************************************************************************
* *
* Function: zbx_ftok *
* *
* Purpose: Create IPC id *
* *
* Parameters: path - filename *
* id - user selectable ID *
* *
* Return value: If the function succeeds, then return unique ID *
* -1 on an error *
* *
* Author: Alexei Vladishev *
* *
* Comments: *
* *
******************************************************************************/
key_t zbx_ftok(char *path, int id)
{
key_t ipc_key;
if (-1 == (ipc_key = ftok(path, id)))
{
zbx_error("cannot create IPC key for path [%s] id [%c]: %s",
path, (char)id, zbx_strerror(errno));
}
return ipc_key;
}
/******************************************************************************
* *
* Function: zbx_thread_wait *
* *
* Purpose: Waits until the "thread" is in the signalled state *
* *
* Parameters: "thread" handle *
* *
* Return value: process or thread exit code *
* *
* Author: Eugene Grigorjev *
* *
******************************************************************************/
int zbx_thread_wait(ZBX_THREAD_HANDLE thread)
{
int status = 0; /* significant 8 bits of the status */
#ifdef _WINDOWS
if (WAIT_OBJECT_0 != WaitForSingleObject(thread, INFINITE))
{
zbx_error("Error on thread waiting. [%s]", strerror_from_system(GetLastError()));
return ZBX_THREAD_ERROR;
}
if (0 == GetExitCodeThread(thread, &status))
{
zbx_error("Error on thread exit code receiving. [%s]", strerror_from_system(GetLastError()));
return ZBX_THREAD_ERROR;
}
if (0 == CloseHandle(thread))
{
zbx_error("Error on thread closing. [%s]", strerror_from_system(GetLastError()));
return ZBX_THREAD_ERROR;
}
#else /* not _WINDOWS */
if (0 >= waitpid(thread, &status, 0))
{
zbx_error("Error on thread waiting.");
return ZBX_THREAD_ERROR;
}
status = WEXITSTATUS(status);
#endif /* _WINDOWS */
return status;
}
/******************************************************************************
* *
* Function: get_signal_handler *
* *
* Purpose: process signals *
* *
* Parameters: sig - signal ID *
* *
* Return value: *
* *
* Comments: *
* *
******************************************************************************/
static void get_signal_handler(int sig)
{
if (SIGPIPE == sig) /* this signal is raised when peer closes connection because of access restrictions */
return;
if (SIGALRM == sig)
zbx_error("Timeout while executing operation");
#if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL)
if (ZBX_TCP_SEC_UNENCRYPTED != configured_tls_connect_mode)
zbx_tls_free_on_signal();
#endif
exit(EXIT_FAILURE);
}
static int svc_RemoveEventSource()
{
wchar_t regkey[256];
wchar_t *wevent_source;
int ret = FAIL;
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 == RegDeleteKey(HKEY_LOCAL_MACHINE, regkey))
{
zbx_error("event source [%s] uninstalled successfully", ZABBIX_EVENT_SOURCE);
ret = SUCCEED;
}
else
{
zbx_error("unable to uninstall event source [%s]: %s",
ZABBIX_EVENT_SOURCE, strerror_from_system(GetLastError()));
}
return SUCCEED;
}
void service_start()
{
int ret;
static SERVICE_TABLE_ENTRY serviceTable[2];
serviceTable[0].lpServiceName = zbx_utf8_to_unicode(ZABBIX_SERVICE_NAME);
serviceTable[0].lpServiceProc = (LPSERVICE_MAIN_FUNCTION)ServiceEntry;
serviceTable[1].lpServiceName = NULL;
serviceTable[1].lpServiceProc = NULL;
ret = StartServiceCtrlDispatcher(serviceTable);
zbx_free(serviceTable[0].lpServiceName);
if (0 == ret)
{
if (ERROR_FAILED_SERVICE_CONTROLLER_CONNECT == GetLastError())
{
zbx_error("\n\n\t!!!ATTENTION!!! Zabbix Agent started as a console application. !!!ATTENTION!!!\n");
MAIN_ZABBIX_ENTRY();
}
else
zbx_error("StartServiceCtrlDispatcher() failed: %s", strerror_from_system(GetLastError()));
}
}
static int svc_OpenService(SC_HANDLE mgr, SC_HANDLE *service, DWORD desired_access)
{
wchar_t *wservice_name;
int ret = SUCCEED;
wservice_name = zbx_utf8_to_unicode(ZABBIX_SERVICE_NAME);
if (NULL == (*service = OpenService(mgr, wservice_name, desired_access)))
{
zbx_error("ERROR: cannot open service [%s]: %s",
ZABBIX_SERVICE_NAME, strerror_from_system(GetLastError()));
ret = FAIL;
}
zbx_free(wservice_name);
return ret;
}
/******************************************************************************
* *
* Function: zbx_mutex_destroy *
* *
* Purpose: Destroy the mutex *
* *
* Parameters: mutex - handle of mutex *
* *
* Return value: If the function succeeds, then return 1, 0 on an error *
* *
* Author: Eugene Grigorjev *
* *
******************************************************************************/
int zbx_mutex_destroy(ZBX_MUTEX *mutex)
{
#ifdef _WINDOWS
if (ZBX_MUTEX_NULL == *mutex)
return SUCCEED;
if (0 == CloseHandle(*mutex))
{
zbx_error("error on mutex destroying: %s", strerror_from_system(GetLastError()));
return FAIL;
}
#else
if (0 == --mutexes)
semctl(ZBX_SEM_LIST_ID, 0, IPC_RMID, 0);
#endif
*mutex = ZBX_MUTEX_NULL;
return SUCCEED;
}
