ze-filter  (ze-filter-0.8.0-develop-180218)
zePolicy.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 : Mon Jun 16 08:45:55 CEST 2014
13  *
14  * This program is free software - GPL v2.,
15  *
16  * This program is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
19  *
20  */
21 
22 
23 #include <ze-sys.h>
24 #include <ze-filter.h>
25 #include <zePolicy.h>
26 
27 
28 
29 static bool stPolicyLookupDomain(char *prefix, char *key, char *buf,
30  size_t size, bool recurse,
31  bool chkDefault);
32 
33 static bool stPolicyLookupIPv4Addr(char *prefix, char *key, char *buf,
34  size_t size, bool recurse,
35  bool chkDefault);
36 
37 static bool stPolicyLookupIPv6Addr(char *prefix, char *key, char *buf,
38  size_t size, bool recurse,
39  bool chkDefault);
40 static bool stPolicyLookupNetClass(char *addr, char *name,
41  netclass_T * class, char *buf,
42  size_t size, bool recurse);
43 
44 static bool stPolicyLookupEmailAddr(char *prefix, char *key,
45  char *buf, size_t size,
46  bool recurse, bool chkDefault);
47 
48 
49 static void
50 zmStrDump(s)
51  char *s;
52 {
53  char buf[1024];
54 
55  if (s == NULL)
56  return;
57  for (; *s != '\0'; s++) {
58  char tbuf[10];
59 
60  snprintf(tbuf, sizeof (tbuf), "%02x ", *s);
61  strlcat(buf, tbuf, sizeof (buf));
62 
63  }
64  ZE_MessageInfo(0, "* %s", buf);
65 }
66 
67 /* ****************************************************************************
68  * *
69  * *
70  ******************************************************************************/
71 #define FILL_NETCLASS(cPtr, label, equiv, class) \
72  do { \
73  memset((cPtr), 0, sizeof(cPtr)); \
74  (cPtr)->ok = FALSE; \
75  if ((label) != NULL) \
76  { \
77  strlcpy((cPtr)->label, 0, sizeof((cPtr)->label)); \
78  (cPtr)->ok = TRUE; \
79  } \
80  if ((equiv) != NULL) \
81  strlcpy((cPtr)->equiv, 0, sizeof((cPtr)->equiv)); \
82  (cPtr)->class = NET_UNKNOWN; \
83  } while (0)
84 
85 bool
86 PolicyLookupClient(prefix, addr, name, netClass, buf, bufSize)
87  char *prefix;
88  char *addr;
89  char *name;
90  netclass_T *netClass;
91  char *buf;
92  size_t bufSize;
93 {
94  bool ok = FALSE;
95  char *addrKey = NULL;
96  char *argv[32];
97  int argc;
98  int i;
99  char classBuf[1024];
100  netclass_T gClass = NETCLASS_INITIALIZER;
101 
102 #if 0
103  if (key == NULL || strlen(key) == 0)
104  goto fin;
105 #endif
106 
107  if (addr != NULL) {
108  ok = db_policy_lookup(prefix, addr, buf, bufSize);
109  if (ok)
110  return ok;
111  }
112  if (name != NULL) {
113  ok = db_policy_lookup(prefix, name, buf, bufSize);
114  if (ok)
115  return ok;
116  }
117 
118  /*
119  * fill netclass rec
120  */
121  if (netClass != NULL && netClass->ok)
122  gClass = *netClass;
123 
124  if (!gClass.ok) {
125  char netBuf[128];
126 
127  (void) PolicyLookupNetClass(addr, name, &gClass, netBuf, sizeof (netBuf));
128  }
129 
130  if (gClass.ok && strlen(gClass.equiv) == 0) {
131  (void) db_policy_lookup("NetClassEquiv", gClass.label, gClass.equiv,
132  sizeof (gClass.equiv));
133  }
134 
135  if (gClass.ok) {
136  if (strlen(gClass.label) > 0) {
137  ok = db_policy_lookup(prefix, gClass.label, buf, bufSize);
138  if (ok)
139  return ok;
140  }
141  if (strlen(gClass.equiv) > 0) {
142  ok = db_policy_lookup(prefix, gClass.equiv, buf, bufSize);
143  if (ok)
144  return ok;
145  }
146  }
147 
148  if (addr != NULL) {
149  ok = stPolicyLookupIPv4Addr(prefix, addr, buf, bufSize, TRUE, FALSE);
150  if (ok)
151  return ok;
152  }
153  if (name != NULL) {
154  ok = stPolicyLookupDomain(prefix, name, buf, bufSize, TRUE, FALSE);
155  if (ok)
156  return ok;
157  }
158 
159 fin:
160  if (!ok)
161  ok = db_policy_lookup(prefix, "*", buf, bufSize);
162  if (!ok)
163  ok = db_policy_lookup(prefix, "default", buf, bufSize);
164 
165  return ok;
166 }
167 
168 /* ****************************************************************************
169  * *
170  * *
171  ******************************************************************************/
172 bool
173 PolicyLookupDomain(prefix, key, buf, size)
174  char *prefix;
175  char *key;
176  char *buf;
177  size_t size;
178 {
179  return stPolicyLookupDomain(prefix, key, buf, size, TRUE, TRUE);
180 }
181 
182 /* ****************************************************************************
183  * *
184  * *
185  ******************************************************************************/
186 bool
187 PolicyLookupIPv4Addr(prefix, key, buf, size)
188  char *prefix;
189  char *key;
190  char *buf;
191  size_t size;
192 {
193  return stPolicyLookupIPv4Addr(prefix, key, buf, size, TRUE, TRUE);
194 }
195 
196 /* ****************************************************************************
197  * *
198  * *
199  ******************************************************************************/
200 bool
201 PolicyLookupIPv6Addr(prefix, key, buf, size)
202  char *prefix;
203  char *key;
204  char *buf;
205  size_t size;
206 {
207  return stPolicyLookupIPv6Addr(prefix, key, buf, size, TRUE, TRUE);
208 }
209 
210 /* ****************************************************************************
211  * *
212  * *
213  ******************************************************************************/
214 bool
215 PolicyLookupNetClass(addr, name, class, buf, size)
216  char *addr;
217  char *name;
218  netclass_T *class;
219  char *buf;
220  size_t size;
221 {
222  return stPolicyLookupNetClass(addr, name, class, buf, size, TRUE);
223 }
224 
225 /* ****************************************************************************
226  * *
227  * *
228  ******************************************************************************/
229 bool
230 PolicyLookupEmailAddr(prefix, key, buf, size)
231  char *prefix;
232  char *key;
233  char *buf;
234  size_t size;
235 {
236  return stPolicyLookupEmailAddr(prefix, key, buf, size, TRUE, TRUE);
237 }
238 
239 /* ****************************************************************************
240  * *
241  * *
242  ******************************************************************************/
243 bool
244 PolicyLookupTuple(prefix, addr, name, netclass, from, to, result)
245  char *prefix;
246  char *addr;
247  char *name;
248  char *netclass;
249  char *from;
250  char *to;
251  bool result;
252 {
253 }
254 
255 
256 /* ****************************************************************************
257  * *
258  * *
259  ******************************************************************************/
260 bool
261 zmPolicyInit()
262 {
263  return TRUE;
264 }
265 
266 bool
267 zmPolicyOpen()
268 {
269  return TRUE;
270 }
271 
272 bool
273 zmPolicyClose()
274 {
275  return TRUE;
276 }
277 
278 bool
279 zmPolicyReopen()
280 {
281  return TRUE;
282 }
283 
284 /* ****************************************************************************
285  * *
286  * *
287  ******************************************************************************/
288 static bool
289 stPolicyLookupDomain(prefix, key, buf, bufSize, recurse, chkDefault)
290  char *prefix;
291  char *key;
292  char *buf;
293  size_t bufSize;
294  bool recurse;
295  bool chkDefault;
296 {
297  bool ok = FALSE;
298  char *domKey = NULL;
299  char *argv[32];
300  int argc;
301  int i;
302 
303  if (key == NULL || strlen(key) == 0)
304  goto fin;
305 
306  ok = db_policy_lookup(prefix, key, buf, bufSize);
307  if (ok)
308  goto fin;
309 
310  if (recurse) {
311  domKey = strdup(key);
312  if (domKey == NULL) {
313  ZE_LogSysError("Can't strdup(%s)", key);
314  goto fin;
315  }
316  argc = zeStr2Tokens(domKey, 32, argv, ".");
317  for (i = 0; i < argc && !ok; i++) {
318  char *lKey = NULL;
319 
320  argv[i] = "*";
321  lKey = zeStrJoin(".", argc - i, &argv[i]);
322  ok = db_policy_lookup(prefix, lKey, buf, bufSize);
323  FREE(lKey);
324  }
325  FREE(domKey);
326  }
327 
328 fin:
329  if (!ok && chkDefault)
330  ok = db_policy_lookup(prefix, "*", buf, bufSize);
331  if (!ok && chkDefault)
332  ok = db_policy_lookup(prefix, "default", buf, bufSize);
333 
334  return ok;
335 }
336 
337 
338 /* ****************************************************************************
339  * *
340  * *
341  ******************************************************************************/
342 static bool
343 stPolicyLookupIPv4Addr(prefix, key, buf, bufSize, recurse, chkDefault)
344  char *prefix;
345  char *key;
346  char *buf;
347  size_t bufSize;
348  bool recurse;
349  bool chkDefault;
350 {
351  bool ok = FALSE;
352  char *addrKey = NULL;
353  char *argv[32];
354  int argc;
355  int i;
356 
357  if (key == NULL || strlen(key) == 0)
358  goto fin;
359 
360  ok = db_policy_lookup(prefix, key, buf, bufSize);
361  if (ok)
362  return ok;
363 
364  if (recurse) {
365  addrKey = strdup(key);
366  if (addrKey == NULL) {
367  ZE_LogSysError("Can't strdup(%s)", key);
368  goto fin;
369  }
370  argc = zeStr2Tokens(addrKey, 32, argv, ".");
371  for (i = argc - 1; i > 0 && !ok; i--) {
372  char *lKey = NULL;
373 
374  lKey = zeStrJoin(".", i, argv);
375  ok = db_policy_lookup(prefix, lKey, buf, bufSize);
376  FREE(lKey);
377  }
378  FREE(addrKey);
379  }
380 
381 fin:
382  if (!ok && chkDefault)
383  ok = db_policy_lookup(prefix, "*", buf, bufSize);
384  if (!ok && chkDefault)
385  ok = db_policy_lookup(prefix, "default", buf, bufSize);
386 
387  return ok;
388 }
389 
390 /* ****************************************************************************
391  * *
392  * *
393  ******************************************************************************/
394 static bool
395 stPolicyLookupIPv6Addr(prefix, key, buf, bufSize, recurse, chkDefault)
396  char *prefix;
397  char *key;
398  char *buf;
399  size_t bufSize;
400  bool recurse;
401  bool chkDefault;
402 {
403  bool ok = FALSE;
404  char *addrKey = NULL;
405  char *argv[32];
406  int argc;
407  int i;
408 
409  if (key == NULL || strlen(key) == 0)
410  goto fin;
411 
412  ok = db_policy_lookup(prefix, key, buf, bufSize);
413  if (ok)
414  return ok;
415 
416  if (recurse) {
417  addrKey = strdup(key);
418  if (addrKey == NULL) {
419  ZE_LogSysError("Can't strdup(%s)", key);
420  goto fin;
421  }
422  argc = zeStr2Tokens(addrKey, 32, argv, ".");
423  for (i = argc; i > 0 && !ok; i--) {
424  char *lKey = NULL;
425 
426  lKey = zeStrJoin(".", argc, argv);
427  ok = db_policy_lookup(prefix, lKey, buf, bufSize);
428  FREE(lKey);
429  }
430  FREE(addrKey);
431  }
432 
433 fin:
434  if (!ok && chkDefault)
435  ok = db_policy_lookup(prefix, "*", buf, bufSize);
436  if (!ok && chkDefault)
437  ok = db_policy_lookup(prefix, "default", buf, bufSize);
438 
439  return ok;
440 }
441 
442 /* ****************************************************************************
443  * *
444  * *
445  ******************************************************************************/
446 static bool
447 stPolicyLookupNetClass(addr, name, class, buf, bufSize, recurse)
448  char *addr;
449  char *name;
450  netclass_T *class;
451  char *buf;
452  size_t bufSize;
453  bool recurse;
454 {
455  bool ok = FALSE;
456 
457  if ((addr == NULL || strlen(addr) == 0)
458  && (name == NULL || strlen(name) == 0))
459  goto fin;
460 
461  ok = db_policy_lookup("NetClass", addr, buf, bufSize);
462  if (ok)
463  goto fin;
464 
465  if (recurse) {
466  char *addrKey = NULL;
467  int argc;
468  char *argv[32];
469  int i;
470 
471  addrKey = strdup(addr);
472  if (addrKey == NULL) {
473  ZE_LogSysError("Can't strdup(%s)", addr);
474  goto fin;
475  }
476  argc = zeStr2Tokens(addrKey, 32, argv, ".");
477  for (i = argc - 1; i > 0 && !ok; i--) {
478  char *lKey = NULL;
479 
480  lKey = zeStrJoin(".", i, argv);
481  ok = db_policy_lookup("NetClass", lKey, buf, bufSize);
482  FREE(lKey);
483  }
484 
485  FREE(addrKey);
486 
487  if (ok)
488  goto fin;
489  }
490 
491  ok = db_policy_lookup("NetClass", name, buf, bufSize);
492  if (ok)
493  goto fin;
494 
495  if (recurse) {
496  char *nameKey = NULL;
497  int argc;
498  char *argv[32];
499  int i;
500 
501  nameKey = strdup(name);
502  if (nameKey == NULL) {
503  ZE_LogSysError("Can't strdup(%s)", name);
504  goto fin;
505  }
506  argc = zeStr2Tokens(nameKey, 32, argv, ".");
507  for (i = 0; i < argc && !ok; i++) {
508  char *lKey = NULL;
509 
510  argv[i] = "*";
511  lKey = zeStrJoin(".", argc - i, &argv[i]);
512  ok = db_policy_lookup("NetClass", lKey, buf, bufSize);
513  FREE(lKey);
514  }
515 
516  FREE(nameKey);
517 
518  if (ok)
519  goto fin;
520  }
521 
522 fin:
523  if (ok && class != NULL) {
524  bool tOK = FALSE;
525  char tBuf[128];
526 
527  memset(class, 0, sizeof (*class));
528  class->ok = TRUE;
529 
530  strlcpy(class->label, buf, sizeof (class->label));
531  class->class = DecodeNetClass(buf, NULL, 0);
532 
533  tOK = db_policy_lookup("NetClassEquiv", buf, tBuf, sizeof (tBuf));
534  if (tOK) {
535  strlcpy(class->equiv, tBuf, sizeof (class->equiv));
536  class->class |= DecodeNetClass(tBuf, NULL, 0);
537  }
538  }
539  return ok;
540 
541 }
542 
543 /* ****************************************************************************
544  * *
545  * *
546  ******************************************************************************/
547 static bool
548 stPolicyLookupEmailAddr(prefix, key, buf, bufSize, recurse, chkDefault)
549  char *prefix;
550  char *key;
551  char *buf;
552  size_t bufSize;
553  bool recurse;
554  bool chkDefault;
555 {
556  bool ok = FALSE;
557  char *emailKey = NULL;
558  int i;
559  char kBuf[1024];
560  char *userKey = NULL, *domKey = NULL, *p;
561 
562  if (key == NULL || strlen(key) == 0)
563  goto fin;
564 
565  ok = db_policy_lookup(prefix, key, buf, bufSize);
566  if (ok)
567  return ok;
568 
569  if (STRCASEEQUAL("nullsender", key))
570  goto fin;
571 
572  emailKey = strdup(key);
573  if (emailKey == NULL) {
574  ZE_LogSysError("Can't strdup(%s)", key);
575  goto fin;
576  }
577  if ((p = strchr(emailKey, '@')) != NULL) {
578  *p = '\0';
579  domKey = ++p;
580  userKey = emailKey;
581  } else {
582  domKey = emailKey;
583  userKey = "";
584  }
585 
586  if (strlen(domKey) > 0) {
587  snprintf(kBuf, sizeof (kBuf), "%s@%s", "*", domKey);
588  ok = db_policy_lookup(prefix, kBuf, buf, bufSize);
589  if (ok)
590  goto fin;
591  }
592 
593 
594  if (strlen(domKey) > 0) {
595  ok = db_policy_lookup(prefix, domKey, buf, bufSize);
596  if (ok)
597  goto fin;
598  }
599 
600  if (recurse) {
601  char *argv[32], *argvT[32];
602  int argc;
603 
604  argc = zeStr2Tokens(domKey, 32, argv, ".");
605 
606  memcpy(argvT, argv, sizeof (argvT));
607  for (i = 0; i < argc && !ok; i++) {
608  char *lKey = NULL;
609 
610  argvT[i] = "*";
611  lKey = zeStrJoin(".", argc - i, &argvT[i]);
612 
613  snprintf(kBuf, sizeof (kBuf), "%s@%s", userKey, lKey);
614  ok = db_policy_lookup(prefix, kBuf, buf, bufSize);
615  if (ok) {
616  FREE(lKey);
617  break;
618  }
619 
620  snprintf(kBuf, sizeof (kBuf), "%s@%s", "*", lKey);
621  ok = db_policy_lookup(prefix, kBuf, buf, bufSize);
622  if (ok) {
623  FREE(lKey);
624  break;
625  }
626 
627  ok = db_policy_lookup(prefix, lKey, buf, bufSize);
628  FREE(lKey);
629  }
630  if (ok)
631  goto fin;
632  }
633 
634  snprintf(kBuf, sizeof (kBuf), "%s@%s", "*", "*");
635  ok = db_policy_lookup(prefix, kBuf, buf, bufSize);
636  if (ok)
637  goto fin;
638 
639 fin:
640  FREE(emailKey);
641 
642  if (!ok && chkDefault)
643  ok = db_policy_lookup(prefix, "*", buf, bufSize);
644  if (!ok && chkDefault)
645  ok = db_policy_lookup(prefix, "default", buf, bufSize);
646 
647  return ok;
648 }
zmPolicyInit
bool zmPolicyInit()
Definition: zePolicy.c:261
netclass_T::equiv
char equiv[32]
Definition: ze-netclass.h:73
zeStrJoin
char * zeStrJoin(char *, int, char **)
Definition: zeStrings.c:224
PolicyLookupIPv6Addr
bool PolicyLookupIPv6Addr(char *prefix, char *key, char *buf, size_t size)
Definition: zePolicy.c:201
PolicyLookupEmailAddr
bool PolicyLookupEmailAddr(char *prefix, char *key, char *buf, size_t size)
Definition: zePolicy.c:230
netclass_T::ok
bool ok
Definition: ze-netclass.h:70
FREE
#define FREE(x)
Definition: macros.h:37
ok
bool ok
Definition: ze-connopen.c:59
NETCLASS_INITIALIZER
#define NETCLASS_INITIALIZER
Definition: ze-netclass.h:76
db_policy_lookup
bool db_policy_lookup(char *prefix, char *key, char *bufout, size_t szbuf)
Definition: ze-dbpolicy.c:370
FALSE
#define FALSE
Definition: macros.h:160
strlcpy
#define strlcpy
Definition: zeString.h:32
PolicyLookupDomain
bool PolicyLookupDomain(char *prefix, char *key, char *buf, size_t size)
Definition: zePolicy.c:173
zeStr2Tokens
int zeStr2Tokens(char *, int, char **, char *)
Definition: zeStrings.c:610
PolicyLookupNetClass
bool PolicyLookupNetClass(char *addr, char *name, netclass_T *class, char *buf, size_t size)
Definition: zePolicy.c:215
strlcat
#define strlcat
Definition: zeString.h:28
strchr
#define strchr
Definition: ze-sys.h:218
PolicyLookupIPv4Addr
bool PolicyLookupIPv4Addr(char *prefix, char *key, char *buf, size_t size)
Definition: zePolicy.c:187
netclass_T
Definition: ze-netclass.h:69
PolicyLookupClient
bool PolicyLookupClient(char *prefix, char *addr, char *name, netclass_T *netClass, char *buf, size_t bufSize)
Definition: zePolicy.c:86
ZE_MessageInfo
#define ZE_MessageInfo(level,...)
Definition: zeSyslog.h:90
TRUE
#define TRUE
Definition: macros.h:157
memcpy
#define memcpy(d, s, n)
Definition: ze-sys.h:224
ZE_LogSysError
#define ZE_LogSysError(...)
Definition: zeSyslog.h:129
PolicyLookupTuple
bool PolicyLookupTuple(char *prefix, char *addr, char *name, char *netclass, char *from, char *to, bool result)
Definition: zePolicy.c:244
STRCASEEQUAL
#define STRCASEEQUAL(a, b)
Definition: macros.h:72
netclass_T::label
char label[32]
Definition: ze-netclass.h:72
DecodeNetClass
int DecodeNetClass(char *, char *, size_t)
Definition: ze-netclass.c:124
zmPolicyClose
bool zmPolicyClose()
Definition: zePolicy.c:273
zmPolicyOpen
bool zmPolicyOpen()
Definition: zePolicy.c:267
zmPolicyReopen
bool zmPolicyReopen()
Definition: zePolicy.c:279