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(NULL, fsp);
109 ret = !brl_locktest(br_lck,
119 struct byte_range_lock *br_lck = brl_get_locks_readonly(NULL, 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(NULL, 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(NULL, 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(NULL, 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(NULL, 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(NULL,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 int open_read_only;
390 BOOL locking_init(int read_only)
397 lock_db = db_open(NULL, lock_path("locking.tdb"), 0,
400 |(read_only?0x0:TDB_CLEAR_IF_FIRST),
401 read_only?O_RDONLY:O_RDWR|O_CREAT, 0644);
404 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
408 if (!posix_locking_init(read_only))
411 open_read_only = read_only;
416 /*******************************************************************
417 Deinitialize the share_mode management.
418 ******************************************************************/
420 BOOL locking_end(void)
422 brl_shutdown(open_read_only);
424 TALLOC_FREE(lock_db);
429 /*******************************************************************
430 Form a static locking key for a dev/inode pair.
431 ******************************************************************/
433 static TDB_DATA locking_key(struct file_id id)
435 static struct file_id key;
438 kbuf.dptr = (uint8 *)&key;
439 kbuf.dsize = sizeof(key);
443 /*******************************************************************
444 Print out a share mode.
445 ********************************************************************/
447 char *share_mode_str(int num, struct share_mode_entry *e)
449 static pstring share_str;
451 slprintf(share_str, sizeof(share_str)-1, "share_mode_entry[%d]: %s "
452 "pid = %s, share_access = 0x%x, private_options = 0x%x, "
453 "access_mask = 0x%x, mid = 0x%x, type= 0x%x, gen_id = %lu, "
454 "uid = %u, flags = %u, file_id %s",
456 e->op_type == UNUSED_SHARE_MODE_ENTRY ? "UNUSED" : "",
457 procid_str_static(&e->pid),
458 e->share_access, e->private_options,
459 e->access_mask, e->op_mid, e->op_type, e->share_file_id,
460 (unsigned int)e->uid, (unsigned int)e->flags,
461 file_id_string_tos(&e->id));
466 /*******************************************************************
467 Print out a share mode table.
468 ********************************************************************/
470 static void print_share_mode_table(struct locking_data *data)
472 int num_share_modes = data->u.s.num_share_mode_entries;
473 struct share_mode_entry *shares =
474 (struct share_mode_entry *)(data + 1);
477 for (i = 0; i < num_share_modes; i++) {
478 struct share_mode_entry entry;
480 memcpy(&entry, &shares[i], sizeof(struct share_mode_entry));
481 DEBUG(10,("print_share_mode_table: %s\n",
482 share_mode_str(i, &entry)));
486 /*******************************************************************
487 Get all share mode entries for a dev/inode pair.
488 ********************************************************************/
490 static BOOL parse_share_modes(TDB_DATA dbuf, struct share_mode_lock *lck)
492 struct locking_data *data;
495 if (dbuf.dsize < sizeof(struct locking_data)) {
496 smb_panic("parse_share_modes: buffer too short");
499 data = (struct locking_data *)dbuf.dptr;
501 lck->delete_on_close = data->u.s.delete_on_close;
502 lck->num_share_modes = data->u.s.num_share_mode_entries;
504 DEBUG(10, ("parse_share_modes: delete_on_close: %d, "
505 "num_share_modes: %d\n",
506 lck->delete_on_close,
507 lck->num_share_modes));
509 if ((lck->num_share_modes < 0) || (lck->num_share_modes > 1000000)) {
510 DEBUG(0, ("invalid number of share modes: %d\n",
511 lck->num_share_modes));
512 smb_panic("parse_share_modes: invalid number of share modes");
515 lck->share_modes = NULL;
517 if (lck->num_share_modes != 0) {
519 if (dbuf.dsize < (sizeof(struct locking_data) +
520 (lck->num_share_modes *
521 sizeof(struct share_mode_entry)))) {
522 smb_panic("parse_share_modes: buffer too short");
525 lck->share_modes = (struct share_mode_entry *)
526 TALLOC_MEMDUP(lck, dbuf.dptr+sizeof(*data),
527 lck->num_share_modes *
528 sizeof(struct share_mode_entry));
530 if (lck->share_modes == NULL) {
531 smb_panic("parse_share_modes: talloc failed");
535 /* Get any delete token. */
536 if (data->u.s.delete_token_size) {
537 uint8 *p = dbuf.dptr + sizeof(*data) +
538 (lck->num_share_modes *
539 sizeof(struct share_mode_entry));
541 if ((data->u.s.delete_token_size < sizeof(uid_t) + sizeof(gid_t)) ||
542 ((data->u.s.delete_token_size - sizeof(uid_t)) % sizeof(gid_t)) != 0) {
543 DEBUG(0, ("parse_share_modes: invalid token size %d\n",
544 data->u.s.delete_token_size));
545 smb_panic("parse_share_modes: invalid token size");
548 lck->delete_token = TALLOC_P(lck, UNIX_USER_TOKEN);
549 if (!lck->delete_token) {
550 smb_panic("parse_share_modes: talloc failed");
553 /* Copy out the uid and gid. */
554 memcpy(&lck->delete_token->uid, p, sizeof(uid_t));
556 memcpy(&lck->delete_token->gid, p, sizeof(gid_t));
559 /* Any supplementary groups ? */
560 lck->delete_token->ngroups = (data->u.s.delete_token_size > (sizeof(uid_t) + sizeof(gid_t))) ?
561 ((data->u.s.delete_token_size -
562 (sizeof(uid_t) + sizeof(gid_t)))/sizeof(gid_t)) : 0;
564 if (lck->delete_token->ngroups) {
565 /* Make this a talloc child of lck->delete_token. */
566 lck->delete_token->groups = TALLOC_ARRAY(lck->delete_token, gid_t,
567 lck->delete_token->ngroups);
568 if (!lck->delete_token) {
569 smb_panic("parse_share_modes: talloc failed");
572 for (i = 0; i < lck->delete_token->ngroups; i++) {
573 memcpy(&lck->delete_token->groups[i], p, sizeof(gid_t));
579 lck->delete_token = NULL;
582 /* Save off the associated service path and filename. */
583 lck->servicepath = talloc_strdup(lck, (const char *)dbuf.dptr + sizeof(*data) +
584 (lck->num_share_modes *
585 sizeof(struct share_mode_entry)) +
586 data->u.s.delete_token_size );
587 if (lck->servicepath == NULL) {
588 smb_panic("parse_share_modes: talloc_strdup failed");
591 lck->filename = talloc_strdup(lck, (const char *)dbuf.dptr + sizeof(*data) +
592 (lck->num_share_modes *
593 sizeof(struct share_mode_entry)) +
594 data->u.s.delete_token_size +
595 strlen(lck->servicepath) + 1 );
596 if (lck->filename == NULL) {
597 smb_panic("parse_share_modes: talloc_strdup failed");
601 * Ensure that each entry has a real process attached.
604 for (i = 0; i < lck->num_share_modes; i++) {
605 struct share_mode_entry *entry_p = &lck->share_modes[i];
606 DEBUG(10,("parse_share_modes: %s\n",
607 share_mode_str(i, entry_p) ));
608 if (!process_exists(entry_p->pid)) {
609 DEBUG(10,("parse_share_modes: deleted %s\n",
610 share_mode_str(i, entry_p) ));
611 entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
612 lck->modified = True;
619 static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
624 struct locking_data *data;
627 uint32 delete_token_size;
632 for (i=0; i<lck->num_share_modes; i++) {
633 if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
638 if (num_valid == 0) {
642 sp_len = strlen(lck->servicepath);
643 delete_token_size = (lck->delete_token ?
644 (sizeof(uid_t) + sizeof(gid_t) + (lck->delete_token->ngroups*sizeof(gid_t))) : 0);
646 result.dsize = sizeof(*data) +
647 lck->num_share_modes * sizeof(struct share_mode_entry) +
650 strlen(lck->filename) + 1;
651 result.dptr = TALLOC_ARRAY(lck, uint8, result.dsize);
653 if (result.dptr == NULL) {
654 smb_panic("talloc failed");
657 data = (struct locking_data *)result.dptr;
659 data->u.s.num_share_mode_entries = lck->num_share_modes;
660 data->u.s.delete_on_close = lck->delete_on_close;
661 data->u.s.delete_token_size = delete_token_size;
662 DEBUG(10, ("unparse_share_modes: del: %d, tok = %u, num: %d\n",
663 data->u.s.delete_on_close,
664 (unsigned int)data->u.s.delete_token_size,
665 data->u.s.num_share_mode_entries));
666 memcpy(result.dptr + sizeof(*data), lck->share_modes,
667 sizeof(struct share_mode_entry)*lck->num_share_modes);
668 offset = sizeof(*data) +
669 sizeof(struct share_mode_entry)*lck->num_share_modes;
671 /* Store any delete on close token. */
672 if (lck->delete_token) {
673 uint8 *p = result.dptr + offset;
675 memcpy(p, &lck->delete_token->uid, sizeof(uid_t));
678 memcpy(p, &lck->delete_token->gid, sizeof(gid_t));
681 for (i = 0; i < lck->delete_token->ngroups; i++) {
682 memcpy(p, &lck->delete_token->groups[i], sizeof(gid_t));
685 offset = p - result.dptr;
688 safe_strcpy((char *)result.dptr + offset, lck->servicepath,
689 result.dsize - offset - 1);
690 offset += sp_len + 1;
691 safe_strcpy((char *)result.dptr + offset, lck->filename,
692 result.dsize - offset - 1);
694 if (DEBUGLEVEL >= 10) {
695 print_share_mode_table(data);
701 static int share_mode_lock_destructor(struct share_mode_lock *lck)
706 if (!lck->modified) {
710 data = unparse_share_modes(lck);
712 if (data.dptr == NULL) {
714 /* There has been an entry before, delete it */
716 status = lck->record->delete_rec(lck->record);
717 if (!NT_STATUS_IS_OK(status)) {
718 DEBUG(0, ("delete_rec returned %s\n",
720 smb_panic("could not delete share entry");
726 status = lck->record->store(lck->record, data, TDB_REPLACE);
727 if (!NT_STATUS_IS_OK(status)) {
728 DEBUG(0, ("store returned %s\n", nt_errstr(status)));
729 smb_panic("could not store share mode entry");
737 static BOOL fill_share_mode_lock(struct share_mode_lock *lck,
739 const char *servicepath,
741 TDB_DATA share_mode_data)
743 /* Ensure we set every field here as the destructor must be
744 valid even if parse_share_modes fails. */
746 lck->servicepath = NULL;
747 lck->filename = NULL;
749 lck->num_share_modes = 0;
750 lck->share_modes = NULL;
751 lck->delete_token = NULL;
752 lck->delete_on_close = False;
754 lck->modified = False;
756 lck->fresh = (share_mode_data.dptr == NULL);
759 if (fname == NULL || servicepath == NULL) {
762 lck->filename = talloc_strdup(lck, fname);
763 lck->servicepath = talloc_strdup(lck, servicepath);
764 if (lck->filename == NULL || lck->servicepath == NULL) {
765 DEBUG(0, ("talloc failed\n"));
769 if (!parse_share_modes(share_mode_data, lck)) {
770 DEBUG(0, ("Could not parse share modes\n"));
778 struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
780 const char *servicepath,
783 struct share_mode_lock *lck;
784 TDB_DATA key = locking_key(id);
786 if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
787 DEBUG(0, ("talloc failed\n"));
791 if (!(lck->record = lock_db->fetch_locked(lock_db, lck, key))) {
792 DEBUG(3, ("Could not lock share entry\n"));
797 if (!fill_share_mode_lock(lck, id, servicepath, fname,
798 lck->record->value)) {
799 DEBUG(3, ("fill_share_mode_lock failed\n"));
804 talloc_set_destructor(lck, share_mode_lock_destructor);
809 struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
811 const char *servicepath,
814 struct share_mode_lock *lck;
815 TDB_DATA key = locking_key(id);
818 if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
819 DEBUG(0, ("talloc failed\n"));
823 if (lock_db->fetch(lock_db, lck, key, &data) == -1) {
824 DEBUG(3, ("Could not fetch share entry\n"));
829 if (!fill_share_mode_lock(lck, id, servicepath, fname, data)) {
830 DEBUG(3, ("fill_share_mode_lock failed\n"));
835 TALLOC_FREE(data.dptr);
840 /*******************************************************************
841 Sets the service name and filename for rename.
842 At this point we emit "file renamed" messages to all
843 process id's that have this file open.
844 Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
845 ********************************************************************/
847 BOOL rename_share_filename(struct messaging_context *msg_ctx,
848 struct share_mode_lock *lck,
849 const char *servicepath,
858 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
859 servicepath, newname));
862 * rename_internal_fsp() and rename_internals() add './' to
863 * head of newname if newname does not contain a '/'.
865 while (newname[0] && newname[1] && newname[0] == '.' && newname[1] == '/') {
869 lck->servicepath = talloc_strdup(lck, servicepath);
870 lck->filename = talloc_strdup(lck, newname);
871 if (lck->filename == NULL || lck->servicepath == NULL) {
872 DEBUG(0, ("rename_share_filename: talloc failed\n"));
875 lck->modified = True;
877 sp_len = strlen(lck->servicepath);
878 fn_len = strlen(lck->filename);
880 msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + fn_len + 1;
882 /* Set up the name changed message. */
883 frm = TALLOC_ARRAY(lck, char, msg_len);
888 push_file_id_16(frm, &lck->id);
890 DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
892 safe_strcpy(&frm[16], lck->servicepath, sp_len);
893 safe_strcpy(&frm[16 + sp_len + 1], lck->filename, fn_len);
895 /* Send the messages. */
896 for (i=0; i<lck->num_share_modes; i++) {
897 struct share_mode_entry *se = &lck->share_modes[i];
898 if (!is_valid_share_mode_entry(se)) {
901 /* But not to ourselves... */
902 if (procid_is_me(&se->pid)) {
906 DEBUG(10,("rename_share_filename: sending rename message to pid %s "
907 "file_id %s sharepath %s newname %s\n",
908 procid_str_static(&se->pid),
909 file_id_string_tos(&lck->id),
910 lck->servicepath, lck->filename ));
912 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
913 (uint8 *)frm, msg_len);
919 BOOL get_delete_on_close_flag(struct file_id id)
922 struct share_mode_lock *lck;
924 if (!(lck = fetch_share_mode_unlocked(NULL, id, NULL, NULL))) {
927 result = lck->delete_on_close;
932 BOOL is_valid_share_mode_entry(const struct share_mode_entry *e)
936 if (e->op_type == UNUSED_SHARE_MODE_ENTRY) {
937 /* cope with dead entries from the process not
938 existing. These should not be considered valid,
939 otherwise we end up doing zero timeout sharing
944 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
945 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
946 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
948 SMB_ASSERT(num_props <= 1);
949 return (num_props != 0);
952 BOOL is_deferred_open_entry(const struct share_mode_entry *e)
954 return (e->op_type == DEFERRED_OPEN_ENTRY);
957 BOOL is_unused_share_mode_entry(const struct share_mode_entry *e)
959 return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
962 /*******************************************************************
963 Fill a share mode entry.
964 ********************************************************************/
966 static void fill_share_mode_entry(struct share_mode_entry *e,
968 uid_t uid, uint16 mid, uint16 op_type)
971 e->pid = procid_self();
972 e->share_access = fsp->share_access;
973 e->private_options = fsp->fh->private_options;
974 e->access_mask = fsp->access_mask;
976 e->op_type = op_type;
977 e->time.tv_sec = fsp->open_time.tv_sec;
978 e->time.tv_usec = fsp->open_time.tv_usec;
979 e->id = fsp->file_id;
980 e->share_file_id = fsp->fh->gen_id;
981 e->uid = (uint32)uid;
982 e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
985 static void fill_deferred_open_entry(struct share_mode_entry *e,
986 const struct timeval request_time,
987 struct file_id id, uint16 mid)
990 e->pid = procid_self();
992 e->op_type = DEFERRED_OPEN_ENTRY;
993 e->time.tv_sec = request_time.tv_sec;
994 e->time.tv_usec = request_time.tv_usec;
1000 static void add_share_mode_entry(struct share_mode_lock *lck,
1001 const struct share_mode_entry *entry)
1005 for (i=0; i<lck->num_share_modes; i++) {
1006 struct share_mode_entry *e = &lck->share_modes[i];
1007 if (is_unused_share_mode_entry(e)) {
1013 if (i == lck->num_share_modes) {
1014 /* No unused entry found */
1015 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
1016 &lck->share_modes, &lck->num_share_modes);
1018 lck->modified = True;
1021 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
1022 uid_t uid, uint16 mid, uint16 op_type, BOOL initial_delete_on_close_allowed)
1024 struct share_mode_entry entry;
1025 fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
1026 if (initial_delete_on_close_allowed) {
1027 entry.flags |= SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE;
1029 add_share_mode_entry(lck, &entry);
1032 void add_deferred_open(struct share_mode_lock *lck, uint16 mid,
1033 struct timeval request_time,
1036 struct share_mode_entry entry;
1037 fill_deferred_open_entry(&entry, request_time, id, mid);
1038 add_share_mode_entry(lck, &entry);
1041 /*******************************************************************
1042 Check if two share mode entries are identical, ignoring oplock
1043 and mid info and desired_access. (Removed paranoia test - it's
1044 not automatically a logic error if they are identical. JRA.)
1045 ********************************************************************/
1047 static BOOL share_modes_identical(struct share_mode_entry *e1,
1048 struct share_mode_entry *e2)
1050 /* We used to check for e1->share_access == e2->share_access here
1051 as well as the other fields but 2 different DOS or FCB opens
1052 sharing the same share mode entry may validly differ in
1053 fsp->share_access field. */
1055 return (procid_equal(&e1->pid, &e2->pid) &&
1056 file_id_equal(&e1->id, &e2->id) &&
1057 e1->share_file_id == e2->share_file_id );
1060 static BOOL deferred_open_identical(struct share_mode_entry *e1,
1061 struct share_mode_entry *e2)
1063 return (procid_equal(&e1->pid, &e2->pid) &&
1064 (e1->op_mid == e2->op_mid) &&
1065 file_id_equal(&e1->id, &e2->id));
1068 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
1069 struct share_mode_entry *entry)
1073 for (i=0; i<lck->num_share_modes; i++) {
1074 struct share_mode_entry *e = &lck->share_modes[i];
1075 if (is_valid_share_mode_entry(entry) &&
1076 is_valid_share_mode_entry(e) &&
1077 share_modes_identical(e, entry)) {
1080 if (is_deferred_open_entry(entry) &&
1081 is_deferred_open_entry(e) &&
1082 deferred_open_identical(e, entry)) {
1089 /*******************************************************************
1090 Del the share mode of a file for this process. Return the number of
1092 ********************************************************************/
1094 BOOL del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
1096 struct share_mode_entry entry, *e;
1098 /* Don't care about the pid owner being correct here - just a search. */
1099 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1101 e = find_share_mode_entry(lck, &entry);
1106 e->op_type = UNUSED_SHARE_MODE_ENTRY;
1107 lck->modified = True;
1111 void del_deferred_open_entry(struct share_mode_lock *lck, uint16 mid)
1113 struct share_mode_entry entry, *e;
1115 fill_deferred_open_entry(&entry, timeval_zero(),
1118 e = find_share_mode_entry(lck, &entry);
1123 e->op_type = UNUSED_SHARE_MODE_ENTRY;
1124 lck->modified = True;
1127 /*******************************************************************
1128 Remove an oplock mid and mode entry from a share mode.
1129 ********************************************************************/
1131 BOOL remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1133 struct share_mode_entry entry, *e;
1135 /* Don't care about the pid owner being correct here - just a search. */
1136 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1138 e = find_share_mode_entry(lck, &entry);
1144 e->op_type = NO_OPLOCK;
1145 lck->modified = True;
1149 /*******************************************************************
1150 Downgrade a oplock type from exclusive to level II.
1151 ********************************************************************/
1153 BOOL downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1155 struct share_mode_entry entry, *e;
1157 /* Don't care about the pid owner being correct here - just a search. */
1158 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1160 e = find_share_mode_entry(lck, &entry);
1165 e->op_type = LEVEL_II_OPLOCK;
1166 lck->modified = True;
1170 /****************************************************************************
1171 Deal with the internal needs of setting the delete on close flag. Note that
1172 as the tdb locking is recursive, it is safe to call this from within
1173 open_file_ntcreate. JRA.
1174 ****************************************************************************/
1176 NTSTATUS can_set_delete_on_close(files_struct *fsp, BOOL delete_on_close,
1179 if (!delete_on_close) {
1180 return NT_STATUS_OK;
1184 * Only allow delete on close for writable files.
1187 if ((dosmode & aRONLY) &&
1188 !lp_delete_readonly(SNUM(fsp->conn))) {
1189 DEBUG(10,("can_set_delete_on_close: file %s delete on close "
1190 "flag set but file attribute is readonly.\n",
1192 return NT_STATUS_CANNOT_DELETE;
1196 * Only allow delete on close for writable shares.
1199 if (!CAN_WRITE(fsp->conn)) {
1200 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1201 "close flag set but write access denied on share.\n",
1203 return NT_STATUS_ACCESS_DENIED;
1207 * Only allow delete on close for files/directories opened with delete
1211 if (!(fsp->access_mask & DELETE_ACCESS)) {
1212 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1213 "close flag set but delete access denied.\n",
1215 return NT_STATUS_ACCESS_DENIED;
1218 /* Don't allow delete on close for non-empty directories. */
1219 if (fsp->is_directory) {
1220 return can_delete_directory(fsp->conn, fsp->fsp_name);
1223 return NT_STATUS_OK;
1226 /****************************************************************************
1227 Do we have an open file handle that created this entry ?
1228 ****************************************************************************/
1230 BOOL can_set_initial_delete_on_close(const struct share_mode_lock *lck)
1234 for (i=0; i<lck->num_share_modes; i++) {
1235 if (lck->share_modes[i].flags & SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE) {
1242 /*************************************************************************
1243 Return a talloced copy of a UNIX_USER_TOKEN. NULL on fail.
1244 (Should this be in locking.c.... ?).
1245 *************************************************************************/
1247 static UNIX_USER_TOKEN *copy_unix_token(TALLOC_CTX *ctx, UNIX_USER_TOKEN *tok)
1249 UNIX_USER_TOKEN *cpy;
1255 cpy = TALLOC_P(ctx, UNIX_USER_TOKEN);
1260 cpy->uid = tok->uid;
1261 cpy->gid = tok->gid;
1262 cpy->ngroups = tok->ngroups;
1264 /* Make this a talloc child of cpy. */
1265 cpy->groups = TALLOC_ARRAY(cpy, gid_t, tok->ngroups);
1269 memcpy(cpy->groups, tok->groups, tok->ngroups * sizeof(gid_t));
1274 /****************************************************************************
1275 Replace the delete on close token.
1276 ****************************************************************************/
1278 void set_delete_on_close_token(struct share_mode_lock *lck, UNIX_USER_TOKEN *tok)
1280 /* Ensure there's no token. */
1281 if (lck->delete_token) {
1282 TALLOC_FREE(lck->delete_token); /* Also deletes groups... */
1283 lck->delete_token = NULL;
1286 /* Copy the new token (can be NULL). */
1287 lck->delete_token = copy_unix_token(lck, tok);
1288 lck->modified = True;
1291 /****************************************************************************
1292 Sets the delete on close flag over all share modes on this file.
1293 Modify the share mode entry for all files open
1294 on this device and inode to tell other smbds we have
1295 changed the delete on close flag. This will be noticed
1296 in the close code, the last closer will delete the file
1298 This makes a copy of any UNIX_USER_TOKEN into the
1299 lck entry. This function is used when the lock is already granted.
1300 ****************************************************************************/
1302 void set_delete_on_close_lck(struct share_mode_lock *lck, BOOL delete_on_close, UNIX_USER_TOKEN *tok)
1304 if (lck->delete_on_close != delete_on_close) {
1305 set_delete_on_close_token(lck, tok);
1306 lck->delete_on_close = delete_on_close;
1307 if (delete_on_close) {
1308 SMB_ASSERT(lck->delete_token != NULL);
1310 lck->modified = True;
1314 BOOL set_delete_on_close(files_struct *fsp, BOOL delete_on_close, UNIX_USER_TOKEN *tok)
1316 struct share_mode_lock *lck;
1318 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1319 "fnum = %d, file %s\n",
1320 delete_on_close ? "Adding" : "Removing", fsp->fnum,
1327 lck = get_share_mode_lock(NULL, fsp->file_id, NULL, NULL);
1332 set_delete_on_close_lck(lck, delete_on_close, tok);
1334 if (fsp->is_directory) {
1335 send_stat_cache_delete_message(fsp->fsp_name);
1342 /****************************************************************************
1343 Sets the allow initial delete on close flag for this share mode.
1344 ****************************************************************************/
1346 BOOL set_allow_initial_delete_on_close(struct share_mode_lock *lck, files_struct *fsp, BOOL delete_on_close)
1348 struct share_mode_entry entry, *e;
1350 /* Don't care about the pid owner being correct here - just a search. */
1351 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1353 e = find_share_mode_entry(lck, &entry);
1358 if (delete_on_close) {
1359 e->flags |= SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE;
1361 e->flags &= ~SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE;
1363 lck->modified = True;
1367 struct forall_state {
1368 void (*fn)(const struct share_mode_entry *entry,
1369 const char *sharepath,
1371 void *private_data);
1375 static int traverse_fn(struct db_record *rec, void *_state)
1377 struct forall_state *state = (struct forall_state *)_state;
1378 struct locking_data *data;
1379 struct share_mode_entry *shares;
1380 const char *sharepath;
1384 /* Ensure this is a locking_key record. */
1385 if (rec->key.dsize != sizeof(struct file_id))
1388 data = (struct locking_data *)rec->value.dptr;
1389 shares = (struct share_mode_entry *)(rec->value.dptr + sizeof(*data));
1390 sharepath = (const char *)rec->value.dptr + sizeof(*data) +
1391 data->u.s.num_share_mode_entries*sizeof(*shares) +
1392 data->u.s.delete_token_size;
1393 fname = (const char *)rec->value.dptr + sizeof(*data) +
1394 data->u.s.num_share_mode_entries*sizeof(*shares) +
1395 data->u.s.delete_token_size +
1396 strlen(sharepath) + 1;
1398 for (i=0;i<data->u.s.num_share_mode_entries;i++) {
1399 state->fn(&shares[i], sharepath, fname,
1400 state->private_data);
1405 /*******************************************************************
1406 Call the specified function on each entry under management by the
1408 ********************************************************************/
1410 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
1411 const char *, void *),
1414 struct forall_state state;
1416 if (lock_db == NULL)
1420 state.private_data = private_data;
1422 return lock_db->traverse_read(lock_db, traverse_fn, (void *)&state);