git.samba.org / kai / samba.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
s3: Fix a typo
[kai/samba.git] / source3 / locking / locking.c
diff --git a/source3/locking/locking.c b/source3/locking/locking.c
index dd735be88a32835d722c260e7b02449d464b3ad1..35ae7584a268b02670a61dc6ce9feeffe5121525 100644 (file)
--- a/source3/locking/locking.c
+++ b/source3/locking/locking.c
@@ -4,17 +4,17 @@
    Copyright (C) Andrew Tridgell 1992-2000
    Copyright (C) Jeremy Allison 1992-2006
    Copyright (C) Volker Lendecke 2005
    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 3 of the License, or
    (at your option) any later version.
    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 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.
    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, see <http://www.gnu.org/licenses/>.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
@@ -29,13 +29,23 @@
    September 1997. Jeremy Allison (jallison@whistle.com). Added oplock
    support.
 
    September 1997. Jeremy Allison (jallison@whistle.com). Added oplock
    support.
 
-   rewrtten completely to use new tdb code. Tridge, Dec '99
+   rewritten completely to use new tdb code. Tridge, Dec '99
 
    Added POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
    Added Unix Extensions POSIX locking support. Jeremy Allison Mar 2006.
 */
 
 #include "includes.h"
 
    Added POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
    Added Unix Extensions POSIX locking support. Jeremy Allison Mar 2006.
 */
 
 #include "includes.h"
+#include "system/filesys.h"
+#include "locking/proto.h"
+#include "smbd/globals.h"
+#include "dbwrap/dbwrap.h"
+#include "dbwrap/dbwrap_open.h"
+#include "../libcli/security/security.h"
+#include "serverid.h"
+#include "messages.h"
+#include "util_tdb.h"
+#include "../librpc/gen_ndr/ndr_open_files.h"
 
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_LOCKING
 
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_LOCKING
@@ -76,7 +86,7 @@ const char *lock_flav_name(enum brl_flavour lock_flav)
 ****************************************************************************/
 
 void init_strict_lock_struct(files_struct *fsp,
 ****************************************************************************/
 
 void init_strict_lock_struct(files_struct *fsp,
-                               uint32 smbpid,
+                               uint64_t smblctx,
                                br_off start,
                                br_off size,
                                enum brl_type lock_type,
                                br_off start,
                                br_off size,
                                enum brl_type lock_type,
@@ -84,9 +94,9 @@ void init_strict_lock_struct(files_struct *fsp,
 {
        SMB_ASSERT(lock_type == READ_LOCK || lock_type == WRITE_LOCK);
 
 {
        SMB_ASSERT(lock_type == READ_LOCK || lock_type == WRITE_LOCK);
 
-       plock->context.smbpid = smbpid;
+       plock->context.smblctx = smblctx;
         plock->context.tid = fsp->conn->cnum;
         plock->context.tid = fsp->conn->cnum;
-        plock->context.pid = procid_self();
+        plock->context.pid = sconn_server_id(fsp->conn->sconn);
         plock->start = start;
         plock->size = size;
         plock->fnum = fsp->fnum;
         plock->start = start;
         plock->size = size;
         plock->fnum = fsp->fnum;
@@ -109,39 +119,41 @@ bool strict_lock_default(files_struct *fsp, struct lock_struct *plock)
 
        if (strict_locking == Auto) {
                if  (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (plock->lock_type == READ_LOCK || plock->lock_type == WRITE_LOCK)) {
 
        if (strict_locking == Auto) {
                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->fsp_name ));
+                       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) &&
                           (plock->lock_type == READ_LOCK)) {
                        ret = True;
                } else if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
                           (plock->lock_type == READ_LOCK)) {
-                       DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp->fsp_name ));
+                       DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp_str_dbg(fsp)));
                        ret = True;
                } else {
                        ret = True;
                } else {
-                       struct byte_range_lock *br_lck = brl_get_locks_readonly(talloc_tos(), fsp);
+                       struct byte_range_lock *br_lck;
+
+                       br_lck = brl_get_locks_readonly(fsp);
                        if (!br_lck) {
                                return True;
                        }
                        ret = brl_locktest(br_lck,
                        if (!br_lck) {
                                return True;
                        }
                        ret = brl_locktest(br_lck,
-                                       plock->context.smbpid,
+                                       plock->context.smblctx,
                                        plock->context.pid,
                                        plock->start,
                                        plock->size,
                                        plock->lock_type,
                                        plock->lock_flav);
                                        plock->context.pid,
                                        plock->start,
                                        plock->size,
                                        plock->lock_type,
                                        plock->lock_flav);
-                       TALLOC_FREE(br_lck);
                }
        } else {
                }
        } else {
-               struct byte_range_lock *br_lck = brl_get_locks_readonly(talloc_tos(), fsp);
+               struct byte_range_lock *br_lck;
+
+               br_lck = brl_get_locks_readonly(fsp);
                if (!br_lck) {
                        return True;
                }
                ret = brl_locktest(br_lck,
                if (!br_lck) {
                        return True;
                }
                ret = brl_locktest(br_lck,
-                               plock->context.smbpid,
+                               plock->context.smblctx,
                                plock->context.pid,
                                plock->start,
                                plock->size,
                                plock->lock_type,
                                plock->lock_flav);
                                plock->context.pid,
                                plock->start,
                                plock->size,
                                plock->lock_type,
                                plock->lock_flav);
-               TALLOC_FREE(br_lck);
        }
 
        DEBUG(10,("strict_lock_default: flavour = %s brl start=%.0f "
        }
 
        DEBUG(10,("strict_lock_default: flavour = %s brl start=%.0f "
@@ -149,7 +161,7 @@ bool strict_lock_default(files_struct *fsp, struct lock_struct *plock)
                        lock_flav_name(plock->lock_flav),
                        (double)plock->start, (double)plock->size,
                        ret ? "unlocked" : "locked",
                        lock_flav_name(plock->lock_flav),
                        (double)plock->start, (double)plock->size,
                        ret ? "unlocked" : "locked",
-                       plock->fnum, fsp->fsp_name ));
+                       plock->fnum, fsp_str_dbg(fsp)));
 
        return ret;
 }
 
        return ret;
 }
