Finish removal of iconv_convenience in public API's.
[bbaumbach/samba-autobuild/.git] / source4 / ntvfs / common / opendb_tdb.c
index 0736af3d1efdd5f28ab968e031a502b0c0672af9..944ec866314fb0ea4c6d7eb6315b489053d90cb2 100644 (file)
@@ -40,7 +40,7 @@
 
 #include "includes.h"
 #include "system/filesys.h"
-#include "lib/tdb/include/tdb.h"
+#include "../tdb/include/tdb.h"
 #include "messaging/messaging.h"
 #include "tdb_wrap.h"
 #include "lib/messaging/irpc.h"
 #include "ntvfs/common/ntvfs_common.h"
 #include "cluster/cluster.h"
 #include "param/param.h"
+#include "ntvfs/sysdep/sys_lease.h"
 
 struct odb_context {
        struct tdb_wrap *w;
        struct ntvfs_context *ntvfs_ctx;
        bool oplocks;
+       struct sys_lease_context *lease_ctx;
 };
 
 /*
@@ -63,8 +65,19 @@ struct odb_context {
 struct odb_lock {
        struct odb_context *odb;
        TDB_DATA key;
+
+       struct opendb_file file;
+
+       struct {
+               struct opendb_entry *e;
+               bool attrs_only;
+       } can_open;
 };
 
+static NTSTATUS odb_oplock_break_send(struct messaging_context *msg_ctx,
+                                     struct opendb_entry *e,
+                                     uint8_t level);
+
 /*
   Open up the openfiles.tdb database. Close it down using
   talloc_free(). We need the messaging_ctx to allow for pending open
@@ -88,8 +101,12 @@ static struct odb_context *odb_tdb_init(TALLOC_CTX *mem_ctx,
 
        odb->ntvfs_ctx = ntvfs_ctx;
 
-       /* leave oplocks disabled by default until the code is working */
-       odb->oplocks = lp_parm_bool(ntvfs_ctx->lp_ctx, NULL, "opendb", "oplocks", false);
+       odb->oplocks = share_bool_option(ntvfs_ctx->config, SHARE_OPLOCKS, SHARE_OPLOCKS_DEFAULT);
+
+       odb->lease_ctx = sys_lease_context_create(ntvfs_ctx->config, odb,
+                                                 ntvfs_ctx->event_ctx,
+                                                 ntvfs_ctx->msg_ctx,
+                                                 odb_oplock_break_send);
 
        return odb;
 }
@@ -103,6 +120,8 @@ static int odb_lock_destructor(struct odb_lock *lck)
        return 0;
 }
 
+static NTSTATUS odb_pull_record(struct odb_lock *lck, struct opendb_file *file);
+
 /*
   get a lock on a entry in the odb. This call returns a lock handle,
   which the caller should unlock using talloc_free().
@@ -111,6 +130,7 @@ static struct odb_lock *odb_tdb_lock(TALLOC_CTX *mem_ctx,
                                     struct odb_context *odb, DATA_BLOB *file_key)
 {
        struct odb_lock *lck;
+       NTSTATUS status;
 
        lck = talloc(mem_ctx, struct odb_lock);
        if (lck == NULL) {
@@ -130,7 +150,18 @@ static struct odb_lock *odb_tdb_lock(TALLOC_CTX *mem_ctx,
                return NULL;
        }
 
+       ZERO_STRUCT(lck->can_open);
+
        talloc_set_destructor(lck, odb_lock_destructor);
+
+       status = odb_pull_record(lck, &lck->file);
+       if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
+               /* initialise a blank structure */
+               ZERO_STRUCT(lck->file);
+       } else if (!NT_STATUS_IS_OK(status)) {
+               talloc_free(lck);
+               return NULL;
+       }
        
        return lck;
 }
@@ -215,7 +246,7 @@ static NTSTATUS odb_pull_record(struct odb_lock *lck, struct opendb_file *file)
        blob.data = dbuf.dptr;
        blob.length = dbuf.dsize;
 
