s3-talloc Change TALLOC_ARRAY() to talloc_array()
[samba.git] / source3 / locking / locking.c
index a9b13d61a118108dfd8fbfa287810ed76315ebe0..55412ec8b2aa8c702db98b739d6e6fe2f64b276c 100644 (file)
@@ -4,17 +4,17 @@
    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 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/>.
 
 */
 
 #include "includes.h"
-#include "librpc/gen_ndr/messaging.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
@@ -304,15 +310,15 @@ NTSTATUS do_unlock(struct messaging_context *msg_ctx,
 {
        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_str_dbg(fsp)));
@@ -329,7 +335,7 @@ NTSTATUS do_unlock(struct messaging_context *msg_ctx,
                        offset,
                        count,
                        lock_flav);
-   
+
        TALLOC_FREE(br_lck);
 
        if (!ok) {
@@ -359,7 +365,7 @@ NTSTATUS do_lock_cancel(files_struct *fsp,
                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);
        }
@@ -436,7 +442,7 @@ static bool locking_init_internal(bool read_only)
 
        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) {
@@ -490,7 +496,7 @@ char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
        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%llx, type= 0x%x, gen_id = %lu, "
-                "uid = %u, flags = %u, file_id %s",
+                "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),
@@ -498,7 +504,8 @@ char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
                 e->access_mask, (unsigned long long)e->op_mid,
                 e->op_type, e->share_file_id,
                 (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);
 }
 
 /*******************************************************************
@@ -530,6 +537,104 @@ static void print_share_mode_table(struct locking_data *data)
        }
 }
 
+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.
 ********************************************************************/
