ze-filter  (ze-filter-0.8.0-develop-180218)
zeMap.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 : Sun Jun 15 21:10:02 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 
25 #include <libze.h>
26 #include <zeStrings.h>
27 
28 #include <ze-filter.h>
29 
30 
31 /* TODO ...
32 ** Verify locks : use map_lock instead of zeDb_lock
33 */
34 
35 #if 0
36 #define MAP_LOCK(map) map_lock(map)
37 #define MAP_UNLOCK(map) map_unlock(map)
38 #else
39 #define MAP_LOCK(map) zeDb_lock(&map->db)
40 #define MAP_UNLOCK(map) zeDb_Unlock(&map->db)
41 #endif
42 
43 /* ****************************************************************************
44  * *
45  * *
46  ******************************************************************************/
47 bool
49  ZEMAP_T *map;
50 {
51  ASSERT(map != NULL);
52  ASSERT(map->signature == SIGNATURE);
53 
54  return TRUE;
55 }
56 
57 /* ****************************************************************************
58  * *
59  * *
60  ******************************************************************************/
61 bool
63  ZEMAP_T *map;
64 {
65  bool res = FALSE;
66 
67  ASSERT(map != NULL);
68  ASSERT(map->signature == SIGNATURE);
69 
70  res = zeDb_OK(&map->db);
71 
72  return res;
73 }
74 
75 /* ****************************************************************************
76  * *
77  * *
78  ******************************************************************************/
79 bool
80 zeMap_Open(map, env, name, rdonly, cache_size)
81  ZEMAP_T *map;
82  ZEDB_ENV_T *env;
83  char *name;
84  int rdonly;
85  size_t cache_size;
86 {
87  bool res = TRUE;
88  long pf = 0;
89  char *s;
90 
91  ASSERT(map != NULL);
92  ASSERT(map->signature == SIGNATURE);
93  ASSERT(name != NULL);
94  ASSERT(strlen(name) > 0);
95 
96  if (zeDb_OK(&map->db))
97  return TRUE;
98 
99  map->rdonly = rdonly;
100  FREE(map->name);
101  map->name = strdup(name);
102  if (map->name == NULL)
103  ZE_LogSysError("strdup(%s)", name);
104 
105  s = "ldap:";
106  if (strncasecmp(map->name, s, strlen(s)) == 0);
107  s = "db:";
108  if (strncasecmp(map->name, s, strlen(s)) == 0);
109  s = "btree:";
110  if (strncasecmp(map->name, s, strlen(s)) == 0);
111  s = "hash:";
112  if (strncasecmp(map->name, s, strlen(s)) == 0);
113  s = "inet:";
114  if (strncasecmp(map->name, s, strlen(s)) == 0);
115  s = "unix:";
116  if (strncasecmp(map->name, s, strlen(s)) == 0);
117  s = "local:";
118  if (strncasecmp(map->name, s, strlen(s)) == 0);
119 
120  if (zeStrRegex(map->name, "^/.*", NULL, &pf, TRUE));
121 
122  map->cache_size = cache_size;
123  map->env = env;
124 
125  if (!zeDb_OK(&map->db))
126  res = zeDb_Open(&map->db, env, name, (map->rdonly ? 0444 : 0644),
127  map->rdonly, TRUE, map->cache_size);
128 
129  return res;
130 }
131 
132 /* ****************************************************************************
133  * *
134  * *
135  ******************************************************************************/
136 bool
138  ZEMAP_T *map;
139 {
140  bool res = TRUE;
141 
142  ASSERT(map != NULL);
143  ASSERT(map->signature == SIGNATURE);
144 
145  if (!zeDb_OK(&map->db))
146  return res;
147 
148  if (zeDb_OK(&map->db))
149  res = zeDb_Close(&map->db);
150 
151  FREE(map->name);
152 
153  return res;
154 }
155 
156 /* ****************************************************************************
157  * *
158  * *
159  ******************************************************************************/
160 bool
162  ZEMAP_T *map;
163 {
164  bool res = FALSE;
165 
166  ASSERT(map != NULL);
167  ASSERT(map->signature == SIGNATURE);
168 
169  if (zeDb_OK(&map->db))
170  res = zeDb_Close(&map->db);
171 
172  res = zeDb_Open(&map->db, map->env, map->name, (map->rdonly ? 0444 : 0644),
173  map->rdonly, FALSE, map->cache_size);
174 
175  return res;
176 }
177 
178 /* ****************************************************************************
179  * *
180  * *
181  ******************************************************************************/
182 bool
183 zeMap_Lookup(map, key, value, size)
184  ZEMAP_T *map;
185  char *key;
186  char *value;
187  size_t size;
188 {
189  bool res = FALSE;
190  char k[256];
191  char v[1024];
192 
193  ASSERT(map != NULL);
194  ASSERT(map->signature == SIGNATURE);
195  ASSERT(key != NULL);
196 
197  if (!zeDb_OK(&map->db)) {
198  ZE_LogMsgError(0, "Lookup on a closed map...");
199  return res;
200  }
201 
202  (void) strlcpy(k, key, sizeof (k));
203  (void) zeStr2Lower(k);
204  memset(v, 0, sizeof (v));
205 
206  if (zeDb_GetRec(&map->db, k, v, sizeof (v))) {
207  if (value != NULL && size > 0)
208  strlcpy(value, v, size);
209 
210  res = TRUE;
211  }
212 
213  return res;
214 }
215 
216 /* ****************************************************************************
217  * *
218  * *
219  ******************************************************************************/
220 bool
221 zeMap_Add(map, key, value, size)
222  ZEMAP_T *map;
223  char *key;
224  char *value;
225  size_t size;
226 {
227  char k[256];
228  bool res = FALSE;
229 
230  ASSERT(map != NULL);
231  ASSERT(map->signature == SIGNATURE);
232  ASSERT(key != NULL);
233  ASSERT(value != NULL);
234 
235  (void) strlcpy(k, key, sizeof (k));
236  (void) zeStr2Lower(k);
237  res = zeDb_AddRec(&map->db, k, value, size);
238 
239  return res;
240 }
241 
242 /* ****************************************************************************
243  * *
244  * *
245  ******************************************************************************/
246 bool
247 zeMap_Delete(map, key)
248  ZEMAP_T *map;
249  char *key;
250 {
251  bool res = FALSE;
252 
253  ASSERT(map != NULL);
254  ASSERT(map->signature == SIGNATURE);
255  ASSERT(key != NULL);
256 
257  res = zeDb_DelRec(&map->db, key);
258 
259  return res;
260 }
261 
262 /* ****************************************************************************
263  * *
264  * *
265  ******************************************************************************/
266 #define BSZ 256
267 
268 bool
269 zeMap_Browse(map, func, arg, skey, ksz, tmax)
270  ZEMAP_T *map;
271  ZEMAP_BROWSE_F func;
272  void *arg;
273  char *skey;
274  size_t ksz;
275  time_t tmax;
276 {
277  bool res = FALSE;
278  bool ok;
279  char kbuf[BSZ], vbuf[BSZ];
280  time_t ti;
281  int nb = 0;
282 
283  ASSERT(map != NULL);
284  ASSERT(map->signature == SIGNATURE);
285 
286  res = zeDb_CursorOpen(&map->db, map->rdonly);
287 
288  memset(kbuf, 0, sizeof (kbuf));
289  memset(vbuf, 0, sizeof (vbuf));
290  if (skey != NULL)
291  strlcpy(kbuf, skey, sizeof (kbuf));
292 
293  ti = time(NULL);
294 
296 
297  for (ok = zeDb_CursorGetFirst(&map->db, kbuf, BSZ, vbuf, BSZ);
298  ok; ok = zeDb_CursorGetNext(&map->db, kbuf, BSZ, vbuf, BSZ)) {
299  nb++;
300  ZE_MessageInfo(19, "MAP : %-20s %s", kbuf, vbuf);
301 
302  DB_BTREE_SEQ_CHECK(kbuf, map->db.database);
303 
304  if (func != NULL) {
305  int r = ZEMAP_BROWSE_CONTINUE;
306 
307  r = func(kbuf, vbuf, arg);
308 
309  if ((r & ZEMAP_BROWSE_DELETE) != 0) {
310  if (!zeDb_CursorDel(&map->db));
311  }
312  if ((r & ZEMAP_BROWSE_STOP) != 0)
313  break;
314  }
315  if (nb % 1000 == 0 && tmax > 0) {
316  time_t tf;
317 
318  tf = time(NULL);
319  if (tf - ti > tmax)
320  break;
321  }
322  }
324  if (!ok) {
325  if (skey != NULL && ksz > 0)
326  *skey = '\0';
327  } else {
328  if (skey != NULL && ksz > 0)
329  strlcpy(skey, kbuf, ksz);
330  }
331 
332  res = zeDb_CursorClose(&map->db);
333 
334  return TRUE;
335 }
336 
337 /* ****************************************************************************
338  * *
339  * *
340  ******************************************************************************/
341 bool
343  ZEMAP_T *map;
344 {
345  bool res = TRUE;
346 
347  ASSERT(map != NULL);
348  ASSERT(map->signature == SIGNATURE);
349 
350  MUTEX_LOCK(&map->mutex);
351 
352  return res;
353 }
354 
355 /* ****************************************************************************
356  * *
357  * *
358  ******************************************************************************/
359 bool
361  ZEMAP_T *map;
362 {
363  bool res = TRUE;
364 
365  ASSERT(map != NULL);
366  ASSERT(map->signature == SIGNATURE);
367 
368  MUTEX_UNLOCK(&map->mutex);
369 
370  return res;
371 }
372 
373 /* ****************************************************************************
374  * *
375  * *
376  ******************************************************************************/
377 bool
379  ZEMAP_T *map;
380 {
381  bool res = FALSE;
382 
383  ASSERT(map != NULL);
384  ASSERT(map->signature == SIGNATURE);
385 
386  res = zeDb_Flush(&map->db);
387 
388  return res;
389 }
bool zeMap_Reopen(ZEMAP_T *map)
Definition: zeMap.c:161
#define ZEMAP_BROWSE_CONTINUE
Definition: zeMap.h:53
bool zeDb_AddRec(ZEDB_T *h, char *, void *, size_t)
Definition: zeDb.c:750
#define ASSERT(a)
Definition: macros.h:27
bool zeMap_Add(ZEMAP_T *map, char *key, char *value, size_t size)
Definition: zeMap.c:221
bool zeDb_OK(ZEDB_T *h)
Definition: zeDb.c:649
#define FREE(x)
Definition: macros.h:37
#define ZEMAP_BROWSE_STOP
Definition: zeMap.h:54
ZEDB_T db
Definition: zeMap.h:34
bool zeMap_OK(ZEMAP_T *map)
Definition: zeMap.c:62
#define MUTEX_UNLOCK(mutex)
Definition: macros.h:101
bool zeMap_Init(ZEMAP_T *map)
Definition: zeMap.c:48
bool ok
Definition: ze-connopen.c:59
#define MUTEX_LOCK(mutex)
Definition: macros.h:93
bool zeMap_Browse(ZEMAP_T *map, ZEMAP_BROWSE_F func, void *arg, char *skey, size_t ksz, time_t tmax)
Definition: zeMap.c:269
#define FALSE
Definition: macros.h:160
#define DB_BTREE_SEQ_START()
Definition: zeDb.h:176
#define ZEMAP_BROWSE_DELETE
Definition: zeMap.h:55
#define strlcpy
Definition: zeString.h:32
#define ZE_LogMsgError(level,...)
Definition: zeSyslog.h:113
bool zeDb_CursorGetFirst(ZEDB_T *h, char *, size_t, void *, size_t)
Definition: zeDb.c:1041
bool zeStrRegex(char *, char *, long *, long *, bool)
Definition: zeStrings.c:544
bool zeDb_DelRec(ZEDB_T *h, char *)
Definition: zeDb.c:863
bool zeMap_Lock(ZEMAP_T *map)
Definition: zeMap.c:342
pthread_mutex_t mutex
Definition: zeMap.h:30
int signature
Definition: zeMap.h:29
bool zeMap_Delete(ZEMAP_T *map, char *key)
Definition: zeMap.c:247
bool zeDb_Open(ZEDB_T *h, ZEDB_ENV_T *, char *, int, bool, bool, size_t)
Definition: zeDb.c:462
Definition: zeMap.h:27
bool zeDb_Close(ZEDB_T *h)
Definition: zeDb.c:667
#define DB_BTREE_SEQ_END()
Definition: zeDb.h:196
size_t cache_size
Definition: zeMap.h:33
int rdonly
Definition: zeMap.h:32
#define ZE_MessageInfo(level,...)
Definition: zeSyslog.h:90
char * database
Definition: zeDb.h:50
int nb
Definition: ze-connopen.c:61
bool zeDb_GetRec(ZEDB_T *h, char *, void *, size_t)
Definition: zeDb.c:791
bool zeMap_Flush(ZEMAP_T *map)
Definition: zeMap.c:378
#define TRUE
Definition: macros.h:157
bool zeMap_Open(ZEMAP_T *map, ZEDB_ENV_T *env, char *name, int rdonly, size_t cache_size)
Definition: zeMap.c:80
#define ZE_LogSysError(...)
Definition: zeSyslog.h:129
#define BSZ
Definition: zeMap.c:266
int(* ZEMAP_BROWSE_F)(char *, char *, void *)
Definition: zeMap.h:57
bool zeDb_CursorOpen(ZEDB_T *h, bool)
Definition: zeDb.c:936
void ZEDB_ENV_T
Definition: zeDb.h:85
bool zeDb_CursorDel(ZEDB_T *h)
Definition: zeDb.c:1189
ZEDB_ENV_T * env
Definition: zeMap.h:35
#define DB_BTREE_SEQ_CHECK(key, dbname)
Definition: zeDb.h:182
char * zeStr2Lower(char *)
Definition: zeStrings.c:295
bool zeDb_CursorClose(ZEDB_T *h)
Definition: zeDb.c:991
bool zeMap_Lookup(ZEMAP_T *map, char *key, char *value, size_t size)
Definition: zeMap.c:183
bool zeMap_Unlock(ZEMAP_T *map)
Definition: zeMap.c:360
bool zeMap_Close(ZEMAP_T *map)
Definition: zeMap.c:137
#define SIGNATURE
Definition: ze-libjc.h:75
char * name
Definition: zeMap.h:31
bool zeDb_CursorGetNext(ZEDB_T *h, char *, size_t, void *, size_t)
Definition: zeDb.c:1116
bool zeDb_Flush(ZEDB_T *h)
Definition: zeDb.c:725