ze-filter  (ze-filter-0.8.0-develop-180218)
ze-policy.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 #include "ze-filter.h"
28 
29 #define JDEBUG 0
30 
31 #define ACCESS_UNDEF 0
32 #define ACCESS_NO 1
33 #define ACCESS_QUICK_NO 2
34 #define ACCESS_YES 3
35 #define ACCESS_QUICK_YES 4
36 
37 static int access_decode(char *);
38 
40 
41 /* ****************************************************************************
42  * *
43  * *
44  **************************************************************************** */
45 
46 /*
47 ** policy_check vs policy_lookup
48 */
49 
50 bool
51 lookup_policy(prefix, key, buf, szbuf, chkdefault)
52  char *prefix;
53  char *key;
54  char *buf;
55  size_t szbuf;
56  bool chkdefault;
57 {
58  char bufout[256];
59  bool ok = FALSE;
60 
61  if (key == NULL) {
62  if (chkdefault)
63  key = "default";
64  else
65  return FALSE;
66  }
67 
68  ZE_MessageInfo(15, "Checking %s:%s", prefix, key);
69 
70  memset(bufout, 0, sizeof (bufout));
71  if (db_policy_check(prefix, key, bufout, sizeof (bufout))) {
72  if (strlen(bufout) > 0)
73  ZE_MessageInfo(15, " -> Got : %s:%-15s %s\n", prefix, key, bufout);
74  strlcpy(buf, bufout, szbuf);
75 
76  ok = TRUE;
77 
78  goto fin;
79  }
80 
81  if (chkdefault) {
82  if (db_policy_check(prefix, "default", bufout, sizeof (bufout))) {
83  if (strlen(buf) > 0)
84  ZE_MessageInfo(15, " -> Got : %s:%-15s %s\n", prefix, "DEFAULT", buf);
85  strlcpy(buf, bufout, szbuf);
86 
87  ok = TRUE;
88 
89  goto fin;
90  }
91  if (db_policy_check(prefix, "*", bufout, sizeof (bufout))) {
92  if (strlen(buf) > 0)
93  ZE_MessageInfo(15, " -> Got : %s:%-15s %s\n", prefix, "*", buf);
94  strlcpy(buf, bufout, szbuf);
95 
96  ok = TRUE;
97 
98  goto fin;
99  }
100  }
101 
102 fin:
103  return ok;
104 }
105 
106 /* ****************************************************************************
107  * *
108  * *
109  **************************************************************************** */
110 
111 /*
112 ** Checks :
113 **
114 **
115 **
116 */
117 
118 bool
119 check_policy(prefix, key, buf, szbuf, chkdefault)
120  char *prefix;
121  char *key;
122  char *buf;
123  size_t szbuf;
124  bool chkdefault;
125 {
126  char bufout[256];
127  bool ok = FALSE;
128 
129  if (key == NULL) {
130  if (chkdefault)
131  key = "";
132  else
133  return FALSE;
134  }
135 
136  ZE_MessageInfo(15, "Checking %s:%s", prefix, key);
137 
138  memset(bufout, 0, sizeof (bufout));
139  if (db_policy_check(prefix, key, bufout, sizeof (bufout))) {
140  if (strlen(bufout) > 0)
141  ZE_MessageInfo(15, " -> Got : %s:%-15s %s\n", prefix, key, bufout);
142  strlcpy(buf, bufout, szbuf);
143 
144  ok = TRUE;
145 
146  goto fin;
147  }
148 
149  if (zeStrRegex(key, IPV4_ADDR_REGEX, NULL, NULL, TRUE) ||
150  zeStrRegex(key, IPV6_ADDR_REGEX, NULL, NULL, TRUE) ||
151  zeStrRegex(key, DOMAINNAME_REGEX, NULL, NULL, TRUE)) {
152  char tb[256];
153 
154  if (ze_logLevel > 10) {
155  if (zeStrRegex(key, IPV4_ADDR_REGEX, NULL, NULL, TRUE))
156  ZE_MessageInfo(15, " -> IP : %s", key);
157  if (zeStrRegex(key, IPV6_ADDR_REGEX, NULL, NULL, TRUE))
158  ZE_MessageInfo(15, " -> IP : %s", key);
159  if (zeStrRegex(key, DOMAINNAME_REGEX, NULL, NULL, TRUE))
160  ZE_MessageInfo(15, " -> DOMAIN : %s", key);
161  }
162 
163  if (db_policy_check("NetClass", key, tb, sizeof (tb))) {
164  if (strlen(tb) > 0)
165  ZE_MessageInfo(15, " -> Got : %s:%-15s %s\n", "NetClass", key, tb);
166  if (db_policy_check(prefix, tb, bufout, sizeof (bufout))) {
167  if (strlen(bufout) > 0)
168  ZE_MessageInfo(15, " -> Got : %s:%-15s %s\n", prefix, tb, bufout);
169  strlcpy(buf, bufout, szbuf);
170  ok = TRUE;
171 
172  goto fin;
173  }
174  }
175  }
176 
177  if (chkdefault) {
178  if (db_policy_check(prefix, "default", bufout, sizeof (bufout))) {
179  if (strlen(bufout) > 0)
180  ZE_MessageInfo(15, " -> Got : %s:%-15s %s\n", prefix, "DEFAULT", buf);
181  strlcpy(buf, bufout, szbuf);
182  ok = TRUE;
183 
184  goto fin;
185  }
186  if (db_policy_check(prefix, "*", bufout, sizeof (bufout))) {
187  if (strlen(bufout) > 0)
188  ZE_MessageInfo(15, " -> Got : %s:%-15s %s\n", prefix, "*", buf);
189  strlcpy(buf, bufout, szbuf);
190  ok = TRUE;
191 
192  goto fin;
193  }
194  }
195 
196 fin:
197  return ok;
198 }
199 
200 /* ****************************************************************************
201  * *
202  * *
203  **************************************************************************** */
204 bool
205 check_host_policy(prefix, addr, name, class, buf, size, cdef)
206  char *prefix;
207  char *addr;
208  char *name;
209  char *class;
210  char *buf;
211  size_t size;
212  bool cdef;
213 {
214  bool ok = FALSE;
215  char lclass[128];
216 
217  memset(buf, 0, size);
218  if (addr != NULL)
219  ok = lookup_policy(prefix, addr, buf, size, FALSE);
220  ZE_MessageInfo(11, "Prefix : %s; Addr : %s; Buf : %s",
221  prefix, STRNULL(addr, "???"), buf);
222  if (ok)
223  goto fin;
224 
225  if (name != NULL)
226  ok = lookup_policy(prefix, name, buf, size, FALSE);
227  ZE_MessageInfo(11, "Prefix : %s; Name : %s; Buf : %s",
228  prefix, STRNULL(name, "???"), buf);
229  if (ok)
230  goto fin;
231 
232  memset(lclass, 0, sizeof (lclass));
233  if (class == NULL || strlen(class) == 0) {
234  if (addr != NULL && strlen(addr) > 0)
235  ok = lookup_policy("NetClass", addr, lclass, sizeof (lclass), FALSE);
236  if (!ok && name != NULL && strlen(name) > 0)
237  ok = lookup_policy("NetClass", name, lclass, sizeof (lclass), FALSE);
238  } else
239  strlcpy(lclass, class, sizeof (lclass));
240 
241  if (strlen(lclass) == 0)
242  goto fin;
243 
244  ok = lookup_policy(prefix, lclass, buf, size, cdef);
245  ZE_MessageInfo(11, "Prefix : %s; Class : %s; Buf : %s",
246  prefix, STRNULL(class, "???"), buf);
247 
248 fin:
249  return ok;
250 }
251 
252 /* ****************************************************************************
253  * *
254  * *
255  **************************************************************************** */
256 #define MAX_TOKENS 256
257 
258 #define DECODE_ACCESS(value, result) \
259  do { \
260  switch (access_decode(value)) { \
261  case ACCESS_YES: \
262  result = TRUE; \
263  break; \
264  case ACCESS_NO: \
265  result = FALSE; \
266  break; \
267  case ACCESS_QUICK_YES: \
268  return TRUE; \
269  break; \
270  case ACCESS_QUICK_NO: \
271  return FALSE; \
272  break; \
273  } \
274 } while (0)
275 
276 bool
277 check_policy_tuple(prefix, ip, name, netclass, from, to, result)
278  char *prefix;
279  char *ip;
280  char *name;
281  char *netclass;
282  char *from;
283  char *to;
284  bool result;
285 {
286  char tag[256], value[256], key[256];
287  char send[256], rcpt[256];
288 
289  prefix = STRNULL(prefix, "");
290  ip = STRNULL(ip, "");
291  name = STRNULL(name, "");
292  netclass = STRNULL(netclass, "UNKNOWN");
293  from = STRNULL(from, "nullsender");
294  to = STRNULL(to, "");
295 
296  memset(send, 0, sizeof (send));
297  extract_email_address(send, from, sizeof (send));
298  memset(rcpt, 0, sizeof (rcpt));
299  extract_email_address(rcpt, to, sizeof (rcpt));
300 
301  from = send;
302  to = rcpt;
303 
304  memset(tag, 0, sizeof (tag));
305  memset(key, 0, sizeof (key));
306  memset(value, 0, sizeof (value));
307 
308  ZE_MessageInfo(15, "TUPLE %s %s %s %s", ip, name, from, to);
309 
310  /*
311  ** Checking CONNECT
312  */
313  snprintf(tag, sizeof (tag), "%sConnect", prefix);
314  if (check_host_policy(tag, ip, name, netclass, value, sizeof (value), TRUE)) {
315  switch (access_decode(value)) {
316  case ACCESS_YES:
317  result = TRUE;
318  break;
319  case ACCESS_NO:
320  result = FALSE;
321  break;
322  case ACCESS_QUICK_YES:
323  return TRUE;
324  break;
325  case ACCESS_QUICK_NO:
326  return FALSE;
327  break;
328  }
329  }
330 
331  if (from == NULL)
332  goto fin;
333 
334  /*
335  ** Checking FROM
336  */
337  {
338  char *token = NULL;
339 
341  if (token != NULL && strlen(token) > 0) {
342  char *argv[MAX_TOKENS];
343  int argc;
344 
345  int i;
346  char *p;
347 
348  ZE_MessageInfo(11, " Checking FROM_TOKENS %s", token);
349 
350  snprintf(tag, sizeof (tag), "%sFrom", prefix);
351  argc = zeStr2Tokens(token, MAX_TOKENS, argv, " ");
352  for (i = 0; i < argc; i++) {
353  ZE_MessageInfo(11, " Checking %s:%s", tag, argv[i]);
354  if ((p = strstr(from, argv[i])) != NULL) {
355  if (check_policy(tag, p, value, sizeof (value), FALSE)) {
356  switch (access_decode(value)) {
357  case ACCESS_YES:
358  result = TRUE;
359  break;
360  case ACCESS_NO:
361  result = FALSE;
362  break;
363  case ACCESS_QUICK_YES:
364  return TRUE;
365  break;
366  case ACCESS_QUICK_NO:
367  return FALSE;
368  break;
369  }
370  }
371  }
372  }
373  }
374  }
375 
376  snprintf(tag, sizeof (tag), "%sFrom", prefix);
377  if (check_policy(tag, from, value, sizeof (value), TRUE)) {
378  switch (access_decode(value)) {
379  case ACCESS_YES:
380  result = TRUE;
381  break;
382  case ACCESS_NO:
383  result = FALSE;
384  break;
385  case ACCESS_QUICK_YES:
386  return TRUE;
387  break;
388  case ACCESS_QUICK_NO:
389  return FALSE;
390  break;
391  }
392  }
393 
394  if (to == NULL)
395  goto fin;
396 
397  /*
398  ** Checking TO
399  */
400  {
401  char *token = NULL;
402 
403  token = cf_get_str(CF_TO_PASS_TOKEN);
404  if (token != NULL && strlen(token) > 0) {
405  char *argv[MAX_TOKENS];
406  int argc;
407 
408  int i;
409  char *p;
410 
411  ZE_MessageInfo(11, " Checking TO_TOKENS %s", token);
412 
413  snprintf(tag, sizeof (tag), "%sTo", prefix);
414  argc = zeStr2Tokens(token, MAX_TOKENS, argv, " ,");
415  for (i = 0; i < argc; i++) {
416  ZE_MessageInfo(11, " Checking %s:%s", tag, argv[i]);
417  if ((p = strstr(from, argv[i])) != NULL) {
418  if (check_policy(tag, p, value, sizeof (value), FALSE)) {
419  switch (access_decode(value)) {
420  case ACCESS_YES:
421  result = TRUE;
422  break;
423  case ACCESS_NO:
424  result = FALSE;
425  break;
426  case ACCESS_QUICK_YES:
427  return TRUE;
428  break;
429  case ACCESS_QUICK_NO:
430  return FALSE;
431  break;
432  }
433  }
434  }
435  }
436  }
437  }
438 
439  snprintf(tag, sizeof (tag), "%sTo", prefix);
440  ZE_MessageInfo(20, "TAG : %s %s", tag, to);
441  if (check_policy(tag, to, value, sizeof (value), TRUE)) {
442  switch (access_decode(value)) {
443  case ACCESS_YES:
444  result = TRUE;
445  break;
446  case ACCESS_NO:
447  result = FALSE;
448  break;
449  case ACCESS_QUICK_YES:
450  return TRUE;
451  break;
452  case ACCESS_QUICK_NO:
453  return FALSE;
454  break;
455  }
456  }
457 
458 fin:
459  ZE_MessageInfo(15, "TUPLE %s %s %s %s : %s", ip, name, send, rcpt,
460  STRBOOL(result, "YES", "NO"));
461  return result;
462 }
463 
464 
465 /* ****************************************************************************
466  * *
467  * *
468  **************************************************************************** */
469 bool
470 check_policy_all_rcpts(prefix, ip, name, netclass, from, rcpt, result, conflict)
471  char *prefix;
472  char *ip;
473  char *name;
474  char *netclass;
475  char *from;
476  rcpt_addr_T *rcpt;
477  bool result;
478  int conflict;
479 {
480  bool doit = result;
481 
482  rcpt_addr_T *p = NULL;
483  int nok = 0, nko = 0;
484 
485  for (p = rcpt; p != NULL; p = p->next) {
486  bool ok;
487 
488  if (p->access != RCPT_OK)
489  continue;
490 
491  ok = check_policy_tuple(prefix, ip, name, netclass, from, p->rcpt, result);
492  if (ok == result)
493  nok++;
494  else
495  nko++;
496  }
497  doit = (nok > 0) ? result : !result;
498  if (nko > 0 && nok > 0) {
499  switch (conflict) {
500  case OPT_ONE_WIN:
501  doit = (nko > 0) ? !result : result;
502  break;
503  case OPT_MAJORITY_WIN:
504  doit = (nok > nko) ? result : !result;
505  break;
506  case OPT_DEFAULT:
507  default:
508  doit = result;
509  break;
510  }
511  }
512  return doit;
513 }
514 
515 /* ****************************************************************************
516  * *
517  * *
518  **************************************************************************** */
519 #define VAL2LIMIT(r,buffer) \
520  do { \
521  long v = 0; \
522  \
523  v = zeStr2long(buffer, NULL, r); \
524  if (r <= 0) \
525  r = MAX(v,0); \
526  else \
527  r = (v > 0) ? MIN(v,r) : r; \
528  } while (0)
529 
530 long
531 check_limit_tuple(prefix, ip, name, netclass, from, to, result)
532  char *prefix;
533  char *ip;
534  char *name;
535  char *netclass;
536  char *from;
537  char *to;
538  long result;
539 {
540  char tag[256], buffer[256], key[256];
541  char send[256], rcpt[256];
542 
543  prefix = STRNULL(prefix, "");
544  ip = STRNULL(ip, "");
545  name = STRNULL(name, "");
546  netclass = STRNULL(netclass, "UNKNOWN");
547  from = STRNULL(from, "nullsender");
548  to = STRNULL(to, "");
549 
550  memset(send, 0, sizeof (send));
551  extract_email_address(send, from, sizeof (send));
552  memset(rcpt, 0, sizeof (rcpt));
553  extract_email_address(rcpt, to, sizeof (rcpt));
554 
555  from = send;
556  to = rcpt;
557 
558  memset(tag, 0, sizeof (tag));
559  memset(key, 0, sizeof (key));
560  memset(buffer, 0, sizeof (buffer));
561 
562  ZE_MessageInfo(15, "TUPLE %s %s %s %s", ip, name, from, to);
563 
564  result = MAX(result, 0);
565  /*
566  ** Checking CONNECT
567  */
568 
569  snprintf(tag, sizeof (tag), "%sConnect", prefix);
570  if (check_host_policy(tag, ip, name, netclass, buffer, sizeof (buffer), TRUE)) {
571  VAL2LIMIT(result, buffer);
572  }
573 
574  if (from == NULL)
575  goto fin;
576 
577  /*
578  ** Checking FROM
579  */
580  {
581  char *token = NULL;
582 
584  if (token != NULL && strlen(token) > 0) {
585  char *argv[MAX_TOKENS];
586  int argc;
587 
588  int i;
589  char *p;
590 
591  ZE_MessageInfo(11, " Checking FROM_TOKENS %s", token);
592 
593  snprintf(tag, sizeof (tag), "%sFrom", prefix);
594  argc = zeStr2Tokens(token, MAX_TOKENS, argv, " ");
595  for (i = 0; i < argc; i++) {
596  ZE_MessageInfo(11, " Checking %s:%s", tag, argv[i]);
597  if ((p = strstr(from, argv[i])) != NULL) {
598  if (check_policy(tag, p, buffer, sizeof (buffer), FALSE)) {
599  VAL2LIMIT(result, buffer);
600  }
601  }
602  }
603  }
604  }
605 
606  snprintf(tag, sizeof (tag), "%sFrom", prefix);
607  if (check_policy(tag, from, buffer, sizeof (buffer), TRUE)) {
608  VAL2LIMIT(result, buffer);
609  }
610 
611  if (to == NULL)
612  goto fin;
613 
614  /*
615  ** Checking TO
616  */
617  {
618  char *token = NULL;
619 
620  token = cf_get_str(CF_TO_PASS_TOKEN);
621  if (token != NULL && strlen(token) > 0) {
622  char *argv[MAX_TOKENS];
623  int argc;
624 
625  int i;
626  char *p;
627 
628  ZE_MessageInfo(11, " Checking TO_TOKENS %s", token);
629 
630  snprintf(tag, sizeof (tag), "%sTo", prefix);
631  argc = zeStr2Tokens(token, MAX_TOKENS, argv, " ,");
632  for (i = 0; i < argc; i++) {
633  ZE_MessageInfo(11, " Checking %s:%s", tag, argv[i]);
634  if ((p = strstr(from, argv[i])) != NULL) {
635  if (check_policy(tag, p, buffer, sizeof (buffer), FALSE)) {
636  VAL2LIMIT(result, buffer);
637  }
638  }
639  }
640  }
641  }
642 
643  snprintf(tag, sizeof (tag), "%sTo", prefix);
644  ZE_MessageInfo(20, "TAG : %s %s", tag, to);
645  if (check_policy(tag, to, buffer, sizeof (buffer), TRUE)) {
646  VAL2LIMIT(result, buffer);
647  }
648 
649 fin:
650  ZE_MessageInfo(20, "TUPLE %s %s %s %s : %ld", ip, name, send, rcpt, result);
651  return result;
652 }
653 
654 
655 /* ****************************************************************************
656  * *
657  * *
658  **************************************************************************** */
659 long
660 check_limit_all_rcpts(prefix, ip, name, netclass, from, rcpt, defval)
661  char *prefix;
662  char *ip;
663  char *name;
664  char *netclass;
665  char *from;
666  rcpt_addr_T *rcpt;
667  long defval;
668 {
669  long result = defval;
670 
671  rcpt_addr_T *p = NULL;
672 
673  for (p = rcpt; p != NULL; p = p->next) {
674  long v;
675 
676  v = check_limit_tuple(prefix, ip, name, netclass, from, p->rcpt, result);
677  v = MAX(0, v);
678  if (result <= 0) {
679  result = v;
680  } else {
681  result = MIN(v, result);
682  }
683  }
684  return result;
685 }
686 
687 /* ****************************************************************************
688  * *
689  * *
690  **************************************************************************** */
691 bool
693 {
694  return db_policy_open(TRUE);
695 }
696 
697 /* ****************************************************************************
698  * *
699  * *
700  **************************************************************************** */
701 bool
703 {
704  return db_policy_close();
705 }
706 
707 /* ****************************************************************************
708  * *
709  * *
710  **************************************************************************** */
711 bool
713 {
714  return db_policy_reopen();
715 }
716 
717 /* ****************************************************************************
718  * *
719  * *
720  **************************************************************************** */
721 int
723  char *code;
724 {
725  if (code == NULL || strlen(code) == 0)
726  return JC_DEFAULT;
727 
728  if (strcasecmp(code, "DEFAULT") == 0)
729  return JC_DEFAULT;
730 
731  if (strcasecmp(code, "REJECT") == 0)
732  return JC_REJECT;
733 
734  if (strcasecmp(code, "OK") == 0)
735  return JC_OK;
736 
737  return JC_DEFAULT;
738 }
739 
740 /* ****************************************************************************
741  * *
742  * *
743  **************************************************************************** */
744 static int
745 access_decode(s)
746  char *s;
747 {
748  if (s == NULL)
749  return ACCESS_UNDEF;
750 
751  if (strcasecmp(s, "NO") == 0)
752  return ACCESS_NO;
753 
754  if (strcasecmp(s, "QUICKNO") == 0)
755  return ACCESS_QUICK_NO;
756 
757  if (strcasecmp(s, "QUICK-NO") == 0)
758  return ACCESS_QUICK_NO;
759 
760  if (strcasecmp(s, "NOQUICK") == 0)
761  return ACCESS_QUICK_NO;
762 
763  if (strcasecmp(s, "NO-QUICK") == 0)
764  return ACCESS_QUICK_NO;
765 
766  if (strcasecmp(s, "YES") == 0)
767  return ACCESS_YES;
768 
769  if (strcasecmp(s, "QUICKYES") == 0)
770  return ACCESS_QUICK_YES;
771 
772  if (strcasecmp(s, "QUICK-YES") == 0)
773  return ACCESS_QUICK_YES;
774 
775  if (strcasecmp(s, "YESQUICK") == 0)
776  return ACCESS_QUICK_YES;
777 
778  if (strcasecmp(s, "YES-QUICK") == 0)
779  return ACCESS_QUICK_YES;
780 
781  return ACCESS_UNDEF;
782 }
#define MAX(a, b)
Definition: macros.h:139
#define OPT_DEFAULT
Definition: ze-cf.h:79
#define STRBOOL(x, t, f)
Definition: macros.h:87
char * rcpt
Definition: ze-rcpt-list.h:31
bool policy_close()
Definition: ze-policy.c:702
bool check_policy_all_rcpts(char *prefix, char *ip, char *name, char *netclass, char *from, rcpt_addr_T *rcpt, bool result, int conflict)
Definition: ze-policy.c:470
#define OPT_ONE_WIN
Definition: ze-cf.h:80
bool check_policy(char *prefix, char *key, char *buf, size_t szbuf, bool chkdefault)
Definition: ze-policy.c:119
bool check_host_policy(char *prefix, char *addr, char *name, char *class, char *buf, size_t size, bool cdef)
Definition: ze-policy.c:205
#define ACCESS_UNDEF
Definition: ze-policy.c:31
int ze_logLevel
Definition: zeSyslog.c:34
#define STRNULL(x, r)
Definition: macros.h:81
bool ok
Definition: ze-connopen.c:59
#define ACCESS_YES
Definition: ze-policy.c:34
#define IPV6_ADDR_REGEX
Definition: macros.h:219
#define FALSE
Definition: macros.h:160
#define strlcpy
Definition: zeString.h:32
#define VAL2LIMIT(r, buffer)
Definition: ze-policy.c:519
#define ACCESS_NO
Definition: ze-policy.c:32
bool zeStrRegex(char *, char *, long *, long *, bool)
Definition: zeStrings.c:544
char * extract_email_address(char *, char *, size_t)
bool policy_reopen()
Definition: ze-policy.c:712
bool db_policy_reopen()
Definition: ze-dbpolicy.c:82
#define ACCESS_QUICK_NO
Definition: ze-policy.c:33
int zeStr2Tokens(char *, int, char **, char *)
Definition: zeStrings.c:610
#define MIN(a, b)
Definition: macros.h:140
bool policy_init()
Definition: ze-policy.c:692
#define ACCESS_QUICK_YES
Definition: ze-policy.c:35
int policy_decode(char *code)
Definition: ze-policy.c:722
#define CF_TO_PASS_TOKEN
Definition: cfh-defs.h:83
bool lookup_policy(char *prefix, char *key, char *buf, size_t szbuf, bool chkdefault)
Definition: ze-policy.c:51
bool db_policy_close()
Definition: ze-dbpolicy.c:105
#define DOMAINNAME_REGEX
Definition: macros.h:216
#define RCPT_OK
Definition: ze-rcpt.h:38
long check_limit_all_rcpts(char *prefix, char *ip, char *name, char *netclass, char *from, rcpt_addr_T *rcpt, long defval)
Definition: ze-policy.c:660
rcpt_addr_T * next
Definition: ze-rcpt-list.h:39
#define CF_FROM_PASS_TOKEN
Definition: cfh-defs.h:82
bool db_policy_check(char *prefix, char *key, char *bufout, size_t szbuf)
Definition: ze-dbpolicy.c:141
#define ZE_MessageInfo(level,...)
Definition: zeSyslog.h:90
bool db_policy_open(bool)
Definition: ze-dbpolicy.c:44
#define JC_DEFAULT
Definition: ze-policy.h:68
#define TRUE
Definition: macros.h:157
#define JC_OK
Definition: ze-policy.h:69
char * cf_get_str(int id)
Definition: ze-cf.c:854
#define MAX_TOKENS
Definition: ze-policy.c:256
#define IPV4_ADDR_REGEX
Definition: macros.h:218
long check_limit_tuple(char *prefix, char *ip, char *name, char *netclass, char *from, char *to, long result)
Definition: ze-policy.c:531
int policy_log_level
Definition: ze-policy.c:39
bool check_policy_tuple(char *prefix, char *ip, char *name, char *netclass, char *from, char *to, bool result)
Definition: ze-policy.c:277
#define JC_REJECT
Definition: ze-policy.h:70
#define OPT_MAJORITY_WIN
Definition: ze-cf.h:81