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"));
839 TALLOC_FREE(data.dptr);
844 /*******************************************************************
845 Sets the service name and filename for rename.
846 At this point we emit "file renamed" messages to all
847 process id's that have this file open.
848 Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
849 ********************************************************************/
851 bool rename_share_filename(struct messaging_context *msg_ctx,
852 struct share_mode_lock *lck,
853 const char *servicepath,
862 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
863 servicepath, newname));
866 * rename_internal_fsp() and rename_internals() add './' to
867 * head of newname if newname does not contain a '/'.
869 while (newname[0] && newname[1] && newname[0] == '.' && newname[1] == '/') {
873 lck->servicepath = talloc_strdup(lck, servicepath);
874 lck->filename = talloc_strdup(lck, newname);
875 if (lck->filename == NULL || lck->servicepath == NULL) {
876 DEBUG(0, ("rename_share_filename: talloc failed\n"));
879 lck->modified = True;
881 sp_len = strlen(lck->servicepath);
882 fn_len = strlen(lck->filename);
884 msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + fn_len + 1;
886 /* Set up the name changed message. */
887 frm = TALLOC_ARRAY(lck, char, msg_len);
892 push_file_id_16(frm, &lck->id);
894 DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
896 safe_strcpy(&frm[16], lck->servicepath, sp_len);
897 safe_strcpy(&frm[16 + sp_len + 1], lck->filename, fn_len);
899 /* Send the messages. */
900 for (i=0; i<lck->num_share_modes; i++) {
901 struct share_mode_entry *se = &lck->share_modes[i];
902 if (!is_valid_share_mode_entry(se)) {
905 /* But not to ourselves... */
906 if (procid_is_me(&se->pid)) {
910 DEBUG(10,("rename_share_filename: sending rename message to pid %s "
911 "file_id %s sharepath %s newname %s\n",
912 procid_str_static(&se->pid),
913 file_id_string_tos(&lck->id),
914 lck->servicepath, lck->filename ));
916 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
917 (uint8 *)frm, msg_len);
923 bool get_delete_on_close_flag(struct file_id id)
926 struct share_mode_lock *lck;
928 if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id, NULL, NULL))) {
931 result = lck->delete_on_close;
936 bool is_valid_share_mode_entry(const struct share_mode_entry *e)
940 if (e->op_type == UNUSED_SHARE_MODE_ENTRY) {
941 /* cope with dead entries from the process not
942 existing. These should not be considered valid,
943 otherwise we end up doing zero timeout sharing
948 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
949 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
950 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
952 SMB_ASSERT(num_props <= 1);
953 return (num_props != 0);
956 bool is_deferred_open_entry(const struct share_mode_entry *e)
958 return (e->op_type == DEFERRED_OPEN_ENTRY);
961 bool is_unused_share_mode_entry(const struct share_mode_entry *e)
963 return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
966 /*******************************************************************
967 Fill a share mode entry.
968 ********************************************************************/
970 static void fill_share_mode_entry(struct share_mode_entry *e,
972 uid_t uid, uint16 mid, uint16 op_type)
975 e->pid = procid_self();
976 e->share_access = fsp->share_access;
977 e->private_options = fsp->fh->private_options;
978 e->access_mask = fsp->access_mask;
980 e->op_type = op_type;
981 e->time.tv_sec = fsp->open_time.tv_sec;
982 e->time.tv_usec = fsp->open_time.tv_usec;
983 e->id = fsp->file_id;
984 e->share_file_id = fsp->fh->gen_id;
985 e->uid = (uint32)uid;
986 e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
989 static void fill_deferred_open_entry(struct share_mode_entry *e,
990 const struct timeval request_time,
991 struct file_id id, uint16 mid)
994 e->pid = procid_self();
996 e->op_type = DEFERRED_OPEN_ENTRY;
997 e->time.tv_sec = request_time.tv_sec;
998 e->time.tv_usec = request_time.tv_usec;
1000 e->uid = (uint32)-1;
1004 static void add_share_mode_entry(struct share_mode_lock *lck,
1005 const struct share_mode_entry *entry)
1009 for (i=0; i<lck->num_share_modes; i++) {
1010 struct share_mode_entry *e = &lck->share_modes[i];
1011 if (is_unused_share_mode_entry(e)) {
1017 if (i == lck->num_share_modes) {
1018 /* No unused entry found */
1019 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
1020 &lck->share_modes, &lck->num_share_modes);
1022 lck->modified = True;
1025 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
1026 uid_t uid, uint16 mid, uint16 op_type, bool initial_delete_on_close_allowed)
1028 struct share_mode_entry entry;
1029 fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
1030 if (initial_delete_on_close_allowed) {
1031 entry.flags |= SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE;
1033 add_share_mode_entry(lck, &entry);
1036 void add_deferred_open(struct share_mode_lock *lck, uint16 mid,
1037 struct timeval request_time,
1040 struct share_mode_entry entry;
1041 fill_deferred_open_entry(&entry, request_time, id, mid);
1042 add_share_mode_entry(lck, &entry);
1045 /*******************************************************************
1046 Check if two share mode entries are identical, ignoring oplock
1047 and mid info and desired_access. (Removed paranoia test - it's
1048 not automatically a logic error if they are identical. JRA.)
1049 ********************************************************************/
1051 static bool share_modes_identical(struct share_mode_entry *e1,
1052 struct share_mode_entry *e2)
1054 /* We used to check for e1->share_access == e2->share_access here
1055 as well as the other fields but 2 different DOS or FCB opens
1056 sharing the same share mode entry may validly differ in
1057 fsp->share_access field. */
1059 return (procid_equal(&e1->pid, &e2->pid) &&
1060 file_id_equal(&e1->id, &e2->id) &&
1061 e1->share_file_id == e2->share_file_id );
1064 static bool deferred_open_identical(struct share_mode_entry *e1,
1065 struct share_mode_entry *e2)
1067 return (procid_equal(&e1->pid, &e2->pid) &&
1068 (e1->op_mid == e2->op_mid) &&
1069 file_id_equal(&e1->id, &e2->id));
1072 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
1073 struct share_mode_entry *entry)
1077 for (i=0; i<lck->num_share_modes; i++) {
1078 struct share_mode_entry *e = &lck->share_modes[i];
1079 if (is_valid_share_mode_entry(entry) &&
1080 is_valid_share_mode_entry(e) &&
1081 share_modes_identical(e, entry)) {
1084 if (is_deferred_open_entry(entry) &&
1085 is_deferred_open_entry(e) &&
1086 deferred_open_identical(e, entry)) {
1093 /*******************************************************************
1094 Del the share mode of a file for this process. Return the number of
1096 ********************************************************************/
1098 bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
1100 struct share_mode_entry entry, *e;
1102 /* Don't care about the pid owner being correct here - just a search. */
1103 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1105 e = find_share_mode_entry(lck, &entry);
1110 e->op_type = UNUSED_SHARE_MODE_ENTRY;
1111 lck->modified = True;
1115 void del_deferred_open_entry(struct share_mode_lock *lck, uint16 mid)
1117 struct share_mode_entry entry, *e;
1119 fill_deferred_open_entry(&entry, timeval_zero(),
1122 e = find_share_mode_entry(lck, &entry);
1127 e->op_type = UNUSED_SHARE_MODE_ENTRY;
1128 lck->modified = True;
1131 /*******************************************************************
1132 Remove an oplock mid and mode entry from a share mode.
1133 ********************************************************************/
1135 bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1137 struct share_mode_entry entry, *e;
1139 /* Don't care about the pid owner being correct here - just a search. */
1140 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1142 e = find_share_mode_entry(lck, &entry);
1148 e->op_type = NO_OPLOCK;
1149 lck->modified = True;
1153 /*******************************************************************
1154 Downgrade a oplock type from exclusive to level II.
1155 ********************************************************************/
1157 bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1159 struct share_mode_entry entry, *e;
1161 /* Don't care about the pid owner being correct here - just a search. */
1162 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1164 e = find_share_mode_entry(lck, &entry);
1169 e->op_type = LEVEL_II_OPLOCK;
1170 lck->modified = True;
1174 /****************************************************************************
1175 Deal with the internal needs of setting the delete on close flag. Note that
1176 as the tdb locking is recursive, it is safe to call this from within
1177 open_file_ntcreate. JRA.
1178 ****************************************************************************/
1180 NTSTATUS can_set_delete_on_close(files_struct *fsp, bool delete_on_close,
1183 if (!delete_on_close) {
1184 return NT_STATUS_OK;
1188 * Only allow delete on close for writable files.
1191 if ((dosmode & aRONLY) &&
1192 !lp_delete_readonly(SNUM(fsp->conn))) {
1193 DEBUG(10,("can_set_delete_on_close: file %s delete on close "
1194 "flag set but file attribute is readonly.\n",
1196 return NT_STATUS_CANNOT_DELETE;
1200 * Only allow delete on close for writable shares.
1203 if (!CAN_WRITE(fsp->conn)) {
1204 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1205 "close flag set but write access denied on share.\n",
1207 return NT_STATUS_ACCESS_DENIED;
1211 * Only allow delete on close for files/directories opened with delete
1215 if (!(fsp->access_mask & DELETE_ACCESS)) {
1216 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1217 "close flag set but delete access denied.\n",
1219 return NT_STATUS_ACCESS_DENIED;
1222 /* Don't allow delete on close for non-empty directories. */
1223 if (fsp->is_directory) {
1224 return can_delete_directory(fsp->conn, fsp->fsp_name);
1227 return NT_STATUS_OK;
1230 /****************************************************************************
1231 Do we have an open file handle that created this entry ?
1232 ****************************************************************************/
1234 bool can_set_initial_delete_on_close(const struct share_mode_lock *lck)
1238 for (i=0; i<lck->num_share_modes; i++) {
1239 if (lck->share_modes[i].flags & SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE) {
1246 /*************************************************************************
1247 Return a talloced copy of a UNIX_USER_TOKEN. NULL on fail.
1248 (Should this be in locking.c.... ?).
1249 *************************************************************************/
1251 static UNIX_USER_TOKEN *copy_unix_token(TALLOC_CTX *ctx, UNIX_USER_TOKEN *tok)
1253 UNIX_USER_TOKEN *cpy;
1259 cpy = TALLOC_P(ctx, UNIX_USER_TOKEN);
1264 cpy->uid = tok->uid;
1265 cpy->gid = tok->gid;
1266 cpy->ngroups = tok->ngroups;
1268 /* Make this a talloc child of cpy. */
1269 cpy->groups = TALLOC_ARRAY(cpy, gid_t, tok->ngroups);
1273 memcpy(cpy->groups, tok->groups, tok->ngroups * sizeof(gid_t));
1278 /****************************************************************************
1279 Replace the delete on close token.
1280 ****************************************************************************/
1282 void set_delete_on_close_token(struct share_mode_lock *lck, UNIX_USER_TOKEN *tok)
1284 /* Ensure there's no token. */
1285 if (lck->delete_token) {
1286 TALLOC_FREE(lck->delete_token); /* Also deletes groups... */
1287 lck->delete_token = NULL;
1290 /* Copy the new token (can be NULL). */
1291 lck->delete_token = copy_unix_token(lck, tok);
1292 lck->modified = True;
1295 /****************************************************************************
1296 Sets the delete on close flag over all share modes on this file.
1297 Modify the share mode entry for all files open
1298 on this device and inode to tell other smbds we have
1299 changed the delete on close flag. This will be noticed
1300 in the close code, the last closer will delete the file
1302 This makes a copy of any UNIX_USER_TOKEN into the
1303 lck entry. This function is used when the lock is already granted.
1304 ****************************************************************************/
1306 void set_delete_on_close_lck(struct share_mode_lock *lck, bool delete_on_close, UNIX_USER_TOKEN *tok)
1308 if (lck->delete_on_close != delete_on_close) {
1309 set_delete_on_close_token(lck, tok);
1310 lck->delete_on_close = delete_on_close;
1311 if (delete_on_close) {
1312 SMB_ASSERT(lck->delete_token != NULL);
1314 lck->modified = True;
1318 bool set_delete_on_close(files_struct *fsp, bool delete_on_close, UNIX_USER_TOKEN *tok)
1320 struct share_mode_lock *lck;
1322 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1323 "fnum = %d, file %s\n",
1324 delete_on_close ? "Adding" : "Removing", fsp->fnum,
1331 lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL);
1336 set_delete_on_close_lck(lck, delete_on_close, tok);
1338 if (fsp->is_directory) {
1339 send_stat_cache_delete_message(fsp->fsp_name);
1346 /****************************************************************************
1347 Sets the allow initial delete on close flag for this share mode.
1348 ****************************************************************************/
1350 bool set_allow_initial_delete_on_close(struct share_mode_lock *lck, files_struct *fsp, bool delete_on_close)
1352 struct share_mode_entry entry, *e;
1354 /* Don't care about the pid owner being correct here - just a search. */
1355 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1357 e = find_share_mode_entry(lck, &entry);
1362 if (delete_on_close) {
1363 e->flags |= SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE;
1365 e->flags &= ~SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE;
1367 lck->modified = True;
1371 struct forall_state {
1372 void (*fn)(const struct share_mode_entry *entry,
1373 const char *sharepath,
1375 void *private_data);
1379 static int traverse_fn(struct db_record *rec, void *_state)
1381 struct forall_state *state = (struct forall_state *)_state;
1382 struct locking_data *data;
1383 struct share_mode_entry *shares;
1384 const char *sharepath;
1388 /* Ensure this is a locking_key record. */
1389 if (rec->key.dsize != sizeof(struct file_id))
1392 data = (struct locking_data *)rec->value.dptr;
1393 shares = (struct share_mode_entry *)(rec->value.dptr + sizeof(*data));
1394 sharepath = (const char *)rec->value.dptr + sizeof(*data) +
1395 data->u.s.num_share_mode_entries*sizeof(*shares) +
1396 data->u.s.delete_token_size;
1397 fname = (const char *)rec->value.dptr + sizeof(*data) +
1398 data->u.s.num_share_mode_entries*sizeof(*shares) +
1399 data->u.s.delete_token_size +
1400 strlen(sharepath) + 1;
1402 for (i=0;i<data->u.s.num_share_mode_entries;i++) {
1403 state->fn(&shares[i], sharepath, fname,
1404 state->private_data);
1409 /*******************************************************************
1410 Call the specified function on each entry under management by the
1412 ********************************************************************/
1414 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
1415 const char *, void *),
1418 struct forall_state state;
1420 if (lock_db == NULL)
1424 state.private_data = private_data;
1426 return lock_db->traverse_read(lock_db, traverse_fn, (void *)&state);