Changeset 988 for vendor/current/source3/lib/gencache.c

Timestamp:

Nov 24, 2016, 1:14:11 PM (9 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

File:

• vendor/current/source3/lib/gencache.c (modified) (33 diffs)

vendor/current/source3/lib/gencache.c

@@ -26 +26 @@
 #include "system/glob.h"
 #include "util_tdb.h"
+#include "tdb_wrap/tdb_wrap.h"
+#include "../lib/util/memcache.h"
 
 #undef  DBGC_CLASS
@@ -36 +38 @@
 #define BLOB_TYPE_LEN 9
 
-static struct tdb_context *cache;
-static struct tdb_context *cache_notrans;
+static struct tdb_wrap *cache;
+static struct tdb_wrap *cache_notrans;
+static int cache_notrans_seqnum;
 
 /**
@@ -59 +62 @@
         char* cache_fname = NULL;
         int open_flags = O_RDWR|O_CREAT;
-        bool first_try = true;
 
         /* skip file open if it's already opened */
-        if (cache) return True;
-
-        cache_fname = lock_path("gencache.tdb");
+        if (cache) {
+                return true;
+        }
+
+        cache_fname = cache_path("gencache.tdb");
+        if (cache_fname == NULL) {
+                return false;
+        }
 
         DEBUG(5, ("Opening cache file at %s\n", cache_fname));
 
-again:
-        cache = tdb_open_log(cache_fname, 0, TDB_DEFAULT|TDB_INCOMPATIBLE_HASH, open_flags, 0644);
+        cache = tdb_wrap_open(NULL, cache_fname, 0,
+                              TDB_DEFAULT|TDB_INCOMPATIBLE_HASH,
+                              open_flags, 0644);
         if (cache) {
                 int ret;
-                ret = tdb_check(cache, NULL, NULL);
+                ret = tdb_check(cache->tdb, NULL, NULL);
                 if (ret != 0) {
-                        tdb_close(cache);
-                        cache = NULL;
-                        if (!first_try) {
-                                DEBUG(0, ("gencache_init: tdb_check(%s) failed\n",
-                                          cache_fname));
-                                return false;
-                        }
-                        first_try = false;
-                        DEBUG(0, ("gencache_init: tdb_check(%s) failed - retry after CLEAR_IF_FIRST\n",
-                                  cache_fname));
-                        cache = tdb_open_log(cache_fname, 0, TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH, open_flags, 0644);
-                        if (cache) {
-                                tdb_close(cache);
-                                cache = NULL;
-                                goto again;
-                        }
+                        TALLOC_FREE(cache);
+
+                        /*
+                         * Retry with CLEAR_IF_FIRST.
+                         *
+                         * Warning: Converting this to dbwrap won't work
+                         * directly. gencache.c does transactions on this tdb,
+                         * and dbwrap forbids this for CLEAR_IF_FIRST
+                         * databases. tdb does allow transactions on
+                         * CLEAR_IF_FIRST databases, so lets use it here to
+                         * clean up a broken database.
+                         */
+                        cache = tdb_wrap_open(NULL, cache_fname, 0,
+                                              TDB_DEFAULT|
+                                              TDB_INCOMPATIBLE_HASH|
+                                              TDB_CLEAR_IF_FIRST,
+                                              open_flags, 0644);
                 }
         }
@@ -95 +104 @@
         if (!cache && (errno == EACCES)) {
                 open_flags = O_RDONLY;
-                cache = tdb_open_log(cache_fname, 0, TDB_DEFAULT|TDB_INCOMPATIBLE_HASH, open_flags,
-                                     0644);
+                cache = tdb_wrap_open(NULL, cache_fname, 0,
+                                      TDB_DEFAULT|TDB_INCOMPATIBLE_HASH,
+                                      open_flags, 0644);
                 if (cache) {
                         DEBUG(5, ("gencache_init: Opening cache file %s read-only.\n", cache_fname));
                 }
         }
+        TALLOC_FREE(cache_fname);
 
         if (!cache) {
                 DEBUG(5, ("Attempt to open gencache.tdb has failed.\n"));
-                return False;
+                return false;
         }
 
         cache_fname = lock_path("gencache_notrans.tdb");
+        if (cache_fname == NULL) {
+                TALLOC_FREE(cache);
+                return false;
+        }
 
         DEBUG(5, ("Opening cache file at %s\n", cache_fname));
 
-        cache_notrans = tdb_open_log(cache_fname, 0, TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
-                                     open_flags, 0644);
+        cache_notrans = tdb_wrap_open(NULL, cache_fname, 0,
+                                      TDB_CLEAR_IF_FIRST|
+                                      TDB_INCOMPATIBLE_HASH|
+                                      TDB_SEQNUM|
+                                      TDB_NOSYNC|
+                                      TDB_MUTEX_LOCKING,
+                                      open_flags, 0644);
         if (cache_notrans == NULL) {
                 DEBUG(5, ("Opening %s failed: %s\n", cache_fname,
                           strerror(errno)));
-                tdb_close(cache);
-                cache = NULL;
-                return false;
-        }
-
-        return True;
+                TALLOC_FREE(cache_fname);
+                TALLOC_FREE(cache);
+                return false;
+        }
+        TALLOC_FREE(cache_fname);
+
+        return true;
 }
 
