/******************************************************************************
* *
* Function: main *
* *
* Purpose: executes proxy processes *
* *
* Author: Eugene Grigorjev *
* *
******************************************************************************/
int main(int argc, char **argv)
{
zbx_task_t task = ZBX_TASK_START;
char ch;
progname = get_program_name(argv[0]);
/* parse the command-line */
while ((char)EOF != (ch = (char)zbx_getopt_long(argc, argv, shortopts, longopts, NULL)))
{
switch (ch)
{
case 'c':
CONFIG_FILE = zbx_strdup(CONFIG_FILE, zbx_optarg);
break;
case 'R':
if (0 == strcmp(zbx_optarg, ZBX_CONFIG_CACHE_RELOAD))
task = ZBX_TASK_CONFIG_CACHE_RELOAD;
else
{
printf("invalid runtime control option: %s\n", zbx_optarg);
exit(EXIT_FAILURE);
}
break;
case 'h':
help();
exit(-1);
break;
case 'V':
version();
exit(-1);
break;
default:
usage();
exit(-1);
break;
}
}
if (NULL == CONFIG_FILE)
CONFIG_FILE = zbx_strdup(CONFIG_FILE, SYSCONFDIR "/zabbix_proxy.conf");
/* required for simple checks */
init_metrics();
zbx_load_config();
if (ZBX_TASK_CONFIG_CACHE_RELOAD == task)
exit(SUCCEED == zbx_sigusr_send(ZBX_TASK_CONFIG_CACHE_RELOAD) ? EXIT_SUCCESS : EXIT_FAILURE);
#ifdef HAVE_OPENIPMI
init_ipmi_handler();
#endif
return daemon_start(CONFIG_ALLOW_ROOT);
}
/******************************************************************************
* *
* Function: main *
* *
* Purpose: executes proxy processes *
* *
* Author: Eugene Grigorjev *
* *
******************************************************************************/
int main(int argc, char **argv)
{
ZBX_TASK_EX t = {ZBX_TASK_START};
char ch;
#if defined(PS_OVERWRITE_ARGV) || defined(PS_PSTAT_ARGV)
argv = setproctitle_save_env(argc, argv);
#endif
progname = get_program_name(argv[0]);
/* parse the command-line */
while ((char)EOF != (ch = (char)zbx_getopt_long(argc, argv, shortopts, longopts, NULL)))
{
switch (ch)
{
case 'c':
CONFIG_FILE = zbx_strdup(CONFIG_FILE, zbx_optarg);
break;
case 'R':
if (SUCCEED != parse_rtc_options(zbx_optarg, daemon_type, &t.flags))
exit(EXIT_FAILURE);
t.task = ZBX_TASK_RUNTIME_CONTROL;
break;
case 'h':
help();
exit(EXIT_SUCCESS);
break;
case 'V':
version();
exit(EXIT_SUCCESS);
break;
default:
usage();
exit(EXIT_FAILURE);
break;
}
}
if (NULL == CONFIG_FILE)
CONFIG_FILE = zbx_strdup(CONFIG_FILE, SYSCONFDIR "/zabbix_proxy.conf");
/* required for simple checks */
init_metrics();
zbx_load_config();
if (ZBX_TASK_RUNTIME_CONTROL == t.task)
exit(SUCCEED == zbx_sigusr_send(t.flags) ? EXIT_SUCCESS : EXIT_FAILURE);
#ifdef HAVE_OPENIPMI
init_ipmi_handler();
#endif
return daemon_start(CONFIG_ALLOW_ROOT, CONFIG_USER);
}
/******************************************************************************
* *
* Function: main *
* *
* Purpose: executes server processes *
* *
* Author: Eugene Grigorjev *
* *
******************************************************************************/
int main(int argc, char **argv)
{
struct tm *tm;
struct timeval tv;
int ms;
char ch = '\0';
progname = get_program_name(argv[0]);
/* parse the command-line */
while ((char) EOF != (ch = (char) zbx_getopt_long(argc, argv, shortopts, longopts, NULL))) {
switch (ch) {
case 'c':
CONFIG_FILE = zbx_strdup(CONFIG_FILE, zbx_optarg);
break;
case 'h':
help_jobarg();
exit(-1);
break;
case 'V':
version_jobarg();
exit(-1);
break;
default:
usage();
exit(-1);
break;
}
}
if (NULL == CONFIG_FILE)
CONFIG_FILE = zbx_strdup(CONFIG_FILE, SYSCONFDIR "/jobarg_server.conf");
zbx_load_config();
gettimeofday(&tv, NULL);
tm = localtime(&tv.tv_sec);
ms = (int)(tv.tv_usec / 1000);
zbx_snprintf(serverid, sizeof(serverid), "%04d%02d%02d%02d%02d%02d%03d",
1900 + tm->tm_year, 1 + tm->tm_mon, tm->tm_mday,
tm->tm_hour, tm->tm_min, tm->tm_sec, ms);
return daemon_start(CONFIG_ALLOW_ROOT);
}
int main(int argc, char **argv)
{
FILE *in;
char in_line[MAX_BUFFER_LEN], hostname[MAX_STRING_LEN], key[MAX_STRING_LEN],
key_value[MAX_BUFFER_LEN], clock[32];
int total_count = 0, succeed_count = 0, buffer_count = 0, read_more = 0, ret = SUCCEED;
double last_send = 0;
const char *p;
zbx_thread_args_t thread_args;
ZBX_THREAD_SENDVAL_ARGS sentdval_args;
progname = get_program_name(argv[0]);
parse_commandline(argc, argv);
zbx_load_config(CONFIG_FILE);
zabbix_open_log(LOG_TYPE_UNDEFINED, CONFIG_LOG_LEVEL, NULL);
if (NULL == ZABBIX_SERVER)
{
zabbix_log(LOG_LEVEL_WARNING, "'Server' parameter required");
goto exit;
}
if (0 == ZABBIX_SERVER_PORT)
ZABBIX_SERVER_PORT = ZBX_DEFAULT_SERVER_PORT;
if (MIN_ZABBIX_PORT > ZABBIX_SERVER_PORT)
{
zabbix_log(LOG_LEVEL_WARNING, "Incorrect port number [%d]. Allowed [%d:%d]",
(int)ZABBIX_SERVER_PORT, (int)MIN_ZABBIX_PORT, (int)MAX_ZABBIX_PORT);
goto exit;
}
thread_args.thread_num = 0;
thread_args.args = &sentdval_args;
sentdval_args.server = ZABBIX_SERVER;
sentdval_args.port = ZABBIX_SERVER_PORT;
zbx_json_init(&sentdval_args.json, ZBX_JSON_STAT_BUF_LEN);
zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_REQUEST, ZBX_PROTO_VALUE_SENDER_DATA, ZBX_JSON_TYPE_STRING);
zbx_json_addarray(&sentdval_args.json, ZBX_PROTO_TAG_DATA);
if (INPUT_FILE)
{
if (0 == strcmp(INPUT_FILE, "-"))
{
in = stdin;
if (1 == REAL_TIME)
{
/* set line buffering on stdin */
setvbuf(stdin, (char *)NULL, _IOLBF, 0);
}
}
else if (NULL == (in = fopen(INPUT_FILE, "r")) )
{
zabbix_log(LOG_LEVEL_WARNING, "cannot open [%s]: %s", INPUT_FILE, zbx_strerror(errno));
ret = FAIL;
goto exit;
}
while (NULL != fgets(in_line, sizeof(in_line), in) && SUCCEED == ret) /* <hostname> <key> [<timestamp>] <value> */
{
total_count++; /* also used as inputline */
zbx_rtrim(in_line, "\r\n");
p = in_line;
if ('\0' == *p || NULL == (p = get_string(p, hostname, sizeof(hostname))) || '\0' == *hostname)
{
zabbix_log(LOG_LEVEL_WARNING, "[line %d] 'Hostname' required", total_count);
continue;
}
if (0 == strcmp(hostname, "-"))
{
if (NULL == ZABBIX_HOSTNAME)
{
zabbix_log(LOG_LEVEL_WARNING, "[line %d] '-' encountered as 'Hostname', "
"but no default hostname was specified", total_count);
continue;
}
else
zbx_strlcpy(hostname, ZABBIX_HOSTNAME, sizeof(hostname));
}
if ('\0' == *p || NULL == (p = get_string(p, key, sizeof(key))) || '\0' == *key)
{
zabbix_log(LOG_LEVEL_WARNING, "[line %d] 'Key' required", total_count);
continue;
}
if (1 == WITH_TIMESTAMPS)
{
if ('\0' == *p || NULL == (p = get_string(p, clock, sizeof(clock))) || '\0' == *clock)
{
zabbix_log(LOG_LEVEL_WARNING, "[line %d] 'Timestamp' required", total_count);
continue;
}
}
if ('\0' != *p && '"' != *p)
zbx_strlcpy(key_value, p, sizeof(key_value));
else if ('\0' == *p || NULL == (p = get_string(p, key_value, sizeof(key_value))) || '\0' == *key_value)
{
zabbix_log(LOG_LEVEL_WARNING, "[line %d] 'Key value' required", total_count);
continue;
}
zbx_rtrim(key_value, "\r\n");
zbx_json_addobject(&sentdval_args.json, NULL);
zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_HOST, hostname, ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_KEY, key, ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_VALUE, key_value, ZBX_JSON_TYPE_STRING);
if (1 == WITH_TIMESTAMPS)
zbx_json_adduint64(&sentdval_args.json, ZBX_PROTO_TAG_CLOCK, atoi(clock));
zbx_json_close(&sentdval_args.json);
succeed_count++;
buffer_count++;
if (stdin == in && 1 == REAL_TIME)
{
/* if there is nothing on standard input after 1/5 seconds, we send what we have */
/* otherwise, we keep reading, but we should send data at least once per second */
struct timeval tv;
fd_set read_set;
tv.tv_sec = 0;
tv.tv_usec = 200000;
FD_ZERO(&read_set);
FD_SET(0, &read_set); /* stdin is file descriptor 0 */
if (-1 == (read_more = select(1, &read_set, NULL, NULL, &tv)))
{
zabbix_log(LOG_LEVEL_WARNING, "select() failed: %s", zbx_strerror(errno));
}
else if (1 <= read_more)
{
if (0 == last_send)
last_send = zbx_time();
else if (zbx_time() - last_send >= 1)
read_more = 0;
}
}
if (VALUES_MAX == buffer_count || (stdin == in && 1 == REAL_TIME && 0 >= read_more))
{
zbx_json_close(&sentdval_args.json);
if (1 == WITH_TIMESTAMPS)
zbx_json_adduint64(&sentdval_args.json, ZBX_PROTO_TAG_CLOCK, (int)time(NULL));
last_send = zbx_time();
ret = zbx_thread_wait(zbx_thread_start(send_value, &thread_args));
buffer_count = 0;
zbx_json_clean(&sentdval_args.json);
zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_REQUEST, ZBX_PROTO_VALUE_SENDER_DATA,
ZBX_JSON_TYPE_STRING);
zbx_json_addarray(&sentdval_args.json, ZBX_PROTO_TAG_DATA);
}
}
zbx_json_close(&sentdval_args.json);
if (0 != buffer_count)
{
if (1 == WITH_TIMESTAMPS)
zbx_json_adduint64(&sentdval_args.json, ZBX_PROTO_TAG_CLOCK, (int)time(NULL));
ret = zbx_thread_wait(zbx_thread_start(send_value, &thread_args));
}
if (in != stdin)
fclose(in);
}
else
{
total_count++;
do /* try block simulation */
{
if (NULL == ZABBIX_HOSTNAME)
{
zabbix_log(LOG_LEVEL_WARNING, "'Hostname' parameter required");
break;
}
if (NULL == ZABBIX_KEY)
{
zabbix_log(LOG_LEVEL_WARNING, "Key required");
break;
}
if (NULL == ZABBIX_KEY_VALUE)
{
zabbix_log(LOG_LEVEL_WARNING, "Key value required");
break;
}
zbx_json_addobject(&sentdval_args.json, NULL);
zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_HOST, ZABBIX_HOSTNAME, ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_KEY, ZABBIX_KEY, ZBX_JSON_TYPE_STRING);
zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_VALUE, ZABBIX_KEY_VALUE, ZBX_JSON_TYPE_STRING);
zbx_json_close(&sentdval_args.json);
succeed_count++;
ret = zbx_thread_wait(zbx_thread_start(send_value, &thread_args));
}
while(0); /* try block simulation */
}
zbx_json_free(&sentdval_args.json);
if (SUCCEED == ret)
printf("sent: %d; skipped: %d; total: %d\n", succeed_count, (total_count - succeed_count), total_count);
else
printf("Sending failed. Use option -vv for more detailed output.\n");
exit:
zabbix_close_log();
return ret;
}
int main(int argc, char **argv)
{
ZBX_TASK_EX t;
#ifdef _WINDOWS
int ret;
/* Provide, so our process handles errors instead of the system itself. */
/* Attention!!! */
/* The system does not display the critical-error-handler message box. */
/* Instead, the system sends the error to the calling process.*/
SetErrorMode(SEM_FAILCRITICALERRORS);
#endif
#if defined(PS_OVERWRITE_ARGV) || defined(PS_PSTAT_ARGV)
argv = setproctitle_save_env(argc, argv);
#endif
memset(&t, 0, sizeof(t));
t.task = ZBX_TASK_START;
progname = get_program_name(argv[0]);
parse_commandline(argc, argv, &t);
import_symbols();
/* this is needed to set default hostname in zbx_load_config() */
init_metrics();
switch (t.task)
{
case ZBX_TASK_SHOW_USAGE:
usage();
exit(EXIT_FAILURE);
break;
#ifdef _WINDOWS
case ZBX_TASK_INSTALL_SERVICE:
case ZBX_TASK_UNINSTALL_SERVICE:
case ZBX_TASK_START_SERVICE:
case ZBX_TASK_STOP_SERVICE:
zbx_load_config(ZBX_CFG_FILE_REQUIRED);
zbx_free_config();
if (t.flags & ZBX_TASK_FLAG_MULTIPLE_AGENTS)
{
zbx_snprintf(ZABBIX_SERVICE_NAME, sizeof(ZABBIX_SERVICE_NAME), "%s [%s]",
APPLICATION_NAME, CONFIG_HOSTNAME);
zbx_snprintf(ZABBIX_EVENT_SOURCE, sizeof(ZABBIX_EVENT_SOURCE), "%s [%s]",
APPLICATION_NAME, CONFIG_HOSTNAME);
}
ret = zbx_exec_service_task(argv[0], &t);
free_metrics();
exit(ret);
break;
#endif
case ZBX_TASK_TEST_METRIC:
case ZBX_TASK_PRINT_SUPPORTED:
zbx_load_config(ZBX_CFG_FILE_OPTIONAL);
#ifdef _WINDOWS
init_perf_collector(0);
load_perf_counters(CONFIG_PERF_COUNTERS);
#else
zbx_set_common_signal_handlers();
#endif
#ifndef _WINDOWS
if (FAIL == load_modules(CONFIG_LOAD_MODULE_PATH, CONFIG_LOAD_MODULE, CONFIG_TIMEOUT, 0))
{
zabbix_log(LOG_LEVEL_CRIT, "loading modules failed, exiting...");
exit(EXIT_FAILURE);
}
#endif
load_user_parameters(CONFIG_USER_PARAMETERS);
load_aliases(CONFIG_ALIASES);
zbx_free_config();
if (ZBX_TASK_TEST_METRIC == t.task)
test_parameter(TEST_METRIC);
else
test_parameters();
#ifdef _WINDOWS
free_perf_collector(); /* cpu_collector must be freed before perf_collector is freed */
#endif
#ifndef _WINDOWS
unload_modules();
#endif
free_metrics();
alias_list_free();
exit(SUCCEED);
break;
default:
zbx_load_config(ZBX_CFG_FILE_REQUIRED);
break;
}
START_MAIN_ZABBIX_ENTRY(CONFIG_ALLOW_ROOT);
exit(SUCCEED);
}
int main(int argc, char **argv)
{
char ch;
int task = ZBX_TASK_START;
char *TEST_METRIC = NULL;
zbx_sock_t s_in;
zbx_sock_t s_out;
int ret;
char **value, *command;
AGENT_RESULT result;
progname = get_program_name(argv[0]);
/* parse the command-line */
while ((char)EOF != (ch = (char)zbx_getopt_long(argc, argv, "c:hVpt:", longopts, NULL)))
{
switch (ch)
{
case 'c':
CONFIG_FILE = strdup(zbx_optarg);
break;
case 'h':
help();
exit(FAIL);
break;
case 'V':
version();
#ifdef _AIX
tl_version();
#endif
exit(FAIL);
break;
case 'p':
if (task == ZBX_TASK_START)
task = ZBX_TASK_PRINT_SUPPORTED;
break;
case 't':
if (task == ZBX_TASK_START)
{
task = ZBX_TASK_TEST_METRIC;
TEST_METRIC = strdup(zbx_optarg);
}
break;
default:
usage();
exit(FAIL);
break;
}
}
if (NULL == CONFIG_FILE)
CONFIG_FILE = DEFAULT_CONFIG_FILE;
/* load configuration */
if (ZBX_TASK_PRINT_SUPPORTED == task || ZBX_TASK_TEST_METRIC == task)
zbx_load_config(ZBX_CFG_FILE_OPTIONAL);
else
zbx_load_config(ZBX_CFG_FILE_REQUIRED);
/* metrics should be initialized before loading user parameters */
init_metrics();
/* user parameters */
load_user_parameters(CONFIG_USER_PARAMETERS);
/* aliases */
load_aliases(CONFIG_ALIASES);
zbx_free_config();
/* do not create debug files */
zabbix_open_log(LOG_TYPE_SYSLOG, LOG_LEVEL_EMPTY, NULL);
switch (task)
{
case ZBX_TASK_TEST_METRIC:
case ZBX_TASK_PRINT_SUPPORTED:
if (ZBX_TASK_TEST_METRIC == task)
test_parameter(TEST_METRIC);
else
test_parameters();
zabbix_close_log();
free_metrics();
alias_list_free();
exit(SUCCEED);
break;
default:
/* do nothing */
break;
}
signal(SIGINT, child_signal_handler);
signal(SIGTERM, child_signal_handler);
signal(SIGQUIT, child_signal_handler);
signal(SIGALRM, child_signal_handler);
alarm(CONFIG_TIMEOUT);
zbx_tcp_init(&s_in, (ZBX_SOCKET)fileno(stdin));
zbx_tcp_init(&s_out, (ZBX_SOCKET)fileno(stdout));
if (SUCCEED == (ret = zbx_tcp_check_security(&s_in, CONFIG_HOSTS_ALLOWED, 0)))
{
if (SUCCEED == (ret = zbx_tcp_recv(&s_in, &command)))
{
zbx_rtrim(command, "\r\n");
zabbix_log(LOG_LEVEL_DEBUG, "Requested [%s]", command);
init_result(&result);
process(command, 0, &result);
if (NULL == (value = GET_TEXT_RESULT(&result)))
value = GET_MSG_RESULT(&result);
if (NULL != value)
{
zabbix_log(LOG_LEVEL_DEBUG, "Sending back [%s]", *value);
ret = zbx_tcp_send(&s_out, *value);
}
free_result(&result);
}
if (FAIL == ret)
zabbix_log(LOG_LEVEL_DEBUG, "Processing error: %s", zbx_tcp_strerror());
}
fflush(stdout);
alarm(0);
zabbix_close_log();
free_metrics();
alias_list_free();
return SUCCEED;
}
/******************************************************************************
* *
* Function: main *
* *
* Purpose: executes server processes *
* *
* Author: Eugene Grigorjev *
* *
******************************************************************************/
int main(int argc, char **argv)
{
ZBX_TASK_EX t = {ZBX_TASK_START};
char ch, *error = NULL;
int opt_c = 0, opt_r = 0;
#if defined(PS_OVERWRITE_ARGV) || defined(PS_PSTAT_ARGV)
argv = setproctitle_save_env(argc, argv);
#endif
progname = get_program_name(argv[0]);
/* parse the command-line */
while ((char)EOF != (ch = (char)zbx_getopt_long(argc, argv, shortopts, longopts, NULL)))
{
switch (ch)
{
case 'c':
opt_c++;
if (NULL == CONFIG_FILE)
CONFIG_FILE = zbx_strdup(CONFIG_FILE, zbx_optarg);
break;
case 'R':
opt_r++;
if (SUCCEED != parse_rtc_options(zbx_optarg, program_type, &t.data))
exit(EXIT_FAILURE);
t.task = ZBX_TASK_RUNTIME_CONTROL;
break;
case 'h':
help();
exit(EXIT_SUCCESS);
break;
case 'V':
version();
exit(EXIT_SUCCESS);
break;
case 'f':
t.flags |= ZBX_TASK_FLAG_FOREGROUND;
break;
default:
usage();
exit(EXIT_FAILURE);
break;
}
}
/* every option may be specified only once */
if (1 < opt_c || 1 < opt_r)
{
if (1 < opt_c)
zbx_error("option \"-c\" or \"--config\" specified multiple times");
if (1 < opt_r)
zbx_error("option \"-R\" or \"--runtime-control\" specified multiple times");
exit(EXIT_FAILURE);
}
/* Parameters which are not option values are invalid. The check relies on zbx_getopt_internal() which */
/* always permutes command line arguments regardless of POSIXLY_CORRECT environment variable. */
if (argc > zbx_optind)
{
int i;
for (i = zbx_optind; i < argc; i++)
zbx_error("invalid parameter \"%s\"", argv[i]);
exit(EXIT_FAILURE);
}
if (NULL == CONFIG_FILE)
CONFIG_FILE = zbx_strdup(NULL, DEFAULT_CONFIG_FILE);
/* required for simple checks */
init_metrics();
zbx_load_config(&t);
if (ZBX_TASK_RUNTIME_CONTROL == t.task)
exit(SUCCEED == zbx_sigusr_send(t.data) ? EXIT_SUCCESS : EXIT_FAILURE);
zbx_initialize_events();
if (FAIL == zbx_ipc_service_init_env(CONFIG_SOCKET_PATH, &error))
{
zbx_error("Cannot initialize IPC services: %s", error);
zbx_free(error);
exit(EXIT_FAILURE);
}
return daemon_start(CONFIG_ALLOW_ROOT, CONFIG_USER, t.flags);
}
/******************************************************************************
* *
* Function: main *
* *
* Purpose: executes server processes *
* *
* Author: Eugene Grigorjev *
* *
******************************************************************************/
int main(int argc, char **argv)
{
zbx_task_t task = ZBX_TASK_START;
char ch = '\0';
int nodeid = 0;
#if defined(PS_OVERWRITE_ARGV) || defined(PS_PSTAT_ARGV)
argv = setproctitle_save_env(argc, argv);
#endif
progname = get_program_name(argv[0]);
/* parse the command-line */
while ((char)EOF != (ch = (char)zbx_getopt_long(argc, argv, shortopts, longopts, NULL)))
{
switch (ch)
{
case 'c':
CONFIG_FILE = zbx_strdup(CONFIG_FILE, zbx_optarg);
break;
case 'R':
if (0 == strcmp(zbx_optarg, ZBX_CONFIG_CACHE_RELOAD))
task = ZBX_TASK_CONFIG_CACHE_RELOAD;
else
{
printf("invalid runtime control option: %s\n", zbx_optarg);
exit(EXIT_FAILURE);
}
break;
case 'h':
help();
exit(-1);
break;
case 'n':
nodeid = (NULL == zbx_optarg ? 0 : atoi(zbx_optarg));
task = ZBX_TASK_CHANGE_NODEID;
break;
case 'V':
version();
exit(-1);
break;
default:
usage();
exit(-1);
break;
}
}
if (NULL == CONFIG_FILE)
CONFIG_FILE = zbx_strdup(CONFIG_FILE, SYSCONFDIR "/zabbix_server.conf");
/* required for simple checks */
init_metrics();
zbx_load_config();
if (ZBX_TASK_CONFIG_CACHE_RELOAD == task)
exit(SUCCEED == zbx_sigusr_send(ZBX_TASK_CONFIG_CACHE_RELOAD) ? EXIT_SUCCESS : EXIT_FAILURE);
#ifdef HAVE_OPENIPMI
init_ipmi_handler();
#endif
switch (task)
{
case ZBX_TASK_CHANGE_NODEID:
exit(SUCCEED == change_nodeid(nodeid) ? EXIT_SUCCESS : EXIT_FAILURE);
break;
default:
break;
}
return daemon_start(CONFIG_ALLOW_ROOT);
}
