s3-talloc Change TALLOC_ARRAY() to talloc_array()
[samba.git] / source3 / locking / locking.c
index 39cc991b5f297b6b997ffb60bbf4ed0369acf9fe..55412ec8b2aa8c702db98b739d6e6fe2f64b276c 100644 (file)
@@ -4,20 +4,19 @@
    Copyright (C) Andrew Tridgell 1992-2000
    Copyright (C) Jeremy Allison 1992-2006
    Copyright (C) Volker Lendecke 2005
-   
+
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
-   
+
    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
-   
+
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
    Revision History:
 
 */
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "locking/proto.h"
+#include "smbd/globals.h"
+#include "dbwrap.h"
+#include "../libcli/security/security.h"
+#include "serverid.h"
+#include "messages.h"
+#include "util_tdb.h"
 
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_LOCKING
 
+#define NO_LOCKING_COUNT (-1)
+
 /* the locking database handle */
-static TDB_CONTEXT *tdb;
+static struct db_context *lock_db;
 
 /****************************************************************************
  Debugging aids :-).
@@ -74,82 +83,103 @@ const char *lock_flav_name(enum brl_flavour lock_flav)
  Called in the read/write codepath.
 ****************************************************************************/
 
-BOOL is_locked(files_struct *fsp,
-               uint32 smbpid,
-               SMB_BIG_UINT count,
-               SMB_BIG_UINT offset, 
-               enum brl_type lock_type)
+void init_strict_lock_struct(files_struct *fsp,
+                               uint64_t smblctx,
+                               br_off start,
+                               br_off size,
+                               enum brl_type lock_type,
+                               struct lock_struct *plock)
+{
+       SMB_ASSERT(lock_type == READ_LOCK || lock_type == WRITE_LOCK);
+
+       plock->context.smblctx = smblctx;
+        plock->context.tid = fsp->conn->cnum;
+        plock->context.pid = sconn_server_id(fsp->conn->sconn);
+        plock->start = start;
+        plock->size = size;
+        plock->fnum = fsp->fnum;
+        plock->lock_type = lock_type;
+        plock->lock_flav = lp_posix_cifsu_locktype(fsp);
+}
+
+bool strict_lock_default(files_struct *fsp, struct lock_struct *plock)
 {
        int strict_locking = lp_strict_locking(fsp->conn->params);
-       enum brl_flavour lock_flav = lp_posix_cifsu_locktype(fsp);
-       BOOL ret = True;
-       
-       if (count == 0) {
-               return False;
+       bool ret = False;
+
+       if (plock->size == 0) {
+               return True;
        }
 
        if (!lp_locking(fsp->conn->params) || !strict_locking) {
-               return False;
+               return True;
        }
 
        if (strict_locking == Auto) {
-               if  (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (lock_type == READ_LOCK || lock_type == WRITE_LOCK)) {
-                       DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp->fsp_name ));
-                       ret = False;
+               if  (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (plock->lock_type == READ_LOCK || plock->lock_type == WRITE_LOCK)) {
+                       DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp_str_dbg(fsp)));
+                       ret = True;
                } else if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
-                          (lock_type == READ_LOCK)) {
-                       DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp->fsp_name ));
-                       ret = False;
+                          (plock->lock_type == READ_LOCK)) {
+                       DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp_str_dbg(fsp)));
+                       ret = True;
                } else {
-                       struct byte_range_lock *br_lck = brl_get_locks_readonly(NULL, fsp);
+                       struct byte_range_lock *br_lck;
+
+                       br_lck = brl_get_locks_readonly(fsp);
                        if (!br_lck) {
-                               return False;
+                               return True;
                        }
-                       ret = !brl_locktest(br_lck,
-                                       smbpid,
-                                       procid_self(),
-                                       offset,
-                                       count,
-                                       lock_type,
-                                       lock_flav);
-                       TALLOC_FREE(br_lck);
+                       ret = brl_locktest(br_lck,
+                                       plock->context.smblctx,
+                                       plock->context.pid,
+                                       plock->start,
+                                       plock->size,
+                                       plock->lock_type,
+                                       plock->lock_flav);
                }
        } else {
-               struct byte_range_lock *br_lck = brl_get_locks_readonly(NULL, fsp);
+               struct byte_range_lock *br_lck;
+
+               br_lck = brl_get_locks_readonly(fsp);
                if (!br_lck) {
-                       return False;
+                       return True;
                }
-               ret = !brl_locktest(br_lck,
-                               smbpid,
-                               procid_self(),
-                               offset,
-                               count,
-                               lock_type,
-                               lock_flav);
-               TALLOC_FREE(br_lck);
-       }
-
-       DEBUG(10,("is_locked: flavour = %s brl start=%.0f len=%.0f %s for fnum %d file %s\n",
-                       lock_flav_name(lock_flav),
-                       (double)offset, (double)count, ret ? "locked" : "unlocked",
-                       fsp->fnum, fsp->fsp_name ));
+               ret = brl_locktest(br_lck,
+                               plock->context.smblctx,
+                               plock->context.pid,
+                               plock->start,
+                               plock->size,
+                               plock->lock_type,
+                               plock->lock_flav);
+       }
+
+       DEBUG(10,("strict_lock_default: flavour = %s brl start=%.0f "
+                       "len=%.0f %s for fnum %d file %s\n",
+                       lock_flav_name(plock->lock_flav),
+                       (double)plock->start, (double)plock->size,
+                       ret ? "unlocked" : "locked",
+                       plock->fnum, fsp_str_dbg(fsp)));
 
        return ret;
 }
 
