2 Unix SMB/CIFS implementation.
4 Copyright (C) Andrew Tridgell 1992-2000
5 Copyright (C) Jeremy Allison 1992-2006
6 Copyright (C) Volker Lendecke 2005
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 12 aug 96: Erik.Devriendt@te6.siemens.be
24 added support for shared memory implementation of share mode locking
26 May 1997. Jeremy Allison (jallison@whistle.com). Modified share mode
27 locking to deal with multiple share modes per open file.
29 September 1997. Jeremy Allison (jallison@whistle.com). Added oplock
32 rewritten completely to use new tdb code. Tridge, Dec '99
34 Added POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
35 Added Unix Extensions POSIX locking support. Jeremy Allison Mar 2006.
39 #include "system/filesys.h"
40 #include "lib/util/server_id.h"
41 #include "locking/proto.h"
42 #include "smbd/globals.h"
43 #include "dbwrap/dbwrap.h"
44 #include "dbwrap/dbwrap_open.h"
45 #include "../libcli/security/security.h"
49 #include "../librpc/gen_ndr/ndr_open_files.h"
50 #include "librpc/gen_ndr/ndr_file_id.h"
51 #include "locking/leases_db.h"
54 #define DBGC_CLASS DBGC_LOCKING
56 #define NO_LOCKING_COUNT (-1)
58 /****************************************************************************
60 ****************************************************************************/
62 const char *lock_type_name(enum brl_type lock_type)
69 case PENDING_READ_LOCK:
70 return "PENDING_READ";
71 case PENDING_WRITE_LOCK:
72 return "PENDING_WRITE";
78 const char *lock_flav_name(enum brl_flavour lock_flav)
80 return (lock_flav == WINDOWS_LOCK) ? "WINDOWS_LOCK" : "POSIX_LOCK";
83 /****************************************************************************
84 Utility function called to see if a file region is locked.
85 Called in the read/write codepath.
86 ****************************************************************************/
88 void init_strict_lock_struct(files_struct *fsp,
92 enum brl_type lock_type,
93 struct lock_struct *plock)
95 SMB_ASSERT(lock_type == READ_LOCK || lock_type == WRITE_LOCK);
97 plock->context.smblctx = smblctx;
98 plock->context.tid = fsp->conn->cnum;
99 plock->context.pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
100 plock->start = start;
102 plock->fnum = fsp->fnum;
103 plock->lock_type = lock_type;
104 plock->lock_flav = lp_posix_cifsu_locktype(fsp);
107 bool strict_lock_check_default(files_struct *fsp, struct lock_struct *plock)
109 struct byte_range_lock *br_lck;
110 int strict_locking = lp_strict_locking(fsp->conn->params);
113 if (plock->size == 0) {
117 if (!lp_locking(fsp->conn->params) || !strict_locking) {
121 if (strict_locking == Auto) {
122 uint32_t lease_type = fsp_lease_type(fsp);
124 if ((lease_type & SMB2_LEASE_READ) &&
125 (plock->lock_type == READ_LOCK))
127 DBG_DEBUG("optimisation - read lease on file %s\n",
132 if ((lease_type & SMB2_LEASE_WRITE) &&
133 (plock->lock_type == WRITE_LOCK))
135 DBG_DEBUG("optimisation - write lease on file %s\n",
141 br_lck = brl_get_locks_readonly(fsp);
145 ret = brl_locktest(br_lck, plock);
149 * We got a lock conflict. Retry with rw locks to enable
150 * autocleanup. This is the slow path anyway.
152 br_lck = brl_get_locks(talloc_tos(), fsp);
153 if (br_lck == NULL) {
156 ret = brl_locktest(br_lck, plock);
160 DEBUG(10, ("strict_lock_default: flavour = %s brl start=%ju "
161 "len=%ju %s for fnum %ju file %s\n",
162 lock_flav_name(plock->lock_flav),
163 (uintmax_t)plock->start, (uintmax_t)plock->size,
164 ret ? "unlocked" : "locked",
165 (uintmax_t)plock->fnum, fsp_str_dbg(fsp)));
170 /****************************************************************************
171 Find out if a lock could be granted - return who is blocking us if we can't.
172 ****************************************************************************/
174 NTSTATUS query_lock(files_struct *fsp,
178 enum brl_type *plock_type,
179 enum brl_flavour lock_flav)
181 struct byte_range_lock *br_lck = NULL;
183 if (!fsp->can_lock) {
184 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
187 if (!lp_locking(fsp->conn->params)) {
191 br_lck = brl_get_locks_readonly(fsp);
193 return NT_STATUS_NO_MEMORY;
196 return brl_lockquery(br_lck,
198 messaging_server_id(fsp->conn->sconn->msg_ctx),
205 static void increment_current_lock_count(files_struct *fsp,
206 enum brl_flavour lock_flav)
208 if (lock_flav == WINDOWS_LOCK &&
209 fsp->current_lock_count != NO_LOCKING_COUNT) {
210 /* blocking ie. pending, locks also count here,
211 * as this is an efficiency counter to avoid checking
212 * the lock db. on close. JRA. */
214 fsp->current_lock_count++;
216 /* Notice that this has had a POSIX lock request.
217 * We can't count locks after this so forget them.
219 fsp->current_lock_count = NO_LOCKING_COUNT;
223 static void decrement_current_lock_count(files_struct *fsp,
224 enum brl_flavour lock_flav)
226 if (lock_flav == WINDOWS_LOCK &&
227 fsp->current_lock_count != NO_LOCKING_COUNT) {
228 SMB_ASSERT(fsp->current_lock_count > 0);
229 fsp->current_lock_count--;
233 /****************************************************************************
234 Utility function called by locking requests.
235 ****************************************************************************/
237 struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
242 enum brl_type lock_type,
243 enum brl_flavour lock_flav,
248 struct byte_range_lock *br_lck = NULL;
250 /* silently return ok on print files as we don't do locking there */
251 if (fsp->print_file) {
252 *perr = NT_STATUS_OK;
256 if (!fsp->can_lock) {
257 *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
261 if (!lp_locking(fsp->conn->params)) {
262 *perr = NT_STATUS_OK;
266 /* NOTE! 0 byte long ranges ARE allowed and should be stored */
268 DEBUG(10,("do_lock: lock flavour %s lock type %s start=%ju len=%ju "
269 "blocking_lock=%s requested for %s file %s\n",
270 lock_flav_name(lock_flav), lock_type_name(lock_type),
271 (uintmax_t)offset, (uintmax_t)count, blocking_lock ? "true" :
272 "false", fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
274 br_lck = brl_get_locks(talloc_tos(), fsp);
276 *perr = NT_STATUS_NO_MEMORY;
280 *perr = brl_lock(msg_ctx,
283 messaging_server_id(fsp->conn->sconn->msg_ctx),
291 DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
293 increment_current_lock_count(fsp, lock_flav);
297 /****************************************************************************
298 Utility function called by unlocking requests.
299 ****************************************************************************/
301 NTSTATUS do_unlock(struct messaging_context *msg_ctx,
306 enum brl_flavour lock_flav)
309 struct byte_range_lock *br_lck = NULL;
311 if (!fsp->can_lock) {
312 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
315 if (!lp_locking(fsp->conn->params)) {
319 DEBUG(10, ("do_unlock: unlock start=%ju len=%ju requested for %s file "
320 "%s\n", (uintmax_t)offset, (uintmax_t)count,
321 fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
323 br_lck = brl_get_locks(talloc_tos(), fsp);
325 return NT_STATUS_NO_MEMORY;
328 ok = brl_unlock(msg_ctx,
331 messaging_server_id(fsp->conn->sconn->msg_ctx),
339 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
340 return NT_STATUS_RANGE_NOT_LOCKED;
343 decrement_current_lock_count(fsp, lock_flav);
347 /****************************************************************************
348 Cancel any pending blocked locks.
349 ****************************************************************************/
351 NTSTATUS do_lock_cancel(files_struct *fsp,
355 enum brl_flavour lock_flav)
358 struct byte_range_lock *br_lck = NULL;
360 if (!fsp->can_lock) {
361 return fsp->is_directory ?
362 NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
365 if (!lp_locking(fsp->conn->params)) {
366 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
369 DEBUG(10, ("do_lock_cancel: cancel start=%ju len=%ju requested for "
370 "%s file %s\n", (uintmax_t)offset, (uintmax_t)count,
371 fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
373 br_lck = brl_get_locks(talloc_tos(), fsp);
375 return NT_STATUS_NO_MEMORY;
378 ok = brl_lock_cancel(br_lck,
380 messaging_server_id(fsp->conn->sconn->msg_ctx),
388 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
389 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
392 decrement_current_lock_count(fsp, lock_flav);
396 /****************************************************************************
397 Remove any locks on this fd. Called from file_close().
398 ****************************************************************************/
400 void locking_close_file(struct messaging_context *msg_ctx,
402 enum file_close_type close_type)
404 struct byte_range_lock *br_lck;
406 if (!lp_locking(fsp->conn->params)) {
410 /* If we have no outstanding locks or pending
411 * locks then we don't need to look in the lock db.
414 if (fsp->current_lock_count == 0) {
418 br_lck = brl_get_locks(talloc_tos(),fsp);
421 cancel_pending_lock_requests_by_fid(fsp, br_lck, close_type);
422 brl_close_fnum(msg_ctx, br_lck);
427 /*******************************************************************
428 Print out a share mode.
429 ********************************************************************/
431 char *share_mode_str(TALLOC_CTX *ctx, int num,
432 const struct file_id *id,
433 const struct share_mode_entry *e)
435 struct server_id_buf tmp;
437 return talloc_asprintf(ctx, "share_mode_entry[%d]: "
438 "pid = %s, share_access = 0x%x, private_options = 0x%x, "
439 "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %llu, "
440 "uid = %u, flags = %u, file_id %s, name_hash = 0x%x",
442 server_id_str_buf(e->pid, &tmp),
443 e->share_access, e->private_options,
444 e->access_mask, (unsigned long long)e->op_mid,
445 e->op_type, (unsigned long long)e->share_file_id,
446 (unsigned int)e->uid, (unsigned int)e->flags,
447 file_id_string_tos(id),
448 (unsigned int)e->name_hash);
451 /*******************************************************************
452 Fetch a share mode where we know one MUST exist. This call reference
453 counts it internally to allow for nested lock fetches.
454 ********************************************************************/
456 struct share_mode_lock *get_existing_share_mode_lock(TALLOC_CTX *mem_ctx,
457 const struct file_id id)
459 return get_share_mode_lock(mem_ctx, id, NULL, NULL, NULL);
462 /*******************************************************************
463 Sets the service name and filename for rename.
464 At this point we emit "file renamed" messages to all
465 process id's that have this file open.
466 Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
467 ********************************************************************/
469 bool rename_share_filename(struct messaging_context *msg_ctx,
470 struct share_mode_lock *lck,
472 const char *servicepath,
473 uint32_t orig_name_hash,
474 uint32_t new_name_hash,
475 const struct smb_filename *smb_fname_dst)
477 struct share_mode_data *d = lck->data;
484 bool strip_two_chars = false;
485 bool has_stream = smb_fname_dst->stream_name != NULL;
486 struct server_id self_pid = messaging_server_id(msg_ctx);
488 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
489 servicepath, smb_fname_dst->base_name));
492 * rename_internal_fsp() and rename_internals() add './' to
493 * head of newname if newname does not contain a '/'.
495 if (smb_fname_dst->base_name[0] &&
496 smb_fname_dst->base_name[1] &&
497 smb_fname_dst->base_name[0] == '.' &&
498 smb_fname_dst->base_name[1] == '/') {
499 strip_two_chars = true;
502 d->servicepath = talloc_strdup(d, servicepath);
503 d->base_name = talloc_strdup(d, smb_fname_dst->base_name +
504 (strip_two_chars ? 2 : 0));
505 d->stream_name = talloc_strdup(d, smb_fname_dst->stream_name);
506 if (d->base_name == NULL ||
507 (has_stream && d->stream_name == NULL) ||
508 d->servicepath == NULL) {
509 DEBUG(0, ("rename_share_filename: talloc failed\n"));
514 sp_len = strlen(d->servicepath);
515 bn_len = strlen(d->base_name);
516 sn_len = has_stream ? strlen(d->stream_name) : 0;
518 msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
521 /* Set up the name changed message. */
522 frm = talloc_array(d, char, msg_len);
527 push_file_id_24(frm, &id);
529 DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
532 d->servicepath ? d->servicepath : "",
534 strlcpy(&frm[24 + sp_len + 1],
535 d->base_name ? d->base_name : "",
537 strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
538 d->stream_name ? d->stream_name : "",
541 /* Send the messages. */
542 for (i=0; i<d->num_share_modes; i++) {
543 struct share_mode_entry *se = &d->share_modes[i];
544 struct server_id_buf tmp;
546 if (!is_valid_share_mode_entry(se)) {
550 /* If this is a hardlink to the inode
551 with a different name, skip this. */
552 if (se->name_hash != orig_name_hash) {
556 se->name_hash = new_name_hash;
558 /* But not to ourselves... */
559 if (serverid_equal(&se->pid, &self_pid)) {
563 if (share_mode_stale_pid(d, i)) {
567 DEBUG(10,("rename_share_filename: sending rename message to "
568 "pid %s file_id %s sharepath %s base_name %s "
570 server_id_str_buf(se->pid, &tmp),
571 file_id_string_tos(&id),
572 d->servicepath, d->base_name,
573 has_stream ? d->stream_name : ""));
575 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
576 (uint8_t *)frm, msg_len);
579 for (i=0; i<d->num_leases; i++) {
580 /* Update the filename in leases_db. */
582 struct share_mode_lease *l;
586 status = leases_db_rename(&l->client_guid,
592 if (!NT_STATUS_IS_OK(status)) {
593 /* Any error recovery possible here ? */
594 DEBUG(1,("Failed to rename lease key for "
595 "renamed file %s:%s. %s\n",
606 void get_file_infos(struct file_id id,
608 bool *delete_on_close,
609 struct timespec *write_time)
611 struct share_mode_lock *lck;
613 if (delete_on_close) {
614 *delete_on_close = false;
618 ZERO_STRUCTP(write_time);
621 if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
625 if (delete_on_close) {
626 *delete_on_close = is_delete_on_close_set(lck, name_hash);
630 *write_time = get_share_mode_write_time(lck);
636 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
644 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
645 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
646 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
647 num_props += (e->op_type == LEASE_OPLOCK);
649 if ((num_props > 1) && serverid_exists(&e->pid)) {
650 smb_panic("Invalid share mode entry");
652 return (num_props != 0);
656 * See if we need to remove a lease being referred to by a
657 * share mode that is being marked stale or deleted.
660 static void remove_share_mode_lease(struct share_mode_data *d,
661 struct share_mode_entry *e)
667 op_type = e->op_type;
668 e->op_type = NO_OPLOCK;
672 if (op_type != LEASE_OPLOCK) {
677 * This used to reference a lease. If there's no other one referencing
681 lease_idx = e->lease_idx;
682 e->lease_idx = UINT32_MAX;
684 for (i=0; i<d->num_share_modes; i++) {
685 struct share_mode_entry *e2 = &d->share_modes[i];
694 if (smb2_lease_equal(&e->client_guid,
701 if (i < d->num_share_modes) {
709 d->leases[lease_idx] = d->leases[d->num_leases];
712 * We changed the lease array. Fix all references to it.
714 for (i=0; i<d->num_share_modes; i++) {
715 if (d->share_modes[i].lease_idx == d->num_leases) {
716 d->share_modes[i].lease_idx = lease_idx;
723 status = leases_db_del(&e->client_guid,
727 DEBUG(10, ("%s: leases_db_del returned %s\n", __func__,
733 * In case d->share_modes[i] conflicts with something or otherwise is
734 * being used, we need to make sure the corresponding process still
737 bool share_mode_stale_pid(struct share_mode_data *d, uint32_t idx)
739 struct server_id_buf tmp;
740 struct share_mode_entry *e;
742 if (idx > d->num_share_modes) {
743 DBG_WARNING("Asking for index %"PRIu32", "
744 "only %"PRIu32" around\n",
749 e = &d->share_modes[idx];
756 if (serverid_exists(&e->pid)) {
757 DBG_DEBUG("PID %s (index %"PRIu32" out of %"PRIu32") "
759 server_id_str_buf(e->pid, &tmp),
764 DBG_DEBUG("PID %s (index %"PRIu32" out of %"PRIu32") "
765 "does not exist anymore\n",
766 server_id_str_buf(e->pid, &tmp),
772 if (d->num_delete_tokens != 0) {
775 for (i=0; i<d->num_share_modes; i++) {
776 bool valid = !d->share_modes[i].stale;
782 if (i == d->num_share_modes) {
784 * No valid (non-stale) share mode found, all
785 * who might have set the delete token are
788 TALLOC_FREE(d->delete_tokens);
789 d->num_delete_tokens = 0;
793 remove_share_mode_lease(d, e);
799 void remove_stale_share_mode_entries(struct share_mode_data *d)
804 while (i < d->num_share_modes) {
805 if (d->share_modes[i].stale) {
806 struct share_mode_entry *m = d->share_modes;
807 m[i] = m[d->num_share_modes-1];
808 d->num_share_modes -= 1;
815 bool set_share_mode(struct share_mode_lock *lck,
816 struct files_struct *fsp,
820 const struct GUID *client_guid,
821 const struct smb2_lease_key *lease_key)
823 struct share_mode_data *d = lck->data;
824 struct share_mode_entry *tmp, *e;
826 tmp = talloc_realloc(d, d->share_modes, struct share_mode_entry,
827 d->num_share_modes+1);
831 d->share_modes = tmp;
832 e = &d->share_modes[d->num_share_modes];
833 d->num_share_modes += 1;
837 e->pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
838 e->share_access = fsp->share_access;
839 e->private_options = fsp->fh->private_options;
840 e->access_mask = fsp->access_mask;
842 e->op_type = op_type;
844 if (op_type == LEASE_OPLOCK) {
847 e->client_guid = *client_guid;
848 e->lease_key = *lease_key;
851 * Need to set lease_idx. This is essentially
852 * find_share_mode_lease(), but that will go away
853 * soon. So don't add the dependency here.
856 for (i=0; i<d->num_leases; i++) {
857 struct share_mode_lease *l = &d->leases[i];
859 if (smb2_lease_equal(client_guid,
867 if (i == d->num_leases) {
868 DBG_WARNING("lease not found\n");
869 d->num_share_modes -= 1;
875 e->lease_idx = UINT32_MAX;
878 e->time.tv_sec = fsp->open_time.tv_sec;
879 e->time.tv_usec = fsp->open_time.tv_usec;
880 e->share_file_id = fsp->fh->gen_id;
881 e->uid = (uint32_t)uid;
882 e->flags = (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) ?
883 SHARE_MODE_FLAG_POSIX_OPEN : 0;
884 e->name_hash = fsp->name_hash;
889 struct share_mode_entry *find_share_mode_entry(
890 struct share_mode_lock *lck, files_struct *fsp)
892 struct share_mode_data *d = lck->data;
893 struct server_id pid;
896 pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
898 for (i=0; i<d->num_share_modes; i++) {
899 struct share_mode_entry *e = &d->share_modes[i];
901 if (!is_valid_share_mode_entry(e)) {
904 if (!serverid_equal(&pid, &e->pid)) {
907 if (fsp->fh->gen_id != e->share_file_id) {
915 /*******************************************************************
916 Del the share mode of a file for this process.
917 ********************************************************************/
919 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
921 struct share_mode_entry *e;
923 e = find_share_mode_entry(lck, fsp);
927 remove_share_mode_lease(lck->data, e);
928 *e = lck->data->share_modes[lck->data->num_share_modes-1];
929 lck->data->num_share_modes -= 1;
930 lck->data->modified = True;
934 bool mark_share_mode_disconnected(struct share_mode_lock *lck,
935 struct files_struct *fsp)
937 struct share_mode_entry *e;
939 if (lck->data->num_share_modes != 1) {
943 if (fsp->op == NULL) {
946 if (!fsp->op->global->durable) {
950 e = find_share_mode_entry(lck, fsp);
955 DEBUG(10, ("Marking share mode entry disconnected for durable handle\n"));
957 server_id_set_disconnected(&e->pid);
960 * On reopen the caller needs to check that
961 * the client comes with the correct handle.
963 e->share_file_id = fsp->op->global->open_persistent_id;
965 lck->data->modified = true;
969 /*******************************************************************
970 Remove an oplock mid and mode entry from a share mode.
971 ********************************************************************/
973 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
975 struct share_mode_data *d = lck->data;
976 struct share_mode_entry *e;
978 e = find_share_mode_entry(lck, fsp);
983 remove_share_mode_lease(d, e);
988 /*******************************************************************
989 Downgrade a oplock type from exclusive to level II.
990 ********************************************************************/
992 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
994 struct share_mode_entry *e;
996 e = find_share_mode_entry(lck, fsp);
1001 e->op_type = LEVEL_II_OPLOCK;
1002 lck->data->modified = True;
1006 /****************************************************************************
1007 Adds a delete on close token.
1008 ****************************************************************************/
1010 static bool add_delete_on_close_token(struct share_mode_data *d,
1012 const struct security_token *nt_tok,
1013 const struct security_unix_token *tok)
1015 struct delete_token *tmp, *dtl;
1017 tmp = talloc_realloc(d, d->delete_tokens, struct delete_token,
1018 d->num_delete_tokens+1);
1022 d->delete_tokens = tmp;
1023 dtl = &d->delete_tokens[d->num_delete_tokens];
1025 dtl->name_hash = name_hash;
1026 dtl->delete_nt_token = dup_nt_token(d->delete_tokens, nt_tok);
1027 if (dtl->delete_nt_token == NULL) {
1030 dtl->delete_token = copy_unix_token(d->delete_tokens, tok);
1031 if (dtl->delete_token == NULL) {
1034 d->num_delete_tokens += 1;
1039 void reset_delete_on_close_lck(files_struct *fsp,
1040 struct share_mode_lock *lck)
1042 struct share_mode_data *d = lck->data;
1045 for (i=0; i<d->num_delete_tokens; i++) {
1046 struct delete_token *dt = &d->delete_tokens[i];
1048 if (dt->name_hash == fsp->name_hash) {
1051 /* Delete this entry. */
1052 TALLOC_FREE(dt->delete_nt_token);
1053 TALLOC_FREE(dt->delete_token);
1054 *dt = d->delete_tokens[d->num_delete_tokens-1];
1055 d->num_delete_tokens -= 1;
1060 /****************************************************************************
1061 Sets the delete on close flag over all share modes on this file.
1062 Modify the share mode entry for all files open
1063 on this device and inode to tell other smbds we have
1064 changed the delete on close flag. This will be noticed
1065 in the close code, the last closer will delete the file
1067 This makes a copy of any struct security_unix_token into the
1068 lck entry. This function is used when the lock is already granted.
1069 ****************************************************************************/
1071 void set_delete_on_close_lck(files_struct *fsp,
1072 struct share_mode_lock *lck,
1073 const struct security_token *nt_tok,
1074 const struct security_unix_token *tok)
1076 struct messaging_context *msg_ctx = fsp->conn->sconn->msg_ctx;
1077 struct share_mode_data *d = lck->data;
1080 DATA_BLOB fid_blob = {};
1081 enum ndr_err_code ndr_err;
1083 SMB_ASSERT(nt_tok != NULL);
1084 SMB_ASSERT(tok != NULL);
1086 for (i=0; i<d->num_delete_tokens; i++) {
1087 struct delete_token *dt = &d->delete_tokens[i];
1088 if (dt->name_hash == fsp->name_hash) {
1091 /* Replace this token with the given tok. */
1092 TALLOC_FREE(dt->delete_nt_token);
1093 dt->delete_nt_token = dup_nt_token(dt, nt_tok);
1094 SMB_ASSERT(dt->delete_nt_token != NULL);
1095 TALLOC_FREE(dt->delete_token);
1096 dt->delete_token = copy_unix_token(dt, tok);
1097 SMB_ASSERT(dt->delete_token != NULL);
1103 ret = add_delete_on_close_token(lck->data, fsp->name_hash, nt_tok, tok);
1106 ndr_err = ndr_push_struct_blob(&fid_blob, talloc_tos(), &fsp->file_id,
1107 (ndr_push_flags_fn_t)ndr_push_file_id);
1108 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1109 DEBUG(10, ("ndr_push_file_id failed: %s\n",
1110 ndr_errstr(ndr_err)));
1113 for (i=0; i<d->num_share_modes; i++) {
1114 struct share_mode_entry *e = &d->share_modes[i];
1117 status = messaging_send(
1118 msg_ctx, e->pid, MSG_SMB_NOTIFY_CANCEL_DELETED,
1121 if (!NT_STATUS_IS_OK(status)) {
1122 struct server_id_buf tmp;
1123 DEBUG(10, ("%s: messaging_send to %s returned %s\n",
1124 __func__, server_id_str_buf(e->pid, &tmp),
1125 nt_errstr(status)));
1129 TALLOC_FREE(fid_blob.data);
1132 bool set_delete_on_close(files_struct *fsp, bool delete_on_close,
1133 const struct security_token *nt_tok,
1134 const struct security_unix_token *tok)
1136 struct share_mode_lock *lck;
1138 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1140 delete_on_close ? "Adding" : "Removing", fsp_fnum_dbg(fsp),
1143 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1148 if (delete_on_close) {
1149 set_delete_on_close_lck(fsp, lck, nt_tok, tok);
1151 reset_delete_on_close_lck(fsp, lck);
1154 if (fsp->is_directory) {
1155 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1156 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1157 fsp->fsp_name->base_name);
1162 fsp->delete_on_close = delete_on_close;
1167 static struct delete_token *find_delete_on_close_token(
1168 struct share_mode_data *d, uint32_t name_hash)
1172 DEBUG(10, ("find_delete_on_close_token: name_hash = 0x%x\n",
1173 (unsigned int)name_hash));
1175 for (i=0; i<d->num_delete_tokens; i++) {
1176 struct delete_token *dt = &d->delete_tokens[i];
1178 DEBUG(10, ("find__delete_on_close_token: dt->name_hash = 0x%x\n",
1179 (unsigned int)dt->name_hash ));
1180 if (dt->name_hash == name_hash) {
1187 /****************************************************************************
1188 Return the NT token and UNIX token if there's a match. Return true if
1189 found, false if not.
1190 ****************************************************************************/
1192 bool get_delete_on_close_token(struct share_mode_lock *lck,
1194 const struct security_token **pp_nt_tok,
1195 const struct security_unix_token **pp_tok)
1197 struct delete_token *dt;
1199 dt = find_delete_on_close_token(lck->data, name_hash);
1203 *pp_nt_tok = dt->delete_nt_token;
1204 *pp_tok = dt->delete_token;
1208 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
1210 return find_delete_on_close_token(lck->data, name_hash) != NULL;
1213 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1215 struct share_mode_lock *lck;
1217 DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1218 timestring(talloc_tos(),
1219 convert_timespec_to_time_t(write_time)),
1220 file_id_string_tos(&fileid)));
1222 lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1227 if (timespec_compare(&lck->data->changed_write_time, &write_time) != 0) {
1228 lck->data->modified = True;
1229 lck->data->changed_write_time = write_time;
1236 bool set_write_time(struct file_id fileid, struct timespec write_time)
1238 struct share_mode_lock *lck;
1240 DEBUG(5,("set_write_time: %s id=%s\n",
1241 timestring(talloc_tos(),
1242 convert_timespec_to_time_t(write_time)),
1243 file_id_string_tos(&fileid)));
1245 lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1250 if (timespec_compare(&lck->data->old_write_time, &write_time) != 0) {
1251 lck->data->modified = True;
1252 lck->data->old_write_time = write_time;
1259 struct timespec get_share_mode_write_time(struct share_mode_lock *lck)
1261 struct share_mode_data *d = lck->data;
1263 if (!null_timespec(d->changed_write_time)) {
1264 return d->changed_write_time;
1266 return d->old_write_time;
1269 bool file_has_open_streams(files_struct *fsp)
1271 struct share_mode_lock *lock = NULL;
1272 struct share_mode_data *d = NULL;
1275 lock = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1281 for (i = 0; i < d->num_share_modes; i++) {
1282 struct share_mode_entry *e = &d->share_modes[i];
1284 if (share_mode_stale_pid(d, i)) {
1288 if (e->private_options &
1289 NTCREATEX_OPTIONS_PRIVATE_STREAM_BASEOPEN)