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 TDB_CONTEXT *tdb;
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(files_struct *fsp,
187 enum brl_type lock_type,
188 enum brl_flavour lock_flav,
192 struct byte_range_lock *br_lck = NULL;
194 if (!fsp->can_lock) {
195 *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
199 if (!lp_locking(fsp->conn->params)) {
200 *perr = NT_STATUS_OK;
204 /* NOTE! 0 byte long ranges ARE allowed and should be stored */
206 DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f requested for fnum %d file %s\n",
207 lock_flav_name(lock_flav), lock_type_name(lock_type),
208 (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
210 br_lck = brl_get_locks(NULL, fsp);
212 *perr = NT_STATUS_NO_MEMORY;
216 *perr = brl_lock(br_lck,
225 /* blocking ie. pending, locks also count here,
226 * as this is an efficiency counter to avoid checking
227 * the lock db. on close. JRA. */
229 fsp->current_lock_count++;
234 /****************************************************************************
235 Utility function called by unlocking requests.
236 ****************************************************************************/
238 NTSTATUS do_unlock(files_struct *fsp,
242 enum brl_flavour lock_flav)
245 struct byte_range_lock *br_lck = NULL;
247 if (!fsp->can_lock) {
248 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
251 if (!lp_locking(fsp->conn->params)) {
255 DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for fnum %d file %s\n",
256 (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
258 br_lck = brl_get_locks(NULL, fsp);
260 return NT_STATUS_NO_MEMORY;
263 ok = brl_unlock(br_lck,
273 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
274 return NT_STATUS_RANGE_NOT_LOCKED;
277 SMB_ASSERT(fsp->current_lock_count > 0);
278 fsp->current_lock_count--;
283 /****************************************************************************
284 Cancel any pending blocked locks.
285 ****************************************************************************/
287 NTSTATUS do_lock_cancel(files_struct *fsp,
291 enum brl_flavour lock_flav)
294 struct byte_range_lock *br_lck = NULL;
296 if (!fsp->can_lock) {
297 return fsp->is_directory ?
298 NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
301 if (!lp_locking(fsp->conn->params)) {
302 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
305 DEBUG(10,("do_lock_cancel: cancel start=%.0f len=%.0f requested for fnum %d file %s\n",
306 (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
308 br_lck = brl_get_locks(NULL, fsp);
310 return NT_STATUS_NO_MEMORY;
313 ok = brl_lock_cancel(br_lck,
323 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
324 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
327 SMB_ASSERT(fsp->current_lock_count > 0);
328 fsp->current_lock_count--;
333 /****************************************************************************
334 Remove any locks on this fd. Called from file_close().
335 ****************************************************************************/
337 void locking_close_file(files_struct *fsp)
339 struct byte_range_lock *br_lck;
341 if (!lp_locking(fsp->conn->params)) {
345 /* If we have not outstanding locks or pending
346 * locks then we don't need to look in the lock db.
349 if (fsp->current_lock_count == 0) {
353 br_lck = brl_get_locks(NULL,fsp);
356 cancel_pending_lock_requests_by_fid(fsp, br_lck);
357 brl_close_fnum(br_lck);
362 /****************************************************************************
363 Initialise the locking functions.
364 ****************************************************************************/
366 static int open_read_only;
368 BOOL locking_init(int read_only)
375 tdb = tdb_open_log(lock_path("locking.tdb"),
376 lp_open_files_db_hash_size(),
377 TDB_DEFAULT|(read_only?0x0:TDB_CLEAR_IF_FIRST),
378 read_only?O_RDONLY:O_RDWR|O_CREAT,
382 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
386 /* Activate the per-hashchain freelist */
387 tdb_set_max_dead(tdb, 5);
389 if (!posix_locking_init(read_only))
392 open_read_only = read_only;
397 /*******************************************************************
398 Deinitialize the share_mode management.
399 ******************************************************************/
401 BOOL locking_end(void)
405 brl_shutdown(open_read_only);
407 if (tdb_close(tdb) != 0)
414 /*******************************************************************
415 Form a static locking key for a dev/inode pair.
416 ******************************************************************/
418 /* key and data records in the tdb locking database */
424 /*******************************************************************
425 Form a static locking key for a dev/inode pair.
426 ******************************************************************/
428 static TDB_DATA locking_key(SMB_DEV_T dev, SMB_INO_T inode)
430 static struct locking_key key;
433 memset(&key, '\0', sizeof(key));
436 kbuf.dptr = (char *)&key;
437 kbuf.dsize = sizeof(key);
441 /*******************************************************************
442 Print out a share mode.
443 ********************************************************************/
445 char *share_mode_str(int num, struct share_mode_entry *e)
447 static pstring share_str;
449 slprintf(share_str, sizeof(share_str)-1, "share_mode_entry[%d]: %s "
450 "pid = %s, share_access = 0x%x, private_options = 0x%x, "
451 "access_mask = 0x%x, mid = 0x%x, type= 0x%x, file_id = %lu, "
452 "uid = %u, flags = %u, dev = 0x%x, inode = %.0f",
454 e->op_type == UNUSED_SHARE_MODE_ENTRY ? "UNUSED" : "",
455 procid_str_static(&e->pid),
456 e->share_access, e->private_options,
457 e->access_mask, e->op_mid, e->op_type, e->share_file_id,
458 (unsigned int)e->uid, (unsigned int)e->flags,
459 (unsigned int)e->dev, (double)e->inode );
464 /*******************************************************************
465 Print out a share mode table.
466 ********************************************************************/
468 static void print_share_mode_table(struct locking_data *data)
470 int num_share_modes = data->u.s.num_share_mode_entries;
471 struct share_mode_entry *shares =
472 (struct share_mode_entry *)(data + 1);
475 for (i = 0; i < num_share_modes; i++) {
476 struct share_mode_entry entry;
478 memcpy(&entry, &shares[i], sizeof(struct share_mode_entry));
479 DEBUG(10,("print_share_mode_table: %s\n",
480 share_mode_str(i, &entry)));
484 /*******************************************************************
485 Get all share mode entries for a dev/inode pair.
486 ********************************************************************/
488 static BOOL parse_share_modes(TDB_DATA dbuf, struct share_mode_lock *lck)
490 struct locking_data *data;
493 if (dbuf.dsize < sizeof(struct locking_data)) {
494 smb_panic("PANIC: parse_share_modes: buffer too short.\n");
497 data = (struct locking_data *)dbuf.dptr;
499 lck->delete_on_close = data->u.s.delete_on_close;
500 lck->num_share_modes = data->u.s.num_share_mode_entries;
502 DEBUG(10, ("parse_share_modes: delete_on_close: %d, "
503 "num_share_modes: %d\n",
504 lck->delete_on_close,
505 lck->num_share_modes));
507 if ((lck->num_share_modes < 0) || (lck->num_share_modes > 1000000)) {
508 DEBUG(0, ("invalid number of share modes: %d\n",
509 lck->num_share_modes));
510 smb_panic("PANIC: invalid number of share modes");
513 lck->share_modes = NULL;
515 if (lck->num_share_modes != 0) {
517 if (dbuf.dsize < (sizeof(struct locking_data) +
518 (lck->num_share_modes *
519 sizeof(struct share_mode_entry)))) {
520 smb_panic("PANIC: parse_share_modes: buffer too short.\n");
523 lck->share_modes = (struct share_mode_entry *)
524 talloc_memdup(lck, dbuf.dptr+sizeof(*data),
525 lck->num_share_modes *
526 sizeof(struct share_mode_entry));
528 if (lck->share_modes == NULL) {
529 smb_panic("talloc failed\n");
533 /* Get any delete token. */
534 if (data->u.s.delete_token_size) {
535 char *p = dbuf.dptr + sizeof(*data) +
536 (lck->num_share_modes *
537 sizeof(struct share_mode_entry));
539 if ((data->u.s.delete_token_size < sizeof(uid_t) + sizeof(gid_t)) ||
540 ((data->u.s.delete_token_size - sizeof(uid_t)) % sizeof(gid_t)) != 0) {
541 DEBUG(0, ("parse_share_modes: invalid token size %d\n",
542 data->u.s.delete_token_size));
543 smb_panic("parse_share_modes: invalid token size\n");
546 lck->delete_token = TALLOC_P(lck, UNIX_USER_TOKEN);
547 if (!lck->delete_token) {
548 smb_panic("talloc failed\n");
551 /* Copy out the uid and gid. */
552 memcpy(&lck->delete_token->uid, p, sizeof(uid_t));
554 memcpy(&lck->delete_token->gid, p, sizeof(gid_t));
557 /* Any supplementary groups ? */
558 lck->delete_token->ngroups = (data->u.s.delete_token_size > (sizeof(uid_t) + sizeof(gid_t))) ?
559 ((data->u.s.delete_token_size -
560 (sizeof(uid_t) + sizeof(gid_t)))/sizeof(gid_t)) : 0;
562 if (lck->delete_token->ngroups) {
563 /* Make this a talloc child of lck->delete_token. */
564 lck->delete_token->groups = TALLOC_ARRAY(lck->delete_token, gid_t,
565 lck->delete_token->ngroups);
566 if (!lck->delete_token) {
567 smb_panic("talloc failed\n");
570 for (i = 0; i < lck->delete_token->ngroups; i++) {
571 memcpy(&lck->delete_token->groups[i], p, sizeof(gid_t));
577 lck->delete_token = NULL;
580 /* Save off the associated service path and filename. */
581 lck->servicepath = talloc_strdup(lck, dbuf.dptr + sizeof(*data) +
582 (lck->num_share_modes *
583 sizeof(struct share_mode_entry)) +
584 data->u.s.delete_token_size );
585 if (lck->servicepath == NULL) {
586 smb_panic("talloc_strdup failed\n");
589 lck->filename = talloc_strdup(lck, dbuf.dptr + sizeof(*data) +
590 (lck->num_share_modes *
591 sizeof(struct share_mode_entry)) +
592 data->u.s.delete_token_size +
593 strlen(lck->servicepath) + 1 );
594 if (lck->filename == NULL) {
595 smb_panic("talloc_strdup failed\n");
599 * Ensure that each entry has a real process attached.
602 for (i = 0; i < lck->num_share_modes; i++) {
603 struct share_mode_entry *entry_p = &lck->share_modes[i];
604 DEBUG(10,("parse_share_modes: %s\n",
605 share_mode_str(i, entry_p) ));
606 if (!process_exists(entry_p->pid)) {
607 DEBUG(10,("parse_share_modes: deleted %s\n",
608 share_mode_str(i, entry_p) ));
609 entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
610 lck->modified = True;
617 static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
622 struct locking_data *data;
625 uint32 delete_token_size;
630 for (i=0; i<lck->num_share_modes; i++) {
631 if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
636 if (num_valid == 0) {
640 sp_len = strlen(lck->servicepath);
641 delete_token_size = (lck->delete_token ?
642 (sizeof(uid_t) + sizeof(gid_t) + (lck->delete_token->ngroups*sizeof(gid_t))) : 0);
644 result.dsize = sizeof(*data) +
645 lck->num_share_modes * sizeof(struct share_mode_entry) +
648 strlen(lck->filename) + 1;
649 result.dptr = TALLOC_ARRAY(lck, char, result.dsize);
651 if (result.dptr == NULL) {
652 smb_panic("talloc failed\n");
655 data = (struct locking_data *)result.dptr;
657 data->u.s.num_share_mode_entries = lck->num_share_modes;
658 data->u.s.delete_on_close = lck->delete_on_close;
659 data->u.s.delete_token_size = delete_token_size;
660 DEBUG(10, ("unparse_share_modes: del: %d, tok = %u, num: %d\n",
661 data->u.s.delete_on_close,
662 (unsigned int)data->u.s.delete_token_size,
663 data->u.s.num_share_mode_entries));
664 memcpy(result.dptr + sizeof(*data), lck->share_modes,
665 sizeof(struct share_mode_entry)*lck->num_share_modes);
666 offset = sizeof(*data) +
667 sizeof(struct share_mode_entry)*lck->num_share_modes;
669 /* Store any delete on close token. */
670 if (lck->delete_token) {
671 char *p = result.dptr + offset;
673 memcpy(p, &lck->delete_token->uid, sizeof(uid_t));
676 memcpy(p, &lck->delete_token->gid, sizeof(gid_t));
679 for (i = 0; i < lck->delete_token->ngroups; i++) {
680 memcpy(p, &lck->delete_token->groups[i], sizeof(gid_t));
683 offset = p - result.dptr;
686 safe_strcpy(result.dptr + offset, lck->servicepath,
687 result.dsize - offset - 1);
688 offset += sp_len + 1;
689 safe_strcpy(result.dptr + offset, lck->filename,
690 result.dsize - offset - 1);
692 if (DEBUGLEVEL >= 10) {
693 print_share_mode_table(data);
699 static int share_mode_lock_destructor(struct share_mode_lock *lck)
701 TDB_DATA key = locking_key(lck->dev, lck->ino);
704 if (!lck->modified) {
708 data = unparse_share_modes(lck);
710 if (data.dptr == NULL) {
712 /* There has been an entry before, delete it */
713 if (tdb_delete(tdb, key) == -1) {
714 smb_panic("Could not delete share entry\n");
720 if (tdb_store(tdb, key, data, TDB_REPLACE) == -1) {
721 smb_panic("Could not store share mode entry\n");
725 tdb_chainunlock(tdb, key);
730 struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
731 SMB_DEV_T dev, SMB_INO_T ino,
732 const char *servicepath,
735 struct share_mode_lock *lck;
736 TDB_DATA key = locking_key(dev, ino);
739 lck = TALLOC_P(mem_ctx, struct share_mode_lock);
741 DEBUG(0, ("talloc failed\n"));
745 /* Ensure we set every field here as the destructor must be
746 valid even if parse_share_modes fails. */
748 lck->servicepath = NULL;
749 lck->filename = NULL;
752 lck->num_share_modes = 0;
753 lck->share_modes = NULL;
754 lck->delete_token = NULL;
755 lck->delete_on_close = False;
757 lck->modified = False;
759 if (tdb_chainlock(tdb, key) != 0) {
760 DEBUG(3, ("Could not lock share entry\n"));
765 /* We must set the destructor immediately after the chainlock
766 ensure the lock is cleaned up on any of the error return
769 talloc_set_destructor(lck, share_mode_lock_destructor);
771 data = tdb_fetch(tdb, key);
772 lck->fresh = (data.dptr == NULL);
776 if (fname == NULL || servicepath == NULL) {
780 lck->filename = talloc_strdup(lck, fname);
781 lck->servicepath = talloc_strdup(lck, servicepath);
782 if (lck->filename == NULL || lck->servicepath == NULL) {
783 DEBUG(0, ("talloc failed\n"));
788 if (!parse_share_modes(data, lck)) {
789 DEBUG(0, ("Could not parse share modes\n"));
791 SAFE_FREE(data.dptr);
796 SAFE_FREE(data.dptr);
801 /*******************************************************************
802 Sets the service name and filename for rename.
803 At this point we emit "file renamed" messages to all
804 process id's that have this file open.
805 Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
806 ********************************************************************/
808 BOOL rename_share_filename(struct share_mode_lock *lck,
809 const char *servicepath,
822 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
823 servicepath, newname));
826 * rename_internal_fsp() and rename_internals() add './' to
827 * head of newname if newname does not contain a '/'.
829 while (newname[0] && newname[1] && newname[0] == '.' && newname[1] == '/') {
833 lck->servicepath = talloc_strdup(lck, servicepath);
834 lck->filename = talloc_strdup(lck, newname);
835 if (lck->filename == NULL || lck->servicepath == NULL) {
836 DEBUG(0, ("rename_share_filename: talloc failed\n"));
839 lck->modified = True;
841 sp_len = strlen(lck->servicepath);
842 fn_len = strlen(lck->filename);
844 msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + fn_len + 1;
846 /* Set up the name changed message. */
847 frm = TALLOC_ARRAY(lck, char, msg_len);
852 SDEV_T_VAL(frm,0,lck->dev);
853 SINO_T_VAL(frm,8,lck->ino);
855 DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
857 safe_strcpy(&frm[16], lck->servicepath, sp_len);
858 safe_strcpy(&frm[16 + sp_len + 1], lck->filename, fn_len);
860 /* Send the messages. */
861 for (i=0; i<lck->num_share_modes; i++) {
862 struct share_mode_entry *se = &lck->share_modes[i];
863 if (!is_valid_share_mode_entry(se)) {
866 /* But not to ourselves... */
867 if (procid_is_me(&se->pid)) {
871 DEBUG(10,("rename_share_filename: sending rename message to pid %s "
872 "dev %x, inode %.0f sharepath %s newname %s\n",
873 procid_str_static(&se->pid),
874 (unsigned int)lck->dev, (double)lck->ino,
875 lck->servicepath, lck->filename ));
877 message_send_pid(se->pid, MSG_SMB_FILE_RENAME,
884 static int pull_delete_on_close_flag(TDB_DATA key, TDB_DATA dbuf,
887 BOOL *result = (BOOL *)private_data;
888 struct locking_data *data;
890 if (dbuf.dsize < sizeof(struct locking_data)) {
891 smb_panic("PANIC: parse_share_modes: buffer too short.\n");
894 data = (struct locking_data *)dbuf.dptr;
896 *result = data->u.s.delete_on_close;
900 BOOL get_delete_on_close_flag(SMB_DEV_T dev, SMB_INO_T inode)
902 TDB_DATA key = locking_key(dev, inode);
905 tdb_parse_record(tdb, key, pull_delete_on_close_flag,
910 BOOL is_valid_share_mode_entry(const struct share_mode_entry *e)
914 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
915 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
916 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
918 SMB_ASSERT(num_props <= 1);
919 return (num_props != 0);
922 BOOL is_deferred_open_entry(const struct share_mode_entry *e)
924 return (e->op_type == DEFERRED_OPEN_ENTRY);
927 BOOL is_unused_share_mode_entry(const struct share_mode_entry *e)
929 return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
932 /*******************************************************************
933 Fill a share mode entry.
934 ********************************************************************/
936 static void fill_share_mode_entry(struct share_mode_entry *e,
938 uid_t uid, uint16 mid, uint16 op_type)
941 e->pid = procid_self();
942 e->share_access = fsp->share_access;
943 e->private_options = fsp->fh->private_options;
944 e->access_mask = fsp->access_mask;
946 e->op_type = op_type;
947 e->time.tv_sec = fsp->open_time.tv_sec;
948 e->time.tv_usec = fsp->open_time.tv_usec;
950 e->inode = fsp->inode;
951 e->share_file_id = fsp->fh->file_id;
952 e->uid = (uint32)uid;
953 e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
956 static void fill_deferred_open_entry(struct share_mode_entry *e,
957 const struct timeval request_time,
958 SMB_DEV_T dev, SMB_INO_T ino, uint16 mid)
961 e->pid = procid_self();
963 e->op_type = DEFERRED_OPEN_ENTRY;
964 e->time.tv_sec = request_time.tv_sec;
965 e->time.tv_usec = request_time.tv_usec;
972 static void add_share_mode_entry(struct share_mode_lock *lck,
973 const struct share_mode_entry *entry)
977 for (i=0; i<lck->num_share_modes; i++) {
978 struct share_mode_entry *e = &lck->share_modes[i];
979 if (is_unused_share_mode_entry(e)) {
985 if (i == lck->num_share_modes) {
986 /* No unused entry found */
987 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
988 &lck->share_modes, &lck->num_share_modes);
990 lck->modified = True;
993 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
994 uid_t uid, uint16 mid, uint16 op_type)
996 struct share_mode_entry entry;
997 fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
998 add_share_mode_entry(lck, &entry);
1001 void add_deferred_open(struct share_mode_lock *lck, uint16 mid,
1002 struct timeval request_time,
1003 SMB_DEV_T dev, SMB_INO_T ino)
1005 struct share_mode_entry entry;
1006 fill_deferred_open_entry(&entry, request_time, dev, ino, mid);
1007 add_share_mode_entry(lck, &entry);
1010 /*******************************************************************
1011 Check if two share mode entries are identical, ignoring oplock
1012 and mid info and desired_access. (Removed paranoia test - it's
1013 not automatically a logic error if they are identical. JRA.)
1014 ********************************************************************/
1016 static BOOL share_modes_identical(struct share_mode_entry *e1,
1017 struct share_mode_entry *e2)
1019 /* We used to check for e1->share_access == e2->share_access here
1020 as well as the other fields but 2 different DOS or FCB opens
1021 sharing the same share mode entry may validly differ in
1022 fsp->share_access field. */
1024 return (procid_equal(&e1->pid, &e2->pid) &&
1025 e1->dev == e2->dev &&
1026 e1->inode == e2->inode &&
1027 e1->share_file_id == e2->share_file_id );
1030 static BOOL deferred_open_identical(struct share_mode_entry *e1,
1031 struct share_mode_entry *e2)
1033 return (procid_equal(&e1->pid, &e2->pid) &&
1034 (e1->op_mid == e2->op_mid) &&
1035 (e1->dev == e2->dev) &&
1036 (e1->inode == e2->inode));
1039 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
1040 struct share_mode_entry *entry)
1044 for (i=0; i<lck->num_share_modes; i++) {
1045 struct share_mode_entry *e = &lck->share_modes[i];
1046 if (is_valid_share_mode_entry(entry) &&
1047 is_valid_share_mode_entry(e) &&
1048 share_modes_identical(e, entry)) {
1051 if (is_deferred_open_entry(entry) &&
1052 is_deferred_open_entry(e) &&
1053 deferred_open_identical(e, entry)) {
1060 /*******************************************************************
1061 Del the share mode of a file for this process. Return the number of
1063 ********************************************************************/
1065 BOOL del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
1067 struct share_mode_entry entry, *e;
1069 /* Don't care about the pid owner being correct here - just a search. */
1070 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1072 e = find_share_mode_entry(lck, &entry);
1077 e->op_type = UNUSED_SHARE_MODE_ENTRY;
1078 lck->modified = True;
1082 void del_deferred_open_entry(struct share_mode_lock *lck, uint16 mid)
1084 struct share_mode_entry entry, *e;
1086 fill_deferred_open_entry(&entry, timeval_zero(),
1087 lck->dev, lck->ino, mid);
1089 e = find_share_mode_entry(lck, &entry);
1094 e->op_type = UNUSED_SHARE_MODE_ENTRY;
1095 lck->modified = True;
1098 /*******************************************************************
1099 Remove an oplock mid and mode entry from a share mode.
1100 ********************************************************************/
1102 BOOL remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1104 struct share_mode_entry entry, *e;
1106 /* Don't care about the pid owner being correct here - just a search. */
1107 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1109 e = find_share_mode_entry(lck, &entry);
1115 e->op_type = NO_OPLOCK;
1116 lck->modified = True;
1120 /*******************************************************************
1121 Downgrade a oplock type from exclusive to level II.
1122 ********************************************************************/
1124 BOOL downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1126 struct share_mode_entry entry, *e;
1128 /* Don't care about the pid owner being correct here - just a search. */
1129 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1131 e = find_share_mode_entry(lck, &entry);
1136 e->op_type = LEVEL_II_OPLOCK;
1137 lck->modified = True;
1141 /****************************************************************************
1142 Deal with the internal needs of setting the delete on close flag. Note that
1143 as the tdb locking is recursive, it is safe to call this from within
1144 open_file_ntcreate. JRA.
1145 ****************************************************************************/
1147 NTSTATUS can_set_delete_on_close(files_struct *fsp, BOOL delete_on_close,
1150 if (!delete_on_close) {
1151 return NT_STATUS_OK;
1155 * Only allow delete on close for writable files.
1158 if ((dosmode & aRONLY) &&
1159 !lp_delete_readonly(SNUM(fsp->conn))) {
1160 DEBUG(10,("can_set_delete_on_close: file %s delete on close "
1161 "flag set but file attribute is readonly.\n",
1163 return NT_STATUS_CANNOT_DELETE;
1167 * Only allow delete on close for writable shares.
1170 if (!CAN_WRITE(fsp->conn)) {
1171 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1172 "close flag set but write access denied on share.\n",
1174 return NT_STATUS_ACCESS_DENIED;
1178 * Only allow delete on close for files/directories opened with delete
1182 if (!(fsp->access_mask & DELETE_ACCESS)) {
1183 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1184 "close flag set but delete access denied.\n",
1186 return NT_STATUS_ACCESS_DENIED;
1189 /* Don't allow delete on close for non-empty directories. */
1190 if (fsp->is_directory) {
1191 return can_delete_directory(fsp->conn, fsp->fsp_name);
1194 return NT_STATUS_OK;
1197 /*************************************************************************
1198 Return a talloced copy of a UNIX_USER_TOKEN. NULL on fail.
1199 (Should this be in locking.c.... ?).
1200 *************************************************************************/
1202 static UNIX_USER_TOKEN *copy_unix_token(TALLOC_CTX *ctx, UNIX_USER_TOKEN *tok)
1204 UNIX_USER_TOKEN *cpy;
1210 cpy = TALLOC_P(ctx, UNIX_USER_TOKEN);
1215 cpy->uid = tok->uid;
1216 cpy->gid = tok->gid;
1217 cpy->ngroups = tok->ngroups;
1219 /* Make this a talloc child of cpy. */
1220 cpy->groups = TALLOC_ARRAY(cpy, gid_t, tok->ngroups);
1224 memcpy(cpy->groups, tok->groups, tok->ngroups * sizeof(gid_t));
1229 /****************************************************************************
1230 Replace the delete on close token.
1231 ****************************************************************************/
1233 void set_delete_on_close_token(struct share_mode_lock *lck, UNIX_USER_TOKEN *tok)
1235 /* Ensure there's no token. */
1236 if (lck->delete_token) {
1237 TALLOC_FREE(lck->delete_token); /* Also deletes groups... */
1238 lck->delete_token = NULL;
1241 /* Copy the new token (can be NULL). */
1242 lck->delete_token = copy_unix_token(lck, tok);
1243 lck->modified = True;
1246 /****************************************************************************
1247 Sets the delete on close flag over all share modes on this file.
1248 Modify the share mode entry for all files open
1249 on this device and inode to tell other smbds we have
1250 changed the delete on close flag. This will be noticed
1251 in the close code, the last closer will delete the file
1253 This makes a copy of any UNIX_USER_TOKEN into the
1254 lck entry. This function is used when the lock is already granted.
1255 ****************************************************************************/
1257 void set_delete_on_close_lck(struct share_mode_lock *lck, BOOL delete_on_close, UNIX_USER_TOKEN *tok)
1259 if (lck->delete_on_close != delete_on_close) {
1260 set_delete_on_close_token(lck, tok);
1261 lck->delete_on_close = delete_on_close;
1262 if (delete_on_close) {
1263 SMB_ASSERT(lck->delete_token != NULL);
1265 lck->modified = True;
1269 BOOL set_delete_on_close(files_struct *fsp, BOOL delete_on_close, UNIX_USER_TOKEN *tok)
1271 struct share_mode_lock *lck;
1273 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1274 "fnum = %d, file %s\n",
1275 delete_on_close ? "Adding" : "Removing", fsp->fnum,
1282 lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode, NULL, NULL);
1287 set_delete_on_close_lck(lck, delete_on_close, tok);
1289 if (fsp->is_directory) {
1290 send_stat_cache_delete_message(fsp->fsp_name);
1297 struct forall_state {
1298 void (*fn)(const struct share_mode_entry *entry,
1299 const char *sharepath,
1301 void *private_data);
1305 static int traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf,
1308 struct forall_state *state = (struct forall_state *)_state;
1309 struct locking_data *data;
1310 struct share_mode_entry *shares;
1311 const char *sharepath;
1315 /* Ensure this is a locking_key record. */
1316 if (kbuf.dsize != sizeof(struct locking_key))
1319 data = (struct locking_data *)dbuf.dptr;
1320 shares = (struct share_mode_entry *)(dbuf.dptr + sizeof(*data));
1321 sharepath = dbuf.dptr + sizeof(*data) +
1322 data->u.s.num_share_mode_entries*sizeof(*shares) +
1323 data->u.s.delete_token_size;
1324 fname = dbuf.dptr + sizeof(*data) +
1325 data->u.s.num_share_mode_entries*sizeof(*shares) +
1326 data->u.s.delete_token_size +
1327 strlen(sharepath) + 1;
1329 for (i=0;i<data->u.s.num_share_mode_entries;i++) {
1330 state->fn(&shares[i], sharepath, fname,
1331 state->private_data);
1336 /*******************************************************************
1337 Call the specified function on each entry under management by the
1339 ********************************************************************/
1341 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
1342 const char *, void *),
1345 struct forall_state state;
1351 state.private_data = private_data;
1353 return tdb_traverse(tdb, traverse_fn, (void *)&state);