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 "librpc/gen_ndr/messaging.h"
40 #include "smbd/globals.h"
43 #define DBGC_CLASS DBGC_LOCKING
45 #define NO_LOCKING_COUNT (-1)
47 /* the locking database handle */
48 static struct db_context *lock_db;
50 /****************************************************************************
52 ****************************************************************************/
54 const char *lock_type_name(enum brl_type lock_type)
61 case PENDING_READ_LOCK:
62 return "PENDING_READ";
63 case PENDING_WRITE_LOCK:
64 return "PENDING_WRITE";
70 const char *lock_flav_name(enum brl_flavour lock_flav)
72 return (lock_flav == WINDOWS_LOCK) ? "WINDOWS_LOCK" : "POSIX_LOCK";
75 /****************************************************************************
76 Utility function called to see if a file region is locked.
77 Called in the read/write codepath.
78 ****************************************************************************/
80 void init_strict_lock_struct(files_struct *fsp,
84 enum brl_type lock_type,
85 struct lock_struct *plock)
87 SMB_ASSERT(lock_type == READ_LOCK || lock_type == WRITE_LOCK);
89 plock->context.smblctx = smblctx;
90 plock->context.tid = fsp->conn->cnum;
91 plock->context.pid = sconn_server_id(fsp->conn->sconn);
94 plock->fnum = fsp->fnum;
95 plock->lock_type = lock_type;
96 plock->lock_flav = lp_posix_cifsu_locktype(fsp);
99 bool strict_lock_default(files_struct *fsp, struct lock_struct *plock)
101 int strict_locking = lp_strict_locking(fsp->conn->params);
104 if (plock->size == 0) {
108 if (!lp_locking(fsp->conn->params) || !strict_locking) {
112 if (strict_locking == Auto) {
113 if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (plock->lock_type == READ_LOCK || plock->lock_type == WRITE_LOCK)) {
114 DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp_str_dbg(fsp)));
116 } else if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
117 (plock->lock_type == READ_LOCK)) {
118 DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp_str_dbg(fsp)));
121 struct byte_range_lock *br_lck;
123 br_lck = brl_get_locks_readonly(fsp);
127 ret = brl_locktest(br_lck,
128 plock->context.smblctx,
136 struct byte_range_lock *br_lck;
138 br_lck = brl_get_locks_readonly(fsp);
142 ret = brl_locktest(br_lck,
143 plock->context.smblctx,
151 DEBUG(10,("strict_lock_default: flavour = %s brl start=%.0f "
152 "len=%.0f %s for fnum %d file %s\n",
153 lock_flav_name(plock->lock_flav),
154 (double)plock->start, (double)plock->size,
155 ret ? "unlocked" : "locked",
156 plock->fnum, fsp_str_dbg(fsp)));
161 void strict_unlock_default(files_struct *fsp, struct lock_struct *plock)
165 /****************************************************************************
166 Find out if a lock could be granted - return who is blocking us if we can't.
167 ****************************************************************************/
169 NTSTATUS query_lock(files_struct *fsp,
173 enum brl_type *plock_type,
174 enum brl_flavour lock_flav)
176 struct byte_range_lock *br_lck = NULL;
178 if (!fsp->can_lock) {
179 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
182 if (!lp_locking(fsp->conn->params)) {
186 br_lck = brl_get_locks_readonly(fsp);
188 return NT_STATUS_NO_MEMORY;
191 return brl_lockquery(br_lck,
193 sconn_server_id(fsp->conn->sconn),
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 /* silently return ok on print files as we don't do locking there */
247 if (fsp->print_file) {
248 *perr = NT_STATUS_OK;
252 if (!fsp->can_lock) {
253 *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
257 if (!lp_locking(fsp->conn->params)) {
258 *perr = NT_STATUS_OK;
262 /* NOTE! 0 byte long ranges ARE allowed and should be stored */
264 DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f "
265 "blocking_lock=%s requested for fnum %d file %s\n",
266 lock_flav_name(lock_flav), lock_type_name(lock_type),
267 (double)offset, (double)count, blocking_lock ? "true" :
268 "false", fsp->fnum, fsp_str_dbg(fsp)));
270 br_lck = brl_get_locks(talloc_tos(), fsp);
272 *perr = NT_STATUS_NO_MEMORY;
276 *perr = brl_lock(msg_ctx,
279 sconn_server_id(fsp->conn->sconn),
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=%.0f len=%.0f requested for fnum %d file %s\n",
317 (double)offset, (double)count, fsp->fnum,
320 br_lck = brl_get_locks(talloc_tos(), fsp);
322 return NT_STATUS_NO_MEMORY;
325 ok = brl_unlock(msg_ctx,
328 sconn_server_id(fsp->conn->sconn),
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,
353 struct blocking_lock_record *blr)
356 struct byte_range_lock *br_lck = NULL;
358 if (!fsp->can_lock) {
359 return fsp->is_directory ?
360 NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
363 if (!lp_locking(fsp->conn->params)) {
364 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
367 DEBUG(10,("do_lock_cancel: cancel start=%.0f len=%.0f requested for fnum %d file %s\n",
368 (double)offset, (double)count, fsp->fnum,
371 br_lck = brl_get_locks(talloc_tos(), fsp);
373 return NT_STATUS_NO_MEMORY;
376 ok = brl_lock_cancel(br_lck,
378 sconn_server_id(fsp->conn->sconn),
387 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
388 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
391 decrement_current_lock_count(fsp, lock_flav);
395 /****************************************************************************
396 Remove any locks on this fd. Called from file_close().
397 ****************************************************************************/
399 void locking_close_file(struct messaging_context *msg_ctx,
401 enum file_close_type close_type)
403 struct byte_range_lock *br_lck;
405 if (!lp_locking(fsp->conn->params)) {
409 /* If we have not outstanding locks or pending
410 * locks then we don't need to look in the lock db.
413 if (fsp->current_lock_count == 0) {
417 br_lck = brl_get_locks(talloc_tos(),fsp);
420 cancel_pending_lock_requests_by_fid(fsp, br_lck, close_type);
421 brl_close_fnum(msg_ctx, br_lck);
426 /****************************************************************************
427 Initialise the locking functions.
428 ****************************************************************************/
430 static bool locking_init_internal(bool read_only)
437 lock_db = db_open(NULL, lock_path("locking.tdb"),
438 lp_open_files_db_hash_size(),
439 TDB_DEFAULT|TDB_VOLATILE|TDB_CLEAR_IF_FIRST,
440 read_only?O_RDONLY:O_RDWR|O_CREAT, 0644);
443 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
447 if (!posix_locking_init(read_only))
453 bool locking_init(void)
455 return locking_init_internal(false);
458 bool locking_init_readonly(void)
460 return locking_init_internal(true);
463 /*******************************************************************
464 Deinitialize the share_mode management.
465 ******************************************************************/
467 bool locking_end(void)
470 TALLOC_FREE(lock_db);
474 /*******************************************************************
475 Form a static locking key for a dev/inode pair.
476 ******************************************************************/
478 static TDB_DATA locking_key(const struct file_id *id, struct file_id *tmp)
481 return make_tdb_data((const uint8_t *)tmp, sizeof(*tmp));
484 /*******************************************************************
485 Print out a share mode.
486 ********************************************************************/
488 char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
490 return talloc_asprintf(ctx, "share_mode_entry[%d]: %s "
491 "pid = %s, share_access = 0x%x, private_options = 0x%x, "
492 "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %lu, "
493 "uid = %u, flags = %u, file_id %s",
495 e->op_type == UNUSED_SHARE_MODE_ENTRY ? "UNUSED" : "",
496 procid_str_static(&e->pid),
497 e->share_access, e->private_options,
498 e->access_mask, (unsigned long long)e->op_mid,
499 e->op_type, e->share_file_id,
500 (unsigned int)e->uid, (unsigned int)e->flags,
501 file_id_string_tos(&e->id));
504 /*******************************************************************
505 Print out a share mode table.
506 ********************************************************************/
508 static void print_share_mode_table(struct locking_data *data)
510 int num_share_modes = data->u.s.num_share_mode_entries;
511 struct share_mode_entry *shares =
512 (struct share_mode_entry *)(data + 1);
515 for (i = 0; i < num_share_modes; i++) {
516 struct share_mode_entry entry;
520 * We need to memcpy the entry here due to alignment
521 * restrictions that are not met when directly accessing
525 memcpy(&entry, &shares[i], sizeof(struct share_mode_entry));
526 str = share_mode_str(talloc_tos(), i, &entry);
528 DEBUG(10,("print_share_mode_table: %s\n", str ? str : ""));
533 /*******************************************************************
534 Get all share mode entries for a dev/inode pair.
535 ********************************************************************/
537 static bool parse_share_modes(const TDB_DATA dbuf, struct share_mode_lock *lck)
539 struct locking_data data;
542 if (dbuf.dsize < sizeof(struct locking_data)) {
543 smb_panic("parse_share_modes: buffer too short");
546 memcpy(&data, dbuf.dptr, sizeof(data));
548 lck->delete_on_close = data.u.s.delete_on_close;
549 lck->old_write_time = data.u.s.old_write_time;
550 lck->changed_write_time = data.u.s.changed_write_time;
551 lck->num_share_modes = data.u.s.num_share_mode_entries;
553 DEBUG(10, ("parse_share_modes: delete_on_close: %d, owrt: %s, "
554 "cwrt: %s, tok: %u, num_share_modes: %d\n",
555 lck->delete_on_close,
556 timestring(talloc_tos(),
557 convert_timespec_to_time_t(lck->old_write_time)),
558 timestring(talloc_tos(),
559 convert_timespec_to_time_t(
560 lck->changed_write_time)),
561 (unsigned int)data.u.s.delete_token_size,
562 lck->num_share_modes));
564 if ((lck->num_share_modes < 0) || (lck->num_share_modes > 1000000)) {
565 DEBUG(0, ("invalid number of share modes: %d\n",
566 lck->num_share_modes));
567 smb_panic("parse_share_modes: invalid number of share modes");
570 lck->share_modes = NULL;
572 if (lck->num_share_modes != 0) {
574 if (dbuf.dsize < (sizeof(struct locking_data) +
575 (lck->num_share_modes *
576 sizeof(struct share_mode_entry)))) {
577 smb_panic("parse_share_modes: buffer too short");
580 lck->share_modes = (struct share_mode_entry *)
582 dbuf.dptr+sizeof(struct locking_data),
583 lck->num_share_modes *
584 sizeof(struct share_mode_entry));
586 if (lck->share_modes == NULL) {
587 smb_panic("parse_share_modes: talloc failed");
591 /* Get any delete token. */
592 if (data.u.s.delete_token_size) {
593 uint8 *p = dbuf.dptr + sizeof(struct locking_data) +
594 (lck->num_share_modes *
595 sizeof(struct share_mode_entry));
597 if ((data.u.s.delete_token_size < sizeof(uid_t) + sizeof(gid_t)) ||
598 ((data.u.s.delete_token_size - sizeof(uid_t)) % sizeof(gid_t)) != 0) {
599 DEBUG(0, ("parse_share_modes: invalid token size %d\n",
600 data.u.s.delete_token_size));
601 smb_panic("parse_share_modes: invalid token size");
604 lck->delete_token = TALLOC_P(lck, UNIX_USER_TOKEN);
605 if (!lck->delete_token) {
606 smb_panic("parse_share_modes: talloc failed");
609 /* Copy out the uid and gid. */
610 memcpy(&lck->delete_token->uid, p, sizeof(uid_t));
612 memcpy(&lck->delete_token->gid, p, sizeof(gid_t));
615 /* Any supplementary groups ? */
616 lck->delete_token->ngroups = (data.u.s.delete_token_size > (sizeof(uid_t) + sizeof(gid_t))) ?
617 ((data.u.s.delete_token_size -
618 (sizeof(uid_t) + sizeof(gid_t)))/sizeof(gid_t)) : 0;
620 if (lck->delete_token->ngroups) {
621 /* Make this a talloc child of lck->delete_token. */
622 lck->delete_token->groups = TALLOC_ARRAY(lck->delete_token, gid_t,
623 lck->delete_token->ngroups);
624 if (!lck->delete_token) {
625 smb_panic("parse_share_modes: talloc failed");
628 for (i = 0; i < lck->delete_token->ngroups; i++) {
629 memcpy(&lck->delete_token->groups[i], p, sizeof(gid_t));
635 lck->delete_token = NULL;
638 /* Save off the associated service path and filename. */
639 lck->servicepath = (const char *)dbuf.dptr + sizeof(struct locking_data) +
640 (lck->num_share_modes * sizeof(struct share_mode_entry)) +
641 data.u.s.delete_token_size;
643 lck->base_name = (const char *)dbuf.dptr + sizeof(struct locking_data) +
644 (lck->num_share_modes * sizeof(struct share_mode_entry)) +
645 data.u.s.delete_token_size +
646 strlen(lck->servicepath) + 1;
648 lck->stream_name = (const char *)dbuf.dptr + sizeof(struct locking_data) +
649 (lck->num_share_modes * sizeof(struct share_mode_entry)) +
650 data.u.s.delete_token_size +
651 strlen(lck->servicepath) + 1 +
652 strlen(lck->base_name) + 1;
655 * Ensure that each entry has a real process attached.
658 for (i = 0; i < lck->num_share_modes; i++) {
659 struct share_mode_entry *entry_p = &lck->share_modes[i];
661 if (DEBUGLEVEL >= 10) {
662 str = share_mode_str(NULL, i, entry_p);
664 DEBUG(10,("parse_share_modes: %s\n",
666 if (!serverid_exists(&entry_p->pid)) {
667 DEBUG(10,("parse_share_modes: deleted %s\n",
669 entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
670 lck->modified = True;
678 static TDB_DATA unparse_share_modes(const struct share_mode_lock *lck)
683 struct locking_data *data;
685 ssize_t sp_len, bn_len, sn_len;
686 uint32 delete_token_size;
691 for (i=0; i<lck->num_share_modes; i++) {
692 if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
697 if (num_valid == 0) {
701 sp_len = strlen(lck->servicepath);
702 bn_len = strlen(lck->base_name);
703 sn_len = lck->stream_name != NULL ? strlen(lck->stream_name) : 0;
705 delete_token_size = (lck->delete_token ?
706 (sizeof(uid_t) + sizeof(gid_t) + (lck->delete_token->ngroups*sizeof(gid_t))) : 0);
708 result.dsize = sizeof(*data) +
709 lck->num_share_modes * sizeof(struct share_mode_entry) +
714 result.dptr = TALLOC_ARRAY(lck, uint8, result.dsize);
716 if (result.dptr == NULL) {
717 smb_panic("talloc failed");
720 data = (struct locking_data *)result.dptr;
722 data->u.s.num_share_mode_entries = lck->num_share_modes;
723 data->u.s.delete_on_close = lck->delete_on_close;
724 data->u.s.old_write_time = lck->old_write_time;
725 data->u.s.changed_write_time = lck->changed_write_time;
726 data->u.s.delete_token_size = delete_token_size;
728 DEBUG(10,("unparse_share_modes: del: %d, owrt: %s cwrt: %s, tok: %u, "
729 "num: %d\n", data->u.s.delete_on_close,
730 timestring(talloc_tos(),
731 convert_timespec_to_time_t(lck->old_write_time)),
732 timestring(talloc_tos(),
733 convert_timespec_to_time_t(
734 lck->changed_write_time)),
735 (unsigned int)data->u.s.delete_token_size,
736 data->u.s.num_share_mode_entries));
738 memcpy(result.dptr + sizeof(*data), lck->share_modes,
739 sizeof(struct share_mode_entry)*lck->num_share_modes);
740 offset = sizeof(*data) +
741 sizeof(struct share_mode_entry)*lck->num_share_modes;
743 /* Store any delete on close token. */
744 if (lck->delete_token) {
745 uint8 *p = result.dptr + offset;
747 memcpy(p, &lck->delete_token->uid, sizeof(uid_t));
750 memcpy(p, &lck->delete_token->gid, sizeof(gid_t));
753 for (i = 0; i < lck->delete_token->ngroups; i++) {
754 memcpy(p, &lck->delete_token->groups[i], sizeof(gid_t));
757 offset = p - result.dptr;
760 safe_strcpy((char *)result.dptr + offset, lck->servicepath,
761 result.dsize - offset - 1);
762 offset += sp_len + 1;
763 safe_strcpy((char *)result.dptr + offset, lck->base_name,
764 result.dsize - offset - 1);
765 offset += bn_len + 1;
766 safe_strcpy((char *)result.dptr + offset, lck->stream_name,
767 result.dsize - offset - 1);
769 if (DEBUGLEVEL >= 10) {
770 print_share_mode_table(data);
776 static int share_mode_lock_destructor(struct share_mode_lock *lck)
781 if (!lck->modified) {
785 data = unparse_share_modes(lck);
787 if (data.dptr == NULL) {
789 /* There has been an entry before, delete it */
791 status = lck->record->delete_rec(lck->record);
792 if (!NT_STATUS_IS_OK(status)) {
795 DEBUG(0, ("delete_rec returned %s\n",
798 if (asprintf(&errmsg, "could not delete share "
800 nt_errstr(status)) == -1) {
801 smb_panic("could not delete share"
810 status = lck->record->store(lck->record, data, TDB_REPLACE);
811 if (!NT_STATUS_IS_OK(status)) {
814 DEBUG(0, ("store returned %s\n", nt_errstr(status)));
816 if (asprintf(&errmsg, "could not store share mode entry: %s",
817 nt_errstr(status)) == -1) {
818 smb_panic("could not store share mode entry");
828 static bool fill_share_mode_lock(struct share_mode_lock *lck,
830 const char *servicepath,
831 const struct smb_filename *smb_fname,
832 TDB_DATA share_mode_data,
833 const struct timespec *old_write_time)
835 /* Ensure we set every field here as the destructor must be
836 valid even if parse_share_modes fails. */
838 lck->servicepath = NULL;
839 lck->base_name = NULL;
840 lck->stream_name = NULL;
842 lck->num_share_modes = 0;
843 lck->share_modes = NULL;
844 lck->delete_token = NULL;
845 lck->delete_on_close = False;
846 ZERO_STRUCT(lck->old_write_time);
847 ZERO_STRUCT(lck->changed_write_time);
849 lck->modified = False;
851 lck->fresh = (share_mode_data.dptr == NULL);
855 if (smb_fname == NULL || servicepath == NULL
856 || old_write_time == NULL) {
860 has_stream = smb_fname->stream_name != NULL;
862 lck->base_name = talloc_strdup(lck, smb_fname->base_name);
863 lck->stream_name = talloc_strdup(lck, smb_fname->stream_name);
864 lck->servicepath = talloc_strdup(lck, servicepath);
865 if (lck->base_name == NULL ||
866 (has_stream && lck->stream_name == NULL) ||
867 lck->servicepath == NULL) {
868 DEBUG(0, ("talloc failed\n"));
871 lck->old_write_time = *old_write_time;
873 if (!parse_share_modes(share_mode_data, lck)) {
874 DEBUG(0, ("Could not parse share modes\n"));
882 struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
883 const struct file_id id,
884 const char *servicepath,
885 const struct smb_filename *smb_fname,
886 const struct timespec *old_write_time)
888 struct share_mode_lock *lck;
890 TDB_DATA key = locking_key(&id, &tmp);
892 if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
893 DEBUG(0, ("talloc failed\n"));
897 if (!(lck->record = lock_db->fetch_locked(lock_db, lck, key))) {
898 DEBUG(3, ("Could not lock share entry\n"));
903 if (!fill_share_mode_lock(lck, id, servicepath, smb_fname,
904 lck->record->value, old_write_time)) {
905 DEBUG(3, ("fill_share_mode_lock failed\n"));
910 talloc_set_destructor(lck, share_mode_lock_destructor);
915 struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
916 const struct file_id id)
918 struct share_mode_lock *lck;
920 TDB_DATA key = locking_key(&id, &tmp);
923 if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
924 DEBUG(0, ("talloc failed\n"));
928 if (lock_db->fetch(lock_db, lck, key, &data) == -1) {
929 DEBUG(3, ("Could not fetch share entry\n"));
934 if (!fill_share_mode_lock(lck, id, NULL, NULL, data, NULL)) {
935 DEBUG(10, ("fetch_share_mode_unlocked: no share_mode record "
936 "around (file not open)\n"));
944 /*******************************************************************
945 Sets the service name and filename for rename.
946 At this point we emit "file renamed" messages to all
947 process id's that have this file open.
948 Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
949 ********************************************************************/
951 bool rename_share_filename(struct messaging_context *msg_ctx,
952 struct share_mode_lock *lck,
953 const char *servicepath,
954 const struct smb_filename *smb_fname_dst)
962 bool strip_two_chars = false;
963 bool has_stream = smb_fname_dst->stream_name != NULL;
965 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
966 servicepath, smb_fname_dst->base_name));
969 * rename_internal_fsp() and rename_internals() add './' to
970 * head of newname if newname does not contain a '/'.
972 if (smb_fname_dst->base_name[0] &&
973 smb_fname_dst->base_name[1] &&
974 smb_fname_dst->base_name[0] == '.' &&
975 smb_fname_dst->base_name[1] == '/') {
976 strip_two_chars = true;
979 lck->servicepath = talloc_strdup(lck, servicepath);
980 lck->base_name = talloc_strdup(lck, smb_fname_dst->base_name +
981 (strip_two_chars ? 2 : 0));
982 lck->stream_name = talloc_strdup(lck, smb_fname_dst->stream_name);
983 if (lck->base_name == NULL ||
984 (has_stream && lck->stream_name == NULL) ||
985 lck->servicepath == NULL) {
986 DEBUG(0, ("rename_share_filename: talloc failed\n"));
989 lck->modified = True;
991 sp_len = strlen(lck->servicepath);
992 bn_len = strlen(lck->base_name);
993 sn_len = has_stream ? strlen(lck->stream_name) : 0;
995 msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
998 /* Set up the name changed message. */
999 frm = TALLOC_ARRAY(lck, char, msg_len);
1004 push_file_id_24(frm, &lck->id);
1006 DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
1008 safe_strcpy(&frm[24], lck->servicepath, sp_len);
1009 safe_strcpy(&frm[24 + sp_len + 1], lck->base_name, bn_len);
1010 safe_strcpy(&frm[24 + sp_len + 1 + bn_len + 1], lck->stream_name,
1013 /* Send the messages. */
1014 for (i=0; i<lck->num_share_modes; i++) {
1015 struct share_mode_entry *se = &lck->share_modes[i];
1016 if (!is_valid_share_mode_entry(se)) {
1019 /* But not to ourselves... */
1020 if (procid_is_me(&se->pid)) {
1024 DEBUG(10,("rename_share_filename: sending rename message to "
1025 "pid %s file_id %s sharepath %s base_name %s "
1027 procid_str_static(&se->pid),
1028 file_id_string_tos(&lck->id),
1029 lck->servicepath, lck->base_name,
1030 has_stream ? lck->stream_name : ""));
1032 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
1033 (uint8 *)frm, msg_len);
1039 void get_file_infos(struct file_id id,
1040 bool *delete_on_close,
1041 struct timespec *write_time)
1043 struct share_mode_lock *lck;
1045 if (delete_on_close) {
1046 *delete_on_close = false;
1050 ZERO_STRUCTP(write_time);
1053 if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
1057 if (delete_on_close) {
1058 *delete_on_close = lck->delete_on_close;
1064 wt = lck->changed_write_time;
1065 if (null_timespec(wt)) {
1066 wt = lck->old_write_time;
1075 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
1079 if (e->op_type == UNUSED_SHARE_MODE_ENTRY) {
1080 /* cope with dead entries from the process not
1081 existing. These should not be considered valid,
1082 otherwise we end up doing zero timeout sharing
1087 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
1088 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
1089 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
1091 SMB_ASSERT(num_props <= 1);
1092 return (num_props != 0);
1095 bool is_deferred_open_entry(const struct share_mode_entry *e)
1097 return (e->op_type == DEFERRED_OPEN_ENTRY);
1100 bool is_unused_share_mode_entry(const struct share_mode_entry *e)
1102 return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
1105 /*******************************************************************
1106 Fill a share mode entry.
1107 ********************************************************************/
1109 static void fill_share_mode_entry(struct share_mode_entry *e,
1111 uid_t uid, uint64_t mid, uint16 op_type)
1114 e->pid = sconn_server_id(fsp->conn->sconn);
1115 e->share_access = fsp->share_access;
1116 e->private_options = fsp->fh->private_options;
1117 e->access_mask = fsp->access_mask;
1119 e->op_type = op_type;
1120 e->time.tv_sec = fsp->open_time.tv_sec;
1121 e->time.tv_usec = fsp->open_time.tv_usec;
1122 e->id = fsp->file_id;
1123 e->share_file_id = fsp->fh->gen_id;
1124 e->uid = (uint32)uid;
1125 e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
1128 static void fill_deferred_open_entry(struct share_mode_entry *e,
1129 const struct timeval request_time,
1131 struct server_id pid,
1137 e->op_type = DEFERRED_OPEN_ENTRY;
1138 e->time.tv_sec = request_time.tv_sec;
1139 e->time.tv_usec = request_time.tv_usec;
1141 e->uid = (uint32)-1;
1145 static void add_share_mode_entry(struct share_mode_lock *lck,
1146 const struct share_mode_entry *entry)
1150 for (i=0; i<lck->num_share_modes; i++) {
1151 struct share_mode_entry *e = &lck->share_modes[i];
1152 if (is_unused_share_mode_entry(e)) {
1158 if (i == lck->num_share_modes) {
1159 /* No unused entry found */
1160 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
1161 &lck->share_modes, &lck->num_share_modes);
1163 lck->modified = True;
1166 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
1167 uid_t uid, uint64_t mid, uint16 op_type)
1169 struct share_mode_entry entry;
1170 fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
1171 add_share_mode_entry(lck, &entry);
1174 void add_deferred_open(struct share_mode_lock *lck, uint64_t mid,
1175 struct timeval request_time,
1176 struct server_id pid, struct file_id id)
1178 struct share_mode_entry entry;
1179 fill_deferred_open_entry(&entry, request_time, id, pid, mid);
1180 add_share_mode_entry(lck, &entry);
1183 /*******************************************************************
1184 Check if two share mode entries are identical, ignoring oplock
1185 and mid info and desired_access. (Removed paranoia test - it's
1186 not automatically a logic error if they are identical. JRA.)
1187 ********************************************************************/
1189 static bool share_modes_identical(struct share_mode_entry *e1,
1190 struct share_mode_entry *e2)
1192 /* We used to check for e1->share_access == e2->share_access here
1193 as well as the other fields but 2 different DOS or FCB opens
1194 sharing the same share mode entry may validly differ in
1195 fsp->share_access field. */
1197 return (procid_equal(&e1->pid, &e2->pid) &&
1198 file_id_equal(&e1->id, &e2->id) &&
1199 e1->share_file_id == e2->share_file_id );
1202 static bool deferred_open_identical(struct share_mode_entry *e1,
1203 struct share_mode_entry *e2)
1205 return (procid_equal(&e1->pid, &e2->pid) &&
1206 (e1->op_mid == e2->op_mid) &&
1207 file_id_equal(&e1->id, &e2->id));
1210 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
1211 struct share_mode_entry *entry)
1215 for (i=0; i<lck->num_share_modes; i++) {
1216 struct share_mode_entry *e = &lck->share_modes[i];
1217 if (is_valid_share_mode_entry(entry) &&
1218 is_valid_share_mode_entry(e) &&
1219 share_modes_identical(e, entry)) {
1222 if (is_deferred_open_entry(entry) &&
1223 is_deferred_open_entry(e) &&
1224 deferred_open_identical(e, entry)) {
1231 /*******************************************************************
1232 Del the share mode of a file for this process. Return the number of
1234 ********************************************************************/
1236 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
1238 struct share_mode_entry entry, *e;
1240 /* Don't care about the pid owner being correct here - just a search. */
1241 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1243 e = find_share_mode_entry(lck, &entry);
1248 e->op_type = UNUSED_SHARE_MODE_ENTRY;
1249 lck->modified = True;
1253 void del_deferred_open_entry(struct share_mode_lock *lck, uint64_t mid,
1254 struct server_id pid)
1256 struct share_mode_entry entry, *e;
1258 fill_deferred_open_entry(&entry, timeval_zero(),
1261 e = find_share_mode_entry(lck, &entry);
1266 e->op_type = UNUSED_SHARE_MODE_ENTRY;
1267 lck->modified = True;
1270 /*******************************************************************
1271 Remove an oplock mid and mode entry from a share mode.
1272 ********************************************************************/
1274 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1276 struct share_mode_entry entry, *e;
1278 /* Don't care about the pid owner being correct here - just a search. */
1279 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1281 e = find_share_mode_entry(lck, &entry);
1287 if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
1289 * Going from exclusive or batch,
1290 * we always go through FAKE_LEVEL_II
1293 e->op_type = FAKE_LEVEL_II_OPLOCK;
1295 e->op_type = NO_OPLOCK;
1297 lck->modified = True;
1301 /*******************************************************************
1302 Downgrade a oplock type from exclusive to level II.
1303 ********************************************************************/
1305 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1307 struct share_mode_entry entry, *e;
1309 /* Don't care about the pid owner being correct here - just a search. */
1310 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1312 e = find_share_mode_entry(lck, &entry);
1317 e->op_type = LEVEL_II_OPLOCK;
1318 lck->modified = True;
1322 /****************************************************************************
1323 Check if setting delete on close is allowed on this fsp.
1324 ****************************************************************************/
1326 NTSTATUS can_set_delete_on_close(files_struct *fsp, uint32 dosmode)
1329 * Only allow delete on close for writable files.
1332 if ((dosmode & aRONLY) &&
1333 !lp_delete_readonly(SNUM(fsp->conn))) {
1334 DEBUG(10,("can_set_delete_on_close: file %s delete on close "
1335 "flag set but file attribute is readonly.\n",
1337 return NT_STATUS_CANNOT_DELETE;
1341 * Only allow delete on close for writable shares.
1344 if (!CAN_WRITE(fsp->conn)) {
1345 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1346 "close flag set but write access denied on share.\n",
1348 return NT_STATUS_ACCESS_DENIED;
1352 * Only allow delete on close for files/directories opened with delete
1356 if (!(fsp->access_mask & DELETE_ACCESS)) {
1357 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1358 "close flag set but delete access denied.\n",
1360 return NT_STATUS_ACCESS_DENIED;
1363 /* Don't allow delete on close for non-empty directories. */
1364 if (fsp->is_directory) {
1365 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1366 return can_delete_directory(fsp->conn,
1367 fsp->fsp_name->base_name);
1370 return NT_STATUS_OK;
1373 /*************************************************************************
1374 Return a talloced copy of a UNIX_USER_TOKEN. NULL on fail.
1375 (Should this be in locking.c.... ?).
1376 *************************************************************************/
1378 static UNIX_USER_TOKEN *copy_unix_token(TALLOC_CTX *ctx, const UNIX_USER_TOKEN *tok)
1380 UNIX_USER_TOKEN *cpy;
1386 cpy = TALLOC_P(ctx, UNIX_USER_TOKEN);
1391 cpy->uid = tok->uid;
1392 cpy->gid = tok->gid;
1393 cpy->ngroups = tok->ngroups;
1395 /* Make this a talloc child of cpy. */
1396 cpy->groups = TALLOC_ARRAY(cpy, gid_t, tok->ngroups);
1400 memcpy(cpy->groups, tok->groups, tok->ngroups * sizeof(gid_t));
1405 /****************************************************************************
1406 Replace the delete on close token.
1407 ****************************************************************************/
1409 void set_delete_on_close_token(struct share_mode_lock *lck, const UNIX_USER_TOKEN *tok)
1411 TALLOC_FREE(lck->delete_token); /* Also deletes groups... */
1413 /* Copy the new token (can be NULL). */
1414 lck->delete_token = copy_unix_token(lck, tok);
1415 lck->modified = True;
1418 /****************************************************************************
1419 Sets the delete on close flag over all share modes on this file.
1420 Modify the share mode entry for all files open
1421 on this device and inode to tell other smbds we have
1422 changed the delete on close flag. This will be noticed
1423 in the close code, the last closer will delete the file
1425 This makes a copy of any UNIX_USER_TOKEN into the
1426 lck entry. This function is used when the lock is already granted.
1427 ****************************************************************************/
1429 void set_delete_on_close_lck(struct share_mode_lock *lck, bool delete_on_close, const UNIX_USER_TOKEN *tok)
1431 if (lck->delete_on_close != delete_on_close) {
1432 set_delete_on_close_token(lck, tok);
1433 lck->delete_on_close = delete_on_close;
1434 if (delete_on_close) {
1435 SMB_ASSERT(lck->delete_token != NULL);
1437 lck->modified = True;
1441 bool set_delete_on_close(files_struct *fsp, bool delete_on_close, const UNIX_USER_TOKEN *tok)
1443 struct share_mode_lock *lck;
1445 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1446 "fnum = %d, file %s\n",
1447 delete_on_close ? "Adding" : "Removing", fsp->fnum,
1450 lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
1456 set_delete_on_close_lck(lck, delete_on_close, tok);
1458 if (fsp->is_directory) {
1459 SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
1460 send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
1461 fsp->fsp_name->base_name);
1466 fsp->delete_on_close = delete_on_close;
1471 bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
1473 struct share_mode_lock *lck;
1475 DEBUG(5,("set_sticky_write_time: %s id=%s\n",
1476 timestring(talloc_tos(),
1477 convert_timespec_to_time_t(write_time)),
1478 file_id_string_tos(&fileid)));
1480 lck = get_share_mode_lock(NULL, fileid, NULL, NULL, NULL);
1485 if (timespec_compare(&lck->changed_write_time, &write_time) != 0) {
1486 lck->modified = True;
1487 lck->changed_write_time = write_time;
1494 bool set_write_time(struct file_id fileid, struct timespec write_time)
1496 struct share_mode_lock *lck;
1498 DEBUG(5,("set_write_time: %s id=%s\n",
1499 timestring(talloc_tos(),
1500 convert_timespec_to_time_t(write_time)),
1501 file_id_string_tos(&fileid)));
1503 lck = get_share_mode_lock(NULL, fileid, NULL, NULL, NULL);
1508 if (timespec_compare(&lck->old_write_time, &write_time) != 0) {
1509 lck->modified = True;
1510 lck->old_write_time = write_time;
1518 struct forall_state {
1519 void (*fn)(const struct share_mode_entry *entry,
1520 const char *sharepath,
1522 void *private_data);
1526 static int traverse_fn(struct db_record *rec, void *_state)
1528 struct forall_state *state = (struct forall_state *)_state;
1529 struct locking_data *data;
1530 struct share_mode_entry *shares;
1531 const char *sharepath;
1535 /* Ensure this is a locking_key record. */
1536 if (rec->key.dsize != sizeof(struct file_id))
1539 data = (struct locking_data *)rec->value.dptr;
1540 shares = (struct share_mode_entry *)(rec->value.dptr + sizeof(*data));
1541 sharepath = (const char *)rec->value.dptr + sizeof(*data) +
1542 data->u.s.num_share_mode_entries*sizeof(*shares) +
1543 data->u.s.delete_token_size;
1544 fname = (const char *)rec->value.dptr + sizeof(*data) +
1545 data->u.s.num_share_mode_entries*sizeof(*shares) +
1546 data->u.s.delete_token_size +
1547 strlen(sharepath) + 1;
1549 for (i=0;i<data->u.s.num_share_mode_entries;i++) {
1550 state->fn(&shares[i], sharepath, fname,
1551 state->private_data);
1556 /*******************************************************************
1557 Call the specified function on each entry under management by the
1559 ********************************************************************/
1561 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
1562 const char *, void *),
1565 struct forall_state state;
1567 if (lock_db == NULL)
1571 state.private_data = private_data;
1573 return lock_db->traverse_read(lock_db, traverse_fn, (void *)&state);