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 2 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, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 12 aug 96: Erik.Devriendt@te6.siemens.be
25 added support for shared memory implementation of share mode locking
27 May 1997. Jeremy Allison (jallison@whistle.com). Modified share mode
28 locking to deal with multiple share modes per open file.
30 September 1997. Jeremy Allison (jallison@whistle.com). Added oplock
33 rewrtten completely to use new tdb code. Tridge, Dec '99
35 Added POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
36 Added Unix Extensions POSIX locking support. Jeremy Allison Mar 2006.
42 #define DBGC_CLASS DBGC_LOCKING
44 /* the locking database handle */
45 static struct db_context *lock_db;
47 /****************************************************************************
49 ****************************************************************************/
51 const char *lock_type_name(enum brl_type lock_type)
58 case PENDING_READ_LOCK:
59 return "PENDING_READ";
60 case PENDING_WRITE_LOCK:
61 return "PENDING_WRITE";
67 const char *lock_flav_name(enum brl_flavour lock_flav)
69 return (lock_flav == WINDOWS_LOCK) ? "WINDOWS_LOCK" : "POSIX_LOCK";
72 /****************************************************************************
73 Utility function called to see if a file region is locked.
74 Called in the read/write codepath.
75 ****************************************************************************/
77 BOOL is_locked(files_struct *fsp,
81 enum brl_type lock_type)
83 int strict_locking = lp_strict_locking(fsp->conn->params);
84 enum brl_flavour lock_flav = lp_posix_cifsu_locktype(fsp);
91 if (!lp_locking(fsp->conn->params) || !strict_locking) {
95 if (strict_locking == Auto) {
96 if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (lock_type == READ_LOCK || lock_type == WRITE_LOCK)) {
97 DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp->fsp_name ));
99 } else if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
100 (lock_type == READ_LOCK)) {
101 DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp->fsp_name ));
104 struct byte_range_lock *br_lck = brl_get_locks_readonly(NULL, fsp);
108 ret = !brl_locktest(br_lck,
118 struct byte_range_lock *br_lck = brl_get_locks_readonly(NULL, fsp);
122 ret = !brl_locktest(br_lck,
132 DEBUG(10,("is_locked: flavour = %s brl start=%.0f len=%.0f %s for fnum %d file %s\n",
133 lock_flav_name(lock_flav),
134 (double)offset, (double)count, ret ? "locked" : "unlocked",
135 fsp->fnum, fsp->fsp_name ));
140 /****************************************************************************
141 Find out if a lock could be granted - return who is blocking us if we can't.
142 ****************************************************************************/
144 NTSTATUS query_lock(files_struct *fsp,
146 SMB_BIG_UINT *pcount,
147 SMB_BIG_UINT *poffset,
148 enum brl_type *plock_type,
149 enum brl_flavour lock_flav)
151 struct byte_range_lock *br_lck = NULL;
152 NTSTATUS status = NT_STATUS_LOCK_NOT_GRANTED;
154 if (!fsp->can_lock) {
155 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
158 if (!lp_locking(fsp->conn->params)) {
162 br_lck = brl_get_locks_readonly(NULL, fsp);
164 return NT_STATUS_NO_MEMORY;
167 status = brl_lockquery(br_lck,
179 /****************************************************************************
180 Utility function called by locking requests.
181 ****************************************************************************/
183 struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
188 enum brl_type lock_type,
189 enum brl_flavour lock_flav,
194 struct byte_range_lock *br_lck = NULL;
196 if (!fsp->can_lock) {
197 *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
201 if (!lp_locking(fsp->conn->params)) {
202 *perr = NT_STATUS_OK;
206 /* NOTE! 0 byte long ranges ARE allowed and should be stored */
208 DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f requested for fnum %d file %s\n",
209 lock_flav_name(lock_flav), lock_type_name(lock_type),
210 (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
212 br_lck = brl_get_locks(NULL, fsp);
214 *perr = NT_STATUS_NO_MEMORY;
218 *perr = brl_lock(msg_ctx,
229 /* blocking ie. pending, locks also count here,
230 * as this is an efficiency counter to avoid checking
231 * the lock db. on close. JRA. */
233 fsp->current_lock_count++;
238 /****************************************************************************
239 Utility function called by unlocking requests.
240 ****************************************************************************/
242 NTSTATUS do_unlock(struct messaging_context *msg_ctx,
247 enum brl_flavour lock_flav)
250 struct byte_range_lock *br_lck = NULL;
252 if (!fsp->can_lock) {
253 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
256 if (!lp_locking(fsp->conn->params)) {
260 DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for fnum %d file %s\n",
261 (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
263 br_lck = brl_get_locks(NULL, fsp);
265 return NT_STATUS_NO_MEMORY;
268 ok = brl_unlock(msg_ctx,
279 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
280 return NT_STATUS_RANGE_NOT_LOCKED;
283 SMB_ASSERT(fsp->current_lock_count > 0);
284 fsp->current_lock_count--;
289 /****************************************************************************
290 Cancel any pending blocked locks.
291 ****************************************************************************/
293 NTSTATUS do_lock_cancel(files_struct *fsp,
297 enum brl_flavour lock_flav)
300 struct byte_range_lock *br_lck = NULL;
302 if (!fsp->can_lock) {
303 return fsp->is_directory ?
304 NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
307 if (!lp_locking(fsp->conn->params)) {
308 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
311 DEBUG(10,("do_lock_cancel: cancel start=%.0f len=%.0f requested for fnum %d file %s\n",
312 (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
314 br_lck = brl_get_locks(NULL, fsp);
316 return NT_STATUS_NO_MEMORY;
319 ok = brl_lock_cancel(br_lck,
329 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
330 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
333 SMB_ASSERT(fsp->current_lock_count > 0);
334 fsp->current_lock_count--;
339 /****************************************************************************
340 Remove any locks on this fd. Called from file_close().
341 ****************************************************************************/
343 void locking_close_file(struct messaging_context *msg_ctx,
346 struct byte_range_lock *br_lck;
348 if (!lp_locking(fsp->conn->params)) {
352 /* If we have not outstanding locks or pending
353 * locks then we don't need to look in the lock db.
356 if (fsp->current_lock_count == 0) {
360 br_lck = brl_get_locks(NULL,fsp);
363 cancel_pending_lock_requests_by_fid(fsp, br_lck);
364 brl_close_fnum(msg_ctx, br_lck);
369 /****************************************************************************
370 Initialise the locking functions.
371 ****************************************************************************/
373 static int open_read_only;
375 BOOL locking_init(int read_only)
382 lock_db = db_open(NULL, lock_path("locking.tdb"),
383 lp_open_files_db_hash_size(),
386 |(read_only?0x0:TDB_CLEAR_IF_FIRST),
387 read_only?O_RDONLY:O_RDWR|O_CREAT, 0644);
390 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
394 if (!posix_locking_init(read_only))
397 open_read_only = read_only;
402 /*******************************************************************
403 Deinitialize the share_mode management.
404 ******************************************************************/
406 BOOL locking_end(void)
408 brl_shutdown(open_read_only);
410 TALLOC_FREE(lock_db);
415 /*******************************************************************
416 Form a static locking key for a dev/inode pair.
417 ******************************************************************/
419 /* key and data records in the tdb locking database */
425 /*******************************************************************
426 Form a static locking key for a dev/inode pair.
427 ******************************************************************/
429 static TDB_DATA locking_key(SMB_DEV_T dev, SMB_INO_T inode)
431 static struct locking_key key;
434 memset(&key, '\0', sizeof(key));
437 kbuf.dptr = (uint8 *)&key;
438 kbuf.dsize = sizeof(key);
442 /*******************************************************************
443 Print out a share mode.
444 ********************************************************************/
446 char *share_mode_str(int num, struct share_mode_entry *e)
448 static pstring share_str;
450 slprintf(share_str, sizeof(share_str)-1, "share_mode_entry[%d]: %s "
451 "pid = %s, share_access = 0x%x, private_options = 0x%x, "
452 "access_mask = 0x%x, mid = 0x%x, type= 0x%x, file_id = %lu, "
453 "uid = %u, flags = %u, dev = 0x%x, inode = %.0f",
455 e->op_type == UNUSED_SHARE_MODE_ENTRY ? "UNUSED" : "",
456 procid_str_static(&e->pid),
457 e->share_access, e->private_options,
458 e->access_mask, e->op_mid, e->op_type, e->share_file_id,
459 (unsigned int)e->uid, (unsigned int)e->flags,
460 (unsigned int)e->dev, (double)e->inode );
465 /*******************************************************************
466 Print out a share mode table.
467 ********************************************************************/
469 static void print_share_mode_table(struct locking_data *data)
471 int num_share_modes = data->u.s.num_share_mode_entries;
472 struct share_mode_entry *shares =
473 (struct share_mode_entry *)(data + 1);
476 for (i = 0; i < num_share_modes; i++) {
477 struct share_mode_entry entry;
479 memcpy(&entry, &shares[i], sizeof(struct share_mode_entry));
480 DEBUG(10,("print_share_mode_table: %s\n",
481 share_mode_str(i, &entry)));
485 /*******************************************************************
486 Get all share mode entries for a dev/inode pair.
487 ********************************************************************/
489 static BOOL parse_share_modes(TDB_DATA dbuf, struct share_mode_lock *lck)
491 struct locking_data *data;
494 if (dbuf.dsize < sizeof(struct locking_data)) {
495 smb_panic("PANIC: parse_share_modes: buffer too short.\n");
498 data = (struct locking_data *)dbuf.dptr;
500 lck->delete_on_close = data->u.s.delete_on_close;
501 lck->num_share_modes = data->u.s.num_share_mode_entries;
503 DEBUG(10, ("parse_share_modes: delete_on_close: %d, "
504 "num_share_modes: %d\n",
505 lck->delete_on_close,
506 lck->num_share_modes));
508 if ((lck->num_share_modes < 0) || (lck->num_share_modes > 1000000)) {
509 DEBUG(0, ("invalid number of share modes: %d\n",
510 lck->num_share_modes));
511 smb_panic("PANIC: invalid number of share modes");
514 lck->share_modes = NULL;
516 if (lck->num_share_modes != 0) {
518 if (dbuf.dsize < (sizeof(struct locking_data) +
519 (lck->num_share_modes *
520 sizeof(struct share_mode_entry)))) {
521 smb_panic("PANIC: parse_share_modes: buffer too short.\n");
524 lck->share_modes = (struct share_mode_entry *)
525 TALLOC_MEMDUP(lck, dbuf.dptr+sizeof(*data),
526 lck->num_share_modes *
527 sizeof(struct share_mode_entry));
529 if (lck->share_modes == NULL) {
530 smb_panic("talloc failed\n");
534 /* Get any delete token. */
535 if (data->u.s.delete_token_size) {
536 uint8 *p = dbuf.dptr + sizeof(*data) +
537 (lck->num_share_modes *
538 sizeof(struct share_mode_entry));
540 if ((data->u.s.delete_token_size < sizeof(uid_t) + sizeof(gid_t)) ||
541 ((data->u.s.delete_token_size - sizeof(uid_t)) % sizeof(gid_t)) != 0) {
542 DEBUG(0, ("parse_share_modes: invalid token size %d\n",
543 data->u.s.delete_token_size));
544 smb_panic("parse_share_modes: invalid token size\n");
547 lck->delete_token = TALLOC_P(lck, UNIX_USER_TOKEN);
548 if (!lck->delete_token) {
549 smb_panic("talloc failed\n");
552 /* Copy out the uid and gid. */
553 memcpy(&lck->delete_token->uid, p, sizeof(uid_t));
555 memcpy(&lck->delete_token->gid, p, sizeof(gid_t));
558 /* Any supplementary groups ? */
559 lck->delete_token->ngroups = (data->u.s.delete_token_size > (sizeof(uid_t) + sizeof(gid_t))) ?
560 ((data->u.s.delete_token_size -
561 (sizeof(uid_t) + sizeof(gid_t)))/sizeof(gid_t)) : 0;
563 if (lck->delete_token->ngroups) {
564 /* Make this a talloc child of lck->delete_token. */
565 lck->delete_token->groups = TALLOC_ARRAY(lck->delete_token, gid_t,
566 lck->delete_token->ngroups);
567 if (!lck->delete_token) {
568 smb_panic("talloc failed\n");
571 for (i = 0; i < lck->delete_token->ngroups; i++) {
572 memcpy(&lck->delete_token->groups[i], p, sizeof(gid_t));
578 lck->delete_token = NULL;
581 /* Save off the associated service path and filename. */
582 lck->servicepath = talloc_strdup(lck, (const char *)dbuf.dptr + sizeof(*data) +
583 (lck->num_share_modes *
584 sizeof(struct share_mode_entry)) +
585 data->u.s.delete_token_size );
586 if (lck->servicepath == NULL) {
587 smb_panic("talloc_strdup failed\n");
590 lck->filename = talloc_strdup(lck, (const char *)dbuf.dptr + sizeof(*data) +
591 (lck->num_share_modes *
592 sizeof(struct share_mode_entry)) +
593 data->u.s.delete_token_size +
594 strlen(lck->servicepath) + 1 );
595 if (lck->filename == NULL) {
596 smb_panic("talloc_strdup failed\n");
600 * Ensure that each entry has a real process attached.
603 for (i = 0; i < lck->num_share_modes; i++) {
604 struct share_mode_entry *entry_p = &lck->share_modes[i];
605 DEBUG(10,("parse_share_modes: %s\n",
606 share_mode_str(i, entry_p) ));
607 if (!process_exists(entry_p->pid)) {
608 DEBUG(10,("parse_share_modes: deleted %s\n",
609 share_mode_str(i, entry_p) ));
610 entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
611 lck->modified = True;
618 static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
623 struct locking_data *data;
626 uint32 delete_token_size;
631 for (i=0; i<lck->num_share_modes; i++) {
632 if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
637 if (num_valid == 0) {
641 sp_len = strlen(lck->servicepath);
642 delete_token_size = (lck->delete_token ?
643 (sizeof(uid_t) + sizeof(gid_t) + (lck->delete_token->ngroups*sizeof(gid_t))) : 0);
645 result.dsize = sizeof(*data) +
646 lck->num_share_modes * sizeof(struct share_mode_entry) +
649 strlen(lck->filename) + 1;
650 result.dptr = TALLOC_ARRAY(lck, uint8, result.dsize);
652 if (result.dptr == NULL) {
653 smb_panic("talloc failed\n");
656 data = (struct locking_data *)result.dptr;
658 data->u.s.num_share_mode_entries = lck->num_share_modes;
659 data->u.s.delete_on_close = lck->delete_on_close;
660 data->u.s.delete_token_size = delete_token_size;
661 DEBUG(10, ("unparse_share_modes: del: %d, tok = %u, num: %d\n",
662 data->u.s.delete_on_close,
663 (unsigned int)data->u.s.delete_token_size,
664 data->u.s.num_share_mode_entries));
665 memcpy(result.dptr + sizeof(*data), lck->share_modes,
666 sizeof(struct share_mode_entry)*lck->num_share_modes);
667 offset = sizeof(*data) +
668 sizeof(struct share_mode_entry)*lck->num_share_modes;
670 /* Store any delete on close token. */
671 if (lck->delete_token) {
672 uint8 *p = result.dptr + offset;
674 memcpy(p, &lck->delete_token->uid, sizeof(uid_t));
677 memcpy(p, &lck->delete_token->gid, sizeof(gid_t));
680 for (i = 0; i < lck->delete_token->ngroups; i++) {
681 memcpy(p, &lck->delete_token->groups[i], sizeof(gid_t));
684 offset = p - result.dptr;
687 safe_strcpy((char *)result.dptr + offset, lck->servicepath,
688 result.dsize - offset - 1);
689 offset += sp_len + 1;
690 safe_strcpy((char *)result.dptr + offset, lck->filename,
691 result.dsize - offset - 1);
693 if (DEBUGLEVEL >= 10) {
694 print_share_mode_table(data);
700 static int share_mode_lock_destructor(struct share_mode_lock *lck)
705 if (!lck->modified) {
709 data = unparse_share_modes(lck);
711 if (data.dptr == NULL) {
713 /* There has been an entry before, delete it */
715 status = lck->record->delete_rec(lck->record);
716 if (!NT_STATUS_IS_OK(status)) {
717 DEBUG(0, ("delete_rec returned %s\n",
719 smb_panic("Could not delete share entry\n");
725 status = lck->record->store(lck->record, data, TDB_REPLACE);
726 if (!NT_STATUS_IS_OK(status)) {
727 DEBUG(0, ("store returned %s\n", nt_errstr(status)));
728 smb_panic("Could not store share mode entry\n");
736 static BOOL fill_share_mode_lock(struct share_mode_lock *lck,
737 SMB_DEV_T dev, SMB_INO_T ino,
738 const char *servicepath,
740 TDB_DATA share_mode_data)
742 /* Ensure we set every field here as the destructor must be
743 valid even if parse_share_modes fails. */
745 lck->servicepath = NULL;
746 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,
779 SMB_DEV_T dev, SMB_INO_T ino,
780 const char *servicepath,
783 struct share_mode_lock *lck;
784 TDB_DATA key = locking_key(dev, ino);
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, dev, ino, 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,
810 SMB_DEV_T dev, SMB_INO_T ino,
811 const char *servicepath,
814 struct share_mode_lock *lck;
815 TDB_DATA key = locking_key(dev, ino);
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, dev, ino, 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,
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 SDEV_T_VAL(frm,0,lck->dev);
893 SINO_T_VAL(frm,8,lck->ino);
895 DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
897 safe_strcpy(&frm[16], lck->servicepath, sp_len);
898 safe_strcpy(&frm[16 + sp_len + 1], lck->filename, fn_len);
900 /* Send the messages. */
901 for (i=0; i<lck->num_share_modes; i++) {
902 struct share_mode_entry *se = &lck->share_modes[i];
903 if (!is_valid_share_mode_entry(se)) {
906 /* But not to ourselves... */
907 if (procid_is_me(&se->pid)) {
911 DEBUG(10,("rename_share_filename: sending rename message to pid %s "
912 "dev %x, inode %.0f sharepath %s newname %s\n",
913 procid_str_static(&se->pid),
914 (unsigned int)lck->dev, (double)lck->ino,
915 lck->servicepath, lck->filename ));
917 messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
918 (uint8 *)frm, msg_len);
924 BOOL get_delete_on_close_flag(SMB_DEV_T dev, SMB_INO_T inode)
927 struct share_mode_lock *lck;
929 if (!(lck = fetch_share_mode_unlocked(NULL, dev, inode, NULL, NULL))) {
932 result = lck->delete_on_close;
937 BOOL is_valid_share_mode_entry(const struct share_mode_entry *e)
941 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
942 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
943 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
945 SMB_ASSERT(num_props <= 1);
946 return (num_props != 0);
949 BOOL is_deferred_open_entry(const struct share_mode_entry *e)
951 return (e->op_type == DEFERRED_OPEN_ENTRY);
954 BOOL is_unused_share_mode_entry(const struct share_mode_entry *e)
956 return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
959 /*******************************************************************
960 Fill a share mode entry.
961 ********************************************************************/
963 static void fill_share_mode_entry(struct share_mode_entry *e,
965 uid_t uid, uint16 mid, uint16 op_type)
968 e->pid = procid_self();
969 e->share_access = fsp->share_access;
970 e->private_options = fsp->fh->private_options;
971 e->access_mask = fsp->access_mask;
973 e->op_type = op_type;
974 e->time.tv_sec = fsp->open_time.tv_sec;
975 e->time.tv_usec = fsp->open_time.tv_usec;
977 e->inode = fsp->inode;
978 e->share_file_id = fsp->fh->file_id;
979 e->uid = (uint32)uid;
980 e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
983 static void fill_deferred_open_entry(struct share_mode_entry *e,
984 const struct timeval request_time,
985 SMB_DEV_T dev, SMB_INO_T ino, uint16 mid)
988 e->pid = procid_self();
990 e->op_type = DEFERRED_OPEN_ENTRY;
991 e->time.tv_sec = request_time.tv_sec;
992 e->time.tv_usec = request_time.tv_usec;
999 static void add_share_mode_entry(struct share_mode_lock *lck,
1000 const struct share_mode_entry *entry)
1004 for (i=0; i<lck->num_share_modes; i++) {
1005 struct share_mode_entry *e = &lck->share_modes[i];
1006 if (is_unused_share_mode_entry(e)) {
1012 if (i == lck->num_share_modes) {
1013 /* No unused entry found */
1014 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
1015 &lck->share_modes, &lck->num_share_modes);
1017 lck->modified = True;
1020 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
1021 uid_t uid, uint16 mid, uint16 op_type, BOOL initial_delete_on_close_allowed)
1023 struct share_mode_entry entry;
1024 fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
1025 if (initial_delete_on_close_allowed) {
1026 entry.flags |= SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE;
1028 add_share_mode_entry(lck, &entry);
1031 void add_deferred_open(struct share_mode_lock *lck, uint16 mid,
1032 struct timeval request_time,
1033 SMB_DEV_T dev, SMB_INO_T ino)
1035 struct share_mode_entry entry;
1036 fill_deferred_open_entry(&entry, request_time, dev, ino, mid);
1037 add_share_mode_entry(lck, &entry);
1040 /*******************************************************************
1041 Check if two share mode entries are identical, ignoring oplock
1042 and mid info and desired_access. (Removed paranoia test - it's
1043 not automatically a logic error if they are identical. JRA.)
1044 ********************************************************************/
1046 static BOOL share_modes_identical(struct share_mode_entry *e1,
1047 struct share_mode_entry *e2)
1049 /* We used to check for e1->share_access == e2->share_access here
1050 as well as the other fields but 2 different DOS or FCB opens
1051 sharing the same share mode entry may validly differ in
1052 fsp->share_access field. */
1054 return (procid_equal(&e1->pid, &e2->pid) &&
1055 e1->dev == e2->dev &&
1056 e1->inode == e2->inode &&
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 (e1->dev == e2->dev) &&
1066 (e1->inode == e2->inode));
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(),
1117 lck->dev, lck->ino, mid);
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->dev, fsp->inode, 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 locking_key))
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(lock_db, traverse_fn, (void *)&state);