r14996: Fix compilation of gencache
[bbaumbach/samba-autobuild/.git] / source4 / lib / gencache / gencache.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    Generic, persistent and shared between processes cache mechanism for use
5    by various parts of the Samba code
6
7    Copyright (C) Rafal Szczesniak    2002
8    
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 2 of the License, or
12    (at your option) any later version.
13    
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #include "includes.h"
25 #include "lib/tdb/include/tdbutil.h"
26 #include "system/time.h"
27 #include "system/filesys.h"
28 #include "db_wrap.h"
29 #include "lib/gencache/gencache.h"
30
31 #define TIMEOUT_LEN 12
32 #define CACHE_DATA_FMT  "%12u/%s"
33
34 static struct tdb_wrap *cache;
35
36 /**
37  * @file gencache.c
38  * @brief Generic, persistent and shared between processes cache mechanism
39  *        for use by various parts of the Samba code
40  *
41  **/
42
43
44 /**
45  * Cache initialisation function. Opens cache tdb file or creates
46  * it if does not exist.
47  *
48  * @return true on successful initialisation of the cache or
49  *         false on failure
50  **/
51
52 BOOL gencache_init(void)
53 {
54         char* cache_fname = NULL;
55         
56         /* skip file open if it's already opened */
57         if (cache) return True;
58
59         asprintf(&cache_fname, "%s/%s", lp_lockdir(), "gencache.tdb");
60         if (cache_fname)
61                 DEBUG(5, ("Opening cache file at %s\n", cache_fname));
62         else {
63                 DEBUG(0, ("Filename allocation failed.\n"));
64                 return False;
65         }
66
67         cache = tdb_wrap_open(NULL, cache_fname, 0, TDB_DEFAULT,
68                               O_RDWR|O_CREAT, 0644);
69
70         SAFE_FREE(cache_fname);
71         if (!cache) {
72                 DEBUG(5, ("Attempt to open gencache.tdb has failed.\n"));
73                 return False;
74         }
75         return True;
76 }
77
78
79 /**
80  * Cache shutdown function. Closes opened cache tdb file.
81  *
82  * @return true on successful closing the cache or
83  *         false on failure during cache shutdown
84  **/
85  
86 BOOL gencache_shutdown(void)
87 {
88         if (!cache) return False;
89         DEBUG(5, ("Closing cache file\n"));
90         talloc_free(cache);
91         return True;
92 }
93
94
95 /**
96  * Set an entry in the cache file. If there's no such
97  * one, then add it.
98  *
99  * @param keystr string that represents a key of this entry
100  * @param value text representation value being cached
101  * @param timeout time when the value is expired
102  *
103  * @retval true when entry is successfuly stored
104  * @retval false on failure
105  **/
106  
107 BOOL gencache_set(const char *keystr, const char *value, time_t timeout)
108 {
109         int ret;
110         TDB_DATA keybuf, databuf;
111         char* valstr = NULL;
112         
113         /* fail completely if get null pointers passed */
114         SMB_ASSERT(keystr && value);
115
116         if (!gencache_init()) return False;
117         
118         asprintf(&valstr, CACHE_DATA_FMT, (int)timeout, value);
119         if (!valstr)
120                 return False;
121
122         keybuf.dptr = strdup(keystr);
123         keybuf.dsize = strlen(keystr)+1;
124         databuf.dptr = strdup(valstr);
125         databuf.dsize = strlen(valstr)+1;
126         DEBUG(10, ("Adding cache entry with key = %s; value = %s and timeout \
127                    = %s (%d seconds %s)\n", keybuf.dptr, value, ctime(&timeout),
128                    (int)(timeout - time(NULL)), timeout > time(NULL) ? "ahead" : "in the past"));
129                 
130         ret = tdb_store(cache->tdb, keybuf, databuf, 0);
131         SAFE_FREE(valstr);
132         SAFE_FREE(keybuf.dptr);
133         SAFE_FREE(databuf.dptr);
134         
135         return ret == 0;
136 }
137
138
139 /**
140  * Set existing entry to the cache file.
141  *
142  * @param keystr string that represents a key of this entry
143  * @param valstr text representation value being cached
144  * @param timeout time when the value is expired
145  *
146  * @retval true when entry is successfuly set
147  * @retval false on failure
148  **/
149
150 BOOL gencache_set_only(const char *keystr, const char *valstr, time_t timeout)
151 {
152         int ret = -1;
153         TDB_DATA keybuf, databuf;
154         char *old_valstr, *datastr;
155         time_t old_timeout;
156         
157         /* fail completely if get null pointers passed */
158         SMB_ASSERT(keystr && valstr);
159
160         if (!gencache_init()) return False;
161                         
162         /* 
163          * Check whether entry exists in the cache
164          * Don't verify gencache_get exit code, since the entry may be expired
165          */     
166         gencache_get(keystr, &old_valstr, &old_timeout);
167         
168         if (!(old_valstr && old_timeout)) return False;
169                 
170         DEBUG(10, ("Setting cache entry with key = %s; old value = %s and old timeout \
171                    = %s\n", keystr, old_valstr, ctime(&old_timeout)));
172
173         asprintf(&datastr, CACHE_DATA_FMT, (int)timeout, valstr);
174         keybuf.dptr = strdup(keystr);
175         keybuf.dsize = strlen(keystr)+1;
176         databuf.dptr = strdup(datastr);
177         databuf.dsize = strlen(datastr)+1;
178         DEBUGADD(10, ("New value = %s, new timeout = %s (%d seconds %s)", valstr,
179                       ctime(&timeout), (int)(timeout - time(NULL)),
180                       timeout > time(NULL) ? "ahead" : "in the past"));
181
182                 
183         ret = tdb_store(cache->tdb, keybuf, databuf, TDB_REPLACE);
184
185         SAFE_FREE(datastr);
186         SAFE_FREE(old_valstr);
187         SAFE_FREE(keybuf.dptr);
188         SAFE_FREE(databuf.dptr);
189         
190         return ret == 0;
191 }
192  
193
194 /**
195  * Delete one entry from the cache file.
196  *
197  * @param keystr string that represents a key of this entry
198  *
199  * @retval true upon successful deletion
200  * @retval false in case of failure
201  **/
202
203 BOOL gencache_del(const char *keystr)
204 {
205         int ret;
206         TDB_DATA keybuf;
207         
208         /* fail completely if get null pointers passed */
209         SMB_ASSERT(keystr);
210
211         if (!gencache_init()) return False;     
212         
213         keybuf.dptr = strdup(keystr);
214         keybuf.dsize = strlen(keystr)+1;
215         DEBUG(10, ("Deleting cache entry (key = %s)\n", keystr));
216         ret = tdb_delete(cache->tdb, keybuf);
217         
218         SAFE_FREE(keybuf.dptr);
219         return ret == 0;
220 }
221
222
223 /**
224  * Get existing entry from the cache file.
225  *
226  * @param keystr string that represents a key of this entry
227  * @param valstr buffer that is allocated and filled with the entry value
228  *        buffer's disposing must be done outside
229  * @param timeout pointer to a time_t that is filled with entry's
230  *        timeout
231  *
232  * @retval true when entry is successfuly fetched
233  * @retval False for failure
234  **/
235
236 BOOL gencache_get(const char *keystr, char **valstr, time_t *timeout)
237 {
238         TDB_DATA keybuf, databuf;
239
240         /* fail completely if get null pointers passed */
241         SMB_ASSERT(keystr);
242
243         if (!gencache_init())
244                 return False;
245         
246         keybuf.dptr = strdup(keystr);
247         keybuf.dsize = strlen(keystr)+1;
248         databuf = tdb_fetch(cache->tdb, keybuf);
249         SAFE_FREE(keybuf.dptr);
250         
251         if (databuf.dptr && databuf.dsize > TIMEOUT_LEN) {
252                 char* entry_buf = strndup(databuf.dptr, databuf.dsize);
253                 char *v;
254                 time_t t;
255                 unsigned i;
256
257                 v = malloc_array_p(char, databuf.dsize - TIMEOUT_LEN);
258                                 
259                 SAFE_FREE(databuf.dptr);
260                 sscanf(entry_buf, CACHE_DATA_FMT, (int*)&i, v);
261                 SAFE_FREE(entry_buf);
262                 t = i;
263
264                 DEBUG(10, ("Returning %s cache entry: key = %s, value = %s, "
265                            "timeout = %s\n", t > time(NULL) ? "valid" :
266                            "expired", keystr, v, ctime(&t)));
267
268                 if (valstr)
269                         *valstr = v;
270                 else
271                         SAFE_FREE(v);
272
273                 if (timeout)
274                         *timeout = t;
275
276                 return t > time(NULL);
277
278         } else {
279                 SAFE_FREE(databuf.dptr);
280
281                 if (valstr)
282                         *valstr = NULL;
283
284                 if (timeout)
285                         timeout = NULL;
286
287                 DEBUG(10, ("Cache entry with key = %s couldn't be found\n", 
288                            keystr));
289
290                 return False;
291         }
292 }
293
294
295 /**
296  * Iterate through all entries which key matches to specified pattern
297  *
298  * @param fn pointer to the function that will be supplied with each single
299  *        matching cache entry (key, value and timeout) as an arguments
300  * @param data void pointer to an arbitrary data that is passed directly to the fn
301  *        function on each call
302  * @param keystr_pattern pattern the existing entries' keys are matched to
303  *
304  **/
305
306 void gencache_iterate(void (*fn)(const char* key, const char *value, time_t timeout, void* dptr),
307                       void* data, const char* keystr_pattern)
308 {
309         TDB_LIST_NODE *node, *first_node;
310         TDB_DATA databuf;
311         char *keystr = NULL, *valstr = NULL, *entry = NULL;
312         time_t timeout = 0;
313         unsigned i;
314
315         /* fail completely if get null pointers passed */
316         SMB_ASSERT(fn && keystr_pattern);
317
318         if (!gencache_init()) return;
319
320         DEBUG(5, ("Searching cache keys with pattern %s\n", keystr_pattern));
321         node = tdb_search_keys(cache->tdb, keystr_pattern);
322         first_node = node;
323         
324         while (node) {
325                 /* ensure null termination of the key string */
326                 keystr = strndup(node->node_key.dptr, node->node_key.dsize);
327                 
328                 /* 
329                  * We don't use gencache_get function, because we need to iterate through
330                  * all of the entries. Validity verification is up to fn routine.
331                  */
332                 databuf = tdb_fetch(cache->tdb, node->node_key);
333                 if (!databuf.dptr || databuf.dsize <= TIMEOUT_LEN) {
334                         SAFE_FREE(databuf.dptr);
335                         SAFE_FREE(keystr);
336                         node = node->next;
337                         continue;
338                 }
339                 entry = strndup(databuf.dptr, databuf.dsize);
340                 SAFE_FREE(databuf.dptr);
341                 valstr = malloc_array_p(char, databuf.dsize - TIMEOUT_LEN);
342                 sscanf(entry, CACHE_DATA_FMT, (int*)(&i), valstr);
343                 timeout = i;
344                 
345                 DEBUG(10, ("Calling function with arguments (key = %s, value = %s, timeout = %s)\n",
346                            keystr, valstr, ctime(&timeout)));
347                 fn(keystr, valstr, timeout, data);
348                 
349                 SAFE_FREE(valstr);
350                 SAFE_FREE(entry);
351                 SAFE_FREE(keystr);
352                 node = node->next;
353         }
354         
355         tdb_search_list_free(first_node);
356 }
357
358 /********************************************************************
359  lock a key
360 ********************************************************************/
361
362 int gencache_lock_entry( const char *key )
363 {
364         return tdb_lock_bystring(cache->tdb, key);
365 }
366
367 /********************************************************************
368  unlock a key
369 ********************************************************************/
370
371 void gencache_unlock_entry( const char *key )
372 {
373         tdb_unlock_bystring(cache->tdb, key);
374 }
375
376