source/lib/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
  26 #undef  DBGC_CLASS
  27 #define DBGC_CLASS DBGC_TDB
  28
  29 #define TIMEOUT_LEN 12
  30 #define CACHE_DATA_FMT  "%12u/%s"
  31 #define READ_CACHE_DATA_FMT_TEMPLATE "%%12u/%%%us"
  32
  33 static TDB_CONTEXT *cache;
  34 static BOOL cache_readonly;
  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         cache_fname = lock_path("gencache.tdb");
  60
  61         DEBUG(5, ("Opening cache file at %s\n", cache_fname));
  62
  63         cache = tdb_open_log(cache_fname, 0, TDB_DEFAULT,
  64                              O_RDWR|O_CREAT, 0644);
  65
  66         if (!cache && (errno == EACCES)) {
  67                 cache = tdb_open_log(cache_fname, 0, TDB_DEFAULT, O_RDONLY, 0644);
  68                 if (cache) {
  69                         cache_readonly = True;
  70                         DEBUG(5, ("gencache_init: Opening cache file %s read-only.\n", cache_fname));
  71                 }
  72         }
  73
  74         if (!cache) {
  75                 DEBUG(5, ("Attempt to open gencache.tdb has failed.\n"));
  76                 return False;
  77         }
  78         return True;
  79 }
  80
  81
  82 /**
  83  * Cache shutdown function. Closes opened cache tdb file.
  84  *
  85  * @return true on successful closing the cache or
  86  *         false on failure during cache shutdown
  87  **/
  88
  89 BOOL gencache_shutdown(void)
  90 {
  91         int ret;
  92         /* tdb_close routine returns -1 on error */
  93         if (!cache) return False;
  94         DEBUG(5, ("Closing cache file\n"));
  95         ret = tdb_close(cache);
  96         cache = NULL;
  97         cache_readonly = False;
  98         return ret != -1;
  99 }
 100
 101
 102 /**
 103  * Set an entry in the cache file. If there's no such
 104  * one, then add it.
 105  *
 106  * @param keystr string that represents a key of this entry
 107  * @param value text representation value being cached
 108  * @param timeout time when the value is expired
 109  *
 110  * @retval true when entry is successfuly stored
 111  * @retval false on failure
 112  **/
 113
 114 BOOL gencache_set(const char *keystr, const char *value, time_t timeout)
 115 {
 116         int ret;
 117         TDB_DATA databuf;
 118         char* valstr = NULL;
 119
 120         /* fail completely if get null pointers passed */
 121         SMB_ASSERT(keystr && value);
 122
 123         if (!gencache_init()) return False;
 124
 125         if (cache_readonly) {
 126                 return False;
 127         }
 128
 129         asprintf(&valstr, CACHE_DATA_FMT, (int)timeout, value);
 130         if (!valstr)
 131                 return False;
 132
 133         databuf = string_term_tdb_data(valstr);
 134         DEBUG(10, ("Adding cache entry with key = %s; value = %s and timeout ="
 135                    " %s (%d seconds %s)\n", keystr, value,ctime(&timeout),
 136                    (int)(timeout - time(NULL)),
 137                    timeout > time(NULL) ? "ahead" : "in the past"));
 138
 139         ret = tdb_store_bystring(cache, keystr, databuf, 0);
 140         SAFE_FREE(valstr);
 141
 142         return ret == 0;
 143 }
 144
 145 /**
 146  * Delete one entry from the cache file.
 147  *
 148  * @param keystr string that represents a key of this entry
 149  *
 150  * @retval true upon successful deletion
 151  * @retval false in case of failure
 152  **/
 153
 154 BOOL gencache_del(const char *keystr)
 155 {
 156         int ret;
 157
 158         /* fail completely if get null pointers passed */
 159         SMB_ASSERT(keystr);
 160
 161         if (!gencache_init()) return False;
 162
 163         if (cache_readonly) {
 164                 return False;
 165         }
 166
 167         DEBUG(10, ("Deleting cache entry (key = %s)\n", keystr));
 168         ret = tdb_delete_bystring(cache, keystr);
 169
 170         return ret == 0;
 171 }
 172
 173
 174 /**
 175  * Get existing entry from the cache file.
 176  *
 177  * @param keystr string that represents a key of this entry
 178  * @param valstr buffer that is allocated and filled with the entry value
 179  *        buffer's disposing must be done outside
 180  * @param timeout pointer to a time_t that is filled with entry's
 181  *        timeout
 182  *
 183  * @retval true when entry is successfuly fetched
 184  * @retval False for failure
 185  **/
 186
 187 BOOL gencache_get(const char *keystr, char **valstr, time_t *timeout)
 188 {
 189         TDB_DATA databuf;
 190         time_t t;
 191         char *endptr;
 192
 193         /* fail completely if get null pointers passed */
 194         SMB_ASSERT(keystr);
 195
 196         if (!gencache_init()) {
 197                 return False;
 198         }
 199
 200         databuf = tdb_fetch_bystring(cache, keystr);
 201
 202         if (databuf.dptr == NULL) {
 203                 DEBUG(10, ("Cache entry with key = %s couldn't be found\n",
 204                            keystr));
 205                 return False;
 206         }
 207
 208         t = strtol(databuf.dptr, &endptr, 10);
 209
 210         if ((endptr == NULL) || (*endptr != '/')) {
 211                 DEBUG(2, ("Invalid gencache data format: %s\n", databuf.dptr));
 212                 SAFE_FREE(databuf.dptr);
 213                 return False;
 214         }
 215
 216         DEBUG(10, ("Returning %s cache entry: key = %s, value = %s, "
 217                    "timeout = %s", t > time(NULL) ? "valid" :
 218                    "expired", keystr, endptr+1, ctime(&t)));
 219
 220         if (t <= time(NULL)) {
 221
 222                 /* We're expired, delete the entry */
 223                 tdb_delete_bystring(cache, keystr);
 224
 225                 SAFE_FREE(databuf.dptr);
 226                 return False;
 227         }
 228
 229         if (valstr) {
 230                 *valstr = SMB_STRDUP(endptr+1);
 231                 if (*valstr == NULL) {
 232                         SAFE_FREE(databuf.dptr);
 233                         DEBUG(0, ("strdup failed\n"));
 234                         return False;
 235                 }
 236         }
 237
 238         SAFE_FREE(databuf.dptr);
 239
 240         if (timeout) {
 241                 *timeout = t;
 242         }
 243
 244         return True;
 245 }
 246
 247
 248 /**
 249  * Iterate through all entries which key matches to specified pattern
 250  *
 251  * @param fn pointer to the function that will be supplied with each single
 252  *        matching cache entry (key, value and timeout) as an arguments
 253  * @param data void pointer to an arbitrary data that is passed directly to the fn
 254  *        function on each call
 255  * @param keystr_pattern pattern the existing entries' keys are matched to
 256  *
 257  **/
 258
 259 void gencache_iterate(void (*fn)(const char* key, const char *value, time_t timeout, void* dptr),
 260                       void* data, const char* keystr_pattern)
 261 {
 262         TDB_LIST_NODE *node, *first_node;
 263         TDB_DATA databuf;
 264         char *keystr = NULL, *valstr = NULL, *entry = NULL;
 265         time_t timeout = 0;
 266         int status;
 267         unsigned u;
 268
 269         /* fail completely if get null pointers passed */
 270         SMB_ASSERT(fn && keystr_pattern);
 271
 272         if (!gencache_init()) return;
 273
 274         DEBUG(5, ("Searching cache keys with pattern %s\n", keystr_pattern));
 275         node = tdb_search_keys(cache, keystr_pattern);
 276         first_node = node;
 277
 278         while (node) {
 279                 char *fmt;
 280
 281                 /* ensure null termination of the key string */
 282                 keystr = SMB_STRNDUP(node->node_key.dptr, node->node_key.dsize);
 283                 if (!keystr) {
 284                         break;
 285                 }
 286
 287                 /*
 288                  * We don't use gencache_get function, because we need to iterate through
 289                  * all of the entries. Validity verification is up to fn routine.
 290                  */
 291                 databuf = tdb_fetch(cache, node->node_key);
 292                 if (!databuf.dptr || databuf.dsize <= TIMEOUT_LEN) {
 293                         SAFE_FREE(databuf.dptr);
 294                         SAFE_FREE(keystr);
 295                         node = node->next;
 296                         continue;
 297                 }
 298                 entry = SMB_STRNDUP(databuf.dptr, databuf.dsize);
 299                 if (!entry) {
 300                         SAFE_FREE(databuf.dptr);
 301                         SAFE_FREE(keystr);
 302                         break;
 303                 }
 304
 305                 SAFE_FREE(databuf.dptr);
 306
 307                 valstr = (char *)SMB_MALLOC(databuf.dsize + 1 - TIMEOUT_LEN);
 308                 if (!valstr) {
 309                         SAFE_FREE(entry);
 310                         SAFE_FREE(keystr);
 311                         break;
 312                 }
 313
 314                 asprintf(&fmt, READ_CACHE_DATA_FMT_TEMPLATE, (unsigned int)databuf.dsize - TIMEOUT_LEN);
 315                 if (!fmt) {
 316                         SAFE_FREE(valstr);
 317                         SAFE_FREE(entry);
 318                         SAFE_FREE(keystr);
 319                         break;
 320                 }
 321                 status = sscanf(entry, fmt, &u, valstr);
 322                 SAFE_FREE(fmt);
 323
 324                 if ( status != 2 ) {
 325                         DEBUG(0,("gencache_iterate: invalid return from sscanf %d\n",status));
 326                 }
 327                 timeout = u;
 328
 329                 DEBUG(10, ("Calling function with arguments (key = %s, value = %s, timeout = %s)\n",
 330                            keystr, valstr, ctime(&timeout)));
 331                 fn(keystr, valstr, timeout, data);
 332
 333                 SAFE_FREE(valstr);
 334                 SAFE_FREE(entry);
 335                 SAFE_FREE(keystr);
 336                 node = node->next;
 337         }
 338
 339         tdb_search_list_free(first_node);
 340 }
 341
 342 /********************************************************************
 343  lock a key
 344 ********************************************************************/
 345
 346 int gencache_lock_entry( const char *key )
 347 {
 348         if (!gencache_init())
 349                 return -1;
 350
 351         return tdb_lock_bystring(cache, key);
 352 }
 353
 354 /********************************************************************
 355  unlock a key
 356 ********************************************************************/
 357
 358 void gencache_unlock_entry( const char *key )
 359 {
 360         if (!gencache_init())
 361                 return;
 362
 363         tdb_unlock_bystring(cache, key);
 364         return;
 365 }