+void strict_unlock_default(files_struct *fsp, struct lock_struct *plock)
+{
+}
+
 /****************************************************************************
  Find out if a lock could be granted - return who is blocking us if we can't.
 ****************************************************************************/
 
 NTSTATUS query_lock(files_struct *fsp,
-                       uint32 *psmbpid,
-                       SMB_BIG_UINT *pcount,
-                       SMB_BIG_UINT *poffset,
+                       uint64_t *psmblctx,
+                       uint64_t *pcount,
+                       uint64_t *poffset,
                        enum brl_type *plock_type,
                        enum brl_flavour lock_flav)
 {
        struct byte_range_lock *br_lck = NULL;
-       NTSTATUS status = NT_STATUS_LOCK_NOT_GRANTED;
 
        if (!fsp->can_lock) {
                return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
@@ -159,38 +189,72 @@ NTSTATUS query_lock(files_struct *fsp,
                return NT_STATUS_OK;
        }
 
-       br_lck = brl_get_locks_readonly(NULL, fsp);
+       br_lck = brl_get_locks_readonly(fsp);
        if (!br_lck) {
                return NT_STATUS_NO_MEMORY;
        }
 
-       status = brl_lockquery(br_lck,
-                       psmbpid,
-                       procid_self(),
+       return brl_lockquery(br_lck,
+                       psmblctx,
+                       sconn_server_id(fsp->conn->sconn),
                        poffset,
                        pcount,
                        plock_type,
                        lock_flav);
+}
 
-       TALLOC_FREE(br_lck);
-       return status;
+static void increment_current_lock_count(files_struct *fsp,
+    enum brl_flavour lock_flav)
+{
+       if (lock_flav == WINDOWS_LOCK &&
+           fsp->current_lock_count != NO_LOCKING_COUNT) {
+               /* blocking ie. pending, locks also count here,
+                * as this is an efficiency counter to avoid checking
+                * the lock db. on close. JRA. */
+
+               fsp->current_lock_count++;
+       } else {
+               /* Notice that this has had a POSIX lock request.
+                * We can't count locks after this so forget them.
+                */
+               fsp->current_lock_count = NO_LOCKING_COUNT;
+       }
+}
+
+static void decrement_current_lock_count(files_struct *fsp,
+    enum brl_flavour lock_flav)
+{
+       if (lock_flav == WINDOWS_LOCK &&
+           fsp->current_lock_count != NO_LOCKING_COUNT) {
+               SMB_ASSERT(fsp->current_lock_count > 0);
+               fsp->current_lock_count--;
+       }
 }
 
 /****************************************************************************
  Utility function called by locking requests.
 ****************************************************************************/
 
-struct byte_range_lock *do_lock(files_struct *fsp,
-                       uint32 lock_pid,
-                       SMB_BIG_UINT count,
-                       SMB_BIG_UINT offset,
+struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
+                       files_struct *fsp,
+                       uint64_t smblctx,
+                       uint64_t count,
+                       uint64_t offset,
                        enum brl_type lock_type,
                        enum brl_flavour lock_flav,
-                       BOOL blocking_lock,
-                       NTSTATUS *perr)
+                       bool blocking_lock,
+                       NTSTATUS *perr,
+                       uint64_t *psmblctx,
+                       struct blocking_lock_record *blr)
 {
        struct byte_range_lock *br_lck = NULL;
 
+       /* silently return ok on print files as we don't do locking there */
+       if (fsp->print_file) {
+               *perr = NT_STATUS_OK;
+               return NULL;
+       }
+
        if (!fsp->can_lock) {
                *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
                return NULL;
@@ -203,25 +267,33 @@ struct byte_range_lock *do_lock(files_struct *fsp,
 
        /* NOTE! 0 byte long ranges ARE allowed and should be stored  */
 
-       DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f requested for fnum %d file %s\n",
+       DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f "
+               "blocking_lock=%s requested for fnum %d file %s\n",
                lock_flav_name(lock_flav), lock_type_name(lock_type),
-               (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
+               (double)offset, (double)count, blocking_lock ? "true" :
+               "false", fsp->fnum, fsp_str_dbg(fsp)));
 
-       br_lck = brl_get_locks(NULL, fsp);
+       br_lck = brl_get_locks(talloc_tos(), fsp);
        if (!br_lck) {
                *perr = NT_STATUS_NO_MEMORY;
                return NULL;
        }
 
-       *perr = brl_lock(br_lck,
-                       lock_pid,
-                       procid_self(),
+       *perr = brl_lock(msg_ctx,
+                       br_lck,
+                       smblctx,
+                       sconn_server_id(fsp->conn->sconn),
                        offset,
-                       count, 
+                       count,
                        lock_type,
                        lock_flav,
-                       blocking_lock);
+                       blocking_lock,
+                       psmblctx,
+                       blr);
+
+       DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
 
+       increment_current_lock_count(fsp, lock_flav);
        return br_lck;
 }
 
@@ -229,38 +301,41 @@ struct byte_range_lock *do_lock(files_struct *fsp,
  Utility function called by unlocking requests.
 ****************************************************************************/
 
-NTSTATUS do_unlock(files_struct *fsp,
-                       uint32 lock_pid,
-                       SMB_BIG_UINT count,
-                       SMB_BIG_UINT offset,
+NTSTATUS do_unlock(struct messaging_context *msg_ctx,
+                       files_struct *fsp,
+                       uint64_t smblctx,
+                       uint64_t count,
+                       uint64_t offset,
                        enum brl_flavour lock_flav)
 {
-       BOOL ok = False;
+       bool ok = False;
        struct byte_range_lock *br_lck = NULL;
-       
+
        if (!fsp->can_lock) {
                return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
        }
-       
+
        if (!lp_locking(fsp->conn->params)) {
                return NT_STATUS_OK;
        }
-       
+
        DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for fnum %d file %s\n",
-                 (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
+                 (double)offset, (double)count, fsp->fnum,
+                 fsp_str_dbg(fsp)));
 
-       br_lck = brl_get_locks(NULL, fsp);
+       br_lck = brl_get_locks(talloc_tos(), fsp);
        if (!br_lck) {
                return NT_STATUS_NO_MEMORY;
        }
 
-       ok = brl_unlock(br_lck,
-                       lock_pid,
-                       procid_self(),
+       ok = brl_unlock(msg_ctx,
+                       br_lck,
+                       smblctx,
+                       sconn_server_id(fsp->conn->sconn),
                        offset,
                        count,
                        lock_flav);
-   
+
        TALLOC_FREE(br_lck);
 
        if (!ok) {
@@ -268,6 +343,7 @@ NTSTATUS do_unlock(files_struct *fsp,
                return NT_STATUS_RANGE_NOT_LOCKED;
        }
 
+       decrement_current_lock_count(fsp, lock_flav);
        return NT_STATUS_OK;
 }
 
@@ -276,38 +352,41 @@ NTSTATUS do_unlock(files_struct *fsp,
 ****************************************************************************/
 
 NTSTATUS do_lock_cancel(files_struct *fsp,
-                       uint32 lock_pid,
-                       SMB_BIG_UINT count,
-                       SMB_BIG_UINT offset,
-                       enum brl_flavour lock_flav)
+                       uint64 smblctx,
+                       uint64_t count,
+                       uint64_t offset,
+                       enum brl_flavour lock_flav,
+                       struct blocking_lock_record *blr)
 {
-       BOOL ok = False;
+       bool ok = False;
        struct byte_range_lock *br_lck = NULL;
-       
+
        if (!fsp->can_lock) {
                return fsp->is_directory ?
                        NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
        }
-       
+
        if (!lp_locking(fsp->conn->params)) {
                return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
        }
 
        DEBUG(10,("do_lock_cancel: cancel start=%.0f len=%.0f requested for fnum %d file %s\n",
-                 (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
+                 (double)offset, (double)count, fsp->fnum,
+                 fsp_str_dbg(fsp)));
 
-       br_lck = brl_get_locks(NULL, fsp);
+       br_lck = brl_get_locks(talloc_tos(), fsp);
        if (!br_lck) {
                return NT_STATUS_NO_MEMORY;
        }
 
        ok = brl_lock_cancel(br_lck,
-                       lock_pid,
-                       procid_self(),
+                       smblctx,
+                       sconn_server_id(fsp->conn->sconn),
                        offset,
                        count,
-                       lock_flav);
-   
+                       lock_flav,
+                       blr);
+
        TALLOC_FREE(br_lck);
 
        if (!ok) {
@@ -315,6 +394,7 @@ NTSTATUS do_lock_cancel(files_struct *fsp,
                return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
        }
 
+       decrement_current_lock_count(fsp, lock_flav);
        return NT_STATUS_OK;
 }
 
@@ -322,7 +402,9 @@ NTSTATUS do_lock_cancel(files_struct *fsp,
  Remove any locks on this fd. Called from file_close().
 ****************************************************************************/
 
-void locking_close_file(files_struct *fsp)
+void locking_close_file(struct messaging_context *msg_ctx,
+                       files_struct *fsp,
+                       enum file_close_type close_type)
 {
        struct byte_range_lock *br_lck;
 
@@ -330,11 +412,19 @@ void locking_close_file(files_struct *fsp)
                return;
        }
 
-       br_lck = brl_get_locks(NULL,fsp);
+       /* If we have not outstanding locks or pending
+        * locks then we don't need to look in the lock db.
+        */
+
+       if (fsp->current_lock_count == 0) {
+               return;
+       }
+
+       br_lck = brl_get_locks(talloc_tos(),fsp);
 
        if (br_lck) {
-               cancel_pending_lock_requests_by_fid(fsp, br_lck);
-               brl_close_fnum(br_lck);
+               cancel_pending_lock_requests_by_fid(fsp, br_lck, close_type);
+               brl_close_fnum(msg_ctx, br_lck);
                TALLOC_FREE(br_lck);
        }
 }
@@ -343,22 +433,19 @@ void locking_close_file(files_struct *fsp)
  Initialise the locking functions.
 ****************************************************************************/
 
-static int open_read_only;
-
-BOOL locking_init(int read_only)
+static bool locking_init_internal(bool read_only)
 {
        brl_init(read_only);
 
-       if (tdb)
+       if (lock_db)
                return True;
 
-       tdb = tdb_open_log(lock_path("locking.tdb"), 
-                       lp_open_files_db_hash_size(),
-                       TDB_DEFAULT|(read_only?0x0:TDB_CLEAR_IF_FIRST), 
-                       read_only?O_RDONLY:O_RDWR|O_CREAT,
-                       0644);
+       lock_db = db_open(NULL, lock_path("locking.tdb"),
+                         lp_open_files_db_hash_size(),
+                         TDB_DEFAULT|TDB_VOLATILE|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
+                         read_only?O_RDONLY:O_RDWR|O_CREAT, 0644);
 
-       if (!tdb) {
+       if (!lock_db) {
                DEBUG(0,("ERROR: Failed to initialise locking database\n"));
                return False;
        }
@@ -366,76 +453,59 @@ BOOL locking_init(int read_only)
        if (!posix_locking_init(read_only))
                return False;
 
-       open_read_only = read_only;
-
        return True;
 }
 
-/*******************************************************************
- Deinitialize the share_mode management.
-******************************************************************/
-
-BOOL locking_end(void)
+bool locking_init(void)
 {
-       BOOL ret = True;
-
-       brl_shutdown(open_read_only);
-       if (tdb) {
-               if (tdb_close(tdb) != 0)
-                       ret = False;
-       }
+       return locking_init_internal(false);
+}
 
-       return ret;
+bool locking_init_readonly(void)
+{
+       return locking_init_internal(true);
 }
 
 /*******************************************************************
Form a static locking key for a dev/inode pair.
Deinitialize the share_mode management.
 ******************************************************************/
 
-/* key and data records in the tdb locking database */
-struct locking_key {
-       SMB_DEV_T dev;
-       SMB_INO_T ino;
-};
+bool locking_end(void)
+{
+       brl_shutdown();
+       TALLOC_FREE(lock_db);
+       return true;
+}
 
 /*******************************************************************
  Form a static locking key for a dev/inode pair.
 ******************************************************************/
 
-static TDB_DATA locking_key(SMB_DEV_T dev, SMB_INO_T inode)
+static TDB_DATA locking_key(const struct file_id *id, struct file_id *tmp)
 {
-       static struct locking_key key;
-       TDB_DATA kbuf;
-
-       memset(&key, '\0', sizeof(key));
-       key.dev = dev;
-       key.ino = inode;
-       kbuf.dptr = (char *)&key;
-       kbuf.dsize = sizeof(key);
-       return kbuf;
+       *tmp = *id;
+       return make_tdb_data((const uint8_t *)tmp, sizeof(*tmp));
 }
 
 /*******************************************************************
  Print out a share mode.
 ********************************************************************/
 
-char *share_mode_str(int num, struct share_mode_entry *e)
+char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
 {
-       static pstring share_str;
-
-       slprintf(share_str, sizeof(share_str)-1, "share_mode_entry[%d]: %s "
+       return talloc_asprintf(ctx, "share_mode_entry[%d]: %s "
                 "pid = %s, share_access = 0x%x, private_options = 0x%x, "
-                "access_mask = 0x%x, mid = 0x%x, type= 0x%x, file_id = %lu, "
-                "uid = %u, flags = %u, dev = 0x%x, inode = %.0f",
+                "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %lu, "
+                "uid = %u, flags = %u, file_id %s, name_hash = 0x%x",
                 num,
                 e->op_type == UNUSED_SHARE_MODE_ENTRY ? "UNUSED" : "",
                 procid_str_static(&e->pid),
                 e->share_access, e->private_options,
-                e->access_mask, e->op_mid, e->op_type, e->share_file_id,
+                e->access_mask, (unsigned long long)e->op_mid,
+                e->op_type, e->share_file_id,
                 (unsigned int)e->uid, (unsigned int)e->flags,
-                (unsigned int)e->dev, (double)e->inode );
-
-       return share_str;
+                file_id_string_tos(&e->id),
+                (unsigned int)e->name_hash);
 }
 
 /*******************************************************************
@@ -451,126 +521,198 @@ static void print_share_mode_table(struct locking_data *data)
 
        for (i = 0; i < num_share_modes; i++) {
                struct share_mode_entry entry;
+               char *str;
+
+               /*
+                * We need to memcpy the entry here due to alignment
+                * restrictions that are not met when directly accessing
+                * shares[i]
+                */
 
                memcpy(&entry, &shares[i], sizeof(struct share_mode_entry));
-               DEBUG(10,("print_share_mode_table: %s\n",
-                         share_mode_str(i, &entry)));
+               str = share_mode_str(talloc_tos(), i, &entry);
+
+               DEBUG(10,("print_share_mode_table: %s\n", str ? str : ""));
+               TALLOC_FREE(str);
        }
 }
 
+static int parse_delete_tokens_list(struct share_mode_lock *lck,
+               struct locking_data *pdata,
+               const TDB_DATA dbuf)
+{
+       uint8_t *p = dbuf.dptr + sizeof(struct locking_data) +
+                       (lck->num_share_modes *
+                       sizeof(struct share_mode_entry));
+       uint8_t *end_ptr = dbuf.dptr + (dbuf.dsize - 2);
+       int delete_tokens_size = 0;
+       int i;
+
+       lck->delete_tokens = NULL;
+
+       for (i = 0; i < pdata->u.s.num_delete_token_entries; i++) {
+               uint32_t token_len;
+               struct delete_token_list *pdtl;
+
+               if (end_ptr - p < (sizeof(uint32_t) + sizeof(uint32_t) +
+                                       sizeof(uid_t) + sizeof(gid_t))) {
+                       DEBUG(0,("parse_delete_tokens_list: "
+                               "corrupt token list (%u)",
+                               (unsigned int)(end_ptr - p)));
+                       smb_panic("corrupt token list");
+                       return -1;
+               }
+
+               memcpy(&token_len, p, sizeof(token_len));
+               delete_tokens_size += token_len;
+
+               if (p + token_len > end_ptr || token_len < sizeof(token_len) +
+                                               sizeof(pdtl->name_hash) +
+                                               sizeof(uid_t) +
+                                               sizeof(gid_t)) {
+                       DEBUG(0,("parse_delete_tokens_list: "
+                               "invalid token length (%u)\n",
+                               (unsigned int)token_len ));
+                       smb_panic("invalid token length");
+                       return -1;
+               }
+
+               p += sizeof(token_len);
+
+               pdtl = TALLOC_ZERO_P(lck, struct delete_token_list);
+               if (pdtl == NULL) {
+                       DEBUG(0,("parse_delete_tokens_list: talloc failed"));
+                       return -1;
+               }
+               /* Copy out the name_hash. */
+               memcpy(&pdtl->name_hash, p, sizeof(pdtl->name_hash));
+               p += sizeof(pdtl->name_hash);
+
+               pdtl->delete_token = TALLOC_ZERO_P(pdtl, struct security_unix_token);
+               if (pdtl->delete_token == NULL) {
+                       DEBUG(0,("parse_delete_tokens_list: talloc failed"));
+                       return -1;
+               }
+
+               /* Copy out the uid and gid. */
+               memcpy(&pdtl->delete_token->uid, p, sizeof(uid_t));
+               p += sizeof(uid_t);
+               memcpy(&pdtl->delete_token->gid, p, sizeof(gid_t));
+               p += sizeof(gid_t);
+
+               token_len -= (sizeof(token_len) + sizeof(pdtl->name_hash) +
+                               sizeof(uid_t) + sizeof(gid_t));
+
+               /* Any supplementary groups ? */
+               if (token_len) {
+                       int j;
+
+                       if (token_len % sizeof(gid_t) != 0) {
+                               DEBUG(0,("parse_delete_tokens_list: "
+                                       "corrupt group list (%u)",
+                                       (unsigned int)(token_len % sizeof(gid_t)) ));
+                               smb_panic("corrupt group list");
+                               return -1;
+                       }
+
+                       pdtl->delete_token->ngroups = token_len / sizeof(gid_t);
+                       pdtl->delete_token->groups = talloc_array(pdtl->delete_token, gid_t,
+                                               pdtl->delete_token->ngroups);
+                       if (pdtl->delete_token->groups == NULL) {
+                               DEBUG(0,("parse_delete_tokens_list: talloc failed"));
+                               return -1;
+                       }
+
+                       for (j = 0; j < pdtl->delete_token->ngroups; j++) {
+                               memcpy(&pdtl->delete_token->groups[j], p, sizeof(gid_t));
+                               p += sizeof(gid_t);
+                       }
+               }
+               /* Add to the list. */
+               DLIST_ADD(lck->delete_tokens, pdtl);
+       }
+
+       return delete_tokens_size;
+}
+
 /*******************************************************************
  Get all share mode entries for a dev/inode pair.
 ********************************************************************/
 
-static BOOL parse_share_modes(TDB_DATA dbuf, struct share_mode_lock *lck)
+static bool parse_share_modes(const TDB_DATA dbuf, struct share_mode_lock *lck)
 {
-       struct locking_data *data;
+       struct locking_data data;
+       int delete_tokens_size;
        int i;
 
        if (dbuf.dsize < sizeof(struct locking_data)) {
-               smb_panic("PANIC: parse_share_modes: buffer too short.\n");
+               smb_panic("parse_share_modes: buffer too short");
        }
 
-       data = (struct locking_data *)dbuf.dptr;
+       memcpy(&data, dbuf.dptr, sizeof(data));
 
-       lck->delete_on_close = data->u.s.delete_on_close;
-       lck->num_share_modes = data->u.s.num_share_mode_entries;
+       lck->old_write_time = data.u.s.old_write_time;
+       lck->changed_write_time = data.u.s.changed_write_time;
+       lck->num_share_modes = data.u.s.num_share_mode_entries;
 
-       DEBUG(10, ("parse_share_modes: delete_on_close: %d, "
-                  "num_share_modes: %d\n",
-               lck->delete_on_close,
-               lck->num_share_modes));
+       DEBUG(10, ("parse_share_modes: owrt: %s, "
+                  "cwrt: %s, ntok: %u, num_share_modes: %d\n",
+                  timestring(talloc_tos(),
+                             convert_timespec_to_time_t(lck->old_write_time)),
+                  timestring(talloc_tos(),
+                             convert_timespec_to_time_t(
+                                     lck->changed_write_time)),
+                  (unsigned int)data.u.s.num_delete_token_entries,
+                  lck->num_share_modes));
 
        if ((lck->num_share_modes < 0) || (lck->num_share_modes > 1000000)) {
                DEBUG(0, ("invalid number of share modes: %d\n",
                          lck->num_share_modes));
-               smb_panic("PANIC: invalid number of share modes");
+               smb_panic("parse_share_modes: invalid number of share modes");
        }
 
        lck->share_modes = NULL;
-       
+
        if (lck->num_share_modes != 0) {
 
                if (dbuf.dsize < (sizeof(struct locking_data) +
                                  (lck->num_share_modes *
                                   sizeof(struct share_mode_entry)))) {
-                       smb_panic("PANIC: parse_share_modes: buffer too short.\n");
+                       smb_panic("parse_share_modes: buffer too short");
                }
-                                 
+
                lck->share_modes = (struct share_mode_entry *)
-                       talloc_memdup(lck, dbuf.dptr+sizeof(*data),
+                       TALLOC_MEMDUP(lck,
+                                     dbuf.dptr+sizeof(struct locking_data),
                                      lck->num_share_modes *
                                      sizeof(struct share_mode_entry));
 
                if (lck->share_modes == NULL) {
-                       smb_panic("talloc failed\n");
+                       smb_panic("parse_share_modes: talloc failed");
                }
        }
 
-       /* Get any delete token. */
-       if (data->u.s.delete_token_size) {
-               char *p = dbuf.dptr + sizeof(*data) +
-                               (lck->num_share_modes *
-                               sizeof(struct share_mode_entry));
-
-               if ((data->u.s.delete_token_size < sizeof(uid_t) + sizeof(gid_t)) ||
-                               ((data->u.s.delete_token_size - sizeof(uid_t)) % sizeof(gid_t)) != 0) {
-                       DEBUG(0, ("parse_share_modes: invalid token size %d\n",
-                               data->u.s.delete_token_size));
-                       smb_panic("parse_share_modes: invalid token size\n");
-               }
-
-               lck->delete_token = TALLOC_P(lck, UNIX_USER_TOKEN);
-               if (!lck->delete_token) {
-                       smb_panic("talloc failed\n");
-               }
-
-               /* Copy out the uid and gid. */
-               memcpy(&lck->delete_token->uid, p, sizeof(uid_t));
-               p += sizeof(uid_t);
-               memcpy(&lck->delete_token->gid, p, sizeof(gid_t));
-               p += sizeof(gid_t);
-
-               /* Any supplementary groups ? */
-               lck->delete_token->ngroups = (data->u.s.delete_token_size > (sizeof(uid_t) + sizeof(gid_t))) ?
-                                       ((data->u.s.delete_token_size -
-                                               (sizeof(uid_t) + sizeof(gid_t)))/sizeof(gid_t)) : 0;
-
-               if (lck->delete_token->ngroups) {
-                       /* Make this a talloc child of lck->delete_token. */
-                       lck->delete_token->groups = TALLOC_ARRAY(lck->delete_token, gid_t,
-                                                       lck->delete_token->ngroups);
-                       if (!lck->delete_token) {
-                               smb_panic("talloc failed\n");
-                       }
-
-                       for (i = 0; i < lck->delete_token->ngroups; i++) {
-                               memcpy(&lck->delete_token->groups[i], p, sizeof(gid_t));
-                               p += sizeof(gid_t);
-                       }
-               }
-
-       } else {
-               lck->delete_token = NULL;
+       /* Get any delete tokens. */
+       delete_tokens_size = parse_delete_tokens_list(lck, &data, dbuf);
+       if (delete_tokens_size < 0) {
+               smb_panic("parse_share_modes: parse_delete_tokens_list failed");
        }
 
        /* Save off the associated service path and filename. */
-       lck->servicepath = talloc_strdup(lck, dbuf.dptr + sizeof(*data) +
-                                       (lck->num_share_modes *
-                                       sizeof(struct share_mode_entry)) +
-                                       data->u.s.delete_token_size );
-       if (lck->servicepath == NULL) {
-               smb_panic("talloc_strdup failed\n");
-       }
+       lck->servicepath = (const char *)dbuf.dptr + sizeof(struct locking_data) +
+               (lck->num_share_modes * sizeof(struct share_mode_entry)) +
+               delete_tokens_size;
 
-       lck->filename = talloc_strdup(lck, dbuf.dptr + sizeof(*data) +
-                                       (lck->num_share_modes *
-                                       sizeof(struct share_mode_entry)) +
-                                       data->u.s.delete_token_size +
-                                       strlen(lck->servicepath) + 1 );
-       if (lck->filename == NULL) {
-               smb_panic("talloc_strdup failed\n");
-       }
+       lck->base_name = (const char *)dbuf.dptr + sizeof(struct locking_data) +
+               (lck->num_share_modes * sizeof(struct share_mode_entry)) +
+               delete_tokens_size +
+               strlen(lck->servicepath) + 1;
+
+       lck->stream_name = (const char *)dbuf.dptr + sizeof(struct locking_data) +
+               (lck->num_share_modes * sizeof(struct share_mode_entry)) +
+               delete_tokens_size +
+               strlen(lck->servicepath) + 1 +
+               strlen(lck->base_name) + 1;
 
        /*
         * Ensure that each entry has a real process attached.
@@ -578,28 +720,35 @@ static BOOL parse_share_modes(TDB_DATA dbuf, struct share_mode_lock *lck)
 
        for (i = 0; i < lck->num_share_modes; i++) {
                struct share_mode_entry *entry_p = &lck->share_modes[i];
+               char *str = NULL;
+               if (DEBUGLEVEL >= 10) {
+                       str = share_mode_str(NULL, i, entry_p);
+               }
                DEBUG(10,("parse_share_modes: %s\n",
-                         share_mode_str(i, entry_p) ));
-               if (!process_exists(entry_p->pid)) {
+                       str ? str : ""));
+               if (!serverid_exists(&entry_p->pid)) {
                        DEBUG(10,("parse_share_modes: deleted %s\n",
-                                 share_mode_str(i, entry_p) ));
+                               str ? str : ""));
                        entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
                        lck->modified = True;
                }
+               TALLOC_FREE(str);
        }
 
        return True;
 }
 
-static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
+static TDB_DATA unparse_share_modes(const struct share_mode_lock *lck)
 {
        TDB_DATA result;
        int num_valid = 0;
        int i;
        struct locking_data *data;
        ssize_t offset;
-       ssize_t sp_len;
-       uint32 delete_token_size;
+       ssize_t sp_len, bn_len, sn_len;
+       uint32_t delete_tokens_size = 0;
+       struct delete_token_list *pdtl = NULL;
+       uint32_t num_delete_token_entries = 0;
 
        result.dptr = NULL;
        result.dsize = 0;
@@ -615,56 +764,92 @@ static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
        }
 
        sp_len = strlen(lck->servicepath);
-       delete_token_size = (lck->delete_token ?
-                       (sizeof(uid_t) + sizeof(gid_t) + (lck->delete_token->ngroups*sizeof(gid_t))) : 0);
+       bn_len = strlen(lck->base_name);
+       sn_len = lck->stream_name != NULL ? strlen(lck->stream_name) : 0;
+
+       for (pdtl = lck->delete_tokens; pdtl; pdtl = pdtl->next) {
+               num_delete_token_entries++;
+               delete_tokens_size += (sizeof(uint32_t) +
+                               sizeof(uint32_t) +
+                               sizeof(uid_t) +
+                               sizeof(gid_t) +
+                               pdtl->delete_token->ngroups*sizeof(gid_t));
+       }
 
        result.dsize = sizeof(*data) +
                lck->num_share_modes * sizeof(struct share_mode_entry) +
-               delete_token_size +
+               delete_tokens_size +
                sp_len + 1 +
-               strlen(lck->filename) + 1;
-       result.dptr = TALLOC_ARRAY(lck, char, result.dsize);
+               bn_len + 1 +
+               sn_len + 1;
+       result.dptr = talloc_array(lck, uint8, result.dsize);
 
        if (result.dptr == NULL) {
-               smb_panic("talloc failed\n");
+               smb_panic("talloc failed");
        }
 
        data = (struct locking_data *)result.dptr;
        ZERO_STRUCTP(data);
        data->u.s.num_share_mode_entries = lck->num_share_modes;
-       data->u.s.delete_on_close = lck->delete_on_close;
-       data->u.s.delete_token_size = delete_token_size;
-       DEBUG(10, ("unparse_share_modes: del: %d, tok = %u, num: %d\n",
-               data->u.s.delete_on_close,
-               (unsigned int)data->u.s.delete_token_size,
-               data->u.s.num_share_mode_entries));
+       data->u.s.old_write_time = lck->old_write_time;
+       data->u.s.changed_write_time = lck->changed_write_time;
+       data->u.s.num_delete_token_entries = num_delete_token_entries;
+
+       DEBUG(10,("unparse_share_modes: owrt: %s cwrt: %s, ntok: %u, "
+                 "num: %d\n",
+                 timestring(talloc_tos(),
+                            convert_timespec_to_time_t(lck->old_write_time)),
+                 timestring(talloc_tos(),
+                            convert_timespec_to_time_t(
+                                    lck->changed_write_time)),
+                 (unsigned int)data->u.s.num_delete_token_entries,
+                 data->u.s.num_share_mode_entries));
+
        memcpy(result.dptr + sizeof(*data), lck->share_modes,
               sizeof(struct share_mode_entry)*lck->num_share_modes);
        offset = sizeof(*data) +
                sizeof(struct share_mode_entry)*lck->num_share_modes;
 
-       /* Store any delete on close token. */
-       if (lck->delete_token) {
-               char *p = result.dptr + offset;
+       /* Store any delete on close tokens. */
+       for (pdtl = lck->delete_tokens; pdtl; pdtl = pdtl->next) {
+               struct security_unix_token *pdt = pdtl->delete_token;
+               uint32_t token_size = sizeof(uint32_t) +
+                                       sizeof(uint32_t) +
+                                       sizeof(uid_t) +
+                                       sizeof(gid_t) +
+                                       (pdt->ngroups * sizeof(gid_t));
+               uint8_t *p = result.dptr + offset;
+
+               memcpy(p, &token_size, sizeof(uint32_t));
+               p += sizeof(uint32_t);
+
+               memcpy(p, &pdtl->name_hash, sizeof(uint32_t));
+               p += sizeof(uint32_t);
 
-               memcpy(p, &lck->delete_token->uid, sizeof(uid_t));
+               memcpy(p, &pdt->uid, sizeof(uid_t));
                p += sizeof(uid_t);
 
-               memcpy(p, &lck->delete_token->gid, sizeof(gid_t));
+               memcpy(p, &pdt->gid, sizeof(gid_t));
                p += sizeof(gid_t);
 
-               for (i = 0; i < lck->delete_token->ngroups; i++) {
-                       memcpy(p, &lck->delete_token->groups[i], sizeof(gid_t));
+               for (i = 0; i < pdt->ngroups; i++) {
+                       memcpy(p, &pdt->groups[i], sizeof(gid_t));
                        p += sizeof(gid_t);
                }
-               offset = p - result.dptr;
+               offset += token_size;
        }
 
-       safe_strcpy(result.dptr + offset, lck->servicepath,
-                   result.dsize - offset - 1);
+       strlcpy((char *)result.dptr + offset,
+               lck->servicepath ? lck->servicepath : "",
+               result.dsize - offset);
        offset += sp_len + 1;
-       safe_strcpy(result.dptr + offset, lck->filename,
-                   result.dsize - offset - 1);
+       strlcpy((char *)result.dptr + offset,
+               lck->base_name ? lck->base_name : "",
+               result.dsize - offset);
+       offset += bn_len + 1;
+       strlcpy((char *)result.dptr + offset,
+               lck->stream_name ? lck->stream_name : "",
+               result.dsize - offset);
 
        if (DEBUGLEVEL >= 10) {
                print_share_mode_table(data);
@@ -675,11 +860,11 @@ static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
 
 static int share_mode_lock_destructor(struct share_mode_lock *lck)
 {
-       TDB_DATA key = locking_key(lck->dev, lck->ino);
+       NTSTATUS status;
        TDB_DATA data;
 
        if (!lck->modified) {
-               goto done;
+               return 0;
        }
 
        data = unparse_share_modes(lck);
@@ -687,90 +872,155 @@ static int share_mode_lock_destructor(struct share_mode_lock *lck)
        if (data.dptr == NULL) {
                if (!lck->fresh) {
                        /* There has been an entry before, delete it */
-                       if (tdb_delete(tdb, key) == -1) {
-                               smb_panic("Could not delete share entry\n");
+
+                       status = lck->record->delete_rec(lck->record);
+                       if (!NT_STATUS_IS_OK(status)) {
+                               char *errmsg;
+
+                               DEBUG(0, ("delete_rec returned %s\n",
+                                         nt_errstr(status)));
+
+                               if (asprintf(&errmsg, "could not delete share "
+                                            "entry: %s\n",
+                                            nt_errstr(status)) == -1) {
+                                       smb_panic("could not delete share"
+                                                 "entry");
+                               }
+                               smb_panic(errmsg);
                        }
                }
                goto done;
        }
 
-       if (tdb_store(tdb, key, data, TDB_REPLACE) == -1) {
-               smb_panic("Could not store share mode entry\n");
+       status = lck->record->store(lck->record, data, TDB_REPLACE);
+       if (!NT_STATUS_IS_OK(status)) {
+               char *errmsg;
+
+               DEBUG(0, ("store returned %s\n", nt_errstr(status)));
+
+               if (asprintf(&errmsg, "could not store share mode entry: %s",
+                            nt_errstr(status)) == -1) {
+                       smb_panic("could not store share mode entry");
+               }
+               smb_panic(errmsg);
        }
 
  done:
-       tdb_chainunlock(tdb, key);
 
        return 0;
 }
 
-struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
-                                               SMB_DEV_T dev, SMB_INO_T ino,
-                                               const char *servicepath,
-                                               const char *fname)
+static bool fill_share_mode_lock(struct share_mode_lock *lck,
+                                struct file_id id,
+                                const char *servicepath,
+                                const struct smb_filename *smb_fname,
+                                TDB_DATA share_mode_data,
+                                const struct timespec *old_write_time)
 {
-       struct share_mode_lock *lck;
-       TDB_DATA key = locking_key(dev, ino);
-       TDB_DATA data;
-
-       lck = TALLOC_P(mem_ctx, struct share_mode_lock);
-       if (lck == NULL) {
-               DEBUG(0, ("talloc failed\n"));
-               return NULL;
-       }
-
        /* Ensure we set every field here as the destructor must be
           valid even if parse_share_modes fails. */
 
        lck->servicepath = NULL;
-       lck->filename = NULL;
-       lck->dev = dev;
-       lck->ino = ino;
+       lck->base_name = NULL;
+       lck->stream_name = NULL;
+       lck->id = id;
        lck->num_share_modes = 0;
        lck->share_modes = NULL;
-       lck->delete_token = NULL;
-       lck->delete_on_close = False;
+       lck->delete_tokens = NULL;
+       ZERO_STRUCT(lck->old_write_time);
+       ZERO_STRUCT(lck->changed_write_time);
        lck->fresh = False;
        lck->modified = False;
 
-       if (tdb_chainlock(tdb, key) != 0) {
+       lck->fresh = (share_mode_data.dptr == NULL);
+
+       if (lck->fresh) {
+               bool has_stream;
+               if (smb_fname == NULL || servicepath == NULL
+                   || old_write_time == NULL) {
+                       return False;
+               }
+
+               has_stream = smb_fname->stream_name != NULL;
+
+               lck->base_name = talloc_strdup(lck, smb_fname->base_name);
+               lck->stream_name = talloc_strdup(lck, smb_fname->stream_name);
+               lck->servicepath = talloc_strdup(lck, servicepath);
+               if (lck->base_name == NULL ||
+                   (has_stream && lck->stream_name == NULL) ||
+                   lck->servicepath == NULL) {
+                       DEBUG(0, ("talloc failed\n"));
+                       return False;
+               }
+               lck->old_write_time = *old_write_time;
+       } else {
+               if (!parse_share_modes(share_mode_data, lck)) {
+                       DEBUG(0, ("Could not parse share modes\n"));
+                       return False;
+               }
+       }
+
+       return True;
+}
+
+struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
+                                           const struct file_id id,
+                                           const char *servicepath,
+                                           const struct smb_filename *smb_fname,
+                                           const struct timespec *old_write_time)
+{
+       struct share_mode_lock *lck;
+       struct file_id tmp;
+       TDB_DATA key = locking_key(&id, &tmp);
+
+       if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
+               DEBUG(0, ("talloc failed\n"));
+               return NULL;
+       }
+
+       if (!(lck->record = lock_db->fetch_locked(lock_db, lck, key))) {
                DEBUG(3, ("Could not lock share entry\n"));
                TALLOC_FREE(lck);
                return NULL;
        }
 
-       /* We must set the destructor immediately after the chainlock
-          ensure the lock is cleaned up on any of the error return
-          paths below. */
+       if (!fill_share_mode_lock(lck, id, servicepath, smb_fname,
+                                 lck->record->value, old_write_time)) {
+               DEBUG(3, ("fill_share_mode_lock failed\n"));
+               TALLOC_FREE(lck);
+               return NULL;
+       }
 
        talloc_set_destructor(lck, share_mode_lock_destructor);
 
-       data = tdb_fetch(tdb, key);
-       lck->fresh = (data.dptr == NULL);
+       return lck;
+}
 
-       if (lck->fresh) {
+struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
+                                                 const struct file_id id)
+{
+       struct share_mode_lock *lck;
+       struct file_id tmp;
+       TDB_DATA key = locking_key(&id, &tmp);
+       TDB_DATA data;
 
-               if (fname == NULL || servicepath == NULL) {
-                       TALLOC_FREE(lck);
-                       return NULL;
-               }
-               lck->filename = talloc_strdup(lck, fname);
-               lck->servicepath = talloc_strdup(lck, servicepath);
-               if (lck->filename == NULL || lck->servicepath == NULL) {
-                       DEBUG(0, ("talloc failed\n"));
-                       TALLOC_FREE(lck);
-                       return NULL;
-               }
-       } else {
-               if (!parse_share_modes(data, lck)) {
-                       DEBUG(0, ("Could not parse share modes\n"));
-                       TALLOC_FREE(lck);
-                       SAFE_FREE(data.dptr);
-                       return NULL;
-               }
+       if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
+               DEBUG(0, ("talloc failed\n"));
+               return NULL;
+       }
+
+       if (lock_db->fetch(lock_db, lck, key, &data) == -1) {
+               DEBUG(3, ("Could not fetch share entry\n"));
+               TALLOC_FREE(lck);
+               return NULL;
        }
 
-       SAFE_FREE(data.dptr);
+       if (!fill_share_mode_lock(lck, id, NULL, NULL, data, NULL)) {
+               DEBUG(10, ("fetch_share_mode_unlocked: no share_mode record "
+                          "around (file not open)\n"));
+               TALLOC_FREE(lck);
+               return NULL;
+       }
 
        return lck;
 }
@@ -782,57 +1032,74 @@ struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
  Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
 ********************************************************************/
 
-BOOL rename_share_filename(struct share_mode_lock *lck,
+bool rename_share_filename(struct messaging_context *msg_ctx,
+                       struct share_mode_lock *lck,
                        const char *servicepath,
-                       const char *newname)
+                       uint32_t orig_name_hash,
+                       uint32_t new_name_hash,
+                       const struct smb_filename *smb_fname_dst)
 {
        size_t sp_len;
-       size_t fn_len;
+       size_t bn_len;
+       size_t sn_len;
        size_t msg_len;
        char *frm = NULL;
        int i;
-
-       if (!lck) {
-               return False;
-       }
+       bool strip_two_chars = false;
+       bool has_stream = smb_fname_dst->stream_name != NULL;
 
        DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
-               servicepath, newname));
+                  servicepath, smb_fname_dst->base_name));
 
        /*
         * rename_internal_fsp() and rename_internals() add './' to
         * head of newname if newname does not contain a '/'.
         */
-       while (newname[0] && newname[1] && newname[0] == '.' && newname[1] == '/') {
-               newname += 2;
+       if (smb_fname_dst->base_name[0] &&
+           smb_fname_dst->base_name[1] &&
+           smb_fname_dst->base_name[0] == '.' &&
+           smb_fname_dst->base_name[1] == '/') {
+               strip_two_chars = true;
        }
 
        lck->servicepath = talloc_strdup(lck, servicepath);
-       lck->filename = talloc_strdup(lck, newname);
-       if (lck->filename == NULL || lck->servicepath == NULL) {
+       lck->base_name = talloc_strdup(lck, smb_fname_dst->base_name +
+                                      (strip_two_chars ? 2 : 0));
+       lck->stream_name = talloc_strdup(lck, smb_fname_dst->stream_name);
+       if (lck->base_name == NULL ||
+           (has_stream && lck->stream_name == NULL) ||
+           lck->servicepath == NULL) {
                DEBUG(0, ("rename_share_filename: talloc failed\n"));
                return False;
        }
        lck->modified = True;
 
        sp_len = strlen(lck->servicepath);
-       fn_len = strlen(lck->filename);
+       bn_len = strlen(lck->base_name);
+       sn_len = has_stream ? strlen(lck->stream_name) : 0;
 
-       msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + fn_len + 1;
+       msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
+           sn_len + 1;
 
        /* Set up the name changed message. */
-       frm = TALLOC_ARRAY(lck, char, msg_len);
+       frm = talloc_array(lck, char, msg_len);
        if (!frm) {
                return False;
        }
 
-       SDEV_T_VAL(frm,0,lck->dev);
-       SINO_T_VAL(frm,8,lck->ino);
+       push_file_id_24(frm, &lck->id);
 
        DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
 
-       safe_strcpy(&frm[16], lck->servicepath, sp_len);
-       safe_strcpy(&frm[16 + sp_len + 1], lck->filename, fn_len);
+       strlcpy(&frm[24],
+               lck->servicepath ? lck->servicepath : "",
+               sp_len+1);
+       strlcpy(&frm[24 + sp_len + 1],
+               lck->base_name ? lck->base_name : "",
+               bn_len+1);
+       strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
+               lck->stream_name ? lck->stream_name : "",
+               sn_len+1);
 
        /* Send the messages. */
        for (i=0; i<lck->num_share_modes; i++) {
@@ -840,40 +1107,84 @@ BOOL rename_share_filename(struct share_mode_lock *lck,
                if (!is_valid_share_mode_entry(se)) {
                        continue;
                }
+
+               /* If this is a hardlink to the inode
+                  with a different name, skip this. */
+               if (se->name_hash != orig_name_hash) {
+                       continue;
+               }
+
+               se->name_hash = new_name_hash;
+
                /* But not to ourselves... */
                if (procid_is_me(&se->pid)) {
                        continue;
                }
 
-               DEBUG(10,("rename_share_filename: sending rename message to pid %s "
-                       "dev %x, inode  %.0f sharepath %s newname %s\n",
-                       procid_str_static(&se->pid),
-                       (unsigned int)lck->dev, (double)lck->ino,
-                       lck->servicepath, lck->filename ));
+               DEBUG(10,("rename_share_filename: sending rename message to "
+                         "pid %s file_id %s sharepath %s base_name %s "
+                         "stream_name %s\n",
+                         procid_str_static(&se->pid),
+                         file_id_string_tos(&lck->id),
+                         lck->servicepath, lck->base_name,
+                       has_stream ? lck->stream_name : ""));
 
-               message_send_pid(se->pid, MSG_SMB_FILE_RENAME,
-                               frm, msg_len, True);
+               messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
+                                  (uint8 *)frm, msg_len);
        }
 
        return True;
 }
 
-BOOL get_delete_on_close_flag(SMB_DEV_T dev, SMB_INO_T inode)
+void get_file_infos(struct file_id id,
+                   uint32_t name_hash,
+                   bool *delete_on_close,
+                   struct timespec *write_time)
 {
-       BOOL result;
-       struct share_mode_lock *lck = get_share_mode_lock(NULL, dev, inode, NULL, NULL);
-       if (!lck) {
-               return False;
+       struct share_mode_lock *lck;
+
+       if (delete_on_close) {
+               *delete_on_close = false;
+       }
+
+       if (write_time) {
+               ZERO_STRUCTP(write_time);
+       }
+
+       if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
+               return;
+       }
+
+       if (delete_on_close) {
+               *delete_on_close = is_delete_on_close_set(lck, name_hash);
        }
-       result = lck->delete_on_close;
+
+       if (write_time) {
+               struct timespec wt;
+
+               wt = lck->changed_write_time;
+               if (null_timespec(wt)) {
+                       wt = lck->old_write_time;
+               }
+
+               *write_time = wt;
+       }
+
        TALLOC_FREE(lck);
-       return result;
 }
 
-BOOL is_valid_share_mode_entry(const struct share_mode_entry *e)
+bool is_valid_share_mode_entry(const struct share_mode_entry *e)
 {
        int num_props = 0;
 
+       if (e->op_type == UNUSED_SHARE_MODE_ENTRY) {
+               /* cope with dead entries from the process not
+                  existing. These should not be considered valid,
+                  otherwise we end up doing zero timeout sharing
+                  violation */
+               return False;
+       }
+
        num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
        num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
        num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
@@ -882,12 +1193,12 @@ BOOL is_valid_share_mode_entry(const struct share_mode_entry *e)
        return (num_props != 0);
 }
 
-BOOL is_deferred_open_entry(const struct share_mode_entry *e)
+bool is_deferred_open_entry(const struct share_mode_entry *e)
 {
        return (e->op_type == DEFERRED_OPEN_ENTRY);
 }
 
-BOOL is_unused_share_mode_entry(const struct share_mode_entry *e)
+bool is_unused_share_mode_entry(const struct share_mode_entry *e)
 {
        return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
 }
@@ -898,10 +1209,10 @@ BOOL is_unused_share_mode_entry(const struct share_mode_entry *e)
 
 static void fill_share_mode_entry(struct share_mode_entry *e,
                                  files_struct *fsp,
-                                 uid_t uid, uint16 mid, uint16 op_type)
+                                 uid_t uid, uint64_t mid, uint16 op_type)
 {
        ZERO_STRUCTP(e);
-       e->pid = procid_self();
+       e->pid = sconn_server_id(fsp->conn->sconn);
        e->share_access = fsp->share_access;
        e->private_options = fsp->fh->private_options;
        e->access_mask = fsp->access_mask;
@@ -909,25 +1220,26 @@ static void fill_share_mode_entry(struct share_mode_entry *e,
        e->op_type = op_type;
        e->time.tv_sec = fsp->open_time.tv_sec;
        e->time.tv_usec = fsp->open_time.tv_usec;
-       e->dev = fsp->dev;
-       e->inode = fsp->inode;
-       e->share_file_id = fsp->fh->file_id;
+       e->id = fsp->file_id;
+       e->share_file_id = fsp->fh->gen_id;
        e->uid = (uint32)uid;
        e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
+       e->name_hash = fsp->name_hash;
 }
 
 static void fill_deferred_open_entry(struct share_mode_entry *e,
                                     const struct timeval request_time,
-                                    SMB_DEV_T dev, SMB_INO_T ino, uint16 mid)
+                                    struct file_id id,
+                                    struct server_id pid,
+                                    uint64_t mid)
 {
        ZERO_STRUCTP(e);
-       e->pid = procid_self();
+       e->pid = pid;
        e->op_mid = mid;
        e->op_type = DEFERRED_OPEN_ENTRY;
        e->time.tv_sec = request_time.tv_sec;
        e->time.tv_usec = request_time.tv_usec;
-       e->dev = dev;
-       e->inode = ino;
+       e->id = id;
        e->uid = (uint32)-1;
        e->flags = 0;
 }
@@ -954,19 +1266,19 @@ static void add_share_mode_entry(struct share_mode_lock *lck,
 }
 
 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
-                       uid_t uid, uint16 mid, uint16 op_type)
+                   uid_t uid, uint64_t mid, uint16 op_type)
 {
        struct share_mode_entry entry;
        fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
        add_share_mode_entry(lck, &entry);
 }
 
-void add_deferred_open(struct share_mode_lock *lck, uint16 mid,
+void add_deferred_open(struct share_mode_lock *lck, uint64_t mid,
                       struct timeval request_time,
-                      SMB_DEV_T dev, SMB_INO_T ino)
+                      struct server_id pid, struct file_id id)
 {
        struct share_mode_entry entry;
-       fill_deferred_open_entry(&entry, request_time, dev, ino, mid);
+       fill_deferred_open_entry(&entry, request_time, id, pid, mid);
        add_share_mode_entry(lck, &entry);
 }
 
@@ -976,7 +1288,7 @@ void add_deferred_open(struct share_mode_lock *lck, uint16 mid,
  not automatically a logic error if they are identical. JRA.)
 ********************************************************************/
 
-static BOOL share_modes_identical(struct share_mode_entry *e1,
+static bool share_modes_identical(struct share_mode_entry *e1,
                                  struct share_mode_entry *e2)
 {
        /* We used to check for e1->share_access == e2->share_access here
@@ -985,18 +1297,16 @@ static BOOL share_modes_identical(struct share_mode_entry *e1,
           fsp->share_access field. */
 
        return (procid_equal(&e1->pid, &e2->pid) &&
-               e1->dev == e2->dev &&
-               e1->inode == e2->inode &&
+               file_id_equal(&e1->id, &e2->id) &&
                e1->share_file_id == e2->share_file_id );
 }
 
-static BOOL deferred_open_identical(struct share_mode_entry *e1,
+static bool deferred_open_identical(struct share_mode_entry *e1,
                                    struct share_mode_entry *e2)
 {
        return (procid_equal(&e1->pid, &e2->pid) &&
                (e1->op_mid == e2->op_mid) &&
-               (e1->dev == e2->dev) &&
-               (e1->inode == e2->inode));
+               file_id_equal(&e1->id, &e2->id));
 }
 
 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
@@ -1025,7 +1335,7 @@ static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lc
  entries left.
 ********************************************************************/
 
-BOOL del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
+bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
 {
        struct share_mode_entry entry, *e;
 
@@ -1042,12 +1352,13 @@ BOOL del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
        return True;
 }
 
-void del_deferred_open_entry(struct share_mode_lock *lck, uint16 mid)
+void del_deferred_open_entry(struct share_mode_lock *lck, uint64_t mid,
+                            struct server_id pid)
 {
        struct share_mode_entry entry, *e;
 
        fill_deferred_open_entry(&entry, timeval_zero(),
-                                lck->dev, lck->ino, mid);
+                                lck->id, pid, mid);
 
        e = find_share_mode_entry(lck, &entry);
        if (e == NULL) {
@@ -1062,7 +1373,7 @@ void del_deferred_open_entry(struct share_mode_lock *lck, uint16 mid)
  Remove an oplock mid and mode entry from a share mode.
 ********************************************************************/
 
-BOOL remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
+bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 {
        struct share_mode_entry entry, *e;
 
@@ -1074,8 +1385,19 @@ BOOL remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
                return False;
        }
 
-       e->op_mid = 0;
-       e->op_type = NO_OPLOCK;
+       if (EXCLUSIVE_OPLOCK_TYPE(e->op_type)) {
+               /*
+                * Going from exclusive or batch,
+                * we always go through FAKE_LEVEL_II
+                * first.
+                */
+               if (!EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
+                       smb_panic("remove_share_oplock: logic error");
+               }
+               e->op_type = FAKE_LEVEL_II_OPLOCK;
+       } else {
+               e->op_type = NO_OPLOCK;
+       }
        lck->modified = True;
        return True;
 }
@@ -1084,7 +1406,7 @@ BOOL remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
  Downgrade a oplock type from exclusive to level II.
 ********************************************************************/
 
-BOOL downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
+bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 {
        struct share_mode_entry entry, *e;
 
@@ -1102,27 +1424,20 @@ BOOL downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
 }
 
 /****************************************************************************
- Deal with the internal needs of setting the delete on close flag. Note that
- as the tdb locking is recursive, it is safe to call this from within 
- open_file_ntcreate. JRA.
+ Check if setting delete on close is allowed on this fsp.
 ****************************************************************************/
 
-NTSTATUS can_set_delete_on_close(files_struct *fsp, BOOL delete_on_close,
-                                uint32 dosmode)
+NTSTATUS can_set_delete_on_close(files_struct *fsp, uint32 dosmode)
 {
-       if (!delete_on_close) {
-               return NT_STATUS_OK;
-       }
-
        /*
         * Only allow delete on close for writable files.
         */
 
-       if ((dosmode & aRONLY) &&
+       if ((dosmode & FILE_ATTRIBUTE_READONLY) &&
            !lp_delete_readonly(SNUM(fsp->conn))) {
                DEBUG(10,("can_set_delete_on_close: file %s delete on close "
                          "flag set but file attribute is readonly.\n",
-                         fsp->fsp_name ));
+                         fsp_str_dbg(fsp)));
                return NT_STATUS_CANNOT_DELETE;
        }
 
@@ -1133,7 +1448,7 @@ NTSTATUS can_set_delete_on_close(files_struct *fsp, BOOL delete_on_close,
        if (!CAN_WRITE(fsp->conn)) {
                DEBUG(10,("can_set_delete_on_close: file %s delete on "
                          "close flag set but write access denied on share.\n",
-                         fsp->fsp_name ));
+                         fsp_str_dbg(fsp)));
                return NT_STATUS_ACCESS_DENIED;
        }
 
@@ -1145,67 +1460,30 @@ NTSTATUS can_set_delete_on_close(files_struct *fsp, BOOL delete_on_close,
        if (!(fsp->access_mask & DELETE_ACCESS)) {
                DEBUG(10,("can_set_delete_on_close: file %s delete on "
                          "close flag set but delete access denied.\n",
-                         fsp->fsp_name ));
+                         fsp_str_dbg(fsp)));
                return NT_STATUS_ACCESS_DENIED;
        }
 
        /* Don't allow delete on close for non-empty directories. */
        if (fsp->is_directory) {
-               long offset = 0;
-               NTSTATUS status;
-               SMB_STRUCT_STAT st;
-               struct dptr_struct *dirptr;
-               const char *name;
-
-               status = dptr_create(fsp->conn,
-                                       fsp->fsp_name,
-                                       False,
-                                       True,
-                                       0,
-                                       "*",
-                                       True,
-                                       0,
-                                       &dirptr);
-               if (!NT_STATUS_IS_OK(status)) {
-                       return status;
-               }
-
-               /* Read 3 entries. Ignore first 2 (they're . and .. ) */
-               name = dptr_ReadDirName(dirptr, &offset, &st);
-               if (!name) {
-                       dptr_CloseDir(dirptr);
-                       return NT_STATUS_ACCESS_DENIED;
-               }
-               name = dptr_ReadDirName(dirptr, &offset, &st);
-               if (!name) {
-                       dptr_CloseDir(dirptr);
-                       return NT_STATUS_ACCESS_DENIED;
-               }
-               name = dptr_ReadDirName(dirptr, &offset, &st);
-               dptr_CloseDir(dirptr);
-               if (name) {
-                       DEBUG(10,("can_set_delete_on_close: got name %s - can't delete\n", name ));
-                       return NT_STATUS_DIRECTORY_NOT_EMPTY;
-               }
+               SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
+               return can_delete_directory(fsp->conn,
+                                           fsp->fsp_name->base_name);
        }
 
        return NT_STATUS_OK;
 }
 
 /*************************************************************************
- Return a talloced copy of a UNIX_USER_TOKEN. NULL on fail.
+ Return a talloced copy of a struct security_unix_token. NULL on fail.
  (Should this be in locking.c.... ?).
 *************************************************************************/
 
-static UNIX_USER_TOKEN *copy_unix_token(TALLOC_CTX *ctx, UNIX_USER_TOKEN *tok)
+static struct security_unix_token *copy_unix_token(TALLOC_CTX *ctx, const struct security_unix_token *tok)
 {
-       UNIX_USER_TOKEN *cpy;
+       struct security_unix_token *cpy;
 
-       if (tok == NULL) {
-               return NULL;
-       }
-
-       cpy = TALLOC_P(ctx, UNIX_USER_TOKEN);
+       cpy = TALLOC_P(ctx, struct security_unix_token);
        if (!cpy) {
                return NULL;
        }
@@ -1215,30 +1493,40 @@ static UNIX_USER_TOKEN *copy_unix_token(TALLOC_CTX *ctx, UNIX_USER_TOKEN *tok)
        cpy->ngroups = tok->ngroups;
        if (tok->ngroups) {
                /* Make this a talloc child of cpy. */
-               cpy->groups = TALLOC_ARRAY(cpy, gid_t, tok->ngroups);
+               cpy->groups = (gid_t *)talloc_memdup(
+                       cpy, tok->groups, tok->ngroups * sizeof(gid_t));
                if (!cpy->groups) {
+                       TALLOC_FREE(cpy);
                        return NULL;
                }
-               memcpy(cpy->groups, tok->groups, tok->ngroups * sizeof(gid_t));
        }
        return cpy;
 }
 
 /****************************************************************************
Replace the delete on close token.
Adds a delete on close token.
 ****************************************************************************/
 
-void set_delete_on_close_token(struct share_mode_lock *lck, UNIX_USER_TOKEN *tok)
+static bool add_delete_on_close_token(struct share_mode_lock *lck,
+                       uint32_t name_hash,
+                       const struct security_unix_token *tok)
 {
-       /* Ensure there's no token. */
-       if (lck->delete_token) {
-               TALLOC_FREE(lck->delete_token); /* Also deletes groups... */
-               lck->delete_token = NULL;
+       struct delete_token_list *dtl;
+
+       dtl = TALLOC_ZERO_P(lck, struct delete_token_list);
+       if (dtl == NULL) {
+               return false;
        }
 
-       /* Copy the new token (can be NULL). */
-       lck->delete_token = copy_unix_token(lck, tok);
-       lck->modified = True;
+       dtl->name_hash = name_hash;
+       dtl->delete_token = copy_unix_token(lck, tok);
+       if (dtl->delete_token == NULL) {
+               TALLOC_FREE(dtl);
+               return false;
+       }
+       DLIST_ADD(lck->delete_tokens, dtl);
+       lck->modified = true;
+       return true;
 }
 
 /****************************************************************************
@@ -1248,50 +1536,150 @@ void set_delete_on_close_token(struct share_mode_lock *lck, UNIX_USER_TOKEN *tok
  changed the delete on close flag. This will be noticed
  in the close code, the last closer will delete the file
  if flag is set.
- This makes a copy of any UNIX_USER_TOKEN into the
+ This makes a copy of any struct security_unix_token into the
  lck entry. This function is used when the lock is already granted.
 ****************************************************************************/
 
-void set_delete_on_close_lck(struct share_mode_lock *lck, BOOL delete_on_close, UNIX_USER_TOKEN *tok)
+void set_delete_on_close_lck(files_struct *fsp,
+                       struct share_mode_lock *lck,
+                       bool delete_on_close,
+                       const struct security_unix_token *tok)
 {
-       if (lck->delete_on_close != delete_on_close) {
-               set_delete_on_close_token(lck, tok);
-               lck->delete_on_close = delete_on_close;
-               if (delete_on_close) {
-                       SMB_ASSERT(lck->delete_token != NULL);
+       struct delete_token_list *dtl;
+       bool ret;
+
+       if (delete_on_close) {
+               SMB_ASSERT(tok != NULL);
+       } else {
+               SMB_ASSERT(tok == NULL);
+       }
+
+       for (dtl = lck->delete_tokens; dtl; dtl = dtl->next) {
+               if (dtl->name_hash == fsp->name_hash) {
+                       lck->modified = true;
+                       if (delete_on_close == false) {
+                               /* Delete this entry. */
+                               DLIST_REMOVE(lck->delete_tokens, dtl);
+                               TALLOC_FREE(dtl);
+                               return;
+                       }
+                       /* Replace this token with the
+                          given tok. */
+                       TALLOC_FREE(dtl->delete_token);
+                       dtl->delete_token = copy_unix_token(dtl, tok);
+                       SMB_ASSERT(dtl->delete_token != NULL);
                }
-               lck->modified = True;
        }
+
+       if (!delete_on_close) {
+               /* Nothing to delete - not found. */
+               return;
+       }
+
+       ret = add_delete_on_close_token(lck, fsp->name_hash, tok);
+       SMB_ASSERT(ret);
 }
 
-BOOL set_delete_on_close(files_struct *fsp, BOOL delete_on_close, UNIX_USER_TOKEN *tok)
+bool set_delete_on_close(files_struct *fsp, bool delete_on_close, const struct security_unix_token *tok)
 {
        struct share_mode_lock *lck;
-       
+
        DEBUG(10,("set_delete_on_close: %s delete on close flag for "
                  "fnum = %d, file %s\n",
                  delete_on_close ? "Adding" : "Removing", fsp->fnum,
-                 fsp->fsp_name ));
+                 fsp_str_dbg(fsp)));
 
-       if (fsp->is_stat) {
-               return True;
+       lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
+                                 NULL);
+       if (lck == NULL) {
+               return False;
        }
 
-       lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode, NULL, NULL);
+       set_delete_on_close_lck(fsp, lck, delete_on_close,
+                       delete_on_close ? tok : NULL);
+
+       if (fsp->is_directory) {
+               SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
+               send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
+                                              fsp->fsp_name->base_name);
+       }
+
+       TALLOC_FREE(lck);
+
+       fsp->delete_on_close = delete_on_close;
+
+       return True;
+}
+
+const struct security_unix_token *get_delete_on_close_token(struct share_mode_lock *lck, uint32_t name_hash)
+{
+       struct delete_token_list *dtl;
+
+       DEBUG(10,("get_delete_on_close_token: name_hash = 0x%x\n",
+                       (unsigned int)name_hash ));
+
+       for (dtl = lck->delete_tokens; dtl; dtl = dtl->next) {
+               DEBUG(10,("get_delete_on_close_token: dtl->name_hash = 0x%x\n",
+                               (unsigned int)dtl->name_hash ));
+               if (dtl->name_hash == name_hash) {
+                       return dtl->delete_token;
+               }
+       }
+       return NULL;
+}
+
+bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
+{
+       return (get_delete_on_close_token(lck, name_hash) != NULL);
+}
+
+bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
+{
+       struct share_mode_lock *lck;
+
+       DEBUG(5,("set_sticky_write_time: %s id=%s\n",
+                timestring(talloc_tos(),
+                           convert_timespec_to_time_t(write_time)),
+                file_id_string_tos(&fileid)));
+
+       lck = get_share_mode_lock(NULL, fileid, NULL, NULL, NULL);
        if (lck == NULL) {
                return False;
        }
 
-       set_delete_on_close_lck(lck, delete_on_close, tok);
+       if (timespec_compare(&lck->changed_write_time, &write_time) != 0) {
+               lck->modified = True;
+               lck->changed_write_time = write_time;
+       }
+
+       TALLOC_FREE(lck);
+       return True;
+}
+
+bool set_write_time(struct file_id fileid, struct timespec write_time)
+{
+       struct share_mode_lock *lck;
 
-       if (fsp->is_directory) {
-               send_stat_cache_delete_message(fsp->fsp_name);
+       DEBUG(5,("set_write_time: %s id=%s\n",
+                timestring(talloc_tos(),
+                           convert_timespec_to_time_t(write_time)),
+                file_id_string_tos(&fileid)));
+
+       lck = get_share_mode_lock(NULL, fileid, NULL, NULL, NULL);
+       if (lck == NULL) {
+               return False;
+       }
+
+       if (timespec_compare(&lck->old_write_time, &write_time) != 0) {
+               lck->modified = True;
+               lck->old_write_time = write_time;
        }
 
        TALLOC_FREE(lck);
        return True;
 }
 
+
 struct forall_state {
        void (*fn)(const struct share_mode_entry *entry,
                   const char *sharepath,
@@ -1300,28 +1688,39 @@ struct forall_state {
        void *private_data;
 };
 
-static int traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf, 
-                       void *_state)
+static int traverse_fn(struct db_record *rec, void *_state)
 {
        struct forall_state *state = (struct forall_state *)_state;
        struct locking_data *data;
        struct share_mode_entry *shares;
        const char *sharepath;
        const char *fname;
+       const char *del_tokens;
+       uint32_t total_del_token_size = 0;
        int i;
 
        /* Ensure this is a locking_key record. */
-       if (kbuf.dsize != sizeof(struct locking_key))
+       if (rec->key.dsize != sizeof(struct file_id))
                return 0;
 
-       data = (struct locking_data *)dbuf.dptr;
-       shares = (struct share_mode_entry *)(dbuf.dptr + sizeof(*data));
-       sharepath = dbuf.dptr + sizeof(*data) +
+       data = (struct locking_data *)rec->value.dptr;
+       shares = (struct share_mode_entry *)(rec->value.dptr + sizeof(*data));
+       del_tokens = (const char *)rec->value.dptr + sizeof(*data) +
+               data->u.s.num_share_mode_entries*sizeof(*shares);
+
+       for (i = 0; i < data->u.s.num_delete_token_entries; i++) {
+               uint32_t del_token_size;
+               memcpy(&del_token_size, del_tokens, sizeof(uint32_t));
+               total_del_token_size += del_token_size;
+               del_tokens += del_token_size;
+       }
+
+       sharepath = (const char *)rec->value.dptr + sizeof(*data) +
                data->u.s.num_share_mode_entries*sizeof(*shares) +
-               data->u.s.delete_token_size;
-       fname = dbuf.dptr + sizeof(*data) +
+               total_del_token_size;
+       fname = (const char *)rec->value.dptr + sizeof(*data) +
                data->u.s.num_share_mode_entries*sizeof(*shares) +
-               data->u.s.delete_token_size +
+               total_del_token_size +
                strlen(sharepath) + 1;
 
        for (i=0;i<data->u.s.num_share_mode_entries;i++) {
@@ -1342,11 +1741,11 @@ int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
 {
        struct forall_state state;
 
-       if (tdb == NULL)
+       if (lock_db == NULL)
                return 0;
 
        state.fn = fn;
        state.private_data = private_data;
 
-       return tdb_traverse(tdb, traverse_fn, (void *)&state);
+       return lock_db->traverse_read(lock_db, traverse_fn, (void *)&state);
 }