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

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