-       ndr_err = ndr_pull_struct_blob(&blob, lck, lp_iconv_convenience(lck->odb->ntvfs_ctx->lp_ctx), file, (ndr_pull_flags_fn_t)ndr_pull_opendb_file);
+       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);
@@ -243,7 +274,7 @@ static NTSTATUS odb_push_record(struct odb_lock *lck, struct opendb_file *file)
                return NT_STATUS_OK;
        }
 
-       ndr_err = ndr_push_struct_blob(&blob, lck, lp_iconv_convenience(lck->odb->ntvfs_ctx->lp_ctx), file, (ndr_push_flags_fn_t)ndr_push_opendb_file);
+       ndr_err = ndr_push_struct_blob(&blob, lck, file, (ndr_push_flags_fn_t)ndr_push_opendb_file);
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
                return ndr_map_error2ntstatus(ndr_err);
        }
@@ -263,7 +294,7 @@ static NTSTATUS odb_push_record(struct odb_lock *lck, struct opendb_file *file)
 /*
   send an oplock break to a client
 */
-static NTSTATUS odb_oplock_break_send(struct odb_context *odb,
+static NTSTATUS odb_oplock_break_send(struct messaging_context *msg_ctx,
                                      struct opendb_entry *e,
                                      uint8_t level)
 {
@@ -280,7 +311,7 @@ static NTSTATUS odb_oplock_break_send(struct odb_context *odb,
 
        blob = data_blob_const(&op_break, sizeof(op_break));
 
-       status = messaging_send(odb->ntvfs_ctx->msg_ctx, e->server,
+       status = messaging_send(msg_ctx, e->server,
                                MSG_NTVFS_OPLOCK_BREAK, &blob);
        NT_STATUS_NOT_OK_RETURN(status);
 
@@ -348,7 +379,8 @@ static NTSTATUS odb_tdb_open_can_internal(struct odb_context *odb,
                            !file->entries[i].allow_level_II_oplock) {
                                oplock_return = OPLOCK_BREAK_TO_NONE;
                        }
-                       odb_oplock_break_send(odb, &file->entries[i],
+                       odb_oplock_break_send(odb->ntvfs_ctx->msg_ctx,
+                                             &file->entries[i],
                                              oplock_return);
                        return NT_STATUS_OPLOCK_NOT_GRANTED;
                }
@@ -396,7 +428,8 @@ static NTSTATUS odb_tdb_open_can_internal(struct odb_context *odb,
                            !file->entries[i].allow_level_II_oplock) {
                                oplock_return = OPLOCK_BREAK_TO_NONE;
                        }
-                       odb_oplock_break_send(odb, &file->entries[i],
+                       odb_oplock_break_send(odb->ntvfs_ctx->msg_ctx,
+                                             &file->entries[i],
                                              oplock_return);
                        return NT_STATUS_OPLOCK_NOT_GRANTED;
                }
@@ -409,128 +442,131 @@ static NTSTATUS odb_tdb_open_can_internal(struct odb_context *odb,
 }
 
 /*
-  register an open file in the open files database. This implements the share_access
-  rules
+  register an open file in the open files database.
+  The share_access rules are implemented by odb_can_open()
+  and it's needed to call odb_can_open() before
+  odb_open_file() otherwise NT_STATUS_INTERNAL_ERROR is returned
 
   Note that the path is only used by the delete on close logic, not
   for comparing with other filenames
 */
 static NTSTATUS odb_tdb_open_file(struct odb_lock *lck,
                                  void *file_handle, const char *path,
-                                 uint32_t stream_id, uint32_t share_access,
-                                 uint32_t access_mask, bool delete_on_close,
-                                 uint32_t open_disposition, bool break_to_none,
+                                 int *fd, NTTIME open_write_time,
                                  bool allow_level_II_oplock,
                                  uint32_t oplock_level, uint32_t *oplock_granted)
 {
        struct odb_context *odb = lck->odb;
-       struct opendb_entry e;
-       struct opendb_file file;
-       NTSTATUS status;
-       bool attrs_only = false;
+
+       if (!lck->can_open.e) {
+               return NT_STATUS_INTERNAL_ERROR;
+       }
 
        if (odb->oplocks == false) {
                oplock_level = OPLOCK_NONE;
        }
 
-       status = odb_pull_record(lck, &file);
-       if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
-               /* initialise a blank structure */
-               ZERO_STRUCT(file);
-               file.path = path;
-       } else {
-               NT_STATUS_NOT_OK_RETURN(status);
+       if (!oplock_granted) {
+               oplock_level = OPLOCK_NONE;
        }
 
-       /* see if it conflicts */
-       status = odb_tdb_open_can_internal(odb, &file, stream_id,
-                                          share_access, access_mask,
-                                          delete_on_close, open_disposition,
-                                          break_to_none, &attrs_only);
-       NT_STATUS_NOT_OK_RETURN(status);
+       if (lck->file.path == NULL) {
+               lck->file.path = talloc_strdup(lck, path);
+               NT_STATUS_HAVE_NO_MEMORY(lck->file.path);
+       }
 
-       /* see if it conflicts */
-       e.server                = odb->ntvfs_ctx->server_id;
-       e.file_handle           = file_handle;
-       e.stream_id             = stream_id;
-       e.share_access          = share_access;
-       e.access_mask           = access_mask;
-       e.delete_on_close       = delete_on_close;
-       e.allow_level_II_oplock = allow_level_II_oplock;
-       e.oplock_level          = OPLOCK_NONE;
+       if (lck->file.open_write_time == 0) {
+               lck->file.open_write_time = open_write_time;
+       }
 
        /*
          possibly grant an exclusive, batch or level2 oplock
        */
+       if (lck->can_open.attrs_only) {
+               oplock_level    = OPLOCK_NONE;
+       } else if (oplock_level == OPLOCK_EXCLUSIVE) {
+               if (lck->file.num_entries == 0) {
+                       oplock_level    = OPLOCK_EXCLUSIVE;
+               } else if (allow_level_II_oplock) {
+                       oplock_level    = OPLOCK_LEVEL_II;
+               } else {
+                       oplock_level    = OPLOCK_NONE;
+               }
+       } else if (oplock_level == OPLOCK_BATCH) {
+               if (lck->file.num_entries == 0) {
+                       oplock_level    = OPLOCK_BATCH;
+               } else if (allow_level_II_oplock) {
+                       oplock_level    = OPLOCK_LEVEL_II;
+               } else {
+                       oplock_level    = OPLOCK_NONE;
+               }
+       } else if (oplock_level == OPLOCK_LEVEL_II) {
+               oplock_level    = OPLOCK_LEVEL_II;
+       } else {
+               oplock_level    = OPLOCK_NONE;
+       }
+
+       lck->can_open.e->file_handle            = file_handle;
+       lck->can_open.e->fd                     = fd;
+       lck->can_open.e->allow_level_II_oplock  = allow_level_II_oplock;
+       lck->can_open.e->oplock_level           = oplock_level;
+
+       if (odb->lease_ctx && fd) {
+               NTSTATUS status;
+               status = sys_lease_setup(odb->lease_ctx, lck->can_open.e);
+               NT_STATUS_NOT_OK_RETURN(status);
+       }
+
        if (oplock_granted) {
-               if (attrs_only) {
-                       e.oplock_level  = OPLOCK_NONE;
-                       *oplock_granted = NO_OPLOCK_RETURN;
-               } else if (oplock_level == OPLOCK_EXCLUSIVE) {
-                       if (file.num_entries == 0) {
-                               e.oplock_level  = OPLOCK_EXCLUSIVE;
-                               *oplock_granted = EXCLUSIVE_OPLOCK_RETURN;
-                       } else if (allow_level_II_oplock) {
-                               e.oplock_level  = OPLOCK_LEVEL_II;
-                               *oplock_granted = LEVEL_II_OPLOCK_RETURN;
-                       } else {
-                               e.oplock_level  = OPLOCK_NONE;
-                               *oplock_granted = NO_OPLOCK_RETURN;
-                       }
-               } else if (oplock_level == OPLOCK_BATCH) {
-                       if (file.num_entries == 0) {
-                               e.oplock_level  = OPLOCK_BATCH;
-                               *oplock_granted = BATCH_OPLOCK_RETURN;
-                       } else if (allow_level_II_oplock) {
-                               e.oplock_level  = OPLOCK_LEVEL_II;
-                               *oplock_granted = LEVEL_II_OPLOCK_RETURN;
-                       } else {
-                               e.oplock_level  = OPLOCK_NONE;
-                               *oplock_granted = NO_OPLOCK_RETURN;
-                       }
-               } else if (oplock_level == OPLOCK_LEVEL_II) {
-                       e.oplock_level  = OPLOCK_LEVEL_II;
+               if (lck->can_open.e->oplock_level == OPLOCK_EXCLUSIVE) {
+                       *oplock_granted = EXCLUSIVE_OPLOCK_RETURN;
+               } else if (lck->can_open.e->oplock_level == OPLOCK_BATCH) {
+                       *oplock_granted = BATCH_OPLOCK_RETURN;
+               } else if (lck->can_open.e->oplock_level == OPLOCK_LEVEL_II) {
                        *oplock_granted = LEVEL_II_OPLOCK_RETURN;
                } else {
-                       e.oplock_level  = OPLOCK_NONE;
                        *oplock_granted = NO_OPLOCK_RETURN;
                }
        }
 
        /* it doesn't conflict, so add it to the end */
-       file.entries = talloc_realloc(lck, file.entries, struct opendb_entry, 
-                                     file.num_entries+1);
-       NT_STATUS_HAVE_NO_MEMORY(file.entries);
+       lck->file.entries = talloc_realloc(lck, lck->file.entries,
+                                          struct opendb_entry,
+                                          lck->file.num_entries+1);
+       NT_STATUS_HAVE_NO_MEMORY(lck->file.entries);
 
-       file.entries[file.num_entries] = e;
-       file.num_entries++;
+       lck->file.entries[lck->file.num_entries] = *lck->can_open.e;
+       lck->file.num_entries++;
 
-       return odb_push_record(lck, &file);
+       talloc_free(lck->can_open.e);
+       lck->can_open.e = NULL;
+
+       return odb_push_record(lck, &lck->file);
 }
 
 
 /*
   register a pending open file in the open files database
 */
-static NTSTATUS odb_tdb_open_file_pending(struct odb_lock *lck, void *private)
+static NTSTATUS odb_tdb_open_file_pending(struct odb_lock *lck, void *private_data)
 {
        struct odb_context *odb = lck->odb;
-       struct opendb_file file;
-       NTSTATUS status;
-               
-       status = odb_pull_record(lck, &file);
-       NT_STATUS_NOT_OK_RETURN(status);
 
-       file.pending = talloc_realloc(lck, file.pending, struct opendb_pending, 
-                                     file.num_pending+1);
-       NT_STATUS_HAVE_NO_MEMORY(file.pending);
+       if (lck->file.path == NULL) {
+               return NT_STATUS_OBJECT_NAME_NOT_FOUND;
+       }
+
+       lck->file.pending = talloc_realloc(lck, lck->file.pending,
+                                          struct opendb_pending,
+                                          lck->file.num_pending+1);
+       NT_STATUS_HAVE_NO_MEMORY(lck->file.pending);
 
-       file.pending[file.num_pending].server = odb->ntvfs_ctx->server_id;
-       file.pending[file.num_pending].notify_ptr = private;
+       lck->file.pending[lck->file.num_pending].server = odb->ntvfs_ctx->server_id;
+       lck->file.pending[lck->file.num_pending].notify_ptr = private_data;
 
-       file.num_pending++;
+       lck->file.num_pending++;
 
-       return odb_push_record(lck, &file);
+       return odb_push_record(lck, &lck->file);
 }
 
 
@@ -541,54 +577,58 @@ static NTSTATUS odb_tdb_close_file(struct odb_lock *lck, void *file_handle,
                                   const char **_delete_path)
 {
        struct odb_context *odb = lck->odb;
-       struct opendb_file file;
        const char *delete_path = NULL;
        int i;
-       NTSTATUS status;
 
-       status = odb_pull_record(lck, &file);
-       NT_STATUS_NOT_OK_RETURN(status);
+       if (lck->file.path == NULL) {
+               return NT_STATUS_OBJECT_NAME_NOT_FOUND;
+       }
 
        /* find the entry, and delete it */
-       for (i=0;i<file.num_entries;i++) {
-               if (file_handle == file.entries[i].file_handle &&
-                   cluster_id_equal(&odb->ntvfs_ctx->server_id, &file.entries[i].server)) {
-                       if (file.entries[i].delete_on_close) {
-                               file.delete_on_close = true;
+       for (i=0;i<lck->file.num_entries;i++) {
+               if (file_handle == lck->file.entries[i].file_handle &&
+                   cluster_id_equal(&odb->ntvfs_ctx->server_id, &lck->file.entries[i].server)) {
+                       if (lck->file.entries[i].delete_on_close) {
+                               lck->file.delete_on_close = true;
+                       }
+                       if (odb->lease_ctx && lck->file.entries[i].fd) {
+                               NTSTATUS status;
+                               status = sys_lease_remove(odb->lease_ctx, &lck->file.entries[i]);
+                               NT_STATUS_NOT_OK_RETURN(status);
                        }
-                       if (i < file.num_entries-1) {
-                               memmove(file.entries+i, file.entries+i+1, 
-                                       (file.num_entries - (i+1)) * 
+                       if (i < lck->file.num_entries-1) {
+                               memmove(lck->file.entries+i, lck->file.entries+i+1,
+                                       (lck->file.num_entries - (i+1)) *
                                        sizeof(struct opendb_entry));
                        }
                        break;
                }
        }
 
-       if (i == file.num_entries) {
+       if (i == lck->file.num_entries) {
                return NT_STATUS_UNSUCCESSFUL;
        }
 
        /* send any pending notifications, removing them once sent */
-       for (i=0;i<file.num_pending;i++) {
-               messaging_send_ptr(odb->ntvfs_ctx->msg_ctx, file.pending[i].server, 
-                                  MSG_PVFS_RETRY_OPEN, 
-                                  file.pending[i].notify_ptr);
+       for (i=0;i<lck->file.num_pending;i++) {
+               messaging_send_ptr(odb->ntvfs_ctx->msg_ctx,
+                                  lck->file.pending[i].server,
+                                  MSG_PVFS_RETRY_OPEN,
+                                  lck->file.pending[i].notify_ptr);
        }
-       file.num_pending = 0;
+       lck->file.num_pending = 0;
 
-       file.num_entries--;
+       lck->file.num_entries--;
 
-       if (file.num_entries == 0 && file.delete_on_close) {
-               delete_path = talloc_strdup(lck, file.path);
-               NT_STATUS_HAVE_NO_MEMORY(delete_path);
+       if (lck->file.num_entries == 0 && lck->file.delete_on_close) {
+               delete_path = lck->file.path;
        }
 
        if (_delete_path) {
                *_delete_path = delete_path;
        }
 
-       return odb_push_record(lck, &file);
+       return odb_push_record(lck, &lck->file);
 }
 
 /*
@@ -598,36 +638,42 @@ static NTSTATUS odb_tdb_update_oplock(struct odb_lock *lck, void *file_handle,
                                      uint32_t oplock_level)
 {
        struct odb_context *odb = lck->odb;
-       struct opendb_file file;
        int i;
-       NTSTATUS status;
 
-       status = odb_pull_record(lck, &file);
-       NT_STATUS_NOT_OK_RETURN(status);
+       if (lck->file.path == NULL) {
+               return NT_STATUS_OBJECT_NAME_NOT_FOUND;
+       }
 
        /* find the entry, and update it */
-       for (i=0;i<file.num_entries;i++) {
-               if (file_handle == file.entries[i].file_handle &&
-                   cluster_id_equal(&odb->ntvfs_ctx->server_id, &file.entries[i].server)) {
-                       file.entries[i].oplock_level = oplock_level;
+       for (i=0;i<lck->file.num_entries;i++) {
+               if (file_handle == lck->file.entries[i].file_handle &&
+                   cluster_id_equal(&odb->ntvfs_ctx->server_id, &lck->file.entries[i].server)) {
+                       lck->file.entries[i].oplock_level = oplock_level;
+
+                       if (odb->lease_ctx && lck->file.entries[i].fd) {
+                               NTSTATUS status;
+                               status = sys_lease_update(odb->lease_ctx, &lck->file.entries[i]);
+                               NT_STATUS_NOT_OK_RETURN(status);
+                       }
+
                        break;
                }
        }
 
-       if (i == file.num_entries) {
+       if (i == lck->file.num_entries) {
                return NT_STATUS_UNSUCCESSFUL;
        }
 
        /* send any pending notifications, removing them once sent */
-       for (i=0;i<file.num_pending;i++) {
+       for (i=0;i<lck->file.num_pending;i++) {
                messaging_send_ptr(odb->ntvfs_ctx->msg_ctx,
-                                  file.pending[i].server,
+                                  lck->file.pending[i].server,
                                   MSG_PVFS_RETRY_OPEN,
-                                  file.pending[i].notify_ptr);
+                                  lck->file.pending[i].notify_ptr);
        }
-       file.num_pending = 0;
+       lck->file.num_pending = 0;
 
-       return odb_push_record(lck, &file);
+       return odb_push_record(lck, &lck->file);
 }
 
 /*
@@ -636,34 +682,27 @@ static NTSTATUS odb_tdb_update_oplock(struct odb_lock *lck, void *file_handle,
 static NTSTATUS odb_tdb_break_oplocks(struct odb_lock *lck)
 {
        struct odb_context *odb = lck->odb;
-       NTSTATUS status;
-       struct opendb_file file;
        int i;
-       bool modified = true;
-
-       status = odb_pull_record(lck, &file);
-       if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
-               return NT_STATUS_OK;
-       }
-       NT_STATUS_NOT_OK_RETURN(status);
+       bool modified = false;
 
        /* see if anyone has an oplock, which we need to break */
-       for (i=0;i<file.num_entries;i++) {
-               if (file.entries[i].oplock_level == OPLOCK_LEVEL_II) {
+       for (i=0;i<lck->file.num_entries;i++) {
+               if (lck->file.entries[i].oplock_level == OPLOCK_LEVEL_II) {
                        /*
                         * there could be multiple level2 oplocks
                         * and we just send a break to none to all of them
                         * without waiting for a release
                         */
-                       odb_oplock_break_send(odb, &file.entries[i],
+                       odb_oplock_break_send(odb->ntvfs_ctx->msg_ctx,
+                                             &lck->file.entries[i],
                                              OPLOCK_BREAK_TO_NONE);
-                       file.entries[i].oplock_level = OPLOCK_NONE;
+                       lck->file.entries[i].oplock_level = OPLOCK_NONE;
                        modified = true;
                }
        }
 
        if (modified) {
-               return odb_push_record(lck, &file);
+               return odb_push_record(lck, &lck->file);
        }
        return NT_STATUS_OK;
 }
@@ -671,36 +710,35 @@ static NTSTATUS odb_tdb_break_oplocks(struct odb_lock *lck)
 /*
   remove a pending opendb entry
 */
-static NTSTATUS odb_tdb_remove_pending(struct odb_lock *lck, void *private)
+static NTSTATUS odb_tdb_remove_pending(struct odb_lock *lck, void *private_data)
 {
        struct odb_context *odb = lck->odb;
        int i;
-       NTSTATUS status;
-       struct opendb_file file;
 
-       status = odb_pull_record(lck, &file);
-       NT_STATUS_NOT_OK_RETURN(status);
+       if (lck->file.path == NULL) {
+               return NT_STATUS_OBJECT_NAME_NOT_FOUND;
+       }
 
        /* find the entry, and delete it */
-       for (i=0;i<file.num_pending;i++) {
-               if (private == file.pending[i].notify_ptr &&
-                   cluster_id_equal(&odb->ntvfs_ctx->server_id, &file.pending[i].server)) {
-                       if (i < file.num_pending-1) {
-                               memmove(file.pending+i, file.pending+i+1, 
-                                       (file.num_pending - (i+1)) * 
+       for (i=0;i<lck->file.num_pending;i++) {
+               if (private_data == lck->file.pending[i].notify_ptr &&
+                   cluster_id_equal(&odb->ntvfs_ctx->server_id, &lck->file.pending[i].server)) {
+                       if (i < lck->file.num_pending-1) {
+                               memmove(lck->file.pending+i, lck->file.pending+i+1,
+                                       (lck->file.num_pending - (i+1)) *
                                        sizeof(struct opendb_pending));
                        }
                        break;
                }
        }
 
-       if (i == file.num_pending) {
+       if (i == lck->file.num_pending) {
                return NT_STATUS_UNSUCCESSFUL;
        }
 
-       file.num_pending--;
+       lck->file.num_pending--;
        
-       return odb_push_record(lck, &file);
+       return odb_push_record(lck, &lck->file);
 }
 
 
@@ -709,18 +747,15 @@ static NTSTATUS odb_tdb_remove_pending(struct odb_lock *lck, void *private)
 */
 static NTSTATUS odb_tdb_rename(struct odb_lock *lck, const char *path)
 {
-       struct opendb_file file;
-       NTSTATUS status;
-
-       status = odb_pull_record(lck, &file);
-       if (NT_STATUS_EQUAL(NT_STATUS_OBJECT_NAME_NOT_FOUND, status)) {
+       if (lck->file.path == NULL) {
                /* not having the record at all is OK */
                return NT_STATUS_OK;
        }
-       NT_STATUS_NOT_OK_RETURN(status);
 
-       file.path = path;
-       return odb_push_record(lck, &file);
+       lck->file.path = talloc_strdup(lck, path);
+       NT_STATUS_HAVE_NO_MEMORY(lck->file.path);
+
+       return odb_push_record(lck, &lck->file);
 }
 
 /*
@@ -728,16 +763,14 @@ static NTSTATUS odb_tdb_rename(struct odb_lock *lck, const char *path)
 */
 static NTSTATUS odb_tdb_get_path(struct odb_lock *lck, const char **path)
 {
-       struct opendb_file file;
-       NTSTATUS status;
-
        *path = NULL;
 
-       status = odb_pull_record(lck, &file);
        /* we don't ignore NT_STATUS_OBJECT_NAME_NOT_FOUND here */
-       NT_STATUS_NOT_OK_RETURN(status);
+       if (lck->file.path == NULL) {
+               return NT_STATUS_OBJECT_NAME_NOT_FOUND;
+       }
 
-       *path = file.path;
+       *path = lck->file.path;
 
        return NT_STATUS_OK;
 }
@@ -747,45 +780,64 @@ static NTSTATUS odb_tdb_get_path(struct odb_lock *lck, const char **path)
 */
 static NTSTATUS odb_tdb_set_delete_on_close(struct odb_lock *lck, bool del_on_close)
 {
-       NTSTATUS status;
-       struct opendb_file file;
+       if (lck->file.path == NULL) {
+               return NT_STATUS_OBJECT_NAME_NOT_FOUND;
+       }
 
-       status = odb_pull_record(lck, &file);
-       NT_STATUS_NOT_OK_RETURN(status);
+       lck->file.delete_on_close = del_on_close;
+
+       return odb_push_record(lck, &lck->file);
+}
+
+/*
+  update the write time on an open file
+*/
+static NTSTATUS odb_tdb_set_write_time(struct odb_lock *lck,
+                                      NTTIME write_time, bool force)
+{
+       if (lck->file.path == NULL) {
+               return NT_STATUS_OBJECT_NAME_NOT_FOUND;
+       }
+
+       if (lck->file.changed_write_time != 0 && !force) {
+               return NT_STATUS_OK;
+       }
 
-       file.delete_on_close = del_on_close;
+       lck->file.changed_write_time = write_time;
 
-       return odb_push_record(lck, &file);
+       return odb_push_record(lck, &lck->file);
 }
 
 /*
   return the current value of the delete_on_close bit, and how many
   people still have the file open
 */
-static NTSTATUS odb_tdb_get_delete_on_close(struct odb_context *odb, 
-                                           DATA_BLOB *key, bool *del_on_close)
+static NTSTATUS odb_tdb_get_file_infos(struct odb_context *odb, DATA_BLOB *key,
+                                      bool *del_on_close, NTTIME *write_time)
 {
-       NTSTATUS status;
-       struct opendb_file file;
        struct odb_lock *lck;
 
-       (*del_on_close) = false;
+       if (del_on_close) {
+               *del_on_close = false;
+       }
+       if (write_time) {
+               *write_time = 0;
+       }
 
        lck = odb_lock(odb, odb, key);
        NT_STATUS_HAVE_NO_MEMORY(lck);
 
-       status = odb_pull_record(lck, &file);
-       if (NT_STATUS_EQUAL(NT_STATUS_OBJECT_NAME_NOT_FOUND, status)) {
-               talloc_free(lck);
-               return NT_STATUS_OK;
+       if (del_on_close) {
+               *del_on_close = lck->file.delete_on_close;
        }
-       if (!NT_STATUS_IS_OK(status)) {
-               talloc_free(lck);
-               return status;
+       if (write_time) {
+               if (lck->file.changed_write_time == 0) {
+                       *write_time = lck->file.open_write_time;
+               } else {
+                       *write_time = lck->file.changed_write_time;
+               }
        }
 
-       (*del_on_close) = file.delete_on_close;
-
        talloc_free(lck);
 
        return NT_STATUS_OK;
@@ -803,21 +855,26 @@ static NTSTATUS odb_tdb_can_open(struct odb_lock *lck,
 {
        struct odb_context *odb = lck->odb;
        NTSTATUS status;
-       struct opendb_file file;
-       bool attrs_only = false;
 
-       status = odb_pull_record(lck, &file);
-       if (NT_STATUS_EQUAL(status, NT_STATUS_OBJECT_NAME_NOT_FOUND)) {
-               return NT_STATUS_OK;
-       }
-       NT_STATUS_NOT_OK_RETURN(status);
-
-       status = odb_tdb_open_can_internal(odb, &file, stream_id,
+       status = odb_tdb_open_can_internal(odb, &lck->file, stream_id,
                                           share_access, access_mask,
                                           delete_on_close, open_disposition,
-                                          break_to_none, &attrs_only);
+                                          break_to_none, &lck->can_open.attrs_only);
        NT_STATUS_NOT_OK_RETURN(status);
 
+       lck->can_open.e = talloc(lck, struct opendb_entry);
+       NT_STATUS_HAVE_NO_MEMORY(lck->can_open.e);
+
+       lck->can_open.e->server                 = odb->ntvfs_ctx->server_id;
+       lck->can_open.e->file_handle            = NULL;
+       lck->can_open.e->fd                     = NULL;
+       lck->can_open.e->stream_id              = stream_id;
+       lck->can_open.e->share_access           = share_access;
+       lck->can_open.e->access_mask            = access_mask;
+       lck->can_open.e->delete_on_close        = delete_on_close;
+       lck->can_open.e->allow_level_II_oplock  = false;
+       lck->can_open.e->oplock_level           = OPLOCK_NONE;
+
        return NT_STATUS_OK;
 }
 
@@ -833,7 +890,8 @@ static const struct opendb_ops opendb_tdb_ops = {
        .odb_rename              = odb_tdb_rename,
        .odb_get_path            = odb_tdb_get_path,
        .odb_set_delete_on_close = odb_tdb_set_delete_on_close,
-       .odb_get_delete_on_close = odb_tdb_get_delete_on_close,
+       .odb_set_write_time      = odb_tdb_set_write_time,
+       .odb_get_file_infos      = odb_tdb_get_file_infos,
        .odb_can_open            = odb_tdb_can_open,
        .odb_update_oplock       = odb_tdb_update_oplock,
        .odb_break_oplocks       = odb_tdb_break_oplocks
@@ -842,5 +900,6 @@ static const struct opendb_ops opendb_tdb_ops = {
 
 void odb_tdb_init_ops(void)
 {
+       sys_lease_init();
        odb_set_ops(&opendb_tdb_ops);
 }