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"),
398 lp_open_files_db_hash_size(),
401 |(read_only?0x0:TDB_CLEAR_IF_FIRST),
402 read_only?O_RDONLY:O_RDWR|O_CREAT, 0644);
405 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
409 if (!posix_locking_init(read_only))
412 open_read_only = read_only;
417 /*******************************************************************
418 Deinitialize the share_mode management.
419 ******************************************************************/
421 BOOL locking_end(void)
423 brl_shutdown(open_read_only);
425 TALLOC_FREE(lock_db);
430 /*******************************************************************
431 Form a static locking key for a dev/inode pair.
432 ******************************************************************/
434 static TDB_DATA locking_key(struct file_id id)
436 static struct file_id key;
439 kbuf.dptr = (uint8 *)&key;
440 kbuf.dsize = sizeof(key);
444 /*******************************************************************
445 Print out a share mode.
446 ********************************************************************/
448 char *share_mode_str(int num, struct share_mode_entry *e)
450 static pstring share_str;
452 slprintf(share_str, sizeof(share_str)-1, "share_mode_entry[%d]: %s "
453 "pid = %s, share_access = 0x%x, private_options = 0x%x, "
454 "access_mask = 0x%x, mid = 0x%x, type= 0x%x, gen_id = %lu, "
455 "uid = %u, flags = %u, file_id %s",
457 e->op_type == UNUSED_SHARE_MODE_ENTRY ? "UNUSED" : "",
458 procid_str_static(&e->pid),
459 e->share_access, e->private_options,
460 e->access_mask, e->op_mid, e->op_type, e->share_file_id,
461 (unsigned int)e->uid, (unsigned int)e->flags,
462 file_id_static_string(&e->id));
467 /*******************************************************************
468 Print out a share mode table.
469 ********************************************************************/
471 static void print_share_mode_table(struct locking_data *data)
473 int num_share_modes = data->u.s.num_share_mode_entries;
474 struct share_mode_entry *shares =
475 (struct share_mode_entry *)(data + 1);
478 for (i = 0; i < num_share_modes; i++) {
479 struct share_mode_entry entry;
481 memcpy(&entry, &shares[i], sizeof(struct share_mode_entry));
482 DEBUG(10,("print_share_mode_table: %s\n",
483 share_mode_str(i, &entry)));
487 /*******************************************************************
488 Get all share mode entries for a dev/inode pair.
489 ********************************************************************/
491 static BOOL parse_share_modes(TDB_DATA dbuf, struct share_mode_lock *lck)
493 struct locking_data *data;
496 if (dbuf.dsize < sizeof(struct locking_data)) {
497 smb_panic("parse_share_modes: buffer too short");
500 data = (struct locking_data *)dbuf.dptr;
502 lck->delete_on_close = data->u.s.delete_on_close;
503 lck->num_share_modes = data->u.s.num_share_mode_entries;
505 DEBUG(10, ("parse_share_modes: delete_on_close: %d, "
506 "num_share_modes: %d\n",
507 lck->delete_on_close,
508 lck->num_share_modes));
510 if ((lck->num_share_modes < 0) || (lck->num_share_modes > 1000000)) {
511 DEBUG(0, ("invalid number of share modes: %d\n",
512 lck->num_share_modes));
513 smb_panic("parse_share_modes: invalid number of share modes");
516 lck->share_modes = NULL;
518 if (lck->num_share_modes != 0) {
520 if (dbuf.dsize < (sizeof(struct locking_data) +
521 (lck->num_share_modes *
522 sizeof(struct share_mode_entry)))) {
523 smb_panic("parse_share_modes: buffer too short");
526 lck->share_modes = (struct share_mode_entry *)
527 TALLOC_MEMDUP(lck, dbuf.dptr+sizeof(*data),
528 lck->num_share_modes *
529 sizeof(struct share_mode_entry));
531 if (lck->share_modes == NULL) {
532 smb_panic("parse_share_modes: talloc failed");
536 /* Get any delete token. */
537 if (data->u.s.delete_token_size) {
538 uint8 *p = dbuf.dptr + sizeof(*data) +
539 (lck->num_share_modes *
540 sizeof(struct share_mode_entry));
542 if ((data->u.s.delete_token_size < sizeof(uid_t) + sizeof(gid_t)) ||
543 ((data->u.s.delete_token_size - sizeof(uid_t)) % sizeof(gid_t)) != 0) {
544 DEBUG(0, ("parse_share_modes: invalid token size %d\n",
545 data->u.s.delete_token_size));
546 smb_panic("parse_share_modes: invalid token size");
549 lck->delete_token = TALLOC_P(lck, UNIX_USER_TOKEN);
550 if (!lck->delete_token) {
551 smb_panic("parse_share_modes: talloc failed");
554 /* Copy out the uid and gid. */
555 memcpy(&lck->delete_token->uid, p, sizeof(uid_t));
557 memcpy(&lck->delete_token->gid, p, sizeof(gid_t));
560 /* Any supplementary groups ? */
561 lck->delete_token->ngroups = (data->u.s.delete_token_size > (sizeof(uid_t) + sizeof(gid_t))) ?
562 ((data->u.s.delete_token_size -
563 (sizeof(uid_t) + sizeof(gid_t)))/sizeof(gid_t)) : 0;
565 if (lck->delete_token->ngroups) {
566 /* Make this a talloc child of lck->delete_token. */
567 lck->delete_token->groups = TALLOC_ARRAY(lck->delete_token, gid_t,
568 lck->delete_token->ngroups);
569 if (!lck->delete_token) {
570 smb_panic("parse_share_modes: talloc failed");
573 for (i = 0; i < lck->delete_token->ngroups; i++) {
574 memcpy(&lck->delete_token->groups[i], p, sizeof(gid_t));
580 lck->delete_token = NULL;
583 /* Save off the associated service path and filename. */
584 lck->servicepath = talloc_strdup(lck, (const char *)dbuf.dptr + sizeof(*data) +
585 (lck->num_share_modes *
586 sizeof(struct share_mode_entry)) +
587 data->u.s.delete_token_size );
588 if (lck->servicepath == NULL) {
589 smb_panic("parse_share_modes: talloc_strdup failed");
592 lck->filename = talloc_strdup(lck, (const char *)dbuf.dptr + sizeof(*data) +
593 (lck->num_share_modes *
594 sizeof(struct share_mode_entry)) +
595 data->u.s.delete_token_size +
596 strlen(lck->servicepath) + 1 );
597 if (lck->filename == NULL) {
598 smb_panic("parse_share_modes: talloc_strdup failed");
602 * Ensure that each entry has a real process attached.
605 for (i = 0; i < lck->num_share_modes; i++) {
606 struct share_mode_entry *entry_p = &lck->share_modes[i];
607 DEBUG(10,("parse_share_modes: %s\n",
608 share_mode_str(i, entry_p) ));
609 if (!process_exists(entry_p->pid)) {
610 DEBUG(10,("parse_share_modes: deleted %s\n",
611 share_mode_str(i, entry_p) ));
612 entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
613 lck->modified = True;
620 static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
625 struct locking_data *data;
628 uint32 delete_token_size;
633 for (i=0; i<lck->num_share_modes; i++) {
634 if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
639 if (num_valid == 0) {
643 sp_len = strlen(lck->servicepath);
644 delete_token_size = (lck->delete_token ?
645 (sizeof(uid_t) + sizeof(gid_t) + (lck->delete_token->ngroups*sizeof(gid_t))) : 0);
647 result.dsize = sizeof(*data) +
648 lck->num_share_modes * sizeof(struct share_mode_entry) +
651 strlen(lck->filename) + 1;
652 result.dptr = TALLOC_ARRAY(lck, uint8, result.dsize);
654 if (result.dptr == NULL) {
655 smb_panic("talloc failed");
658 data = (struct locking_data *)result.dptr;
660 data->u.s.num_share_mode_entries = lck->num_share_modes;
661 data->u.s.delete_on_close = lck->delete_on_close;
662 data->u.s.delete_token_size = delete_token_size;
663 DEBUG(10, ("unparse_share_modes: del: %d, tok = %u, num: %d\n",
664 data->u.s.delete_on_close,
665 (unsigned int)data->u.s.delete_token_size,
666 data->u.s.num_share_mode_entries));
667 memcpy(result.dptr + sizeof(*data), lck->share_modes,
668 sizeof(struct share_mode_entry)*lck->num_share_modes);
669 offset = sizeof(*data) +
670 sizeof(struct share_mode_entry)*lck->num_share_modes;
672 /* Store any delete on close token. */
673 if (lck->delete_token) {
674 uint8 *p = result.dptr + offset;
676 memcpy(p, &lck->delete_token->uid, sizeof(uid_t));
679 memcpy(p, &lck->delete_token->gid, sizeof(gid_t));
682 for (i = 0; i < lck->delete_token->ngroups; i++) {
683 memcpy(p, &lck->delete_token->groups[i], sizeof(gid_t));
686 offset = p - result.dptr;
689 safe_strcpy((char *)result.dptr + offset, lck->servicepath,
690 result.dsize - offset - 1);
691 offset += sp_len + 1;
692 safe_strcpy((char *)result.dptr + offset, lck->filename,
693 result.dsize - offset - 1);
695 if (DEBUGLEVEL >= 10) {
696 print_share_mode_table(data);
702 static int share_mode_lock_destructor(struct share_mode_lock *lck)
707 if (!lck->modified) {
711 data = unparse_share_modes(lck);
713 if (data.dptr == NULL) {
715 /* There has been an entry before, delete it */
717 status = lck->record->delete_rec(lck->record);
718 if (!NT_STATUS_IS_OK(status)) {
719 DEBUG(0, ("delete_rec returned %s\n",
721 smb_panic("could not delete share entry");
727 status = lck->record->store(lck->record, data, TDB_REPLACE);
728 if (!NT_STATUS_IS_OK(status)) {
729 DEBUG(0, ("store returned %s\n", nt_errstr(status)));
730 smb_panic("could not store share mode entry");
738 static BOOL fill_share_mode_lock(struct share_mode_lock *lck,
740 const char *servicepath,
742 TDB_DATA share_mode_data)
744 /* Ensure we set every field here as the destructor must be
745 valid even if parse_share_modes fails. */
747 lck->servicepath = NULL;
748 lck->filename = NULL;
750 lck->num_share_modes = 0;
751 lck->share_modes = NULL;
752 lck->delete_token = NULL;
753 lck->delete_on_close = False;
755 lck->modified = False;
757 lck->fresh = (share_mode_data.dptr == NULL);
760 if (fname == NULL || servicepath == NULL) {
763 lck->filename = talloc_strdup(lck, fname);
764 lck->servicepath = talloc_strdup(lck, servicepath);
765 if (lck->filename == NULL || lck->servicepath == NULL) {
766 DEBUG(0, ("talloc failed\n"));
770 if (!parse_share_modes(share_mode_data, lck)) {
771 DEBUG(0, ("Could not parse share modes\n"));
779 struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
781 const char *servicepath,
784 struct share_mode_lock *lck;
785 TDB_DATA key = locking_key(id);
787 if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
788 DEBUG(0, ("talloc failed\n"));
792 if (!(lck->record = lock_db->fetch_locked(lock_db, lck, key))) {
793 DEBUG(3, ("Could not lock share entry\n"));
798 if (!fill_share_mode_lock(lck, id, servicepath, fname,
799 lck->record->value)) {
800 DEBUG(3, ("fill_share_mode_lock failed\n"));
805 talloc_set_destructor(lck, share_mode_lock_destructor);
810 struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
812 const char *servicepath,
815 struct share_mode_lock *lck;
816 TDB_DATA key = locking_key(id);
819 if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
820 DEBUG(0, ("talloc failed\n"));
824 if (lock_db->fetch(lock_db, lck, key, &data) == -1) {
825 DEBUG(3, ("Could not fetch share entry\n"));
830 if (!fill_share_mode_lock(lck, id, servicepath, fname, data)) {
831 DEBUG(3, ("fill_share_mode_lock failed\n"));
836 TALLOC_FREE(data.dptr);
841 /*******************************************************************
842 Sets the service name and filename for rename.
843 At this point we emit "file renamed" messages to all
844 process id's that have this file open.
845 Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
846 ********************************************************************/
848 BOOL rename_share_filename(struct messaging_context *msg_ctx,
849 struct share_mode_lock *lck,
850 const char *servicepath,
859 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
860 servicepath, newname));
863 * rename_internal_fsp() and rename_internals() add './' to
864 * head of newname if newname does not contain a '/'.
866 while (newname[0] && newname[1] && newname[0] == '.' && newname[1] == '/') {
870 lck->servicepath = talloc_strdup(lck, servicepath);
871 lck->filename = talloc_strdup(lck, newname);
872 if (lck->filename == NULL || lck->servicepath == NULL) {
873 DEBUG(0, ("rename_share_filename: talloc failed\n"));
876 lck->modified = True;
878 sp_len = strlen(lck->servicepath);
879 fn_len = strlen(lck->filename);
881 msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + fn_len + 1;
883 /* Set up the name changed message. */
884 frm = TALLOC_ARRAY(lck, char, msg_len);
889 push_file_id_16(frm, &lck->id);
891 DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
893 safe_strcpy(&frm[16], lck->servicepath, sp_len);
894 safe_strcpy(&frm[16 + sp_len + 1], lck->filename, fn_len);
896 /* Send the messages. */
897 for (i=0; i<lck->num_share_modes; i++) {
898 struct share_mode_entry *se = &lck->share_modes[i];
899 if (!is_valid_share_mode_entry(se)) {
902 /* But not to ourselves... */
903 if (procid_is_me(&se->pid)) {
907 DEBUG(10,("rename_share_filename: sending rename message to pid %s "
908 "file_id %s sharepath %s newname %s\n",
909 procid_str_static(&se->pid),
910 file_id_static_string(&lck->id),
911 lck->servicepath, lck->filename ));
913 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
914 (uint8 *)frm, msg_len);
920 BOOL get_delete_on_close_flag(struct file_id id)
923 struct share_mode_lock *lck;
925 if (!(lck = fetch_share_mode_unlocked(NULL, id, NULL, NULL))) {
928 result = lck->delete_on_close;
933 BOOL is_valid_share_mode_entry(const struct share_mode_entry *e)
937 if (e->op_type == UNUSED_SHARE_MODE_ENTRY) {
938 /* cope with dead entries from the process not
939 existing. These should not be considered valid,
940 otherwise we end up doing zero timeout sharing
945 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
946 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
947 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
949 SMB_ASSERT(num_props <= 1);
950 return (num_props != 0);
953 BOOL is_deferred_open_entry(const struct share_mode_entry *e)
955 return (e->op_type == DEFERRED_OPEN_ENTRY);
958 BOOL is_unused_share_mode_entry(const struct share_mode_entry *e)
960 return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
963 /*******************************************************************
964 Fill a share mode entry.
965 ********************************************************************/
967 static void fill_share_mode_entry(struct share_mode_entry *e,
969 uid_t uid, uint16 mid, uint16 op_type)
972 e->pid = procid_self();
973 e->share_access = fsp->share_access;
974 e->private_options = fsp->fh->private_options;
975 e->access_mask = fsp->access_mask;
977 e->op_type = op_type;
978 e->time.tv_sec = fsp->open_time.tv_sec;
979 e->time.tv_usec = fsp->open_time.tv_usec;
980 e->id = fsp->file_id;
981 e->share_file_id = fsp->fh->gen_id;
982 e->uid = (uint32)uid;
983 e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
986 static void fill_deferred_open_entry(struct share_mode_entry *e,
987 const struct timeval request_time,
988 struct file_id id, uint16 mid)
991 e->pid = procid_self();
993 e->op_type = DEFERRED_OPEN_ENTRY;
994 e->time.tv_sec = request_time.tv_sec;
995 e->time.tv_usec = request_time.tv_usec;
1001 static void add_share_mode_entry(struct share_mode_lock *lck,
1002 const struct share_mode_entry *entry)
1006 for (i=0; i<lck->num_share_modes; i++) {
1007 struct share_mode_entry *e = &lck->share_modes[i];
1008 if (is_unused_share_mode_entry(e)) {
1014 if (i == lck->num_share_modes) {
1015 /* No unused entry found */
1016 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
1017 &lck->share_modes, &lck->num_share_modes);
1019 lck->modified = True;
1022 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
1023 uid_t uid, uint16 mid, uint16 op_type, BOOL initial_delete_on_close_allowed)
1025 struct share_mode_entry entry;
1026 fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
1027 if (initial_delete_on_close_allowed) {
1028 entry.flags |= SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE;
1030 add_share_mode_entry(lck, &entry);
1033 void add_deferred_open(struct share_mode_lock *lck, uint16 mid,
1034 struct timeval request_time,
1037 struct share_mode_entry entry;
1038 fill_deferred_open_entry(&entry, request_time, id, mid);
1039 add_share_mode_entry(lck, &entry);
1042 /*******************************************************************
1043 Check if two share mode entries are identical, ignoring oplock
1044 and mid info and desired_access. (Removed paranoia test - it's
1045 not automatically a logic error if they are identical. JRA.)
1046 ********************************************************************/
1048 static BOOL share_modes_identical(struct share_mode_entry *e1,
1049 struct share_mode_entry *e2)
1051 /* We used to check for e1->share_access == e2->share_access here
1052 as well as the other fields but 2 different DOS or FCB opens
1053 sharing the same share mode entry may validly differ in
1054 fsp->share_access field. */
1056 return (procid_equal(&e1->pid, &e2->pid) &&
1057 file_id_equal(&e1->id, &e2->id) &&
1058 e1->share_file_id == e2->share_file_id );
1061 static BOOL deferred_open_identical(struct share_mode_entry *e1,
1062 struct share_mode_entry *e2)
1064 return (procid_equal(&e1->pid, &e2->pid) &&
1065 (e1->op_mid == e2->op_mid) &&
1066 file_id_equal(&e1->id, &e2->id));
1069 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
1070 struct share_mode_entry *entry)
1074 for (i=0; i<lck->num_share_modes; i++) {
1075 struct share_mode_entry *e = &lck->share_modes[i];
1076 if (is_valid_share_mode_entry(entry) &&
1077 is_valid_share_mode_entry(e) &&
1078 share_modes_identical(e, entry)) {
1081 if (is_deferred_open_entry(entry) &&
1082 is_deferred_open_entry(e) &&
1083 deferred_open_identical(e, entry)) {
1090 /*******************************************************************
1091 Del the share mode of a file for this process. Return the number of
1093 ********************************************************************/
1095 BOOL del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
1097 struct share_mode_entry entry, *e;
1099 /* Don't care about the pid owner being correct here - just a search. */
1100 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1102 e = find_share_mode_entry(lck, &entry);
1107 e->op_type = UNUSED_SHARE_MODE_ENTRY;
1108 lck->modified = True;
1112 void del_deferred_open_entry(struct share_mode_lock *lck, uint16 mid)
1114 struct share_mode_entry entry, *e;
1116 fill_deferred_open_entry(&entry, timeval_zero(),
1119 e = find_share_mode_entry(lck, &entry);
1124 e->op_type = UNUSED_SHARE_MODE_ENTRY;
1125 lck->modified = True;
1128 /*******************************************************************
1129 Remove an oplock mid and mode entry from a share mode.
1130 ********************************************************************/
1132 BOOL remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1134 struct share_mode_entry entry, *e;
1136 /* Don't care about the pid owner being correct here - just a search. */
1137 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1139 e = find_share_mode_entry(lck, &entry);
1145 e->op_type = NO_OPLOCK;
1146 lck->modified = True;
1150 /*******************************************************************
1151 Downgrade a oplock type from exclusive to level II.
1152 ********************************************************************/
1154 BOOL downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1156 struct share_mode_entry entry, *e;
1158 /* Don't care about the pid owner being correct here - just a search. */
1159 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1161 e = find_share_mode_entry(lck, &entry);
1166 e->op_type = LEVEL_II_OPLOCK;
1167 lck->modified = True;
1171 /****************************************************************************
1172 Deal with the internal needs of setting the delete on close flag. Note that
1173 as the tdb locking is recursive, it is safe to call this from within
1174 open_file_ntcreate. JRA.
1175 ****************************************************************************/
1177 NTSTATUS can_set_delete_on_close(files_struct *fsp, BOOL delete_on_close,
1180 if (!delete_on_close) {
1181 return NT_STATUS_OK;
1185 * Only allow delete on close for writable files.
1188 if ((dosmode & aRONLY) &&
1189 !lp_delete_readonly(SNUM(fsp->conn))) {
1190 DEBUG(10,("can_set_delete_on_close: file %s delete on close "
1191 "flag set but file attribute is readonly.\n",
1193 return NT_STATUS_CANNOT_DELETE;
1197 * Only allow delete on close for writable shares.
1200 if (!CAN_WRITE(fsp->conn)) {
1201 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1202 "close flag set but write access denied on share.\n",
1204 return NT_STATUS_ACCESS_DENIED;
1208 * Only allow delete on close for files/directories opened with delete
1212 if (!(fsp->access_mask & DELETE_ACCESS)) {
1213 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1214 "close flag set but delete access denied.\n",
1216 return NT_STATUS_ACCESS_DENIED;
1219 /* Don't allow delete on close for non-empty directories. */
1220 if (fsp->is_directory) {
1221 return can_delete_directory(fsp->conn, fsp->fsp_name);
1224 return NT_STATUS_OK;
1227 /****************************************************************************
1228 Do we have an open file handle that created this entry ?
1229 ****************************************************************************/
1231 BOOL can_set_initial_delete_on_close(const struct share_mode_lock *lck)
1235 for (i=0; i<lck->num_share_modes; i++) {
1236 if (lck->share_modes[i].flags & SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE) {
1243 /*************************************************************************
1244 Return a talloced copy of a UNIX_USER_TOKEN. NULL on fail.
1245 (Should this be in locking.c.... ?).
1246 *************************************************************************/
1248 static UNIX_USER_TOKEN *copy_unix_token(TALLOC_CTX *ctx, UNIX_USER_TOKEN *tok)
1250 UNIX_USER_TOKEN *cpy;
1256 cpy = TALLOC_P(ctx, UNIX_USER_TOKEN);
1261 cpy->uid = tok->uid;
1262 cpy->gid = tok->gid;
1263 cpy->ngroups = tok->ngroups;
1265 /* Make this a talloc child of cpy. */
1266 cpy->groups = TALLOC_ARRAY(cpy, gid_t, tok->ngroups);
1270 memcpy(cpy->groups, tok->groups, tok->ngroups * sizeof(gid_t));
1275 /****************************************************************************
1276 Replace the delete on close token.
1277 ****************************************************************************/
1279 void set_delete_on_close_token(struct share_mode_lock *lck, UNIX_USER_TOKEN *tok)
1281 /* Ensure there's no token. */
1282 if (lck->delete_token) {
1283 TALLOC_FREE(lck->delete_token); /* Also deletes groups... */
1284 lck->delete_token = NULL;
1287 /* Copy the new token (can be NULL). */
1288 lck->delete_token = copy_unix_token(lck, tok);
1289 lck->modified = True;
1292 /****************************************************************************
1293 Sets the delete on close flag over all share modes on this file.
1294 Modify the share mode entry for all files open
1295 on this device and inode to tell other smbds we have
1296 changed the delete on close flag. This will be noticed
1297 in the close code, the last closer will delete the file
1299 This makes a copy of any UNIX_USER_TOKEN into the
1300 lck entry. This function is used when the lock is already granted.
1301 ****************************************************************************/
1303 void set_delete_on_close_lck(struct share_mode_lock *lck, BOOL delete_on_close, UNIX_USER_TOKEN *tok)
1305 if (lck->delete_on_close != delete_on_close) {
1306 set_delete_on_close_token(lck, tok);
1307 lck->delete_on_close = delete_on_close;
1308 if (delete_on_close) {
1309 SMB_ASSERT(lck->delete_token != NULL);
1311 lck->modified = True;
1315 BOOL set_delete_on_close(files_struct *fsp, BOOL delete_on_close, UNIX_USER_TOKEN *tok)
1317 struct share_mode_lock *lck;
1319 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1320 "fnum = %d, file %s\n",
1321 delete_on_close ? "Adding" : "Removing", fsp->fnum,
1328 lck = get_share_mode_lock(NULL, fsp->file_id, NULL, NULL);
1333 set_delete_on_close_lck(lck, delete_on_close, tok);
1335 if (fsp->is_directory) {
1336 send_stat_cache_delete_message(fsp->fsp_name);
1343 /****************************************************************************
1344 Sets the allow initial delete on close flag for this share mode.
1345 ****************************************************************************/
1347 BOOL set_allow_initial_delete_on_close(struct share_mode_lock *lck, files_struct *fsp, BOOL delete_on_close)
1349 struct share_mode_entry entry, *e;
1351 /* Don't care about the pid owner being correct here - just a search. */
1352 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1354 e = find_share_mode_entry(lck, &entry);
1359 if (delete_on_close) {
1360 e->flags |= SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE;
1362 e->flags &= ~SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE;
1364 lck->modified = True;
1368 struct forall_state {
1369 void (*fn)(const struct share_mode_entry *entry,
1370 const char *sharepath,
1372 void *private_data);
1376 static int traverse_fn(struct db_record *rec, void *_state)
1378 struct forall_state *state = (struct forall_state *)_state;
1379 struct locking_data *data;
1380 struct share_mode_entry *shares;
1381 const char *sharepath;
1385 /* Ensure this is a locking_key record. */
1386 if (rec->key.dsize != sizeof(struct file_id))
1389 data = (struct locking_data *)rec->value.dptr;
1390 shares = (struct share_mode_entry *)(rec->value.dptr + sizeof(*data));
1391 sharepath = (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 fname = (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 strlen(sharepath) + 1;
1399 for (i=0;i<data->u.s.num_share_mode_entries;i++) {
1400 state->fn(&shares[i], sharepath, fname,
1401 state->private_data);
1406 /*******************************************************************
1407 Call the specified function on each entry under management by the
1409 ********************************************************************/
1411 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
1412 const char *, void *),
1415 struct forall_state state;
1417 if (lock_db == NULL)
1421 state.private_data = private_data;
1423 return lock_db->traverse_read(lock_db, traverse_fn, (void *)&state);