@@ -163,14 +175,13 @@ void strict_unlock_default(files_struct *fsp, struct lock_struct *plock)
 ****************************************************************************/
 
 NTSTATUS query_lock(files_struct *fsp,
 ****************************************************************************/
 
 NTSTATUS query_lock(files_struct *fsp,
-                       uint32 *psmbpid,
+                       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;
                        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;
 
        if (!fsp->can_lock) {
                return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
@@ -180,21 +191,18 @@ NTSTATUS query_lock(files_struct *fsp,
                return NT_STATUS_OK;
        }
 
                return NT_STATUS_OK;
        }
 
-       br_lck = brl_get_locks_readonly(talloc_tos(), fsp);
+       br_lck = brl_get_locks_readonly(fsp);
        if (!br_lck) {
                return NT_STATUS_NO_MEMORY;
        }
 
        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);
                        poffset,
                        pcount,
                        plock_type,
                        lock_flav);
-
-       TALLOC_FREE(br_lck);
-       return status;
 }
 
 static void increment_current_lock_count(files_struct *fsp,
 }
 
 static void increment_current_lock_count(files_struct *fsp,
@@ -231,18 +239,24 @@ static void decrement_current_lock_count(files_struct *fsp,
 
 struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
                        files_struct *fsp,
 
 struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
                        files_struct *fsp,
-                       uint32 lock_pid,
+                       uint64_t smblctx,
                        uint64_t count,
                        uint64_t offset,
                        enum brl_type lock_type,
                        enum brl_flavour lock_flav,
                        bool blocking_lock,
                        NTSTATUS *perr,
                        uint64_t count,
                        uint64_t offset,
                        enum brl_type lock_type,
                        enum brl_flavour lock_flav,
                        bool blocking_lock,
                        NTSTATUS *perr,
-                       uint32 *plock_pid,
+                       uint64_t *psmblctx,
                        struct blocking_lock_record *blr)
 {
        struct byte_range_lock *br_lck = NULL;
 
                        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;
        if (!fsp->can_lock) {
                *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
                return NULL;
@@ -259,7 +273,7 @@ struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
                "blocking_lock=%s requested for fnum %d file %s\n",
                lock_flav_name(lock_flav), lock_type_name(lock_type),
                (double)offset, (double)count, blocking_lock ? "true" :
                "blocking_lock=%s requested for fnum %d file %s\n",
                lock_flav_name(lock_flav), lock_type_name(lock_type),
                (double)offset, (double)count, blocking_lock ? "true" :
-               "false", fsp->fnum, fsp->fsp_name));
+               "false", fsp->fnum, fsp_str_dbg(fsp)));
 
        br_lck = brl_get_locks(talloc_tos(), fsp);
        if (!br_lck) {
 
        br_lck = brl_get_locks(talloc_tos(), fsp);
        if (!br_lck) {
@@ -269,14 +283,14 @@ struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
 
        *perr = brl_lock(msg_ctx,
                        br_lck,
 
        *perr = brl_lock(msg_ctx,
                        br_lck,
-                       lock_pid,
-                       procid_self(),
+                       smblctx,
+                       sconn_server_id(fsp->conn->sconn),
                        offset,
                        offset,
-                       count, 
+                       count,
                        lock_type,
                        lock_flav,
                        blocking_lock,
                        lock_type,
                        lock_flav,
                        blocking_lock,
-                       plock_pid,
+                       psmblctx,
                        blr);
 
        DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
                        blr);
 
        DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
@@ -291,24 +305,25 @@ struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
 
 NTSTATUS do_unlock(struct messaging_context *msg_ctx,
                        files_struct *fsp,
 
 NTSTATUS do_unlock(struct messaging_context *msg_ctx,
                        files_struct *fsp,
-                       uint32 lock_pid,
+                       uint64_t smblctx,
                        uint64_t count,
                        uint64_t offset,
                        enum brl_flavour lock_flav)
 {
        bool ok = False;
        struct byte_range_lock *br_lck = NULL;
                        uint64_t count,
                        uint64_t offset,
                        enum brl_flavour lock_flav)
 {
        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 (!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;
        }
        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",
        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(talloc_tos(), fsp);
        if (!br_lck) {
 
        br_lck = brl_get_locks(talloc_tos(), fsp);
        if (!br_lck) {
@@ -317,12 +332,12 @@ NTSTATUS do_unlock(struct messaging_context *msg_ctx,
 
        ok = brl_unlock(msg_ctx,
                        br_lck,
 
        ok = brl_unlock(msg_ctx,
                        br_lck,
-                       lock_pid,
-                       procid_self(),
+                       smblctx,
+                       sconn_server_id(fsp->conn->sconn),
                        offset,
                        count,
                        lock_flav);
                        offset,
                        count,
                        lock_flav);
-   
+
        TALLOC_FREE(br_lck);
 
        if (!ok) {
        TALLOC_FREE(br_lck);
 
        if (!ok) {
@@ -339,7 +354,7 @@ NTSTATUS do_unlock(struct messaging_context *msg_ctx,
 ****************************************************************************/
 
 NTSTATUS do_lock_cancel(files_struct *fsp,
 ****************************************************************************/
 
 NTSTATUS do_lock_cancel(files_struct *fsp,
-                       uint32 lock_pid,
+                       uint64 smblctx,
                        uint64_t count,
                        uint64_t offset,
                        enum brl_flavour lock_flav,
                        uint64_t count,
                        uint64_t offset,
                        enum brl_flavour lock_flav,
@@ -352,13 +367,14 @@ NTSTATUS do_lock_cancel(files_struct *fsp,
                return fsp->is_directory ?
                        NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
        }
                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",
        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(talloc_tos(), fsp);
        if (!br_lck) {
 
        br_lck = brl_get_locks(talloc_tos(), fsp);
        if (!br_lck) {
@@ -366,8 +382,8 @@ NTSTATUS do_lock_cancel(files_struct *fsp,
        }
 
        ok = brl_lock_cancel(br_lck,
        }
 
        ok = brl_lock_cancel(br_lck,
-                       lock_pid,
-                       procid_self(),
+                       smblctx,
+                       sconn_server_id(fsp->conn->sconn),
                        offset,
                        count,
                        lock_flav,
                        offset,
                        count,
                        lock_flav,
@@ -389,7 +405,8 @@ NTSTATUS do_lock_cancel(files_struct *fsp,
 ****************************************************************************/
 
 void locking_close_file(struct messaging_context *msg_ctx,
 ****************************************************************************/
 
 void locking_close_file(struct messaging_context *msg_ctx,
-                       files_struct *fsp)
+                       files_struct *fsp,
+                       enum file_close_type close_type)
 {
        struct byte_range_lock *br_lck;
 
 {
        struct byte_range_lock *br_lck;
 
@@ -408,7 +425,7 @@ void locking_close_file(struct messaging_context *msg_ctx,
        br_lck = brl_get_locks(talloc_tos(),fsp);
 
        if (br_lck) {
        br_lck = brl_get_locks(talloc_tos(),fsp);
 
        if (br_lck) {
-               cancel_pending_lock_requests_by_fid(fsp, br_lck);
+               cancel_pending_lock_requests_by_fid(fsp, br_lck, close_type);
                brl_close_fnum(msg_ctx, br_lck);
                TALLOC_FREE(br_lck);
        }
                brl_close_fnum(msg_ctx, br_lck);
                TALLOC_FREE(br_lck);
        }
@@ -427,7 +444,7 @@ static bool locking_init_internal(bool read_only)
 
        lock_db = db_open(NULL, lock_path("locking.tdb"),
                          lp_open_files_db_hash_size(),
 
        lock_db = db_open(NULL, lock_path("locking.tdb"),
                          lp_open_files_db_hash_size(),
-                         TDB_DEFAULT|TDB_VOLATILE|TDB_CLEAR_IF_FIRST,
+                         TDB_DEFAULT|TDB_VOLATILE|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
                          read_only?O_RDONLY:O_RDWR|O_CREAT, 0644);
 
        if (!lock_db) {
                          read_only?O_RDONLY:O_RDWR|O_CREAT, 0644);
 
        if (!lock_db) {
@@ -478,276 +495,112 @@ static TDB_DATA locking_key(const struct file_id *id, struct file_id *tmp)
 
 char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
 {
 
 char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
 {
-       return talloc_asprintf(ctx, "share_mode_entry[%d]: %s "
+       return talloc_asprintf(ctx, "share_mode_entry[%d]: "
                 "pid = %s, share_access = 0x%x, private_options = 0x%x, "
                 "pid = %s, share_access = 0x%x, private_options = 0x%x, "
-                "access_mask = 0x%x, mid = 0x%x, type= 0x%x, gen_id = %lu, "
-                "uid = %u, flags = %u, file_id %s",
+                "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,
                 num,
-                e->op_type == UNUSED_SHARE_MODE_ENTRY ? "UNUSED" : "",
                 procid_str_static(&e->pid),
                 e->share_access, e->private_options,
                 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->uid, (unsigned int)e->flags,
-                file_id_string_tos(&e->id));
+                file_id_string_tos(&e->id),
+                (unsigned int)e->name_hash);
 }
 
 /*******************************************************************
 }
 
 /*******************************************************************
- Print out a share mode table.
+ Get all share mode entries for a dev/inode pair.
 ********************************************************************/
 
 ********************************************************************/
 
-static void print_share_mode_table(struct locking_data *data)
+static bool parse_share_modes(const TDB_DATA dbuf, struct share_mode_lock *lck)
 {
 {
-       int num_share_modes = data->u.s.num_share_mode_entries;
-       struct share_mode_entry *shares =
-               (struct share_mode_entry *)(data + 1);
        int i;
        int i;
+       struct server_id *pids;
+       bool *pid_exists;
+       enum ndr_err_code ndr_err;
+       DATA_BLOB blob;
 
 
-       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));
-               str = share_mode_str(talloc_tos(), i, &entry);
+       blob.data = dbuf.dptr;
+       blob.length = dbuf.dsize;
 
 
-               DEBUG(10,("print_share_mode_table: %s\n", str ? str : ""));
-               TALLOC_FREE(str);
+       ndr_err = ndr_pull_struct_blob(
+               &blob, lck, lck,
+               (ndr_pull_flags_fn_t)ndr_pull_share_mode_lock);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               DEBUG(1, ("ndr_pull_share_mode_lock failed\n"));
+               return false;
        }
        }
-}
 
 
-/*******************************************************************
- Get all share mode entries for a dev/inode pair.
-********************************************************************/
-
-static bool parse_share_modes(TDB_DATA dbuf, struct share_mode_lock *lck)
-{
-       struct locking_data data;
-       int i;
+       lck->modified = false;
 
 
-       if (dbuf.dsize < sizeof(struct locking_data)) {
-               smb_panic("parse_share_modes: buffer too short");
+       if (DEBUGLEVEL >= 10) {
+               DEBUG(10, ("parse_share_modes:\n"));
+               NDR_PRINT_DEBUG(share_mode_lock, lck);
        }
 
        }
 
-       memcpy(&data, dbuf.dptr, sizeof(data));
-
-       lck->delete_on_close = data.u.s.delete_on_close;
-       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, owrt: %s, "
-                  "cwrt: %s, tok: %u, num_share_modes: %d\n",
-                  lck->delete_on_close,
-                  timestring(debug_ctx(),
-                             convert_timespec_to_time_t(lck->old_write_time)),
-                  timestring(debug_ctx(),
-                             convert_timespec_to_time_t(
-                                     lck->changed_write_time)),
-                  (unsigned int)data.u.s.delete_token_size,
-                  lck->num_share_modes));
+       /*
+        * Ensure that each entry has a real process attached.
+        */
 
 
-       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("parse_share_modes: invalid number of share modes");
+       pids = talloc_array(talloc_tos(), struct server_id,
+                           lck->num_share_modes);
+       if (pids == NULL) {
+               smb_panic("parse_share_modes: talloc_array failed");
        }
        }
-
-       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("parse_share_modes: buffer too short");
-               }
-                                 
-               lck->share_modes = (struct share_mode_entry *)
-                       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("parse_share_modes: talloc failed");
-               }
+       pid_exists = talloc_array(talloc_tos(), bool, lck->num_share_modes);
+       if (pid_exists == NULL) {
+               smb_panic("parse_share_modes: talloc_array failed");
        }
 
        }
 
-       /* Get any delete token. */
-       if (data.u.s.delete_token_size) {
-               uint8 *p = dbuf.dptr + sizeof(struct locking_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");
-               }
-
-               lck->delete_token = TALLOC_P(lck, UNIX_USER_TOKEN);
-               if (!lck->delete_token) {
-                       smb_panic("parse_share_modes: talloc failed");
-               }
-
-               /* 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("parse_share_modes: talloc failed");
-                       }
-
-                       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;
+       for (i=0; i<lck->num_share_modes; i++) {
+               pids[i] = lck->share_modes[i].pid;
        }
 
        }
 
-       /* Save off the associated service path and filename. */
-       lck->servicepath = (const char *)dbuf.dptr + sizeof(struct locking_data) +
-               (lck->num_share_modes * sizeof(struct share_mode_entry)) +
-               data.u.s.delete_token_size;
-
-       lck->filename = (const char *)dbuf.dptr + sizeof(struct locking_data) +
-               (lck->num_share_modes * sizeof(struct share_mode_entry)) +
-               data.u.s.delete_token_size +
-               strlen(lck->servicepath) + 1;
-
-       /*
-        * Ensure that each entry has a real process attached.
-        */
+       if (!serverids_exist(pids, lck->num_share_modes, pid_exists)) {
+               smb_panic("parse_share_modes: serverids_exist failed");
+       }
 
 
-       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",
-                       str ? str : ""));
-               if (!process_exists(entry_p->pid)) {
-                       DEBUG(10,("parse_share_modes: deleted %s\n",
-                               str ? str : ""));
-                       entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
+       i = 0;
+       while (i < lck->num_share_modes) {
+               struct share_mode_entry *e = &lck->share_modes[i];
+               if (!pid_exists[i]) {
+                       *e = lck->share_modes[lck->num_share_modes-1];
+                       lck->num_share_modes -= 1;
                        lck->modified = True;
                        lck->modified = True;
+                       continue;
                }
                }
-               TALLOC_FREE(str);
+               i += 1;
        }
        }
+       TALLOC_FREE(pid_exists);
+       TALLOC_FREE(pids);
 
        return True;
 }
 
 static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
 {
 
        return True;
 }
 
 static TDB_DATA unparse_share_modes(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;
-
-       result.dptr = NULL;
-       result.dsize = 0;
-
-       for (i=0; i<lck->num_share_modes; i++) {
-               if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
-                       num_valid += 1;
-               }
-       }
+       DATA_BLOB blob;
+       enum ndr_err_code ndr_err;
 
 
-       if (num_valid == 0) {
-               return result;
+       if (DEBUGLEVEL >= 10) {
+               DEBUG(10, ("unparse_share_modes:\n"));
+               NDR_PRINT_DEBUG(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);
-
-       result.dsize = sizeof(*data) +
-               lck->num_share_modes * sizeof(struct share_mode_entry) +
-               delete_token_size +
-               sp_len + 1 +
-               strlen(lck->filename) + 1;
-       result.dptr = TALLOC_ARRAY(lck, uint8, result.dsize);
-
-       if (result.dptr == NULL) {
-               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.old_write_time = lck->old_write_time;
-       data->u.s.changed_write_time = lck->changed_write_time;
-       data->u.s.delete_token_size = delete_token_size;
-
-       DEBUG(10,("unparse_share_modes: del: %d, owrt: %s cwrt: %s, tok: %u, "
-                 "num: %d\n", data->u.s.delete_on_close,
-                 timestring(debug_ctx(),
-                            convert_timespec_to_time_t(lck->old_write_time)),
-                 timestring(debug_ctx(),
-                            convert_timespec_to_time_t(
-                                    lck->changed_write_time)),
-                 (unsigned int)data->u.s.delete_token_size,
-                 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) {
-               uint8 *p = result.dptr + offset;
-
-               memcpy(p, &lck->delete_token->uid, sizeof(uid_t));
-               p += sizeof(uid_t);
-
-               memcpy(p, &lck->delete_token->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));
-                       p += sizeof(gid_t);
-               }
-               offset = p - result.dptr;
+       if (lck->num_share_modes == 0) {
+               DEBUG(10, ("No used share mode found\n"));
+               return make_tdb_data(NULL, 0);
        }
 
        }
 
-       safe_strcpy((char *)result.dptr + offset, lck->servicepath,
-                   result.dsize - offset - 1);
-       offset += sp_len + 1;
-       safe_strcpy((char *)result.dptr + offset, lck->filename,
-                   result.dsize - offset - 1);
-
-       if (DEBUGLEVEL >= 10) {
-               print_share_mode_table(data);
+       ndr_err = ndr_push_struct_blob(
+               &blob, lck, lck,
+               (ndr_push_flags_fn_t)ndr_push_share_mode_lock);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               smb_panic("ndr_push_share_mode_lock failed");
        }
 
        }
 
-       return result;
+       return make_tdb_data(blob.data, blob.length);
 }
 
 static int share_mode_lock_destructor(struct share_mode_lock *lck)
 }
 
 static int share_mode_lock_destructor(struct share_mode_lock *lck)
@@ -765,20 +618,36 @@ static int share_mode_lock_destructor(struct share_mode_lock *lck)
                if (!lck->fresh) {
                        /* There has been an entry before, delete it */
 
                if (!lck->fresh) {
                        /* There has been an entry before, delete it */
 
-                       status = lck->record->delete_rec(lck->record);
+                       status = dbwrap_record_delete(lck->record);
                        if (!NT_STATUS_IS_OK(status)) {
                        if (!NT_STATUS_IS_OK(status)) {
+                               char *errmsg;
+
                                DEBUG(0, ("delete_rec returned %s\n",
                                          nt_errstr(status)));
                                DEBUG(0, ("delete_rec returned %s\n",
                                          nt_errstr(status)));
-                               smb_panic("could not delete share entry");
+
+                               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;
        }
 
                        }
                }
                goto done;
        }
 
-       status = lck->record->store(lck->record, data, TDB_REPLACE);
+       status = dbwrap_record_store(lck->record, data, TDB_REPLACE);
        if (!NT_STATUS_IS_OK(status)) {
        if (!NT_STATUS_IS_OK(status)) {
+               char *errmsg;
+
                DEBUG(0, ("store returned %s\n", nt_errstr(status)));
                DEBUG(0, ("store returned %s\n", nt_errstr(status)));
-               smb_panic("could not store share mode entry");
+
+               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:
        }
 
  done:
@@ -789,45 +658,55 @@ static int share_mode_lock_destructor(struct share_mode_lock *lck)
 static bool fill_share_mode_lock(struct share_mode_lock *lck,
                                 struct file_id id,
                                 const char *servicepath,
 static bool fill_share_mode_lock(struct share_mode_lock *lck,
                                 struct file_id id,
                                 const char *servicepath,
-                                const char *fname,
+                                const struct smb_filename *smb_fname,
                                 TDB_DATA share_mode_data,
                                 const struct timespec *old_write_time)
 {
                                 TDB_DATA share_mode_data,
                                 const struct timespec *old_write_time)
 {
+       bool fresh;
+
        /* Ensure we set every field here as the destructor must be
           valid even if parse_share_modes fails. */
 
        lck->servicepath = 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->base_name = NULL;
+       lck->stream_name = NULL;
        lck->id = id;
        lck->num_share_modes = 0;
        lck->share_modes = NULL;
        lck->id = id;
        lck->num_share_modes = 0;
        lck->share_modes = NULL;
-       lck->delete_token = NULL;
-       lck->delete_on_close = False;
+       lck->num_delete_tokens = 0;
+       lck->delete_tokens = NULL;
        ZERO_STRUCT(lck->old_write_time);
        ZERO_STRUCT(lck->changed_write_time);
        ZERO_STRUCT(lck->old_write_time);
        ZERO_STRUCT(lck->changed_write_time);
-       lck->fresh = False;
-       lck->modified = False;
 
 
-       lck->fresh = (share_mode_data.dptr == NULL);
+       fresh = (share_mode_data.dptr == NULL);
 
 
-       if (lck->fresh) {
-               if (fname == NULL || servicepath == NULL
+       if (fresh) {
+               bool has_stream;
+               if (smb_fname == NULL || servicepath == NULL
                    || old_write_time == NULL) {
                        return False;
                }
                    || old_write_time == NULL) {
                        return False;
                }
-               lck->filename = talloc_strdup(lck, fname);
+
+               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);
                lck->servicepath = talloc_strdup(lck, servicepath);
-               if (lck->filename == NULL || lck->servicepath == NULL) {
+               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;
                        DEBUG(0, ("talloc failed\n"));
                        return False;
                }
                lck->old_write_time = *old_write_time;
+               lck->modified = false;
        } else {
                if (!parse_share_modes(share_mode_data, lck)) {
                        DEBUG(0, ("Could not parse share modes\n"));
                        return False;
                }
        }
        } else {
                if (!parse_share_modes(share_mode_data, lck)) {
                        DEBUG(0, ("Could not parse share modes\n"));
                        return False;
                }
        }
+       lck->fresh = fresh;
 
        return True;
 }
 
        return True;
 }
@@ -835,58 +714,68 @@ static bool fill_share_mode_lock(struct share_mode_lock *lck,
 struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
                                            const struct file_id id,
                                            const char *servicepath,
 struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
                                            const struct file_id id,
                                            const char *servicepath,
-                                           const char *fname,
+                                           const struct smb_filename *smb_fname,
                                            const struct timespec *old_write_time)
 {
        struct share_mode_lock *lck;
        struct file_id tmp;
                                            const struct timespec *old_write_time)
 {
        struct share_mode_lock *lck;
        struct file_id tmp;
+       struct db_record *rec;
        TDB_DATA key = locking_key(&id, &tmp);
        TDB_DATA key = locking_key(&id, &tmp);
+       TDB_DATA value;
 
 
-       if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
+       if (!(lck = talloc(mem_ctx, struct share_mode_lock))) {
                DEBUG(0, ("talloc failed\n"));
                return NULL;
        }
 
                DEBUG(0, ("talloc failed\n"));
                return NULL;
        }
 
-       if (!(lck->record = lock_db->fetch_locked(lock_db, lck, key))) {
+       rec = dbwrap_fetch_locked(lock_db, lck, key);
+       if (rec == NULL) {
                DEBUG(3, ("Could not lock share entry\n"));
                TALLOC_FREE(lck);
                return NULL;
        }
 
                DEBUG(3, ("Could not lock share entry\n"));
                TALLOC_FREE(lck);
                return NULL;
        }
 
-       if (!fill_share_mode_lock(lck, id, servicepath, fname,
-                                 lck->record->value, old_write_time)) {
+       value = dbwrap_record_get_value(rec);
+
+       if (!fill_share_mode_lock(lck, id, servicepath, smb_fname,
+                                 value, old_write_time)) {
                DEBUG(3, ("fill_share_mode_lock failed\n"));
                TALLOC_FREE(lck);
                return NULL;
        }
 
                DEBUG(3, ("fill_share_mode_lock failed\n"));
                TALLOC_FREE(lck);
                return NULL;
        }
 
+       lck->record = rec;
        talloc_set_destructor(lck, share_mode_lock_destructor);
 
        return lck;
 }
 
 struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
        talloc_set_destructor(lck, share_mode_lock_destructor);
 
        return lck;
 }
 
 struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
-                                                 const struct file_id id,
-                                                 const char *servicepath,
-                                                 const char *fname)
+                                                 const struct file_id id)
 {
        struct share_mode_lock *lck;
        struct file_id tmp;
        TDB_DATA key = locking_key(&id, &tmp);
        TDB_DATA data;
 {
        struct share_mode_lock *lck;
        struct file_id tmp;
        TDB_DATA key = locking_key(&id, &tmp);
        TDB_DATA data;
+       NTSTATUS status;
 
 
-       if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
+       if (!(lck = talloc(mem_ctx, struct share_mode_lock))) {
                DEBUG(0, ("talloc failed\n"));
                return NULL;
        }
 
                DEBUG(0, ("talloc failed\n"));
                return NULL;
        }
 
-       if (lock_db->fetch(lock_db, lck, key, &data) == -1) {
+       status = dbwrap_fetch(lock_db, lck, key, &data);
+       if (!NT_STATUS_IS_OK(status)) {
                DEBUG(3, ("Could not fetch share entry\n"));
                TALLOC_FREE(lck);
                return NULL;
        }
                DEBUG(3, ("Could not fetch share entry\n"));
                TALLOC_FREE(lck);
                return NULL;
        }
+       if (data.dptr == NULL) {
+               TALLOC_FREE(lck);
+               return NULL;
+       }
 
 
-       if (!fill_share_mode_lock(lck, id, servicepath, fname, data, NULL)) {
+       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);
                DEBUG(10, ("fetch_share_mode_unlocked: no share_mode record "
                           "around (file not open)\n"));
                TALLOC_FREE(lck);
@@ -906,40 +795,54 @@ struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
 bool rename_share_filename(struct messaging_context *msg_ctx,
                        struct share_mode_lock *lck,
                        const char *servicepath,
 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 sp_len;
-       size_t fn_len;
+       size_t bn_len;
+       size_t sn_len;
        size_t msg_len;
        char *frm = NULL;
        int i;
        size_t msg_len;
        char *frm = NULL;
        int i;
+       bool strip_two_chars = false;
+       bool has_stream = smb_fname_dst->stream_name != NULL;
 
        DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
 
        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 '/'.
         */
 
        /*
         * 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->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);
                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. */
 
        /* Set up the name changed message. */
-       frm = TALLOC_ARRAY(lck, char, msg_len);
+       frm = talloc_array(lck, char, msg_len);
        if (!frm) {
                return False;
        }
        if (!frm) {
                return False;
        }
@@ -948,8 +851,15 @@ bool rename_share_filename(struct messaging_context *msg_ctx,
 
        DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
 
 
        DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
 
-       safe_strcpy(&frm[24], lck->servicepath, sp_len);
-       safe_strcpy(&frm[24 + 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++) {
 
        /* Send the messages. */
        for (i=0; i<lck->num_share_modes; i++) {
@@ -957,16 +867,27 @@ bool rename_share_filename(struct messaging_context *msg_ctx,
                if (!is_valid_share_mode_entry(se)) {
                        continue;
                }
                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;
                }
 
                /* But not to ourselves... */
                if (procid_is_me(&se->pid)) {
                        continue;
                }
 
-               DEBUG(10,("rename_share_filename: sending rename message to pid %s "
-                         "file_id %s sharepath %s newname %s\n",
+               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),
                          procid_str_static(&se->pid),
                          file_id_string_tos(&lck->id),
-                         lck->servicepath, lck->filename ));
+                         lck->servicepath, lck->base_name,
+                       has_stream ? lck->stream_name : ""));
 
                messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
                                   (uint8 *)frm, msg_len);
 
                messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
                                   (uint8 *)frm, msg_len);
@@ -976,6 +897,7 @@ bool rename_share_filename(struct messaging_context *msg_ctx,
 }
 
 void get_file_infos(struct file_id id,
 }
 
 void get_file_infos(struct file_id id,
+                   uint32_t name_hash,
                    bool *delete_on_close,
                    struct timespec *write_time)
 {
                    bool *delete_on_close,
                    struct timespec *write_time)
 {
@@ -989,12 +911,12 @@ void get_file_infos(struct file_id id,
                ZERO_STRUCTP(write_time);
        }
 
                ZERO_STRUCTP(write_time);
        }
 
-       if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id, NULL, NULL))) {
+       if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
                return;
        }
 
        if (delete_on_close) {
                return;
        }
 
        if (delete_on_close) {
-               *delete_on_close = lck->delete_on_close;
+               *delete_on_close = is_delete_on_close_set(lck, name_hash);
        }
 
        if (write_time) {
        }
 
        if (write_time) {
@@ -1015,14 +937,6 @@ bool is_valid_share_mode_entry(const struct share_mode_entry *e)
 {
        int num_props = 0;
 
 {
        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);
        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);
@@ -1036,21 +950,16 @@ bool is_deferred_open_entry(const struct share_mode_entry *e)
        return (e->op_type == DEFERRED_OPEN_ENTRY);
 }
 
        return (e->op_type == DEFERRED_OPEN_ENTRY);
 }
 
-bool is_unused_share_mode_entry(const struct share_mode_entry *e)
-{
-       return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
-}
-
 /*******************************************************************
  Fill a share mode entry.
 ********************************************************************/
 
 static void fill_share_mode_entry(struct share_mode_entry *e,
                                  files_struct *fsp,
 /*******************************************************************
  Fill a share mode entry.
 ********************************************************************/
 
 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);
 {
        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;
        e->share_access = fsp->share_access;
        e->private_options = fsp->fh->private_options;
        e->access_mask = fsp->access_mask;
@@ -1062,14 +971,17 @@ static void fill_share_mode_entry(struct share_mode_entry *e,
        e->share_file_id = fsp->fh->gen_id;
        e->uid = (uint32)uid;
        e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
        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,
 }
 
 static void fill_deferred_open_entry(struct share_mode_entry *e,
                                     const struct timeval request_time,
-                                    struct file_id id, uint16 mid)
+                                    struct file_id id,
+                                    struct server_id pid,
+                                    uint64_t mid)
 {
        ZERO_STRUCTP(e);
 {
        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->op_mid = mid;
        e->op_type = DEFERRED_OPEN_ENTRY;
        e->time.tv_sec = request_time.tv_sec;
@@ -1082,38 +994,25 @@ static void fill_deferred_open_entry(struct share_mode_entry *e,
 static void add_share_mode_entry(struct share_mode_lock *lck,
                                 const struct share_mode_entry *entry)
 {
 static void add_share_mode_entry(struct share_mode_lock *lck,
                                 const struct share_mode_entry *entry)
 {
-       int i;
-
-       for (i=0; i<lck->num_share_modes; i++) {
-               struct share_mode_entry *e = &lck->share_modes[i];
-               if (is_unused_share_mode_entry(e)) {
-                       *e = *entry;
-                       break;
-               }
-       }
-
-       if (i == lck->num_share_modes) {
-               /* No unused entry found */
-               ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
-                            &lck->share_modes, &lck->num_share_modes);
-       }
+       ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
+                    &lck->share_modes, &lck->num_share_modes);
        lck->modified = True;
 }
 
 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
        lck->modified = True;
 }
 
 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);
 }
 
 {
        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,
                       struct timeval request_time,
-                      struct file_id id)
+                      struct server_id pid, struct file_id id)
 {
        struct share_mode_entry entry;
 {
        struct share_mode_entry entry;
-       fill_deferred_open_entry(&entry, request_time, id, mid);
+       fill_deferred_open_entry(&entry, request_time, id, pid, mid);
        add_share_mode_entry(lck, &entry);
 }
 
        add_share_mode_entry(lck, &entry);
 }
 
@@ -1181,25 +1080,26 @@ bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
        if (e == NULL) {
                return False;
        }
        if (e == NULL) {
                return False;
        }
-
-       e->op_type = UNUSED_SHARE_MODE_ENTRY;
+       *e = lck->share_modes[lck->num_share_modes-1];
+       lck->num_share_modes -= 1;
        lck->modified = True;
        return True;
 }
 
        lck->modified = True;
        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(),
 {
        struct share_mode_entry entry, *e;
 
        fill_deferred_open_entry(&entry, timeval_zero(),
-                                lck->id, mid);
+                                lck->id, pid, mid);
 
        e = find_share_mode_entry(lck, &entry);
        if (e == NULL) {
                return;
        }
 
        e = find_share_mode_entry(lck, &entry);
        if (e == NULL) {
                return;
        }
