/****************************************************************************** * * * 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(int argc, char **argv) { FILE *in; char in_line[MAX_BUFFER_LEN], hostname[MAX_STRING_LEN], key[MAX_STRING_LEN], key_value[MAX_BUFFER_LEN], clock[32]; int total_count = 0, succeed_count = 0, buffer_count = 0, read_more = 0, ret = SUCCEED; double last_send = 0; const char *p; zbx_thread_args_t thread_args; ZBX_THREAD_SENDVAL_ARGS sentdval_args; progname = get_program_name(argv[0]); parse_commandline(argc, argv); zbx_load_config(CONFIG_FILE); zabbix_open_log(LOG_TYPE_UNDEFINED, CONFIG_LOG_LEVEL, NULL); if (NULL == ZABBIX_SERVER) { zabbix_log(LOG_LEVEL_WARNING, "'Server' parameter required"); goto exit; } if (0 == ZABBIX_SERVER_PORT) ZABBIX_SERVER_PORT = ZBX_DEFAULT_SERVER_PORT; if (MIN_ZABBIX_PORT > ZABBIX_SERVER_PORT) { zabbix_log(LOG_LEVEL_WARNING, "Incorrect port number [%d]. Allowed [%d:%d]", (int)ZABBIX_SERVER_PORT, (int)MIN_ZABBIX_PORT, (int)MAX_ZABBIX_PORT); goto exit; } thread_args.thread_num = 0; thread_args.args = &sentdval_args; sentdval_args.server = ZABBIX_SERVER; sentdval_args.port = ZABBIX_SERVER_PORT; zbx_json_init(&sentdval_args.json, ZBX_JSON_STAT_BUF_LEN); zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_REQUEST, ZBX_PROTO_VALUE_SENDER_DATA, ZBX_JSON_TYPE_STRING); zbx_json_addarray(&sentdval_args.json, ZBX_PROTO_TAG_DATA); if (INPUT_FILE) { if (0 == strcmp(INPUT_FILE, "-")) { in = stdin; if (1 == REAL_TIME) { /* set line buffering on stdin */ setvbuf(stdin, (char *)NULL, _IOLBF, 0); } } else if (NULL == (in = fopen(INPUT_FILE, "r")) ) { zabbix_log(LOG_LEVEL_WARNING, "cannot open [%s]: %s", INPUT_FILE, zbx_strerror(errno)); ret = FAIL; goto exit; } while (NULL != fgets(in_line, sizeof(in_line), in) && SUCCEED == ret) /* <hostname> <key> [<timestamp>] <value> */ { total_count++; /* also used as inputline */ zbx_rtrim(in_line, "\r\n"); p = in_line; if ('\0' == *p || NULL == (p = get_string(p, hostname, sizeof(hostname))) || '\0' == *hostname) { zabbix_log(LOG_LEVEL_WARNING, "[line %d] 'Hostname' required", total_count); continue; } if (0 == strcmp(hostname, "-")) { if (NULL == ZABBIX_HOSTNAME) { zabbix_log(LOG_LEVEL_WARNING, "[line %d] '-' encountered as 'Hostname', " "but no default hostname was specified", total_count); continue; } else zbx_strlcpy(hostname, ZABBIX_HOSTNAME, sizeof(hostname)); } if ('\0' == *p || NULL == (p = get_string(p, key, sizeof(key))) || '\0' == *key) { zabbix_log(LOG_LEVEL_WARNING, "[line %d] 'Key' required", total_count); continue; } if (1 == WITH_TIMESTAMPS) { if ('\0' == *p || NULL == (p = get_string(p, clock, sizeof(clock))) || '\0' == *clock) { zabbix_log(LOG_LEVEL_WARNING, "[line %d] 'Timestamp' required", total_count); continue; } } if ('\0' != *p && '"' != *p) zbx_strlcpy(key_value, p, sizeof(key_value)); else if ('\0' == *p || NULL == (p = get_string(p, key_value, sizeof(key_value))) || '\0' == *key_value) { zabbix_log(LOG_LEVEL_WARNING, "[line %d] 'Key value' required", total_count); continue; } zbx_rtrim(key_value, "\r\n"); zbx_json_addobject(&sentdval_args.json, NULL); zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_HOST, hostname, ZBX_JSON_TYPE_STRING); zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_KEY, key, ZBX_JSON_TYPE_STRING); zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_VALUE, key_value, ZBX_JSON_TYPE_STRING); if (1 == WITH_TIMESTAMPS) zbx_json_adduint64(&sentdval_args.json, ZBX_PROTO_TAG_CLOCK, atoi(clock)); zbx_json_close(&sentdval_args.json); succeed_count++; buffer_count++; if (stdin == in && 1 == REAL_TIME) { /* if there is nothing on standard input after 1/5 seconds, we send what we have */ /* otherwise, we keep reading, but we should send data at least once per second */ struct timeval tv; fd_set read_set; tv.tv_sec = 0; tv.tv_usec = 200000; FD_ZERO(&read_set); FD_SET(0, &read_set); /* stdin is file descriptor 0 */ if (-1 == (read_more = select(1, &read_set, NULL, NULL, &tv))) { zabbix_log(LOG_LEVEL_WARNING, "select() failed: %s", zbx_strerror(errno)); } else if (1 <= read_more) { if (0 == last_send) last_send = zbx_time(); else if (zbx_time() - last_send >= 1) read_more = 0; } } if (VALUES_MAX == buffer_count || (stdin == in && 1 == REAL_TIME && 0 >= read_more)) { zbx_json_close(&sentdval_args.json); if (1 == WITH_TIMESTAMPS) zbx_json_adduint64(&sentdval_args.json, ZBX_PROTO_TAG_CLOCK, (int)time(NULL)); last_send = zbx_time(); ret = zbx_thread_wait(zbx_thread_start(send_value, &thread_args)); buffer_count = 0; zbx_json_clean(&sentdval_args.json); zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_REQUEST, ZBX_PROTO_VALUE_SENDER_DATA, ZBX_JSON_TYPE_STRING); zbx_json_addarray(&sentdval_args.json, ZBX_PROTO_TAG_DATA); } } zbx_json_close(&sentdval_args.json); if (0 != buffer_count) { if (1 == WITH_TIMESTAMPS) zbx_json_adduint64(&sentdval_args.json, ZBX_PROTO_TAG_CLOCK, (int)time(NULL)); ret = zbx_thread_wait(zbx_thread_start(send_value, &thread_args)); } if (in != stdin) fclose(in); } else { total_count++; do /* try block simulation */ { if (NULL == ZABBIX_HOSTNAME) { zabbix_log(LOG_LEVEL_WARNING, "'Hostname' parameter required"); break; } if (NULL == ZABBIX_KEY) { zabbix_log(LOG_LEVEL_WARNING, "Key required"); break; } if (NULL == ZABBIX_KEY_VALUE) { zabbix_log(LOG_LEVEL_WARNING, "Key value required"); break; } zbx_json_addobject(&sentdval_args.json, NULL); zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_HOST, ZABBIX_HOSTNAME, ZBX_JSON_TYPE_STRING); zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_KEY, ZABBIX_KEY, ZBX_JSON_TYPE_STRING); zbx_json_addstring(&sentdval_args.json, ZBX_PROTO_TAG_VALUE, ZABBIX_KEY_VALUE, ZBX_JSON_TYPE_STRING); zbx_json_close(&sentdval_args.json); succeed_count++; ret = zbx_thread_wait(zbx_thread_start(send_value, &thread_args)); } while(0); /* try block simulation */ } zbx_json_free(&sentdval_args.json); if (SUCCEED == ret) printf("sent: %d; skipped: %d; total: %d\n", succeed_count, (total_count - succeed_count), total_count); else printf("Sending failed. Use option -vv for more detailed output.\n"); exit: zabbix_close_log(); return ret; }
int MAIN_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, *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_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; }
int MAIN_ZABBIX_ENTRY(void) { int i; pid_t pid; zbx_sock_t listen_sock; int server_num = 0; if(CONFIG_LOG_FILE == NULL) { 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_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_IPV6 # define IPV6_FEATURE_STATUS "YES" #else # define IPV6_FEATURE_STATUS " NO" #endif zabbix_log( LOG_LEVEL_WARNING, "Starting zabbix_proxy. ZABBIX %s (revision %s).", ZABBIX_VERSION, ZABBIX_REVISION); zabbix_log( LOG_LEVEL_WARNING, "**** Enabled features ****"); zabbix_log( LOG_LEVEL_WARNING, "SNMP monitoring: " SNMP_FEATURE_STATUS ); zabbix_log( LOG_LEVEL_WARNING, "WEB monitoring: " LIBCURL_FEATURE_STATUS ); zabbix_log( LOG_LEVEL_WARNING, "ODBC: " ODBC_FEATURE_STATUS ); zabbix_log( LOG_LEVEL_WARNING, "IPv6 support: " IPV6_FEATURE_STATUS ); zabbix_log( LOG_LEVEL_WARNING, "**************************"); #ifdef HAVE_SQLITE3 if(ZBX_MUTEX_ERROR == php_sem_get(&sqlite_access, CONFIG_DBNAME)) { zbx_error("Unable to create mutex for sqlite"); exit(FAIL); } #endif /* HAVE_SQLITE3 */ DBinit(); init_database_cache(ZBX_PROCESS_PROXY); threads = calloc(1 + CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_HTTPPOLLER_FORKS + CONFIG_DISCOVERER_FORKS + CONFIG_DBSYNCER_FORKS + CONFIG_IPMIPOLLER_FORKS, sizeof(pid_t)); if (CONFIG_TRAPPERD_FORKS > 0) { if (FAIL == zbx_tcp_listen(&listen_sock, CONFIG_LISTEN_IP, (unsigned short)CONFIG_LISTEN_PORT)) { zabbix_log(LOG_LEVEL_CRIT, "Listener failed with error: %s.", zbx_tcp_strerror()); exit(1); } } for ( i = 1; i <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_HTTPPOLLER_FORKS + CONFIG_DISCOVERER_FORKS + CONFIG_DBSYNCER_FORKS + CONFIG_IPMIPOLLER_FORKS; i++) { if ((pid = zbx_fork()) == 0) { server_num = i; break; } else threads[i] = pid; } /* Main process */ if (server_num == 0) { init_main_process(); zabbix_log(LOG_LEVEL_WARNING, "server #%d started [Heartbeat sender]", server_num); main_heart_loop(); for (;;) zbx_sleep(3600); } if (server_num <= CONFIG_CONFSYNCER_FORKS) { zabbix_log(LOG_LEVEL_WARNING, "server #%d started [Configuration syncer]", server_num); main_proxyconfig_loop(server_num); } else if (server_num <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS) { zabbix_log(LOG_LEVEL_WARNING, "server #%d started [Datasender]", server_num); main_datasender_loop(); } else if (server_num <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS) { #ifdef HAVE_SNMP init_snmp("zabbix_server"); #endif /* HAVE_SNMP */ zabbix_log(LOG_LEVEL_WARNING, "server #%d started [Poller. SNMP:"SNMP_FEATURE_STATUS"]", server_num); main_poller_loop(ZBX_PROCESS_PROXY, ZBX_POLLER_TYPE_NORMAL, server_num - (CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS)); } else if (server_num <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS) { zabbix_log(LOG_LEVEL_WARNING, "server #%d started [Trapper]", server_num); child_trapper_main(ZBX_PROCESS_PROXY, &listen_sock); } else if(server_num <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS) { zabbix_log(LOG_LEVEL_WARNING, "server #%d started [ICMP pinger]", server_num); main_pinger_loop(ZBX_PROCESS_PROXY, server_num - (CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS)); } else if(server_num <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS) { zabbix_log(LOG_LEVEL_WARNING, "server #%d started [Housekeeper]", server_num); main_housekeeper_loop(); } else if(server_num <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS) { #ifdef HAVE_SNMP init_snmp("zabbix_server"); #endif /* HAVE_SNMP */ zabbix_log(LOG_LEVEL_WARNING, "server #%d started [Poller for unreachable hosts. SNMP:"SNMP_FEATURE_STATUS"]", server_num); main_poller_loop(ZBX_PROCESS_PROXY, ZBX_POLLER_TYPE_UNREACHABLE, server_num - (CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS)); } else if (server_num <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_HTTPPOLLER_FORKS) { zabbix_log(LOG_LEVEL_WARNING, "server #%d started [HTTP Poller]", server_num); main_httppoller_loop(ZBX_PROCESS_PROXY, server_num - (CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS)); } else if (server_num <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_HTTPPOLLER_FORKS + CONFIG_DISCOVERER_FORKS) { #ifdef HAVE_SNMP init_snmp("zabbix_server"); #endif /* HAVE_SNMP */ zabbix_log(LOG_LEVEL_WARNING, "server #%d started [Discoverer. SNMP:"SNMP_FEATURE_STATUS"]", server_num); main_discoverer_loop(ZBX_PROCESS_PROXY, server_num - (CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_HTTPPOLLER_FORKS)); } else if (server_num <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_HTTPPOLLER_FORKS + CONFIG_DISCOVERER_FORKS + CONFIG_DBSYNCER_FORKS) { zabbix_log(LOG_LEVEL_WARNING, "server #%d started [DB Syncer]", server_num); main_dbsyncer_loop(); } else if (server_num <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_HTTPPOLLER_FORKS + CONFIG_DISCOVERER_FORKS + CONFIG_DBSYNCER_FORKS + CONFIG_IPMIPOLLER_FORKS) { zabbix_log(LOG_LEVEL_WARNING, "server #%d started [IPMI Poller]", server_num); main_poller_loop(ZBX_PROCESS_PROXY, ZBX_POLLER_TYPE_IPMI, server_num - (CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_HTTPPOLLER_FORKS + CONFIG_DISCOVERER_FORKS + CONFIG_DBSYNCER_FORKS)); } 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, *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; }
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; }