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 bool is_locked(files_struct *fsp,
82 enum brl_type lock_type)
84 int strict_locking = lp_strict_locking(fsp->conn->params);
85 enum brl_flavour lock_flav = lp_posix_cifsu_locktype(fsp);
92 if (!lp_locking(fsp->conn->params) || !strict_locking) {
96 if (strict_locking == Auto) {
97 if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (lock_type == READ_LOCK || lock_type == WRITE_LOCK)) {
98 DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp->fsp_name ));
100 } else if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
101 (lock_type == READ_LOCK)) {
102 DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp->fsp_name ));
105 struct byte_range_lock *br_lck = brl_get_locks_readonly(talloc_tos(), fsp);
109 ret = !brl_locktest(br_lck,
119 struct byte_range_lock *br_lck = brl_get_locks_readonly(talloc_tos(), fsp);
123 ret = !brl_locktest(br_lck,
133 DEBUG(10,("is_locked: flavour = %s brl start=%.0f len=%.0f %s for fnum %d file %s\n",
134 lock_flav_name(lock_flav),
135 (double)offset, (double)count, ret ? "locked" : "unlocked",
136 fsp->fnum, fsp->fsp_name ));
141 /****************************************************************************
142 Find out if a lock could be granted - return who is blocking us if we can't.
143 ****************************************************************************/
145 NTSTATUS query_lock(files_struct *fsp,
147 SMB_BIG_UINT *pcount,
148 SMB_BIG_UINT *poffset,
149 enum brl_type *plock_type,
150 enum brl_flavour lock_flav)
152 struct byte_range_lock *br_lck = NULL;
153 NTSTATUS status = NT_STATUS_LOCK_NOT_GRANTED;
155 if (!fsp->can_lock) {
156 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
159 if (!lp_locking(fsp->conn->params)) {
163 br_lck = brl_get_locks_readonly(talloc_tos(), fsp);
165 return NT_STATUS_NO_MEMORY;
168 status = brl_lockquery(br_lck,
180 /****************************************************************************
181 Utility function called by locking requests.
182 ****************************************************************************/
184 struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
189 enum brl_type lock_type,
190 enum brl_flavour lock_flav,
195 struct byte_range_lock *br_lck = NULL;
197 if (!fsp->can_lock) {
198 *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
202 if (!lp_locking(fsp->conn->params)) {
203 *perr = NT_STATUS_OK;
207 /* NOTE! 0 byte long ranges ARE allowed and should be stored */
209 DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f requested for fnum %d file %s\n",
210 lock_flav_name(lock_flav), lock_type_name(lock_type),
211 (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
213 br_lck = brl_get_locks(talloc_tos(), fsp);
215 *perr = NT_STATUS_NO_MEMORY;
219 *perr = brl_lock(msg_ctx,
230 if (lock_flav == WINDOWS_LOCK &&
231 fsp->current_lock_count != NO_LOCKING_COUNT) {
232 /* blocking ie. pending, locks also count here,
233 * as this is an efficiency counter to avoid checking
234 * the lock db. on close. JRA. */
236 fsp->current_lock_count++;
238 /* Notice that this has had a POSIX lock request.
239 * We can't count locks after this so forget them.
241 fsp->current_lock_count = NO_LOCKING_COUNT;
247 /****************************************************************************
248 Utility function called by unlocking requests.
249 ****************************************************************************/
251 NTSTATUS do_unlock(struct messaging_context *msg_ctx,
256 enum brl_flavour lock_flav)
259 struct byte_range_lock *br_lck = NULL;
261 if (!fsp->can_lock) {
262 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
265 if (!lp_locking(fsp->conn->params)) {
269 DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for fnum %d file %s\n",
270 (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
272 br_lck = brl_get_locks(talloc_tos(), fsp);
274 return NT_STATUS_NO_MEMORY;
277 ok = brl_unlock(msg_ctx,
288 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
289 return NT_STATUS_RANGE_NOT_LOCKED;
292 if (lock_flav == WINDOWS_LOCK &&
293 fsp->current_lock_count != NO_LOCKING_COUNT) {
294 SMB_ASSERT(fsp->current_lock_count > 0);
295 fsp->current_lock_count--;
301 /****************************************************************************
302 Cancel any pending blocked locks.
303 ****************************************************************************/
305 NTSTATUS do_lock_cancel(files_struct *fsp,
309 enum brl_flavour lock_flav)
312 struct byte_range_lock *br_lck = NULL;
314 if (!fsp->can_lock) {
315 return fsp->is_directory ?
316 NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
319 if (!lp_locking(fsp->conn->params)) {
320 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
323 DEBUG(10,("do_lock_cancel: cancel start=%.0f len=%.0f requested for fnum %d file %s\n",
324 (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
326 br_lck = brl_get_locks(talloc_tos(), fsp);
328 return NT_STATUS_NO_MEMORY;
331 ok = brl_lock_cancel(br_lck,
341 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
342 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
345 if (lock_flav == WINDOWS_LOCK &&
346 fsp->current_lock_count != NO_LOCKING_COUNT) {
347 SMB_ASSERT(fsp->current_lock_count > 0);
348 fsp->current_lock_count--;
354 /****************************************************************************
355 Remove any locks on this fd. Called from file_close().
356 ****************************************************************************/
358 void locking_close_file(struct messaging_context *msg_ctx,
361 struct byte_range_lock *br_lck;
363 if (!lp_locking(fsp->conn->params)) {
367 /* If we have not outstanding locks or pending
368 * locks then we don't need to look in the lock db.
371 if (fsp->current_lock_count == 0) {
375 br_lck = brl_get_locks(talloc_tos(),fsp);
378 cancel_pending_lock_requests_by_fid(fsp, br_lck);
379 brl_close_fnum(msg_ctx, br_lck);
384 /****************************************************************************
385 Initialise the locking functions.
386 ****************************************************************************/
388 static bool locking_init_internal(bool read_only)
395 lock_db = db_open(NULL, lock_path("locking.tdb"), 0,
398 |(read_only?0x0:TDB_CLEAR_IF_FIRST),
399 read_only?O_RDONLY:O_RDWR|O_CREAT, 0644);
402 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
406 if (!posix_locking_init(read_only))
412 bool locking_init(void)
414 return locking_init_internal(false);
417 bool locking_init_readonly(void)
419 return locking_init_internal(true);
422 /*******************************************************************
423 Deinitialize the share_mode management.
424 ******************************************************************/
426 bool locking_end(void)
429 TALLOC_FREE(lock_db);
433 /*******************************************************************
434 Form a static locking key for a dev/inode pair.
435 ******************************************************************/
437 static TDB_DATA locking_key(const struct file_id *id, struct file_id *tmp)
440 return make_tdb_data((const uint8_t *)tmp, sizeof(*tmp));
443 /*******************************************************************
444 Print out a share mode.
445 ********************************************************************/
447 char *share_mode_str(TALLOC_CTX *ctx, int num, struct share_mode_entry *e)
449 return talloc_asprintf(ctx, "share_mode_entry[%d]: %s "
450 "pid = %s, share_access = 0x%x, private_options = 0x%x, "
451 "access_mask = 0x%x, mid = 0x%x, type= 0x%x, gen_id = %lu, "
452 "uid = %u, flags = %u, file_id %s",
454 e->op_type == UNUSED_SHARE_MODE_ENTRY ? "UNUSED" : "",
455 procid_str_static(&e->pid),
456 e->share_access, e->private_options,
457 e->access_mask, e->op_mid, e->op_type, e->share_file_id,
458 (unsigned int)e->uid, (unsigned int)e->flags,
459 file_id_string_tos(&e->id));
462 /*******************************************************************
463 Print out a share mode table.
464 ********************************************************************/
466 static void print_share_mode_table(struct locking_data *data)
468 int num_share_modes = data->u.s.num_share_mode_entries;
469 struct share_mode_entry *shares =
470 (struct share_mode_entry *)(data + 1);
473 for (i = 0; i < num_share_modes; i++) {
474 struct share_mode_entry entry;
478 * We need to memcpy the entry here due to alignment
479 * restrictions that are not met when directly accessing
483 memcpy(&entry, &shares[i], sizeof(struct share_mode_entry));
484 str = share_mode_str(talloc_tos(), i, &entry);
486 DEBUG(10,("print_share_mode_table: %s\n", str ? str : ""));
491 /*******************************************************************
492 Get all share mode entries for a dev/inode pair.
493 ********************************************************************/
495 static bool parse_share_modes(TDB_DATA dbuf, struct share_mode_lock *lck)
497 struct locking_data *data;
500 if (dbuf.dsize < sizeof(struct locking_data)) {
501 smb_panic("parse_share_modes: buffer too short");
504 data = (struct locking_data *)dbuf.dptr;
506 lck->delete_on_close = data->u.s.delete_on_close;
507 lck->num_share_modes = data->u.s.num_share_mode_entries;
509 DEBUG(10, ("parse_share_modes: delete_on_close: %d, "
510 "num_share_modes: %d\n",
511 lck->delete_on_close,
512 lck->num_share_modes));
514 if ((lck->num_share_modes < 0) || (lck->num_share_modes > 1000000)) {
515 DEBUG(0, ("invalid number of share modes: %d\n",
516 lck->num_share_modes));
517 smb_panic("parse_share_modes: invalid number of share modes");
520 lck->share_modes = NULL;
522 if (lck->num_share_modes != 0) {
524 if (dbuf.dsize < (sizeof(struct locking_data) +
525 (lck->num_share_modes *
526 sizeof(struct share_mode_entry)))) {
527 smb_panic("parse_share_modes: buffer too short");
530 lck->share_modes = (struct share_mode_entry *)
531 TALLOC_MEMDUP(lck, dbuf.dptr+sizeof(*data),
532 lck->num_share_modes *
533 sizeof(struct share_mode_entry));
535 if (lck->share_modes == NULL) {
536 smb_panic("parse_share_modes: talloc failed");
540 /* Get any delete token. */
541 if (data->u.s.delete_token_size) {
542 uint8 *p = dbuf.dptr + sizeof(*data) +
543 (lck->num_share_modes *
544 sizeof(struct share_mode_entry));
546 if ((data->u.s.delete_token_size < sizeof(uid_t) + sizeof(gid_t)) ||
547 ((data->u.s.delete_token_size - sizeof(uid_t)) % sizeof(gid_t)) != 0) {
548 DEBUG(0, ("parse_share_modes: invalid token size %d\n",
549 data->u.s.delete_token_size));
550 smb_panic("parse_share_modes: invalid token size");
553 lck->delete_token = TALLOC_P(lck, UNIX_USER_TOKEN);
554 if (!lck->delete_token) {
555 smb_panic("parse_share_modes: talloc failed");
558 /* Copy out the uid and gid. */
559 memcpy(&lck->delete_token->uid, p, sizeof(uid_t));
561 memcpy(&lck->delete_token->gid, p, sizeof(gid_t));
564 /* Any supplementary groups ? */
565 lck->delete_token->ngroups = (data->u.s.delete_token_size > (sizeof(uid_t) + sizeof(gid_t))) ?
566 ((data->u.s.delete_token_size -
567 (sizeof(uid_t) + sizeof(gid_t)))/sizeof(gid_t)) : 0;
569 if (lck->delete_token->ngroups) {
570 /* Make this a talloc child of lck->delete_token. */
571 lck->delete_token->groups = TALLOC_ARRAY(lck->delete_token, gid_t,
572 lck->delete_token->ngroups);
573 if (!lck->delete_token) {
574 smb_panic("parse_share_modes: talloc failed");
577 for (i = 0; i < lck->delete_token->ngroups; i++) {
578 memcpy(&lck->delete_token->groups[i], p, sizeof(gid_t));
584 lck->delete_token = NULL;
587 /* Save off the associated service path and filename. */
588 lck->servicepath = (const char *)dbuf.dptr + sizeof(*data) +
589 (lck->num_share_modes * sizeof(struct share_mode_entry)) +
590 data->u.s.delete_token_size;
592 lck->filename = (const char *)dbuf.dptr + sizeof(*data) +
593 (lck->num_share_modes * sizeof(struct share_mode_entry)) +
594 data->u.s.delete_token_size +
595 strlen(lck->servicepath) + 1;
598 * Ensure that each entry has a real process attached.
601 for (i = 0; i < lck->num_share_modes; i++) {
602 struct share_mode_entry *entry_p = &lck->share_modes[i];
604 if (DEBUGLEVEL >= 10) {
605 str = share_mode_str(NULL, i, entry_p);
607 DEBUG(10,("parse_share_modes: %s\n",
609 if (!process_exists(entry_p->pid)) {
610 DEBUG(10,("parse_share_modes: deleted %s\n",
612 entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
613 lck->modified = True;
621 static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
626 struct locking_data *data;
629 uint32 delete_token_size;
634 for (i=0; i<lck->num_share_modes; i++) {
635 if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
640 if (num_valid == 0) {
644 sp_len = strlen(lck->servicepath);
645 delete_token_size = (lck->delete_token ?
646 (sizeof(uid_t) + sizeof(gid_t) + (lck->delete_token->ngroups*sizeof(gid_t))) : 0);
648 result.dsize = sizeof(*data) +
649 lck->num_share_modes * sizeof(struct share_mode_entry) +
652 strlen(lck->filename) + 1;
653 result.dptr = TALLOC_ARRAY(lck, uint8, result.dsize);
655 if (result.dptr == NULL) {
656 smb_panic("talloc failed");
659 data = (struct locking_data *)result.dptr;
661 data->u.s.num_share_mode_entries = lck->num_share_modes;
662 data->u.s.delete_on_close = lck->delete_on_close;
663 data->u.s.delete_token_size = delete_token_size;
664 DEBUG(10, ("unparse_share_modes: del: %d, tok = %u, num: %d\n",
665 data->u.s.delete_on_close,
666 (unsigned int)data->u.s.delete_token_size,
667 data->u.s.num_share_mode_entries));
668 memcpy(result.dptr + sizeof(*data), lck->share_modes,
669 sizeof(struct share_mode_entry)*lck->num_share_modes);
670 offset = sizeof(*data) +
671 sizeof(struct share_mode_entry)*lck->num_share_modes;
673 /* Store any delete on close token. */
674 if (lck->delete_token) {
675 uint8 *p = result.dptr + offset;
677 memcpy(p, &lck->delete_token->uid, sizeof(uid_t));
680 memcpy(p, &lck->delete_token->gid, sizeof(gid_t));
683 for (i = 0; i < lck->delete_token->ngroups; i++) {
684 memcpy(p, &lck->delete_token->groups[i], sizeof(gid_t));
687 offset = p - result.dptr;
690 safe_strcpy((char *)result.dptr + offset, lck->servicepath,
691 result.dsize - offset - 1);
692 offset += sp_len + 1;
693 safe_strcpy((char *)result.dptr + offset, lck->filename,
694 result.dsize - offset - 1);
696 if (DEBUGLEVEL >= 10) {
697 print_share_mode_table(data);
703 static int share_mode_lock_destructor(struct share_mode_lock *lck)
708 if (!lck->modified) {
712 data = unparse_share_modes(lck);
714 if (data.dptr == NULL) {
716 /* There has been an entry before, delete it */
718 status = lck->record->delete_rec(lck->record);
719 if (!NT_STATUS_IS_OK(status)) {
720 DEBUG(0, ("delete_rec returned %s\n",
722 smb_panic("could not delete share entry");
728 status = lck->record->store(lck->record, data, TDB_REPLACE);
729 if (!NT_STATUS_IS_OK(status)) {
730 DEBUG(0, ("store returned %s\n", nt_errstr(status)));
731 smb_panic("could not store share mode entry");
739 static bool fill_share_mode_lock(struct share_mode_lock *lck,
741 const char *servicepath,
743 TDB_DATA share_mode_data)
745 /* Ensure we set every field here as the destructor must be
746 valid even if parse_share_modes fails. */
748 lck->servicepath = NULL;
749 lck->filename = NULL;
751 lck->num_share_modes = 0;
752 lck->share_modes = NULL;
753 lck->delete_token = NULL;
754 lck->delete_on_close = False;
756 lck->modified = False;
758 lck->fresh = (share_mode_data.dptr == NULL);
761 if (fname == NULL || servicepath == NULL) {
764 lck->filename = talloc_strdup(lck, fname);
765 lck->servicepath = talloc_strdup(lck, servicepath);
766 if (lck->filename == NULL || lck->servicepath == NULL) {
767 DEBUG(0, ("talloc failed\n"));
771 if (!parse_share_modes(share_mode_data, lck)) {
772 DEBUG(0, ("Could not parse share modes\n"));
780 struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
781 const struct file_id id,
782 const char *servicepath,
785 struct share_mode_lock *lck;
787 TDB_DATA key = locking_key(&id, &tmp);
789 if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
790 DEBUG(0, ("talloc failed\n"));
794 if (!(lck->record = lock_db->fetch_locked(lock_db, lck, key))) {
795 DEBUG(3, ("Could not lock share entry\n"));
800 if (!fill_share_mode_lock(lck, id, servicepath, fname,
801 lck->record->value)) {
802 DEBUG(3, ("fill_share_mode_lock failed\n"));
807 talloc_set_destructor(lck, share_mode_lock_destructor);
812 struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
813 const struct file_id id,
814 const char *servicepath,
817 struct share_mode_lock *lck;
819 TDB_DATA key = locking_key(&id, &tmp);
822 if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
823 DEBUG(0, ("talloc failed\n"));
827 if (lock_db->fetch(lock_db, lck, key, &data) == -1) {
828 DEBUG(3, ("Could not fetch share entry\n"));
833 if (!fill_share_mode_lock(lck, id, servicepath, fname, data)) {
834 DEBUG(3, ("fill_share_mode_lock failed\n"));
842 /*******************************************************************
843 Sets the service name and filename for rename.
844 At this point we emit "file renamed" messages to all
845 process id's that have this file open.
846 Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
847 ********************************************************************/
849 bool rename_share_filename(struct messaging_context *msg_ctx,
850 struct share_mode_lock *lck,
851 const char *servicepath,
860 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
861 servicepath, newname));
864 * rename_internal_fsp() and rename_internals() add './' to
865 * head of newname if newname does not contain a '/'.
867 while (newname[0] && newname[1] && newname[0] == '.' && newname[1] == '/') {
871 lck->servicepath = talloc_strdup(lck, servicepath);
872 lck->filename = talloc_strdup(lck, newname);
873 if (lck->filename == NULL || lck->servicepath == NULL) {
874 DEBUG(0, ("rename_share_filename: talloc failed\n"));
877 lck->modified = True;
879 sp_len = strlen(lck->servicepath);
880 fn_len = strlen(lck->filename);
882 msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + fn_len + 1;
884 /* Set up the name changed message. */
885 frm = TALLOC_ARRAY(lck, char, msg_len);
890 push_file_id_16(frm, &lck->id);
892 DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
894 safe_strcpy(&frm[16], lck->servicepath, sp_len);
895 safe_strcpy(&frm[16 + sp_len + 1], lck->filename, fn_len);
897 /* Send the messages. */
898 for (i=0; i<lck->num_share_modes; i++) {
899 struct share_mode_entry *se = &lck->share_modes[i];
900 if (!is_valid_share_mode_entry(se)) {
903 /* But not to ourselves... */
904 if (procid_is_me(&se->pid)) {
908 DEBUG(10,("rename_share_filename: sending rename message to pid %s "
909 "file_id %s sharepath %s newname %s\n",
910 procid_str_static(&se->pid),
911 file_id_string_tos(&lck->id),
912 lck->servicepath, lck->filename ));
914 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
915 (uint8 *)frm, msg_len);
921 bool get_delete_on_close_flag(struct file_id id)
924 struct share_mode_lock *lck;
926 if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id, NULL, NULL))) {
929 result = lck->delete_on_close;
934 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
938 if (e->op_type == UNUSED_SHARE_MODE_ENTRY) {
939 /* cope with dead entries from the process not
940 existing. These should not be considered valid,
941 otherwise we end up doing zero timeout sharing
946 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
947 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
948 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
950 SMB_ASSERT(num_props <= 1);
951 return (num_props != 0);
954 bool is_deferred_open_entry(const struct share_mode_entry *e)
956 return (e->op_type == DEFERRED_OPEN_ENTRY);
959 bool is_unused_share_mode_entry(const struct share_mode_entry *e)
961 return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
964 /*******************************************************************
965 Fill a share mode entry.
966 ********************************************************************/
968 static void fill_share_mode_entry(struct share_mode_entry *e,
970 uid_t uid, uint16 mid, uint16 op_type)
973 e->pid = procid_self();
974 e->share_access = fsp->share_access;
975 e->private_options = fsp->fh->private_options;
976 e->access_mask = fsp->access_mask;
978 e->op_type = op_type;
979 e->time.tv_sec = fsp->open_time.tv_sec;
980 e->time.tv_usec = fsp->open_time.tv_usec;
981 e->id = fsp->file_id;
982 e->share_file_id = fsp->fh->gen_id;
983 e->uid = (uint32)uid;
984 e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
987 static void fill_deferred_open_entry(struct share_mode_entry *e,
988 const struct timeval request_time,
989 struct file_id id, uint16 mid)
992 e->pid = procid_self();
994 e->op_type = DEFERRED_OPEN_ENTRY;
995 e->time.tv_sec = request_time.tv_sec;
996 e->time.tv_usec = request_time.tv_usec;
1002 static void add_share_mode_entry(struct share_mode_lock *lck,
1003 const struct share_mode_entry *entry)
1007 for (i=0; i<lck->num_share_modes; i++) {
1008 struct share_mode_entry *e = &lck->share_modes[i];
1009 if (is_unused_share_mode_entry(e)) {
1015 if (i == lck->num_share_modes) {
1016 /* No unused entry found */
1017 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
1018 &lck->share_modes, &lck->num_share_modes);
1020 lck->modified = True;
1023 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
1024 uid_t uid, uint16 mid, uint16 op_type, bool initial_delete_on_close_allowed)
1026 struct share_mode_entry entry;
1027 fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
1028 if (initial_delete_on_close_allowed) {
1029 entry.flags |= SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE;
1031 add_share_mode_entry(lck, &entry);
1034 void add_deferred_open(struct share_mode_lock *lck, uint16 mid,
1035 struct timeval request_time,
1038 struct share_mode_entry entry;
1039 fill_deferred_open_entry(&entry, request_time, id, mid);
1040 add_share_mode_entry(lck, &entry);
1043 /*******************************************************************
1044 Check if two share mode entries are identical, ignoring oplock
1045 and mid info and desired_access. (Removed paranoia test - it's
1046 not automatically a logic error if they are identical. JRA.)
1047 ********************************************************************/
1049 static bool share_modes_identical(struct share_mode_entry *e1,
1050 struct share_mode_entry *e2)
1052 /* We used to check for e1->share_access == e2->share_access here
1053 as well as the other fields but 2 different DOS or FCB opens
1054 sharing the same share mode entry may validly differ in
1055 fsp->share_access field. */
1057 return (procid_equal(&e1->pid, &e2->pid) &&
1058 file_id_equal(&e1->id, &e2->id) &&
1059 e1->share_file_id == e2->share_file_id );
1062 static bool deferred_open_identical(struct share_mode_entry *e1,
1063 struct share_mode_entry *e2)
1065 return (procid_equal(&e1->pid, &e2->pid) &&
1066 (e1->op_mid == e2->op_mid) &&
1067 file_id_equal(&e1->id, &e2->id));
1070 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
1071 struct share_mode_entry *entry)
1075 for (i=0; i<lck->num_share_modes; i++) {
1076 struct share_mode_entry *e = &lck->share_modes[i];
1077 if (is_valid_share_mode_entry(entry) &&
1078 is_valid_share_mode_entry(e) &&
1079 share_modes_identical(e, entry)) {
1082 if (is_deferred_open_entry(entry) &&
1083 is_deferred_open_entry(e) &&
1084 deferred_open_identical(e, entry)) {
1091 /*******************************************************************
1092 Del the share mode of a file for this process. Return the number of
1094 ********************************************************************/
1096 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
1098 struct share_mode_entry entry, *e;
1100 /* Don't care about the pid owner being correct here - just a search. */
1101 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1103 e = find_share_mode_entry(lck, &entry);
1108 e->op_type = UNUSED_SHARE_MODE_ENTRY;
1109 lck->modified = True;
1113 void del_deferred_open_entry(struct share_mode_lock *lck, uint16 mid)
1115 struct share_mode_entry entry, *e;
1117 fill_deferred_open_entry(&entry, timeval_zero(),
1120 e = find_share_mode_entry(lck, &entry);
1125 e->op_type = UNUSED_SHARE_MODE_ENTRY;
1126 lck->modified = True;
1129 /*******************************************************************
1130 Remove an oplock mid and mode entry from a share mode.
1131 ********************************************************************/
1133 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1135 struct share_mode_entry entry, *e;
1137 /* Don't care about the pid owner being correct here - just a search. */
1138 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1140 e = find_share_mode_entry(lck, &entry);
1146 e->op_type = NO_OPLOCK;
1147 lck->modified = True;
1151 /*******************************************************************
1152 Downgrade a oplock type from exclusive to level II.
1153 ********************************************************************/
1155 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1157 struct share_mode_entry entry, *e;
1159 /* Don't care about the pid owner being correct here - just a search. */
1160 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1162 e = find_share_mode_entry(lck, &entry);
1167 e->op_type = LEVEL_II_OPLOCK;
1168 lck->modified = True;
1172 /****************************************************************************
1173 Deal with the internal needs of setting the delete on close flag. Note that
1174 as the tdb locking is recursive, it is safe to call this from within
1175 open_file_ntcreate. JRA.
1176 ****************************************************************************/
1178 NTSTATUS can_set_delete_on_close(files_struct *fsp, bool delete_on_close,
1181 if (!delete_on_close) {
1182 return NT_STATUS_OK;
1186 * Only allow delete on close for writable files.
1189 if ((dosmode & aRONLY) &&
1190 !lp_delete_readonly(SNUM(fsp->conn))) {
1191 DEBUG(10,("can_set_delete_on_close: file %s delete on close "
1192 "flag set but file attribute is readonly.\n",
1194 return NT_STATUS_CANNOT_DELETE;
1198 * Only allow delete on close for writable shares.
1201 if (!CAN_WRITE(fsp->conn)) {
1202 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1203 "close flag set but write access denied on share.\n",
1205 return NT_STATUS_ACCESS_DENIED;
1209 * Only allow delete on close for files/directories opened with delete
1213 if (!(fsp->access_mask & DELETE_ACCESS)) {
1214 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1215 "close flag set but delete access denied.\n",
1217 return NT_STATUS_ACCESS_DENIED;
1220 /* Don't allow delete on close for non-empty directories. */
1221 if (fsp->is_directory) {
1222 return can_delete_directory(fsp->conn, fsp->fsp_name);
1225 return NT_STATUS_OK;
1228 /****************************************************************************
1229 Do we have an open file handle that created this entry ?
1230 ****************************************************************************/
1232 bool can_set_initial_delete_on_close(const struct share_mode_lock *lck)
1236 for (i=0; i<lck->num_share_modes; i++) {
1237 if (lck->share_modes[i].flags & SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE) {
1244 /*************************************************************************
1245 Return a talloced copy of a UNIX_USER_TOKEN. NULL on fail.
1246 (Should this be in locking.c.... ?).
1247 *************************************************************************/
1249 static UNIX_USER_TOKEN *copy_unix_token(TALLOC_CTX *ctx, UNIX_USER_TOKEN *tok)
1251 UNIX_USER_TOKEN *cpy;
1257 cpy = TALLOC_P(ctx, UNIX_USER_TOKEN);
1262 cpy->uid = tok->uid;
1263 cpy->gid = tok->gid;
1264 cpy->ngroups = tok->ngroups;
1266 /* Make this a talloc child of cpy. */
1267 cpy->groups = TALLOC_ARRAY(cpy, gid_t, tok->ngroups);
1271 memcpy(cpy->groups, tok->groups, tok->ngroups * sizeof(gid_t));
1276 /****************************************************************************
1277 Replace the delete on close token.
1278 ****************************************************************************/
1280 void set_delete_on_close_token(struct share_mode_lock *lck, UNIX_USER_TOKEN *tok)
1282 TALLOC_FREE(lck->delete_token); /* Also deletes groups... */
1284 /* Copy the new token (can be NULL). */
1285 lck->delete_token = copy_unix_token(lck, tok);
1286 lck->modified = True;
1289 /****************************************************************************
1290 Sets the delete on close flag over all share modes on this file.
1291 Modify the share mode entry for all files open
1292 on this device and inode to tell other smbds we have
1293 changed the delete on close flag. This will be noticed
1294 in the close code, the last closer will delete the file
1296 This makes a copy of any UNIX_USER_TOKEN into the
1297 lck entry. This function is used when the lock is already granted.
1298 ****************************************************************************/
1300 void set_delete_on_close_lck(struct share_mode_lock *lck, bool delete_on_close, UNIX_USER_TOKEN *tok)
1302 if (lck->delete_on_close != delete_on_close) {
1303 set_delete_on_close_token(lck, tok);
1304 lck->delete_on_close = delete_on_close;
1305 if (delete_on_close) {
1306 SMB_ASSERT(lck->delete_token != NULL);
1308 lck->modified = True;
1312 bool set_delete_on_close(files_struct *fsp, bool delete_on_close, UNIX_USER_TOKEN *tok)
1314 struct share_mode_lock *lck;
1316 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1317 "fnum = %d, file %s\n",
1318 delete_on_close ? "Adding" : "Removing", fsp->fnum,
1325 lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL);
1330 set_delete_on_close_lck(lck, delete_on_close, tok);
1332 if (fsp->is_directory) {
1333 send_stat_cache_delete_message(fsp->fsp_name);
1340 /****************************************************************************
1341 Sets the allow initial delete on close flag for this share mode.
1342 ****************************************************************************/
1344 bool set_allow_initial_delete_on_close(struct share_mode_lock *lck, files_struct *fsp, bool delete_on_close)
1346 struct share_mode_entry entry, *e;
1348 /* Don't care about the pid owner being correct here - just a search. */
1349 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1351 e = find_share_mode_entry(lck, &entry);
1356 if (delete_on_close) {
1357 e->flags |= SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE;
1359 e->flags &= ~SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE;
1361 lck->modified = True;
1365 struct forall_state {
1366 void (*fn)(const struct share_mode_entry *entry,
1367 const char *sharepath,
1369 void *private_data);
1373 static int traverse_fn(struct db_record *rec, void *_state)
1375 struct forall_state *state = (struct forall_state *)_state;
1376 struct locking_data *data;
1377 struct share_mode_entry *shares;
1378 const char *sharepath;
1382 /* Ensure this is a locking_key record. */
1383 if (rec->key.dsize != sizeof(struct file_id))
1386 data = (struct locking_data *)rec->value.dptr;
1387 shares = (struct share_mode_entry *)(rec->value.dptr + sizeof(*data));
1388 sharepath = (const char *)rec->value.dptr + sizeof(*data) +
1389 data->u.s.num_share_mode_entries*sizeof(*shares) +
1390 data->u.s.delete_token_size;
1391 fname = (const char *)rec->value.dptr + sizeof(*data) +
1392 data->u.s.num_share_mode_entries*sizeof(*shares) +
1393 data->u.s.delete_token_size +
1394 strlen(sharepath) + 1;
1396 for (i=0;i<data->u.s.num_share_mode_entries;i++) {
1397 state->fn(&shares[i], sharepath, fname,
1398 state->private_data);
1403 /*******************************************************************
1404 Call the specified function on each entry under management by the
1406 ********************************************************************/
1408 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
1409 const char *, void *),
1412 struct forall_state state;
1414 if (lock_db == NULL)
1418 state.private_data = private_data;
1420 return lock_db->traverse_read(lock_db, traverse_fn, (void *)&state);