-
-       e->op_type = UNUSED_SHARE_MODE_ENTRY;
+       *e = lck->share_modes[lck->num_share_modes-1];
+       lck->num_share_modes -= 1;
        lck->modified = True;
 }
 
        lck->modified = True;
 }
 
@@ -1219,13 +1119,15 @@ bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
                return False;
        }
 
                return False;
        }
 
-       e->op_mid = 0;
-       if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
+       if (EXCLUSIVE_OPLOCK_TYPE(e->op_type)) {
                /*
                 * Going from exclusive or batch,
                 * we always go through FAKE_LEVEL_II
                 * first.
                 */
                /*
                 * 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;
                e->op_type = FAKE_LEVEL_II_OPLOCK;
        } else {
                e->op_type = NO_OPLOCK;
@@ -1255,76 +1157,16 @@ bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
        return True;
 }
 
        return True;
 }
 
-/****************************************************************************
- 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.
-****************************************************************************/
-
-NTSTATUS can_set_delete_on_close(files_struct *fsp, bool delete_on_close,
-                                uint32 dosmode)
-{
-       if (!delete_on_close) {
-               return NT_STATUS_OK;
-       }
-
-       /*
-        * Only allow delete on close for writable files.
-        */
-
-       if ((dosmode & aRONLY) &&
-           !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 ));
-               return NT_STATUS_CANNOT_DELETE;
-       }
-
-       /*
-        * Only allow delete on close for writable shares.
-        */
-
-       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 ));
-               return NT_STATUS_ACCESS_DENIED;
-       }
-
-       /*
-        * Only allow delete on close for files/directories opened with delete
-        * intent.
-        */
-
-       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 ));
-               return NT_STATUS_ACCESS_DENIED;
-       }
-
-       /* Don't allow delete on close for non-empty directories. */
-       if (fsp->is_directory) {
-               return can_delete_directory(fsp->conn, fsp->fsp_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.... ?).
 *************************************************************************/
 
  (Should this be in locking.c.... ?).
 *************************************************************************/
 
-static UNIX_USER_TOKEN *copy_unix_token(TALLOC_CTX *ctx, const 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;
-
-       if (tok == NULL) {
-               return NULL;
-       }
+       struct security_unix_token *cpy;
 
 
-       cpy = TALLOC_P(ctx, UNIX_USER_TOKEN);
+       cpy = talloc(ctx, struct security_unix_token);
        if (!cpy) {
                return NULL;
        }
        if (!cpy) {
                return NULL;
        }
@@ -1334,26 +1176,42 @@ static UNIX_USER_TOKEN *copy_unix_token(TALLOC_CTX *ctx, const UNIX_USER_TOKEN *
        cpy->ngroups = tok->ngroups;
        if (tok->ngroups) {
                /* Make this a talloc child of cpy. */
        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) {
                if (!cpy->groups) {
+                       TALLOC_FREE(cpy);
                        return NULL;
                }
                        return NULL;
                }
-               memcpy(cpy->groups, tok->groups, tok->ngroups * sizeof(gid_t));
        }
        return cpy;
 }
 
 /****************************************************************************
        }
        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, const 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)
 {
 {
-       TALLOC_FREE(lck->delete_token); /* Also deletes groups... */
+       struct delete_token *tmp, *dtl;
 
 
-       /* Copy the new token (can be NULL). */
-       lck->delete_token = copy_unix_token(lck, tok);
-       lck->modified = True;
+       tmp = talloc_realloc(lck, lck->delete_tokens, struct delete_token,
+                            lck->num_delete_tokens+1);
+       if (tmp == NULL) {
+               return false;
+       }
+       lck->delete_tokens = tmp;
+       dtl = &lck->delete_tokens[lck->num_delete_tokens];
+
+       dtl->name_hash = name_hash;
+       dtl->delete_token = copy_unix_token(lck->delete_tokens, tok);
+       if (dtl->delete_token == NULL) {
+               return false;
+       }
+       lck->num_delete_tokens += 1;
+       lck->modified = true;
+       return true;
 }
 
 /****************************************************************************
 }
 
 /****************************************************************************
@@ -1363,31 +1221,61 @@ void set_delete_on_close_token(struct share_mode_lock *lck, const UNIX_USER_TOKE
  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.
  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.
 ****************************************************************************/
 
  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, const 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);
