int main(int argc, char* argv[])
{
try
{
initialise_program_options(argc,argv);
if (get_program_options()->helpMode())
std::cout << get_program_options();
else if (get_program_options()->versionMode())
std::cout << get_program_version() << "\n";
else
{
run(argc,argv);
TMPROF_PRINT_TO_FILE(get_program_name() + "_TMPROF.html",true);
}
}
catch(std::exception const& e)
{
try { save_crash_report(e.what()); } catch (...) {}
return -1;
}
catch(...)
{
try { save_crash_report("Unknown exception was thrown."); } catch (...) {}
return -2;
}
return 0;
}
/******************************************************************************
* *
* Function: *
* *
* Purpose: *
* *
* Parameters: *
* *
* Return value: *
* *
* Comments: *
* *
******************************************************************************/
int main(int argc, char **argv)
{
progname = get_program_name(argv[0]);
parse_commandline(argc, argv);
ja_load_config(CONFIG_FILE);
START_MAIN_ZABBIX_ENTRY(CONFIG_ALLOW_ROOT);
exit(SUCCEED);
}
/******************************************************************************
* *
* 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 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);
}
/* Generate an HTML table row for process PID. The return
* value is a pointer to a buffer that the caller must
* deallocate with free, or NULL if an error occurs. */
static char* format_process_info(pid_t pid)
{
int rval;
uid_t uid;
gid_t gid;
char* user_name;
char* group_name;
int rss;
char* program_name;
size_t result_length;
char* result;
/* Obtain the process's user and group IDs. */
rval = get_uid_gid(pid, &uid, &gid);
if (rval != 0) {
return NULL;
}
/* Obtain the process's RSS. */
rss = get_rss(pid);
if (rss == -1) {
return NULL;
}
/* Obtain the process's program name. */
program_name = get_program_name(pid);
if (program_name == NULL) {
return NULL;
}
/* Convert user and group IDs to corresponding names. */
user_name = get_user_name(uid);
group_name = get_group_name(gid);
/* Comput the length of the string we'll need to hold the
* result, and allocate memory to hold it. */
result_length = strlen(program_name) +
strlen(user_name) + strlen(group_name) + 128;
result = (char*) xmalloc(result_length);
/* Format the result. */
snprintf(result, result_length,
" <tr><td align=\"right\">%d</td>"
"<td><tt>%s</tt></td><td>%s</td>"
"<td>%s</td><td align=\"right\">%d</td></tr>\n",
(int)pid, program_name, user_name, group_name, rss);
/* Clean up. */
free(program_name);
free(user_name);
free(group_name);
/* All done. */
return result;
}
static void
print_version(void)
{
u_fprintf(u_stdout, "%S: Version 1.0, 3-21-2014 - copyright (C) Oly Project\n",
get_program_name());
u_fprintf(u_stdout, "\tLicensed according to the terms of the GNU general public\n");
u_fprintf(u_stdout, "\tlicense, version 2 or (at your option) any later version.\n");
u_fprintf(u_stdout, "\tThis program is provided in the hopes that it will be useful, but\n");
u_fprintf(u_stdout, "\tWITHOUT ANY WARRANTY, to the extent permitted by law.\n\n");
u_fprintf(u_stdout, "\tVisit %s for precise details on authorship.\n", PACKAGE_URL);
}
int main(int argc, char **argv)
{
int trigger_fd;
struct trigger_connect_params params;
int local_fd[3], remote_fd[3];
int i;
char *abs_exec_path;
if (argc < 4) {
fprintf(stderr,
"usage: %s target_vmname program_ident local_program [local program arguments]\n",
argv[0]);
exit(1);
}
trigger_fd = open(QREXEC_AGENT_TRIGGER_PATH, O_WRONLY);
if (trigger_fd < 0) {
perror("open QREXEC_AGENT_TRIGGER_PATH");
exit(1);
}
for (i = 0; i < 3; i++) {
local_fd[i] = connect_unix_socket();
read(local_fd[i], &remote_fd[i], sizeof(remote_fd[i]));
if (i != 2 || getenv("PASS_LOCAL_STDERR")) {
char *env;
asprintf(&env, "SAVED_FD_%d=%d", i, dup(i));
putenv(env);
dup2(local_fd[i], i);
close(local_fd[i]);
}
}
memset(¶ms, 0, sizeof(params));
strncpy(params.exec_index, argv[2], sizeof(params.exec_index));
strncpy(params.target_vmname, argv[1],
sizeof(params.target_vmname));
snprintf(params.process_fds.ident,
sizeof(params.process_fds.ident), "%d %d %d",
remote_fd[0], remote_fd[1], remote_fd[2]);
write(trigger_fd, ¶ms, sizeof(params));
close(trigger_fd);
abs_exec_path = strdup(argv[3]);
argv[3] = get_program_name(argv[3]);
execv(abs_exec_path, argv + 3);
perror("execv");
return 1;
}
bool
self_uninstall()
{
bool ret;
char pname[MAX_PATH];
struct installer inst;
if (!get_program_name(pname, MAX_PATH))
return false;
DEBUG(LOG_DEFAULT, "progname is %s\n", pname);
installer_init(&inst, pname);
ret = installer_uninstall(&inst);
installer_clear(&inst);
return ret;
}
/******************************************************************************
* *
* 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);
}
bool
self_install()
{
struct installer inst;
char home[MAX_PATH];
char pname[MAX_PATH];
DEBUG(LOG_DEFAULT, "installation init\n");
if (!get_program_name(pname, MAX_PATH))
return false;
DEBUG(LOG_DEFAULT, "progname is %s\n", pname);
installer_init(&inst, pname);
if (installer_get_target_path(&inst, home, sizeof(home)))
return false;
installer_install(&inst, home);
installer_clear(&inst);
return true;
}
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;
}
/*--------------------------------------------------------------------------------------------------------------------*/
int main (int argc, char **argv)
{
params_t *par = 0;
osr_err_code err = OSR_OK;
osr_expert *expert = 0;
int parse_result = 0;
par = params_create();
parse_result = parse_command_line (argc, argv, par);
if (parse_result)
{
params_destroy(par);
if (LEARN_USAGE_ERR_CODE == parse_result)
{
print_usage(get_program_name(argv[0]));
return 0;
}
printf ("Error: can't parse command line.\n");
return 1;
}
if (par->print_usage)
printf ("libosr version %s\n", osr_version_text() );
if (par->print_ver)
printf ("libosr version %s\n", osr_version_text() );
if (par->separate_html)
{
err = osr_separate_html (par->separate_html, par->html_separate_step);
params_destroy(par);
if (OSR_OK == err)
return 0;
else
return 1;
}
if ( OSR_OK == err )
{
expert = osr_expert_create();
if (0 == expert)
{
if (!par->no_print_err)
printf ("Error: OSR initializing error, %s.\n", osr_get_error_text(err));
err = OSR_INVALID_DATA;
}
if (par->ignore_filter)
{
osr_filter unlim;
osr_get_default_filter(&unlim);
unlim.min_symbols_in_word=1,
unlim.max_symbols_in_word=1000,
unlim.min_words_in_line=1,
unlim.min_lines_in_text=1,
unlim.min_text_percentage=1;
osr_set_filter(expert, &unlim);
}
}
if ( OSR_OK == err )
{
unsigned int last_frame_index = 0;
err = osr_process_file(expert, par->file_name, par->frame_index, &last_frame_index);
if ( OSR_OK != err )
if (!par->no_print_err)
{
if ( OSR_WRONG_FRAME_INDEX == err )
printf ("Error: OSR can't get frame %d of animated image."
" It must be [0;%d]. File %s.",
par->frame_index, last_frame_index, par->file_name);
else
printf ("Error: OSR can't process image (file %s), %s.\n",
par->file_name, osr_get_error_text(err));
}
}
if ( OSR_OK == err )
{
if (par->print_verdict)
{
char verdict = 0;
err = osr_get_verdict(expert, &verdict);
if (OSR_OK == err)
printf ("VERDICT: %s\n", verdict ? "text" : "not text");
else
if (!par->no_print_err)
printf ("Error: OSR can't get verdict (file %s), %s.\n",
par->file_name, osr_get_error_text(err));
}
}
if ( OSR_OK == err )
{
if (par->print_info)
{
size_t symbols_count = 0, words_count = 0, lines_count = 0, words_pixels_percentage = 0;
if (OSR_OK == err)
err = osr_get_symbols_count(expert, &symbols_count);
if (OSR_OK == err)
err = osr_get_words_count (expert, &words_count);
if (OSR_OK == err)
err = osr_get_lines_count (expert, &lines_count);
if (OSR_OK == err)
err = osr_get_words_pixels_percentage (expert, &words_pixels_percentage);
if (OSR_OK == err)
{
printf ("TEXT INFO:\n");
if (par->frame_index > 0)
printf (
"frame index = %d\n", par->frame_index);
printf ("good symbols count = %d\n"
"good words count = %d\n"
"good lines count = %d\n"
"good pixels percentage = %d%%\n",
symbols_count, words_count, lines_count, words_pixels_percentage);
}
else
if (!par->no_print_err)
printf ("Error: OSR can't get text properties (file %s), %s.\n",
par->file_name, osr_get_error_text(err));
}
}
if ( OSR_OK == err )
{
if (par->print_signature)
{
char gsg7[33];
err = osr_get_GSG7_signature(expert, gsg7);
if (OSR_OK == err)
{
if ( 0 != gsg7[0] )
printf ("GSG7 %.*s\n", 32, gsg7);
}
else
if (!par->no_print_err)
printf ("Error: OSR can't get GSG7 (file %s), %s.\n",
par->file_name, osr_get_error_text(err));
}
}
if ( OSR_OK == err )
{
if (par->dump_image || par->dump_lines || par->dump_symbols || par->dump_words)
{
char dump_name [500];
get_dump_name (dump_name, 500, par->file_name);
err = osr_get_dump (expert, dump_name, par->dump_image, par->dump_symbols, par->dump_lines, par->dump_words);
if (OSR_OK != err)
if (!par->no_print_err)
printf ("Error: OSR can't get dump of file %s, %s.\n",
par->file_name, osr_get_error_text(err));
}
}
if (par->html_report)
{
char dump_name [500];
get_dump_name (dump_name, 500, par->file_name);
err = osr_get_html_report(expert, par->file_name, dump_name, par->html_report, err, par->frame_index);
if (OSR_OK != err)
if (!par->no_print_err)
printf ("Error: OSR can't get html-report (image file %s), %s.\n",
par->file_name, osr_get_error_text(err));
}
if (OSR_OK == err )
if (par->win_group)
{
char gsg7[33];
err = osr_get_GSG7_signature(expert, gsg7);
if (OSR_OK == err)
{
if (0 == gsg7[0])
strncpy (gsg7, "_not_text", 32);
printf ("@ if not exist %s mkdir %s\n"
"@ move \"%s\" %s\n",
gsg7, gsg7, par->file_name, gsg7);
}
else
if (!par->no_print_err)
printf ("Error: OSR can't get GSG7 (file %s), %s.\n",
par->file_name, osr_get_error_text(err));
}
if (par)
params_destroy(par);
if (expert)
osr_expert_destroy(expert);
if (OSR_OK == err)
return 0;
return 1;
}
static void save_crash_report(std::string const& crash_message)
{
std::cout << "ERROR: " << crash_message << "\n";
boost::filesystem::ofstream ofile( get_program_name() + "_CRASH.txt", std::ios_base::app );
ofile << crash_message << "\n";
}
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);
}
static void
usage(void)
{
u_fprintf(u_stdout, "%S: [OPTIONS]\n",
get_program_name());
}
stack_trace_::stack_trace_() {
#if defined(SYSTEM_UNIX) && !defined(SYSTEM_MAC)
std::string programName = get_program_name();
std::string pid = get_pid();
_stack_trace.push_back(std::string("\t[trace] back trace for ") + programName + " (" + pid + "):");
// create a pipe to read gdb's output
int pipefds[2];
int res = pipe(pipefds);
if (res < 0)
return;
// create a pipe to be used as a barrier
int barrierfds[2];
res = pipe(barrierfds);
if (res < 0)
return;
// fork
int childPid = fork();
// child:
if (!childPid) {
LOG_ALL(tracelog) << "[child] waiting for parent process to allow attaching" << std::endl;
// close writing end of barrier pipe
close(barrierfds[1]);
// wait until parent closes barrier pipe
char buf[1];
while (read(barrierfds[0], buf, sizeof(buf)) > 0)
LOG_ALL(tracelog) << "[child] " << buf[0] << std::endl;
LOG_ALL(tracelog) << "[child] parent process closed barrier pipe, preparing gdb invocation" << std::endl;
// close barrier pipe
close(barrierfds[0]);
// close reading end of output pipe
close(pipefds[0]);
// redirect stdout and stderr to output pipe
dup2(pipefds[1], 1);
dup2(pipefds[1], 2);
// close writing end of pipe (_we_ don't need it any longer)
close(pipefds[1]);
// start gdb
execlp("gdb", "gdb", "--batch", "-n", "-ex", "bt full", programName.c_str(), pid.c_str(), NULL);
// parent:
} else {
LOG_ALL(tracelog) << "[parent] allowing child to attach" << std::endl;
// allow our child process to attach
prctl(PR_SET_PTRACER, childPid, 0, 0, 0);
LOG_ALL(tracelog) << "[parent] closing barrier pipe" << std::endl;
// close barrier pipe to let child proceed
close(barrierfds[0]);
close(barrierfds[1]);
LOG_ALL(tracelog) << "[parent] barrier pipe closed" << std::endl;
// close the write end of pipe
close(pipefds[1]);
// capture child's output
std::string output;
// read the whole output of gdb
char buf[1];
size_t n;
while ((n = read(pipefds[0], buf, sizeof(buf))))
output += std::string(buf, n);
LOG_ALL(tracelog) << "[parent] end of pipe; I read: " << std::endl << output << std::endl;
// split it at newline characters
std::stringstream oss(output);
std::string line;
// ignore every line until '#0 ...'
while (std::getline(oss, line) && (line.size() < 2 || (line[0] != '#' && line[1] != '0')));
// copy remaining lines to stack trace
do {
if (line.size() > 0 && line[0] != '\n')
_stack_trace.push_back(std::string("\t[trace] ") + line);
} while (std::getline(oss, line));
// wait for the child to finish
waitpid(childPid, NULL, 0);
}
#endif // SYSTEM_UNIX && !SYSTEM_MAC
return;
}
/******************************************************************************
* *
* 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);
}
#include <netviewer/program_info.hpp>
#include <netviewer/program_options.hpp>
#include <utility/timeprof.hpp>
#include <utility/log.hpp>
#include <boost/filesystem.hpp>
#include <boost/filesystem/fstream.hpp>
#include <stdexcept>
#include <iostream>
LOG_INITIALISE(get_program_name() + "_LOG",true,true,warning)
extern void run(int argc, char* argv[]);
static void save_crash_report(std::string const& crash_message)
{
std::cout << "ERROR: " << crash_message << "\n";
boost::filesystem::ofstream ofile( get_program_name() + "_CRASH.txt", std::ios_base::app );
ofile << crash_message << "\n";
}
int main(int argc, char* argv[])
{
try
{
initialise_program_options(argc,argv);
if (get_program_options()->helpMode())
std::cout << get_program_options();
else if (get_program_options()->versionMode())
std::cout << get_program_version() << "\n";
else
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;
}
/******************************************************************************
* *
* 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);
}
