ze-filter  (ze-filter-0.8.0-develop-180218)
ze-stats.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 
27 #include "ze-filter.h"
28 
29 /* ****************************************************************************
30  * *
31  * SCORE STATS *
32  **************************************************************************** */
33 #define MAX_SCORE 32
34 #define STATE_FILE "ze-state"
35 
36 static struct {
37  int nb;
38  pthread_mutex_t mutex;
39  int ora[MAX_SCORE + 2];
40  int reg[MAX_SCORE + 2];
41  int msg[MAX_SCORE + 2];
42  int bay[MAX_SCORE + 2];
43 } msg_score = {
44 0, PTHREAD_MUTEX_INITIALIZER};
45 
46 
47 #define SCORE_LOCK() MUTEX_LOCK(&msg_score.mutex)
48 #define SCORE_UNLOCK() MUTEX_UNLOCK(&msg_score.mutex)
49 
50 
51 void
53  msg_scores_T *scores;
54 {
55  int msg_sc;
56  int reg_sc;
57  int ora_sc;
58  double bay_sc;
59 
60  if (scores == NULL)
61  return;
62 
63  reg_sc = scores->body + scores->headers + scores->urlbl;
64  ora_sc = scores->oracle;
65  bay_sc = scores->bayes;
66  msg_sc = reg_sc + ora_sc;
67 
68  SCORE_LOCK();
69 
70  if (msg_score.nb == 0) {
71  memset(msg_score.ora, 0, sizeof (msg_score.ora));
72  memset(msg_score.reg, 0, sizeof (msg_score.reg));
73  memset(msg_score.msg, 0, sizeof (msg_score.msg));
74  memset(msg_score.bay, 0, sizeof (msg_score.bay));
75  }
76 
77  if (msg_sc >= 0 || bay_sc >= 0.75) {
78  int x;
79 
80  /*
81  *** JOE XXX */
82  x = bay_sc * MAX_SCORE;
83  if (x < 0)
84  x = 0;
85 
86  if (bay_sc <= MAX_SCORE)
87  msg_score.bay[x]++;
88  else
89  msg_score.bay[MAX_SCORE + 1]++;
90 
91  if (msg_sc <= MAX_SCORE)
92  msg_score.msg[msg_sc]++;
93  else
94  msg_score.msg[MAX_SCORE + 1]++;
95 
96  if (ora_sc <= MAX_SCORE)
97  msg_score.ora[ora_sc]++;
98  else
99  msg_score.ora[MAX_SCORE + 1]++;
100 
101  if (reg_sc <= MAX_SCORE)
102  msg_score.reg[reg_sc]++;
103  else
104  msg_score.reg[MAX_SCORE + 1]++;
105 
106  msg_score.nb++;
107  }
108 
109  SCORE_UNLOCK();
110 }
111 
112 
113 /* ****************************************************************************
114  * *
115  * *
116  **************************************************************************** */
117 void
119  int fd;
120  int which;
121 {
122  if (fd >= 0) {
123  int i = 0, j;
124  int cnt = 0;
125  int max = 0;
126  int sum = 0;
127  char sout[65];
128  int v;
129 
130  SCORE_LOCK();
131 
132  for (i = 0; i < MAX_SCORE + 2; i++) {
133  v = 0;
134  switch (which) {
135  case 0:
136  v = msg_score.msg[i];
137  break;
138  case 1:
139  v = msg_score.reg[i];
140  break;
141  case 2:
142  v = msg_score.ora[i];
143  break;
144  case 3:
145  v = msg_score.bay[i];
146  break;
147  }
148  cnt += v;
149  if (v > max)
150  max = v;
151  }
152 
153  if (cnt > 0) {
154  FD_PRINTF(fd, "\nMESSAGES : %7d\n", cnt);
155 
156  FD_PRINTF(fd, "\n");
157  sum = 0;
158  for (i = 0; i < MAX_SCORE + 2; i++) {
159  v = 0;
160  switch (which) {
161  case 0:
162  v = msg_score.msg[i];
163  break;
164  case 1:
165  v = msg_score.reg[i];
166  break;
167  case 2:
168  v = msg_score.ora[i];
169  break;
170  case 3:
171  v = msg_score.bay[i];
172  break;
173  default:
174  v = 0;
175  break;
176  }
177 
178  sum += v;
179  memset(sout, 0, sizeof (sout));
180  memset(sout, ' ', 51);
181 
182  memset(sout, '.', (50 * sum) / cnt);
183  for (j = 0; j < 51; j += 10)
184  sout[j] = '|';
185 
186  sout[(50 * sum) / cnt] = 'X';
187  FD_PRINTF(fd, " %4d : %7d %s\n", i, v, sout);
188  }
189  FD_PRINTF(fd, "\n");
190  }
191 
192  SCORE_UNLOCK();
193  }
194 }
195 
196 /* ****************************************************************************
197  * *
198  * *
199  **************************************************************************** */
200 static j_stats_T m_stats;
201 
202 static pthread_mutex_t st_mutex = PTHREAD_MUTEX_INITIALIZER;
203 
204 #define STATS_LOCK() MUTEX_LOCK(&st_mutex)
205 #define STATS_UNLOCK() MUTEX_UNLOCK(&st_mutex)
206 
207 /* ****************************************************************************
208  * *
209  * *
210  **************************************************************************** */
211 static bool
212 fill_counters_buffer(buf, bufsz)
213  char *buf;
214  size_t bufsz;
215 {
216  char str[256];
217  time_t now = time(NULL);
218 
219  if (buf == NULL)
220  return FALSE;
221 
222  memset(str, 0, sizeof (str));
223 
224  snprintf(str, sizeof (str), "%12lld ", (long long) now);
225  strlcat(buf, str, bufsz);
226  snprintf(str, sizeof (str), "RESTART=(%lld) ",
227  (long long) m_stats.glob.value[STAT_RESTART]);
228  strlcat(buf, str, bufsz);
229  snprintf(str, sizeof (str), "CONN=(%lld) ",
230  (long long) m_stats.glob.value[STAT_CONNECT]);
231  strlcat(buf, str, bufsz);
232  snprintf(str, sizeof (str), "ABRT=(%lld) ",
233  (long long) m_stats.glob.value[STAT_ABORT]);
234  strlcat(buf, str, bufsz);
235  snprintf(str, sizeof (str), "MSGS=(%lld) ",
236  (long long) m_stats.glob.value[STAT_MSGS]);
237  strlcat(buf, str, bufsz);
238  snprintf(str, sizeof (str), "KBYTES=(%lld) ",
239  ((unsigned long long) (m_stats.glob.value[STAT_BYTES]) >> 4));
240  strlcat(buf, str, bufsz);
241  snprintf(str, sizeof (str), "RCPT=(%lld) ",
242  (long long) m_stats.glob.value[STAT_ENVTO]);
243  strlcat(buf, str, bufsz);
244  snprintf(str, sizeof (str), "FILES=(%lld) ",
245  (long long) m_stats.glob.value[STAT_FILES]);
246  strlcat(buf, str, bufsz);
247  snprintf(str, sizeof (str), "XFILES=(%lld) ",
248  (long long) m_stats.glob.value[STAT_XFILES]);
249  strlcat(buf, str, bufsz);
250  snprintf(str, sizeof (str), "RCPTRATE=(%lld) ",
251  (long long) m_stats.glob.value[STAT_RCPT_RATE]);
252  strlcat(buf, str, bufsz);
253  snprintf(str, sizeof (str), "THROTTLE=(%lld) ",
254  (long long) m_stats.glob.value[STAT_CONN_RATE]);
255  strlcat(buf, str, bufsz);
256  snprintf(str, sizeof (str), "OPENCONN=(%lld) ",
257  (long long) m_stats.glob.value[STAT_OPEN_CONN]);
258  strlcat(buf, str, bufsz);
259  snprintf(str, sizeof (str), "BADRCPT=(%lld) ",
260  (long long) m_stats.glob.value[STAT_BAD_RCPT]);
261  strlcat(buf, str, bufsz);
262  snprintf(str, sizeof (str), "SPAMTRAP=(%lld) ",
263  (long long) m_stats.glob.value[STAT_RCPT_SPAMTRAP]);
264  strlcat(buf, str, bufsz);
265  snprintf(str, sizeof (str), "LOCALUSER=(%lld) ",
266  (long long) m_stats.glob.value[STAT_LUSERS]);
267  strlcat(buf, str, bufsz);
268  snprintf(str, sizeof (str), "RESFAIL=(%lld) ",
269  (long long) m_stats.glob.value[STAT_RESOLVE_FAIL]);
270  strlcat(buf, str, bufsz);
271  snprintf(str, sizeof (str), "RESFORG=(%lld) ",
272  (long long) m_stats.glob.value[STAT_RESOLVE_FORGED]);
273  strlcat(buf, str, bufsz);
274  snprintf(str, sizeof (str), "MATCHING=(%lld) ",
275  (long long) m_stats.glob.value[STAT_PATTERN_MATCHING]);
276  strlcat(buf, str, bufsz);
277  snprintf(str, sizeof (str), "ORACLE=(%lld) ",
278  (long long) m_stats.glob.value[STAT_ORACLE]);
279  strlcat(buf, str, bufsz);
280  snprintf(str, sizeof (str), "URLBL=(%lld) ",
281  (long long) m_stats.glob.value[STAT_URLBL]);
282  strlcat(buf, str, bufsz);
283  snprintf(str, sizeof (str), "BAYESSPAM=(%lld) ",
284  (long long) m_stats.glob.value[STAT_BAYES_SPAM]);
285  strlcat(buf, str, bufsz);
286  snprintf(str, sizeof (str), "BAYESHAM=(%lld) ",
287  (long long) m_stats.glob.value[STAT_BAYES_HAM]);
288  strlcat(buf, str, bufsz);
290  snprintf(str, sizeof (str), "VIRUS=(%lld) ",
291  (long long) m_stats.glob.value[STAT_VIRUS]);
292  strlcat(buf, str, bufsz);
293  snprintf(str, sizeof (str), "POLICY=(%lld) ",
294  (long long) m_stats.glob.value[STAT_POLICY]);
295  strlcat(buf, str, bufsz);
296  }
297  if (m_stats.glob.value[STAT_BADMX] > 0) {
298  snprintf(str, sizeof (str), "BADMX=(%lld) ",
299  (long long) m_stats.glob.value[STAT_BADMX]);
300  strlcat(buf, str, bufsz);
301  }
302  if (m_stats.glob.value[STAT_GREY_MSGS] > 0) {
303  snprintf(str, sizeof (str), "GREYMSGS=(%lld) ",
304  (long long) m_stats.glob.value[STAT_GREY_MSGS]);
305  strlcat(buf, str, bufsz);
306  }
307  if (m_stats.glob.value[STAT_GREY_RCPT] > 0) {
308  snprintf(str, sizeof (str), "GREYRCPT=(%lld) ",
309  (long long) m_stats.glob.value[STAT_GREY_RCPT]);
310  strlcat(buf, str, bufsz);
311  }
312  strlcat(buf, "\n", bufsz);
313 
314  return TRUE;
315 }
316 
317 /* ****************************************************************************
318  * *
319  * *
320  **************************************************************************** */
321 static LOG_T st_log = LOG_INITIALIZER;
322 
323 bool
325 {
326  return log_reopen(&st_log);
327 }
328 
329 void
330 log_counters(fd, dump)
331  int fd;
332  bool dump;
333 {
334  time_t now = time(NULL);
335 
336  char *fname = cf_get_str(CF_STATS_FILE);
337  char path[1024];
338  char *wkdir = NULL;
339 
340  if (fd >= 0) {
341  char buf[2048];
342 
343  memset(buf, 0, sizeof (buf));
344  snprintf(buf, sizeof (buf), "DATA ");
345  if (fill_counters_buffer(buf, sizeof (buf)))
346  FD_PRINTF(fd, "%s", buf);
347 
348  return;
349  }
350 
351  if (fd < 0) {
352  wkdir = cf_get_str(CF_WORKDIR);
353  if (wkdir == NULL || strlen(wkdir) == 0)
354  wkdir = ZE_WORKDIR;
355 
356  fname = cf_get_str(CF_STATS_FILE);
357 
358  ADJUST_LOG_NAME(path, fname, wkdir, "none:");
359 
360  if (strlen(path) == 0) {
361  ZE_LogMsgError(0, "undefined state file");
362  return;
363  }
364 
365  if (log_check_and_open(&st_log, path)) {
366  char buf[2048];
367 
368  memset(buf, 0, sizeof (buf));
369  if (fill_counters_buffer(buf, sizeof (buf)))
370  log_write(&st_log, buf);
371  }
372  return;
373  }
374 }
375 
376 /* ****************************************************************************
377  * *
378  * *
379  **************************************************************************** */
380 void
382 {
383  time_t now = time(NULL);
384 
385  STATS_LOCK();
386 
387  memset(&m_stats, 0, sizeof (m_stats));
388  strlcpy(m_stats.version, VERSION, sizeof (m_stats.version));
389 
390  m_stats.glob.start = now;
391  m_stats.proc.start = now;
392 
393  STATS_UNLOCK();
394 }
395 
396 /* ****************************************************************************
397  * *
398  * *
399  **************************************************************************** */
400 void
401 stats_inc(which, n)
402  int which;
403  long n;
404 {
405 
406  if (which < 0 || which > DIM_STATS)
407  return;
408 
409  STATS_LOCK();
410 
411  switch (which) {
412  case STAT_BYTES:
413  m_stats.glob.value[STAT_BYTES] += (n >> 6);
414  m_stats.proc.value[STAT_BYTES] += (n >> 6);
415  break;
416  default:
417  m_stats.glob.value[which] += n;
418  m_stats.proc.value[which] += n;
419  break;
420  }
421 
422  STATS_UNLOCK();
423 }
424 
425 /* ****************************************************************************
426  * *
427  * *
428  **************************************************************************** */
429 void
431 {
432  int fd;
433  time_t now = time(NULL);
434  char *fname = STATE_FILE;
435 
436  char path[1024];
437  char *wkdir = NULL;
438 
439  wkdir = cf_get_str(CF_WORKDIR);
440  if (wkdir == NULL || strlen(wkdir) == 0)
441  wkdir = ZE_WORKDIR;
442 
443  ADJUST_FILENAME(path, fname, wkdir, STATE_FILE);
444 
445  if (strlen(path) == 0) {
446  ZE_LogMsgError(0, "undefined state file");
447  return;
448  }
449 
450  if ((fd = open(path, O_WRONLY | O_CREAT, 00644)) >= 0) {
451  STATS_LOCK();
452  m_stats.last_save = now;
453  STATS_UNLOCK();
454 
455  if (write(fd, &m_stats, sizeof (m_stats)) != sizeof (m_stats))
456  ZE_LogSysError("error writing %s file", STRNULL(path, "NULL"));
457  close(fd);
458  } else
459  ZE_LogSysError("error opening %s file", STRNULL(path, "NULL"));
460 }
461 
462 /* ****************************************************************************
463  * *
464  * *
465  **************************************************************************** */
466 void
468 {
469  int fd;
470 
471  char *fname = STATE_FILE;
472 
473  char path[1024];
474  char *wkdir = NULL;
475 
476  wkdir = cf_get_str(CF_WORKDIR);
477  if (wkdir == NULL || strlen(wkdir) == 0)
478  wkdir = ZE_WORKDIR;
479 
480  ADJUST_FILENAME(path, fname, wkdir, STATE_FILE);
481 
482  if (strlen(path) == 0) {
483  ZE_LogMsgError(0, "undefined state file");
484  return;
485  }
486 
487  if ((fd = open(path, O_RDONLY)) >= 0) {
488  STATS_LOCK();
489  if (read(fd, &m_stats, sizeof (m_stats)) != sizeof (m_stats))
490  ZE_LogSysError("error reading %s file", STRNULL(path, "NULL"));
491  STATS_UNLOCK();
492  close(fd);
493  } else
494  ZE_LogSysError("error opening %s file", STRNULL(path, "NULL"));
495 }
496 
497 /* ****************************************************************************
498  * *
499  * *
500  **************************************************************************** */
501 void
503 {
504  time_t now = time(NULL);
505 
506  read_state();
507  /*
508  * save_state ();
509  */
510 
511  STATS_LOCK();
512 
513  memset(&m_stats.proc, 0, sizeof (m_stats.proc));
514  m_stats.proc.start = now;
515  if (m_stats.glob.start == 0)
516  m_stats.glob.start = now;
517 
518  STATS_UNLOCK();
519 
520  save_state();
521 }
522 
523 /* ****************************************************************************
524  * *
525  * *
526  **************************************************************************** */
527 void
529 {
530  time_t now = time(NULL);
531 
532  STATS_LOCK();
533 
534  memset(&m_stats, 0, sizeof (m_stats));
535 
536  strlcpy(m_stats.version, VERSION, sizeof (m_stats.version));
537  m_stats.glob.start = now;
538  m_stats.proc.start = now;
539 
540  STATS_UNLOCK();
541 }
542 
543 /* ****************************************************************************
544  * *
545  * *
546  **************************************************************************** */
547 int
549  int ofd;
550 {
551  int fd;
552  j_stats_T st;
553 
554  char *fname = STATE_FILE;
555 
556  char path[1024];
557  char *wkdir = NULL;
558 
559  wkdir = cf_get_str(CF_WORKDIR);
560  if (wkdir == NULL || strlen(wkdir) == 0)
561  wkdir = ZE_WORKDIR;
562 
563  ADJUST_FILENAME(path, fname, wkdir, STATE_FILE);
564 
565  if (strlen(path) == 0) {
566  ZE_LogMsgError(0, "undefined state file");
567  return 1;
568  }
569 
570  if (ofd < 0)
571  ofd = STDOUT_FILENO;
572 
573  if ((fd = open(path, O_RDONLY)) >= 0) {
574  if (read(fd, &st, sizeof (st)) == sizeof (st)) {
575  char out[256];
576 
577  close(fd);
578 
579  FD_PRINTF(ofd, "%-30s : %s\n", "Version", PACKAGE);
580 
581 #if 0
582  cftime(out, NULL, &st.glob.start);
583 #endif
584  FD_PRINTF(ofd, "%-30s : %s\n", "Start", out);
585  FD_PRINTF(ofd, "%-30s : %ld\n", "# Start-up",
586  st.glob.value[STAT_RESTART]);
587  FD_PRINTF(ofd, "%-30s : %ld\n", "# Messages", st.glob.value[STAT_MSGS]);
588  FD_PRINTF(ofd, "%-30s : %ld\n", "# Connect", st.glob.value[STAT_CONNECT]);
589  FD_PRINTF(ofd, "%-30s : %ld\n", "# Abort", st.glob.value[STAT_ABORT]);
590  FD_PRINTF(ofd, "%-30s : %ld\n", "# Close", st.glob.value[STAT_CLOSE]);
591  FD_PRINTF(ofd, "%-30s : %ld\n", "# ENV RCPT", st.glob.value[STAT_ENVTO]);
592  FD_PRINTF(ofd, "%-30s : %ld\n", "# Attached files",
593  st.glob.value[STAT_FILES]);
594  FD_PRINTF(ofd, "%-30s : %ld\n", "# X-Files", st.glob.value[STAT_XFILES]);
595  FD_PRINTF(ofd, "%-30s : %ld\n", "# Virus", st.glob.value[STAT_VIRUS]);
596  FD_PRINTF(ofd, "%-30s : %ld\n", "# Reject Local Users",
597  st.glob.value[STAT_LUSERS]);
598  FD_PRINTF(ofd, "%-30s : %ld\n", "# Reject No RCPT Headers",
600  FD_PRINTF(ofd, "%-30s : %ld\n", "# Reject No Senders ",
602  FD_PRINTF(ofd, "%-30s : %ld\n", "# Reject Exceed Max RCPT",
603  st.glob.value[STAT_MAX_RCPT]);
604 
605  FD_PRINTF(ofd, "\n");
606 #if 0
607  cftime(out, NULL, &st.proc.start);
608 #endif
609  FD_PRINTF(ofd, "%-30s : %s\n", "Start", out);
610  FD_PRINTF(ofd, "%-30s : %ld\n", "# Start-up",
611  st.proc.value[STAT_RESTART]);
612  FD_PRINTF(ofd, "%-30s : %ld\n", "# Messages", st.proc.value[STAT_MSGS]);
613  FD_PRINTF(ofd, "%-30s : %ld\n", "# Connect", st.proc.value[STAT_CONNECT]);
614  FD_PRINTF(ofd, "%-30s : %ld\n", "# Abort", st.proc.value[STAT_ABORT]);
615  FD_PRINTF(ofd, "%-30s : %ld\n", "# Close", st.proc.value[STAT_CLOSE]);
616  FD_PRINTF(ofd, "%-30s : %ld\n", "# ENV RCPT", st.proc.value[STAT_ENVTO]);
617  FD_PRINTF(ofd, "%-30s : %ld\n", "# Attached files",
618  st.proc.value[STAT_FILES]);
619  FD_PRINTF(ofd, "%-30s : %ld\n", "# X-Files", st.proc.value[STAT_XFILES]);
620  FD_PRINTF(ofd, "%-30s : %ld\n", "# Virus", st.proc.value[STAT_VIRUS]);
621  FD_PRINTF(ofd, "%-30s : %ld\n", "# Reject Local Users",
622  st.proc.value[STAT_LUSERS]);
623  FD_PRINTF(ofd, "%-30s : %ld\n", "# Reject No RCPT Headers",
625  FD_PRINTF(ofd, "%-30s : %ld\n", "# Reject No Senders ",
627  FD_PRINTF(ofd, "%-30s : %ld\n", "# Reject Exceed Max RCPT",
628  st.proc.value[STAT_MAX_RCPT]);
629  } else {
630  close(fd);
631  FD_PRINTF(ofd, "Error reading %s file : %s\n", path, strerror(errno));
632  return 1;
633  }
634  } else {
635  FD_PRINTF(ofd, "Error opening %s file : %s\n", path, strerror(errno));
636  return 1;
637  }
638  return 0;
639 }
640 
641 /* ****************************************************************************
642  * *
643  * *
644  **************************************************************************** */
645 
646 typedef struct _code {
647  int c_val;
648  int order;
649  char *c_name;
650 } CODE;
651 
652 static CODE stat_names[] = {
653  {
654  STAT_RESTART,
655  0,
656  "Filter launches"},
657  {
658  STAT_BYTES,
659  0,
660  "KBytes transfered"},
661  {
662  STAT_MSGS,
663  0,
664  "Messages"},
665  {
666  STAT_CONNECT,
667  0,
668  "Connect"},
669  {
670  STAT_ABORT,
671  0,
672  "Abort"},
673  {
674  STAT_CLOSE,
675  0,
676  "Close"},
677  {
678  STAT_ENVTO,
679  0,
680  "Cumulative # RCPT"},
681  {
682  STAT_FILES,
683  0,
684  "Attached files"},
685  {
686  STAT_XFILES,
687  0,
688  "Attached unsafe files"},
689  {
690  STAT_VIRUS,
691  0,
692  "Attached virus"},
693  {
694  STAT_LUSERS,
695  0,
696  "Msgs sent to intranet users"},
697  {
699  0,
700  "No To or CC headers"},
701  {
703  0,
704  "No From headers"},
705  {
707  0,
708  "No headers at all"},
709  {
711  0,
712  "Gateways without DNS resolution"},
713  {
715  0,
716  "Gateways with forged DNS names"},
717  {
719  0,
720  "Msgs exceeding allowed # of recipients"},
721  {
723  0,
724  "Hosts exceeding allowed recipient rate"},
725  {
727  0,
728  "Hosts exceeding allowed connection rate"},
729  {
731  0,
732  "Hosts exceeding allowed open connections"},
733  {
735  0,
736  "Hosts doing too much empty connections"},
737  {
739  0,
740  "Hosts harvesting"},
741  {
743  0,
744  "Forbidden subject contents (regex)"},
745  {
747  0,
748  "Forbiden body contents (regex)"},
749  {
750  STAT_BINARY,
751  0,
752  "Binary encoded message body"},
753  {
754  STAT_BASE64,
755  0,
756  "BASE 64 encoded message body"},
757  {
759  0,
760  "Quoted-printable message body"},
761  {
762  STAT_POLICY,
763  0,
764  "Message violating site policy"},
765  {
766  STAT_BADMX,
767  0,
768  "Sender address has BAD MX"},
769  {
771  0,
772  "Recipient delayed by greylisting"},
773  {
775  0,
776  "Message delayed by greylisting"},
777  {-1, 0, NULL}
778 };
779 
780 
781 char *
783  int code;
784 {
785  CODE *p = stat_names;
786 
787  if (code < 0)
788  return NULL;
789 
790  while (p->c_name) {
791  if (code == p->c_val)
792  return p->c_name;
793  p++;
794  }
795  return NULL;
796 }
797 
798 
799 
800 
801 
802 /* ****************************************************************************
803  * *
804  * *
805  **************************************************************************** */
806 void
807 print_p_stats(ofd, st, title, c, all)
808  int ofd;
809  p_stats_T *st;
810  char *title;
811  int c;
812  int all;
813 {
814  char out[256];
815  char *p;
816 
817  FD_PRINTF(ofd, "\n%s\n", title);
818  strlcpy(out, ctime(&st->start), sizeof (out));
819 
820  if ((p = strchr(out, '\n')) != NULL)
821  *p = '\0';
822  FD_PRINTF(ofd, "%c %-30s : %s\n", c, "Start", out);
823  /*
824  * FD_PRINTF(ofd, "%c %-30s : %10ld\n", c, "# Start-up", st->value[STAT_RESTART]);
825  */
826  FD_PRINTF(ofd, "%c %-30s : %10ld\n", c, "# Messages", st->value[STAT_MSGS]);
827  FD_PRINTF(ofd, "%c %-30s : %10lu\n", c, "# KBytes",
828  ((unsigned long) (st->value[STAT_BYTES]) >> 4));
829  FD_PRINTF(ofd, "%c %-30s : %10ld\n", c, "# Connect", st->value[STAT_CONNECT]);
830  FD_PRINTF(ofd, "%c %-30s : %10ld\n", c, "# Abort", st->value[STAT_ABORT]);
831  FD_PRINTF(ofd, "%c %-30s : %10ld\n", c, "# Close", st->value[STAT_CLOSE]);
832  if (all || st->value[STAT_ENVTO] > 0)
833  FD_PRINTF(ofd, "%c %-30s : %10ld\n", c, "# ENV RCPT",
834  st->value[STAT_ENVTO]);
835  if (all || st->value[STAT_FILES] > 0)
836  FD_PRINTF(ofd, "%c %-30s : %10ld\n", c, "# Attached files",
837  st->value[STAT_FILES]);
838  if (all || st->value[STAT_XFILES] > 0)
839  FD_PRINTF(ofd, "%c %-30s : %10ld\n", c, "# X-Files",
840  st->value[STAT_XFILES]);
841  if (all || st->value[STAT_VIRUS] > 0)
842  FD_PRINTF(ofd, "%c %-30s : %10ld\n", c, "# Virus", st->value[STAT_VIRUS]);
843  if (all || st->value[STAT_LUSERS] > 0)
844  FD_PRINTF(ofd, "%c %-30s : %10ld\n", c, "# Reject Local Users",
845  st->value[STAT_LUSERS]);
846  if (all || st->value[STAT_NO_TO_HEADERS] > 0)
847  FD_PRINTF(ofd, "%c %-30s : %10ld\n", c, "# Reject No RCPT Headers",
849  if (all || st->value[STAT_NO_FROM_HEADERS] > 0)
850  FD_PRINTF(ofd, "%c %-30s : %10ld\n", c, "# Reject No Senders ",
852  if (all || st->value[STAT_MAX_RCPT] > 0)
853  FD_PRINTF(ofd, "%c %-30s : %10ld\n", c, "# Reject Exceed Max RCPT",
854  st->value[STAT_MAX_RCPT]);
855  if (all || st->value[STAT_RCPT_RATE] > 0)
856  FD_PRINTF(ofd, "%c %-30s : %10ld\n", c, "# Reject Exceed rcpt rate",
857  st->value[STAT_RCPT_RATE]);
858  if (all || st->value[STAT_CONN_RATE] > 0)
859  FD_PRINTF(ofd, "%c %-30s : %10ld\n", c, "# Reject Exceed conn rate",
860  st->value[STAT_CONN_RATE]);
861  if (all || st->value[STAT_RESOLVE_FAIL] > 0)
862  FD_PRINTF(ofd, "%c %-30s : %10ld\n", c, "# Resolve FAIL",
863  st->value[STAT_RESOLVE_FAIL]);
864  if (all || st->value[STAT_RESOLVE_FORGED] > 0)
865  FD_PRINTF(ofd, "%c %-30s : %10ld\n", c, "# Resolve FORGED",
867  if (all || st->value[STAT_BADMX] > 0)
868  FD_PRINTF(ofd, "%c %-30s : %10ld\n", c, "# Sender with bad MX",
869  st->value[STAT_BADMX]);
870 
871 }
872 
873 /* ****************************************************************************
874  * *
875  * *
876  **************************************************************************** */
877 void
878 print_p_stats_all(ofd, sta, titlea, stb, titleb, all, nf)
879  int ofd;
880  p_stats_T *sta;
881  char *titlea;
882  p_stats_T *stb;
883  char *titleb;
884  int all;
885  bool nf;
886 {
887  char out[256];
888  char *p;
889  int i;
890 
891  strlcpy(out, ctime(&sta->start), sizeof out);
892  if ((p = strchr(out, '\n')) != NULL)
893  *p = '\0';
894  FD_PRINTF(ofd, "\n%-30s %s\n", titlea, out);
895 
896  strlcpy(out, ctime(&stb->start), sizeof out);
897  if ((p = strchr(out, '\n')) != NULL)
898  *p = '\0';
899  FD_PRINTF(ofd, "%-30s %s\n", titleb, out);
900 
901  FD_PRINTF(ofd, "%-40s : %10ld %10ld\n",
902  "# Start-up", sta->value[STAT_RESTART], stb->value[STAT_RESTART]);
903  FD_PRINTF(ofd, "%-40s : %10ld %10ld\n",
904  "# Messages", sta->value[STAT_MSGS], stb->value[STAT_MSGS]);
905  FD_PRINTF(ofd, "%-40s : %10lu %10lu\n",
906  "# KBytes",
907  (unsigned long) sta->value[STAT_BYTES] >> 4,
908  (unsigned long) stb->value[STAT_BYTES] >> 4);
909  FD_PRINTF(ofd, "%-40s : %10ld %10ld\n",
910  "# Connect", sta->value[STAT_CONNECT], stb->value[STAT_CONNECT]);
911 
912  if (nf) {
913  for (i = STAT_ABORT; i < DIM_STATS; i++) {
914  if (sta->value[i] > 0 || stb->value[i] > 0) {
915  char *p = stats_title(i);
916 
917  if (p != NULL)
918  FD_PRINTF(ofd, "* %-40s : %10ld %10ld\n", p, sta->value[i],
919  stb->value[i]);
920  }
921  }
922  } else {
923  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n",
924  "Abort", sta->value[STAT_ABORT], stb->value[STAT_ABORT]);
925  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n",
926  "Close", sta->value[STAT_CLOSE], stb->value[STAT_CLOSE]);
927 
928  if (sta->value[STAT_ENVTO] > 0 || stb->value[STAT_ENVTO] > 0)
929  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n",
930  "ENV RCPT", sta->value[STAT_ENVTO], stb->value[STAT_ENVTO]);
931 
932  if (all || sta->value[STAT_FILES] > 0 || stb->value[STAT_FILES] > 0)
933  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n",
934  "Attached files", sta->value[STAT_FILES],
935  stb->value[STAT_FILES]);
936  if (all || sta->value[STAT_XFILES] > 0 || stb->value[STAT_XFILES] > 0)
937  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n",
938  "X-Files", sta->value[STAT_XFILES], stb->value[STAT_XFILES]);
939  if (all || sta->value[STAT_VIRUS] > 0 || stb->value[STAT_VIRUS] > 0)
940  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n",
941  "Virus", sta->value[STAT_VIRUS], stb->value[STAT_VIRUS]);
942  if (all || sta->value[STAT_LUSERS] > 0 || stb->value[STAT_LUSERS] > 0)
943  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n",
944  "Reject Local Users", sta->value[STAT_LUSERS],
945  stb->value[STAT_LUSERS]);
946  if (all || sta->value[STAT_MAX_RCPT] > 0 || stb->value[STAT_MAX_RCPT] > 0)
947  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n",
948  "Reject Exceed Max RCPT",
949  sta->value[STAT_MAX_RCPT], stb->value[STAT_MAX_RCPT]);
950  if (all || sta->value[STAT_RCPT_RATE] > 0 || stb->value[STAT_RCPT_RATE] > 0)
951  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n",
952  "Reject Exceed Throttle",
954  if (all || sta->value[STAT_CONN_RATE] > 0 || stb->value[STAT_CONN_RATE] > 0)
955  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n",
956  "Reject Exceed Conn Rate",
958  if (all || sta->value[STAT_BADMX] > 0 || stb->value[STAT_BADMX] > 0)
959  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n",
960  "Sender has bad MX", sta->value[STAT_BADMX],
961  stb->value[STAT_BADMX]);
962  if (all || sta->value[STAT_SINGLE_MESSAGE] > 0
963  || stb->value[STAT_SINGLE_MESSAGE] > 0)
964  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n", "Message per connection limit",
966  stb->value[STAT_SINGLE_MESSAGE]);
967 
968  if (all || sta->value[STAT_RCPT_REJECT] > 0
969  || stb->value[STAT_RCPT_REJECT] > 0)
970  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n", "Recipient - - REJECT",
972 
973  if (all || sta->value[STAT_RCPT_ACCESS] > 0
974  || stb->value[STAT_RCPT_ACCESS] > 0)
975  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n", "Recipient - ACCESS DENIED",
977 
978  if (all || sta->value[STAT_RCPT_BAD_NETWORK] > 0
979  || stb->value[STAT_RCPT_BAD_NETWORK] > 0)
980  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n",
981  "Recipient - BAD_NETWORK",
984 
985  if (all || sta->value[STAT_RCPT_UNKNOWN] > 0
986  || stb->value[STAT_RCPT_UNKNOWN] > 0)
987  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n", "Recipient - USER UNKNOWN",
989 
990  if (all || sta->value[STAT_RCPT_SPAMTRAP] > 0
991  || stb->value[STAT_RCPT_SPAMTRAP] > 0)
992  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n", "Recipient - SPAMTRAP",
994 
995  if (all || sta->value[STAT_BAD_RCPT] > 0 || stb->value[STAT_BAD_RCPT] > 0)
996  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n",
997  "Connections from harvesters",
998  sta->value[STAT_BAD_RCPT], stb->value[STAT_BAD_RCPT]);
999 
1000  if (all || sta->value[STAT_GREY_RCPT] > 0 || stb->value[STAT_GREY_RCPT] > 0)
1001  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n",
1002  "Recipients delayed by greylisting",
1003  sta->value[STAT_GREY_RCPT], stb->value[STAT_GREY_RCPT]);
1004  if (all || sta->value[STAT_GREY_MSGS] > 0 || stb->value[STAT_GREY_MSGS] > 0)
1005  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n",
1006  "Messages delayed by greylisting",
1007  sta->value[STAT_GREY_MSGS], stb->value[STAT_GREY_MSGS]);
1008  if (all || sta->value[STAT_RESOLVE_FAIL] > 0
1009  || stb->value[STAT_RESOLVE_FAIL] > 0)
1010  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n", "Resolve FAIL",
1012  if (all || sta->value[STAT_RESOLVE_FORGED] > 0
1013  || stb->value[STAT_RESOLVE_FORGED] > 0)
1014  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n", "Resolve FORGED",
1015  sta->value[STAT_RESOLVE_FORGED],
1016  stb->value[STAT_RESOLVE_FORGED]);
1017  if (all || sta->value[STAT_NO_TO_HEADERS] > 0
1018  || stb->value[STAT_NO_TO_HEADERS] > 0)
1019  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n", "Reject No RCPT Headers",
1021  if (all || sta->value[STAT_NO_FROM_HEADERS] > 0
1022  || stb->value[STAT_NO_FROM_HEADERS] > 0)
1023  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n", "Reject No Senders ",
1025  stb->value[STAT_NO_FROM_HEADERS]);
1026  if (all || sta->value[STAT_PATTERN_MATCHING] > 0
1027  || stb->value[STAT_PATTERN_MATCHING] > 0)
1028  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n", "Reject pattern matching",
1031  if (all || sta->value[STAT_URLBL] > 0 || stb->value[STAT_URLBL] > 0)
1032  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n", "Reject URL BL",
1033  sta->value[STAT_URLBL], stb->value[STAT_URLBL]);
1034  if (all || sta->value[STAT_ORACLE] > 0 || stb->value[STAT_ORACLE] > 0)
1035  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n", "Detected by heuristic filter",
1036  sta->value[STAT_ORACLE], stb->value[STAT_ORACLE]);
1037  if (all || sta->value[STAT_BAYES_SPAM] > 0
1038  || stb->value[STAT_BAYES_SPAM] > 0)
1039  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n", "Detected by bayes filter",
1041  if (all || sta->value[STAT_SUBJECT_CONTENTS] > 0
1042  || stb->value[STAT_SUBJECT_CONTENTS] > 0)
1043  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n", "Reject subject contents",
1046  if (all || sta->value[STAT_HEADERS_CONTENTS] > 0
1047  || stb->value[STAT_HEADERS_CONTENTS] > 0)
1048  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n", "Reject headers contents",
1051  if (all || sta->value[STAT_BINARY] > 0 || stb->value[STAT_BINARY] > 0)
1052  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n",
1053  "Reject binary encoded body",
1054  sta->value[STAT_BINARY], stb->value[STAT_BINARY]);
1055  if (all || sta->value[STAT_BASE64] > 0 || stb->value[STAT_BASE64] > 0)
1056  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n",
1057  "Reject base 64 encoded body",
1058  sta->value[STAT_BASE64], stb->value[STAT_BASE64]);
1059  if (all || sta->value[STAT_QUOTED_PRINTABLE] > 0
1060  || stb->value[STAT_QUOTED_PRINTABLE] > 0)
1061  FD_PRINTF(ofd, "# %-40s : %10ld %10ld\n",
1062  "Reject quoted printable encoded body",
1065  }
1066 }
1067 
1068 /* ****************************************************************************
1069  * *
1070  * *
1071  **************************************************************************** */
1072 int
1073 dump_state(ofd, jp, jg, all, nf)
1074  int ofd;
1075  int jp;
1076  int jg;
1077  int all;
1078  bool nf;
1079 {
1080  int fd;
1081  j_stats_T st;
1082  char *p;
1083 
1084  char *fname = STATE_FILE;
1085 
1086  char path[1024];
1087  char *wkdir = NULL;
1088 
1089  wkdir = cf_get_str(CF_WORKDIR);
1090  if (wkdir == NULL || strlen(wkdir) == 0)
1091  wkdir = ZE_WORKDIR;
1092 
1093  ADJUST_FILENAME(path, fname, wkdir, STATE_FILE);
1094 
1095  if (strlen(path) == 0) {
1096  ZE_LogMsgError(0, "undefined state file");
1097  return 1;
1098  }
1099 
1100  if (ofd < 0)
1101  ofd = STDOUT_FILENO;
1102 
1103  if ((fd = open(path, O_RDONLY)) >= 0) {
1104  if (read(fd, &st, sizeof (st)) == sizeof (st)) {
1105  char out[256];
1106 
1107  close(fd);
1108 
1109  FD_PRINTF(ofd, "%-30s : %s\n", "Version", PACKAGE);
1110 
1111  strlcpy(out, ctime(&st.last_save), sizeof (out));
1112  if ((p = strchr(out, '\n')) != NULL)
1113  *p = '\0';
1114  FD_PRINTF(ofd, "%-30s : %s\n", "Last counters dump", out);
1115 
1116  if (!jp && !jg)
1117  print_p_stats(ofd, &st.glob, "*** GLOBAL DATA ***\n", 'G', all);
1118 
1119  if (!jp && jg)
1120  print_p_stats(ofd, &st.glob, "*** GLOBAL DATA ***\n", 'G', all);
1121 
1122  if (jp && !jg)
1123  print_p_stats(ofd, &st.proc, "*** PROCESSUS DATA ***\n", 'P', all);
1124 
1125  if (jp && jg)
1126  print_p_stats_all(ofd, &st.proc,
1127  "*** PROCESSUS DATA ***",
1128  &st.glob, "*** GLOBAL DATA ***", all, nf);
1129  } else {
1130  close(fd);
1131  ZE_LogSysError("Error reading %s file", path);
1132  return 1;
1133  }
1134  } else {
1135  ZE_LogSysError("Error opening %s file", path);
1136  return 1;
1137  }
1138  return 0;
1139 }
1140 
1141 /* ****************************************************************************
1142  * *
1143  * *
1144  **************************************************************************** */
1145 void
1147 {
1148 
1149  /*
1150  * XXX Joe
1151  */
1152 
1153  char out[256];
1154  char *p;
1155  char *title = "*** PROCESSUS DATA ***";
1156  p_stats_T *st;
1157  char c = ' ';
1158 
1159  st = &m_stats.proc;
1160 
1161  ZE_MessageInfo(9, "%s", title);
1162  strlcpy(out, ctime(&st->start), sizeof (out));
1163 
1164  if ((p = strchr(out, '\n')) != NULL)
1165  *p = '\0';
1166  ZE_MessageInfo(9, "%c %-30s : %s", c, "Start", out);
1167  /*
1168  * ZE_MessageInfo(9, "%c %-30s : %10ld", c, "# Start-up", st->value[STAT_RESTART]);
1169  */
1170  ZE_MessageInfo(9, "%c %-30s : %10ld", c, "# Messages", st->value[STAT_MSGS]);
1171  ZE_MessageInfo(9, "%c %-30s : %10lu", c, "# KBytes",
1172  ((unsigned long) (st->value[STAT_BYTES]) >> 4));
1173  ZE_MessageInfo(9, "%c %-30s : %10ld", c, "# Connect",
1174  st->value[STAT_CONNECT]);
1175  ZE_MessageInfo(9, "%c %-30s : %10ld", c, "# Abort", st->value[STAT_ABORT]);
1176  ZE_MessageInfo(9, "%c %-30s : %10ld", c, "# Close", st->value[STAT_CLOSE]);
1177  if (st->value[STAT_ENVTO] > 0)
1178  ZE_MessageInfo(9, "%c %-30s : %10ld", c, "# ENV RCPT",
1179  st->value[STAT_ENVTO]);
1180  if (st->value[STAT_FILES] > 0)
1181  ZE_MessageInfo(9, "%c %-30s : %10ld", c, "# Attached files",
1182  st->value[STAT_FILES]);
1183  if (st->value[STAT_XFILES] > 0)
1184  ZE_MessageInfo(9, "%c %-30s : %10ld", c, "# X-Files",
1185  st->value[STAT_XFILES]);
1186  if (st->value[STAT_VIRUS] > 0)
1187  ZE_MessageInfo(9, "%c %-30s : %10ld", c, "# Virus", st->value[STAT_VIRUS]);
1188  if (st->value[STAT_LUSERS] > 0)
1189  ZE_MessageInfo(9, "%c %-30s : %10ld", c, "# Reject Local Users",
1190  st->value[STAT_LUSERS]);
1191  if (st->value[STAT_NO_TO_HEADERS] > 0)
1192  ZE_MessageInfo(9, "%c %-30s : %10ld", c, "# Reject No RCPT Headers",
1193  st->value[STAT_NO_TO_HEADERS]);
1194  if (st->value[STAT_NO_FROM_HEADERS] > 0)
1195  ZE_MessageInfo(9, "%c %-30s : %10ld", c, "# Reject No Senders ",
1197  if (st->value[STAT_MAX_RCPT] > 0)
1198  ZE_MessageInfo(9, "%c %-30s : %10ld", c, "# Reject Exceed Max RCPT",
1199  st->value[STAT_MAX_RCPT]);
1200  if (st->value[STAT_RCPT_RATE] > 0)
1201  ZE_MessageInfo(9, "%c %-30s : %10ld", c, "# Reject Exceed rcpt rate",
1202  st->value[STAT_RCPT_RATE]);
1203  if (st->value[STAT_CONN_RATE] > 0)
1204  ZE_MessageInfo(9, "%c %-30s : %10ld", c, "# Reject Exceed conn rate",
1205  st->value[STAT_CONN_RATE]);
1206  if (st->value[STAT_RESOLVE_FAIL] > 0)
1207  ZE_MessageInfo(9, "%c %-30s : %10ld", c, "# Resolve FAIL",
1208  st->value[STAT_RESOLVE_FAIL]);
1209  if (st->value[STAT_RESOLVE_FORGED] > 0)
1210  ZE_MessageInfo(9, "%c %-30s : %10ld", c, "# Resolve FORGED",
1211  st->value[STAT_RESOLVE_FORGED]);
1212  if (st->value[STAT_BADMX] > 0)
1213  ZE_MessageInfo(9, "%c %-30s : %10ld", c, "# Sender with bad MX",
1214  st->value[STAT_BADMX]);
1215 
1216 }
void print_filter_stats_summary()
Definition: ze-stats.c:1146
#define MAX_SCORE
Definition: ze-stats.c:33
bool log_write(LOG_T *, char *)
Definition: ze-txtlog.c:329
p_stats_T glob
Definition: ze-stats.h:112
#define LOG_INITIALIZER
Definition: ze-txtlog.h:96
bool log_counters_reopen()
Definition: ze-stats.c:324
#define STAT_RESTART
Definition: ze-stats.h:26
#define STATE_FILE
Definition: ze-stats.c:34
#define VERSION
Definition: version.h:25
#define STAT_RCPT_REJECT
Definition: ze-stats.h:83
#define STAT_RCPT_ACCESS
Definition: ze-stats.h:84
#define STAT_BAYES_SPAM
Definition: ze-stats.h:64
#define STAT_NO_FROM_HEADERS
Definition: ze-stats.h:39
#define STAT_SINGLE_MESSAGE
Definition: ze-stats.h:68
time_t last_save
Definition: ze-stats.h:111
#define STAT_ENVTO
Definition: ze-stats.h:32
int nb
Definition: ze-stats.c:37
void print_p_stats_all(int ofd, p_stats_T *sta, char *titlea, p_stats_T *stb, char *titleb, int all, bool nf)
Definition: ze-stats.c:878
#define ZE_WORKDIR
Definition: defs.h:33
pthread_mutex_t mutex
Definition: ze-stats.c:38
bool log_reopen(LOG_T *)
Definition: ze-txtlog.c:275
#define STAT_BINARY
Definition: ze-stats.h:60
void reset_state()
Definition: ze-stats.c:528
int c_val
Definition: ze-stats.c:647
#define STRNULL(x, r)
Definition: macros.h:81
#define STATS_LOCK()
Definition: ze-stats.c:204
void msg_score_stats_print(int fd, int which)
Definition: ze-stats.c:118
#define STAT_URLBL
Definition: ze-stats.h:56
#define FALSE
Definition: macros.h:160
#define STAT_EMPTY_CONN
Definition: ze-stats.h:72
#define strlcpy
Definition: zeString.h:32
time_t start
Definition: ze-stats.h:98
#define ZE_LogMsgError(level,...)
Definition: zeSyslog.h:113
#define ADJUST_FILENAME(path, fname, cfdir, defval)
Definition: macros.h:236
#define STAT_MSGS
Definition: ze-stats.h:28
#define STAT_NO_TO_HEADERS
Definition: ze-stats.h:38
#define STAT_XFILES
Definition: ze-stats.h:34
#define STAT_GREY_MSGS
Definition: ze-stats.h:80
#define FD_PRINTF(fdp,...)
Definition: macros.h:45
void log_counters(int fd, bool dump)
Definition: ze-stats.c:330
#define STATS_UNLOCK()
Definition: ze-stats.c:205
int cf_get_int(int id)
Definition: ze-cf.c:803
#define STAT_CLOSE
Definition: ze-stats.h:31
#define STAT_PATTERN_MATCHING
Definition: ze-stats.h:50
#define STAT_NO_HEADERS
Definition: ze-stats.h:48
int dump_state(int ofd, int jp, int jg, int all, bool nf)
Definition: ze-stats.c:1073
void init_proc_state()
Definition: ze-stats.c:502
#define strlcat
Definition: zeString.h:28
#define STAT_ORACLE
Definition: ze-stats.h:55
#define strchr
Definition: ze-sys.h:218
#define STAT_VIRUS
Definition: ze-stats.h:35
#define OPT_OK
Definition: ze-cf.h:47
int ora[MAX_SCORE+2]
Definition: ze-stats.c:39
#define STAT_RCPT_RATE
Definition: ze-stats.h:45
#define CF_SCANNER_ACTION
Definition: cfh-defs.h:97
void read_state()
Definition: ze-stats.c:467
int order
Definition: ze-stats.c:648
int print_state(int ofd)
Definition: ze-stats.c:548
int reg[MAX_SCORE+2]
Definition: ze-stats.c:40
void stats_inc(int which, long n)
Definition: ze-stats.c:401
#define SCORE_LOCK()
Definition: ze-stats.c:47
#define STAT_POLICY
Definition: ze-stats.h:58
#define STAT_QUOTED_PRINTABLE
Definition: ze-stats.h:62
#define ZE_MessageInfo(level,...)
Definition: zeSyslog.h:90
#define log_check_and_open(log, name)
Definition: ze-txtlog.h:130
#define SCORE_UNLOCK()
Definition: ze-stats.c:48
#define STAT_CONN_RATE
Definition: ze-stats.h:44
#define TRUE
Definition: macros.h:157
#define STAT_RCPT_UNKNOWN
Definition: ze-stats.h:86
#define STAT_RESOLVE_FAIL
Definition: ze-stats.h:41
#define STAT_MAX_RCPT
Definition: ze-stats.h:43
#define STAT_BYTES
Definition: ze-stats.h:27
#define ZE_LogSysError(...)
Definition: zeSyslog.h:129
char version[128]
Definition: ze-stats.h:110
void print_p_stats(int ofd, p_stats_T *st, char *title, int c, int all)
Definition: ze-stats.c:807
#define DIM_STATS
Definition: ze-stats.h:91
char * cf_get_str(int id)
Definition: ze-cf.c:854
#define STAT_BAYES_HAM
Definition: ze-stats.h:65
#define max(a, b)
Definition: macros.h:127
double bayes
Definition: ze-msg-score.h:88
void msg_score_stats_update(msg_scores_T *scores)
Definition: ze-stats.c:52
#define STAT_FILES
Definition: ze-stats.h:33
#define STAT_BAD_RCPT
Definition: ze-stats.h:74
char * c_name
Definition: ze-stats.c:649
#define STAT_CONNECT
Definition: ze-stats.h:29
#define STAT_SUBJECT_CONTENTS
Definition: ze-stats.h:51
#define STAT_GREY_RCPT
Definition: ze-stats.h:79
#define PACKAGE
Definition: version.h:28
#define STAT_RCPT_BAD_NETWORK
Definition: ze-stats.h:85
#define STAT_ABORT
Definition: ze-stats.h:30
void save_state()
Definition: ze-stats.c:430
struct _code CODE
#define STAT_LUSERS
Definition: ze-stats.h:36
#define STAT_BADMX
Definition: ze-stats.h:78
#define CF_WORKDIR
Definition: cfh-defs.h:67
#define STAT_HEADERS_CONTENTS
Definition: ze-stats.h:52
#define STAT_OPEN_CONN
Definition: ze-stats.h:71
p_stats_T proc
Definition: ze-stats.h:113
int msg[MAX_SCORE+2]
Definition: ze-stats.c:41
#define STAT_RESOLVE_FORGED
Definition: ze-stats.h:42
int bay[MAX_SCORE+2]
Definition: ze-stats.c:42
#define STAT_RCPT_SPAMTRAP
Definition: ze-stats.h:87
long value[DIM_STATS]
Definition: ze-stats.h:102
#define STAT_BASE64
Definition: ze-stats.h:61
#define ADJUST_LOG_NAME(path, fname, dir, defval)
Definition: ze-txtlog.h:133
#define CF_STATS_FILE
Definition: cfh-defs.h:70
void stats_reset()
Definition: ze-stats.c:381
char * stats_title(int code)
Definition: ze-stats.c:782