+       int i;
+       bool ret;
+
+       if (delete_on_close) {
+               SMB_ASSERT(tok != NULL);
+       } else {
+               SMB_ASSERT(tok == NULL);
+       }
+
+       for (i=0; i<lck->num_delete_tokens; i++) {
+               struct delete_token *dt = &lck->delete_tokens[i];
+               if (dt->name_hash == fsp->name_hash) {
+                       lck->modified = true;
+                       if (delete_on_close == false) {
+                               /* Delete this entry. */
+                               TALLOC_FREE(dt->delete_token);
+                               *dt = lck->delete_tokens[
+                                       lck->num_delete_tokens-1];
+                               lck->num_delete_tokens -= 1;
+                               return;
+                       }
+                       /* Replace this token with the
+                          given tok. */
+                       TALLOC_FREE(dt->delete_token);
+                       dt->delete_token = copy_unix_token(dt, tok);
+                       SMB_ASSERT(dt->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, const UNIX_USER_TOKEN *tok)
+bool set_delete_on_close(files_struct *fsp, bool delete_on_close, const struct security_unix_token *tok)
 {
 {
-       UNIX_USER_TOKEN *tok_copy = NULL;
        struct share_mode_lock *lck;
        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,
        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)));
 
        lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
                                  NULL);
 
        lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
                                  NULL);
