/******************************************************************************
* *
* Function: *
* *
* Purpose: *
* *
* Parameters: *
* *
* Return value: *
* *
* Comments: *
* *
******************************************************************************/
static void parse_commandline(int argc, char **argv)
{
char ch;
/* parse the command-line */
CONFIG_FILE = NULL;
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(FAIL);
break;
case 'V':
version_jobarg();
exit(FAIL);
break;
default:
usage();
exit(FAIL);
break;
}
}
if (NULL == CONFIG_FILE) {
CONFIG_FILE = DEFAULT_CONFIG_FILE;
}
}
/******************************************************************************
* *
* 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);
}
/******************************************************************************
* *
* Function: main *
* *
* Purpose: executes server processes *
* *
* Parameters: *
* *
* Return value: *
* *
* Author: Eugene Grigorjev *
* *
* Comments: *
* *
******************************************************************************/
int main(int argc, char **argv)
{
char ch = '\0';
progname = argv[0];
/* Parse the command-line. */
while ((ch = (char)zbx_getopt_long(argc, argv, shortopts, longopts,NULL)) != (char)EOF)
switch (ch) {
case 'c':
CONFIG_FILE = strdup(zbx_optarg);
break;
case 'h':
help();
exit(-1);
break;
case 'V':
version();
exit(-1);
break;
default:
usage();
exit(-1);
break;
}
if(CONFIG_FILE == NULL)
{
CONFIG_FILE=strdup("/etc/zabbix/zabbix_proxy.conf");
}
/* Required for simple checks */
init_metrics();
init_config();
#ifdef HAVE_OPENIPMI
init_ipmi_handler();
#endif
return daemon_start(CONFIG_ALLOW_ROOT);
}
static void parse_commandline(int argc, char **argv)
{
char ch = '\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();
exit(-1);
break;
case 'V':
version();
exit(-1);
break;
case 'I':
CONFIG_SOURCE_IP = zbx_strdup(CONFIG_SOURCE_IP, zbx_optarg);
break;
case 'z':
ZABBIX_SERVER = zbx_strdup(ZABBIX_SERVER, zbx_optarg);
break;
case 'p':
ZABBIX_SERVER_PORT = (unsigned short)atoi(zbx_optarg);
break;
case 's':
ZABBIX_HOSTNAME = zbx_strdup(ZABBIX_HOSTNAME, zbx_optarg);
break;
case 'k':
ZABBIX_KEY = zbx_strdup(ZABBIX_KEY, zbx_optarg);
break;
case 'o':
ZABBIX_KEY_VALUE = zbx_strdup(ZABBIX_KEY_VALUE, zbx_optarg);
break;
case 'i':
INPUT_FILE = zbx_strdup(INPUT_FILE, zbx_optarg);
break;
case 'T':
WITH_TIMESTAMPS = 1;
break;
case 'r':
REAL_TIME = 1;
break;
case 'v':
if (LOG_LEVEL_WARNING == CONFIG_LOG_LEVEL)
CONFIG_LOG_LEVEL = LOG_LEVEL_DEBUG;
else
CONFIG_LOG_LEVEL = LOG_LEVEL_WARNING;
break;
default:
usage();
exit(FAIL);
break;
}
}
if (NULL == ZABBIX_SERVER && NULL == CONFIG_FILE)
{
usage();
exit(FAIL);
}
}
static void parse_commandline(int argc, char **argv, ZBX_TASK_EX *t)
{
char ch = '\0';
t->task = ZBX_TASK_START;
/* parse the command-line */
while ((char)EOF != (ch = (char)zbx_getopt_long(argc, argv, shortopts, longopts, NULL)))
{
switch (ch)
{
case 'c':
CONFIG_FILE = strdup(zbx_optarg);
break;
case 'h':
help();
exit(EXIT_FAILURE);
break;
case 'V':
version();
#ifdef _AIX
tl_version();
#endif
exit(EXIT_FAILURE);
break;
case 'p':
if (ZBX_TASK_START == t->task)
t->task = ZBX_TASK_PRINT_SUPPORTED;
break;
case 't':
if (ZBX_TASK_START == t->task)
{
t->task = ZBX_TASK_TEST_METRIC;
TEST_METRIC = strdup(zbx_optarg);
}
break;
#ifdef _WINDOWS
case 'i':
t->task = ZBX_TASK_INSTALL_SERVICE;
break;
case 'd':
t->task = ZBX_TASK_UNINSTALL_SERVICE;
break;
case 's':
t->task = ZBX_TASK_START_SERVICE;
break;
case 'x':
t->task = ZBX_TASK_STOP_SERVICE;
break;
case 'm':
t->flags = ZBX_TASK_FLAG_MULTIPLE_AGENTS;
break;
#endif
default:
t->task = ZBX_TASK_SHOW_USAGE;
break;
}
}
if (NULL == CONFIG_FILE)
CONFIG_FILE = DEFAULT_CONFIG_FILE;
}
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: main function *
* *
* Parameters: *
* *
* Return value: *
* *
* Comments: *
* *
******************************************************************************/
int main(int argc, char **argv)
{
int i, ret = SUCCEED;
char *host = NULL, *key = NULL, *source_ip = NULL, ch;
unsigned short opt_count[256] = {0}, port = ZBX_DEFAULT_AGENT_PORT;
#if defined(_WINDOWS)
char *error = NULL;
#endif
#if !defined(_WINDOWS) && (defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL))
if (SUCCEED != zbx_coredump_disable())
{
zbx_error("cannot disable core dump, exiting...");
exit(EXIT_FAILURE);
}
#endif
progname = get_program_name(argv[0]);
/* parse the command-line */
while ((char)EOF != (ch = (char)zbx_getopt_long(argc, argv, shortopts, longopts, NULL)))
{
opt_count[(unsigned char)ch]++;
switch (ch)
{
case 'k':
if (NULL == key)
key = zbx_strdup(NULL, zbx_optarg);
break;
case 'p':
port = (unsigned short)atoi(zbx_optarg);
break;
case 's':
if (NULL == host)
host = zbx_strdup(NULL, zbx_optarg);
break;
case 'I':
if (NULL == source_ip)
source_ip = zbx_strdup(NULL, zbx_optarg);
break;
case 'h':
help();
exit(EXIT_SUCCESS);
break;
case 'V':
version();
exit(EXIT_SUCCESS);
break;
#if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL)
case '1':
CONFIG_TLS_CONNECT = zbx_strdup(CONFIG_TLS_CONNECT, zbx_optarg);
break;
case '2':
CONFIG_TLS_CA_FILE = zbx_strdup(CONFIG_TLS_CA_FILE, zbx_optarg);
break;
case '3':
CONFIG_TLS_CRL_FILE = zbx_strdup(CONFIG_TLS_CRL_FILE, zbx_optarg);
break;
case '4':
CONFIG_TLS_SERVER_CERT_ISSUER = zbx_strdup(CONFIG_TLS_SERVER_CERT_ISSUER, zbx_optarg);
break;
case '5':
CONFIG_TLS_SERVER_CERT_SUBJECT = zbx_strdup(CONFIG_TLS_SERVER_CERT_SUBJECT, zbx_optarg);
break;
case '6':
CONFIG_TLS_CERT_FILE = zbx_strdup(CONFIG_TLS_CERT_FILE, zbx_optarg);
break;
case '7':
CONFIG_TLS_KEY_FILE = zbx_strdup(CONFIG_TLS_KEY_FILE, zbx_optarg);
break;
case '8':
CONFIG_TLS_PSK_IDENTITY = zbx_strdup(CONFIG_TLS_PSK_IDENTITY, zbx_optarg);
break;
case '9':
CONFIG_TLS_PSK_FILE = zbx_strdup(CONFIG_TLS_PSK_FILE, zbx_optarg);
break;
#else
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
zbx_error("TLS parameters cannot be used: 'zabbix_get' was compiled without TLS"
" support");
exit(EXIT_FAILURE);
break;
#endif
default:
usage();
exit(EXIT_FAILURE);
break;
}
}
#if defined(_WINDOWS)
if (SUCCEED != zbx_socket_start(&error))
{
zbx_error(error);
zbx_free(error);
exit(EXIT_FAILURE);
}
#endif
if (NULL == host || NULL == key)
{
usage();
ret = FAIL;
}
/* every option may be specified only once */
for (i = 0; NULL != longopts[i].name; i++)
{
ch = longopts[i].val;
if (1 < opt_count[(unsigned char)ch])
{
if (NULL == strchr(shortopts, ch))
zbx_error("option \"--%s\" specified multiple times", longopts[i].name);
else
zbx_error("option \"-%c\" or \"--%s\" specified multiple times", ch, longopts[i].name);
ret = FAIL;
}
}
if (FAIL == ret)
goto out;
/* 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)
{
for (i = zbx_optind; i < argc; i++)
zbx_error("invalid parameter \"%s\"", argv[i]);
ret = FAIL;
}
if (FAIL == ret)
{
printf("Try '%s --help' for more information.\n", progname);
goto out;
}
if (NULL != CONFIG_TLS_CONNECT || NULL != CONFIG_TLS_CA_FILE || NULL != CONFIG_TLS_CRL_FILE ||
NULL != CONFIG_TLS_SERVER_CERT_ISSUER || NULL != CONFIG_TLS_SERVER_CERT_SUBJECT ||
NULL != CONFIG_TLS_CERT_FILE || NULL != CONFIG_TLS_KEY_FILE ||
NULL != CONFIG_TLS_PSK_IDENTITY || NULL != CONFIG_TLS_PSK_FILE)
{
#if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL)
zbx_tls_validate_config();
if (ZBX_TCP_SEC_UNENCRYPTED != configured_tls_connect_mode)
{
#if defined(_WINDOWS)
zbx_tls_init_parent();
#endif
zbx_tls_init_child();
}
#endif
}
#if !defined(_WINDOWS)
signal(SIGINT, get_signal_handler);
signal(SIGTERM, get_signal_handler);
signal(SIGQUIT, get_signal_handler);
signal(SIGALRM, get_signal_handler);
signal(SIGPIPE, get_signal_handler);
#endif
ret = get_value(source_ip, host, port, key);
out:
zbx_free(host);
zbx_free(key);
zbx_free(source_ip);
#if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL)
if (ZBX_TCP_SEC_UNENCRYPTED != configured_tls_connect_mode)
{
zbx_tls_free();
#if defined(_WINDOWS)
zbx_tls_library_deinit();
#endif
}
#endif
#if defined(_WINDOWS)
while (0 == WSACleanup())
;
#endif
return SUCCEED == ret ? EXIT_SUCCESS : EXIT_FAILURE;
}
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;
memset(&result, 0, sizeof(AGENT_RESULT));
progname = get_program_name(argv[0]);
/* Parse the command-line. */
while ((ch = (char)zbx_getopt_long(argc, argv, "c:hVpt:", longopts, NULL)) != (char)EOF)
switch (ch)
{
case 'c':
CONFIG_FILE = strdup(zbx_optarg);
break;
case 'h':
help();
exit(-1);
break;
case 'V':
version();
#ifdef _AIX
tl_version();
#endif /* _AIX */
exit(-1);
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:
task = ZBX_TASK_SHOW_USAGE;
break;
}
if (CONFIG_FILE == NULL)
CONFIG_FILE = DEFAULT_CONFIG_FILE;
init_metrics();
if (ZBX_TASK_START == task)
{
load_config();
load_user_parameters(0);
}
/* Do not create debug files */
zabbix_open_log(LOG_TYPE_SYSLOG, LOG_LEVEL_EMPTY, NULL);
switch (task)
{
case ZBX_TASK_PRINT_SUPPORTED:
load_user_parameters(1);
test_parameters();
exit(-1);
break;
case ZBX_TASK_TEST_METRIC:
load_user_parameters(1);
test_parameter(TEST_METRIC, PROCESS_TEST);
exit(-1);
break;
case ZBX_TASK_SHOW_USAGE:
usage();
exit(-1);
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(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);
free_metrics();
alias_list_free();
alarm(0);
zabbix_close_log();
return SUCCEED;
}
/******************************************************************************
* *
* 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);
}