@@ -537,6 +642,7 @@ static void print_share_mode_table(struct locking_data *data)
 static bool parse_share_modes(const TDB_DATA dbuf, struct share_mode_lock *lck)
 {
        struct locking_data data;
+       int delete_tokens_size;
        int i;
 
        if (dbuf.dsize < sizeof(struct locking_data)) {
@@ -545,20 +651,18 @@ static bool parse_share_modes(const TDB_DATA dbuf, struct 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,
+       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.delete_token_size,
+                  (unsigned int)data.u.s.num_delete_token_entries,
                   lck->num_share_modes));
 
        if ((lck->num_share_modes < 0) || (lck->num_share_modes > 1000000)) {
@@ -568,7 +672,7 @@ static bool parse_share_modes(const TDB_DATA dbuf, struct share_mode_lock *lck)
        }
 
        lck->share_modes = NULL;
-       
+
        if (lck->num_share_modes != 0) {
 
                if (dbuf.dsize < (sizeof(struct locking_data) +
@@ -576,7 +680,7 @@ static bool parse_share_modes(const TDB_DATA dbuf, struct share_mode_lock *lck)
                                   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),
@@ -588,66 +692,25 @@ static bool parse_share_modes(const TDB_DATA dbuf, struct share_mode_lock *lck)
                }
        }
 
-       /* 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;
+       /* 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 = (const char *)dbuf.dptr + sizeof(struct locking_data) +
                (lck->num_share_modes * sizeof(struct share_mode_entry)) +
-               data.u.s.delete_token_size;
+               delete_tokens_size;
 
        lck->base_name = (const char *)dbuf.dptr + sizeof(struct locking_data) +
                (lck->num_share_modes * sizeof(struct share_mode_entry)) +
-               data.u.s.delete_token_size +
+               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)) +
-               data.u.s.delete_token_size +
+               delete_tokens_size +
                strlen(lck->servicepath) + 1 +
                strlen(lck->base_name) + 1;
 
@@ -683,7 +746,9 @@ static TDB_DATA unparse_share_modes(const struct share_mode_lock *lck)
        struct locking_data *data;
        ssize_t offset;
        ssize_t sp_len, bn_len, sn_len;
-       uint32 delete_token_size;
+       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;
@@ -702,16 +767,22 @@ static TDB_DATA unparse_share_modes(const struct share_mode_lock *lck)
        bn_len = strlen(lck->base_name);
        sn_len = lck->stream_name != NULL ? strlen(lck->stream_name) : 0;
 
-       delete_token_size = (lck->delete_token ?
-                       (sizeof(uid_t) + sizeof(gid_t) + (lck->delete_token->ngroups*sizeof(gid_t))) : 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 +
                bn_len + 1 +
                sn_len + 1;
-       result.dptr = TALLOC_ARRAY(lck, uint8, result.dsize);
+       result.dptr = talloc_array(lck, uint8, result.dsize);
 
        if (result.dptr == NULL) {
                smb_panic("talloc failed");
@@ -720,19 +791,18 @@ static TDB_DATA unparse_share_modes(const struct share_mode_lock *lck)
        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;
+       data->u.s.num_delete_token_entries = num_delete_token_entries;
 
-       DEBUG(10,("unparse_share_modes: del: %d, owrt: %s cwrt: %s, tok: %u, "
-                 "num: %d\n", data->u.s.delete_on_close,
+       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.delete_token_size,
+                 (unsigned int)data->u.s.num_delete_token_entries,
                  data->u.s.num_share_mode_entries));
 
        memcpy(result.dptr + sizeof(*data), lck->share_modes,
@@ -740,31 +810,46 @@ static TDB_DATA unparse_share_modes(const struct share_mode_lock *lck)
        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;
+       /* 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((char *)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((char *)result.dptr + offset, lck->base_name,
-                   result.dsize - offset - 1);
+       strlcpy((char *)result.dptr + offset,
+               lck->base_name ? lck->base_name : "",
+               result.dsize - offset);
        offset += bn_len + 1;
-       safe_strcpy((char *)result.dptr + offset, lck->stream_name,
-                   result.dsize - offset - 1);
+       strlcpy((char *)result.dptr + offset,
+               lck->stream_name ? lck->stream_name : "",
+               result.dsize - offset);
 
        if (DEBUGLEVEL >= 10) {
                print_share_mode_table(data);
@@ -841,8 +926,7 @@ static bool fill_share_mode_lock(struct share_mode_lock *lck,
        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;
@@ -951,6 +1035,8 @@ 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,
+                       uint32_t orig_name_hash,
+                       uint32_t new_name_hash,
                        const struct smb_filename *smb_fname_dst)
 {
        size_t sp_len;
@@ -996,7 +1082,7 @@ bool rename_share_filename(struct messaging_context *msg_ctx,
            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;
        }
@@ -1005,10 +1091,15 @@ bool rename_share_filename(struct messaging_context *msg_ctx,
 
        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->base_name, bn_len);
-       safe_strcpy(&frm[24 + sp_len + 1 + bn_len + 1], lck->stream_name,
-                   sn_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++) {
@@ -1016,6 +1107,15 @@ bool rename_share_filename(struct messaging_context *msg_ctx,
                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;
@@ -1037,6 +1137,7 @@ bool rename_share_filename(struct messaging_context *msg_ctx,
 }
 
 void get_file_infos(struct file_id id,
+                   uint32_t name_hash,
                    bool *delete_on_close,
                    struct timespec *write_time)
 {
@@ -1055,7 +1156,7 @@ void get_file_infos(struct file_id id,
        }
 
        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) {
@@ -1123,6 +1224,7 @@ 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->name_hash = fsp->name_hash;
 }
 
 static void fill_deferred_open_entry(struct share_mode_entry *e,
@@ -1283,13 +1385,15 @@ bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
                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.
                 */
+               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;
@@ -1329,7 +1433,7 @@ NTSTATUS can_set_delete_on_close(files_struct *fsp, uint32 dosmode)
         * 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",
@@ -1371,19 +1475,15 @@ NTSTATUS can_set_delete_on_close(files_struct *fsp, uint32 dosmode)
 }
 
 /*************************************************************************
- 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, 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;
+       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;
        }
@@ -1393,26 +1493,40 @@ 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->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, 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_list *dtl;
 
-       /* Copy the new token (can be NULL). */
-       lck->delete_token = copy_unix_token(lck, tok);
-       lck->modified = True;
+       dtl = TALLOC_ZERO_P(lck, struct delete_token_list);
+       if (dtl == NULL) {
+               return false;
+       }
+
+       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;
 }
 
 /****************************************************************************
@@ -1422,26 +1536,54 @@ 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.
- 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, 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);
+       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, const 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,
@@ -1453,11 +1595,13 @@ bool set_delete_on_close(files_struct *fsp, bool delete_on_close, const UNIX_USE
                return False;
        }
 
-       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) {
                SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
-               send_stat_cache_delete_message(fsp->fsp_name->base_name);
+               send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
+                                              fsp->fsp_name->base_name);
        }
 
        TALLOC_FREE(lck);
@@ -1467,6 +1611,28 @@ bool set_delete_on_close(files_struct *fsp, bool delete_on_close, const UNIX_USE
        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;
@@ -1529,6 +1695,8 @@ static int traverse_fn(struct db_record *rec, void *_state)
        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. */
@@ -1537,12 +1705,22 @@ static int traverse_fn(struct db_record *rec, void *_state)
 
        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;
+               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++) {