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.
41 #define DBGC_CLASS DBGC_LOCKING
43 #define NO_LOCKING_COUNT (-1)
45 /* the locking database handle */
46 static struct db_context *lock_db;
48 /****************************************************************************
50 ****************************************************************************/
52 const char *lock_type_name(enum brl_type lock_type)
59 case PENDING_READ_LOCK:
60 return "PENDING_READ";
61 case PENDING_WRITE_LOCK:
62 return "PENDING_WRITE";
68 const char *lock_flav_name(enum brl_flavour lock_flav)
70 return (lock_flav == WINDOWS_LOCK) ? "WINDOWS_LOCK" : "POSIX_LOCK";
73 /****************************************************************************
74 Utility function called to see if a file region is locked.
75 Called in the read/write codepath.
76 ****************************************************************************/
78 void init_strict_lock_struct(files_struct *fsp,
82 enum brl_type lock_type,
83 struct lock_struct *plock)
85 SMB_ASSERT(lock_type == READ_LOCK || lock_type == WRITE_LOCK);
87 plock->context.smbpid = smbpid;
88 plock->context.tid = fsp->conn->cnum;
89 plock->context.pid = procid_self();
92 plock->fnum = fsp->fnum;
93 plock->lock_type = lock_type;
94 plock->lock_flav = lp_posix_cifsu_locktype(fsp);
97 bool strict_lock_default(files_struct *fsp, struct lock_struct *plock)
99 int strict_locking = lp_strict_locking(fsp->conn->params);
102 if (plock->size == 0) {
106 if (!lp_locking(fsp->conn->params) || !strict_locking) {
110 if (strict_locking == Auto) {
111 if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (plock->lock_type == READ_LOCK || plock->lock_type == WRITE_LOCK)) {
112 DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp->fsp_name ));
114 } else if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
115 (plock->lock_type == READ_LOCK)) {
116 DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp->fsp_name ));
119 struct byte_range_lock *br_lck = brl_get_locks_readonly(talloc_tos(), fsp);
123 ret = brl_locktest(br_lck,
124 plock->context.smbpid,
133 struct byte_range_lock *br_lck = brl_get_locks_readonly(talloc_tos(), fsp);
137 ret = brl_locktest(br_lck,
138 plock->context.smbpid,
147 DEBUG(10,("strict_lock_default: flavour = %s brl start=%.0f "
148 "len=%.0f %s for fnum %d file %s\n",
149 lock_flav_name(plock->lock_flav),
150 (double)plock->start, (double)plock->size,
151 ret ? "unlocked" : "locked",
152 plock->fnum, fsp->fsp_name ));
157 void strict_unlock_default(files_struct *fsp, struct lock_struct *plock)
161 /****************************************************************************
162 Find out if a lock could be granted - return who is blocking us if we can't.
163 ****************************************************************************/
165 NTSTATUS query_lock(files_struct *fsp,
169 enum brl_type *plock_type,
170 enum brl_flavour lock_flav)
172 struct byte_range_lock *br_lck = NULL;
173 NTSTATUS status = NT_STATUS_LOCK_NOT_GRANTED;
175 if (!fsp->can_lock) {
176 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
179 if (!lp_locking(fsp->conn->params)) {
183 br_lck = brl_get_locks_readonly(talloc_tos(), fsp);
185 return NT_STATUS_NO_MEMORY;
188 status = brl_lockquery(br_lck,
200 static void increment_current_lock_count(files_struct *fsp,
201 enum brl_flavour lock_flav)
203 if (lock_flav == WINDOWS_LOCK &&
204 fsp->current_lock_count != NO_LOCKING_COUNT) {
205 /* blocking ie. pending, locks also count here,
206 * as this is an efficiency counter to avoid checking
207 * the lock db. on close. JRA. */
209 fsp->current_lock_count++;
211 /* Notice that this has had a POSIX lock request.
212 * We can't count locks after this so forget them.
214 fsp->current_lock_count = NO_LOCKING_COUNT;
218 static void decrement_current_lock_count(files_struct *fsp,
219 enum brl_flavour lock_flav)
221 if (lock_flav == WINDOWS_LOCK &&
222 fsp->current_lock_count != NO_LOCKING_COUNT) {
223 SMB_ASSERT(fsp->current_lock_count > 0);
224 fsp->current_lock_count--;
228 /****************************************************************************
229 Utility function called by locking requests.
230 ****************************************************************************/
232 struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
237 enum brl_type lock_type,
238 enum brl_flavour lock_flav,
242 struct blocking_lock_record *blr)
244 struct byte_range_lock *br_lck = NULL;
246 if (!fsp->can_lock) {
247 *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
251 if (!lp_locking(fsp->conn->params)) {
252 *perr = NT_STATUS_OK;
256 /* NOTE! 0 byte long ranges ARE allowed and should be stored */
258 DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f "
259 "blocking_lock=%s requested for fnum %d file %s\n",
260 lock_flav_name(lock_flav), lock_type_name(lock_type),
261 (double)offset, (double)count, blocking_lock ? "true" :
262 "false", fsp->fnum, fsp->fsp_name));
264 br_lck = brl_get_locks(talloc_tos(), fsp);
266 *perr = NT_STATUS_NO_MEMORY;
270 *perr = brl_lock(msg_ctx,
282 DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
284 increment_current_lock_count(fsp, lock_flav);
288 /****************************************************************************
289 Utility function called by unlocking requests.
290 ****************************************************************************/
292 NTSTATUS do_unlock(struct messaging_context *msg_ctx,
297 enum brl_flavour lock_flav)
300 struct byte_range_lock *br_lck = NULL;
302 if (!fsp->can_lock) {
303 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
306 if (!lp_locking(fsp->conn->params)) {
310 DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for fnum %d file %s\n",
311 (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
313 br_lck = brl_get_locks(talloc_tos(), fsp);
315 return NT_STATUS_NO_MEMORY;
318 ok = brl_unlock(msg_ctx,
329 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
330 return NT_STATUS_RANGE_NOT_LOCKED;
333 decrement_current_lock_count(fsp, lock_flav);
337 /****************************************************************************
338 Cancel any pending blocked locks.
339 ****************************************************************************/
341 NTSTATUS do_lock_cancel(files_struct *fsp,
345 enum brl_flavour lock_flav,
346 struct blocking_lock_record *blr)
349 struct byte_range_lock *br_lck = NULL;
351 if (!fsp->can_lock) {
352 return fsp->is_directory ?
353 NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
356 if (!lp_locking(fsp->conn->params)) {
357 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
360 DEBUG(10,("do_lock_cancel: cancel start=%.0f len=%.0f requested for fnum %d file %s\n",
361 (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
363 br_lck = brl_get_locks(talloc_tos(), fsp);
365 return NT_STATUS_NO_MEMORY;
368 ok = brl_lock_cancel(br_lck,
379 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
380 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
383 decrement_current_lock_count(fsp, lock_flav);
387 /****************************************************************************
388 Remove any locks on this fd. Called from file_close().
389 ****************************************************************************/
391 void locking_close_file(struct messaging_context *msg_ctx,
394 struct byte_range_lock *br_lck;
396 if (!lp_locking(fsp->conn->params)) {
400 /* If we have not outstanding locks or pending
401 * locks then we don't need to look in the lock db.
404 if (fsp->current_lock_count == 0) {
408 br_lck = brl_get_locks(talloc_tos(),fsp);
411 cancel_pending_lock_requests_by_fid(fsp, br_lck);
412 brl_close_fnum(msg_ctx, br_lck);
417 /****************************************************************************
418 Initialise the locking functions.
419 ****************************************************************************/
421 static bool locking_init_internal(bool read_only)
428 lock_db = db_open(NULL, lock_path("locking.tdb"),
429 lp_open_files_db_hash_size(),
430 TDB_DEFAULT|TDB_VOLATILE|TDB_CLEAR_IF_FIRST,
431 read_only?O_RDONLY:O_RDWR|O_CREAT, 0644);
434 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
438 if (!posix_locking_init(read_only))
444 bool locking_init(void)
446 return locking_init_internal(false);
449 bool locking_init_readonly(void)
451 return locking_init_internal(true);
454 /*******************************************************************
455 Deinitialize the share_mode management.
456 ******************************************************************/
458 bool locking_end(void)
461 TALLOC_FREE(lock_db);
465 /*******************************************************************
466 Form a static locking key for a dev/inode pair.
467 ******************************************************************/
469 static TDB_DATA locking_key(const struct file_id *id, struct file_id *tmp)
472 return make_tdb_data((const uint8_t *)tmp, sizeof(*tmp));
475 /*******************************************************************
476 Print out a share mode.
477 ********************************************************************/
479 char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
481 return talloc_asprintf(ctx, "share_mode_entry[%d]: %s "
482 "pid = %s, share_access = 0x%x, private_options = 0x%x, "
483 "access_mask = 0x%x, mid = 0x%x, type= 0x%x, gen_id = %lu, "
484 "uid = %u, flags = %u, file_id %s",
486 e->op_type == UNUSED_SHARE_MODE_ENTRY ? "UNUSED" : "",
487 procid_str_static(&e->pid),
488 e->share_access, e->private_options,
489 e->access_mask, e->op_mid, e->op_type, e->share_file_id,
490 (unsigned int)e->uid, (unsigned int)e->flags,
491 file_id_string_tos(&e->id));
494 /*******************************************************************
495 Print out a share mode table.
496 ********************************************************************/
498 static void print_share_mode_table(struct locking_data *data)
500 int num_share_modes = data->u.s.num_share_mode_entries;
501 struct share_mode_entry *shares =
502 (struct share_mode_entry *)(data + 1);
505 for (i = 0; i < num_share_modes; i++) {
506 struct share_mode_entry entry;
510 * We need to memcpy the entry here due to alignment
511 * restrictions that are not met when directly accessing
515 memcpy(&entry, &shares[i], sizeof(struct share_mode_entry));
516 str = share_mode_str(talloc_tos(), i, &entry);
518 DEBUG(10,("print_share_mode_table: %s\n", str ? str : ""));
523 /*******************************************************************
524 Get all share mode entries for a dev/inode pair.
525 ********************************************************************/
527 static bool parse_share_modes(const TDB_DATA dbuf, struct share_mode_lock *lck)
529 struct locking_data data;
532 if (dbuf.dsize < sizeof(struct locking_data)) {
533 smb_panic("parse_share_modes: buffer too short");
536 memcpy(&data, dbuf.dptr, sizeof(data));
538 lck->delete_on_close = data.u.s.delete_on_close;
539 lck->old_write_time = data.u.s.old_write_time;
540 lck->changed_write_time = data.u.s.changed_write_time;
541 lck->num_share_modes = data.u.s.num_share_mode_entries;
543 DEBUG(10, ("parse_share_modes: delete_on_close: %d, owrt: %s, "
544 "cwrt: %s, tok: %u, num_share_modes: %d\n",
545 lck->delete_on_close,
546 timestring(debug_ctx(),
547 convert_timespec_to_time_t(lck->old_write_time)),
548 timestring(debug_ctx(),
549 convert_timespec_to_time_t(
550 lck->changed_write_time)),
551 (unsigned int)data.u.s.delete_token_size,
552 lck->num_share_modes));
554 if ((lck->num_share_modes < 0) || (lck->num_share_modes > 1000000)) {
555 DEBUG(0, ("invalid number of share modes: %d\n",
556 lck->num_share_modes));
557 smb_panic("parse_share_modes: invalid number of share modes");
560 lck->share_modes = NULL;
562 if (lck->num_share_modes != 0) {
564 if (dbuf.dsize < (sizeof(struct locking_data) +
565 (lck->num_share_modes *
566 sizeof(struct share_mode_entry)))) {
567 smb_panic("parse_share_modes: buffer too short");
570 lck->share_modes = (struct share_mode_entry *)
572 dbuf.dptr+sizeof(struct locking_data),
573 lck->num_share_modes *
574 sizeof(struct share_mode_entry));
576 if (lck->share_modes == NULL) {
577 smb_panic("parse_share_modes: talloc failed");
581 /* Get any delete token. */
582 if (data.u.s.delete_token_size) {
583 uint8 *p = dbuf.dptr + sizeof(struct locking_data) +
584 (lck->num_share_modes *
585 sizeof(struct share_mode_entry));
587 if ((data.u.s.delete_token_size < sizeof(uid_t) + sizeof(gid_t)) ||
588 ((data.u.s.delete_token_size - sizeof(uid_t)) % sizeof(gid_t)) != 0) {
589 DEBUG(0, ("parse_share_modes: invalid token size %d\n",
590 data.u.s.delete_token_size));
591 smb_panic("parse_share_modes: invalid token size");
594 lck->delete_token = TALLOC_P(lck, UNIX_USER_TOKEN);
595 if (!lck->delete_token) {
596 smb_panic("parse_share_modes: talloc failed");
599 /* Copy out the uid and gid. */
600 memcpy(&lck->delete_token->uid, p, sizeof(uid_t));
602 memcpy(&lck->delete_token->gid, p, sizeof(gid_t));
605 /* Any supplementary groups ? */
606 lck->delete_token->ngroups = (data.u.s.delete_token_size > (sizeof(uid_t) + sizeof(gid_t))) ?
607 ((data.u.s.delete_token_size -
608 (sizeof(uid_t) + sizeof(gid_t)))/sizeof(gid_t)) : 0;
610 if (lck->delete_token->ngroups) {
611 /* Make this a talloc child of lck->delete_token. */
612 lck->delete_token->groups = TALLOC_ARRAY(lck->delete_token, gid_t,
613 lck->delete_token->ngroups);
614 if (!lck->delete_token) {
615 smb_panic("parse_share_modes: talloc failed");
618 for (i = 0; i < lck->delete_token->ngroups; i++) {
619 memcpy(&lck->delete_token->groups[i], p, sizeof(gid_t));
625 lck->delete_token = NULL;
628 /* Save off the associated service path and filename. */
629 lck->servicepath = (const char *)dbuf.dptr + sizeof(struct locking_data) +
630 (lck->num_share_modes * sizeof(struct share_mode_entry)) +
631 data.u.s.delete_token_size;
633 lck->base_name = (const char *)dbuf.dptr + sizeof(struct locking_data) +
634 (lck->num_share_modes * sizeof(struct share_mode_entry)) +
635 data.u.s.delete_token_size +
636 strlen(lck->servicepath) + 1;
638 lck->stream_name = (const char *)dbuf.dptr + sizeof(struct locking_data) +
639 (lck->num_share_modes * sizeof(struct share_mode_entry)) +
640 data.u.s.delete_token_size +
641 strlen(lck->servicepath) + 1 +
642 strlen(lck->base_name) + 1;
645 * Ensure that each entry has a real process attached.
648 for (i = 0; i < lck->num_share_modes; i++) {
649 struct share_mode_entry *entry_p = &lck->share_modes[i];
651 if (DEBUGLEVEL >= 10) {
652 str = share_mode_str(NULL, i, entry_p);
654 DEBUG(10,("parse_share_modes: %s\n",
656 if (!process_exists(entry_p->pid)) {
657 DEBUG(10,("parse_share_modes: deleted %s\n",
659 entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
660 lck->modified = True;
668 static TDB_DATA unparse_share_modes(const struct share_mode_lock *lck)
673 struct locking_data *data;
675 ssize_t sp_len, bn_len, sn_len;
676 uint32 delete_token_size;
681 for (i=0; i<lck->num_share_modes; i++) {
682 if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
687 if (num_valid == 0) {
691 sp_len = strlen(lck->servicepath);
692 bn_len = strlen(lck->base_name);
693 sn_len = lck->stream_name != NULL ? strlen(lck->stream_name) : 0;
695 delete_token_size = (lck->delete_token ?
696 (sizeof(uid_t) + sizeof(gid_t) + (lck->delete_token->ngroups*sizeof(gid_t))) : 0);
698 result.dsize = sizeof(*data) +
699 lck->num_share_modes * sizeof(struct share_mode_entry) +
704 result.dptr = TALLOC_ARRAY(lck, uint8, result.dsize);
706 if (result.dptr == NULL) {
707 smb_panic("talloc failed");
710 data = (struct locking_data *)result.dptr;
712 data->u.s.num_share_mode_entries = lck->num_share_modes;
713 data->u.s.delete_on_close = lck->delete_on_close;
714 data->u.s.old_write_time = lck->old_write_time;
715 data->u.s.changed_write_time = lck->changed_write_time;
716 data->u.s.delete_token_size = delete_token_size;
718 DEBUG(10,("unparse_share_modes: del: %d, owrt: %s cwrt: %s, tok: %u, "
719 "num: %d\n", data->u.s.delete_on_close,
720 timestring(debug_ctx(),
721 convert_timespec_to_time_t(lck->old_write_time)),
722 timestring(debug_ctx(),
723 convert_timespec_to_time_t(
724 lck->changed_write_time)),
725 (unsigned int)data->u.s.delete_token_size,
726 data->u.s.num_share_mode_entries));
728 memcpy(result.dptr + sizeof(*data), lck->share_modes,
729 sizeof(struct share_mode_entry)*lck->num_share_modes);
730 offset = sizeof(*data) +
731 sizeof(struct share_mode_entry)*lck->num_share_modes;
733 /* Store any delete on close token. */
734 if (lck->delete_token) {
735 uint8 *p = result.dptr + offset;
737 memcpy(p, &lck->delete_token->uid, sizeof(uid_t));
740 memcpy(p, &lck->delete_token->gid, sizeof(gid_t));
743 for (i = 0; i < lck->delete_token->ngroups; i++) {
744 memcpy(p, &lck->delete_token->groups[i], sizeof(gid_t));
747 offset = p - result.dptr;
750 safe_strcpy((char *)result.dptr + offset, lck->servicepath,
751 result.dsize - offset - 1);
752 offset += sp_len + 1;
753 safe_strcpy((char *)result.dptr + offset, lck->base_name,
754 result.dsize - offset - 1);
755 offset += bn_len + 1;
756 safe_strcpy((char *)result.dptr + offset, lck->stream_name,
757 result.dsize - offset - 1);
759 if (DEBUGLEVEL >= 10) {
760 print_share_mode_table(data);
766 static int share_mode_lock_destructor(struct share_mode_lock *lck)
771 if (!lck->modified) {
775 data = unparse_share_modes(lck);
777 if (data.dptr == NULL) {
779 /* There has been an entry before, delete it */
781 status = lck->record->delete_rec(lck->record);
782 if (!NT_STATUS_IS_OK(status)) {
783 DEBUG(0, ("delete_rec returned %s\n",
785 smb_panic("could not delete share entry");
791 status = lck->record->store(lck->record, data, TDB_REPLACE);
792 if (!NT_STATUS_IS_OK(status)) {
793 DEBUG(0, ("store returned %s\n", nt_errstr(status)));
794 smb_panic("could not store share mode entry");
802 static bool fill_share_mode_lock(struct share_mode_lock *lck,
804 const char *servicepath,
805 const struct smb_filename *smb_fname,
806 TDB_DATA share_mode_data,
807 const struct timespec *old_write_time)
809 /* Ensure we set every field here as the destructor must be
810 valid even if parse_share_modes fails. */
812 lck->servicepath = NULL;
813 lck->base_name = NULL;
814 lck->stream_name = NULL;
816 lck->num_share_modes = 0;
817 lck->share_modes = NULL;
818 lck->delete_token = NULL;
819 lck->delete_on_close = False;
820 ZERO_STRUCT(lck->old_write_time);
821 ZERO_STRUCT(lck->changed_write_time);
823 lck->modified = False;
825 lck->fresh = (share_mode_data.dptr == NULL);
829 if (smb_fname == NULL || servicepath == NULL
830 || old_write_time == NULL) {
834 has_stream = smb_fname->stream_name != NULL;
836 lck->base_name = talloc_strdup(lck, smb_fname->base_name);
837 lck->stream_name = talloc_strdup(lck, smb_fname->stream_name);
838 lck->servicepath = talloc_strdup(lck, servicepath);
839 if (lck->base_name == NULL ||
840 (has_stream && lck->stream_name == NULL) ||
841 lck->servicepath == NULL) {
842 DEBUG(0, ("talloc failed\n"));
845 lck->old_write_time = *old_write_time;
847 if (!parse_share_modes(share_mode_data, lck)) {
848 DEBUG(0, ("Could not parse share modes\n"));
856 struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
857 const struct file_id id,
858 const char *servicepath,
859 const struct smb_filename *smb_fname,
860 const struct timespec *old_write_time)
862 struct share_mode_lock *lck;
864 TDB_DATA key = locking_key(&id, &tmp);
866 if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
867 DEBUG(0, ("talloc failed\n"));
871 if (!(lck->record = lock_db->fetch_locked(lock_db, lck, key))) {
872 DEBUG(3, ("Could not lock share entry\n"));
877 if (!fill_share_mode_lock(lck, id, servicepath, smb_fname,
878 lck->record->value, old_write_time)) {
879 DEBUG(3, ("fill_share_mode_lock failed\n"));
884 talloc_set_destructor(lck, share_mode_lock_destructor);
889 struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
890 const struct file_id id)
892 struct share_mode_lock *lck;
894 TDB_DATA key = locking_key(&id, &tmp);
897 if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
898 DEBUG(0, ("talloc failed\n"));
902 if (lock_db->fetch(lock_db, lck, key, &data) == -1) {
903 DEBUG(3, ("Could not fetch share entry\n"));
908 if (!fill_share_mode_lock(lck, id, NULL, NULL, data, NULL)) {
909 DEBUG(10, ("fetch_share_mode_unlocked: no share_mode record "
910 "around (file not open)\n"));
918 /*******************************************************************
919 Sets the service name and filename for rename.
920 At this point we emit "file renamed" messages to all
921 process id's that have this file open.
922 Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
923 ********************************************************************/
925 bool rename_share_filename(struct messaging_context *msg_ctx,
926 struct share_mode_lock *lck,
927 const char *servicepath,
928 const struct smb_filename *smb_fname_dst)
936 bool strip_two_chars = false;
937 bool has_stream = smb_fname_dst->stream_name != NULL;
939 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
940 servicepath, smb_fname_dst->base_name));
943 * rename_internal_fsp() and rename_internals() add './' to
944 * head of newname if newname does not contain a '/'.
946 if (smb_fname_dst->base_name[0] &&
947 smb_fname_dst->base_name[1] &&
948 smb_fname_dst->base_name[0] == '.' &&
949 smb_fname_dst->base_name[1] == '/') {
950 strip_two_chars = true;
953 lck->servicepath = talloc_strdup(lck, servicepath);
954 lck->base_name = talloc_strdup(lck, smb_fname_dst->base_name +
955 (strip_two_chars ? 2 : 0));
956 lck->stream_name = talloc_strdup(lck, smb_fname_dst->stream_name);
957 if (lck->base_name == NULL ||
958 (has_stream && lck->stream_name == NULL) ||
959 lck->servicepath == NULL) {
960 DEBUG(0, ("rename_share_filename: talloc failed\n"));
963 lck->modified = True;
965 sp_len = strlen(lck->servicepath);
966 bn_len = strlen(lck->base_name);
967 sn_len = has_stream ? strlen(lck->stream_name) : 0;
969 msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
972 /* Set up the name changed message. */
973 frm = TALLOC_ARRAY(lck, char, msg_len);
978 push_file_id_24(frm, &lck->id);
980 DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
982 safe_strcpy(&frm[24], lck->servicepath, sp_len);
983 safe_strcpy(&frm[24 + sp_len + 1], lck->base_name, bn_len);
984 safe_strcpy(&frm[24 + sp_len + 1 + bn_len + 1], lck->stream_name,
987 /* Send the messages. */
988 for (i=0; i<lck->num_share_modes; i++) {
989 struct share_mode_entry *se = &lck->share_modes[i];
990 if (!is_valid_share_mode_entry(se)) {
993 /* But not to ourselves... */
994 if (procid_is_me(&se->pid)) {
998 DEBUG(10,("rename_share_filename: sending rename message to "
999 "pid %s file_id %s sharepath %s base_name %s "
1001 procid_str_static(&se->pid),
1002 file_id_string_tos(&lck->id),
1003 lck->servicepath, lck->base_name,
1004 has_stream ? lck->stream_name : ""));
1006 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
1007 (uint8 *)frm, msg_len);
1013 void get_file_infos(struct file_id id,
1014 bool *delete_on_close,
1015 struct timespec *write_time)
1017 struct share_mode_lock *lck;
1019 if (delete_on_close) {
1020 *delete_on_close = false;
1024 ZERO_STRUCTP(write_time);
1027 if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
1031 if (delete_on_close) {
1032 *delete_on_close = lck->delete_on_close;
1038 wt = lck->changed_write_time;
1039 if (null_timespec(wt)) {
1040 wt = lck->old_write_time;
1049 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
1053 if (e->op_type == UNUSED_SHARE_MODE_ENTRY) {
1054 /* cope with dead entries from the process not
1055 existing. These should not be considered valid,
1056 otherwise we end up doing zero timeout sharing
1061 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
1062 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
1063 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
1065 SMB_ASSERT(num_props <= 1);
1066 return (num_props != 0);
1069 bool is_deferred_open_entry(const struct share_mode_entry *e)
1071 return (e->op_type == DEFERRED_OPEN_ENTRY);
1074 bool is_unused_share_mode_entry(const struct share_mode_entry *e)
1076 return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
1079 /*******************************************************************
1080 Fill a share mode entry.
1081 ********************************************************************/
1083 static void fill_share_mode_entry(struct share_mode_entry *e,
1085 uid_t uid, uint16 mid, uint16 op_type)
1088 e->pid = procid_self();
1089 e->share_access = fsp->share_access;
1090 e->private_options = fsp->fh->private_options;
1091 e->access_mask = fsp->access_mask;
1093 e->op_type = op_type;
1094 e->time.tv_sec = fsp->open_time.tv_sec;
1095 e->time.tv_usec = fsp->open_time.tv_usec;
1096 e->id = fsp->file_id;
1097 e->share_file_id = fsp->fh->gen_id;
1098 e->uid = (uint32)uid;
1099 e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
1102 static void fill_deferred_open_entry(struct share_mode_entry *e,
1103 const struct timeval request_time,
1104 struct file_id id, uint16 mid)
1107 e->pid = procid_self();
1109 e->op_type = DEFERRED_OPEN_ENTRY;
1110 e->time.tv_sec = request_time.tv_sec;
1111 e->time.tv_usec = request_time.tv_usec;
1113 e->uid = (uint32)-1;
1117 static void add_share_mode_entry(struct share_mode_lock *lck,
1118 const struct share_mode_entry *entry)
1122 for (i=0; i<lck->num_share_modes; i++) {
1123 struct share_mode_entry *e = &lck->share_modes[i];
1124 if (is_unused_share_mode_entry(e)) {
1130 if (i == lck->num_share_modes) {
1131 /* No unused entry found */
1132 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
1133 &lck->share_modes, &lck->num_share_modes);
1135 lck->modified = True;
1138 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
1139 uid_t uid, uint16 mid, uint16 op_type)
1141 struct share_mode_entry entry;
1142 fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
1143 add_share_mode_entry(lck, &entry);
1146 void add_deferred_open(struct share_mode_lock *lck, uint16 mid,
1147 struct timeval request_time,
1150 struct share_mode_entry entry;
1151 fill_deferred_open_entry(&entry, request_time, id, mid);
1152 add_share_mode_entry(lck, &entry);
1155 /*******************************************************************
1156 Check if two share mode entries are identical, ignoring oplock
1157 and mid info and desired_access. (Removed paranoia test - it's
1158 not automatically a logic error if they are identical. JRA.)
1159 ********************************************************************/
1161 static bool share_modes_identical(struct share_mode_entry *e1,
1162 struct share_mode_entry *e2)
1164 /* We used to check for e1->share_access == e2->share_access here
1165 as well as the other fields but 2 different DOS or FCB opens
1166 sharing the same share mode entry may validly differ in
1167 fsp->share_access field. */
1169 return (procid_equal(&e1->pid, &e2->pid) &&
1170 file_id_equal(&e1->id, &e2->id) &&
1171 e1->share_file_id == e2->share_file_id );
1174 static bool deferred_open_identical(struct share_mode_entry *e1,
1175 struct share_mode_entry *e2)
1177 return (procid_equal(&e1->pid, &e2->pid) &&
1178 (e1->op_mid == e2->op_mid) &&
1179 file_id_equal(&e1->id, &e2->id));
1182 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
1183 struct share_mode_entry *entry)
1187 for (i=0; i<lck->num_share_modes; i++) {
1188 struct share_mode_entry *e = &lck->share_modes[i];
1189 if (is_valid_share_mode_entry(entry) &&
1190 is_valid_share_mode_entry(e) &&
1191 share_modes_identical(e, entry)) {
1194 if (is_deferred_open_entry(entry) &&
1195 is_deferred_open_entry(e) &&
1196 deferred_open_identical(e, entry)) {
1203 /*******************************************************************
1204 Del the share mode of a file for this process. Return the number of
1206 ********************************************************************/
1208 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
1210 struct share_mode_entry entry, *e;
1212 /* Don't care about the pid owner being correct here - just a search. */
1213 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1215 e = find_share_mode_entry(lck, &entry);
1220 e->op_type = UNUSED_SHARE_MODE_ENTRY;
1221 lck->modified = True;
1225 void del_deferred_open_entry(struct share_mode_lock *lck, uint16 mid)
1227 struct share_mode_entry entry, *e;
1229 fill_deferred_open_entry(&entry, timeval_zero(),
1232 e = find_share_mode_entry(lck, &entry);
1237 e->op_type = UNUSED_SHARE_MODE_ENTRY;
1238 lck->modified = True;
1241 /*******************************************************************
1242 Remove an oplock mid and mode entry from a share mode.
1243 ********************************************************************/
1245 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1247 struct share_mode_entry entry, *e;
1249 /* Don't care about the pid owner being correct here - just a search. */
1250 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1252 e = find_share_mode_entry(lck, &entry);
1258 if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
1260 * Going from exclusive or batch,
1261 * we always go through FAKE_LEVEL_II
1264 e->op_type = FAKE_LEVEL_II_OPLOCK;
1266 e->op_type = NO_OPLOCK;
1268 lck->modified = True;
1272 /*******************************************************************
1273 Downgrade a oplock type from exclusive to level II.
1274 ********************************************************************/
1276 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1278 struct share_mode_entry entry, *e;
1280 /* Don't care about the pid owner being correct here - just a search. */
1281 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1283 e = find_share_mode_entry(lck, &entry);
1288 e->op_type = LEVEL_II_OPLOCK;
1289 lck->modified = True;
1293 /****************************************************************************
1294 Deal with the internal needs of setting the delete on close flag. Note that
1295 as the tdb locking is recursive, it is safe to call this from within
1296 open_file_ntcreate. JRA.
1297 ****************************************************************************/
1299 NTSTATUS can_set_delete_on_close(files_struct *fsp, bool delete_on_close,
1302 if (!delete_on_close) {
1303 return NT_STATUS_OK;
1307 * Only allow delete on close for writable files.
1310 if ((dosmode & aRONLY) &&
1311 !lp_delete_readonly(SNUM(fsp->conn))) {
1312 DEBUG(10,("can_set_delete_on_close: file %s delete on close "
1313 "flag set but file attribute is readonly.\n",
1315 return NT_STATUS_CANNOT_DELETE;
1319 * Only allow delete on close for writable shares.
1322 if (!CAN_WRITE(fsp->conn)) {
1323 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1324 "close flag set but write access denied on share.\n",
1326 return NT_STATUS_ACCESS_DENIED;
1330 * Only allow delete on close for files/directories opened with delete
1334 if (!(fsp->access_mask & DELETE_ACCESS)) {
1335 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1336 "close flag set but delete access denied.\n",
1338 return NT_STATUS_ACCESS_DENIED;
1341 /* Don't allow delete on close for non-empty directories. */
1342 if (fsp->is_directory) {
1343 return can_delete_directory(fsp->conn, fsp->fsp_name);
1346 return NT_STATUS_OK;
1349 /*************************************************************************
1350 Return a talloced copy of a UNIX_USER_TOKEN. NULL on fail.
1351 (Should this be in locking.c.... ?).
1352 *************************************************************************/
1354 static UNIX_USER_TOKEN *copy_unix_token(TALLOC_CTX *ctx, const UNIX_USER_TOKEN *tok)
1356 UNIX_USER_TOKEN *cpy;
1362 cpy = TALLOC_P(ctx, UNIX_USER_TOKEN);
1367 cpy->uid = tok->uid;
1368 cpy->gid = tok->gid;
1369 cpy->ngroups = tok->ngroups;
1371 /* Make this a talloc child of cpy. */
1372 cpy->groups = TALLOC_ARRAY(cpy, gid_t, tok->ngroups);
1376 memcpy(cpy->groups, tok->groups, tok->ngroups * sizeof(gid_t));
1381 /****************************************************************************
1382 Replace the delete on close token.
1383 ****************************************************************************/
1385 void set_delete_on_close_token(struct share_mode_lock *lck, const UNIX_USER_TOKEN *tok)
1387 TALLOC_FREE(lck->delete_token); /* Also deletes groups... */
1389 /* Copy the new token (can be NULL). */
1390 lck->delete_token = copy_unix_token(lck, tok);
1391 lck->modified = True;
1394 /****************************************************************************
1395 Sets the delete on close flag over all share modes on this file.
1396 Modify the share mode entry for all files open
1397 on this device and inode to tell other smbds we have
1398 changed the delete on close flag. This will be noticed
1399 in the close code, the last closer will delete the file
1401 This makes a copy of any UNIX_USER_TOKEN into the
1402 lck entry. This function is used when the lock is already granted.
1403 ****************************************************************************/
1405 void set_delete_on_close_lck(struct share_mode_lock *lck, bool delete_on_close, const UNIX_USER_TOKEN *tok)
1407 if (lck->delete_on_close != delete_on_close) {
1408 set_delete_on_close_token(lck, tok);
1409 lck->delete_on_close = delete_on_close;
1410 if (delete_on_close) {
1411 SMB_ASSERT(lck->delete_token != NULL);
1413 lck->modified = True;
1417 bool set_delete_on_close(files_struct *fsp, bool delete_on_close, const UNIX_USER_TOKEN *tok)
1419 UNIX_USER_TOKEN *tok_copy = NULL;
1420 struct share_mode_lock *lck;
1422 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1423 "fnum = %d, file %s\n",
1424 delete_on_close ? "Adding" : "Removing", fsp->fnum,
1427 lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
1433 if (fsp->conn->admin_user) {
1434 tok_copy = copy_unix_token(lck, tok);
1435 if (tok_copy == NULL) {
1439 tok_copy->uid = (uid_t)0;
1443 set_delete_on_close_lck(lck, delete_on_close, tok);
1445 if (fsp->is_directory) {
1446 send_stat_cache_delete_message(fsp->fsp_name);
1453 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1455 struct share_mode_lock *lck;
1457 DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1458 timestring(debug_ctx(),
1459 convert_timespec_to_time_t(write_time)),
1460 file_id_string_tos(&fileid)));
1462 lck = get_share_mode_lock(NULL, fileid, NULL, NULL, NULL);
1467 if (timespec_compare(&lck->changed_write_time, &write_time) != 0) {
1468 lck->modified = True;
1469 lck->changed_write_time = write_time;
1476 bool set_write_time(struct file_id fileid, struct timespec write_time)
1478 struct share_mode_lock *lck;
1480 DEBUG(5,("set_write_time: %s id=%s\n",
1481 timestring(debug_ctx(),
1482 convert_timespec_to_time_t(write_time)),
1483 file_id_string_tos(&fileid)));
1485 lck = get_share_mode_lock(NULL, fileid, NULL, NULL, NULL);
1490 if (timespec_compare(&lck->old_write_time, &write_time) != 0) {
1491 lck->modified = True;
1492 lck->old_write_time = write_time;
1500 struct forall_state {
1501 void (*fn)(const struct share_mode_entry *entry,
1502 const char *sharepath,
1504 void *private_data);
1508 static int traverse_fn(struct db_record *rec, void *_state)
1510 struct forall_state *state = (struct forall_state *)_state;
1511 struct locking_data *data;
1512 struct share_mode_entry *shares;
1513 const char *sharepath;
1517 /* Ensure this is a locking_key record. */
1518 if (rec->key.dsize != sizeof(struct file_id))
1521 data = (struct locking_data *)rec->value.dptr;
1522 shares = (struct share_mode_entry *)(rec->value.dptr + sizeof(*data));
1523 sharepath = (const char *)rec->value.dptr + sizeof(*data) +
1524 data->u.s.num_share_mode_entries*sizeof(*shares) +
1525 data->u.s.delete_token_size;
1526 fname = (const char *)rec->value.dptr + sizeof(*data) +
1527 data->u.s.num_share_mode_entries*sizeof(*shares) +
1528 data->u.s.delete_token_size +
1529 strlen(sharepath) + 1;
1531 for (i=0;i<data->u.s.num_share_mode_entries;i++) {
1532 state->fn(&shares[i], sharepath, fname,
1533 state->private_data);
1538 /*******************************************************************
1539 Call the specified function on each entry under management by the
1541 ********************************************************************/
1543 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
1544 const char *, void *),
1547 struct forall_state state;
1549 if (lock_db == NULL)
1553 state.private_data = private_data;
1555 return lock_db->traverse_read(lock_db, traverse_fn, (void *)&state);