@@ -1395,36 +1283,55 @@ bool set_delete_on_close(files_struct *fsp, bool delete_on_close, const UNIX_USE
                return False;
        }
 
                return False;
        }
 
-       if (fsp->conn->admin_user) {
-               tok_copy = copy_unix_token(lck, tok);
-               if (tok_copy == NULL) {
-                       TALLOC_FREE(lck);
-                       return false;
-               }
-               tok_copy->uid = (uid_t)0;
-               tok = tok_copy;
-       }
-
-       set_delete_on_close_lck(lck, delete_on_close, tok);
+       set_delete_on_close_lck(fsp, lck, delete_on_close,
+                       delete_on_close ? tok : NULL);
 
        if (fsp->is_directory) {
 
        if (fsp->is_directory) {
-               send_stat_cache_delete_message(fsp->fsp_name);
+               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);
        }
 
        TALLOC_FREE(lck);
+
+       fsp->delete_on_close = delete_on_close;
+
        return True;
 }
 
        return True;
 }
 
+const struct security_unix_token *get_delete_on_close_token(struct share_mode_lock *lck, uint32_t name_hash)
+{
+       int i;
+
+       DEBUG(10,("get_delete_on_close_token: name_hash = 0x%x\n",
+                       (unsigned int)name_hash ));
+
+       for (i=0; i<lck->num_delete_tokens; i++) {
+               struct delete_token *dt = &lck->delete_tokens[i];
+               DEBUG(10,("get_delete_on_close_token: dtl->name_hash = 0x%x\n",
+                               (unsigned int)dt->name_hash ));
+               if (dt->name_hash == name_hash) {
+                       return dt->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",
 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(debug_ctx(),
+                timestring(talloc_tos(),
                            convert_timespec_to_time_t(write_time)),
                 file_id_string_tos(&fileid)));
 
                            convert_timespec_to_time_t(write_time)),
                 file_id_string_tos(&fileid)));
 
