ze-filter  (ze-filter-0.8.0-develop-180218)
ze-signal.c
Go to the documentation of this file.
1 
2 /*
3  *
4  * ze-filter - Mail Server Filter for sendmail
5  *
6  * Copyright (c) 2001-2018 - Jose-Marcio Martins da Cruz
7  *
8  * Auteur : Jose Marcio Martins da Cruz
9  * jose.marcio.mc@gmail.org
10  *
11  * Historique :
12  * Creation : janvier 2002
13  *
14  * This program is free software, but with restricted license :
15  *
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
20  *
21  * More details about ze-filter license can be found at ze-filter
22  * web site : http://foss.jose-marcio.org
23  */
24 
25 #include <ze-sys.h>
26 #include <libze.h>
27 
28 #include <libmilter/mfapi.h>
29 
30 #include "ze-filter.h"
31 
32 
33 #define USE_SMFI_STOP 1
34 
35 /* ****************************************************************************
36  * *
37  * *
38  ******************************************************************************/
39 static void do_proc_save();
40 static void do_proc_log();
41 static void do_proc_reset();
42 static void do_proc_exit();
43 static void do_proc_conf();
44 
45 
46 static bool flag_save = FALSE;
47 static bool flag_reset = FALSE;
48 static bool flag_exit = FALSE;
49 static bool flag_log = FALSE;
50 static bool flag_conf = FALSE;
51 
52 static time_t time2exit = 0;
53 
54 
55 /* ****************************************************************************
56  * *
57  * *
58  ******************************************************************************/
59 #define MAX_FAILS_T 16
60 
61 void *
63  void *name;
64 {
65  int sig, errs;
66  sigset_t set;
67 
68  bool done = FALSE;
69 
70  ZE_MessageInfo(10, "*** Starting %s ...", ZE_FUNCTION);
71 
72  memset(&set, 0, sizeof (set));
73  sigemptyset(&set);
74 
75  sigaddset(&set, SIGHUP);
76  sigaddset(&set, SIGTERM);
77  sigaddset(&set, SIGINT);
78  sigaddset(&set, SIGQUIT);
79  sigaddset(&set, SIGUSR1);
80  sigaddset(&set, SIGUSR2);
81  /*
82  * sigaddset(&set, SIGALRM);
83  */
84 
85  sigaddset(&set, SIGSYS);
86  sigaddset(&set, SIGILL);
87  sigaddset(&set, SIGBUS);
88  sigaddset(&set, SIGFPE);
89  sigaddset(&set, SIGSEGV);
90 
91  errs = 0;
92 
93  while (!done) {
94  sig = 0;
95 
96  if (sigwait(&set, &sig) != 0) {
97  if (errno == EINTR)
98  continue;
99  ZE_LogSysError("sigwait");
100  if (++errs > MAX_FAILS_T) {
101  ZE_LogMsgError(0, "sigwait returned too many errors");
102  break;
103  }
104  continue;
105  }
106  errs = 0;
107 
108  ZE_LogMsgInfo(14, " *** Signal %d received", sig);
109  switch (sig) {
110  case SIGHUP:
111  ZE_LogMsgInfo(10, " *** Terminate command received : SIGHUP");
112  done = TRUE;
113  break;
114  case SIGTERM:
115  ZE_LogMsgInfo(10, " *** Terminate command received : SIGTERM");
116  done = TRUE;
117  break;
118  case SIGUSR1:
119  ZE_LogMsgInfo(10, " *** Dump counters command received : SIGUSR1");
120  flag_log = TRUE;
121  flag_save = TRUE;
122  break;
123  case SIGUSR2:
124  ZE_LogMsgInfo(10, " *** Reset counters command received : SIGUSR2");
125  flag_reset = TRUE;
126  break;
127  case SIGALRM:
128  break;
129  case SIGINT:
130  ZE_LogMsgWarning(0, " *** Received signal SIGINT");
131  done = TRUE;
132  break;
133  case SIGQUIT:
134  case SIGBUS:
135  case SIGFPE:
136  case SIGSEGV:
137  case SIGSYS:
138  case SIGILL:
139  case SIGABRT:
140  ZE_LogMsgWarning(0, " *** Received signal %d", sig);
141  done = TRUE;
142  break;
143  default:
144  ZE_LogMsgWarning(0, " *** Undefined behavior defined for signal %d",
145  sig);
146  break;
147  }
148  }
149 
150  flag_exit = TRUE;
151 
152  sleep(3);
153 
154  exit(EX_SOFTWARE);
155 
156  return NULL;
157 }
158 
159 
160 /* ****************************************************************************
161  * *
162  * *
163  ******************************************************************************/
164 bool
166 {
167  pthread_t tid;
168  int r;
169  sigset_t set;
170 
171  ZE_MessageInfo(10, "*** Starting %s ...", ZE_FUNCTION);
172 
173  sigemptyset(&set);
174 
175  sigaddset(&set, SIGHUP);
176  sigaddset(&set, SIGTERM);
177  sigaddset(&set, SIGINT);
178  sigaddset(&set, SIGQUIT);
179  sigaddset(&set, SIGUSR1);
180  sigaddset(&set, SIGUSR2);
181  sigaddset(&set, SIGALRM);
182  sigaddset(&set, SIGABRT);
183 
184  if ((r = pthread_sigmask(SIG_BLOCK, &set, NULL)) != 0) {
185  errno = r;
186  ZE_LogSysError("Couldn't mask signals");
187  }
188 
189  if ((r = pthread_create(&tid, NULL, filter_signal_handler, NULL)) != 0)
190  ZE_LogSysError("Error launching filter_signal_handler");
191 
192  return TRUE;
193 }
194 
195 /* ****************************************************************************
196  * *
197  * *
198  ******************************************************************************/
199 static void
200 do_proc_save()
201 {
202  save_state();
203  smtprate_save_table(NULL);
204  flag_save = FALSE;
205 }
206 
207 static void
208 do_proc_log()
209 {
211  do_proc_save();
212 
213  flag_log = FALSE;
214 }
215 
216 static void
217 do_proc_reset()
218 {
219  reset_state();
220  do_proc_save();
221 
222  flag_reset = FALSE;
223 }
224 
225 static void
226 do_proc_exit()
227 {
228  do_proc_save();
229 
230 #if (USE_SMFI_STOP == 1) && defined(HAVE_SMFI_STOP)
231  if (ze_logLevel > 10)
232  ZE_LogMsgWarning(0, "USING smfi_stop()");
233  smfi_stop();
235 #else
236  if (ze_logLevel > 10)
237  ZE_LogMsgWarning(0, "USING kill(0, SIGTERM)");
239  kill(0, SIGTERM);
240  sleep(2);
241  exit(0);
242 #endif /* USE_SMFI_STOP */
243 
244  flag_exit = FALSE;
245 }
246 
247 static void
248 do_proc_conf()
249 {
250  do_proc_save();
251  kill(getpid(), SIGHUP);
252  flag_conf = FALSE;
253 }
254 
255 /* ****************************************************************************
256  * *
257  * *
258  ******************************************************************************/
259 extern bool log_attached_files_reopen();
260 extern bool log_quarantine_reopen();
261 extern bool log_virus_reopen();
262 extern bool log_regex_reopen();
263 extern bool log_counters_reopen();
264 extern bool reopen_scores4stats_file();
265 
266 bool
268 {
269  bool res = TRUE;
270  bool log_grey_expire_reopen();
271 
272  ZE_MessageInfo(10, "* Reopening all log files");
273 
274  if (!log_attached_files_reopen()) {
275  ZE_LogMsgWarning(0, "Can't reopen ze-files log file");
276  res = FALSE;
277  }
278 
279  if (!log_quarantine_reopen()) {
280  ZE_LogMsgWarning(0, "Can't reopen ze-quarantine log file");
281  res = FALSE;
282  }
283 
284  if (!log_virus_reopen()) {
285  ZE_LogMsgWarning(0, "Can't reopen ze-virus log file");
286  res = FALSE;
287  }
288 
289  if (!log_counters_reopen()) {
290  ZE_LogMsgWarning(0, "Can't reopen ze-stats log file");
291  res = FALSE;
292  }
293 
294  if (!log_regex_reopen()) {
295  ZE_LogMsgWarning(0, "Can't reopen ze-regex log file");
296  res = FALSE;
297  }
298 
299  if (!log_grey_expire_reopen()) {
300  ZE_LogMsgWarning(0, "Can't reopen ze-grey-expire log file");
301  res = FALSE;
302  }
303 
304  {
305  char *env = getenv("DUMP_MESSAGE_SCORE");
306 
307  if (env != NULL && STRCASEEQUAL(env, "yes")) {
308  if (!reopen_scores4stats_file()) {
309  ZE_LogMsgWarning(0, "Can't reopen ze-series log file");
310  res = FALSE;
311  }
312  }
313  }
314  return res;
315 }
316 
317 
318 /* ****************************************************************************
319  * *
320  * *
321  ******************************************************************************/
322 
323 #define DT_LOOP DT_SIGALRM
324 
325 /* save connection rate and resolve raw data */
326 #define DT_SAVE 120
327 
328 /* connection rate and resolve results */
329 #define DT_RATE_UPDATE 300
330 
331 /* server throttle */
332 #define DT_GUPDATE 10
333 
334 /* history update */
335 #define DT_HUPDATE 600
336 
337 /* update counting of file descriptors */
338 #define DT_COUNT_FD 10
339 
340 /* logging server throttle */
341 #define DT_LOG_THROTTLE 60
342 
343 #define MAX_INTR 16
344 
345 /* resource usage check */
346 #define DT_RESOURCE 10
347 #define DIM_LOAD_HISTORY 32
348 
349 static void *
350 periodic_tasks_loop(data)
351  void *data;
352 {
353  char sout[256];
354 
355  time_t t_now, t_last;
356  time_t t_loop, t_save, t_rate_updt, t_stats;
357  time_t t_h_updt, t_gt_updt, t_fd, t_conf;
358  time_t t_log_throttle, t_resource;
359  int msg_ok = 0;
360 
361  int nb_int = 0;
362 
363  int DT_RELOAD = cf_get_int(CF_AUTO_RELOAD_TABLES);
364 
365  pthread_t tid;
366 
367  time_t t_init = time(NULL);
368 
369  int server_idle[DIM_LOAD_HISTORY];
370 
371  time_t t_restart = (time_t) 0;
372 
373  tid = pthread_self();
374  (void) pthread_detach(tid);
375 
376  t_loop = t_save = t_rate_updt = t_stats = 0;
377  t_gt_updt = t_h_updt = t_fd = t_conf = 0;
378  t_log_throttle = t_resource = 0;
379 
380  t_last = t_now = time(NULL);
381 
382 #if 0
383  XXX
384 #ifdef _POSIX_PTHREAD_SEMANTICS
385  ctime_r(&t_now, sout);
386 #else
387  ctime_r(&t_now, sout, sizeof (sout));
388 #endif
389 #endif
390 
391  ZE_MessageInfo(9, "*** Starting %s", ZE_FUNCTION);
392 
393  /*
394  * init server_idle data
395  */
396  {
397  int n;
398 
399  for (n = 0; n < DIM_LOAD_HISTORY; n++)
400  server_idle[n] = 100;
401  }
402 
403  /*
404  * init data from environnement
405  */
406  {
407  char *env = NULL;
408 
409  if ((env = getenv("PERIODIC_AUTO_RESTART")) != NULL) {
410  time_t t;
411 
412  t = zeStr2time(env, NULL, 3600);
413  if (t > 1 HOURS)
414  t_restart = t;
415  }
416  }
417 
418  for (;;) {
419  time_t dt;
420 
421  ZE_MessageInfo(15, " Looping...");
422 
423 #if defined(OS_LINUX)
424  if (getppid() == 1)
425  break;
426 #endif
427 
428  t_last = t_now;
429  sleep(DT_LOOP);
430  t_now = time(NULL);
431 
432  if ((time2exit != 0) && ((t_now - time2exit) > 5)) {
434  "why system continues to run ? Surely one Linux box...");
436  kill(0, SIGTERM);
437  sleep(1);
438  exit(0);
439  }
440 
441  if (t_now < (t_last + DT_LOOP)) {
442  nb_int++;
443  if ((nb_int > MAX_INTR) && ((nb_int % MAX_INTR) == 0))
444  ZE_LogMsgWarning(0, "Too many interrupts : %d", nb_int);
445  continue;
446  }
447  nb_int = 0;
448 
449  dt = t_now - t_last;
450 
451  t_loop += dt;
452  t_save += dt;
453  t_rate_updt += dt;
454  t_gt_updt += dt;
455  t_h_updt += dt;
456  t_stats += dt;
457  t_fd += dt;
458  t_conf += dt;
459  t_log_throttle += dt;
460  t_resource += dt;
461 
462  if (ze_logLevel >= 15) {
463  memset(sout, 0, sizeof (sout));
464 #ifdef _POSIX_PTHREAD_SEMANTICS
465  ctime_r(&t_now, sout);
466 #else
467  ctime_r(&t_now, sout, sizeof (sout));
468 #endif
469  ZE_LogMsgInfo(15, "t_now = %s", sout);
470  }
471 
472  if (flag_conf) {
473  do_proc_conf();
474  }
475 
476  if (flag_log) {
477  do_proc_log();
478  t_stats = 0;
479  }
480 
481  if (flag_save || ((DT_SAVE > 0) && (t_save >= DT_SAVE))) {
482  do_proc_save();
483  t_save = 0;
484  }
485 
486  if (flag_reset) {
487  do_proc_reset();
488  }
489 
490  if (flag_exit) {
491  do_proc_exit();
492  t_save = 0;
493 
494  break;
495  }
496 
497  if (0) {
498  int msg = rand() % 32;
499  static int nb = 0;
500 
501  msg = MSG_OK;
502  if (TRUE || ((nb++ % 5) == 0)) {
503  ZE_MessageInfo(15, "Will send %4d to the father on fd = %2d", msg,
504  fd_pipe);
505  ZE_MessageInfo(15, "Child : pipe = %d %d", pipe_filter[0],
506  pipe_filter[1]);
507  }
508 
509  if (!send_message_pipe(fd_pipe, msg))
510  ZE_LogMsgError(0, "Error sending message to the father...");
511  }
512 
513  if ((statistics_interval > 0) && (t_stats >= statistics_interval)) {
514  do_proc_log();
516  t_stats = 0;
517  }
518 
519  if ((DT_LOG_THROTTLE > 0) && (t_log_throttle >= DT_LOG_THROTTLE)) {
521  t_log_throttle = 0;
522  }
523 
524  if ((DT_RELOAD > 0) && (t_conf >= DT_RELOAD)) {
526 
527  t_conf = 0;
528  }
529 
530  if ((DT_COUNT_FD > 0) && (t_fd >= DT_COUNT_FD)) {
531  int nb = count_file_descriptors();
532 
534  ZE_MessageInfo(13, "%08lX: Nb of open files : %d", t_now, nb);
535  t_fd = 0;
536  }
537 
538  if ((DT_RESOURCE > 0) && (t_resource >= DT_RESOURCE)) {
539  bool ok = TRUE;
540  int n, i;
541  int idle, mean_idle = 0;
542  int min_idle = 0;
543 
544  ZE_MessageInfo(11, "Checking resources level...");
545 
546 #if 0
547  ok = check_rusage();
548  if (!ok) {
549 
550  }
551 #endif
552 
553  /*
554  * update cpu load history
555  */
556  {
557  char *env = getenv("HIGH_LOAD_AUTO_RESTART");
558 
559  if (env != NULL) {
560  int max_load = 100;
561 
562  max_load = zeStr2long(env, NULL, 100);
563  if (errno == ERANGE)
564  max_load = 100;
565  if (max_load < 50 || max_load > 100)
566  max_load = 100;
567 
568  min_idle = 100 - max_load;
569  }
570  }
571 
572  n = (t_now / DT_RESOURCE) % DIM_LOAD_HISTORY;
573  server_idle[n] = idle = get_cpu_load_info(JCPU_IDLE);
574 
575  ZE_MessageInfo(11, " CPU LOAD (IDLE) : %d", idle);
576 
577  n = 0;
578  for (i = 0; i < DIM_LOAD_HISTORY; i++) {
579  mean_idle += server_idle[i];
580  if (server_idle[i] < min_idle)
581  n++;
582  }
583  mean_idle /= DIM_LOAD_HISTORY;
584 
585  /*
586  * check if overloaded all time...
587  */
588  if (min_idle > 0 && n == DIM_LOAD_HISTORY) {
589  ZE_MessageWarning(9, " Server Load too high - Restarting");
590  exit(EX_SOFTWARE);
591  }
592 
593  /*
594  * check auto restart
595  */
596  if (t_restart > 1 HOURS && t_init + t_restart < t_now) {
597  ZE_MessageWarning(9, " Auto restarting after %ld",
598  (long) (t_now - t_init));
599  exit(EX_SOFTWARE);
600  }
601 
602  t_resource = 0;
603  }
604 
605  if ((DT_RATE_UPDATE > 0) && (t_rate_updt >= DT_RATE_UPDATE)) {
606  ZE_LogMsgInfo(11, "DT_RATE_UPDATE...");
607 
608  ZE_LogMsgInfo(11, "Cleaning up smtprate table...");
609  (void) smtprate_cleanup_table(t_now, 20 MINUTES);
610 
611  if (ze_logLevel > 15)
613  t_rate_updt = 0;
614  }
615 
616  if ((DT_GUPDATE > 0) && (t_gt_updt >= DT_GUPDATE)) {
617  update_throttle(t_now);
619  t_gt_updt = 0;
620  }
621 
622  if ((DT_HUPDATE > 0) && (t_h_updt >= DT_HUPDATE)) {
623 #if 0
624  res_history_update(NULL, NULL, t_now, 600);
625 #endif
626  t_h_updt = 0;
627  }
628 
629  if (1) {
630  int nb = 0;
631  int msg;
632 
633  nb = 0;
634  while (!recv_msg_channel(pipe_filter, &msg, CHAN_CHILD)) {
635  nb++;
636  msg_ok = 0;
637  ZE_LogMsgDebug(20, "FILTER - MSG RECV : %d", msg);
638  switch (msg) {
639  case MSG_OK:
640  break;
641  case MSG_TERM:
642  if (!flag_exit)
643  ZE_LogMsgWarning(0, "SUPERVISOR said : QUIT !");
644  flag_exit = TRUE;
645 #if (USE_SMFI_STOP == 1) && defined(HAVE_SMFI_STOP)
646  smfi_stop();
647 #else
648  kill(0, SIGTERM);
649 #endif
650  if (time2exit == 0)
651  time2exit = time(NULL);
652  break;
653  case MSG_CONF:
654  flag_conf = TRUE;
655  break;
656  case MSG_RESET:
657  ZE_MessageWarning(9, " *** Reset state command received");
658  flag_reset = TRUE;
659  break;
660  case MSG_DUMP:
661  flag_log = TRUE;
662  ZE_MessageWarning(9, " *** Dump state command received");
663  break;
664  default:
665  ;
666  }
667  }
668  if (nb == 0) {
669  msg_ok++;
670  ZE_LogMsgDebug(15, "FILTER - MSG RECV : NULL : %d", msg_ok);
671  }
672 
673  if (!flag_exit && ((msg_ok > 4) || (getppid() == 1))) {
674  if (!flag_exit)
675  ZE_LogMsgWarning(0, "FILTER - SUPERVISOR DIED ???");
676  flag_exit = TRUE;
677  save_state();
678  smtprate_save_table(NULL);
679 #if (USE_SMFI_STOP == 1) && defined(HAVE_SMFI_STOP)
680  smfi_stop();
681 #else
682  kill(0, SIGTERM);
683 #endif /* USE_SMFI_STOP */
684  if (time2exit == 0)
685  time2exit = time(NULL);
686 
687  sleep(1);
688  exit(1);
689  }
690  }
691  }
692  return NULL;
693 }
694 
695 /* ****************************************************************************
696  * *
697  * *
698  ******************************************************************************/
699 
700 #if _PERIODIC_DEBUG
701 static void *periodic_tasks_debug(void *);
702 #endif
703 
704 void
706 {
707  pthread_t tid;
708  int r;
709 
710  ZE_MessageInfo(9, "*** Starting %s ...", ZE_FUNCTION);
711  ZE_MessageInfo(9, " Tables will be updated by thread");
712 
713  if ((r = pthread_create(&tid, NULL, periodic_tasks_loop, (void *) NULL)) != 0)
714  ZE_LogSysError("Couldn't launch periodic_tasks_loop");
715 
716 #if _PERIODIC_DEBUG
717  if ((r =
718  pthread_create(&tid, NULL, periodic_tasks_debug, (void *) NULL)) != 0)
719  ZE_LogSysError("Couldn't launch periodic_tasks_debug");
720 #endif
721 
722  (void) cpuload_start();
723 }
724 
725 /* ****************************************************************************
726  * *
727  * *
728  ******************************************************************************/
729 void
731 {
732  char *sock_file;
733 
734  sock_file = milter_sock_file;
735 
736  if ((sock_file == NULL) || (strlen(sock_file) == 0))
737  return;
738 
739  if (strncasecmp(sock_file, "unix:", strlen("unix:")) == 0) {
740  sock_file += strlen("unix:");
741  } else {
742  if (strncasecmp(sock_file, "local:", strlen("local:")) == 0)
743  sock_file += strlen("local:");
744  }
745 
746  if ((sock_file != NULL) && strlen(sock_file) > 0 && *sock_file == '/') {
747  struct stat buf;
748 
749  if (lstat(sock_file, &buf) == 0) {
750  ZE_MessageWarning(9, "Removing SOCK_FILE : %s", sock_file);
751  remove(sock_file);
752  }
753  }
754 }
755 
756 /* ****************************************************************************
757  * *
758  * *
759  ******************************************************************************/
760 #define DT_DEBUG 1
761 
762 #if _PERIODIC_DEBUG
763 
764 static void *
765 periodic_tasks_debug(data)
766  void *data;
767 {
768  for (;;) {
769  int n[4], i, j;
770  char ip[32], name[64];
771 
772  ZE_MessageInfo(19, "Debugging... %ld", time(NULL));
773 
774  for (j = 0; j < (3 * DT_DEBUG); j++) {
775 
776  for (i = 0; i < 4; i++)
777  n[i] = 1 + (rand() % 64);
778 
779  n[0] = 10;
780  n[1] = 10;
781 
782  snprintf(ip, sizeof (ip), "%d.%d.%d.%d", n[0], n[1], n[2], n[3]);
783  snprintf(name, sizeof (name), "%d.%d.%d.%d.jose-marcio.org", n[0], n[1], n[2],
784  n[3]);
785 
786  ZE_MessageInfo(19, "Adding ... %-20s %s", ip, name);
787  (void) connopen_check_host(ip, name, 1);
788 
789  }
790  for (j = 0; j < (3 * DT_DEBUG); j++) {
791 
792  for (i = 0; i < 4; i++)
793  n[i] = 1 + (rand() % 64);
794 
795  n[0] = 10;
796  n[1] = 10;
797 
798  snprintf(ip, sizeof (ip), "%d.%d.%d.%d", n[0], n[1], n[2], n[3]);
799  snprintf(name, sizeof (name), "%d.%d.%d.%d.jose-marcio.org", n[0], n[1], n[2],
800  n[3]);
801 
802  ZE_MessageInfo(19, "Removing ... %-20s %s", ip, name);
803  (void) connopen_check_host(ip, name, -1);
804 
805  }
806 
807  smtprate_add_entry(RATE_CONN, ip, 1, time(NULL));
808 
809  sleep(DT_DEBUG);
810 
811  if (0)
812  break;
813  }
814 
815  return NULL;
816 }
817 
818 #endif
819 
820 /* ****************************************************************************
821  * *
822  * *
823  ******************************************************************************/
824 static uint32_t live = 0;
825 void
827  uint32_t which;
828 {
829  if (which == LIFESIGN_CLEAR)
830  live = 0;
831  else
832  live |= which;
833 }
bool setup_filter_signal_handler()
Definition: ze-signal.c:165
int pipe_filter[2]
Definition: ze-main.c:359
int smtprate_add_entry(int, char *, char *, int, time_t)
Definition: ze-smtprate.c:363
bool log_counters_reopen()
Definition: ze-stats.c:324
void remove_milter_unix_sock(void)
Definition: ze-signal.c:730
#define MSG_TERM
Definition: ze-main.h:31
void log_throttle_stats(void)
Definition: ze-throttle.c:313
int count_file_descriptors(void)
Definition: ze-resource.c:79
bool log_attached_files_reopen()
Definition: ze-log-files.c:45
#define DT_SAVE
Definition: ze-signal.c:326
#define ZE_FUNCTION
Definition: ze-sys.h:471
double get_cpu_load_info(int)
Definition: ze-load.c:753
int recv_msg_channel(int[], int *, int)
#define DT_RATE_UPDATE
Definition: ze-signal.c:329
bool check_rusage()
Definition: ze-resource.c:369
bool log_grey_expire_reopen()
Definition: ze-log-grey.c:48
#define JCPU_IDLE
Definition: ze-load.h:33
int ze_logLevel
Definition: zeSyslog.c:34
bool reopen_scores4stats_file()
bool ok
Definition: ze-connopen.c:59
bool res_history_update(History_T *, char *, time_t, time_t, bool)
Definition: ze-history.c:631
#define ZE_LogMsgInfo(level,...)
Definition: zeSyslog.h:110
bool smtprate_cleanup_table(time_t now, time_t win)
Definition: ze-smtprate.c:552
#define LIFESIGN_CLEAR
Definition: ze-signal.h:33
#define FALSE
Definition: macros.h:160
#define ZE_LogMsgError(level,...)
Definition: zeSyslog.h:113
void log_counters(int, bool)
Definition: ze-stats.c:330
bool log_quarantine_reopen()
bool reopen_all_log_files()
Definition: ze-signal.c:267
char * milter_sock_file
#define MAX_INTR
Definition: ze-signal.c:343
void save_state()
Definition: ze-stats.c:430
int cf_get_int(int id)
Definition: ze-cf.c:803
#define DIM_LOAD_HISTORY
Definition: ze-signal.c:347
#define DT_GUPDATE
Definition: ze-signal.c:332
#define DT_RESOURCE
Definition: ze-signal.c:346
#define DT_DEBUG
Definition: ze-signal.c:760
long zeStr2long(char *s, int *error, long dval)
Definition: zeStrConvert.c:35
#define MSG_RESET
Definition: ze-main.h:33
bool check_throttle_dos(void)
Definition: ze-throttle.c:239
bool log_virus_reopen()
Definition: ze-log-virus.c:45
bool cpuload_start(void)
Definition: ze-load.c:846
#define CF_AUTO_RELOAD_TABLES
Definition: cfh-defs.h:53
#define ZE_LogMsgDebug(level,...)
Definition: zeSyslog.h:109
#define DT_COUNT_FD
Definition: ze-signal.c:338
#define DT_HUPDATE
Definition: ze-signal.c:335
#define ZE_MessageInfo(level,...)
Definition: zeSyslog.h:90
#define MSG_OK
Definition: ze-main.h:30
int nb
Definition: ze-connopen.c:61
#define TRUE
Definition: macros.h:157
#define ZE_MessageWarning(level,...)
Definition: zeSyslog.h:92
int check_file_descriptors(void)
Definition: ze-resource.c:189
#define CHAN_CHILD
Definition: ze-ipc.h:28
#define DT_LOOP
Definition: ze-signal.c:323
#define MSG_CONF
Definition: ze-main.h:32
#define ZE_LogSysError(...)
Definition: zeSyslog.h:129
void remove_milter_sock()
void * filter_signal_handler(void *name)
Definition: ze-signal.c:62
bool log_regex_reopen()
Definition: ze-log-regex.c:52
#define DT_LOG_THROTTLE
Definition: ze-signal.c:341
void launch_periodic_tasks_thread()
Definition: ze-signal.c:705
#define MAX_FAILS_T
Definition: ze-signal.c:59
void reset_state()
Definition: ze-stats.c:528
#define ZE_LogMsgWarning(level,...)
Definition: zeSyslog.h:112
int connopen_check_host(char *, char *, int)
Definition: ze-connopen.c:151
bool send_message_pipe(int, int)
Definition: ze-ipc.c:126
void update_throttle(time_t)
Definition: ze-throttle.c:186
int fd_pipe
Definition: ze-main.c:360
void smtprate_save_table(char *)
Definition: ze-smtprate.c:737
#define MINUTES
Definition: macros.h:143
#define HOURS
Definition: macros.h:144
#define CF_DUMP_COUNTERS
Definition: cfh-defs.h:63
#define STRCASEEQUAL(a, b)
Definition: macros.h:72
#define MSG_DUMP
Definition: ze-main.h:34
bool oracle_dump_counters(int, bool)
void smtprate_log_table()
Definition: ze-smtprate.c:860
void lifetime_set(uint32_t which)
Definition: ze-signal.c:826
void reload_cf_tables()
Definition: ze-cf.c:1066
unsigned int statistics_interval
Definition: ze-cf.c:40
long uint32_t
Definition: ze-sys.h:489
int msg[MAX_SCORE+2]
Definition: ze-stats.c:41
time_t zeStr2time(char *s, int *error, time_t dval)
Definition: zeStrConvert.c:291
#define RATE_CONN
Definition: ze-smtprate.h:51