@@ -127 +148 @@
 {
         TDB_DATA result;
-        result.dptr = (uint8_t *)"@LAST_STABILIZED";
+        result.dptr = discard_const_p(uint8_t, "@LAST_STABILIZED");
         result.dsize = 17;
         return result;
+}
+
+struct gencache_have_val_state {
+        time_t new_timeout;
+        const DATA_BLOB *data;
+        bool gotit;
+};
+
+static void gencache_have_val_parser(time_t old_timeout, DATA_BLOB data,
+                                     void *private_data)
+{
+        struct gencache_have_val_state *state =
+                (struct gencache_have_val_state *)private_data;
+        time_t now = time(NULL);
+        int cache_time_left, new_time_left, additional_time;
+
+        /*
+         * Excuse the many variables, but these time calculations are
+         * confusing to me. We do not want to write to gencache with a
+         * possibly expensive transaction if we are about to write the same
+         * value, just extending the remaining timeout by less than 10%.
+         */
+
+        cache_time_left = old_timeout - now;
+        if (cache_time_left <= 0) {
+                /*
+                 * timed out, write new value
+                 */
+                return;
+        }
+
+        new_time_left = state->new_timeout - now;
+        if (new_time_left <= 0) {
+                /*
+                 * Huh -- no new timeout?? Write it.
+                 */
+                return;
+        }
+
+        if (new_time_left < cache_time_left) {
+                /*
+                 * Someone wants to shorten the timeout. Let it happen.
+                 */
+                return;
+        }
+
+        /*
+         * By how much does the new timeout extend the remaining cache time?
+         */
+        additional_time = new_time_left - cache_time_left;
+
+        if (additional_time * 10 < 0) {
+                /*
+                 * Integer overflow. We extend by so much that we have to write it.
+                 */
+                return;
+        }
+
+        /*
+         * The comparison below is essentially equivalent to
+         *
+         *    new_time_left > cache_time_left * 1.10
+         *
+         * but without floating point calculations.
+         */
+
+        if (additional_time * 10 > cache_time_left) {
+                /*
+                 * We extend the cache timeout by more than 10%. Do it.
+                 */
+                return;
+        }
+
+        /*
+         * Now the more expensive data compare.
+         */
+        if (data_blob_cmp(state->data, &data) != 0) {
+                /*
+                 * Write a new value. Certainly do it.
+                 */
+                return;
+        }
+
+        /*
+         * Extending the timeout by less than 10% for the same cache value is
+         * not worth the trouble writing a value into gencache under a
+         * possibly expensive transaction.
+         */
+        state->gotit = true;
+}
+
+static bool gencache_have_val(const char *keystr, const DATA_BLOB *data,
+                              time_t timeout)
+{
+        struct gencache_have_val_state state;
+
+        state.new_timeout = timeout;
+        state.data = data;
+        state.gotit = false;
+
+        if (!gencache_parse(keystr, gencache_have_val_parser, &state)) {
+                return false;
+        }
+        return state.gotit;
+}
+
+static int last_stabilize_parser(TDB_DATA key, TDB_DATA data,
+                                 void *private_data)
+{
+        time_t *last_stabilize = private_data;
+
+        if ((data.dsize != 0) && (data.dptr[data.dsize-1] == '\0')) {
+                *last_stabilize = atoi((char *)data.dptr);
+        }
+        return 0;
 }
 
@@ -140 +276 @@
  * @param timeout time when the value is expired
  *
- * @retval true when entry is successfuly stored
+ * @retval true when entry is successfully stored
  * @retval false on failure
  **/
