1 /*
2 ** Zabbix
3 ** Copyright (C) 2001-2021 Zabbix SIA
4 **
5 ** This program is free software; you can redistribute it and/or modify
6 ** it under the terms of the GNU General Public License as published by
7 ** the Free Software Foundation; either version 2 of the License, or
8 ** (at your option) any later version.
9 **
10 ** This program is distributed in the hope that it will be useful,
11 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
12 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 ** GNU General Public License for more details.
14 **
15 ** You should have received a copy of the GNU General Public License
16 ** along with this program; if not, write to the Free Software
17 ** Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18 **/
19
20 #include "common.h"
21
22 #include "cfg.h"
23 #include "pid.h"
24 #include "db.h"
25 #include "dbcache.h"
26 #include "zbxdbupgrade.h"
27 #include "log.h"
28 #include "zbxgetopt.h"
29 #include "mutexs.h"
30
31 #include "sysinfo.h"
32 #include "zbxmodules.h"
33 #include "zbxserver.h"
34
35 #include "zbxnix.h"
36 #include "daemon.h"
37 #include "zbxself.h"
38 #include "../libs/zbxnix/control.h"
39
40 #include "alerter/alerter.h"
41 #include "dbsyncer/dbsyncer.h"
42 #include "dbconfig/dbconfig.h"
43 #include "discoverer/discoverer.h"
44 #include "httppoller/httppoller.h"
45 #include "housekeeper/housekeeper.h"
46 #include "pinger/pinger.h"
47 #include "poller/poller.h"
48 #include "poller/checks_ipmi.h"
49 #include "timer/timer.h"
50 #include "trapper/trapper.h"
51 #include "snmptrapper/snmptrapper.h"
52 #include "watchdog/watchdog.h"
53 #include "escalator/escalator.h"
54 #include "proxypoller/proxypoller.h"
55 #include "selfmon/selfmon.h"
56 #include "vmware/vmware.h"
57
58 #include "valuecache.h"
59 #include "setproctitle.h"
60 #include "../libs/zbxcrypto/tls.h"
61
62 #define DEFAULT_CONFIG_FILE SYSCONFDIR "/zabbix_server.conf"
63
64 const char *progname = NULL;
65 const char title_message[] = "zabbix_server";
66 const char syslog_app_name[] = "zabbix_server";
67 const char *usage_message[] = {
68 "[-c config-file]", NULL,
69 "[-c config-file]", "-R runtime-option", NULL,
70 "-h", NULL,
71 "-V", NULL,
72 NULL /* end of text */
73 };
74
75 const char *help_message[] = {
76 "The core daemon of Zabbix software.",
77 "",
78 "Options:",
79 " -c --config config-file Absolute path to the configuration file",
80 " (default: \"" DEFAULT_CONFIG_FILE "\")",
81 " -f --foreground Run Zabbix server in foreground",
82 " -R --runtime-control runtime-option Perform administrative functions",
83 "",
84 " Runtime control options:",
85 " " ZBX_CONFIG_CACHE_RELOAD " Reload configuration cache",
86 " " ZBX_HOUSEKEEPER_EXECUTE " Execute the housekeeper",
87 " " ZBX_LOG_LEVEL_INCREASE "=target Increase log level, affects all processes if",
88 " target is not specified",
89 " " ZBX_LOG_LEVEL_DECREASE "=target Decrease log level, affects all processes if",
90 " target is not specified",
91 "",
92 " Log level control targets:",
93 " process-type All processes of specified type (e.g., poller)",
94 " process-type,N Process type and number (e.g., poller,3)",
95 " pid Process identifier, up to 65535. For larger",
96 " values specify target as \"process-type,N\"",
97 "",
98 " -h --help Display this help message",
99 " -V --version Display version number",
100 NULL /* end of text */
101 };
102
103 /* COMMAND LINE OPTIONS */
104
105 /* long options */
106 static struct zbx_option longopts[] =
107 {
108 {"config", 1, NULL, 'c'},
109 {"foreground", 0, NULL, 'f'},
110 {"runtime-control", 1, NULL, 'R'},
111 {"help", 0, NULL, 'h'},
112 {"version", 0, NULL, 'V'},
113 {NULL}
114 };
115
116 /* short options */
117 static char shortopts[] = "c:hVR:f";
118
119 /* end of COMMAND LINE OPTIONS */
120
121 int threads_num = 0;
122 pid_t *threads = NULL;
123
124 unsigned char program_type = ZBX_PROGRAM_TYPE_SERVER;
125 unsigned char process_type = ZBX_PROCESS_TYPE_UNKNOWN;
126 int process_num = 0;
127 int server_num = 0;
128
129 int CONFIG_ALERTER_FORKS = 1;
130 int CONFIG_DISCOVERER_FORKS = 1;
131 int CONFIG_HOUSEKEEPER_FORKS = 1;
132 int CONFIG_PINGER_FORKS = 1;
133 int CONFIG_POLLER_FORKS = 5;
134 int CONFIG_UNREACHABLE_POLLER_FORKS = 1;
135 int CONFIG_HTTPPOLLER_FORKS = 1;
136 int CONFIG_IPMIPOLLER_FORKS = 0;
137 int CONFIG_TIMER_FORKS = 1;
138 int CONFIG_TRAPPER_FORKS = 5;
139 int CONFIG_SNMPTRAPPER_FORKS = 0;
140 int CONFIG_JAVAPOLLER_FORKS = 0;
141 int CONFIG_ESCALATOR_FORKS = 1;
142 int CONFIG_SELFMON_FORKS = 1;
143 int CONFIG_WATCHDOG_FORKS = 1;
144 int CONFIG_DATASENDER_FORKS = 0;
145 int CONFIG_HEARTBEAT_FORKS = 0;
146 int CONFIG_COLLECTOR_FORKS = 0;
147 int CONFIG_PASSIVE_FORKS = 0;
148 int CONFIG_ACTIVE_FORKS = 0;
149
150 int CONFIG_LISTEN_PORT = ZBX_DEFAULT_SERVER_PORT;
151 char *CONFIG_LISTEN_IP = NULL;
152 char *CONFIG_SOURCE_IP = NULL;
153 int CONFIG_TRAPPER_TIMEOUT = 300;
154
155 int CONFIG_HOUSEKEEPING_FREQUENCY = 1;
156 int CONFIG_MAX_HOUSEKEEPER_DELETE = 5000; /* applies for every separate field value */
157 int CONFIG_SENDER_FREQUENCY = 30;
158 int CONFIG_HISTSYNCER_FORKS = 4;
159 int CONFIG_HISTSYNCER_FREQUENCY = 1;
160 int CONFIG_CONFSYNCER_FORKS = 1;
161 int CONFIG_CONFSYNCER_FREQUENCY = 60;
162
163 int CONFIG_VMWARE_FORKS = 0;
164 int CONFIG_VMWARE_FREQUENCY = 60;
165 int CONFIG_VMWARE_PERF_FREQUENCY = 60;
166 int CONFIG_VMWARE_TIMEOUT = 10;
167
168 zbx_uint64_t CONFIG_CONF_CACHE_SIZE = 8 * ZBX_MEBIBYTE;
169 zbx_uint64_t CONFIG_HISTORY_CACHE_SIZE = 16 * ZBX_MEBIBYTE;
170 zbx_uint64_t CONFIG_HISTORY_INDEX_CACHE_SIZE = 4 * ZBX_MEBIBYTE;
171 zbx_uint64_t CONFIG_TRENDS_CACHE_SIZE = 4 * ZBX_MEBIBYTE;
172 zbx_uint64_t CONFIG_VALUE_CACHE_SIZE = 8 * ZBX_MEBIBYTE;
173 zbx_uint64_t CONFIG_VMWARE_CACHE_SIZE = 8 * ZBX_MEBIBYTE;
174
175 int CONFIG_UNREACHABLE_PERIOD = 45;
176 int CONFIG_UNREACHABLE_DELAY = 15;
177 int CONFIG_UNAVAILABLE_DELAY = 60;
178 int CONFIG_LOG_LEVEL = LOG_LEVEL_WARNING;
179 char *CONFIG_ALERT_SCRIPTS_PATH = NULL;
180 char *CONFIG_EXTERNALSCRIPTS = NULL;
181 char *CONFIG_TMPDIR = NULL;
182 char *CONFIG_FPING_LOCATION = NULL;
183 char *CONFIG_FPING6_LOCATION = NULL;
184 char *CONFIG_DBHOST = NULL;
185 char *CONFIG_DBNAME = NULL;
186 char *CONFIG_DBSCHEMA = NULL;
187 char *CONFIG_DBUSER = NULL;
188 char *CONFIG_DBPASSWORD = NULL;
189 char *CONFIG_DBSOCKET = NULL;
190 int CONFIG_DBPORT = 0;
191 int CONFIG_ENABLE_REMOTE_COMMANDS = 0;
192 int CONFIG_LOG_REMOTE_COMMANDS = 0;
193 int CONFIG_UNSAFE_USER_PARAMETERS = 0;
194
195 char *CONFIG_SNMPTRAP_FILE = NULL;
196
197 char *CONFIG_JAVA_GATEWAY = NULL;
198 int CONFIG_JAVA_GATEWAY_PORT = ZBX_DEFAULT_GATEWAY_PORT;
199
200 char *CONFIG_SSH_KEY_LOCATION = NULL;
201
202 int CONFIG_LOG_SLOW_QUERIES = 0; /* ms; 0 - disable */
203
204 int CONFIG_SERVER_STARTUP_TIME = 0; /* zabbix server startup time */
205
206 int CONFIG_PROXYPOLLER_FORKS = 1; /* parameters for passive proxies */
207
208 /* how often Zabbix server sends configuration data to proxy, in seconds */
209 int CONFIG_PROXYCONFIG_FREQUENCY = SEC_PER_HOUR;
210 int CONFIG_PROXYDATA_FREQUENCY = 1; /* 1s */
211
212 char *CONFIG_LOAD_MODULE_PATH = NULL;
213 char **CONFIG_LOAD_MODULE = NULL;
214
215 char *CONFIG_USER = NULL;
216
217 /* web monitoring */
218 char *CONFIG_SSL_CA_LOCATION = NULL;
219 char *CONFIG_SSL_CERT_LOCATION = NULL;
220 char *CONFIG_SSL_KEY_LOCATION = NULL;
221
222 /* TLS parameters */
223 unsigned int configured_tls_connect_mode = ZBX_TCP_SEC_UNENCRYPTED; /* not used in server, defined for linking */
224 /* with tls.c */
225 unsigned int configured_tls_accept_modes = ZBX_TCP_SEC_UNENCRYPTED; /* not used in server, defined for linking */
226 /* with tls.c */
227 char *CONFIG_TLS_CA_FILE = NULL;
228 char *CONFIG_TLS_CRL_FILE = NULL;
229 char *CONFIG_TLS_CERT_FILE = NULL;
230 char *CONFIG_TLS_KEY_FILE = NULL;
231 #if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL)
232 /* the following TLS parameters are not used in server, they are defined for linking with tls.c */
233 char *CONFIG_TLS_CONNECT = NULL;
234 char *CONFIG_TLS_ACCEPT = NULL;
235 char *CONFIG_TLS_SERVER_CERT_ISSUER = NULL;
236 char *CONFIG_TLS_SERVER_CERT_SUBJECT = NULL;
237 char *CONFIG_TLS_PSK_IDENTITY = NULL;
238 char *CONFIG_TLS_PSK_FILE = NULL;
239 #endif
240
241 int get_process_info_by_thread(int local_server_num, unsigned char *local_process_type, int *local_process_num);
242
get_process_info_by_thread(int local_server_num,unsigned char * local_process_type,int * local_process_num)243 int get_process_info_by_thread(int local_server_num, unsigned char *local_process_type, int *local_process_num)
244 {
245 int server_count = 0;
246
247 if (0 == local_server_num)
248 {
249 /* fail if the main process is queried */
250 return FAIL;
251 }
252 else if (local_server_num <= (server_count += CONFIG_CONFSYNCER_FORKS))
253 {
254 *local_process_type = ZBX_PROCESS_TYPE_CONFSYNCER;
255 *local_process_num = local_server_num - server_count + CONFIG_CONFSYNCER_FORKS;
256 }
257 else if (local_server_num <= (server_count += CONFIG_WATCHDOG_FORKS))
258 {
259 *local_process_type = ZBX_PROCESS_TYPE_WATCHDOG;
260 *local_process_num = local_server_num - server_count + CONFIG_WATCHDOG_FORKS;
261 }
262 else if (local_server_num <= (server_count += CONFIG_POLLER_FORKS))
263 {
264 *local_process_type = ZBX_PROCESS_TYPE_POLLER;
265 *local_process_num = local_server_num - server_count + CONFIG_POLLER_FORKS;
266 }
267 else if (local_server_num <= (server_count += CONFIG_UNREACHABLE_POLLER_FORKS))
268 {
269 *local_process_type = ZBX_PROCESS_TYPE_UNREACHABLE;
270 *local_process_num = local_server_num - server_count + CONFIG_UNREACHABLE_POLLER_FORKS;
271 }
272 else if (local_server_num <= (server_count += CONFIG_TRAPPER_FORKS))
273 {
274 *local_process_type = ZBX_PROCESS_TYPE_TRAPPER;
275 *local_process_num = local_server_num - server_count + CONFIG_TRAPPER_FORKS;
276 }
277 else if (local_server_num <= (server_count += CONFIG_PINGER_FORKS))
278 {
279 *local_process_type = ZBX_PROCESS_TYPE_PINGER;
280 *local_process_num = local_server_num - server_count + CONFIG_PINGER_FORKS;
281 }
282 else if (local_server_num <= (server_count += CONFIG_ALERTER_FORKS))
283 {
284 *local_process_type = ZBX_PROCESS_TYPE_ALERTER;
285 *local_process_num = local_server_num - server_count + CONFIG_ALERTER_FORKS;
286 }
287 else if (local_server_num <= (server_count += CONFIG_HOUSEKEEPER_FORKS))
288 {
289 *local_process_type = ZBX_PROCESS_TYPE_HOUSEKEEPER;
290 *local_process_num = local_server_num - server_count + CONFIG_HOUSEKEEPER_FORKS;
291 }
292 else if (local_server_num <= (server_count += CONFIG_TIMER_FORKS))
293 {
294 *local_process_type = ZBX_PROCESS_TYPE_TIMER;
295 *local_process_num = local_server_num - server_count + CONFIG_TIMER_FORKS;
296 }
297 else if (local_server_num <= (server_count += CONFIG_HTTPPOLLER_FORKS))
298 {
299 *local_process_type = ZBX_PROCESS_TYPE_HTTPPOLLER;
300 *local_process_num = local_server_num - server_count + CONFIG_HTTPPOLLER_FORKS;
301 }
302 else if (local_server_num <= (server_count += CONFIG_DISCOVERER_FORKS))
303 {
304 *local_process_type = ZBX_PROCESS_TYPE_DISCOVERER;
305 *local_process_num = local_server_num - server_count + CONFIG_DISCOVERER_FORKS;
306 }
307 else if (local_server_num <= (server_count += CONFIG_HISTSYNCER_FORKS))
308 {
309 *local_process_type = ZBX_PROCESS_TYPE_HISTSYNCER;
310 *local_process_num = local_server_num - server_count + CONFIG_HISTSYNCER_FORKS;
311 }
312 else if (local_server_num <= (server_count += CONFIG_ESCALATOR_FORKS))
313 {
314 *local_process_type = ZBX_PROCESS_TYPE_ESCALATOR;
315 *local_process_num = local_server_num - server_count + CONFIG_ESCALATOR_FORKS;
316 }
317 else if (local_server_num <= (server_count += CONFIG_IPMIPOLLER_FORKS))
318 {
319 *local_process_type = ZBX_PROCESS_TYPE_IPMIPOLLER;
320 *local_process_num = local_server_num - server_count + CONFIG_IPMIPOLLER_FORKS;
321 }
322 else if (local_server_num <= (server_count += CONFIG_JAVAPOLLER_FORKS))
323 {
324 *local_process_type = ZBX_PROCESS_TYPE_JAVAPOLLER;
325 *local_process_num = local_server_num - server_count + CONFIG_JAVAPOLLER_FORKS;
326 }
327 else if (local_server_num <= (server_count += CONFIG_SNMPTRAPPER_FORKS))
328 {
329 *local_process_type = ZBX_PROCESS_TYPE_SNMPTRAPPER;
330 *local_process_num = local_server_num - server_count + CONFIG_SNMPTRAPPER_FORKS;
331 }
332 else if (local_server_num <= (server_count += CONFIG_PROXYPOLLER_FORKS))
333 {
334 *local_process_type = ZBX_PROCESS_TYPE_PROXYPOLLER;
335 *local_process_num = local_server_num - server_count + CONFIG_PROXYPOLLER_FORKS;
336 }
337 else if (local_server_num <= (server_count += CONFIG_SELFMON_FORKS))
338 {
339 *local_process_type = ZBX_PROCESS_TYPE_SELFMON;
340 *local_process_num = local_server_num - server_count + CONFIG_SELFMON_FORKS;
341 }
342 else if (local_server_num <= (server_count += CONFIG_VMWARE_FORKS))
343 {
344 *local_process_type = ZBX_PROCESS_TYPE_VMWARE;
345 *local_process_num = local_server_num - server_count + CONFIG_VMWARE_FORKS;
346 }
347 else
348 return FAIL;
349
350 return SUCCEED;
351 }
352
353 /******************************************************************************
354 * *
355 * Function: zbx_set_defaults *
356 * *
357 * Purpose: set configuration defaults *
358 * *
359 * Author: Vladimir Levijev *
360 * *
361 ******************************************************************************/
zbx_set_defaults(void)362 static void zbx_set_defaults(void)
363 {
364 CONFIG_SERVER_STARTUP_TIME = time(NULL);
365
366 if (NULL == CONFIG_DBHOST)
367 CONFIG_DBHOST = zbx_strdup(CONFIG_DBHOST, "localhost");
368
369 if (NULL == CONFIG_SNMPTRAP_FILE)
370 CONFIG_SNMPTRAP_FILE = zbx_strdup(CONFIG_SNMPTRAP_FILE, "/tmp/zabbix_traps.tmp");
371
372 if (NULL == CONFIG_PID_FILE)
373 CONFIG_PID_FILE = zbx_strdup(CONFIG_PID_FILE, "/var/run/zabbix/zabbix_server.pid");
374
375 if (NULL == CONFIG_ALERT_SCRIPTS_PATH)
376 CONFIG_ALERT_SCRIPTS_PATH = zbx_strdup(CONFIG_ALERT_SCRIPTS_PATH, DATADIR "/zabbix/alertscripts");
377
378 if (NULL == CONFIG_LOAD_MODULE_PATH)
379 CONFIG_LOAD_MODULE_PATH = zbx_strdup(CONFIG_LOAD_MODULE_PATH, LIBDIR "/modules");
380
381 if (NULL == CONFIG_TMPDIR)
382 CONFIG_TMPDIR = zbx_strdup(CONFIG_TMPDIR, "/tmp");
383
384 if (NULL == CONFIG_FPING_LOCATION)
385 CONFIG_FPING_LOCATION = zbx_strdup(CONFIG_FPING_LOCATION, "/usr/local/sbin/fping");
386 #ifdef HAVE_IPV6
387 if (NULL == CONFIG_FPING6_LOCATION)
388 CONFIG_FPING6_LOCATION = zbx_strdup(CONFIG_FPING6_LOCATION, "/usr/local/sbin/fping6");
389 #endif
390 if (NULL == CONFIG_EXTERNALSCRIPTS)
391 CONFIG_EXTERNALSCRIPTS = zbx_strdup(CONFIG_EXTERNALSCRIPTS, DATADIR "/zabbix/externalscripts");
392 #ifdef HAVE_LIBCURL
393 if (NULL == CONFIG_SSL_CERT_LOCATION)
394 CONFIG_SSL_CERT_LOCATION = zbx_strdup(CONFIG_SSL_CERT_LOCATION, DATADIR "/zabbix/ssl/certs");
395
396 if (NULL == CONFIG_SSL_KEY_LOCATION)
397 CONFIG_SSL_KEY_LOCATION = zbx_strdup(CONFIG_SSL_KEY_LOCATION, DATADIR "/zabbix/ssl/keys");
398 #endif
399
400 #ifdef HAVE_SQLITE3
401 CONFIG_MAX_HOUSEKEEPER_DELETE = 0;
402 #endif
403
404 if (NULL == CONFIG_LOG_TYPE_STR)
405 CONFIG_LOG_TYPE_STR = zbx_strdup(CONFIG_LOG_TYPE_STR, ZBX_OPTION_LOGTYPE_FILE);
406 }
407
408 /******************************************************************************
409 * *
410 * Function: zbx_validate_config *
411 * *
412 * Purpose: validate configuration parameters *
413 * *
414 * Author: Vladimir Levijev *
415 * *
416 ******************************************************************************/
zbx_validate_config(ZBX_TASK_EX * task)417 static void zbx_validate_config(ZBX_TASK_EX *task)
418 {
419 int err = 0;
420
421 if (0 == CONFIG_UNREACHABLE_POLLER_FORKS && 0 != CONFIG_POLLER_FORKS + CONFIG_IPMIPOLLER_FORKS +
422 CONFIG_JAVAPOLLER_FORKS)
423 {
424 zabbix_log(LOG_LEVEL_CRIT, "\"StartPollersUnreachable\" configuration parameter must not be 0"
425 " if regular, IPMI or Java pollers are started");
426 err = 1;
427 }
428
429 if ((NULL == CONFIG_JAVA_GATEWAY || '\0' == *CONFIG_JAVA_GATEWAY) && 0 < CONFIG_JAVAPOLLER_FORKS)
430 {
431 zabbix_log(LOG_LEVEL_CRIT, "\"JavaGateway\" configuration parameter is not specified or empty");
432 err = 1;
433 }
434
435 if (0 != CONFIG_VALUE_CACHE_SIZE && 128 * ZBX_KIBIBYTE > CONFIG_VALUE_CACHE_SIZE)
436 {
437 zabbix_log(LOG_LEVEL_CRIT, "\"ValueCacheSize\" configuration parameter must be either 0"
438 " or greater than 128KB");
439 err = 1;
440 }
441
442 if (NULL != CONFIG_SOURCE_IP && SUCCEED != is_supported_ip(CONFIG_SOURCE_IP))
443 {
444 zabbix_log(LOG_LEVEL_CRIT, "invalid \"SourceIP\" configuration parameter: '%s'", CONFIG_SOURCE_IP);
445 err = 1;
446 }
447 #if !defined(HAVE_IPV6)
448 err |= (FAIL == check_cfg_feature_str("Fping6Location", CONFIG_FPING6_LOCATION, "IPv6 support"));
449 #endif
450 #if !defined(HAVE_LIBCURL)
451 err |= (FAIL == check_cfg_feature_str("SSLCALocation", CONFIG_SSL_CA_LOCATION, "cURL library"));
452 err |= (FAIL == check_cfg_feature_str("SSLCertLocation", CONFIG_SSL_CERT_LOCATION, "cURL library"));
453 err |= (FAIL == check_cfg_feature_str("SSLKeyLocation", CONFIG_SSL_KEY_LOCATION, "cURL library"));
454 #endif
455 #if !defined(HAVE_LIBXML2) || !defined(HAVE_LIBCURL)
456 err |= (FAIL == check_cfg_feature_int("StartVMwareCollectors", CONFIG_VMWARE_FORKS, "VMware support"));
457
458 /* parameters VMwareFrequency, VMwarePerfFrequency, VMwareCacheSize, VMwareTimeout are not checked here */
459 /* because they have non-zero default values */
460 #endif
461
462 if (SUCCEED != zbx_validate_log_parameters(task))
463 err = 1;
464
465 #if !(defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL))
466 err |= (FAIL == check_cfg_feature_str("TLSCAFile", CONFIG_TLS_CA_FILE, "TLS support"));
467 err |= (FAIL == check_cfg_feature_str("TLSCRLFile", CONFIG_TLS_CRL_FILE, "TLS support"));
468 err |= (FAIL == check_cfg_feature_str("TLSCertFile", CONFIG_TLS_CERT_FILE, "TLS support"));
469 err |= (FAIL == check_cfg_feature_str("TLSKeyFile", CONFIG_TLS_KEY_FILE, "TLS support"));
470 #endif
471 if (0 != err)
472 exit(EXIT_FAILURE);
473 }
474
475 /******************************************************************************
476 * *
477 * Function: zbx_load_config *
478 * *
479 * Purpose: parse config file and update configuration parameters *
480 * *
481 * Parameters: *
482 * *
483 * Return value: *
484 * *
485 * Author: Alexei Vladishev *
486 * *
487 * Comments: will terminate process if parsing fails *
488 * *
489 ******************************************************************************/
zbx_load_config(ZBX_TASK_EX * task)490 static void zbx_load_config(ZBX_TASK_EX *task)
491 {
492 static struct cfg_line cfg[] =
493 {
494 /* PARAMETER, VAR, TYPE,
495 MANDATORY, MIN, MAX */
496 {"StartDBSyncers", &CONFIG_HISTSYNCER_FORKS, TYPE_INT,
497 PARM_OPT, 1, 100},
498 {"StartDiscoverers", &CONFIG_DISCOVERER_FORKS, TYPE_INT,
499 PARM_OPT, 0, 250},
500 {"StartHTTPPollers", &CONFIG_HTTPPOLLER_FORKS, TYPE_INT,
501 PARM_OPT, 0, 1000},
502 {"StartPingers", &CONFIG_PINGER_FORKS, TYPE_INT,
503 PARM_OPT, 0, 1000},
504 {"StartPollers", &CONFIG_POLLER_FORKS, TYPE_INT,
505 PARM_OPT, 0, 1000},
506 {"StartPollersUnreachable", &CONFIG_UNREACHABLE_POLLER_FORKS, TYPE_INT,
507 PARM_OPT, 0, 1000},
508 {"StartIPMIPollers", &CONFIG_IPMIPOLLER_FORKS, TYPE_INT,
509 PARM_OPT, 0, 1000},
510 {"StartTimers", &CONFIG_TIMER_FORKS, TYPE_INT,
511 PARM_OPT, 1, 1000},
512 {"StartTrappers", &CONFIG_TRAPPER_FORKS, TYPE_INT,
513 PARM_OPT, 0, 1000},
514 {"StartJavaPollers", &CONFIG_JAVAPOLLER_FORKS, TYPE_INT,
515 PARM_OPT, 0, 1000},
516 {"StartEscalators", &CONFIG_ESCALATOR_FORKS, TYPE_INT,
517 PARM_OPT, 1, 100},
518 {"JavaGateway", &CONFIG_JAVA_GATEWAY, TYPE_STRING,
519 PARM_OPT, 0, 0},
520 {"JavaGatewayPort", &CONFIG_JAVA_GATEWAY_PORT, TYPE_INT,
521 PARM_OPT, 1024, 32767},
522 {"SNMPTrapperFile", &CONFIG_SNMPTRAP_FILE, TYPE_STRING,
523 PARM_OPT, 0, 0},
524 {"StartSNMPTrapper", &CONFIG_SNMPTRAPPER_FORKS, TYPE_INT,
525 PARM_OPT, 0, 1},
526 {"CacheSize", &CONFIG_CONF_CACHE_SIZE, TYPE_UINT64,
527 PARM_OPT, 128 * ZBX_KIBIBYTE, __UINT64_C(8) * ZBX_GIBIBYTE},
528 {"HistoryCacheSize", &CONFIG_HISTORY_CACHE_SIZE, TYPE_UINT64,
529 PARM_OPT, 128 * ZBX_KIBIBYTE, __UINT64_C(2) * ZBX_GIBIBYTE},
530 {"HistoryIndexCacheSize", &CONFIG_HISTORY_INDEX_CACHE_SIZE, TYPE_UINT64,
531 PARM_OPT, 128 * ZBX_KIBIBYTE, __UINT64_C(2) * ZBX_GIBIBYTE},
532 {"TrendCacheSize", &CONFIG_TRENDS_CACHE_SIZE, TYPE_UINT64,
533 PARM_OPT, 128 * ZBX_KIBIBYTE, __UINT64_C(2) * ZBX_GIBIBYTE},
534 {"ValueCacheSize", &CONFIG_VALUE_CACHE_SIZE, TYPE_UINT64,
535 PARM_OPT, 0, __UINT64_C(64) * ZBX_GIBIBYTE},
536 {"CacheUpdateFrequency", &CONFIG_CONFSYNCER_FREQUENCY, TYPE_INT,
537 PARM_OPT, 1, SEC_PER_HOUR},
538 {"HousekeepingFrequency", &CONFIG_HOUSEKEEPING_FREQUENCY, TYPE_INT,
539 PARM_OPT, 0, 24},
540 {"MaxHousekeeperDelete", &CONFIG_MAX_HOUSEKEEPER_DELETE, TYPE_INT,
541 PARM_OPT, 0, 1000000},
542 {"SenderFrequency", &CONFIG_SENDER_FREQUENCY, TYPE_INT,
543 PARM_OPT, 5, SEC_PER_HOUR},
544 {"TmpDir", &CONFIG_TMPDIR, TYPE_STRING,
545 PARM_OPT, 0, 0},
546 {"FpingLocation", &CONFIG_FPING_LOCATION, TYPE_STRING,
547 PARM_OPT, 0, 0},
548 {"Fping6Location", &CONFIG_FPING6_LOCATION, TYPE_STRING,
549 PARM_OPT, 0, 0},
550 {"Timeout", &CONFIG_TIMEOUT, TYPE_INT,
551 PARM_OPT, 1, 30},
552 {"TrapperTimeout", &CONFIG_TRAPPER_TIMEOUT, TYPE_INT,
553 PARM_OPT, 1, 300},
554 {"UnreachablePeriod", &CONFIG_UNREACHABLE_PERIOD, TYPE_INT,
555 PARM_OPT, 1, SEC_PER_HOUR},
556 {"UnreachableDelay", &CONFIG_UNREACHABLE_DELAY, TYPE_INT,
557 PARM_OPT, 1, SEC_PER_HOUR},
558 {"UnavailableDelay", &CONFIG_UNAVAILABLE_DELAY, TYPE_INT,
559 PARM_OPT, 1, SEC_PER_HOUR},
560 {"ListenIP", &CONFIG_LISTEN_IP, TYPE_STRING_LIST,
561 PARM_OPT, 0, 0},
562 {"ListenPort", &CONFIG_LISTEN_PORT, TYPE_INT,
563 PARM_OPT, 1024, 32767},
564 {"SourceIP", &CONFIG_SOURCE_IP, TYPE_STRING,
565 PARM_OPT, 0, 0},
566 {"DebugLevel", &CONFIG_LOG_LEVEL, TYPE_INT,
567 PARM_OPT, 0, 5},
568 {"PidFile", &CONFIG_PID_FILE, TYPE_STRING,
569 PARM_OPT, 0, 0},
570 {"LogType", &CONFIG_LOG_TYPE_STR, TYPE_STRING,
571 PARM_OPT, 0, 0},
572 {"LogFile", &CONFIG_LOG_FILE, TYPE_STRING,
573 PARM_OPT, 0, 0},
574 {"LogFileSize", &CONFIG_LOG_FILE_SIZE, TYPE_INT,
575 PARM_OPT, 0, 1024},
576 {"AlertScriptsPath", &CONFIG_ALERT_SCRIPTS_PATH, TYPE_STRING,
577 PARM_OPT, 0, 0},
578 {"ExternalScripts", &CONFIG_EXTERNALSCRIPTS, TYPE_STRING,
579 PARM_OPT, 0, 0},
580 {"DBHost", &CONFIG_DBHOST, TYPE_STRING,
581 PARM_OPT, 0, 0},
582 {"DBName", &CONFIG_DBNAME, TYPE_STRING,
583 PARM_MAND, 0, 0},
584 {"DBSchema", &CONFIG_DBSCHEMA, TYPE_STRING,
585 PARM_OPT, 0, 0},
586 {"DBUser", &CONFIG_DBUSER, TYPE_STRING,
587 PARM_OPT, 0, 0},
588 {"DBPassword", &CONFIG_DBPASSWORD, TYPE_STRING,
589 PARM_OPT, 0, 0},
590 {"DBSocket", &CONFIG_DBSOCKET, TYPE_STRING,
591 PARM_OPT, 0, 0},
592 {"DBPort", &CONFIG_DBPORT, TYPE_INT,
593 PARM_OPT, 1024, 65535},
594 {"SSHKeyLocation", &CONFIG_SSH_KEY_LOCATION, TYPE_STRING,
595 PARM_OPT, 0, 0},
596 {"LogSlowQueries", &CONFIG_LOG_SLOW_QUERIES, TYPE_INT,
597 PARM_OPT, 0, 3600000},
598 {"StartProxyPollers", &CONFIG_PROXYPOLLER_FORKS, TYPE_INT,
599 PARM_OPT, 0, 250},
600 {"ProxyConfigFrequency", &CONFIG_PROXYCONFIG_FREQUENCY, TYPE_INT,
601 PARM_OPT, 1, SEC_PER_WEEK},
602 {"ProxyDataFrequency", &CONFIG_PROXYDATA_FREQUENCY, TYPE_INT,
603 PARM_OPT, 1, SEC_PER_HOUR},
604 {"LoadModulePath", &CONFIG_LOAD_MODULE_PATH, TYPE_STRING,
605 PARM_OPT, 0, 0},
606 {"LoadModule", &CONFIG_LOAD_MODULE, TYPE_MULTISTRING,
607 PARM_OPT, 0, 0},
608 {"StartVMwareCollectors", &CONFIG_VMWARE_FORKS, TYPE_INT,
609 PARM_OPT, 0, 250},
610 {"VMwareFrequency", &CONFIG_VMWARE_FREQUENCY, TYPE_INT,
611 PARM_OPT, 10, SEC_PER_DAY},
612 {"VMwarePerfFrequency", &CONFIG_VMWARE_PERF_FREQUENCY, TYPE_INT,
613 PARM_OPT, 10, SEC_PER_DAY},
614 {"VMwareCacheSize", &CONFIG_VMWARE_CACHE_SIZE, TYPE_UINT64,
615 PARM_OPT, 256 * ZBX_KIBIBYTE, __UINT64_C(2) * ZBX_GIBIBYTE},
616 {"VMwareTimeout", &CONFIG_VMWARE_TIMEOUT, TYPE_INT,
617 PARM_OPT, 1, 300},
618 {"AllowRoot", &CONFIG_ALLOW_ROOT, TYPE_INT,
619 PARM_OPT, 0, 1},
620 {"User", &CONFIG_USER, TYPE_STRING,
621 PARM_OPT, 0, 0},
622 {"SSLCALocation", &CONFIG_SSL_CA_LOCATION, TYPE_STRING,
623 PARM_OPT, 0, 0},
624 {"SSLCertLocation", &CONFIG_SSL_CERT_LOCATION, TYPE_STRING,
625 PARM_OPT, 0, 0},
626 {"SSLKeyLocation", &CONFIG_SSL_KEY_LOCATION, TYPE_STRING,
627 PARM_OPT, 0, 0},
628 {"TLSCAFile", &CONFIG_TLS_CA_FILE, TYPE_STRING,
629 PARM_OPT, 0, 0},
630 {"TLSCRLFile", &CONFIG_TLS_CRL_FILE, TYPE_STRING,
631 PARM_OPT, 0, 0},
632 {"TLSCertFile", &CONFIG_TLS_CERT_FILE, TYPE_STRING,
633 PARM_OPT, 0, 0},
634 {"TLSKeyFile", &CONFIG_TLS_KEY_FILE, TYPE_STRING,
635 PARM_OPT, 0, 0},
636 {NULL}
637 };
638
639 /* initialize multistrings */
640 zbx_strarr_init(&CONFIG_LOAD_MODULE);
641
642 parse_cfg_file(CONFIG_FILE, cfg, ZBX_CFG_FILE_REQUIRED, ZBX_CFG_STRICT);
643
644 zbx_set_defaults();
645
646 CONFIG_LOG_TYPE = zbx_get_log_type(CONFIG_LOG_TYPE_STR);
647
648 zbx_validate_config(task);
649 #if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL)
650 zbx_tls_validate_config();
651 #endif
652 }
653
654 /******************************************************************************
655 * *
656 * Function: zbx_free_config *
657 * *
658 * Purpose: free configuration memory *
659 * *
660 ******************************************************************************/
zbx_free_config(void)661 static void zbx_free_config(void)
662 {
663 zbx_strarr_free(CONFIG_LOAD_MODULE);
664 }
665
666 /******************************************************************************
667 * *
668 * Function: main *
669 * *
670 * Purpose: executes server processes *
671 * *
672 * Author: Eugene Grigorjev *
673 * *
674 ******************************************************************************/
main(int argc,char ** argv)675 int main(int argc, char **argv)
676 {
677 ZBX_TASK_EX t = {ZBX_TASK_START};
678 char ch;
679 int opt_c = 0, opt_r = 0;
680
681 #if defined(PS_OVERWRITE_ARGV) || defined(PS_PSTAT_ARGV)
682 argv = setproctitle_save_env(argc, argv);
683 #endif
684 progname = get_program_name(argv[0]);
685
686 /* parse the command-line */
687 while ((char)EOF != (ch = (char)zbx_getopt_long(argc, argv, shortopts, longopts, NULL)))
688 {
689 switch (ch)
690 {
691 case 'c':
692 opt_c++;
693 if (NULL == CONFIG_FILE)
694 CONFIG_FILE = zbx_strdup(CONFIG_FILE, zbx_optarg);
695 break;
696 case 'R':
697 opt_r++;
698 if (SUCCEED != parse_rtc_options(zbx_optarg, program_type, &t.data))
699 exit(EXIT_FAILURE);
700
701 t.task = ZBX_TASK_RUNTIME_CONTROL;
702 break;
703 case 'h':
704 help();
705 exit(EXIT_SUCCESS);
706 break;
707 case 'V':
708 version();
709 exit(EXIT_SUCCESS);
710 break;
711 case 'f':
712 t.flags |= ZBX_TASK_FLAG_FOREGROUND;
713 break;
714 default:
715 usage();
716 exit(EXIT_FAILURE);
717 break;
718 }
719 }
720
721 /* every option may be specified only once */
722 if (1 < opt_c || 1 < opt_r)
723 {
724 if (1 < opt_c)
725 zbx_error("option \"-c\" or \"--config\" specified multiple times");
726 if (1 < opt_r)
727 zbx_error("option \"-R\" or \"--runtime-control\" specified multiple times");
728
729 exit(EXIT_FAILURE);
730 }
731
732 /* Parameters which are not option values are invalid. The check relies on zbx_getopt_internal() which */
733 /* always permutes command line arguments regardless of POSIXLY_CORRECT environment variable. */
734 if (argc > zbx_optind)
735 {
736 int i;
737
738 for (i = zbx_optind; i < argc; i++)
739 zbx_error("invalid parameter \"%s\"", argv[i]);
740
741 exit(EXIT_FAILURE);
742 }
743
744 if (NULL == CONFIG_FILE)
745 CONFIG_FILE = zbx_strdup(NULL, DEFAULT_CONFIG_FILE);
746
747 /* required for simple checks */
748 init_metrics();
749
750 zbx_load_config(&t);
751
752 if (ZBX_TASK_RUNTIME_CONTROL == t.task)
753 exit(SUCCEED == zbx_sigusr_send(t.data) ? EXIT_SUCCESS : EXIT_FAILURE);
754
755 #ifdef HAVE_OPENIPMI
756 zbx_init_ipmi_handler();
757 #endif
758 return daemon_start(CONFIG_ALLOW_ROOT, CONFIG_USER, t.flags);
759 }
760
MAIN_ZABBIX_ENTRY(int flags)761 int MAIN_ZABBIX_ENTRY(int flags)
762 {
763 zbx_socket_t listen_sock;
764 int i, db_type;
765
766 if (0 != (flags & ZBX_TASK_FLAG_FOREGROUND))
767 {
768 printf("Starting Zabbix Server. Zabbix %s (revision %s).\nPress Ctrl+C to exit.\n\n",
769 ZABBIX_VERSION, ZABBIX_REVISION);
770 }
771
772 zabbix_open_log(CONFIG_LOG_TYPE, CONFIG_LOG_LEVEL, CONFIG_LOG_FILE);
773
774 #ifdef HAVE_NETSNMP
775 # define SNMP_FEATURE_STATUS "YES"
776 #else
777 # define SNMP_FEATURE_STATUS " NO"
778 #endif
779 #ifdef HAVE_OPENIPMI
780 # define IPMI_FEATURE_STATUS "YES"
781 #else
782 # define IPMI_FEATURE_STATUS " NO"
783 #endif
784 #ifdef HAVE_LIBCURL
785 # define LIBCURL_FEATURE_STATUS "YES"
786 #else
787 # define LIBCURL_FEATURE_STATUS " NO"
788 #endif
789 #if defined(HAVE_LIBCURL) && defined(HAVE_LIBXML2)
790 # define VMWARE_FEATURE_STATUS "YES"
791 #else
792 # define VMWARE_FEATURE_STATUS " NO"
793 #endif
794 #ifdef HAVE_SMTP_AUTHENTICATION
795 # define SMTP_AUTH_FEATURE_STATUS "YES"
796 #else
797 # define SMTP_AUTH_FEATURE_STATUS " NO"
798 #endif
799 #ifdef HAVE_JABBER
800 # define JABBER_FEATURE_STATUS "YES"
801 #else
802 # define JABBER_FEATURE_STATUS " NO"
803 #endif
804 #ifdef HAVE_UNIXODBC
805 # define ODBC_FEATURE_STATUS "YES"
806 #else
807 # define ODBC_FEATURE_STATUS " NO"
808 #endif
809 #ifdef HAVE_SSH2
810 # define SSH2_FEATURE_STATUS "YES"
811 #else
812 # define SSH2_FEATURE_STATUS " NO"
813 #endif
814 #ifdef HAVE_IPV6
815 # define IPV6_FEATURE_STATUS "YES"
816 #else
817 # define IPV6_FEATURE_STATUS " NO"
818 #endif
819 #if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL)
820 # define TLS_FEATURE_STATUS "YES"
821 #else
822 # define TLS_FEATURE_STATUS " NO"
823 #endif
824
825 zabbix_log(LOG_LEVEL_INFORMATION, "Starting Zabbix Server. Zabbix %s (revision %s).",
826 ZABBIX_VERSION, ZABBIX_REVISION);
827
828 zabbix_log(LOG_LEVEL_INFORMATION, "****** Enabled features ******");
829 zabbix_log(LOG_LEVEL_INFORMATION, "SNMP monitoring: " SNMP_FEATURE_STATUS);
830 zabbix_log(LOG_LEVEL_INFORMATION, "IPMI monitoring: " IPMI_FEATURE_STATUS);
831 zabbix_log(LOG_LEVEL_INFORMATION, "Web monitoring: " LIBCURL_FEATURE_STATUS);
832 zabbix_log(LOG_LEVEL_INFORMATION, "VMware monitoring: " VMWARE_FEATURE_STATUS);
833 zabbix_log(LOG_LEVEL_INFORMATION, "SMTP authentication: " SMTP_AUTH_FEATURE_STATUS);
834 zabbix_log(LOG_LEVEL_INFORMATION, "Jabber notifications: " JABBER_FEATURE_STATUS);
835 zabbix_log(LOG_LEVEL_INFORMATION, "Ez Texting notifications: " LIBCURL_FEATURE_STATUS);
836 zabbix_log(LOG_LEVEL_INFORMATION, "ODBC: " ODBC_FEATURE_STATUS);
837 zabbix_log(LOG_LEVEL_INFORMATION, "SSH2 support: " SSH2_FEATURE_STATUS);
838 zabbix_log(LOG_LEVEL_INFORMATION, "IPv6 support: " IPV6_FEATURE_STATUS);
839 zabbix_log(LOG_LEVEL_INFORMATION, "TLS support: " TLS_FEATURE_STATUS);
840 zabbix_log(LOG_LEVEL_INFORMATION, "******************************");
841
842 zabbix_log(LOG_LEVEL_INFORMATION, "using configuration file: %s", CONFIG_FILE);
843
844 #if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL)
845 if (SUCCEED != zbx_coredump_disable())
846 {
847 zabbix_log(LOG_LEVEL_CRIT, "cannot disable core dump, exiting...");
848 exit(EXIT_FAILURE);
849 }
850 #endif
851 if (FAIL == load_modules(CONFIG_LOAD_MODULE_PATH, CONFIG_LOAD_MODULE, CONFIG_TIMEOUT, 1))
852 {
853 zabbix_log(LOG_LEVEL_CRIT, "loading modules failed, exiting...");
854 exit(EXIT_FAILURE);
855 }
856
857 zbx_free_config();
858
859 init_database_cache();
860 init_configuration_cache();
861 init_selfmon_collector();
862
863 /* initialize vmware support */
864 if (0 != CONFIG_VMWARE_FORKS)
865 zbx_vmware_init();
866
867 /* initialize history value cache */
868 zbx_vc_init();
869
870 zbx_create_itservices_lock();
871
872 #ifdef HAVE_SQLITE3
873 zbx_create_sqlite3_mutex();
874 #endif
875
876 if (ZBX_DB_UNKNOWN == (db_type = zbx_db_get_database_type()))
877 {
878 zabbix_log(LOG_LEVEL_ERR, "cannot use database \"%s\": database is not a Zabbix database",
879 CONFIG_DBNAME);
880 exit(EXIT_FAILURE);
881 }
882 else if (ZBX_DB_SERVER != db_type)
883 {
884 zabbix_log(LOG_LEVEL_ERR, "cannot use database \"%s\": its \"users\" table is empty (is this the"
885 " Zabbix proxy database?)", CONFIG_DBNAME);
886 exit(EXIT_FAILURE);
887 }
888
889 if (SUCCEED != DBcheck_version())
890 exit(EXIT_FAILURE);
891
892 DBconnect(ZBX_DB_CONNECT_NORMAL);
893
894 /* make initial configuration sync before worker processes are forked */
895 DCsync_configuration(ZBX_DBSYNC_INIT);
896
897 DBclose();
898
899 threads_num = CONFIG_CONFSYNCER_FORKS + CONFIG_WATCHDOG_FORKS + CONFIG_POLLER_FORKS
900 + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_TRAPPER_FORKS + CONFIG_PINGER_FORKS
901 + CONFIG_ALERTER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_TIMER_FORKS
902 + CONFIG_HTTPPOLLER_FORKS + CONFIG_DISCOVERER_FORKS + CONFIG_HISTSYNCER_FORKS
903 + CONFIG_ESCALATOR_FORKS + CONFIG_IPMIPOLLER_FORKS + CONFIG_JAVAPOLLER_FORKS
904 + CONFIG_SNMPTRAPPER_FORKS + CONFIG_PROXYPOLLER_FORKS + CONFIG_SELFMON_FORKS
905 + CONFIG_VMWARE_FORKS;
906 threads = zbx_calloc(threads, threads_num, sizeof(pid_t));
907
908 if (0 != CONFIG_TRAPPER_FORKS)
909 {
910 if (FAIL == zbx_tcp_listen(&listen_sock, CONFIG_LISTEN_IP, (unsigned short)CONFIG_LISTEN_PORT))
911 {
912 zabbix_log(LOG_LEVEL_CRIT, "listener failed: %s", zbx_socket_strerror());
913 exit(EXIT_FAILURE);
914 }
915 }
916
917 #if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL)
918 zbx_tls_init_parent();
919 #endif
920 zabbix_log(LOG_LEVEL_INFORMATION, "server #0 started [main process]");
921
922 for (i = 0; i < threads_num; i++)
923 {
924 zbx_thread_args_t thread_args;
925 unsigned char poller_type;
926
927 if (FAIL == get_process_info_by_thread(i + 1, &thread_args.process_type, &thread_args.process_num))
928 {
929 THIS_SHOULD_NEVER_HAPPEN;
930 exit(EXIT_FAILURE);
931 }
932
933 thread_args.server_num = i + 1;
934 thread_args.args = NULL;
935
936 switch (thread_args.process_type)
937 {
938 case ZBX_PROCESS_TYPE_CONFSYNCER:
939 zbx_thread_start(dbconfig_thread, &thread_args, &threads[i]);
940 break;
941 case ZBX_PROCESS_TYPE_WATCHDOG:
942 zbx_thread_start(watchdog_thread, &thread_args, &threads[i]);
943 break;
944 case ZBX_PROCESS_TYPE_POLLER:
945 poller_type = ZBX_POLLER_TYPE_NORMAL;
946 thread_args.args = &poller_type;
947 zbx_thread_start(poller_thread, &thread_args, &threads[i]);
948 break;
949 case ZBX_PROCESS_TYPE_UNREACHABLE:
950 poller_type = ZBX_POLLER_TYPE_UNREACHABLE;
951 thread_args.args = &poller_type;
952 zbx_thread_start(poller_thread, &thread_args, &threads[i]);
953 break;
954 case ZBX_PROCESS_TYPE_TRAPPER:
955 thread_args.args = &listen_sock;
956 zbx_thread_start(trapper_thread, &thread_args, &threads[i]);
957 break;
958 case ZBX_PROCESS_TYPE_PINGER:
959 zbx_thread_start(pinger_thread, &thread_args, &threads[i]);
960 break;
961 case ZBX_PROCESS_TYPE_ALERTER:
962 zbx_thread_start(alerter_thread, &thread_args, &threads[i]);
963 break;
964 case ZBX_PROCESS_TYPE_HOUSEKEEPER:
965 zbx_thread_start(housekeeper_thread, &thread_args, &threads[i]);
966 break;
967 case ZBX_PROCESS_TYPE_TIMER:
968 zbx_thread_start(timer_thread, &thread_args, &threads[i]);
969 break;
970 case ZBX_PROCESS_TYPE_HTTPPOLLER:
971 zbx_thread_start(httppoller_thread, &thread_args, &threads[i]);
972 break;
973 case ZBX_PROCESS_TYPE_DISCOVERER:
974 zbx_thread_start(discoverer_thread, &thread_args, &threads[i]);
975 break;
976 case ZBX_PROCESS_TYPE_HISTSYNCER:
977 zbx_thread_start(dbsyncer_thread, &thread_args, &threads[i]);
978 break;
979 case ZBX_PROCESS_TYPE_ESCALATOR:
980 zbx_thread_start(escalator_thread, &thread_args, &threads[i]);
981 break;
982 case ZBX_PROCESS_TYPE_IPMIPOLLER:
983 poller_type = ZBX_POLLER_TYPE_IPMI;
984 thread_args.args = &poller_type;
985 zbx_thread_start(poller_thread, &thread_args, &threads[i]);
986 break;
987 case ZBX_PROCESS_TYPE_JAVAPOLLER:
988 poller_type = ZBX_POLLER_TYPE_JAVA;
989 thread_args.args = &poller_type;
990 zbx_thread_start(poller_thread, &thread_args, &threads[i]);
991 break;
992 case ZBX_PROCESS_TYPE_SNMPTRAPPER:
993 zbx_thread_start(snmptrapper_thread, &thread_args, &threads[i]);
994 break;
995 case ZBX_PROCESS_TYPE_PROXYPOLLER:
996 zbx_thread_start(proxypoller_thread, &thread_args, &threads[i]);
997 break;
998 case ZBX_PROCESS_TYPE_SELFMON:
999 zbx_thread_start(selfmon_thread, &thread_args, &threads[i]);
1000 break;
1001 case ZBX_PROCESS_TYPE_VMWARE:
1002 zbx_thread_start(vmware_thread, &thread_args, &threads[i]);
1003 break;
1004 }
1005 }
1006
1007 while (-1 == wait(&i)) /* wait for any child to exit */
1008 {
1009 if (EINTR != errno)
1010 {
1011 zabbix_log(LOG_LEVEL_ERR, "failed to wait on child processes: %s", zbx_strerror(errno));
1012 break;
1013 }
1014 }
1015
1016 /* all exiting child processes should be caught by signal handlers */
1017 THIS_SHOULD_NEVER_HAPPEN;
1018
1019 zbx_on_exit();
1020
1021 return SUCCEED;
1022 }
1023
zbx_on_exit(void)1024 void zbx_on_exit(void)
1025 {
1026 zabbix_log(LOG_LEVEL_DEBUG, "zbx_on_exit() called");
1027
1028 if (SUCCEED == DBtxn_ongoing())
1029 DBrollback();
1030
1031 if (NULL != threads)
1032 {
1033 int i;
1034 sigset_t set;
1035
1036 /* ignore SIGCHLD signals in order for zbx_sleep() to work */
1037 sigemptyset(&set);
1038 sigaddset(&set, SIGCHLD);
1039 sigprocmask(SIG_BLOCK, &set, NULL);
1040
1041 for (i = 0; i < threads_num; i++)
1042 {
1043 if (threads[i])
1044 {
1045 kill(threads[i], SIGTERM);
1046 threads[i] = ZBX_THREAD_HANDLE_NULL;
1047 }
1048 }
1049
1050 zbx_free(threads);
1051 }
1052
1053 free_metrics();
1054
1055 zbx_sleep(2); /* wait for all child processes to exit */
1056
1057 DBconnect(ZBX_DB_CONNECT_EXIT);
1058
1059 free_database_cache();
1060
1061 DBclose();
1062
1063 free_configuration_cache();
1064
1065 /* free history value cache */
1066 zbx_vc_destroy();
1067
1068 zbx_destroy_itservices_lock();
1069
1070 #ifdef HAVE_OPENIPMI
1071 zbx_free_ipmi_handler();
1072 #endif
1073
1074 #ifdef HAVE_SQLITE3
1075 zbx_remove_sqlite3_mutex();
1076 #endif
1077
1078 /* free vmware support */
1079 if (0 != CONFIG_VMWARE_FORKS)
1080 zbx_vmware_destroy();
1081
1082 free_selfmon_collector();
1083
1084 unload_modules();
1085
1086 zabbix_log(LOG_LEVEL_INFORMATION, "Zabbix Server stopped. Zabbix %s (revision %s).",
1087 ZABBIX_VERSION, ZABBIX_REVISION);
1088
1089 zabbix_close_log();
1090
1091 #if defined(PS_OVERWRITE_ARGV)
1092 setproctitle_free_env();
1093 #endif
1094
1095 exit(EXIT_SUCCESS);
1096 }
1097