Changeset 988 for vendor/current/source4/ntvfs/common

Timestamp:

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

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

Location:

vendor/current/source4/ntvfs/common

Files:

• brlock.c (modified) (9 diffs)
• brlock.h (modified) (2 diffs)
• brlock_tdb.c (modified) (33 diffs)
• init.c (modified) (1 diff)
• notify.c (modified) (28 diffs)
• opendb.c (modified) (1 diff)
• opendb.h (modified) (1 diff)
• opendb_tdb.c (modified) (19 diffs)
• wscript_build (modified) (1 diff)

vendor/current/source4/ntvfs/common/brlock.c

@@ -27 +27 @@
 #include "includes.h"
 #include "system/filesys.h"
-#include <tdb.h>
 #include "messaging/messaging.h"
 #include "lib/messaging/irpc.h"
@@ -39 +38 @@
   set the brl backend ops
 */
-void brl_set_ops(const struct brlock_ops *new_ops)
+void brlock_set_ops(const struct brlock_ops *new_ops)
 {
         ops = new_ops;
@@ -46 +45 @@
 /*
   Open up the brlock database. Close it down using talloc_free(). We
-  need the messaging_ctx to allow for pending lock notifications.
+  need the imessaging_ctx to allow for pending lock notifications.
 */
-struct brl_context *brl_init(TALLOC_CTX *mem_ctx, struct server_id server, 
+struct brl_context *brlock_init(TALLOC_CTX *mem_ctx, struct server_id server, 
                              struct loadparm_context *lp_ctx,
-                             struct messaging_context *messaging_ctx)
+                             struct imessaging_context *imessaging_ctx)
 {
         if (ops == NULL) {
                 brl_tdb_init_ops();
         }
-        return ops->brl_init(mem_ctx, server, lp_ctx, messaging_ctx);
+        return ops->brl_init(mem_ctx, server, lp_ctx, imessaging_ctx);
 }
 
-struct brl_handle *brl_create_handle(TALLOC_CTX *mem_ctx, struct ntvfs_handle *ntvfs, DATA_BLOB *file_key)
+struct brl_handle *brlock_create_handle(TALLOC_CTX *mem_ctx, struct ntvfs_handle *ntvfs, DATA_BLOB *file_key)
 {
         return ops->brl_create_handle(mem_ctx, ntvfs, file_key);
@@ -70 +69 @@
   notification is sent, identified by the notify_ptr
 */
-NTSTATUS brl_lock(struct brl_context *brl,
+NTSTATUS brlock_lock(struct brl_context *brl,
                   struct brl_handle *brlh,
                   uint32_t smbpid,
@@ -84 +83 @@
  Unlock a range of bytes.
 */
-NTSTATUS brl_unlock(struct brl_context *brl,
+NTSTATUS brlock_unlock(struct brl_context *brl,
                     struct brl_handle *brlh, 
                     uint32_t smbpid,
@@ -97 +96 @@
   getting it. In either case they no longer need to be notified.
 */
-NTSTATUS brl_remove_pending(struct brl_context *brl,
+NTSTATUS brlock_remove_pending(struct brl_context *brl,
                             struct brl_handle *brlh, 
                             void *notify_ptr)
@@ -108 +107 @@
   Test if we are allowed to perform IO on a region of an open file
 */
-NTSTATUS brl_locktest(struct brl_context *brl,
+NTSTATUS brlock_locktest(struct brl_context *brl,
                       struct brl_handle *brlh,
                       uint32_t smbpid, 
@@ -121 +120 @@
  Remove any locks associated with a open file.
 */
-NTSTATUS brl_close(struct brl_context *brl,
+NTSTATUS brlock_close(struct brl_context *brl,
                    struct brl_handle *brlh)
 {
@@ -130 +129 @@
  Get a number of locks associated with a open file.
 */
-NTSTATUS brl_count(struct brl_context *brl,
+NTSTATUS brlock_count(struct brl_context *brl,
                    struct brl_handle *brlh,
                    int *count)

vendor/current/source4/ntvfs/common/brlock.h

@@ -25 +25 @@
         struct brl_context *(*brl_init)(TALLOC_CTX *, struct server_id , 
                                         struct loadparm_context *lp_ctx,
-                                        struct messaging_context *);
+                                        struct imessaging_context *);
         struct brl_handle *(*brl_create_handle)(TALLOC_CTX *, struct ntvfs_handle *, DATA_BLOB *);
         NTSTATUS (*brl_lock)(struct brl_context *,
@@ -52 +52 @@
 };
 
-
-void brl_set_ops(const struct brlock_ops *new_ops);
+void brlock_set_ops(const struct brlock_ops *new_ops);
 void brl_tdb_init_ops(void);
-void brl_ctdb_init_ops(void);
-

vendor/current/source4/ntvfs/common/brlock_tdb.c

@@ -27 +27 @@
 #include "includes.h"
 #include "system/filesys.h"
-#include <tdb.h>
 #include "messaging/messaging.h"
-#include "lib/util/tdb_wrap.h"
 #include "lib/messaging/irpc.h"
 #include "libcli/libcli.h"
@@ -36 +34 @@
 #include "ntvfs/ntvfs.h"
 #include "param/param.h"
+#include "dbwrap/dbwrap.h"
 
 /*
@@ -47 +46 @@
 /* this struct is typicaly attached to tcon */
 struct brl_context {
-        struct tdb_wrap *w;
+        struct db_context *db;
         struct server_id server;
-        struct messaging_context *messaging_ctx;
+        struct imessaging_context *imessaging_ctx;
 };
 
@@ -90 +89 @@
 /*
   Open up the brlock.tdb database. Close it down using
-  talloc_free(). We need the messaging_ctx to allow for
+  talloc_free(). We need the imessaging_ctx to allow for
   pending lock notifications.
 */
 static struct brl_context *brl_tdb_init(TALLOC_CTX *mem_ctx, struct server_id server, 
                                         struct loadparm_context *lp_ctx,
-                                    struct messaging_context *messaging_ctx)
+                                    struct imessaging_context *imessaging_ctx)
 {
         struct brl_context *brl;
@@ -104 +103 @@
         }
 
-        brl->w = cluster_tdb_tmp_open(brl, lp_ctx, "brlock.tdb", TDB_DEFAULT);
-        if (brl->w == NULL) {
+        brl->db = cluster_db_tmp_open(brl, lp_ctx, "brlock", TDB_DEFAULT);
+        if (brl->db == NULL) {
                 talloc_free(brl);
                 return NULL;
@@ -111 +110 @@
 
         brl->server = server;
-        brl->messaging_ctx = messaging_ctx;
+        brl->imessaging_ctx = imessaging_ctx;
 
         return brl;
@@ -152 +151 @@
                             struct lock_struct *lck2)
 {
-        /* this extra check is not redundent - it copes with locks
+        /* this extra check is not redundant - it copes with locks
            that go beyond the end of 64 bit file space */
         if (lck1->size != 0 &&
@@ -243 +242 @@
 
         /* in SMB2 mode always return NT_STATUS_LOCK_NOT_GRANTED! */
-        if (lock->ntvfs->ctx->protocol == PROTOCOL_SMB2) {
+        if (lock->ntvfs->ctx->protocol >= PROTOCOL_SMB2_02) {
                 return NT_STATUS_LOCK_NOT_GRANTED;
         }
@@ -303 +302 @@
         struct lock_struct lock, *locks=NULL;
         NTSTATUS status;
+        struct db_record *locked;
 
         kbuf.dptr = brlh->key.data;
@@ -311 +311 @@
         }
 
-        if (tdb_chainlock(brl->w->tdb, kbuf) != 0) {
+        locked = dbwrap_fetch_locked(brl->db, brl, kbuf);
+        if (!locked) {
                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
         }
@@ -329 +330 @@
 
                 if (NT_STATUS_IS_OK(status)) {
-                        tdb_chainunlock(brl->w->tdb, kbuf);
+                        talloc_free(locked);
                         return NT_STATUS_OK;
                 }
         }
 
-        dbuf = tdb_fetch(brl->w->tdb, kbuf);
+        dbuf = dbwrap_record_get_value(locked);
 
         lock.context.smbpid = smbpid;
@@ -359 +360 @@
 
         /* no conflicts - add it to the list of locks */
-        locks = realloc_p(locks, struct lock_struct, count+1);
+        /* FIXME: a dbwrap_record_append() would help here! */
+        locks = talloc_array(locked, struct lock_struct, count+1);
         if (!locks) {
                 status = NT_STATUS_NO_MEMORY;
                 goto fail;
-        } else {
-                dbuf.dptr = (uint8_t *)locks;
-        }
+        }
+        memcpy(locks, dbuf.dptr, dbuf.dsize);
         locks[count] = lock;
+
+        dbuf.dptr = (unsigned char *)locks;
         dbuf.dsize += sizeof(lock);
 
-        if (tdb_store(brl->w->tdb, kbuf, dbuf, TDB_REPLACE) != 0) {
-                status = NT_STATUS_INTERNAL_DB_CORRUPTION;
+        status = dbwrap_record_store(locked, dbuf, TDB_REPLACE);
+        if (!NT_STATUS_IS_OK(status)) {
                 goto fail;
         }
 
-        free(dbuf.dptr);
-        tdb_chainunlock(brl->w->tdb, kbuf);
+        talloc_free(locked);
 
         /* the caller needs to know if the real lock was granted. If
@@ -387 +389 @@
 
  fail:
-
-        free(dbuf.dptr);
-        tdb_chainunlock(brl->w->tdb, kbuf);
+        talloc_free(locked);
         return status;
 }
@@ -420 +420 @@
                                 last_notice = i;
                         }
-                        messaging_send_ptr(brl->messaging_ctx, locks[i].context.server, 
+                        imessaging_send_ptr(brl->imessaging_ctx, locks[i].context.server,
                                            MSG_BRL_RETRY, locks[i].notify_ptr);
                 }
@@ -456 +456 @@
         struct lock_struct *locks, *lock;
         struct lock_context context;
+        struct db_record *locked;
         NTSTATUS status;
 
@@ -465 +466 @@
         }
 
-        if (tdb_chainlock(brl->w->tdb, kbuf) != 0) {
+        locked = dbwrap_fetch_locked(brl->db, brl, kbuf);
+        if (!locked) {
                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
         }
-
-        dbuf = tdb_fetch(brl->w->tdb, kbuf);
-        if (!dbuf.dptr) {
-                tdb_chainunlock(brl->w->tdb, kbuf);
-                return NT_STATUS_RANGE_NOT_LOCKED;
-        }
+        dbuf = dbwrap_record_get_value(locked);
 
         context.smbpid = smbpid;
@@ -510 +507 @@
                 /* found it - delete it */
                 if (count == 1) {
-                        if (tdb_delete(brl->w->tdb, kbuf) != 0) {
-                                status = NT_STATUS_INTERNAL_DB_CORRUPTION;
+                        status = dbwrap_record_delete(locked);
+                        if (!NT_STATUS_IS_OK(status)) {
                                 goto fail;
                         }
@@ -526 +523 @@
                         
                         dbuf.dsize = count * sizeof(*locks);
-                        
-                        if (tdb_store(brl->w->tdb, kbuf, dbuf, TDB_REPLACE) != 0) {
-                                status = NT_STATUS_INTERNAL_DB_CORRUPTION;
+
+                        status = dbwrap_record_store(locked, dbuf, TDB_REPLACE);
+                        if (!NT_STATUS_IS_OK(status)) {
                                 goto fail;
                         }
                 }
-                
-                free(dbuf.dptr);
-                tdb_chainunlock(brl->w->tdb, kbuf);
+
+                talloc_free(locked);
                 return NT_STATUS_OK;
         }
@@ -542 +538 @@
 
  fail:
-        free(dbuf.dptr);
-        tdb_chainunlock(brl->w->tdb, kbuf);
+        talloc_free(locked);
         return status;
 }
@@ -561 +556 @@
         struct lock_struct *locks;
         NTSTATUS status;
+        struct db_record *locked;
 
         kbuf.dptr = brlh->key.data;
         kbuf.dsize = brlh->key.length;
 
-        if (tdb_chainlock(brl->w->tdb, kbuf) != 0) {
+        locked = dbwrap_fetch_locked(brl->db, brl, kbuf);
+        if (!locked) {
                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
         }
 
-        dbuf = tdb_fetch(brl->w->tdb, kbuf);
+        dbuf = dbwrap_record_get_value(locked);
         if (!dbuf.dptr) {
-                tdb_chainunlock(brl->w->tdb, kbuf);
+                talloc_free(locked);
                 return NT_STATUS_RANGE_NOT_LOCKED;
         }
@@ -587 +584 @@
                         /* found it - delete it */
                         if (count == 1) {
-                                if (tdb_delete(brl->w->tdb, kbuf) != 0) {
-                                        status = NT_STATUS_INTERNAL_DB_CORRUPTION;
+                                status = dbwrap_record_delete(locked);
+                                if (!NT_STATUS_IS_OK(status)) {
                                         goto fail;
                                 }
@@ -598 +595 @@
                                 count--;
                                 dbuf.dsize = count * sizeof(*locks);
-                                if (tdb_store(brl->w->tdb, kbuf, dbuf, TDB_REPLACE) != 0) {
-                                        status = NT_STATUS_INTERNAL_DB_CORRUPTION;
+                                status = dbwrap_record_store(locked, dbuf,
+                                                             TDB_REPLACE);
+                                if (!NT_STATUS_IS_OK(status)) {
                                         goto fail;
                                 }
                         }
                         
-                        free(dbuf.dptr);
-                        tdb_chainunlock(brl->w->tdb, kbuf);
+                        talloc_free(locked);
                         return NT_STATUS_OK;
                 }
@@ -614 +611 @@
 
  fail:
-        free(dbuf.dptr);
-        tdb_chainunlock(brl->w->tdb, kbuf);
+        talloc_free(locked);
         return status;
 }
@@ -632 +628 @@
         int count, i;
         struct lock_struct lock, *locks;
+        NTSTATUS status;
 
         kbuf.dptr = brlh->key.data;
@@ -640 +637 @@
         }
 
-        dbuf = tdb_fetch(brl->w->tdb, kbuf);
-        if (dbuf.dptr == NULL) {
+        status = dbwrap_fetch(brl->db, brl, kbuf, &dbuf);
+        if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
                 return NT_STATUS_OK;
+        } else if (!NT_STATUS_IS_OK(status)) {
+                return status;
         }
 
@@ -659 +658 @@
         for (i=0; i<count; i++) {
                 if (brl_tdb_conflict_other(&locks[i], &lock)) {
-                        free(dbuf.dptr);
+                        talloc_free(dbuf.dptr);
                         return NT_STATUS_FILE_LOCK_CONFLICT;
                 }
         }
 
-        free(dbuf.dptr);
+        talloc_free(dbuf.dptr);
         return NT_STATUS_OK;
 }
@@ -678 +677 @@
         int count, i, dcount=0;
         struct lock_struct *locks;
+        struct db_record *locked;
         NTSTATUS status;
 
@@ -683 +683 @@
         kbuf.dsize = brlh->key.length;
 
-        if (tdb_chainlock(brl->w->tdb, kbuf) != 0) {
+        locked = dbwrap_fetch_locked(brl->db, brl, kbuf);
+        if (!locked) {
                 return NT_STATUS_INTERNAL_DB_CORRUPTION;
         }
-
-        dbuf = tdb_fetch(brl->w->tdb, kbuf);
+        dbuf = dbwrap_record_get_value(locked);
         if (!dbuf.dptr) {
-                tdb_chainunlock(brl->w->tdb, kbuf);
+                talloc_free(locked);
                 return NT_STATUS_OK;
         }
@@ -717 +717 @@
 
         if (count == 0) {
-                if (tdb_delete(brl->w->tdb, kbuf) != 0) {
-                        status = NT_STATUS_INTERNAL_DB_CORRUPTION;
-                }
+                status = dbwrap_record_delete(locked);
         } else if (dcount != 0) {
                 /* tell all pending lock holders for this file that
@@ -728 +726 @@
                 dbuf.dsize = count * sizeof(*locks);
 
-                if (tdb_store(brl->w->tdb, kbuf, dbuf, TDB_REPLACE) != 0) {
-                        status = NT_STATUS_INTERNAL_DB_CORRUPTION;
-                }
-        }
-
-        free(dbuf.dptr);
-        tdb_chainunlock(brl->w->tdb, kbuf);
+                status = dbwrap_record_store(locked, dbuf, TDB_REPLACE);
+        }
+        talloc_free(locked);
 
         return status;
@@ -743 +737 @@
 {
         TDB_DATA kbuf, dbuf;
+        NTSTATUS status;
 
         kbuf.dptr = brlh->key.data;
@@ -748 +743 @@
         *count = 0;
 
-        if (tdb_chainlock(brl->w->tdb, kbuf) != 0) {
-                return NT_STATUS_INTERNAL_DB_CORRUPTION;
-        }
-
-        dbuf = tdb_fetch(brl->w->tdb, kbuf);
-        if (!dbuf.dptr) {
-                tdb_chainunlock(brl->w->tdb, kbuf);
+        status = dbwrap_fetch(brl->db, brl, kbuf, &dbuf);
+        if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
                 return NT_STATUS_OK;
-        }
-
+        } else if (!NT_STATUS_IS_OK(status)) {
+                return status;
+        }
         *count = dbuf.dsize / sizeof(struct lock_struct);
 
-        free(dbuf.dptr);
-        tdb_chainunlock(brl->w->tdb, kbuf);
+        talloc_free(dbuf.dptr);
 
         return NT_STATUS_OK;
@@ -780 +770 @@
 void brl_tdb_init_ops(void)
 {
-        brl_set_ops(&brlock_tdb_ops);
-}
+        brlock_set_ops(&brlock_tdb_ops);
+}

vendor/current/source4/ntvfs/common/init.c

@@ -27 +27 @@
 #include "ntvfs/sysdep/sys_notify.h"
 
+NTSTATUS ntvfs_common_init(void);
+
 NTSTATUS ntvfs_common_init(void)
 {

vendor/current/source4/ntvfs/common/notify.c

@@ -26 +26 @@
 #include "includes.h"
 #include "system/filesys.h"
-#include <tdb.h>
-#include "../lib/util/util_tdb.h"
 #include "messaging/messaging.h"
-#include "lib/util/tdb_wrap.h"
 #include "lib/messaging/irpc.h"
-#include "librpc/gen_ndr/ndr_s4_notify.h"
+#include "librpc/gen_ndr/ndr_notify.h"
 #include "../lib/util/dlinklist.h"
 #include "ntvfs/common/ntvfs_common.h"
@@ -38 +35 @@
 #include "param/param.h"
 #include "lib/util/tsort.h"
+#include "lib/dbwrap/dbwrap.h"
+#include "../lib/util/util_tdb.h"
 
 struct notify_context {
-        struct tdb_wrap *w;
+        struct db_context *db;
         struct server_id server;
-        struct messaging_context *messaging_ctx;
+        struct imessaging_context *imessaging_ctx;
         struct notify_list *list;
         struct notify_array *array;
-        int seqnum;
+        int64_t seqnum;
         struct sys_notify_context *sys_notify_ctx;
 };
@@ -64 +63 @@
 
 static NTSTATUS notify_remove_all(struct notify_context *notify);
-static void notify_handler(struct messaging_context *msg_ctx, void *private_data, 
+static void notify_handler(struct imessaging_context *msg_ctx, void *private_data,
                            uint32_t msg_type, struct server_id server_id, DATA_BLOB *data);
 
@@ -72 +71 @@
 static int notify_destructor(struct notify_context *notify)
 {
-        messaging_deregister(notify->messaging_ctx, MSG_PVFS_NOTIFY, notify);
+        imessaging_deregister(notify->imessaging_ctx, MSG_PVFS_NOTIFY, notify);
         notify_remove_all(notify);
         return 0;
@@ -79 +78 @@
 /*
   Open up the notify.tdb database. You should close it down using
-  talloc_free(). We need the messaging_ctx to allow for notifications
+  talloc_free(). We need the imessaging_ctx to allow for notifications
   via internal messages
 */
 struct notify_context *notify_init(TALLOC_CTX *mem_ctx, struct server_id server, 
-                                   struct messaging_context *messaging_ctx,
+                                   struct imessaging_context *imessaging_ctx,
                                    struct loadparm_context *lp_ctx,
                                    struct tevent_context *ev,
@@ -103 +102 @@
         }
 
-        notify->w = cluster_tdb_tmp_open(notify, lp_ctx, "notify.tdb", TDB_SEQNUM);
-        if (notify->w == NULL) {
+        notify->db = cluster_db_tmp_open(notify, lp_ctx, "notify", TDB_SEQNUM);
+        if (notify->db == NULL) {
                 talloc_free(notify);
                 return NULL;
@@ -110 +109 @@
 
         notify->server = server;
-        notify->messaging_ctx = messaging_ctx;
+        notify->imessaging_ctx = imessaging_ctx;
         notify->list = NULL;
         notify->array = NULL;
-        notify->seqnum = tdb_get_seqnum(notify->w->tdb);
+        notify->seqnum = dbwrap_get_seqnum(notify->db);
 
         talloc_set_destructor(notify, notify_destructor);
@@ -119 +118 @@
         /* register with the messaging subsystem for the notify
            message type */
-        messaging_register(notify->messaging_ctx, notify, 
+        imessaging_register(notify->imessaging_ctx, notify,
                            MSG_PVFS_NOTIFY, notify_handler);
 
@@ -131 +130 @@
   lock the notify db
 */
-static NTSTATUS notify_lock(struct notify_context *notify)
-{
-        if (tdb_lock_bystring(notify->w->tdb, NOTIFY_KEY) != 0) {
-                return NT_STATUS_INTERNAL_DB_CORRUPTION;
-        }
-        return NT_STATUS_OK;
-}
-
-/*
-  unlock the notify db
-*/
-static void notify_unlock(struct notify_context *notify)
-{
-        tdb_unlock_bystring(notify->w->tdb, NOTIFY_KEY);
+static struct db_record *notify_lock(struct notify_context *notify)
+{
+        TDB_DATA key = string_term_tdb_data(NOTIFY_KEY);
+
+        return dbwrap_fetch_locked(notify->db, notify, key);
+}
+
+static void notify_unlock(struct db_record *lock)
+{
+        talloc_free(lock);
 }
 
@@ -156 +151 @@
         enum ndr_err_code ndr_err;
         int seqnum;
-
-        seqnum = tdb_get_seqnum(notify->w->tdb);
+        NTSTATUS status;
+
+        seqnum = dbwrap_get_seqnum(notify->db);
 
         if (seqnum == notify->seqnum && notify->array != NULL) {
@@ -169 +165 @@
         NT_STATUS_HAVE_NO_MEMORY(notify->array);
 
-        dbuf = tdb_fetch_bystring(notify->w->tdb, NOTIFY_KEY);
-        if (dbuf.dptr == NULL) {
+        status = dbwrap_fetch_bystring(notify->db, notify, NOTIFY_KEY, &dbuf);
+        if (!NT_STATUS_IS_OK(status)) {
                 return NT_STATUS_OK;
         }
@@ -179 +175 @@
         ndr_err = ndr_pull_struct_blob(&blob, notify->array, notify->array,
                                        (ndr_pull_flags_fn_t)ndr_pull_notify_array);
-        free(dbuf.dptr);
+        talloc_free(dbuf.dptr);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                 return ndr_map_error2ntstatus(ndr_err);
@@ -204 +200 @@
         DATA_BLOB blob;
         enum ndr_err_code ndr_err;
-        int ret;
         TALLOC_CTX *tmp_ctx;
+        NTSTATUS status;
 
         /* if possible, remove some depth arrays */
@@ -215 +211 @@
         /* we might just be able to delete the record */
         if (notify->array->num_depths == 0) {
-                ret = tdb_delete_bystring(notify->w->tdb, NOTIFY_KEY);
-                if (ret != 0) {
-                        return NT_STATUS_INTERNAL_DB_CORRUPTION;
-                }
-                return NT_STATUS_OK;
+                return dbwrap_delete_bystring(notify->db, NOTIFY_KEY);
         }
 
@@ -234 +226 @@
         dbuf.dptr = blob.data;
         dbuf.dsize = blob.length;
-                
-        ret = tdb_store_bystring(notify->w->tdb, NOTIFY_KEY, dbuf, TDB_REPLACE);
+
+        status = dbwrap_store_bystring(notify->db, NOTIFY_KEY, dbuf,
+                                       TDB_REPLACE);
         talloc_free(tmp_ctx);
-        if (ret != 0) {
-                return NT_STATUS_INTERNAL_DB_CORRUPTION;
-        }
-
-        return NT_STATUS_OK;
+        return status;
 }
 
@@ -248 +237 @@
   handle incoming notify messages
 */
-static void notify_handler(struct messaging_context *msg_ctx, void *private_data, 
+static void notify_handler(struct imessaging_context *msg_ctx, void *private_data,
                            uint32_t msg_type, struct server_id server_id, DATA_BLOB *data)
 {
@@ -355 +344 @@
         size_t len;
         int depth;
+        struct db_record *locked;
 
         /* see if change notify is enabled at all */
@@ -361 +351 @@
         }
 
-        status = notify_lock(notify);
-        NT_STATUS_NOT_OK_RETURN(status);
+        locked = notify_lock(notify);
+        if (!locked) {
+                return NT_STATUS_INTERNAL_DB_CORRUPTION;
+        }
 
         status = notify_load(notify);
@@ -416 +408 @@
 
 done:
-        notify_unlock(notify);
+        notify_unlock(locked);
         talloc_free(tmp_path);
 
@@ -431 +423 @@
         int i, depth;
         struct notify_depth *d;
+        struct db_record *locked;
 
         /* see if change notify is enabled at all */
@@ -451 +444 @@
         talloc_free(listel);
 
-        status = notify_lock(notify);
-        NT_STATUS_NOT_OK_RETURN(status);
+        locked = notify_lock(notify);
+        if (!locked) {
+                return NT_STATUS_INTERNAL_DB_CORRUPTION;
+        }
 
         status = notify_load(notify);
         if (!NT_STATUS_IS_OK(status)) {
-                notify_unlock(notify);
+                notify_unlock(locked);
                 return status;
         }
 
         if (depth >= notify->array->num_depths) {
-                notify_unlock(notify);
+                notify_unlock(locked);
                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
         }
@@ -475 +470 @@
         }
         if (i == d->num_entries) {
-                notify_unlock(notify);
+                notify_unlock(locked);
                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
         }
@@ -487 +482 @@
         status = notify_save(notify);
 
-        notify_unlock(notify);
+        notify_unlock(locked);
 
         return status;
@@ -499 +494 @@
         NTSTATUS status;
         int i, depth, del_count=0;
+        struct db_record *locked;
 
         if (notify->list == NULL) {
@@ -504 +500 @@
         }
 
-        status = notify_lock(notify);
-        NT_STATUS_NOT_OK_RETURN(status);
+        locked = notify_lock(notify);
+        if (!locked) {
+                return NT_STATUS_INTERNAL_DB_CORRUPTION;
+        }
 
         status = notify_load(notify);
         if (!NT_STATUS_IS_OK(status)) {
-                notify_unlock(notify);
+                notify_unlock(locked);
                 return status;
         }
@@ -534 +532 @@
         }
 
-        notify_unlock(notify);
+        notify_unlock(locked);
 
         return status;
@@ -553 +551 @@
 
         ev.action = action;
+        ev.dir = discard_const_p(char, "");
         ev.path = path;
         ev.private_data = e->private_data;
@@ -564 +563 @@
         }
 
-        status = messaging_send(notify->messaging_ctx, e->server, 
+        status = imessaging_send(notify->imessaging_ctx, e->server,
                                 MSG_PVFS_NOTIFY, &data);
+        if (!NT_STATUS_IS_OK(status)) {
+                talloc_free(tmp_ctx);
+                return;
+        }
+
         talloc_free(tmp_ctx);
 }

vendor/current/source4/ntvfs/common/opendb.c

@@ -56 +56 @@
 /*
   Open up the openfiles.tdb database. Close it down using
-  talloc_free(). We need the messaging_ctx to allow for pending open
+  talloc_free(). We need the imessaging_ctx to allow for pending open
   notifications.
 */

vendor/current/source4/ntvfs/common/opendb.h

@@ -58 +58 @@
 void odb_set_ops(const struct opendb_ops *new_ops);
 void odb_tdb_init_ops(void);
-void odb_ctdb_init_ops(void);

vendor/current/source4/ntvfs/common/opendb_tdb.c

@@ -41 +41 @@
 #include "includes.h"
 #include "system/filesys.h"
-#include <tdb.h>
+#include "lib/dbwrap/dbwrap.h"
 #include "messaging/messaging.h"
-#include "lib/util/tdb_wrap.h"
 #include "lib/messaging/irpc.h"
 #include "librpc/gen_ndr/ndr_opendb.h"
@@ -53 +52 @@
 
 struct odb_context {
-        struct tdb_wrap *w;
+        struct db_context *db;
         struct ntvfs_context *ntvfs_ctx;
         bool oplocks;
@@ -65 +64 @@
 struct odb_lock {
         struct odb_context *odb;
-        TDB_DATA key;
+        struct db_record *locked;
 
         struct opendb_file file;
@@ -75 +74 @@
 };
 
-static NTSTATUS odb_oplock_break_send(struct messaging_context *msg_ctx,
+static NTSTATUS odb_oplock_break_send(struct imessaging_context *msg_ctx,
                                       struct opendb_entry *e,
                                       uint8_t level);
@@ -81 +80 @@
 /*
   Open up the openfiles.tdb database. Close it down using
-  talloc_free(). We need the messaging_ctx to allow for pending open
+  talloc_free(). We need the imessaging_ctx to allow for pending open
   notifications.
 */
@@ -94 +93 @@
         }
 
-        odb->w = cluster_tdb_tmp_open(odb, ntvfs_ctx->lp_ctx, "openfiles.tdb", TDB_DEFAULT);
-        if (odb->w == NULL) {
+        odb->db = cluster_db_tmp_open(odb, ntvfs_ctx->lp_ctx,
+                                      "openfiles", TDB_DEFAULT);
+        if (odb->db == NULL) {
                 talloc_free(odb);
                 return NULL;
@@ -112 +112 @@
 }
 
-/*
-  destroy a lock on the database
-*/
-static int odb_lock_destructor(struct odb_lock *lck)
-{
-        tdb_chainunlock(lck->odb->w->tdb, lck->key);
-        return 0;
-}
-
 static NTSTATUS odb_pull_record(struct odb_lock *lck, struct opendb_file *file);
 
@@ -132 +123 @@
         struct odb_lock *lck;
         NTSTATUS status;
+        TDB_DATA key;
 
         lck = talloc(mem_ctx, struct odb_lock);
@@ -139 +131 @@
 
         lck->odb = talloc_reference(lck, odb);
-        lck->key.dptr = talloc_memdup(lck, file_key->data, file_key->length);
-        lck->key.dsize = file_key->length;
-        if (lck->key.dptr == NULL) {
+        key.dptr = talloc_memdup(lck, file_key->data, file_key->length);
+        key.dsize = file_key->length;
+        if (key.dptr == NULL) {
                 talloc_free(lck);
                 return NULL;
         }
 
-        if (tdb_chainlock(odb->w->tdb, lck->key) != 0) {
+        lck->locked = dbwrap_fetch_locked(odb->db, lck, key);
+        if (!lck->locked) {
                 talloc_free(lck);
                 return NULL;
@@ -152 +145 @@
 
         ZERO_STRUCT(lck->can_open);
-
-        talloc_set_destructor(lck, odb_lock_destructor);
 
         status = odb_pull_record(lck, &lck->file);
@@ -169 +160 @@
 static DATA_BLOB odb_tdb_get_key(TALLOC_CTX *mem_ctx, struct odb_lock *lck)
 {
-        return data_blob_talloc(mem_ctx, lck->key.dptr, lck->key.dsize);
+        TDB_DATA key = dbwrap_record_get_key(lck->locked);
+        return data_blob_talloc(mem_ctx, key.dptr, key.dsize);
 }
 
@@ -234 +226 @@
 static NTSTATUS odb_pull_record(struct odb_lock *lck, struct opendb_file *file)
 {
-        struct odb_context *odb = lck->odb;
         TDB_DATA dbuf;
         DATA_BLOB blob;
         enum ndr_err_code ndr_err;
 
-        dbuf = tdb_fetch(odb->w->tdb, lck->key);
-        if (dbuf.dptr == NULL) {
+        dbuf = dbwrap_record_get_value(lck->locked);
+        if (!dbuf.dptr) {
                 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
         }
@@ -248 +239 @@
 
         ndr_err = ndr_pull_struct_blob(&blob, lck, file, (ndr_pull_flags_fn_t)ndr_pull_opendb_file);
-        free(dbuf.dptr);
         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                 return ndr_map_error2ntstatus(ndr_err);
@@ -261 +251 @@
 static NTSTATUS odb_push_record(struct odb_lock *lck, struct opendb_file *file)
 {
-        struct odb_context *odb = lck->odb;
         TDB_DATA dbuf;
         DATA_BLOB blob;
         enum ndr_err_code ndr_err;
-        int ret;
+        NTSTATUS status;
 
         if (file->num_entries == 0) {
-                ret = tdb_delete(odb->w->tdb, lck->key);
-                if (ret != 0) {
-                        return NT_STATUS_INTERNAL_DB_CORRUPTION;
-                }
-                return NT_STATUS_OK;
+                return dbwrap_record_delete(lck->locked);
         }
 
@@ -283 +268 @@
         dbuf.dsize = blob.length;
                 
-        ret = tdb_store(odb->w->tdb, lck->key, dbuf, TDB_REPLACE);
+        status = dbwrap_record_store(lck->locked, dbuf, TDB_REPLACE);
         data_blob_free(&blob);
-        if (ret != 0) {
-                return NT_STATUS_INTERNAL_DB_CORRUPTION;
-        }
-
-        return NT_STATUS_OK;
+        return status;
 }
 
@@ -295 +276 @@
   send an oplock break to a client
 */
-static NTSTATUS odb_oplock_break_send(struct messaging_context *msg_ctx,
+static NTSTATUS odb_oplock_break_send(struct imessaging_context *msg_ctx,
                                       struct opendb_entry *e,
                                       uint8_t level)
@@ -312 +293 @@
         blob = data_blob_const(&op_break, sizeof(op_break));
 
-        status = messaging_send(msg_ctx, e->server,
+        status = imessaging_send(msg_ctx, e->server,
                                 MSG_NTVFS_OPLOCK_BREAK, &blob);
         NT_STATUS_NOT_OK_RETURN(status);
@@ -612 +593 @@
         /* send any pending notifications, removing them once sent */
         for (i=0;i<lck->file.num_pending;i++) {
-                messaging_send_ptr(odb->ntvfs_ctx->msg_ctx,
+                imessaging_send_ptr(odb->ntvfs_ctx->msg_ctx,
                                    lck->file.pending[i].server,
                                    MSG_PVFS_RETRY_OPEN,
@@ -667 +648 @@
         /* send any pending notifications, removing them once sent */
         for (i=0;i<lck->file.num_pending;i++) {
-                messaging_send_ptr(odb->ntvfs_ctx->msg_ctx,
+                imessaging_send_ptr(odb->ntvfs_ctx->msg_ctx,
                                    lck->file.pending[i].server,
                                    MSG_PVFS_RETRY_OPEN,

vendor/current/source4/ntvfs/common/wscript_build

@@ -4 +4 @@
         source='init.c brlock.c brlock_tdb.c opendb.c opendb_tdb.c notify.c',
         autoproto='proto.h',
+        deps='util_tdb tdb-wrap',
         public_deps='NDR_OPENDB NDR_NOTIFY sys_notify sys_lease share'
         )