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 ret = brl_locktest(br_lck, plock);
157 DEBUG(10, ("strict_lock_default: flavour = %s brl start=%ju "
158 "len=%ju %s for fnum %ju file %s\n",
159 lock_flav_name(plock->lock_flav),
160 (uintmax_t)plock->start, (uintmax_t)plock->size,
161 ret ? "unlocked" : "locked",
162 (uintmax_t)plock->fnum, fsp_str_dbg(fsp)));
167 /****************************************************************************
168 Find out if a lock could be granted - return who is blocking us if we can't.
169 ****************************************************************************/
171 NTSTATUS query_lock(files_struct *fsp,
175 enum brl_type *plock_type,
176 enum brl_flavour lock_flav)
178 struct byte_range_lock *br_lck = NULL;
180 if (!fsp->can_lock) {
181 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
184 if (!lp_locking(fsp->conn->params)) {
188 br_lck = brl_get_locks_readonly(fsp);
190 return NT_STATUS_NO_MEMORY;
193 return brl_lockquery(br_lck,
195 messaging_server_id(fsp->conn->sconn->msg_ctx),
202 static void increment_current_lock_count(files_struct *fsp,
203 enum brl_flavour lock_flav)
205 if (lock_flav == WINDOWS_LOCK &&
206 fsp->current_lock_count != NO_LOCKING_COUNT) {
207 /* blocking ie. pending, locks also count here,
208 * as this is an efficiency counter to avoid checking
209 * the lock db. on close. JRA. */
211 fsp->current_lock_count++;
213 /* Notice that this has had a POSIX lock request.
214 * We can't count locks after this so forget them.
216 fsp->current_lock_count = NO_LOCKING_COUNT;
220 static void decrement_current_lock_count(files_struct *fsp,
221 enum brl_flavour lock_flav)
223 if (lock_flav == WINDOWS_LOCK &&
224 fsp->current_lock_count != NO_LOCKING_COUNT) {
225 SMB_ASSERT(fsp->current_lock_count > 0);
226 fsp->current_lock_count--;
230 /****************************************************************************
231 Utility function called by locking requests.
232 ****************************************************************************/
234 struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
239 enum brl_type lock_type,
240 enum brl_flavour lock_flav,
245 struct byte_range_lock *br_lck = NULL;
247 /* silently return ok on print files as we don't do locking there */
248 if (fsp->print_file) {
249 *perr = NT_STATUS_OK;
253 if (!fsp->can_lock) {
254 *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
258 if (!lp_locking(fsp->conn->params)) {
259 *perr = NT_STATUS_OK;
263 /* NOTE! 0 byte long ranges ARE allowed and should be stored */
265 DEBUG(10,("do_lock: lock flavour %s lock type %s start=%ju len=%ju "
266 "blocking_lock=%s requested for %s file %s\n",
267 lock_flav_name(lock_flav), lock_type_name(lock_type),
268 (uintmax_t)offset, (uintmax_t)count, blocking_lock ? "true" :
269 "false", fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
271 br_lck = brl_get_locks(talloc_tos(), fsp);
273 *perr = NT_STATUS_NO_MEMORY;
277 *perr = brl_lock(msg_ctx,
280 messaging_server_id(fsp->conn->sconn->msg_ctx),
288 DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
290 increment_current_lock_count(fsp, lock_flav);
294 /****************************************************************************
295 Utility function called by unlocking requests.
296 ****************************************************************************/
298 NTSTATUS do_unlock(struct messaging_context *msg_ctx,
303 enum brl_flavour lock_flav)
306 struct byte_range_lock *br_lck = NULL;
308 if (!fsp->can_lock) {
309 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
312 if (!lp_locking(fsp->conn->params)) {
316 DEBUG(10, ("do_unlock: unlock start=%ju len=%ju requested for %s file "
317 "%s\n", (uintmax_t)offset, (uintmax_t)count,
318 fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
320 br_lck = brl_get_locks(talloc_tos(), fsp);
322 return NT_STATUS_NO_MEMORY;
325 ok = brl_unlock(msg_ctx,
328 messaging_server_id(fsp->conn->sconn->msg_ctx),
336 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
337 return NT_STATUS_RANGE_NOT_LOCKED;
340 decrement_current_lock_count(fsp, lock_flav);
344 /****************************************************************************
345 Cancel any pending blocked locks.
346 ****************************************************************************/
348 NTSTATUS do_lock_cancel(files_struct *fsp,
352 enum brl_flavour lock_flav)
355 struct byte_range_lock *br_lck = NULL;
357 if (!fsp->can_lock) {
358 return fsp->is_directory ?
359 NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
362 if (!lp_locking(fsp->conn->params)) {
363 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
366 DEBUG(10, ("do_lock_cancel: cancel start=%ju len=%ju requested for "
367 "%s file %s\n", (uintmax_t)offset, (uintmax_t)count,
368 fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
370 br_lck = brl_get_locks(talloc_tos(), fsp);
372 return NT_STATUS_NO_MEMORY;
375 ok = brl_lock_cancel(br_lck,
377 messaging_server_id(fsp->conn->sconn->msg_ctx),
385 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
386 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
389 decrement_current_lock_count(fsp, lock_flav);
393 /****************************************************************************
394 Remove any locks on this fd. Called from file_close().
395 ****************************************************************************/
397 void locking_close_file(struct messaging_context *msg_ctx,
399 enum file_close_type close_type)
401 struct byte_range_lock *br_lck;
403 if (!lp_locking(fsp->conn->params)) {
407 /* If we have no outstanding locks or pending
408 * locks then we don't need to look in the lock db.
411 if (fsp->current_lock_count == 0) {
415 br_lck = brl_get_locks(talloc_tos(),fsp);
418 cancel_pending_lock_requests_by_fid(fsp, br_lck, close_type);
419 brl_close_fnum(msg_ctx, br_lck);
424 /*******************************************************************
425 Print out a share mode.
426 ********************************************************************/
428 char *share_mode_str(TALLOC_CTX *ctx, int num,
429 const struct file_id *id,
430 const struct share_mode_entry *e)
432 struct server_id_buf tmp;
434 return talloc_asprintf(ctx, "share_mode_entry[%d]: "
435 "pid = %s, share_access = 0x%x, private_options = 0x%x, "
436 "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %llu, "
437 "uid = %u, flags = %u, file_id %s, name_hash = 0x%x",
439 server_id_str_buf(e->pid, &tmp),
440 e->share_access, e->private_options,
441 e->access_mask, (unsigned long long)e->op_mid,
442 e->op_type, (unsigned long long)e->share_file_id,
443 (unsigned int)e->uid, (unsigned int)e->flags,
444 file_id_string_tos(id),
445 (unsigned int)e->name_hash);
448 /*******************************************************************
449 Fetch a share mode where we know one MUST exist. This call reference
450 counts it internally to allow for nested lock fetches.
451 ********************************************************************/
453 struct share_mode_lock *get_existing_share_mode_lock(TALLOC_CTX *mem_ctx,
454 const struct file_id id)
456 return get_share_mode_lock(mem_ctx, id, NULL, NULL, NULL);
459 /*******************************************************************
460 Sets the service name and filename for rename.
461 At this point we emit "file renamed" messages to all
462 process id's that have this file open.
463 Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
464 ********************************************************************/
466 bool rename_share_filename(struct messaging_context *msg_ctx,
467 struct share_mode_lock *lck,
469 const char *servicepath,
470 uint32_t orig_name_hash,
471 uint32_t new_name_hash,
472 const struct smb_filename *smb_fname_dst)
474 struct share_mode_data *d = lck->data;
481 bool strip_two_chars = false;
482 bool has_stream = smb_fname_dst->stream_name != NULL;
483 struct server_id self_pid = messaging_server_id(msg_ctx);
485 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
486 servicepath, smb_fname_dst->base_name));
489 * rename_internal_fsp() and rename_internals() add './' to
490 * head of newname if newname does not contain a '/'.
492 if (smb_fname_dst->base_name[0] &&
493 smb_fname_dst->base_name[1] &&
494 smb_fname_dst->base_name[0] == '.' &&
495 smb_fname_dst->base_name[1] == '/') {
496 strip_two_chars = true;
499 d->servicepath = talloc_strdup(d, servicepath);
500 d->base_name = talloc_strdup(d, smb_fname_dst->base_name +
501 (strip_two_chars ? 2 : 0));
502 d->stream_name = talloc_strdup(d, smb_fname_dst->stream_name);
503 if (d->base_name == NULL ||
504 (has_stream && d->stream_name == NULL) ||
505 d->servicepath == NULL) {
506 DEBUG(0, ("rename_share_filename: talloc failed\n"));
511 sp_len = strlen(d->servicepath);
512 bn_len = strlen(d->base_name);
513 sn_len = has_stream ? strlen(d->stream_name) : 0;
515 msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
518 /* Set up the name changed message. */
519 frm = talloc_array(d, char, msg_len);
524 push_file_id_24(frm, &id);
526 DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
529 d->servicepath ? d->servicepath : "",
531 strlcpy(&frm[24 + sp_len + 1],
532 d->base_name ? d->base_name : "",
534 strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
535 d->stream_name ? d->stream_name : "",
538 /* Send the messages. */
539 for (i=0; i<d->num_share_modes; i++) {
540 struct share_mode_entry *se = &d->share_modes[i];
541 struct server_id_buf tmp;
543 if (!is_valid_share_mode_entry(se)) {
547 /* If this is a hardlink to the inode
548 with a different name, skip this. */
549 if (se->name_hash != orig_name_hash) {
553 se->name_hash = new_name_hash;
555 /* But not to ourselves... */
556 if (serverid_equal(&se->pid, &self_pid)) {
560 if (share_mode_stale_pid(d, i)) {
564 DEBUG(10,("rename_share_filename: sending rename message to "
565 "pid %s file_id %s sharepath %s base_name %s "
567 server_id_str_buf(se->pid, &tmp),
568 file_id_string_tos(&id),
569 d->servicepath, d->base_name,
570 has_stream ? d->stream_name : ""));
572 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
573 (uint8_t *)frm, msg_len);
576 for (i=0; i<d->num_leases; i++) {
577 /* Update the filename in leases_db. */
579 struct share_mode_lease *l;
583 status = leases_db_rename(&l->client_guid,
589 if (!NT_STATUS_IS_OK(status)) {
590 /* Any error recovery possible here ? */
591 DEBUG(1,("Failed to rename lease key for "
592 "renamed file %s:%s. %s\n",
603 void get_file_infos(struct file_id id,
605 bool *delete_on_close,
606 struct timespec *write_time)
608 struct share_mode_lock *lck;
610 if (delete_on_close) {
611 *delete_on_close = false;
615 ZERO_STRUCTP(write_time);
618 if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
622 if (delete_on_close) {
623 *delete_on_close = is_delete_on_close_set(lck, name_hash);
627 *write_time = get_share_mode_write_time(lck);
633 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
641 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
642 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
643 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
644 num_props += (e->op_type == LEASE_OPLOCK);
646 if ((num_props > 1) && serverid_exists(&e->pid)) {
647 smb_panic("Invalid share mode entry");
649 return (num_props != 0);
653 * See if we need to remove a lease being referred to by a
654 * share mode that is being marked stale or deleted.
657 static void remove_share_mode_lease(struct share_mode_data *d,
658 struct share_mode_entry *e)
660 struct GUID client_guid;
661 struct smb2_lease_key lease_key;
666 op_type = e->op_type;
667 e->op_type = NO_OPLOCK;
671 if (op_type != LEASE_OPLOCK) {
676 * This used to reference a lease. If there's no other one referencing
680 lease_idx = e->lease_idx;
681 e->lease_idx = UINT32_MAX;
683 for (i=0; i<d->num_share_modes; i++) {
684 if (d->share_modes[i].stale) {
687 if (e == &d->share_modes[i]) {
691 if (d->share_modes[i].lease_idx == lease_idx) {
695 if (i < d->num_share_modes) {
703 &d->leases[lease_idx].client_guid,
704 sizeof(client_guid));
705 lease_key = d->leases[lease_idx].lease_key;
708 d->leases[lease_idx] = d->leases[d->num_leases];
711 * We changed the lease array. Fix all references to it.
713 for (i=0; i<d->num_share_modes; i++) {
714 if (d->share_modes[i].lease_idx == d->num_leases) {
715 d->share_modes[i].lease_idx = lease_idx;
716 d->share_modes[i].lease = &d->leases[lease_idx];
723 status = leases_db_del(&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 DEBUG(1, ("Asking for index %u, only %u around\n",
744 idx, (unsigned)d->num_share_modes));
747 e = &d->share_modes[idx];
754 if (serverid_exists(&e->pid)) {
755 DEBUG(10, ("PID %s (index %u out of %u) still exists\n",
756 server_id_str_buf(e->pid, &tmp), idx,
757 (unsigned)d->num_share_modes));
760 DEBUG(10, ("PID %s (index %u out of %u) does not exist anymore\n",
761 server_id_str_buf(e->pid, &tmp), idx,
762 (unsigned)d->num_share_modes));
766 if (d->num_delete_tokens != 0) {
767 uint32_t i, num_stale;
770 * We cannot have any delete tokens
771 * if there are no valid share modes.
776 for (i=0; i<d->num_share_modes; i++) {
777 if (d->share_modes[i].stale) {
782 if (num_stale == d->num_share_modes) {
784 * No non-stale share mode found
786 TALLOC_FREE(d->delete_tokens);
787 d->num_delete_tokens = 0;
791 remove_share_mode_lease(d, e);
797 void remove_stale_share_mode_entries(struct share_mode_data *d)
802 while (i < d->num_share_modes) {
803 if (d->share_modes[i].stale) {
804 struct share_mode_entry *m = d->share_modes;
805 m[i] = m[d->num_share_modes-1];
806 d->num_share_modes -= 1;
813 bool set_share_mode(struct share_mode_lock *lck, struct files_struct *fsp,
814 uid_t uid, uint64_t mid, uint16_t op_type,
817 struct share_mode_data *d = lck->data;
818 struct share_mode_entry *tmp, *e;
819 struct share_mode_lease *lease = NULL;
821 if (lease_idx == UINT32_MAX) {
823 } else if (lease_idx >= d->num_leases) {
826 lease = &d->leases[lease_idx];
829 tmp = talloc_realloc(d, d->share_modes, struct share_mode_entry,
830 d->num_share_modes+1);
834 d->share_modes = tmp;
835 e = &d->share_modes[d->num_share_modes];
836 d->num_share_modes += 1;
840 e->pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
841 e->share_access = fsp->share_access;
842 e->private_options = fsp->fh->private_options;
843 e->access_mask = fsp->access_mask;
845 e->op_type = op_type;
846 e->lease_idx = lease_idx;
848 e->time.tv_sec = fsp->open_time.tv_sec;
849 e->time.tv_usec = fsp->open_time.tv_usec;
850 e->share_file_id = fsp->fh->gen_id;
851 e->uid = (uint32_t)uid;
852 e->flags = (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) ?
853 SHARE_MODE_FLAG_POSIX_OPEN : 0;
854 e->name_hash = fsp->name_hash;
859 struct share_mode_entry *find_share_mode_entry(
860 struct share_mode_lock *lck, files_struct *fsp)
862 struct share_mode_data *d = lck->data;
863 struct server_id pid;
866 pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
868 for (i=0; i<d->num_share_modes; i++) {
869 struct share_mode_entry *e = &d->share_modes[i];
871 if (!is_valid_share_mode_entry(e)) {
874 if (!serverid_equal(&pid, &e->pid)) {
877 if (fsp->fh->gen_id != e->share_file_id) {
885 /*******************************************************************
886 Del the share mode of a file for this process. Return the number of
888 ********************************************************************/
890 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
892 struct share_mode_entry *e;
894 e = find_share_mode_entry(lck, fsp);
898 remove_share_mode_lease(lck->data, e);
899 *e = lck->data->share_modes[lck->data->num_share_modes-1];
900 lck->data->num_share_modes -= 1;
901 lck->data->modified = True;
905 bool mark_share_mode_disconnected(struct share_mode_lock *lck,
906 struct files_struct *fsp)
908 struct share_mode_entry *e;
910 if (lck->data->num_share_modes != 1) {
914 if (fsp->op == NULL) {
917 if (!fsp->op->global->durable) {
921 e = find_share_mode_entry(lck, fsp);
926 DEBUG(10, ("Marking share mode entry disconnected for durable handle\n"));
928 server_id_set_disconnected(&e->pid);
931 * On reopen the caller needs to check that
932 * the client comes with the correct handle.
934 e->share_file_id = fsp->op->global->open_persistent_id;
936 lck->data->modified = true;
940 /*******************************************************************
941 Remove an oplock mid and mode entry from a share mode.
942 ********************************************************************/
944 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
946 struct share_mode_data *d = lck->data;
947 struct share_mode_entry *e;
949 e = find_share_mode_entry(lck, fsp);
954 remove_share_mode_lease(d, e);
959 /*******************************************************************
960 Downgrade a oplock type from exclusive to level II.
961 ********************************************************************/
963 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
965 struct share_mode_entry *e;
967 e = find_share_mode_entry(lck, fsp);
972 e->op_type = LEVEL_II_OPLOCK;
973 lck->data->modified = True;
977 NTSTATUS downgrade_share_lease(struct smbd_server_connection *sconn,
978 struct share_mode_lock *lck,
979 const struct smb2_lease_key *key,
980 uint32_t new_lease_state,
981 struct share_mode_lease **_l)
983 struct share_mode_data *d = lck->data;
984 struct share_mode_lease *l;
989 for (i=0; i<d->num_leases; i++) {
990 if (smb2_lease_equal(&sconn->client->connections->smb2.client.guid,
992 &d->leases[i].client_guid,
993 &d->leases[i].lease_key)) {
997 if (i == d->num_leases) {
998 DEBUG(10, ("lease not found\n"));
999 return NT_STATUS_INVALID_PARAMETER;
1005 DEBUG(1, ("Attempt to break from %d to %d - but we're not in breaking state\n",
1006 (int)l->current_state, (int)new_lease_state));
1007 return NT_STATUS_UNSUCCESSFUL;
1011 * Can't upgrade anything: l->breaking_to_requested (and l->current_state)
1012 * must be a strict bitwise superset of new_lease_state
1014 if ((new_lease_state & l->breaking_to_requested) != new_lease_state) {
1015 DEBUG(1, ("Attempt to upgrade from %d to %d - expected %d\n",
1016 (int)l->current_state, (int)new_lease_state,
1017 (int)l->breaking_to_requested));
1018 return NT_STATUS_REQUEST_NOT_ACCEPTED;
1021 if (l->current_state != new_lease_state) {
1022 l->current_state = new_lease_state;
1026 if ((new_lease_state & ~l->breaking_to_required) != 0) {
1027 DEBUG(5, ("lease state %d not fully broken from %d to %d\n",
1028 (int)new_lease_state,
1029 (int)l->current_state,
1030 (int)l->breaking_to_required));
1031 l->breaking_to_requested = l->breaking_to_required;
1032 if (l->current_state & (~SMB2_LEASE_READ)) {
1034 * Here we break in steps, as windows does
1035 * see the breaking3 and v2_breaking3 tests.
1037 l->breaking_to_requested |= SMB2_LEASE_READ;
1041 return NT_STATUS_OPLOCK_BREAK_IN_PROGRESS;
1044 DEBUG(10, ("breaking from %d to %d - expected %d\n",
1045 (int)l->current_state, (int)new_lease_state,
1046 (int)l->breaking_to_requested));
1048 l->breaking_to_requested = 0;
1049 l->breaking_to_required = 0;
1050 l->breaking = false;
1054 return NT_STATUS_OK;
1057 /****************************************************************************
1058 Adds a delete on close token.
1059 ****************************************************************************/
1061 static bool add_delete_on_close_token(struct share_mode_data *d,
1063 const struct security_token *nt_tok,
1064 const struct security_unix_token *tok)
1066 struct delete_token *tmp, *dtl;
1068 tmp = talloc_realloc(d, d->delete_tokens, struct delete_token,
1069 d->num_delete_tokens+1);
1073 d->delete_tokens = tmp;
1074 dtl = &d->delete_tokens[d->num_delete_tokens];
1076 dtl->name_hash = name_hash;
1077 dtl->delete_nt_token = dup_nt_token(d->delete_tokens, nt_tok);
1078 if (dtl->delete_nt_token == NULL) {
1081 dtl->delete_token = copy_unix_token(d->delete_tokens, tok);
1082 if (dtl->delete_token == NULL) {
1085 d->num_delete_tokens += 1;
1090 void reset_delete_on_close_lck(files_struct *fsp,
1091 struct share_mode_lock *lck)
1093 struct share_mode_data *d = lck->data;
1096 for (i=0; i<d->num_delete_tokens; i++) {
1097 struct delete_token *dt = &d->delete_tokens[i];
1099 if (dt->name_hash == fsp->name_hash) {
1102 /* Delete this entry. */
1103 TALLOC_FREE(dt->delete_nt_token);
1104 TALLOC_FREE(dt->delete_token);
1105 *dt = d->delete_tokens[d->num_delete_tokens-1];
1106 d->num_delete_tokens -= 1;
1111 /****************************************************************************
1112 Sets the delete on close flag over all share modes on this file.
1113 Modify the share mode entry for all files open
1114 on this device and inode to tell other smbds we have
1115 changed the delete on close flag. This will be noticed
1116 in the close code, the last closer will delete the file
1118 This makes a copy of any struct security_unix_token into the
1119 lck entry. This function is used when the lock is already granted.
1120 ****************************************************************************/
1122 void set_delete_on_close_lck(files_struct *fsp,
1123 struct share_mode_lock *lck,
1124 const struct security_token *nt_tok,
1125 const struct security_unix_token *tok)
1127 struct messaging_context *msg_ctx = fsp->conn->sconn->msg_ctx;
1128 struct share_mode_data *d = lck->data;
1131 DATA_BLOB fid_blob = {};
1132 enum ndr_err_code ndr_err;
1134 SMB_ASSERT(nt_tok != NULL);
1135 SMB_ASSERT(tok != NULL);
1137 for (i=0; i<d->num_delete_tokens; i++) {
1138 struct delete_token *dt = &d->delete_tokens[i];
1139 if (dt->name_hash == fsp->name_hash) {
1142 /* Replace this token with the given tok. */
1143 TALLOC_FREE(dt->delete_nt_token);
1144 dt->delete_nt_token = dup_nt_token(dt, nt_tok);
1145 SMB_ASSERT(dt->delete_nt_token != NULL);
1146 TALLOC_FREE(dt->delete_token);
1147 dt->delete_token = copy_unix_token(dt, tok);
1148 SMB_ASSERT(dt->delete_token != NULL);
1154 ret = add_delete_on_close_token(lck->data, fsp->name_hash, nt_tok, tok);
1157 ndr_err = ndr_push_struct_blob(&fid_blob, talloc_tos(), &fsp->file_id,
1158 (ndr_push_flags_fn_t)ndr_push_file_id);
1159 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1160 DEBUG(10, ("ndr_push_file_id failed: %s\n",
1161 ndr_errstr(ndr_err)));
1164 for (i=0; i<d->num_share_modes; i++) {
1165 struct share_mode_entry *e = &d->share_modes[i];
1168 status = messaging_send(
1169 msg_ctx, e->pid, MSG_SMB_NOTIFY_CANCEL_DELETED,
1172 if (!NT_STATUS_IS_OK(status)) {
1173 struct server_id_buf tmp;
1174 DEBUG(10, ("%s: messaging_send to %s returned %s\n",
1175 __func__, server_id_str_buf(e->pid, &tmp),
1176 nt_errstr(status)));
1180 TALLOC_FREE(fid_blob.data);
1183 bool set_delete_on_close(files_struct *fsp, bool delete_on_close,
1184 const struct security_token *nt_tok,
1185 const struct security_unix_token *tok)
1187 struct share_mode_lock *lck;
1189 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1191 delete_on_close ? "Adding" : "Removing", fsp_fnum_dbg(fsp),
1194 lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1199 if (delete_on_close) {
1200 set_delete_on_close_lck(fsp, lck, nt_tok, tok);
1202 reset_delete_on_close_lck(fsp, lck);
1205 if (fsp->is_directory) {
1206 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1207 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1208 fsp->fsp_name->base_name);
1213 fsp->delete_on_close = delete_on_close;
1218 static struct delete_token *find_delete_on_close_token(
1219 struct share_mode_data *d, uint32_t name_hash)
1223 DEBUG(10, ("find_delete_on_close_token: name_hash = 0x%x\n",
1224 (unsigned int)name_hash));
1226 for (i=0; i<d->num_delete_tokens; i++) {
1227 struct delete_token *dt = &d->delete_tokens[i];
1229 DEBUG(10, ("find__delete_on_close_token: dt->name_hash = 0x%x\n",
1230 (unsigned int)dt->name_hash ));
1231 if (dt->name_hash == name_hash) {
1238 /****************************************************************************
1239 Return the NT token and UNIX token if there's a match. Return true if
1240 found, false if not.
1241 ****************************************************************************/
1243 bool get_delete_on_close_token(struct share_mode_lock *lck,
1245 const struct security_token **pp_nt_tok,
1246 const struct security_unix_token **pp_tok)
1248 struct delete_token *dt;
1250 dt = find_delete_on_close_token(lck->data, name_hash);
1254 *pp_nt_tok = dt->delete_nt_token;
1255 *pp_tok = dt->delete_token;
1259 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
1261 return find_delete_on_close_token(lck->data, name_hash) != NULL;
1264 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1266 struct share_mode_lock *lck;
1268 DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1269 timestring(talloc_tos(),
1270 convert_timespec_to_time_t(write_time)),
1271 file_id_string_tos(&fileid)));
1273 lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1278 if (timespec_compare(&lck->data->changed_write_time, &write_time) != 0) {
1279 lck->data->modified = True;
1280 lck->data->changed_write_time = write_time;
1287 bool set_write_time(struct file_id fileid, struct timespec write_time)
1289 struct share_mode_lock *lck;
1291 DEBUG(5,("set_write_time: %s id=%s\n",
1292 timestring(talloc_tos(),
1293 convert_timespec_to_time_t(write_time)),
1294 file_id_string_tos(&fileid)));
1296 lck = get_existing_share_mode_lock(talloc_tos(), fileid);
1301 if (timespec_compare(&lck->data->old_write_time, &write_time) != 0) {
1302 lck->data->modified = True;
1303 lck->data->old_write_time = write_time;
1310 struct timespec get_share_mode_write_time(struct share_mode_lock *lck)
1312 struct share_mode_data *d = lck->data;
1314 if (!null_timespec(d->changed_write_time)) {
1315 return d->changed_write_time;
1317 return d->old_write_time;
1320 bool file_has_open_streams(files_struct *fsp)
1322 struct share_mode_lock *lock = NULL;
1323 struct share_mode_data *d = NULL;
1326 lock = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
1332 for (i = 0; i < d->num_share_modes; i++) {
1333 struct share_mode_entry *e = &d->share_modes[i];
1335 if (share_mode_stale_pid(d, i)) {
1339 if (e->private_options &
1340 NTCREATEX_OPTIONS_PRIVATE_STREAM_BASEOPEN)