@@ -148 +284 @@
 {
         int ret;
-        TDB_DATA databuf;
+        fstring hdr;
+        int hdr_len;
         char* val;
         time_t last_stabilize;
@@ -163 +300 @@
         }
 
-        if (!gencache_init()) return False;
-
-        val = talloc_asprintf(talloc_tos(), CACHE_DATA_FMT, (int)timeout);
+        if (!gencache_init()) {
+                return false;
+        }
+
+        if (gencache_have_val(keystr, blob, timeout)) {
+                DEBUG(10, ("Did not store value for %s, we already got it\n",
+                           keystr));
+                return true;
+        }
+
+        hdr_len = fstr_sprintf(hdr, CACHE_DATA_FMT, (int)timeout);
+
+        if (hdr_len == -1) {
+                return false;
+        }
+        if ((blob->length + (size_t)hdr_len) < blob->length) {
+                return false;
+        }
+
+        val = talloc_array(talloc_tos(), char, hdr_len + blob->length);
         if (val == NULL) {
-                return False;
-        }
-        val = talloc_realloc(NULL, val, char, talloc_array_length(val)-1);
-        if (val == NULL) {
-                return false;
-        }
-        val = (char *)talloc_append_blob(NULL, val, *blob);
-        if (val == NULL) {
-                return false;
-        }
-
-        DEBUG(10, ("Adding cache entry with key = %s and timeout ="
-                   " %s (%d seconds %s)\n", keystr, ctime(&timeout),
+                return false;
+        }
+
+        memcpy(val, hdr, hdr_len);
+        memcpy(val+hdr_len, blob->data, blob->length);
+
+        DEBUG(10, ("Adding cache entry with key=[%s] and timeout="
+                   "[%s] (%d seconds %s)\n", keystr,
+                   timestring(talloc_tos(), timeout),
                    (int)(timeout - time(NULL)), 
                    timeout > time(NULL) ? "ahead" : "in the past"));
 
         ret = tdb_store_bystring(
-                cache_notrans, keystr,
+                cache_notrans->tdb, keystr,
                 make_tdb_data((uint8_t *)val, talloc_array_length(val)),
                 0);
@@ -211 +361 @@
 
         last_stabilize = 0;
-        databuf = tdb_fetch(cache_notrans, last_stabilize_key());
-        if ((databuf.dptr != NULL)
-            && (databuf.dptr[databuf.dsize-1] == '\0')) {
-                last_stabilize = atoi((char *)databuf.dptr);
-                SAFE_FREE(databuf.dptr);
-        }
+
+        tdb_parse_record(cache_notrans->tdb, last_stabilize_key(),
+                         last_stabilize_parser, &last_stabilize);
+
         if ((last_stabilize
              + lp_parm_int(-1, "gencache", "stabilize_interval", 300))
@@ -246 +394 @@
         }
 
-        if (!gencache_init()) return False;     
-
-        DEBUG(10, ("Deleting cache entry (key = %s)\n", keystr));
+        if (!gencache_init()) {
+                return false;
+        }
+
+        DEBUG(10, ("Deleting cache entry (key=[%s])\n", keystr));
 
         /*
@@ -256 +406 @@
          */
 
-        exists = gencache_get_data_blob(keystr, &value, NULL, &was_expired);
+        exists = gencache_get_data_blob(keystr, NULL, &value, NULL,
+                                        &was_expired);
 
         if (!exists && was_expired) {
@@ -300 +451 @@
         void (*parser)(time_t timeout, DATA_BLOB blob, void *private_data);
         void *private_data;
+        bool is_memcache;
 };
 
@@ -321 +473 @@
                 endptr+1, data.dsize - PTR_DIFF(endptr+1, data.dptr));
         state->parser(t, blob, state->private_data);
+
+        if (!state->is_memcache) {
+                memcache_add(NULL, GENCACHE_RAM,
+                             data_blob_const(key.dptr, key.dsize),
+                             data_blob_const(data.dptr, data.dsize));
+        }
+
         return 0;
 }
@@ -330 +489 @@
 {
         struct gencache_parse_state state;
-        TDB_DATA key;
+        TDB_DATA key = string_term_tdb_data(keystr);
+        DATA_BLOB memcache_val;
         int ret;
 
@@ -336 +496 @@
                 return false;
         }
-        if (tdb_data_cmp(string_term_tdb_data(keystr),
-                         last_stabilize_key()) == 0) {
+        if (tdb_data_cmp(key, last_stabilize_key()) == 0) {
                 return false;
         }
@@ -344 +503 @@
         }
 
