Changeset 745 for trunk/server/source3/lib/gencache.c

Timestamp:

Nov 27, 2012, 4:43:17 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: updated trunk to 3.6.0

Location:

trunk/server

Files:

• . (modified) (1 prop)
• source3/lib/gencache.c (modified) (14 diffs)

trunk/server/source3/lib/gencache.c

@@ -23 +23 @@
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "system/glob.h"
+#include "util_tdb.h"
 
 #undef  DBGC_CLASS
@@ -66 +69 @@
 
 again:
-        cache = tdb_open_log(cache_fname, 0, TDB_DEFAULT, open_flags, 0644);
+        cache = tdb_open_log(cache_fname, 0, TDB_DEFAULT|TDB_INCOMPATIBLE_HASH, open_flags, 0644);
         if (cache) {
                 int ret;
@@ -81 +84 @@
                         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, open_flags, 0644);
+                        cache = tdb_open_log(cache_fname, 0, TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH, open_flags, 0644);
                         if (cache) {
                                 tdb_close(cache);
@@ -92 +95 @@
         if (!cache && (errno == EACCES)) {
                 open_flags = O_RDONLY;
-                cache = tdb_open_log(cache_fname, 0, TDB_DEFAULT, open_flags,
+                cache = tdb_open_log(cache_fname, 0, TDB_DEFAULT|TDB_INCOMPATIBLE_HASH, open_flags,
                                      0644);
                 if (cache) {
@@ -108 +111 @@
         DEBUG(5, ("Opening cache file at %s\n", cache_fname));
 
-        cache_notrans = tdb_open_log(cache_fname, 0, TDB_CLEAR_IF_FIRST,
+        cache_notrans = tdb_open_log(cache_fname, 0, TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
                                      open_flags, 0644);
         if (cache_notrans == NULL) {
@@ -275 +278 @@
         char *endptr;
 
+        if (val == NULL) {
+                return false;
+        }
+
         res = strtol(val, &endptr, 10);
 
@@ -288 +295 @@
         }
         return true;
+}
+
+struct gencache_parse_state {
+        void (*parser)(time_t timeout, DATA_BLOB blob, void *private_data);
+        void *private_data;
+};
+
+static int gencache_parse_fn(TDB_DATA key, TDB_DATA data, void *private_data)
+{
+        struct gencache_parse_state *state;
+        DATA_BLOB blob;
+        time_t t;
+        char *endptr;
+        bool ret;
+
+        if (data.dptr == NULL) {
+                return -1;
+        }
+        ret = gencache_pull_timeout((char *)data.dptr, &t, &endptr);
+        if (!ret) {
+                return -1;
+        }
+        state = (struct gencache_parse_state *)private_data;
+        blob = data_blob_const(
+                endptr+1, data.dsize - PTR_DIFF(endptr+1, data.dptr));
+        state->parser(t, blob, state->private_data);
+        return 0;
+}
+
+bool gencache_parse(const char *keystr,
+                    void (*parser)(time_t timeout, DATA_BLOB blob,
+                                   void *private_data),
+                    void *private_data)
+{
+        struct gencache_parse_state state;
+        TDB_DATA key;
+        int ret;
+
+        if (keystr == NULL) {
+                return false;
+        }
+        if (tdb_data_cmp(string_term_tdb_data(keystr),
+                         last_stabilize_key()) == 0) {
+                return false;
+        }
+        if (!gencache_init()) {
+                return false;
+        }
+
+        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) {
+                return true;
+        }
+        ret = tdb_parse_record(cache, key, gencache_parse_fn, &state);
+        return (ret != -1);
+}
+
+struct gencache_get_data_blob_state {
+        DATA_BLOB *blob;
+        time_t timeout;
+        bool result;
+};
+
+static void gencache_get_data_blob_parser(time_t timeout, DATA_BLOB blob,
+                                          void *private_data)
+{
+        struct gencache_get_data_blob_state *state =
+                (struct gencache_get_data_blob_state *)private_data;
+
+        if (timeout == 0) {
+                state->result = false;
+                return;
+        }
+        state->timeout = timeout;
+
+        if (state->blob == NULL) {
+                state->result = true;
+                return;
+        }
+
+        *state->blob = data_blob(blob.data, blob.length);
+        if (state->blob->data == NULL) {
+                state->result = false;
+                return;
+        }
+        state->result = true;
 }
 
@@ -305 +402 @@
                             time_t *timeout, bool *was_expired)
 {
-        TDB_DATA databuf;
-        time_t t;
-        char *endptr;
+        struct gencache_get_data_blob_state state;
         bool expired = false;
 
-        if (keystr == NULL) {
+        state.result = false;
+        state.blob = blob;
+
+        if (!gencache_parse(keystr, gencache_get_data_blob_parser, &state)) {
                 goto fail;
         }
-
-        if (tdb_data_cmp(string_term_tdb_data(keystr),
-                         last_stabilize_key()) == 0) {
-                DEBUG(10, ("Can't get %s as a key\n", keystr));
+        if (!state.result) {
                 goto fail;
         }
-
-        if (!gencache_init()) {
-                goto fail;
-        }
-
-        databuf = tdb_fetch_bystring(cache_notrans, keystr);
-
-        if (databuf.dptr == NULL) {
-                databuf = tdb_fetch_bystring(cache, keystr);
-        }
-
-        if (databuf.dptr == NULL) {
-                DEBUG(10, ("Cache entry with key = %s couldn't be found \n",
-                           keystr));
-                goto fail;
-        }
-
-        if (!gencache_pull_timeout((char *)databuf.dptr, &t, &endptr)) {
-                SAFE_FREE(databuf.dptr);
-                goto fail;
-        }
-
-        DEBUG(10, ("Returning %s cache entry: key = %s, value = %s, "
-                   "timeout = %s", t > time(NULL) ? "valid" :
-                   "expired", keystr, endptr+1, ctime(&t)));
-
-        if (t == 0) {
-                /* Deleted */
-                SAFE_FREE(databuf.dptr);
-                goto fail;
-        }
-
-        if (t <= time(NULL)) {
-
+        if (state.timeout <= time(NULL)) {
                 /*
                  * We're expired, delete the entry. We can't use gencache_del
@@ -360 +422 @@
                  */
                 gencache_set(keystr, "", 0);
-
-                SAFE_FREE(databuf.dptr);
-
                 expired = true;
                 goto fail;
         }
-
-        if (blob != NULL) {
-                *blob = data_blob(
-                        endptr+1,
-                        databuf.dsize - PTR_DIFF(endptr+1, databuf.dptr));
-                if (blob->data == NULL) {
-                        SAFE_FREE(databuf.dptr);
-                        DEBUG(0, ("memdup failed\n"));
-                        goto fail;
-                }
-        }
-
-        SAFE_FREE(databuf.dptr);
-
         if (timeout) {
-                *timeout = t;
+                *timeout = state.timeout;
         }
 
@@ -389 +434 @@
         if (was_expired != NULL) {
                 *was_expired = expired;
+        }
+        if (state.result && state.blob) {
+                data_blob_free(state.blob);
         }
         return false;
@@ -417 +465 @@
         }
 
-        res = tdb_transaction_start(cache);
+        res = tdb_transaction_start_nonblock(cache);
         if (res == -1) {
+
+                if (tdb_error(cache) == TDB_ERR_NOLOCK) {
+                        /*
+                         * Someone else already does the stabilize,
+                         * this does not have to be done twice
+                         */
+                        return true;
+                }
+
                 DEBUG(10, ("Could not start transaction on gencache.tdb: "
                            "%s\n", tdb_errorstr(cache)));
@@ -585 +642 @@
 }
 
-/**
- * Iterate through all entries which key matches to specified pattern
- *
- * @param fn pointer to the function that will be supplied with each single
- *        matching cache entry (key, value and timeout) as an arguments
- * @param data void pointer to an arbitrary data that is passed directly to the fn
- *        function on each call
- * @param keystr_pattern pattern the existing entries' keys are matched to
- *
- **/
-
-struct gencache_iterate_state {
-        void (*fn)(const char *key, const char *value, time_t timeout,
-                   void *priv);
+struct gencache_iterate_blobs_state {
+        void (*fn)(const char *key, DATA_BLOB value,
+                   time_t timeout, void *private_data);
         const char *pattern;
-        void *priv;
+        void *private_data;
         bool in_persistent;
 };
 
-static int gencache_iterate_fn(struct tdb_context *tdb, TDB_DATA key,
-                               TDB_DATA value, void *priv)
-{
-        struct gencache_iterate_state *state =
-                (struct gencache_iterate_state *)priv;
+static int gencache_iterate_blobs_fn(struct tdb_context *tdb, TDB_DATA key,
+                                     TDB_DATA data, void *priv)
+{
+        struct gencache_iterate_blobs_state *state =
+                (struct gencache_iterate_blobs_state *)priv;
         char *keystr;
         char *free_key = NULL;
-        char *valstr;
-        char *free_val = NULL;
-        unsigned long u;
         time_t timeout;
-        char *timeout_endp;
+        char *endptr;
 
         if (tdb_data_cmp(key, last_stabilize_key()) == 0) {
                 return 0;
         }
-
         if (state->in_persistent && tdb_exists(cache_notrans, key)) {
                 return 0;
@@ -633 +675 @@
         }
 
-        if ((value.dptr == NULL) || (value.dsize <= TIMEOUT_LEN)) {
+        if (!gencache_pull_timeout((char *)data.dptr, &timeout, &endptr)) {
                 goto done;
         }
+        endptr += 1;
 
         if (fnmatch(state->pattern, keystr, 0) != 0) {
@@ -641 +684 @@
         }
 
-        if (value.dptr[value.dsize-1] == '\0') {
-                valstr = (char *)value.dptr;
+        DEBUG(10, ("Calling function with arguments (key=%s, timeout=%s)\n",
+                   keystr, ctime(&timeout)));
+
+        state->fn(keystr,
+                  data_blob_const(endptr,
+                                  data.dsize - PTR_DIFF(endptr, data.dptr)),
+                  timeout, state->private_data);
+
+ done:
+        SAFE_FREE(free_key);
+        return 0;
+}
+
+void gencache_iterate_blobs(void (*fn)(const char *key, DATA_BLOB value,
+                                       time_t timeout, void *private_data),
+                            void *private_data, const char *pattern)
+{
+        struct gencache_iterate_blobs_state state;
+
+        if ((fn == NULL) || (pattern == NULL) || !gencache_init()) {
+                return;
+        }
+
+        DEBUG(5, ("Searching cache keys with pattern %s\n", pattern));
+
+        state.fn = fn;
+        state.pattern = pattern;
+        state.private_data = private_data;
+
+        state.in_persistent = false;
+        tdb_traverse(cache_notrans, gencache_iterate_blobs_fn, &state);
+
+        state.in_persistent = true;
+        tdb_traverse(cache, gencache_iterate_blobs_fn, &state);
+}
+
+/**
+ * Iterate through all entries which key matches to specified pattern
+ *
+ * @param fn pointer to the function that will be supplied with each single
+ *        matching cache entry (key, value and timeout) as an arguments
+ * @param data void pointer to an arbitrary data that is passed directly to the fn
+ *        function on each call
+ * @param keystr_pattern pattern the existing entries' keys are matched to
+ *
+ **/
+
+struct gencache_iterate_state {
+        void (*fn)(const char *key, const char *value, time_t timeout,
+                   void *priv);
+        void *private_data;
+};
+
+static void gencache_iterate_fn(const char *key, DATA_BLOB value,
+                                time_t timeout, void *private_data)
+{
+        struct gencache_iterate_state *state =
+                (struct gencache_iterate_state *)private_data;
+        char *valstr;
+        char *free_val = NULL;
+
+        if (value.data[value.length-1] == '\0') {
+                valstr = (char *)value.data;
         } else {
                 /* ensure 0-termination */
-                valstr = SMB_STRNDUP((char *)value.dptr, value.dsize);
+                valstr = SMB_STRNDUP((char *)value.data, value.length);
                 free_val = valstr;
         }
-
-        u = strtoul(valstr, &timeout_endp, 10);
-
-        if ((*timeout_endp != '/') || ((timeout_endp-valstr) != TIMEOUT_LEN)) {
-                goto done;
-        }
-
-        timeout = u;
-        timeout_endp += 1;
 
         DEBUG(10, ("Calling function with arguments "
                    "(key = %s, value = %s, timeout = %s)\n",
-                   keystr, timeout_endp, ctime(&timeout)));
-        state->fn(keystr, timeout_endp, timeout, state->priv);
-
- done:
-        SAFE_FREE(free_key);
+                   key, valstr, ctime(&timeout)));
+
+        state->fn(key, valstr, timeout, state->private_data);
+
         SAFE_FREE(free_val);
-        return 0;
-}
-
-void gencache_iterate(void (*fn)(const char* key, const char *value, time_t timeout, void* dptr),
-                      void* data, const char* keystr_pattern)
+}
+
+void gencache_iterate(void (*fn)(const char *key, const char *value,
+                                 time_t timeout, void *dptr),
+                      void *private_data, const char *pattern)
 {
         struct gencache_iterate_state state;
 
-        if ((fn == NULL) || (keystr_pattern == NULL)) {
+        if (fn == NULL) {
                 return;
         }
-
-        if (!gencache_init()) return;
-
-        DEBUG(5, ("Searching cache keys with pattern %s\n", keystr_pattern));
-
         state.fn = fn;
-        state.pattern = keystr_pattern;
-        state.priv = data;
-
-        state.in_persistent = false;
-        tdb_traverse(cache_notrans, gencache_iterate_fn, &state);
-
-        state.in_persistent = true;
-        tdb_traverse(cache, gencache_iterate_fn, &state);
-}
+        state.private_data = private_data;
+        gencache_iterate_blobs(gencache_iterate_fn, &state, pattern);
+}