-       lck = get_share_mode_lock(NULL, fileid, NULL, NULL, NULL);
+       lck = get_share_mode_lock(talloc_tos(), fileid, NULL, NULL, NULL);
        if (lck == NULL) {
                return False;
        }
        if (lck == NULL) {
                return False;
        }
@@ -1443,11 +1350,11 @@ bool set_write_time(struct file_id fileid, struct timespec write_time)
        struct share_mode_lock *lck;
 
        DEBUG(5,("set_write_time: %s id=%s\n",
        struct share_mode_lock *lck;
 
        DEBUG(5,("set_write_time: %s id=%s\n",
-                timestring(debug_ctx(),
+                timestring(talloc_tos(),
                            convert_timespec_to_time_t(write_time)),
                 file_id_string_tos(&fileid)));
 
                            convert_timespec_to_time_t(write_time)),
                 file_id_string_tos(&fileid)));
 
-       lck = get_share_mode_lock(NULL, fileid, NULL, NULL, NULL);
+       lck = get_share_mode_lock(talloc_tos(), fileid, NULL, NULL, NULL);
        if (lck == NULL) {
                return False;
        }
        if (lck == NULL) {
                return False;
        }
@@ -1473,30 +1380,42 @@ struct forall_state {
 static int traverse_fn(struct db_record *rec, void *_state)
 {
        struct forall_state *state = (struct forall_state *)_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;
-       int i;
+       uint32_t i;
+       TDB_DATA key;
+       TDB_DATA value;
+       DATA_BLOB blob;
+       enum ndr_err_code ndr_err;
+       struct share_mode_lock *lck;
+
+       key = dbwrap_record_get_key(rec);
+       value = dbwrap_record_get_value(rec);
 
        /* Ensure this is a locking_key record. */
 
        /* Ensure this is a locking_key record. */
-       if (rec->key.dsize != sizeof(struct file_id))
+       if (key.dsize != sizeof(struct file_id))
+               return 0;
+
+       lck = talloc(talloc_tos(), struct share_mode_lock);
+       if (lck == NULL) {
                return 0;
                return 0;
+       }
+
+       blob.data = value.dptr;
+       blob.length = value.dsize;
 
 
-       data = (struct locking_data *)rec->value.dptr;
-       shares = (struct share_mode_entry *)(rec->value.dptr + sizeof(*data));
-       sharepath = (const char *)rec->value.dptr + sizeof(*data) +
-               data->u.s.num_share_mode_entries*sizeof(*shares) +
-               data->u.s.delete_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 +
-               strlen(sharepath) + 1;
-
-       for (i=0;i<data->u.s.num_share_mode_entries;i++) {
-               state->fn(&shares[i], sharepath, fname,
+       ndr_err = ndr_pull_struct_blob(
+               &blob, lck, lck,
+               (ndr_pull_flags_fn_t)ndr_pull_share_mode_lock);
+       if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+               DEBUG(1, ("ndr_pull_share_mode_lock failed\n"));
+               return 0;
+       }
+       for (i=0; i<lck->num_share_modes; i++) {
+               state->fn(&lck->share_modes[i],
+                         lck->servicepath, lck->base_name,
                          state->private_data);
        }
                          state->private_data);
        }
+       TALLOC_FREE(lck);
+
        return 0;
 }
 
        return 0;
 }
 
@@ -1510,6 +1429,8 @@ int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
                      void *private_data)
 {
        struct forall_state state;
                      void *private_data)
 {
        struct forall_state state;
+       NTSTATUS status;
+       int count;
 
        if (lock_db == NULL)
                return 0;
 
        if (lock_db == NULL)
                return 0;
@@ -1517,5 +1438,12 @@ int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
        state.fn = fn;
        state.private_data = private_data;
 
        state.fn = fn;
        state.private_data = private_data;
 
-       return lock_db->traverse_read(lock_db, traverse_fn, (void *)&state);
+       status = dbwrap_traverse_read(lock_db, traverse_fn, (void *)&state,
+                                     &count);
+
+       if (!NT_STATUS_IS_OK(status)) {
+               return -1;
+       } else {
+               return count;
+       }
 }
 }
Kai's WIP code