-        key = string_term_tdb_data(keystr);
         state.parser = parser;
         state.private_data = private_data;
 
-        ret = tdb_parse_record(cache_notrans, key, gencache_parse_fn, &state);
-        if (ret != -1) {
+        if (memcache_lookup(NULL, GENCACHE_RAM,
+                            data_blob_const(key.dptr, key.dsize),
+                            &memcache_val)) {
+                /*
+                 * Make sure that nobody has changed the gencache behind our
+                 * back.
+                 */
+                int current_seqnum = tdb_get_seqnum(cache_notrans->tdb);
+                if (current_seqnum == cache_notrans_seqnum) {
+                        /*
+                         * Ok, our memcache is still current, use it without
+                         * going to the tdb files.
+                         */
+                        state.is_memcache = true;
+                        gencache_parse_fn(key, make_tdb_data(memcache_val.data,
+                                                             memcache_val.length),
+                                          &state);
+                        return true;
+                }
+                memcache_flush(NULL, GENCACHE_RAM);
+                cache_notrans_seqnum = current_seqnum;
+        }
+
+        state.is_memcache = false;
+
+        ret = tdb_parse_record(cache_notrans->tdb, key,
+                               gencache_parse_fn, &state);
+        if (ret == 0) {
                 return true;
         }
-        ret = tdb_parse_record(cache, key, gencache_parse_fn, &state);
-        return (ret != -1);
+        ret = tdb_parse_record(cache->tdb, key, gencache_parse_fn, &state);
+        return (ret == 0);
 }
 
 struct gencache_get_data_blob_state {
+        TALLOC_CTX *mem_ctx;
         DATA_BLOB *blob;
         time_t timeout;
@@ -379 +564 @@
         }
 
