/****************************************************************************** * * * Function: terminate_signal_handler * * * * Purpose: handle terminate signals: SIGQUIT, SIGINT, SIGTERM * * * ******************************************************************************/ static void terminate_signal_handler(int sig, siginfo_t *siginfo, void *context) { SIG_CHECK_PARAMS(sig, siginfo, context); if (!SIG_PARENT_PROCESS) { zabbix_log(sig_parent_pid == SIG_CHECKED_FIELD(siginfo, si_pid) ? LOG_LEVEL_DEBUG : LOG_LEVEL_WARNING, "Got signal [signal:%d(%s),sender_pid:%d,sender_uid:%d," "reason:%d]. Exiting ...", sig, get_signal_name(sig), SIG_CHECKED_FIELD(siginfo, si_pid), SIG_CHECKED_FIELD(siginfo, si_uid), SIG_CHECKED_FIELD(siginfo, si_code)); exit(FAIL); } else { if (0 == sig_exiting) { sig_exiting = 1; zabbix_log(sig_parent_pid == SIG_CHECKED_FIELD(siginfo, si_pid) ? LOG_LEVEL_DEBUG : LOG_LEVEL_WARNING, "Got signal [signal:%d(%s),sender_pid:%d,sender_uid:%d," "reason:%d]. Exiting ...", sig, get_signal_name(sig), SIG_CHECKED_FIELD(siginfo, si_pid), SIG_CHECKED_FIELD(siginfo, si_uid), SIG_CHECKED_FIELD(siginfo, si_code)); zbx_on_exit(); } } }
static void parent_signal_handler(int sig) { switch (sig) { case SIGINT: case SIGTERM: zabbix_log(LOG_LEVEL_INFORMATION, "Got signal. Exiting ..."); zbx_on_exit(); break; } }
/****************************************************************************** * * * Function: child_signal_handler * * * * Purpose: handle child signal SIGCHLD * * * ******************************************************************************/ static void child_signal_handler(int sig, siginfo_t *siginfo, void *context) { SIG_CHECK_PARAMS(sig, siginfo, context); if (!SIG_PARENT_PROCESS) exit(FAIL); if (0 == sig_exiting) { sig_exiting = 1; zabbix_log(LOG_LEVEL_CRIT, "One child process died (PID:%d,exitcode/signal:%d). Exiting ...", SIG_CHECKED_FIELD(siginfo, si_pid), SIG_CHECKED_FIELD(siginfo, si_status)); zbx_on_exit(); } }
static void parent_signal_handler(int sig, siginfo_t *siginfo, void *context) { switch (sig) { case SIGCHLD: if (!PARENT_PROCESS) exit(FAIL); if (0 == exiting) { zabbix_log(LOG_LEVEL_CRIT, "One child process died (PID:%d,exitcode/signal:%d). Exiting ...", CHECKED_FIELD(siginfo, si_pid), CHECKED_FIELD(siginfo, si_status)); exiting = 1; zbx_on_exit(); } break; default: child_signal_handler(sig, siginfo, context); } }
/****************************************************************************** * * * Function: * * * * Purpose: * * * * Parameters: * * * * Return value: * * * * Comments: * * * ******************************************************************************/ int MAIN_ZABBIX_ENTRY() { zbx_thread_args_t *thread_args; int thread_num = 0; int status; if (NULL == CONFIG_LOG_FILE || '\0' == *CONFIG_LOG_FILE) { zabbix_open_log(LOG_TYPE_SYSLOG, CONFIG_LOG_LEVEL, NULL); } else { zabbix_open_log(LOG_TYPE_FILE, CONFIG_LOG_LEVEL, CONFIG_LOG_FILE); } zabbix_log(LOG_LEVEL_INFORMATION, "Starting Job Arranger monitor. Job Arranger %s (revision %s).", JOBARG_VERSION, JOBARG_REVISION); /* --- START THREADS --- */ threads_num = 1; threads = (ZBX_THREAD_HANDLE *) zbx_calloc(threads, threads_num, sizeof(ZBX_THREAD_HANDLE)); /* start the executive thread */ thread_args = (zbx_thread_args_t *) zbx_malloc(NULL, sizeof(zbx_thread_args_t)); thread_args->thread_num = thread_num; thread_args->args = NULL; threads[thread_num++] = zbx_thread_start(monitor_thread, thread_args); while (-1 == wait(&status)) { if (EINTR != errno) { zabbix_log(LOG_LEVEL_ERR, "failed to wait on child processes: %s", zbx_strerror(errno)); break; } } THIS_SHOULD_NEVER_HAPPEN; zbx_on_exit(); return SUCCEED; }
int MAIN_ZABBIX_ENTRY() { zbx_thread_args_t *thread_args; zbx_sock_t listen_sock; int i, thread_num = 0; #ifdef _WINDOWS DWORD res; #endif if (NULL == CONFIG_LOG_FILE || '\0' == *CONFIG_LOG_FILE) zabbix_open_log(LOG_TYPE_SYSLOG, CONFIG_LOG_LEVEL, NULL); else zabbix_open_log(LOG_TYPE_FILE, CONFIG_LOG_LEVEL, CONFIG_LOG_FILE); zabbix_log(LOG_LEVEL_INFORMATION, "Starting Zabbix Agent [%s]. Zabbix %s (revision %s).", CONFIG_HOSTNAME, ZABBIX_VERSION, ZABBIX_REVISION); zabbix_log(LOG_LEVEL_INFORMATION, "using configuration file: %s", CONFIG_FILE); #ifndef _WINDOWS if (FAIL == load_modules(CONFIG_LOAD_MODULE_PATH, CONFIG_LOAD_MODULE, CONFIG_TIMEOUT, 1)) { zabbix_log(LOG_LEVEL_CRIT, "loading modules failed, exiting..."); exit(EXIT_FAILURE); } #endif if (0 != CONFIG_PASSIVE_FORKS) { if (FAIL == zbx_tcp_listen(&listen_sock, CONFIG_LISTEN_IP, (unsigned short)CONFIG_LISTEN_PORT)) { zabbix_log(LOG_LEVEL_CRIT, "listener failed: %s", zbx_tcp_strerror()); exit(1); } } init_collector_data(); #ifdef _WINDOWS init_perf_collector(1); load_perf_counters(CONFIG_PERF_COUNTERS); #endif load_user_parameters(CONFIG_USER_PARAMETERS); load_aliases(CONFIG_ALIASES); zbx_free_config(); /* --- START THREADS ---*/ /* allocate memory for a collector, all listeners and an active check */ threads_num = 1 + CONFIG_PASSIVE_FORKS + CONFIG_ACTIVE_FORKS; threads = zbx_calloc(threads, threads_num, sizeof(ZBX_THREAD_HANDLE)); /* start the collector thread */ thread_args = (zbx_thread_args_t *)zbx_malloc(NULL, sizeof(zbx_thread_args_t)); thread_args->thread_num = thread_num; thread_args->thread_num2 = 1; thread_args->args = NULL; threads[thread_num++] = zbx_thread_start(collector_thread, thread_args); /* start listeners */ for (i = 0; i < CONFIG_PASSIVE_FORKS; i++) { thread_args = (zbx_thread_args_t *)zbx_malloc(NULL, sizeof(zbx_thread_args_t)); thread_args->thread_num = thread_num; thread_args->thread_num2 = i + 1; thread_args->args = &listen_sock; threads[thread_num++] = zbx_thread_start(listener_thread, thread_args); } /* start active check */ for (i = 0; i < CONFIG_ACTIVE_FORKS; i++) { thread_args = (zbx_thread_args_t *)zbx_malloc(NULL, sizeof(zbx_thread_args_t)); thread_args->thread_num = thread_num; thread_args->thread_num2 = i + 1; thread_args->args = &CONFIG_ACTIVE_ARGS[i]; threads[thread_num++] = zbx_thread_start(active_checks_thread, thread_args); } #ifdef _WINDOWS set_parent_signal_handler(); /* must be called after all threads are created */ /* wait for an exiting thread */ res = WaitForMultipleObjectsEx(threads_num, threads, FALSE, INFINITE, FALSE); if (ZBX_IS_RUNNING()) { /* Zabbix agent service should either be stopped by the user in ServiceCtrlHandler() or */ /* crash. If some thread has terminated normally, it means something is terribly wrong. */ zabbix_log(LOG_LEVEL_CRIT, "One thread has terminated unexpectedly (code:%lu). Exiting ...", res); THIS_SHOULD_NEVER_HAPPEN; /* notify other threads and allow them to terminate */ ZBX_DO_EXIT(); zbx_sleep(1); } else { /* wait for the service worker thread to terminate us */ zbx_sleep(3); THIS_SHOULD_NEVER_HAPPEN; } #else while (-1 == wait(&i)) /* wait for any child to exit */ { if (EINTR != errno) { zabbix_log(LOG_LEVEL_ERR, "failed to wait on child processes: %s", zbx_strerror(errno)); break; } } /* all exiting child processes should be caught by signal handlers */ THIS_SHOULD_NEVER_HAPPEN; #endif zbx_on_exit(); return SUCCEED; }
int MAIN_ZABBIX_ENTRY() { pid_t pid; zbx_sock_t listen_sock; int i, proxy_num = 0, proxy_count = 0; if (NULL == CONFIG_LOG_FILE || '\0' == *CONFIG_LOG_FILE) zabbix_open_log(LOG_TYPE_SYSLOG, CONFIG_LOG_LEVEL, NULL); else zabbix_open_log(LOG_TYPE_FILE, CONFIG_LOG_LEVEL, CONFIG_LOG_FILE); #ifdef HAVE_SNMP # define SNMP_FEATURE_STATUS "YES" #else # define SNMP_FEATURE_STATUS " NO" #endif #ifdef HAVE_OPENIPMI # define IPMI_FEATURE_STATUS "YES" #else # define IPMI_FEATURE_STATUS " NO" #endif #ifdef HAVE_LIBCURL # define LIBCURL_FEATURE_STATUS "YES" #else # define LIBCURL_FEATURE_STATUS " NO" #endif #ifdef HAVE_ODBC # define ODBC_FEATURE_STATUS "YES" #else # define ODBC_FEATURE_STATUS " NO" #endif #ifdef HAVE_SSH2 # define SSH2_FEATURE_STATUS "YES" #else # define SSH2_FEATURE_STATUS " NO" #endif #ifdef HAVE_IPV6 # define IPV6_FEATURE_STATUS "YES" #else # define IPV6_FEATURE_STATUS " NO" #endif zabbix_log(LOG_LEVEL_INFORMATION, "Starting Zabbix Proxy (%s) [%s]. Zabbix %s (revision %s).", ZBX_PROXYMODE_PASSIVE == CONFIG_PROXYMODE ? "passive" : "active", CONFIG_HOSTNAME, ZABBIX_VERSION, ZABBIX_REVISION); zabbix_log(LOG_LEVEL_INFORMATION, "**** Enabled features ****"); zabbix_log(LOG_LEVEL_INFORMATION, "SNMP monitoring: " SNMP_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "IPMI monitoring: " IPMI_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "WEB monitoring: " LIBCURL_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "ODBC: " ODBC_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "SSH2 support: " SSH2_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "IPv6 support: " IPV6_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "**************************"); DBinit(); init_database_cache(); init_configuration_cache(); init_selfmon_collector(); DBconnect(ZBX_DB_CONNECT_NORMAL); DCsync_configuration(); DBclose(); threads_num = CONFIG_CONFSYNCER_FORKS + CONFIG_HEARTBEAT_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_TRAPPER_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_HTTPPOLLER_FORKS + CONFIG_DISCOVERER_FORKS + CONFIG_HISTSYNCER_FORKS + CONFIG_IPMIPOLLER_FORKS + CONFIG_JAVAPOLLER_FORKS + CONFIG_SNMPTRAPPER_FORKS + CONFIG_SELFMON_FORKS; threads = zbx_calloc(threads, threads_num, sizeof(pid_t)); if (0 < CONFIG_TRAPPER_FORKS) { if (FAIL == zbx_tcp_listen(&listen_sock, CONFIG_LISTEN_IP, (unsigned short)CONFIG_LISTEN_PORT)) { zabbix_log(LOG_LEVEL_CRIT, "listener failed: %s", zbx_tcp_strerror()); exit(1); } } for (i = 0; i < threads_num; i++) { if (0 == (pid = zbx_child_fork())) { proxy_num = i + 1; /* child processes are numbered starting from 1 */ break; } else threads[i] = pid; } if (0 == proxy_num) { zabbix_log(LOG_LEVEL_INFORMATION, "proxy #0 started [main process]"); while (-1 == wait(&i)) /* wait for any child to exit */ { if (EINTR != errno) { zabbix_log(LOG_LEVEL_ERR, "failed to wait on child processes: %s", zbx_strerror(errno)); break; } } /* all exiting child processes should be caught by signal handlers */ THIS_SHOULD_NEVER_HAPPEN; zbx_on_exit(); } else if (proxy_num <= (proxy_count += CONFIG_CONFSYNCER_FORKS)) { /* !!! configuration syncer must be proxy #1 - child_signal_handler() uses threads[0] !!! */ INIT_PROXY(ZBX_PROCESS_TYPE_CONFSYNCER, CONFIG_CONFSYNCER_FORKS); main_proxyconfig_loop(); } else if (proxy_num <= (proxy_count += CONFIG_HEARTBEAT_FORKS)) { INIT_PROXY(ZBX_PROCESS_TYPE_HEARTBEAT, CONFIG_HEARTBEAT_FORKS); main_heart_loop(); } else if (proxy_num <= (proxy_count += CONFIG_DATASENDER_FORKS)) { INIT_PROXY(ZBX_PROCESS_TYPE_DATASENDER, CONFIG_DATASENDER_FORKS); main_datasender_loop(); } else if (proxy_num <= (proxy_count += CONFIG_POLLER_FORKS)) { #ifdef HAVE_SNMP init_snmp("zabbix_proxy"); #endif INIT_PROXY(ZBX_PROCESS_TYPE_POLLER, CONFIG_POLLER_FORKS); main_poller_loop(ZBX_POLLER_TYPE_NORMAL); } else if (proxy_num <= (proxy_count += CONFIG_UNREACHABLE_POLLER_FORKS)) { #ifdef HAVE_SNMP init_snmp("zabbix_proxy"); #endif INIT_PROXY(ZBX_PROCESS_TYPE_UNREACHABLE, CONFIG_UNREACHABLE_POLLER_FORKS); main_poller_loop(ZBX_POLLER_TYPE_UNREACHABLE); } else if (proxy_num <= (proxy_count += CONFIG_TRAPPER_FORKS)) { INIT_PROXY(ZBX_PROCESS_TYPE_TRAPPER, CONFIG_TRAPPER_FORKS); main_trapper_loop(&listen_sock); } else if (proxy_num <= (proxy_count += CONFIG_PINGER_FORKS)) { INIT_PROXY(ZBX_PROCESS_TYPE_PINGER, CONFIG_PINGER_FORKS); main_pinger_loop(); } else if (proxy_num <= (proxy_count += CONFIG_HOUSEKEEPER_FORKS)) { INIT_PROXY(ZBX_PROCESS_TYPE_HOUSEKEEPER, CONFIG_HOUSEKEEPER_FORKS); main_housekeeper_loop(); } else if (proxy_num <= (proxy_count += CONFIG_HTTPPOLLER_FORKS)) { INIT_PROXY(ZBX_PROCESS_TYPE_HTTPPOLLER, CONFIG_HTTPPOLLER_FORKS); main_httppoller_loop(); } else if (proxy_num <= (proxy_count += CONFIG_DISCOVERER_FORKS)) { #ifdef HAVE_SNMP init_snmp("zabbix_proxy"); #endif INIT_PROXY(ZBX_PROCESS_TYPE_DISCOVERER, CONFIG_DISCOVERER_FORKS); main_discoverer_loop(); } else if (proxy_num <= (proxy_count += CONFIG_HISTSYNCER_FORKS)) { INIT_PROXY(ZBX_PROCESS_TYPE_HISTSYNCER, CONFIG_HISTSYNCER_FORKS); main_dbsyncer_loop(); } else if (proxy_num <= (proxy_count += CONFIG_IPMIPOLLER_FORKS)) { INIT_PROXY(ZBX_PROCESS_TYPE_IPMIPOLLER, CONFIG_IPMIPOLLER_FORKS); main_poller_loop(ZBX_POLLER_TYPE_IPMI); } else if (proxy_num <= (proxy_count += CONFIG_JAVAPOLLER_FORKS)) { INIT_PROXY(ZBX_PROCESS_TYPE_JAVAPOLLER, CONFIG_JAVAPOLLER_FORKS); main_poller_loop(ZBX_POLLER_TYPE_JAVA); } else if (proxy_num <= (proxy_count += CONFIG_SNMPTRAPPER_FORKS)) { INIT_PROXY(ZBX_PROCESS_TYPE_SNMPTRAPPER, CONFIG_SNMPTRAPPER_FORKS); main_snmptrapper_loop(); } else if (proxy_num <= (proxy_count += CONFIG_SELFMON_FORKS)) { INIT_PROXY(ZBX_PROCESS_TYPE_SELFMON, CONFIG_SELFMON_FORKS); main_selfmon_loop(); } return SUCCEED; }
/****************************************************************************** * * * Function: * * * * Purpose: * * * * Parameters: * * * * Return value: * * * * Comments: * * * ******************************************************************************/ int MAIN_ZABBIX_ENTRY() { pid_t pid; zbx_sock_t listen_sock; int i, server_num = 0, server_count = 0; if (NULL == CONFIG_LOG_FILE || '\0' == *CONFIG_LOG_FILE) zabbix_open_log(LOG_TYPE_SYSLOG, CONFIG_LOG_LEVEL, NULL); else zabbix_open_log(LOG_TYPE_FILE, CONFIG_LOG_LEVEL, CONFIG_LOG_FILE); ja_log("JASERVER000001", 0, NULL, 0, JOBARG_VERSION, JOBARG_REVISION); ja_init_selfmon_collector(); threads_num = CONFIG_JARUN_FORKS + CONFIG_JATRAPPER_FORKS + CONFIG_JAJOB_FORKS + CONFIG_JAJOBNET_FORKS + CONFIG_JALOADER_FORKS + CONFIG_JABOOT_FORKS + CONFIG_JAMSGSND_FORKS + CONFIG_JASELFMON_FORKS; threads = zbx_calloc(threads, threads_num, sizeof(pid_t)); if (FAIL == zbx_tcp_listen(&listen_sock, CONFIG_LISTEN_IP, (unsigned short) CONFIG_LISTEN_PORT)) { ja_log("JASERVER100001", 0, NULL, 0, zbx_tcp_strerror()); exit(1); } for (i = 0; i < threads_num; i++) { if (0 == (pid = zbx_child_fork())) { server_num = i + 1; break; } else threads[i] = pid; } if (0 == server_num) { ja_log("JASERVER000003", 0, NULL, 0); while (-1 == wait(&i)) { if (EINTR != errno) { ja_log("JASERVER200001", 0, NULL, 0, zbx_strerror(errno)); break; } } THIS_SHOULD_NEVER_HAPPEN; zbx_on_exit(); } else if (server_num <= (server_count += CONFIG_JAJOBNET_FORKS)) { INIT_SERVER(JA_PROCESS_TYPE_JAJOBNET, CONFIG_JAJOBNET_FORKS); main_jajobnet_loop(); } else if (server_num <= (server_count += CONFIG_JARUN_FORKS)) { INIT_SERVER(JA_PROCESS_TYPE_JARUN, CONFIG_JARUN_FORKS); main_jarun_loop(); } else if (server_num <= (server_count += CONFIG_JAJOB_FORKS)) { INIT_SERVER(JA_PROCESS_TYPE_JAJOB, CONFIG_JAJOB_FORKS); main_jajob_loop(); } else if (server_num <= (server_count += CONFIG_JATRAPPER_FORKS)) { INIT_SERVER(JA_PROCESS_TYPE_JATRAPPER, CONFIG_JATRAPPER_FORKS); main_jatrapper_loop(&listen_sock); } else if (server_num <= (server_count += CONFIG_JALOADER_FORKS)) { INIT_SERVER(JA_PROCESS_TYPE_JALOADER, CONFIG_JALOADER_FORKS); main_jaloader_loop(); } else if (server_num <= (server_count += CONFIG_JABOOT_FORKS)) { INIT_SERVER(JA_PROCESS_TYPE_JABOOT, CONFIG_JABOOT_FORKS); main_jaboot_loop(); } else if (server_num <= (server_count += CONFIG_JAMSGSND_FORKS)) { INIT_SERVER(JA_PROCESS_TYPE_JASNDMSG, CONFIG_JAMSGSND_FORKS); main_jamsgsnd_loop(); } else if (server_num <= (server_count += CONFIG_JASELFMON_FORKS)) { INIT_SERVER(JA_PROCESS_TYPE_SELFMON, CONFIG_JASELFMON_FORKS); main_jaselfmon_loop(); } return 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; 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(EXIT_SUCCESS); break; case 'V': version(); #ifdef _AIX tl_version(); #endif exit(EXIT_SUCCESS); 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(EXIT_FAILURE); 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); /* set defaults */ if (NULL == CONFIG_LOAD_MODULE_PATH) CONFIG_LOAD_MODULE_PATH = zbx_strdup(CONFIG_LOAD_MODULE_PATH, LIBDIR "/modules"); zbx_set_common_signal_handlers(); /* metrics should be initialized before loading user parameters */ init_metrics(); /* loadable modules */ 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); } /* 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(); zbx_on_exit(); break; default: /* do nothing */ break; } 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))) { zbx_rtrim(s_in.buffer, "\r\n"); zabbix_log(LOG_LEVEL_DEBUG, "requested [%s]", s_in.buffer); init_result(&result); process(s_in.buffer, 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); zbx_on_exit(); return SUCCEED; }
int MAIN_ZABBIX_ENTRY(int flags) { zbx_socket_t listen_sock; char *error = NULL; int i, db_type; if (0 != (flags & ZBX_TASK_FLAG_FOREGROUND)) { printf("Starting Zabbix Server. Zabbix %s (revision %s).\nPress Ctrl+C to exit.\n\n", ZABBIX_VERSION, ZABBIX_REVISION); } if (SUCCEED != zbx_locks_create(&error)) { zbx_error("cannot create locks: %s", error); zbx_free(error); exit(EXIT_FAILURE); } if (SUCCEED != zabbix_open_log(CONFIG_LOG_TYPE, CONFIG_LOG_LEVEL, CONFIG_LOG_FILE, &error)) { zbx_error("cannot open log: %s", error); zbx_free(error); exit(EXIT_FAILURE); } #ifdef HAVE_NETSNMP # define SNMP_FEATURE_STATUS "YES" #else # define SNMP_FEATURE_STATUS " NO" #endif #ifdef HAVE_OPENIPMI # define IPMI_FEATURE_STATUS "YES" #else # define IPMI_FEATURE_STATUS " NO" #endif #ifdef HAVE_LIBCURL # define LIBCURL_FEATURE_STATUS "YES" #else # define LIBCURL_FEATURE_STATUS " NO" #endif #if defined(HAVE_LIBCURL) && defined(HAVE_LIBXML2) # define VMWARE_FEATURE_STATUS "YES" #else # define VMWARE_FEATURE_STATUS " NO" #endif #ifdef HAVE_SMTP_AUTHENTICATION # define SMTP_AUTH_FEATURE_STATUS "YES" #else # define SMTP_AUTH_FEATURE_STATUS " NO" #endif #ifdef HAVE_JABBER # define JABBER_FEATURE_STATUS "YES" #else # define JABBER_FEATURE_STATUS " NO" #endif #ifdef HAVE_UNIXODBC # define ODBC_FEATURE_STATUS "YES" #else # define ODBC_FEATURE_STATUS " NO" #endif #ifdef HAVE_SSH2 # define SSH2_FEATURE_STATUS "YES" #else # define SSH2_FEATURE_STATUS " NO" #endif #ifdef HAVE_IPV6 # define IPV6_FEATURE_STATUS "YES" #else # define IPV6_FEATURE_STATUS " NO" #endif #if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL) # define TLS_FEATURE_STATUS "YES" #else # define TLS_FEATURE_STATUS " NO" #endif zabbix_log(LOG_LEVEL_INFORMATION, "Starting Zabbix Server. Zabbix %s (revision %s).", ZABBIX_VERSION, ZABBIX_REVISION); zabbix_log(LOG_LEVEL_INFORMATION, "****** Enabled features ******"); zabbix_log(LOG_LEVEL_INFORMATION, "SNMP monitoring: " SNMP_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "IPMI monitoring: " IPMI_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "Web monitoring: " LIBCURL_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "VMware monitoring: " VMWARE_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "SMTP authentication: " SMTP_AUTH_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "Jabber notifications: " JABBER_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "Ez Texting notifications: " LIBCURL_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "ODBC: " ODBC_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "SSH2 support: " SSH2_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "IPv6 support: " IPV6_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "TLS support: " TLS_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "******************************"); zabbix_log(LOG_LEVEL_INFORMATION, "using configuration file: %s", CONFIG_FILE); #if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL) if (SUCCEED != zbx_coredump_disable()) { zabbix_log(LOG_LEVEL_CRIT, "cannot disable core dump, exiting..."); exit(EXIT_FAILURE); } #endif if (FAIL == zbx_load_modules(CONFIG_LOAD_MODULE_PATH, CONFIG_LOAD_MODULE, CONFIG_TIMEOUT, 1)) { zabbix_log(LOG_LEVEL_CRIT, "loading modules failed, exiting..."); exit(EXIT_FAILURE); } zbx_free_config(); if (SUCCEED != init_database_cache(&error)) { zabbix_log(LOG_LEVEL_CRIT, "cannot initialize database cache: %s", error); zbx_free(error); exit(EXIT_FAILURE); } if (SUCCEED != init_configuration_cache(&error)) { zabbix_log(LOG_LEVEL_CRIT, "cannot initialize configuration cache: %s", error); zbx_free(error); exit(EXIT_FAILURE); } if (SUCCEED != init_selfmon_collector(&error)) { zabbix_log(LOG_LEVEL_CRIT, "cannot initialize self-monitoring: %s", error); zbx_free(error); exit(EXIT_FAILURE); } if (0 != CONFIG_VMWARE_FORKS && SUCCEED != zbx_vmware_init(&error)) { zabbix_log(LOG_LEVEL_CRIT, "cannot initialize VMware cache: %s", error); zbx_free(error); exit(EXIT_FAILURE); } if (SUCCEED != zbx_vc_init(&error)) { zabbix_log(LOG_LEVEL_CRIT, "cannot initialize history value cache: %s", error); zbx_free(error); exit(EXIT_FAILURE); } if (SUCCEED != zbx_create_itservices_lock(&error)) { zabbix_log(LOG_LEVEL_CRIT, "cannot create IT services lock: %s", error); zbx_free(error); exit(EXIT_FAILURE); } if (SUCCEED != zbx_history_init(&error)) { zabbix_log(LOG_LEVEL_CRIT, "cannot initialize history storage: %s", error); zbx_free(error); exit(EXIT_FAILURE); } if (FAIL == zbx_export_init(&error)) { zabbix_log(LOG_LEVEL_CRIT, "cannot initialize export: %s", error); zbx_free(error); exit(EXIT_FAILURE); } if (ZBX_DB_UNKNOWN == (db_type = zbx_db_get_database_type())) { zabbix_log(LOG_LEVEL_CRIT, "cannot use database \"%s\": database is not a Zabbix database", CONFIG_DBNAME); exit(EXIT_FAILURE); } else if (ZBX_DB_SERVER != db_type) { zabbix_log(LOG_LEVEL_CRIT, "cannot use database \"%s\": its \"users\" table is empty (is this the" " Zabbix proxy database?)", CONFIG_DBNAME); exit(EXIT_FAILURE); } if (SUCCEED != DBcheck_version()) exit(EXIT_FAILURE); DBconnect(ZBX_DB_CONNECT_NORMAL); /* make initial configuration sync before worker processes are forked */ DCsync_configuration(ZBX_DBSYNC_INIT); if (SUCCEED != zbx_check_postinit_tasks(&error)) { zabbix_log(LOG_LEVEL_CRIT, "cannot complete post initialization tasks: %s", error); zbx_free(error); exit(EXIT_FAILURE); } /* update maintenance states */ zbx_dc_update_maintenances(); DBclose(); zbx_vc_enable(); threads_num = CONFIG_CONFSYNCER_FORKS + CONFIG_POLLER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_TRAPPER_FORKS + CONFIG_PINGER_FORKS + CONFIG_ALERTER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_TIMER_FORKS + CONFIG_HTTPPOLLER_FORKS + CONFIG_DISCOVERER_FORKS + CONFIG_HISTSYNCER_FORKS + CONFIG_ESCALATOR_FORKS + CONFIG_IPMIPOLLER_FORKS + CONFIG_JAVAPOLLER_FORKS + CONFIG_SNMPTRAPPER_FORKS + CONFIG_PROXYPOLLER_FORKS + CONFIG_SELFMON_FORKS + CONFIG_VMWARE_FORKS + CONFIG_TASKMANAGER_FORKS + CONFIG_IPMIMANAGER_FORKS + CONFIG_ALERTMANAGER_FORKS + CONFIG_PREPROCMAN_FORKS + CONFIG_PREPROCESSOR_FORKS + CONFIG_LLDMANAGER_FORKS + CONFIG_LLDWORKER_FORKS; threads = (pid_t *)zbx_calloc(threads, threads_num, sizeof(pid_t)); if (0 != CONFIG_TRAPPER_FORKS) { if (FAIL == zbx_tcp_listen(&listen_sock, CONFIG_LISTEN_IP, (unsigned short)CONFIG_LISTEN_PORT)) { zabbix_log(LOG_LEVEL_CRIT, "listener failed: %s", zbx_socket_strerror()); exit(EXIT_FAILURE); } } #if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL) zbx_tls_init_parent(); #endif zabbix_log(LOG_LEVEL_INFORMATION, "server #0 started [main process]"); for (i = 0; i < threads_num; i++) { zbx_thread_args_t thread_args; unsigned char poller_type; if (FAIL == get_process_info_by_thread(i + 1, &thread_args.process_type, &thread_args.process_num)) { THIS_SHOULD_NEVER_HAPPEN; exit(EXIT_FAILURE); } thread_args.server_num = i + 1; thread_args.args = NULL; switch (thread_args.process_type) { case ZBX_PROCESS_TYPE_CONFSYNCER: zbx_thread_start(dbconfig_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_POLLER: poller_type = ZBX_POLLER_TYPE_NORMAL; thread_args.args = &poller_type; zbx_thread_start(poller_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_UNREACHABLE: poller_type = ZBX_POLLER_TYPE_UNREACHABLE; thread_args.args = &poller_type; zbx_thread_start(poller_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_TRAPPER: thread_args.args = &listen_sock; zbx_thread_start(trapper_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_PINGER: zbx_thread_start(pinger_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_ALERTER: zbx_thread_start(alerter_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_HOUSEKEEPER: zbx_thread_start(housekeeper_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_TIMER: zbx_thread_start(timer_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_HTTPPOLLER: zbx_thread_start(httppoller_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_DISCOVERER: zbx_thread_start(discoverer_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_HISTSYNCER: zbx_thread_start(dbsyncer_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_ESCALATOR: zbx_thread_start(escalator_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_JAVAPOLLER: poller_type = ZBX_POLLER_TYPE_JAVA; thread_args.args = &poller_type; zbx_thread_start(poller_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_SNMPTRAPPER: zbx_thread_start(snmptrapper_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_PROXYPOLLER: zbx_thread_start(proxypoller_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_SELFMON: zbx_thread_start(selfmon_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_VMWARE: zbx_thread_start(vmware_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_TASKMANAGER: zbx_thread_start(taskmanager_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_PREPROCMAN: zbx_thread_start(preprocessing_manager_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_PREPROCESSOR: zbx_thread_start(preprocessing_worker_thread, &thread_args, &threads[i]); break; #ifdef HAVE_OPENIPMI case ZBX_PROCESS_TYPE_IPMIMANAGER: zbx_thread_start(ipmi_manager_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_IPMIPOLLER: zbx_thread_start(ipmi_poller_thread, &thread_args, &threads[i]); break; #endif case ZBX_PROCESS_TYPE_ALERTMANAGER: zbx_thread_start(alert_manager_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_LLDMANAGER: zbx_thread_start(lld_manager_thread, &thread_args, &threads[i]); break; case ZBX_PROCESS_TYPE_LLDWORKER: zbx_thread_start(lld_worker_thread, &thread_args, &threads[i]); break; } } if (SUCCEED == zbx_is_export_enabled()) { zbx_history_export_init("main-process", 0); zbx_problems_export_init("main-process", 0); } while (-1 == wait(&i)) /* wait for any child to exit */ { if (EINTR != errno) { zabbix_log(LOG_LEVEL_ERR, "failed to wait on child processes: %s", zbx_strerror(errno)); break; } } /* all exiting child processes should be caught by signal handlers */ THIS_SHOULD_NEVER_HAPPEN; zbx_on_exit(); return SUCCEED; }
static void child_signal_handler(int sig, siginfo_t *siginfo, void *context) { if (NULL == siginfo) { zabbix_log(LOG_LEVEL_DEBUG, "received [signal:%d(%s)] with NULL siginfo", sig, get_signal_name(sig)); } if (NULL == context) { zabbix_log(LOG_LEVEL_DEBUG, "received [signal:%d(%s)] with NULL context", sig, get_signal_name(sig)); } switch (sig) { case SIGALRM: zabbix_log(LOG_LEVEL_DEBUG, "timeout while answering request"); break; case SIGILL: case SIGFPE: case SIGSEGV: case SIGBUS: zabbix_log(LOG_LEVEL_CRIT, "Got signal [signal:%d(%s),reason:%d,refaddr:%p]. Crashing ...", sig, get_signal_name(sig), CHECKED_FIELD(siginfo, si_code), CHECKED_FIELD_TYPE(siginfo, si_addr, void *)); print_fatal_info(sig, siginfo, context); exit(FAIL); break; case SIGUSR1: zabbix_log(LOG_LEVEL_DEBUG, "Got signal [signal:%d(%s),sender_pid:%d,sender_uid:%d,value_int:%d].", sig, get_signal_name(sig), CHECKED_FIELD(siginfo, si_pid), CHECKED_FIELD(siginfo, si_uid), CHECKED_FIELD(siginfo, si_value.sival_int)); #ifdef HAVE_SIGQUEUE if (!PARENT_PROCESS) { extern void zbx_sigusr_handler(zbx_task_t task); zbx_sigusr_handler(CHECKED_FIELD(siginfo, si_value.sival_int)); } else if (ZBX_TASK_CONFIG_CACHE_RELOAD == CHECKED_FIELD(siginfo, si_value.sival_int)) { extern unsigned char daemon_type; if (0 != (daemon_type & ZBX_DAEMON_TYPE_PROXY_PASSIVE)) { zabbix_log(LOG_LEVEL_WARNING, "forced reloading of the configuration cache" " cannot be performed for a passive proxy"); } else { union sigval s; extern pid_t *threads; s.sival_int = ZBX_TASK_CONFIG_CACHE_RELOAD; /* threads[0] is configuration syncer (it is set in proxy.c and server.c) */ if (-1 != sigqueue(threads[0], SIGUSR1, s)) { zabbix_log(LOG_LEVEL_DEBUG, "the signal is redirected to" " the configuration syncer"); } else { zabbix_log(LOG_LEVEL_ERR, "failed to redirect signal: %s", zbx_strerror(errno)); } } } #endif break; case SIGQUIT: case SIGINT: case SIGTERM: zabbix_log(parent_pid == CHECKED_FIELD(siginfo, si_pid) ? LOG_LEVEL_DEBUG : LOG_LEVEL_WARNING, "Got signal [signal:%d(%s),sender_pid:%d,sender_uid:%d,reason:%d]. Exiting ...", sig, get_signal_name(sig), CHECKED_FIELD(siginfo, si_pid), CHECKED_FIELD(siginfo, si_uid), CHECKED_FIELD(siginfo, si_code)); if (!PARENT_PROCESS) exit(FAIL); if (0 == exiting) { exiting = 1; zbx_on_exit(); } break; case SIGPIPE: zabbix_log(LOG_LEVEL_DEBUG, "Got signal [signal:%d(%s),sender_pid:%d]. Ignoring ...", sig, get_signal_name(sig), CHECKED_FIELD(siginfo, si_pid)); break; default: zabbix_log(LOG_LEVEL_WARNING, "Got signal [signal:%d(%s),sender_pid:%d,sender_uid:%d]. Ignoring ...", sig, get_signal_name(sig), CHECKED_FIELD(siginfo, si_pid), CHECKED_FIELD(siginfo, si_uid)); } }
int MAIN_ZABBIX_ENTRY() { DB_RESULT result; DB_ROW row; pid_t pid; zbx_sock_t listen_sock; int i, server_num = 0, server_count = 0; if (NULL == CONFIG_LOG_FILE || '\0' == *CONFIG_LOG_FILE) zabbix_open_log(LOG_TYPE_SYSLOG, CONFIG_LOG_LEVEL, NULL); else zabbix_open_log(LOG_TYPE_FILE, CONFIG_LOG_LEVEL, CONFIG_LOG_FILE); #ifdef HAVE_SNMP # define SNMP_FEATURE_STATUS "YES" #else # define SNMP_FEATURE_STATUS " NO" #endif #ifdef HAVE_OPENIPMI # define IPMI_FEATURE_STATUS "YES" #else # define IPMI_FEATURE_STATUS " NO" #endif #ifdef HAVE_LIBCURL # define LIBCURL_FEATURE_STATUS "YES" #else # define LIBCURL_FEATURE_STATUS " NO" #endif #if defined(HAVE_LIBXML2) && defined(HAVE_LIBCURL) # define VMWARE_FEATURE_STATUS "YES" #else # define VMWARE_FEATURE_STATUS " NO" #endif #ifdef HAVE_JABBER # define JABBER_FEATURE_STATUS "YES" #else # define JABBER_FEATURE_STATUS " NO" #endif #ifdef HAVE_UNIXODBC # define ODBC_FEATURE_STATUS "YES" #else # define ODBC_FEATURE_STATUS " NO" #endif #ifdef HAVE_SSH2 # define SSH2_FEATURE_STATUS "YES" #else # define SSH2_FEATURE_STATUS " NO" #endif #ifdef HAVE_IPV6 # define IPV6_FEATURE_STATUS "YES" #else # define IPV6_FEATURE_STATUS " NO" #endif zabbix_log(LOG_LEVEL_INFORMATION, "Starting Zabbix Server. Zabbix %s (revision %s).", ZABBIX_VERSION, ZABBIX_REVISION); zabbix_log(LOG_LEVEL_INFORMATION, "****** Enabled features ******"); zabbix_log(LOG_LEVEL_INFORMATION, "SNMP monitoring: " SNMP_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "IPMI monitoring: " IPMI_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "WEB monitoring: " LIBCURL_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "VMware monitoring: " VMWARE_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "Jabber notifications: " JABBER_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "Ez Texting notifications: " LIBCURL_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "ODBC: " ODBC_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "SSH2 support: " SSH2_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "IPv6 support: " IPV6_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "******************************"); if (0 != CONFIG_NODEID) { zabbix_log(LOG_LEVEL_INFORMATION, "NodeID: %3d", CONFIG_NODEID); zabbix_log(LOG_LEVEL_INFORMATION, "******************************"); } zabbix_log(LOG_LEVEL_INFORMATION, "using configuration file: %s", CONFIG_FILE); if (FAIL == load_modules(CONFIG_LOAD_MODULE_PATH, CONFIG_LOAD_MODULE, CONFIG_TIMEOUT, 1)) { zabbix_log(LOG_LEVEL_CRIT, "loading modules failed, exiting..."); exit(EXIT_FAILURE); } zbx_free_config(); init_database_cache(); init_configuration_cache(); init_selfmon_collector(); /* initialize vmware support */ if (0 != CONFIG_VMWARE_FORKS) zbx_vmware_init(); /* initialize history value cache */ zbx_vc_init(); zbx_create_itservices_lock(); #ifdef HAVE_SQLITE3 zbx_create_sqlite3_mutex(); #endif if (SUCCEED != DBcheck_version()) exit(EXIT_FAILURE); DBconnect(ZBX_DB_CONNECT_NORMAL); if (0 != CONFIG_NODEID) { result = DBselect("select masterid from nodes where nodeid=%d", CONFIG_NODEID); if (NULL != (row = DBfetch(result)) && SUCCEED != DBis_null(row[0])) CONFIG_MASTER_NODEID = atoi(row[0]); DBfree_result(result); } DCload_config(); /* make initial configuration sync before worker processes are forked */ DCsync_configuration(); DBclose(); if (ZBX_MUTEX_ERROR == zbx_mutex_create_force(&node_sync_access, ZBX_MUTEX_NODE_SYNC)) { zbx_error("Unable to create mutex for node syncs"); exit(FAIL); } threads_num = CONFIG_CONFSYNCER_FORKS + CONFIG_WATCHDOG_FORKS + CONFIG_POLLER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_TRAPPER_FORKS + CONFIG_PINGER_FORKS + CONFIG_ALERTER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_TIMER_FORKS + CONFIG_NODEWATCHER_FORKS + CONFIG_HTTPPOLLER_FORKS + CONFIG_DISCOVERER_FORKS + CONFIG_HISTSYNCER_FORKS + CONFIG_ESCALATOR_FORKS + CONFIG_IPMIPOLLER_FORKS + CONFIG_JAVAPOLLER_FORKS + CONFIG_SNMPTRAPPER_FORKS + CONFIG_PROXYPOLLER_FORKS + CONFIG_SELFMON_FORKS + CONFIG_VMWARE_FORKS; threads = zbx_calloc(threads, threads_num, sizeof(pid_t)); if (0 < CONFIG_TRAPPER_FORKS) { if (FAIL == zbx_tcp_listen(&listen_sock, CONFIG_LISTEN_IP, (unsigned short)CONFIG_LISTEN_PORT)) { zabbix_log(LOG_LEVEL_CRIT, "listener failed: %s", zbx_tcp_strerror()); exit(1); } } for (i = 0; i < threads_num; i++) { if (0 == (pid = zbx_child_fork())) { server_num = i + 1; /* child processes are numbered starting from 1 */ break; } else threads[i] = pid; } if (0 == server_num) { zabbix_log(LOG_LEVEL_INFORMATION, "server #0 started [main process]"); while (-1 == wait(&i)) /* wait for any child to exit */ { if (EINTR != errno) { zabbix_log(LOG_LEVEL_ERR, "failed to wait on child processes: %s", zbx_strerror(errno)); break; } } /* all exiting child processes should be caught by signal handlers */ THIS_SHOULD_NEVER_HAPPEN; zbx_on_exit(); } else if (server_num <= (server_count += CONFIG_CONFSYNCER_FORKS)) { /* !!! configuration syncer must be server #1 - child_signal_handler() uses threads[0] !!! */ INIT_SERVER(ZBX_PROCESS_TYPE_CONFSYNCER, CONFIG_CONFSYNCER_FORKS); main_dbconfig_loop(); } else if (server_num <= (server_count += CONFIG_WATCHDOG_FORKS)) { INIT_SERVER(ZBX_PROCESS_TYPE_WATCHDOG, CONFIG_WATCHDOG_FORKS); main_watchdog_loop(); } else if (server_num <= (server_count += CONFIG_POLLER_FORKS)) { #ifdef HAVE_SNMP init_snmp("zabbix_server"); #endif INIT_SERVER(ZBX_PROCESS_TYPE_POLLER, CONFIG_POLLER_FORKS); main_poller_loop(ZBX_POLLER_TYPE_NORMAL); } else if (server_num <= (server_count += CONFIG_UNREACHABLE_POLLER_FORKS)) { #ifdef HAVE_SNMP init_snmp("zabbix_server"); #endif INIT_SERVER(ZBX_PROCESS_TYPE_UNREACHABLE, CONFIG_UNREACHABLE_POLLER_FORKS); main_poller_loop(ZBX_POLLER_TYPE_UNREACHABLE); } else if (server_num <= (server_count += CONFIG_TRAPPER_FORKS)) { INIT_SERVER(ZBX_PROCESS_TYPE_TRAPPER, CONFIG_TRAPPER_FORKS); main_trapper_loop(&listen_sock); } else if (server_num <= (server_count += CONFIG_PINGER_FORKS)) { INIT_SERVER(ZBX_PROCESS_TYPE_PINGER, CONFIG_PINGER_FORKS); main_pinger_loop(); } else if (server_num <= (server_count += CONFIG_ALERTER_FORKS)) { INIT_SERVER(ZBX_PROCESS_TYPE_ALERTER, CONFIG_ALERTER_FORKS); main_alerter_loop(); } else if (server_num <= (server_count += CONFIG_HOUSEKEEPER_FORKS)) { INIT_SERVER(ZBX_PROCESS_TYPE_HOUSEKEEPER, CONFIG_HOUSEKEEPER_FORKS); main_housekeeper_loop(); } else if (server_num <= (server_count += CONFIG_TIMER_FORKS)) { INIT_SERVER(ZBX_PROCESS_TYPE_TIMER, CONFIG_TIMER_FORKS); main_timer_loop(); } else if (server_num <= (server_count += CONFIG_NODEWATCHER_FORKS)) { INIT_SERVER(ZBX_PROCESS_TYPE_NODEWATCHER, CONFIG_NODEWATCHER_FORKS); main_nodewatcher_loop(); } else if (server_num <= (server_count += CONFIG_HTTPPOLLER_FORKS)) { INIT_SERVER(ZBX_PROCESS_TYPE_HTTPPOLLER, CONFIG_HTTPPOLLER_FORKS); main_httppoller_loop(); } else if (server_num <= (server_count += CONFIG_DISCOVERER_FORKS)) { #ifdef HAVE_SNMP init_snmp("zabbix_server"); #endif INIT_SERVER(ZBX_PROCESS_TYPE_DISCOVERER, CONFIG_DISCOVERER_FORKS); main_discoverer_loop(); } else if (server_num <= (server_count += CONFIG_HISTSYNCER_FORKS)) { INIT_SERVER(ZBX_PROCESS_TYPE_HISTSYNCER, CONFIG_HISTSYNCER_FORKS); main_dbsyncer_loop(); } else if (server_num <= (server_count += CONFIG_ESCALATOR_FORKS)) { INIT_SERVER(ZBX_PROCESS_TYPE_ESCALATOR, CONFIG_ESCALATOR_FORKS); main_escalator_loop(); } else if (server_num <= (server_count += CONFIG_IPMIPOLLER_FORKS)) { INIT_SERVER(ZBX_PROCESS_TYPE_IPMIPOLLER, CONFIG_IPMIPOLLER_FORKS); main_poller_loop(ZBX_POLLER_TYPE_IPMI); } else if (server_num <= (server_count += CONFIG_JAVAPOLLER_FORKS)) { INIT_SERVER(ZBX_PROCESS_TYPE_JAVAPOLLER, CONFIG_JAVAPOLLER_FORKS); main_poller_loop(ZBX_POLLER_TYPE_JAVA); } else if (server_num <= (server_count += CONFIG_SNMPTRAPPER_FORKS)) { INIT_SERVER(ZBX_PROCESS_TYPE_SNMPTRAPPER, CONFIG_SNMPTRAPPER_FORKS); main_snmptrapper_loop(); } else if (server_num <= (server_count += CONFIG_PROXYPOLLER_FORKS)) { INIT_SERVER(ZBX_PROCESS_TYPE_PROXYPOLLER, CONFIG_PROXYPOLLER_FORKS); main_proxypoller_loop(); } else if (server_num <= (server_count += CONFIG_SELFMON_FORKS)) { INIT_SERVER(ZBX_PROCESS_TYPE_SELFMON, CONFIG_SELFMON_FORKS); main_selfmon_loop(); } else if (server_num <= (server_count += CONFIG_VMWARE_FORKS)) { INIT_SERVER(ZBX_PROCESS_TYPE_VMWARE, CONFIG_VMWARE_FORKS); main_vmware_loop(); } return SUCCEED; }
int MAIN_ZABBIX_ENTRY() { zbx_sock_t listen_sock; int i, db_type; if (NULL == CONFIG_LOG_FILE || '\0' == *CONFIG_LOG_FILE) zabbix_open_log(LOG_TYPE_SYSLOG, CONFIG_LOG_LEVEL, NULL); else zabbix_open_log(LOG_TYPE_FILE, CONFIG_LOG_LEVEL, CONFIG_LOG_FILE); #ifdef HAVE_NETSNMP # define SNMP_FEATURE_STATUS "YES" #else # define SNMP_FEATURE_STATUS " NO" #endif #ifdef HAVE_OPENIPMI # define IPMI_FEATURE_STATUS "YES" #else # define IPMI_FEATURE_STATUS " NO" #endif #ifdef HAVE_LIBCURL # define LIBCURL_FEATURE_STATUS "YES" #else # define LIBCURL_FEATURE_STATUS " NO" #endif #if defined(HAVE_LIBXML2) && defined(HAVE_LIBCURL) # define VMWARE_FEATURE_STATUS "YES" #else # define VMWARE_FEATURE_STATUS " NO" #endif #ifdef HAVE_UNIXODBC # define ODBC_FEATURE_STATUS "YES" #else # define ODBC_FEATURE_STATUS " NO" #endif #ifdef HAVE_SSH2 # define SSH2_FEATURE_STATUS "YES" #else # define SSH2_FEATURE_STATUS " NO" #endif #ifdef HAVE_IPV6 # define IPV6_FEATURE_STATUS "YES" #else # define IPV6_FEATURE_STATUS " NO" #endif zabbix_log(LOG_LEVEL_INFORMATION, "Starting Zabbix Proxy (%s) [%s]. Zabbix %s (revision %s).", ZBX_PROXYMODE_PASSIVE == CONFIG_PROXYMODE ? "passive" : "active", CONFIG_HOSTNAME, ZABBIX_VERSION, ZABBIX_REVISION); zabbix_log(LOG_LEVEL_INFORMATION, "**** Enabled features ****"); zabbix_log(LOG_LEVEL_INFORMATION, "SNMP monitoring: " SNMP_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "IPMI monitoring: " IPMI_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "WEB monitoring: " LIBCURL_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "VMware monitoring: " VMWARE_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "ODBC: " ODBC_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "SSH2 support: " SSH2_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "IPv6 support: " IPV6_FEATURE_STATUS); zabbix_log(LOG_LEVEL_INFORMATION, "**************************"); zabbix_log(LOG_LEVEL_INFORMATION, "using configuration file: %s", CONFIG_FILE); if (FAIL == load_modules(CONFIG_LOAD_MODULE_PATH, CONFIG_LOAD_MODULE, CONFIG_TIMEOUT, 1)) { zabbix_log(LOG_LEVEL_CRIT, "loading modules failed, exiting..."); exit(EXIT_FAILURE); } zbx_free_config(); init_database_cache(); init_configuration_cache(); init_selfmon_collector(); /* initialize vmware support */ if (0 != CONFIG_VMWARE_FORKS) zbx_vmware_init(); DBinit(); if (ZBX_DB_UNKNOWN == (db_type = zbx_db_get_database_type())) { zabbix_log(LOG_LEVEL_ERR, "cannot use database \"%s\": database is not a Zabbix database", CONFIG_DBNAME); exit(EXIT_FAILURE); } else if (ZBX_DB_PROXY != db_type) { zabbix_log(LOG_LEVEL_ERR, "cannot use database \"%s\": Zabbix proxy cannot work with a" " Zabbix server database", CONFIG_DBNAME); exit(EXIT_FAILURE); } if (SUCCEED != DBcheck_version()) exit(EXIT_FAILURE); DBconnect(ZBX_DB_CONNECT_NORMAL); DCsync_configuration(); DBclose(); threads_num = CONFIG_CONFSYNCER_FORKS + CONFIG_HEARTBEAT_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_TRAPPER_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_HTTPPOLLER_FORKS + CONFIG_DISCOVERER_FORKS + CONFIG_HISTSYNCER_FORKS + CONFIG_IPMIPOLLER_FORKS + CONFIG_JAVAPOLLER_FORKS + CONFIG_SNMPTRAPPER_FORKS + CONFIG_SELFMON_FORKS + CONFIG_VMWARE_FORKS; threads = zbx_calloc(threads, threads_num, sizeof(pid_t)); if (0 != CONFIG_TRAPPER_FORKS) { if (FAIL == zbx_tcp_listen(&listen_sock, CONFIG_LISTEN_IP, (unsigned short)CONFIG_LISTEN_PORT)) { zabbix_log(LOG_LEVEL_CRIT, "listener failed: %s", zbx_tcp_strerror()); exit(EXIT_FAILURE); } } zabbix_log(LOG_LEVEL_INFORMATION, "proxy #0 started [main process]"); for (i = 0; i < threads_num; i++) { zbx_thread_args_t thread_args; unsigned char poller_type; if (FAIL == get_process_info_by_thread(i + 1, &thread_args.process_type, &thread_args.process_num)) { THIS_SHOULD_NEVER_HAPPEN; exit(EXIT_FAILURE); } thread_args.server_num = i + 1; thread_args.args = NULL; switch (thread_args.process_type) { case ZBX_PROCESS_TYPE_CONFSYNCER: threads[i] = zbx_thread_start(proxyconfig_thread, &thread_args); break; case ZBX_PROCESS_TYPE_HEARTBEAT: threads[i] = zbx_thread_start(heart_thread, &thread_args); break; case ZBX_PROCESS_TYPE_DATASENDER: threads[i] = zbx_thread_start(datasender_thread, &thread_args); break; case ZBX_PROCESS_TYPE_POLLER: poller_type = ZBX_PROCESS_TYPE_POLLER; thread_args.args = &poller_type; threads[i] = zbx_thread_start(poller_thread, &thread_args); break; case ZBX_PROCESS_TYPE_UNREACHABLE: poller_type = ZBX_PROCESS_TYPE_UNREACHABLE; thread_args.args = &poller_type; threads[i] = zbx_thread_start(poller_thread, &thread_args); break; case ZBX_PROCESS_TYPE_TRAPPER: thread_args.args = &listen_sock; threads[i] = zbx_thread_start(trapper_thread, &thread_args); break; case ZBX_PROCESS_TYPE_PINGER: threads[i] = zbx_thread_start(pinger_thread, &thread_args); break; case ZBX_PROCESS_TYPE_HOUSEKEEPER: threads[i] = zbx_thread_start(housekeeper_thread, &thread_args); break; case ZBX_PROCESS_TYPE_HTTPPOLLER: threads[i] = zbx_thread_start(httppoller_thread, &thread_args); break; case ZBX_PROCESS_TYPE_DISCOVERER: threads[i] = zbx_thread_start(discoverer_thread, &thread_args); break; case ZBX_PROCESS_TYPE_HISTSYNCER: threads[i] = zbx_thread_start(dbsyncer_thread, &thread_args); break; case ZBX_PROCESS_TYPE_IPMIPOLLER: poller_type = ZBX_PROCESS_TYPE_IPMIPOLLER; thread_args.args = &poller_type; threads[i] = zbx_thread_start(poller_thread, &thread_args); break; case ZBX_PROCESS_TYPE_JAVAPOLLER: poller_type = ZBX_PROCESS_TYPE_JAVAPOLLER; thread_args.args = &poller_type; threads[i] = zbx_thread_start(poller_thread, &thread_args); break; case ZBX_PROCESS_TYPE_SNMPTRAPPER: threads[i] = zbx_thread_start(snmptrapper_thread, &thread_args); break; case ZBX_PROCESS_TYPE_SELFMON: threads[i] = zbx_thread_start(selfmon_thread, &thread_args); break; case ZBX_PROCESS_TYPE_VMWARE: threads[i] = zbx_thread_start(vmware_thread, &thread_args); break; } } while (-1 == wait(&i)) /* wait for any child to exit */ { if (EINTR != errno) { zabbix_log(LOG_LEVEL_ERR, "failed to wait on child processes: %s", zbx_strerror(errno)); break; } } /* all exiting child processes should be caught by signal handlers */ THIS_SHOULD_NEVER_HAPPEN; zbx_on_exit(); return SUCCEED; }