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 rewrtten 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 "locking/proto.h"
41 #include "smbd/globals.h"
42 #include "dbwrap/dbwrap.h"
43 #include "dbwrap/dbwrap_open.h"
44 #include "../libcli/security/security.h"
48 #include "../librpc/gen_ndr/ndr_open_files.h"
51 #define DBGC_CLASS DBGC_LOCKING
53 #define NO_LOCKING_COUNT (-1)
55 /* the locking database handle */
56 static struct db_context *lock_db;
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 = sconn_server_id(fsp->conn->sconn);
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_default(files_struct *fsp, struct lock_struct *plock)
109 int strict_locking = lp_strict_locking(fsp->conn->params);
112 if (plock->size == 0) {
116 if (!lp_locking(fsp->conn->params) || !strict_locking) {
120 if (strict_locking == Auto) {
121 if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (plock->lock_type == READ_LOCK || plock->lock_type == WRITE_LOCK)) {
122 DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp_str_dbg(fsp)));
124 } else if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
125 (plock->lock_type == READ_LOCK)) {
126 DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp_str_dbg(fsp)));
129 struct byte_range_lock *br_lck;
131 br_lck = brl_get_locks_readonly(fsp);
135 ret = brl_locktest(br_lck,
136 plock->context.smblctx,
144 struct byte_range_lock *br_lck;
146 br_lck = brl_get_locks_readonly(fsp);
150 ret = brl_locktest(br_lck,
151 plock->context.smblctx,
159 DEBUG(10,("strict_lock_default: flavour = %s brl start=%.0f "
160 "len=%.0f %s for fnum %d file %s\n",
161 lock_flav_name(plock->lock_flav),
162 (double)plock->start, (double)plock->size,
163 ret ? "unlocked" : "locked",
164 plock->fnum, fsp_str_dbg(fsp)));
169 void strict_unlock_default(files_struct *fsp, struct lock_struct *plock)
173 /****************************************************************************
174 Find out if a lock could be granted - return who is blocking us if we can't.
175 ****************************************************************************/
177 NTSTATUS query_lock(files_struct *fsp,
181 enum brl_type *plock_type,
182 enum brl_flavour lock_flav)
184 struct byte_range_lock *br_lck = NULL;
186 if (!fsp->can_lock) {
187 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
190 if (!lp_locking(fsp->conn->params)) {
194 br_lck = brl_get_locks_readonly(fsp);
196 return NT_STATUS_NO_MEMORY;
199 return brl_lockquery(br_lck,
201 sconn_server_id(fsp->conn->sconn),
208 static void increment_current_lock_count(files_struct *fsp,
209 enum brl_flavour lock_flav)
211 if (lock_flav == WINDOWS_LOCK &&
212 fsp->current_lock_count != NO_LOCKING_COUNT) {
213 /* blocking ie. pending, locks also count here,
214 * as this is an efficiency counter to avoid checking
215 * the lock db. on close. JRA. */
217 fsp->current_lock_count++;
219 /* Notice that this has had a POSIX lock request.
220 * We can't count locks after this so forget them.
222 fsp->current_lock_count = NO_LOCKING_COUNT;
226 static void decrement_current_lock_count(files_struct *fsp,
227 enum brl_flavour lock_flav)
229 if (lock_flav == WINDOWS_LOCK &&
230 fsp->current_lock_count != NO_LOCKING_COUNT) {
231 SMB_ASSERT(fsp->current_lock_count > 0);
232 fsp->current_lock_count--;
236 /****************************************************************************
237 Utility function called by locking requests.
238 ****************************************************************************/
240 struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
245 enum brl_type lock_type,
246 enum brl_flavour lock_flav,
250 struct blocking_lock_record *blr)
252 struct byte_range_lock *br_lck = NULL;
254 /* silently return ok on print files as we don't do locking there */
255 if (fsp->print_file) {
256 *perr = NT_STATUS_OK;
260 if (!fsp->can_lock) {
261 *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
265 if (!lp_locking(fsp->conn->params)) {
266 *perr = NT_STATUS_OK;
270 /* NOTE! 0 byte long ranges ARE allowed and should be stored */
272 DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f "
273 "blocking_lock=%s requested for fnum %d file %s\n",
274 lock_flav_name(lock_flav), lock_type_name(lock_type),
275 (double)offset, (double)count, blocking_lock ? "true" :
276 "false", fsp->fnum, fsp_str_dbg(fsp)));
278 br_lck = brl_get_locks(talloc_tos(), fsp);
280 *perr = NT_STATUS_NO_MEMORY;
284 *perr = brl_lock(msg_ctx,
287 sconn_server_id(fsp->conn->sconn),
296 DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
298 increment_current_lock_count(fsp, lock_flav);
302 /****************************************************************************
303 Utility function called by unlocking requests.
304 ****************************************************************************/
306 NTSTATUS do_unlock(struct messaging_context *msg_ctx,
311 enum brl_flavour lock_flav)
314 struct byte_range_lock *br_lck = NULL;
316 if (!fsp->can_lock) {
317 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
320 if (!lp_locking(fsp->conn->params)) {
324 DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for fnum %d file %s\n",
325 (double)offset, (double)count, fsp->fnum,
328 br_lck = brl_get_locks(talloc_tos(), fsp);
330 return NT_STATUS_NO_MEMORY;
333 ok = brl_unlock(msg_ctx,
336 sconn_server_id(fsp->conn->sconn),
344 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
345 return NT_STATUS_RANGE_NOT_LOCKED;
348 decrement_current_lock_count(fsp, lock_flav);
352 /****************************************************************************
353 Cancel any pending blocked locks.
354 ****************************************************************************/
356 NTSTATUS do_lock_cancel(files_struct *fsp,
360 enum brl_flavour lock_flav,
361 struct blocking_lock_record *blr)
364 struct byte_range_lock *br_lck = NULL;
366 if (!fsp->can_lock) {
367 return fsp->is_directory ?
368 NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
371 if (!lp_locking(fsp->conn->params)) {
372 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
375 DEBUG(10,("do_lock_cancel: cancel start=%.0f len=%.0f requested for fnum %d file %s\n",
376 (double)offset, (double)count, fsp->fnum,
379 br_lck = brl_get_locks(talloc_tos(), fsp);
381 return NT_STATUS_NO_MEMORY;
384 ok = brl_lock_cancel(br_lck,
386 sconn_server_id(fsp->conn->sconn),
395 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
396 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
399 decrement_current_lock_count(fsp, lock_flav);
403 /****************************************************************************
404 Remove any locks on this fd. Called from file_close().
405 ****************************************************************************/
407 void locking_close_file(struct messaging_context *msg_ctx,
409 enum file_close_type close_type)
411 struct byte_range_lock *br_lck;
413 if (!lp_locking(fsp->conn->params)) {
417 /* If we have not outstanding locks or pending
418 * locks then we don't need to look in the lock db.
421 if (fsp->current_lock_count == 0) {
425 br_lck = brl_get_locks(talloc_tos(),fsp);
428 cancel_pending_lock_requests_by_fid(fsp, br_lck, close_type);
429 brl_close_fnum(msg_ctx, br_lck);
434 /****************************************************************************
435 Initialise the locking functions.
436 ****************************************************************************/
438 static bool locking_init_internal(bool read_only)
445 lock_db = db_open(NULL, lock_path("locking.tdb"),
446 lp_open_files_db_hash_size(),
447 TDB_DEFAULT|TDB_VOLATILE|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
448 read_only?O_RDONLY:O_RDWR|O_CREAT, 0644);
451 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
455 if (!posix_locking_init(read_only))
461 bool locking_init(void)
463 return locking_init_internal(false);
466 bool locking_init_readonly(void)
468 return locking_init_internal(true);
471 /*******************************************************************
472 Deinitialize the share_mode management.
473 ******************************************************************/
475 bool locking_end(void)
478 TALLOC_FREE(lock_db);
482 /*******************************************************************
483 Form a static locking key for a dev/inode pair.
484 ******************************************************************/
486 static TDB_DATA locking_key(const struct file_id *id, struct file_id *tmp)
489 return make_tdb_data((const uint8_t *)tmp, sizeof(*tmp));
492 /*******************************************************************
493 Print out a share mode.
494 ********************************************************************/
496 char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
498 return talloc_asprintf(ctx, "share_mode_entry[%d]: %s "
499 "pid = %s, share_access = 0x%x, private_options = 0x%x, "
500 "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %lu, "
501 "uid = %u, flags = %u, file_id %s, name_hash = 0x%x",
503 e->op_type == UNUSED_SHARE_MODE_ENTRY ? "UNUSED" : "",
504 procid_str_static(&e->pid),
505 e->share_access, e->private_options,
506 e->access_mask, (unsigned long long)e->op_mid,
507 e->op_type, e->share_file_id,
508 (unsigned int)e->uid, (unsigned int)e->flags,
509 file_id_string_tos(&e->id),
510 (unsigned int)e->name_hash);
513 /*******************************************************************
514 Get all share mode entries for a dev/inode pair.
515 ********************************************************************/
517 static bool parse_share_modes(const TDB_DATA dbuf, struct share_mode_lock *lck)
520 struct server_id *pids;
522 enum ndr_err_code ndr_err;
525 blob.data = dbuf.dptr;
526 blob.length = dbuf.dsize;
528 ndr_err = ndr_pull_struct_blob(
530 (ndr_pull_flags_fn_t)ndr_pull_share_mode_lock);
531 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
532 DEBUG(1, ("ndr_pull_share_mode_lock failed\n"));
536 lck->modified = false;
538 if (DEBUGLEVEL >= 10) {
539 DEBUG(10, ("parse_share_modes:\n"));
540 NDR_PRINT_DEBUG(share_mode_lock, lck);
544 * Ensure that each entry has a real process attached.
547 pids = talloc_array(talloc_tos(), struct server_id,
548 lck->num_share_modes);
550 smb_panic("parse_share_modes: talloc_array failed");
552 pid_exists = talloc_array(talloc_tos(), bool, lck->num_share_modes);
553 if (pid_exists == NULL) {
554 smb_panic("parse_share_modes: talloc_array failed");
557 for (i=0; i<lck->num_share_modes; i++) {
558 pids[i] = lck->share_modes[i].pid;
561 if (!serverids_exist(pids, lck->num_share_modes, pid_exists)) {
562 smb_panic("parse_share_modes: serverids_exist failed");
565 for (i = 0; i < lck->num_share_modes; i++) {
566 struct share_mode_entry *entry_p = &lck->share_modes[i];
567 if (!pid_exists[i]) {
568 entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
569 lck->modified = True;
572 TALLOC_FREE(pid_exists);
578 static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
581 enum ndr_err_code ndr_err;
584 if (DEBUGLEVEL >= 10) {
585 DEBUG(10, ("unparse_share_modes:\n"));
586 NDR_PRINT_DEBUG(share_mode_lock, lck);
589 for (i=0; i<lck->num_share_modes; i++) {
590 if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
594 if (i == lck->num_share_modes) {
595 DEBUG(10, ("No used share mode found\n"));
596 return make_tdb_data(NULL, 0);
599 ndr_err = ndr_push_struct_blob(
601 (ndr_push_flags_fn_t)ndr_push_share_mode_lock);
602 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
603 smb_panic("ndr_push_share_mode_lock failed");
606 return make_tdb_data(blob.data, blob.length);
609 static int share_mode_lock_destructor(struct share_mode_lock *lck)
614 if (!lck->modified) {
618 data = unparse_share_modes(lck);
620 if (data.dptr == NULL) {
622 /* There has been an entry before, delete it */
624 status = dbwrap_record_delete(lck->record);
625 if (!NT_STATUS_IS_OK(status)) {
628 DEBUG(0, ("delete_rec returned %s\n",
631 if (asprintf(&errmsg, "could not delete share "
633 nt_errstr(status)) == -1) {
634 smb_panic("could not delete share"
643 status = dbwrap_record_store(lck->record, data, TDB_REPLACE);
644 if (!NT_STATUS_IS_OK(status)) {
647 DEBUG(0, ("store returned %s\n", nt_errstr(status)));
649 if (asprintf(&errmsg, "could not store share mode entry: %s",
650 nt_errstr(status)) == -1) {
651 smb_panic("could not store share mode entry");
661 static bool fill_share_mode_lock(struct share_mode_lock *lck,
663 const char *servicepath,
664 const struct smb_filename *smb_fname,
665 TDB_DATA share_mode_data,
666 const struct timespec *old_write_time)
670 /* Ensure we set every field here as the destructor must be
671 valid even if parse_share_modes fails. */
673 lck->servicepath = NULL;
674 lck->base_name = NULL;
675 lck->stream_name = NULL;
677 lck->num_share_modes = 0;
678 lck->share_modes = NULL;
679 lck->num_delete_tokens = 0;
680 lck->delete_tokens = NULL;
681 ZERO_STRUCT(lck->old_write_time);
682 ZERO_STRUCT(lck->changed_write_time);
684 fresh = (share_mode_data.dptr == NULL);
688 if (smb_fname == NULL || servicepath == NULL
689 || old_write_time == NULL) {
693 has_stream = smb_fname->stream_name != NULL;
695 lck->base_name = talloc_strdup(lck, smb_fname->base_name);
696 lck->stream_name = talloc_strdup(lck, smb_fname->stream_name);
697 lck->servicepath = talloc_strdup(lck, servicepath);
698 if (lck->base_name == NULL ||
699 (has_stream && lck->stream_name == NULL) ||
700 lck->servicepath == NULL) {
701 DEBUG(0, ("talloc failed\n"));
704 lck->old_write_time = *old_write_time;
705 lck->modified = false;
707 if (!parse_share_modes(share_mode_data, lck)) {
708 DEBUG(0, ("Could not parse share modes\n"));
717 struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
718 const struct file_id id,
719 const char *servicepath,
720 const struct smb_filename *smb_fname,
721 const struct timespec *old_write_time)
723 struct share_mode_lock *lck;
725 struct db_record *rec;
726 TDB_DATA key = locking_key(&id, &tmp);
729 if (!(lck = talloc(mem_ctx, struct share_mode_lock))) {
730 DEBUG(0, ("talloc failed\n"));
734 rec = dbwrap_fetch_locked(lock_db, lck, key);
736 DEBUG(3, ("Could not lock share entry\n"));
741 value = dbwrap_record_get_value(rec);
743 if (!fill_share_mode_lock(lck, id, servicepath, smb_fname,
744 value, old_write_time)) {
745 DEBUG(3, ("fill_share_mode_lock failed\n"));
751 talloc_set_destructor(lck, share_mode_lock_destructor);
756 struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
757 const struct file_id id)
759 struct share_mode_lock *lck;
761 TDB_DATA key = locking_key(&id, &tmp);
765 if (!(lck = talloc(mem_ctx, struct share_mode_lock))) {
766 DEBUG(0, ("talloc failed\n"));
770 status = dbwrap_fetch(lock_db, lck, key, &data);
771 if (!NT_STATUS_IS_OK(status)) {
772 DEBUG(3, ("Could not fetch share entry\n"));
777 if (!fill_share_mode_lock(lck, id, NULL, NULL, data, NULL)) {
778 DEBUG(10, ("fetch_share_mode_unlocked: no share_mode record "
779 "around (file not open)\n"));
787 /*******************************************************************
788 Sets the service name and filename for rename.
789 At this point we emit "file renamed" messages to all
790 process id's that have this file open.
791 Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
792 ********************************************************************/
794 bool rename_share_filename(struct messaging_context *msg_ctx,
795 struct share_mode_lock *lck,
796 const char *servicepath,
797 uint32_t orig_name_hash,
798 uint32_t new_name_hash,
799 const struct smb_filename *smb_fname_dst)
807 bool strip_two_chars = false;
808 bool has_stream = smb_fname_dst->stream_name != NULL;
810 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
811 servicepath, smb_fname_dst->base_name));
814 * rename_internal_fsp() and rename_internals() add './' to
815 * head of newname if newname does not contain a '/'.
817 if (smb_fname_dst->base_name[0] &&
818 smb_fname_dst->base_name[1] &&
819 smb_fname_dst->base_name[0] == '.' &&
820 smb_fname_dst->base_name[1] == '/') {
821 strip_two_chars = true;
824 lck->servicepath = talloc_strdup(lck, servicepath);
825 lck->base_name = talloc_strdup(lck, smb_fname_dst->base_name +
826 (strip_two_chars ? 2 : 0));
827 lck->stream_name = talloc_strdup(lck, smb_fname_dst->stream_name);
828 if (lck->base_name == NULL ||
829 (has_stream && lck->stream_name == NULL) ||
830 lck->servicepath == NULL) {
831 DEBUG(0, ("rename_share_filename: talloc failed\n"));
834 lck->modified = True;
836 sp_len = strlen(lck->servicepath);
837 bn_len = strlen(lck->base_name);
838 sn_len = has_stream ? strlen(lck->stream_name) : 0;
840 msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
843 /* Set up the name changed message. */
844 frm = talloc_array(lck, char, msg_len);
849 push_file_id_24(frm, &lck->id);
851 DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
854 lck->servicepath ? lck->servicepath : "",
856 strlcpy(&frm[24 + sp_len + 1],
857 lck->base_name ? lck->base_name : "",
859 strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
860 lck->stream_name ? lck->stream_name : "",
863 /* Send the messages. */
864 for (i=0; i<lck->num_share_modes; i++) {
865 struct share_mode_entry *se = &lck->share_modes[i];
866 if (!is_valid_share_mode_entry(se)) {
870 /* If this is a hardlink to the inode
871 with a different name, skip this. */
872 if (se->name_hash != orig_name_hash) {
876 se->name_hash = new_name_hash;
878 /* But not to ourselves... */
879 if (procid_is_me(&se->pid)) {
883 DEBUG(10,("rename_share_filename: sending rename message to "
884 "pid %s file_id %s sharepath %s base_name %s "
886 procid_str_static(&se->pid),
887 file_id_string_tos(&lck->id),
888 lck->servicepath, lck->base_name,
889 has_stream ? lck->stream_name : ""));
891 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
892 (uint8 *)frm, msg_len);
898 void get_file_infos(struct file_id id,
900 bool *delete_on_close,
901 struct timespec *write_time)
903 struct share_mode_lock *lck;
905 if (delete_on_close) {
906 *delete_on_close = false;
910 ZERO_STRUCTP(write_time);
913 if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
917 if (delete_on_close) {
918 *delete_on_close = is_delete_on_close_set(lck, name_hash);
924 wt = lck->changed_write_time;
925 if (null_timespec(wt)) {
926 wt = lck->old_write_time;
935 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
939 if (e->op_type == UNUSED_SHARE_MODE_ENTRY) {
940 /* cope with dead entries from the process not
941 existing. These should not be considered valid,
942 otherwise we end up doing zero timeout sharing
947 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
948 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
949 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
951 SMB_ASSERT(num_props <= 1);
952 return (num_props != 0);
955 bool is_deferred_open_entry(const struct share_mode_entry *e)
957 return (e->op_type == DEFERRED_OPEN_ENTRY);
960 bool is_unused_share_mode_entry(const struct share_mode_entry *e)
962 return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
965 /*******************************************************************
966 Fill a share mode entry.
967 ********************************************************************/
969 static void fill_share_mode_entry(struct share_mode_entry *e,
971 uid_t uid, uint64_t mid, uint16 op_type)
974 e->pid = sconn_server_id(fsp->conn->sconn);
975 e->share_access = fsp->share_access;
976 e->private_options = fsp->fh->private_options;
977 e->access_mask = fsp->access_mask;
979 e->op_type = op_type;
980 e->time.tv_sec = fsp->open_time.tv_sec;
981 e->time.tv_usec = fsp->open_time.tv_usec;
982 e->id = fsp->file_id;
983 e->share_file_id = fsp->fh->gen_id;
984 e->uid = (uint32)uid;
985 e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
986 e->name_hash = fsp->name_hash;
989 static void fill_deferred_open_entry(struct share_mode_entry *e,
990 const struct timeval request_time,
992 struct server_id pid,
998 e->op_type = DEFERRED_OPEN_ENTRY;
999 e->time.tv_sec = request_time.tv_sec;
1000 e->time.tv_usec = request_time.tv_usec;
1002 e->uid = (uint32)-1;
1006 static void add_share_mode_entry(struct share_mode_lock *lck,
1007 const struct share_mode_entry *entry)
1011 for (i=0; i<lck->num_share_modes; i++) {
1012 struct share_mode_entry *e = &lck->share_modes[i];
1013 if (is_unused_share_mode_entry(e)) {
1019 if (i == lck->num_share_modes) {
1020 /* No unused entry found */
1021 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
1022 &lck->share_modes, &lck->num_share_modes);
1024 lck->modified = True;
1027 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
1028 uid_t uid, uint64_t mid, uint16 op_type)
1030 struct share_mode_entry entry;
1031 fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
1032 add_share_mode_entry(lck, &entry);
1035 void add_deferred_open(struct share_mode_lock *lck, uint64_t mid,
1036 struct timeval request_time,
1037 struct server_id pid, struct file_id id)
1039 struct share_mode_entry entry;
1040 fill_deferred_open_entry(&entry, request_time, id, pid, mid);
1041 add_share_mode_entry(lck, &entry);
1044 /*******************************************************************
1045 Check if two share mode entries are identical, ignoring oplock
1046 and mid info and desired_access. (Removed paranoia test - it's
1047 not automatically a logic error if they are identical. JRA.)
1048 ********************************************************************/
1050 static bool share_modes_identical(struct share_mode_entry *e1,
1051 struct share_mode_entry *e2)
1053 /* We used to check for e1->share_access == e2->share_access here
1054 as well as the other fields but 2 different DOS or FCB opens
1055 sharing the same share mode entry may validly differ in
1056 fsp->share_access field. */
1058 return (procid_equal(&e1->pid, &e2->pid) &&
1059 file_id_equal(&e1->id, &e2->id) &&
1060 e1->share_file_id == e2->share_file_id );
1063 static bool deferred_open_identical(struct share_mode_entry *e1,
1064 struct share_mode_entry *e2)
1066 return (procid_equal(&e1->pid, &e2->pid) &&
1067 (e1->op_mid == e2->op_mid) &&
1068 file_id_equal(&e1->id, &e2->id));
1071 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
1072 struct share_mode_entry *entry)
1076 for (i=0; i<lck->num_share_modes; i++) {
1077 struct share_mode_entry *e = &lck->share_modes[i];
1078 if (is_valid_share_mode_entry(entry) &&
1079 is_valid_share_mode_entry(e) &&
1080 share_modes_identical(e, entry)) {
1083 if (is_deferred_open_entry(entry) &&
1084 is_deferred_open_entry(e) &&
1085 deferred_open_identical(e, entry)) {
1092 /*******************************************************************
1093 Del the share mode of a file for this process. Return the number of
1095 ********************************************************************/
1097 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
1099 struct share_mode_entry entry, *e;
1101 /* Don't care about the pid owner being correct here - just a search. */
1102 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1104 e = find_share_mode_entry(lck, &entry);
1109 e->op_type = UNUSED_SHARE_MODE_ENTRY;
1110 lck->modified = True;
1114 void del_deferred_open_entry(struct share_mode_lock *lck, uint64_t mid,
1115 struct server_id pid)
1117 struct share_mode_entry entry, *e;
1119 fill_deferred_open_entry(&entry, timeval_zero(),
1122 e = find_share_mode_entry(lck, &entry);
1127 e->op_type = UNUSED_SHARE_MODE_ENTRY;
1128 lck->modified = True;
1131 /*******************************************************************
1132 Remove an oplock mid and mode entry from a share mode.
1133 ********************************************************************/
1135 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1137 struct share_mode_entry entry, *e;
1139 /* Don't care about the pid owner being correct here - just a search. */
1140 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1142 e = find_share_mode_entry(lck, &entry);
1147 if (EXCLUSIVE_OPLOCK_TYPE(e->op_type)) {
1149 * Going from exclusive or batch,
1150 * we always go through FAKE_LEVEL_II
1153 if (!EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
1154 smb_panic("remove_share_oplock: logic error");
1156 e->op_type = FAKE_LEVEL_II_OPLOCK;
1158 e->op_type = NO_OPLOCK;
1160 lck->modified = True;
1164 /*******************************************************************
1165 Downgrade a oplock type from exclusive to level II.
1166 ********************************************************************/
1168 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1170 struct share_mode_entry entry, *e;
1172 /* Don't care about the pid owner being correct here - just a search. */
1173 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1175 e = find_share_mode_entry(lck, &entry);
1180 e->op_type = LEVEL_II_OPLOCK;
1181 lck->modified = True;
1185 /*************************************************************************
1186 Return a talloced copy of a struct security_unix_token. NULL on fail.
1187 (Should this be in locking.c.... ?).
1188 *************************************************************************/
1190 static struct security_unix_token *copy_unix_token(TALLOC_CTX *ctx, const struct security_unix_token *tok)
1192 struct security_unix_token *cpy;
1194 cpy = talloc(ctx, struct security_unix_token);
1199 cpy->uid = tok->uid;
1200 cpy->gid = tok->gid;
1201 cpy->ngroups = tok->ngroups;
1203 /* Make this a talloc child of cpy. */
1204 cpy->groups = (gid_t *)talloc_memdup(
1205 cpy, tok->groups, tok->ngroups * sizeof(gid_t));
1214 /****************************************************************************
1215 Adds a delete on close token.
1216 ****************************************************************************/
1218 static bool add_delete_on_close_token(struct share_mode_lock *lck,
1220 const struct security_unix_token *tok)
1222 struct delete_token *tmp, *dtl;
1224 tmp = talloc_realloc(lck, lck->delete_tokens, struct delete_token,
1225 lck->num_delete_tokens+1);
1229 lck->delete_tokens = tmp;
1230 dtl = &lck->delete_tokens[lck->num_delete_tokens];
1232 dtl->name_hash = name_hash;
1233 dtl->delete_token = copy_unix_token(lck->delete_tokens, tok);
1234 if (dtl->delete_token == NULL) {
1237 lck->num_delete_tokens += 1;
1238 lck->modified = true;
1242 /****************************************************************************
1243 Sets the delete on close flag over all share modes on this file.
1244 Modify the share mode entry for all files open
1245 on this device and inode to tell other smbds we have
1246 changed the delete on close flag. This will be noticed
1247 in the close code, the last closer will delete the file
1249 This makes a copy of any struct security_unix_token into the
1250 lck entry. This function is used when the lock is already granted.
1251 ****************************************************************************/
1253 void set_delete_on_close_lck(files_struct *fsp,
1254 struct share_mode_lock *lck,
1255 bool delete_on_close,
1256 const struct security_unix_token *tok)
1261 if (delete_on_close) {
1262 SMB_ASSERT(tok != NULL);
1264 SMB_ASSERT(tok == NULL);
1267 for (i=0; i<lck->num_delete_tokens; i++) {
1268 struct delete_token *dt = &lck->delete_tokens[i];
1269 if (dt->name_hash == fsp->name_hash) {
1270 lck->modified = true;
1271 if (delete_on_close == false) {
1272 /* Delete this entry. */
1273 TALLOC_FREE(dt->delete_token);
1274 *dt = lck->delete_tokens[
1275 lck->num_delete_tokens-1];
1276 lck->num_delete_tokens -= 1;
1279 /* Replace this token with the
1281 TALLOC_FREE(dt->delete_token);
1282 dt->delete_token = copy_unix_token(dt, tok);
1283 SMB_ASSERT(dt->delete_token != NULL);
1287 if (!delete_on_close) {
1288 /* Nothing to delete - not found. */
1292 ret = add_delete_on_close_token(lck, fsp->name_hash, tok);
1296 bool set_delete_on_close(files_struct *fsp, bool delete_on_close, const struct security_unix_token *tok)
1298 struct share_mode_lock *lck;
1300 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1301 "fnum = %d, file %s\n",
1302 delete_on_close ? "Adding" : "Removing", fsp->fnum,
1305 lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
1311 set_delete_on_close_lck(fsp, lck, delete_on_close,
1312 delete_on_close ? tok : NULL);
1314 if (fsp->is_directory) {
1315 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1316 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1317 fsp->fsp_name->base_name);
1322 fsp->delete_on_close = delete_on_close;
1327 const struct security_unix_token *get_delete_on_close_token(struct share_mode_lock *lck, uint32_t name_hash)
1331 DEBUG(10,("get_delete_on_close_token: name_hash = 0x%x\n",
1332 (unsigned int)name_hash ));
1334 for (i=0; i<lck->num_delete_tokens; i++) {
1335 struct delete_token *dt = &lck->delete_tokens[i];
1336 DEBUG(10,("get_delete_on_close_token: dtl->name_hash = 0x%x\n",
1337 (unsigned int)dt->name_hash ));
1338 if (dt->name_hash == name_hash) {
1339 return dt->delete_token;
1345 bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
1347 return (get_delete_on_close_token(lck, name_hash) != NULL);
1350 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1352 struct share_mode_lock *lck;
1354 DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1355 timestring(talloc_tos(),
1356 convert_timespec_to_time_t(write_time)),
1357 file_id_string_tos(&fileid)));
1359 lck = get_share_mode_lock(talloc_tos(), fileid, NULL, NULL, NULL);
1364 if (timespec_compare(&lck->changed_write_time, &write_time) != 0) {
1365 lck->modified = True;
1366 lck->changed_write_time = write_time;
1373 bool set_write_time(struct file_id fileid, struct timespec write_time)
1375 struct share_mode_lock *lck;
1377 DEBUG(5,("set_write_time: %s id=%s\n",
1378 timestring(talloc_tos(),
1379 convert_timespec_to_time_t(write_time)),
1380 file_id_string_tos(&fileid)));
1382 lck = get_share_mode_lock(talloc_tos(), fileid, NULL, NULL, NULL);
1387 if (timespec_compare(&lck->old_write_time, &write_time) != 0) {
1388 lck->modified = True;
1389 lck->old_write_time = write_time;
1397 struct forall_state {
1398 void (*fn)(const struct share_mode_entry *entry,
1399 const char *sharepath,
1401 void *private_data);
1405 static int traverse_fn(struct db_record *rec, void *_state)
1407 struct forall_state *state = (struct forall_state *)_state;
1412 enum ndr_err_code ndr_err;
1413 struct share_mode_lock *lck;
1415 key = dbwrap_record_get_key(rec);
1416 value = dbwrap_record_get_value(rec);
1418 /* Ensure this is a locking_key record. */
1419 if (key.dsize != sizeof(struct file_id))
1422 lck = talloc(talloc_tos(), struct share_mode_lock);
1427 blob.data = value.dptr;
1428 blob.length = value.dsize;
1430 ndr_err = ndr_pull_struct_blob(
1432 (ndr_pull_flags_fn_t)ndr_pull_share_mode_lock);
1433 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1434 DEBUG(1, ("ndr_pull_share_mode_lock failed\n"));
1437 for (i=0; i<lck->num_share_modes; i++) {
1438 state->fn(&lck->share_modes[i],
1439 lck->servicepath, lck->base_name,
1440 state->private_data);
1447 /*******************************************************************
1448 Call the specified function on each entry under management by the
1450 ********************************************************************/
1452 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
1453 const char *, void *),
1456 struct forall_state state;
1460 if (lock_db == NULL)
1464 state.private_data = private_data;
1466 status = dbwrap_traverse_read(lock_db, traverse_fn, (void *)&state,
1469 if (!NT_STATUS_IS_OK(status)) {