-        *state->blob = data_blob(blob.data, blob.length);
+        *state->blob = data_blob_talloc(state->mem_ctx, blob.data,
+                                        blob.length);
         if (state->blob->data == NULL) {
                 state->result = false;
@@ -396 +582 @@
  *
  * @retval true when entry is successfuly fetched
- * @retval False for failure
+ * @retval false for failure
  **/
 
-bool gencache_get_data_blob(const char *keystr, DATA_BLOB *blob,
+bool gencache_get_data_blob(const char *keystr, TALLOC_CTX *mem_ctx,
+                            DATA_BLOB *blob,
                             time_t *timeout, bool *was_expired)
 {
@@ -406 +593 @@
 
         state.result = false;
+        state.mem_ctx = mem_ctx;
         state.blob = blob;
 
@@ -429 +617 @@
         }
 
-        return True;
+        return true;
 
 fail:
@@ -443 +631 @@
 struct stabilize_state {
         bool written;
-        bool error;
 };
 static int stabilize_fn(struct tdb_context *tdb, TDB_DATA key, TDB_DATA val,
                         void *priv);
 
+static int wipe_fn(struct tdb_context *tdb, TDB_DATA key, TDB_DATA val,
+                   void *priv);
+
 /**
  * Stabilize gencache
@@ -465 +655 @@
         }
 
-        res = tdb_transaction_start_nonblock(cache);
-        if (res == -1) {
-
-                if (tdb_error(cache) == TDB_ERR_NOLOCK) {
+        res = tdb_transaction_start_nonblock(cache->tdb);
+        if (res != 0) {
+                if (tdb_error(cache->tdb) == TDB_ERR_NOLOCK)
+                {
                         /*
                          * Someone else already does the stabilize,
@@ -477 +667 @@
 
                 DEBUG(10, ("Could not start transaction on gencache.tdb: "
-                           "%s\n", tdb_errorstr(cache)));
-                return false;
-        }
-        res = tdb_transaction_start(cache_notrans);
-        if (res == -1) {
-                tdb_transaction_cancel(cache);
-                DEBUG(10, ("Could not start transaction on "
+                           "%s\n", tdb_errorstr(cache->tdb)));
+                return false;
+        }
+
+        res = tdb_lockall(cache_notrans->tdb);
+        if (res != 0) {
+                tdb_transaction_cancel(cache->tdb);
+                DEBUG(10, ("Could not get allrecord lock on "
                            "gencache_notrans.tdb: %s\n",
-                           tdb_errorstr(cache_notrans)));
-                return false;
-        }
-
-        state.error = false;
+                           tdb_errorstr(cache_notrans->tdb)));
+                return false;
+        }
+
         state.written = false;
 
-        res = tdb_traverse(cache_notrans, stabilize_fn, &state);
-        if ((res == -1) || state.error) {
-                if ((tdb_transaction_cancel(cache_notrans) == -1)
-                    || (tdb_transaction_cancel(cache) == -1)) {
-                        smb_panic("tdb_transaction_cancel failed\n");
-                }
+        res = tdb_traverse(cache_notrans->tdb, stabilize_fn, &state);
+        if (res < 0) {
+                tdb_unlockall(cache_notrans->tdb);
+                tdb_transaction_cancel(cache->tdb);
                 return false;
         }
 
         if (!state.written) {
-                if ((tdb_transaction_cancel(cache_notrans) == -1)
-                    || (tdb_transaction_cancel(cache) == -1)) {
-                        smb_panic("tdb_transaction_cancel failed\n");
-                }
+                tdb_unlockall(cache_notrans->tdb);
+                tdb_transaction_cancel(cache->tdb);
                 return true;
         }
 
-        res = tdb_transaction_commit(cache);
-        if (res == -1) {
+        res = tdb_transaction_commit(cache->tdb);
+        if (res != 0) {
                 DEBUG(10, ("tdb_transaction_commit on gencache.tdb failed: "
-                           "%s\n", tdb_errorstr(cache)));
-                if (tdb_transaction_cancel(cache_notrans) == -1) {
-                        smb_panic("tdb_transaction_cancel failed\n");
-                }
-                return false;
-        }
-
-        res = tdb_transaction_commit(cache_notrans);
-        if (res == -1) {
-                DEBUG(10, ("tdb_transaction_commit on gencache.tdb failed: "
-                           "%s\n", tdb_errorstr(cache)));
+                           "%s\n", tdb_errorstr(cache->tdb)));
+                tdb_unlockall(cache_notrans->tdb);
+                return false;
+        }
+
+        res = tdb_traverse(cache_notrans->tdb, wipe_fn, NULL);
+        if (res < 0) {
+                DEBUG(10, ("tdb_traverse with wipe_fn on gencache_notrans.tdb "
+                          "failed: %s\n",
+                           tdb_errorstr(cache_notrans->tdb)));
+                tdb_unlockall(cache_notrans->tdb);
+                return false;
+        }
+
+        res = tdb_unlockall(cache_notrans->tdb);
+        if (res != 0) {
+                DEBUG(10, ("tdb_unlockall on gencache.tdb failed: "
+                           "%s\n", tdb_errorstr(cache->tdb)));
                 return false;
         }
@@ -528 +721 @@
         now = talloc_asprintf(talloc_tos(), "%d", (int)time(NULL));
         if (now != NULL) {
-                tdb_store(cache_notrans, last_stabilize_key(),
+                tdb_store(cache_notrans->tdb, last_stabilize_key(),
                           string_term_tdb_data(now), 0);
                 TALLOC_FREE(now);
@@ -552 +745 @@
         }
         if ((timeout < time(NULL)) || (val.dsize == 0)) {
-                res = tdb_delete(cache, key);
-                if ((res == -1) && (tdb_error(cache) == TDB_ERR_NOEXIST)) {
+                res = tdb_delete(cache->tdb, key);
+                if (res == 0) {
+                        state->written = true;
+                } else if (tdb_error(cache->tdb) == TDB_ERR_NOEXIST) {
                         res = 0;
-                } else {
-                        state->written = true;
                 }
         } else {
-                res = tdb_store(cache, key, val, 0);
+                res = tdb_store(cache->tdb, key, val, 0);
                 if (res == 0) {
                         state->written = true;
@@ -565 +758 @@
         }
 
-        if (res == -1) {
+        if (res != 0) {
                 DEBUG(10, ("Transfer to gencache.tdb failed: %s\n",
-                           tdb_errorstr(cache)));
-                state->error = true;
+                           tdb_errorstr(cache->tdb)));
                 return -1;
         }
 
-        if (tdb_delete(cache_notrans, key) == -1) {
+        return 0;
+}
+
+static int wipe_fn(struct tdb_context *tdb, TDB_DATA key, TDB_DATA val,
+                   void *priv)
+{
+        int res;
+        bool ok;
+        time_t timeout;
+
+        res = tdb_data_cmp(key, last_stabilize_key());
+        if (res == 0) {
+                return 0;
+        }
+
+        ok = gencache_pull_timeout((char *)val.dptr, &timeout, NULL);
+        if (!ok) {
+                DEBUG(10, ("Ignoring invalid entry\n"));
+                return 0;
+        }
+
+        res = tdb_delete(tdb, key);
+        if (res != 0) {
                 DEBUG(10, ("tdb_delete from gencache_notrans.tdb failed: "
-                           "%s\n", tdb_errorstr(cache_notrans)));
-                state->error = true;
+                           "%s\n", tdb_errorstr(cache_notrans->tdb)));
                 return -1;
         }
+
         return 0;
 }
+
 
 /**
@@ -591 +806 @@
  *
  * @retval true when entry is successfuly fetched
- * @retval False for failure
+ * @retval false for failure
  **/
 
-bool gencache_get(const char *keystr, char **value, time_t *ptimeout)
+bool gencache_get(const char *keystr, TALLOC_CTX *mem_ctx, char **value,
+                  time_t *ptimeout)
 {
         DATA_BLOB blob;
-        bool ret = False;
-
-        ret = gencache_get_data_blob(keystr, &blob, ptimeout, NULL);
+        bool ret = false;
+
+        ret = gencache_get_data_blob(keystr, mem_ctx, &blob, ptimeout, NULL);
         if (!ret) {
                 return false;
         }
         if ((blob.data == NULL) || (blob.length == 0)) {
-                SAFE_FREE(blob.data);
+                data_blob_free(&blob);
                 return false;
         }
         if (blob.data[blob.length-1] != '\0') {
                 /* Not NULL terminated, can't be a string */
-                SAFE_FREE(blob.data);
+                data_blob_free(&blob);
                 return false;
         }
         if (value) {
-                *value = SMB_STRDUP((char *)blob.data);
-                data_blob_free(&blob);
-                if (*value == NULL) {
-                        return false;
-                }
+                /*
+                 * talloc_move generates a type-punned warning here. As we
+                 * leave the function immediately, do a simple talloc_steal.
+                 */
+                *value = (char *)talloc_steal(mem_ctx, blob.data);
                 return true;
         }
@@ -663 +879 @@
                 return 0;
         }
-        if (state->in_persistent && tdb_exists(cache_notrans, key)) {
+        if (state->in_persistent && tdb_exists(cache_notrans->tdb, key)) {
                 return 0;
         }
@@ -671 +887 @@
         } else {
                 /* ensure 0-termination */
-                keystr = SMB_STRNDUP((char *)key.dptr, key.dsize);
+                keystr = talloc_strndup(talloc_tos(), (char *)key.dptr, key.dsize);
                 free_key = keystr;
+                if (keystr == NULL) {
+                        goto done;
+                }
         }
 
@@ -684 +903 @@
         }
 
-        DEBUG(10, ("Calling function with arguments (key=%s, timeout=%s)\n",
-                   keystr, ctime(&timeout)));
+        DEBUG(10, ("Calling function with arguments "
+                   "(key=[%s], timeout=[%s])\n",
+                   keystr, timestring(talloc_tos(), timeout)));
 
         state->fn(keystr,
@@ -693 +913 @@
 
  done:
-        SAFE_FREE(free_key);
+        TALLOC_FREE(free_key);
         return 0;
 }
@@ -714 +934 @@
 
         state.in_persistent = false;
-        tdb_traverse(cache_notrans, gencache_iterate_blobs_fn, &state);
+        tdb_traverse(cache_notrans->tdb, gencache_iterate_blobs_fn, &state);
 
         state.in_persistent = true;
-        tdb_traverse(cache, gencache_iterate_blobs_fn, &state);
+        tdb_traverse(cache->tdb, gencache_iterate_blobs_fn, &state);
 }
 
@@ -749 +969 @@
         } else {
                 /* ensure 0-termination */
-                valstr = SMB_STRNDUP((char *)value.data, value.length);
+                valstr = talloc_strndup(talloc_tos(), (char *)value.data, value.length);
                 free_val = valstr;
+                if (valstr == NULL) {
+                        goto done;
+                }
         }
 
         DEBUG(10, ("Calling function with arguments "
-                   "(key = %s, value = %s, timeout = %s)\n",
-                   key, valstr, ctime(&timeout)));
+                   "(key=[%s], value=[%s], timeout=[%s])\n",
+                   key, valstr, timestring(talloc_tos(), timeout)));
 
         state->fn(key, valstr, timeout, state->private_data);
 
-        SAFE_FREE(free_val);
+  done:
+
+        TALLOC_FREE(free_val);
 }