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,
228 /****************************************************************************
229 Utility function called by unlocking requests.
230 ****************************************************************************/
232 NTSTATUS do_unlock(files_struct *fsp,
236 enum brl_flavour lock_flav)
239 struct byte_range_lock *br_lck = NULL;
241 if (!fsp->can_lock) {
242 return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
245 if (!lp_locking(fsp->conn->params)) {
249 DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for fnum %d file %s\n",
250 (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
252 br_lck = brl_get_locks(NULL, fsp);
254 return NT_STATUS_NO_MEMORY;
257 ok = brl_unlock(br_lck,
267 DEBUG(10,("do_unlock: returning ERRlock.\n" ));
268 return NT_STATUS_RANGE_NOT_LOCKED;
274 /****************************************************************************
275 Cancel any pending blocked locks.
276 ****************************************************************************/
278 NTSTATUS do_lock_cancel(files_struct *fsp,
282 enum brl_flavour lock_flav)
285 struct byte_range_lock *br_lck = NULL;
287 if (!fsp->can_lock) {
288 return fsp->is_directory ?
289 NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
292 if (!lp_locking(fsp->conn->params)) {
293 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
296 DEBUG(10,("do_lock_cancel: cancel start=%.0f len=%.0f requested for fnum %d file %s\n",
297 (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
299 br_lck = brl_get_locks(NULL, fsp);
301 return NT_STATUS_NO_MEMORY;
304 ok = brl_lock_cancel(br_lck,
314 DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
315 return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
321 /****************************************************************************
322 Remove any locks on this fd. Called from file_close().
323 ****************************************************************************/
325 void locking_close_file(files_struct *fsp)
327 struct byte_range_lock *br_lck;
329 if (!lp_locking(fsp->conn->params)) {
333 br_lck = brl_get_locks(NULL,fsp);
336 cancel_pending_lock_requests_by_fid(fsp, br_lck);
337 brl_close_fnum(br_lck);
342 /****************************************************************************
343 Initialise the locking functions.
344 ****************************************************************************/
346 static int open_read_only;
348 BOOL locking_init(int read_only)
355 tdb = tdb_open_log(lock_path("locking.tdb"),
356 lp_open_files_db_hash_size(),
357 TDB_DEFAULT|(read_only?0x0:TDB_CLEAR_IF_FIRST),
358 read_only?O_RDONLY:O_RDWR|O_CREAT,
362 DEBUG(0,("ERROR: Failed to initialise locking database\n"));
366 if (!posix_locking_init(read_only))
369 open_read_only = read_only;
374 /*******************************************************************
375 Deinitialize the share_mode management.
376 ******************************************************************/
378 BOOL locking_end(void)
382 brl_shutdown(open_read_only);
384 if (tdb_close(tdb) != 0)
391 /*******************************************************************
392 Form a static locking key for a dev/inode pair.
393 ******************************************************************/
395 /* key and data records in the tdb locking database */
401 /*******************************************************************
402 Form a static locking key for a dev/inode pair.
403 ******************************************************************/
405 static TDB_DATA locking_key(SMB_DEV_T dev, SMB_INO_T inode)
407 static struct locking_key key;
410 memset(&key, '\0', sizeof(key));
413 kbuf.dptr = (char *)&key;
414 kbuf.dsize = sizeof(key);
418 /*******************************************************************
419 Print out a share mode.
420 ********************************************************************/
422 char *share_mode_str(int num, struct share_mode_entry *e)
424 static pstring share_str;
426 slprintf(share_str, sizeof(share_str)-1, "share_mode_entry[%d]: %s "
427 "pid = %s, share_access = 0x%x, private_options = 0x%x, "
428 "access_mask = 0x%x, mid = 0x%x, type= 0x%x, file_id = %lu, "
429 "uid = %u, flags = %u, dev = 0x%x, inode = %.0f",
431 e->op_type == UNUSED_SHARE_MODE_ENTRY ? "UNUSED" : "",
432 procid_str_static(&e->pid),
433 e->share_access, e->private_options,
434 e->access_mask, e->op_mid, e->op_type, e->share_file_id,
435 (unsigned int)e->uid, (unsigned int)e->flags,
436 (unsigned int)e->dev, (double)e->inode );
441 /*******************************************************************
442 Print out a share mode table.
443 ********************************************************************/
445 static void print_share_mode_table(struct locking_data *data)
447 int num_share_modes = data->u.s.num_share_mode_entries;
448 struct share_mode_entry *shares =
449 (struct share_mode_entry *)(data + 1);
452 for (i = 0; i < num_share_modes; i++) {
453 struct share_mode_entry entry;
455 memcpy(&entry, &shares[i], sizeof(struct share_mode_entry));
456 DEBUG(10,("print_share_mode_table: %s\n",
457 share_mode_str(i, &entry)));
461 /*******************************************************************
462 Get all share mode entries for a dev/inode pair.
463 ********************************************************************/
465 static BOOL parse_share_modes(TDB_DATA dbuf, struct share_mode_lock *lck)
467 struct locking_data *data;
470 if (dbuf.dsize < sizeof(struct locking_data)) {
471 smb_panic("PANIC: parse_share_modes: buffer too short.\n");
474 data = (struct locking_data *)dbuf.dptr;
476 lck->delete_on_close = data->u.s.delete_on_close;
477 lck->num_share_modes = data->u.s.num_share_mode_entries;
479 DEBUG(10, ("parse_share_modes: delete_on_close: %d, "
480 "num_share_modes: %d\n",
481 lck->delete_on_close,
482 lck->num_share_modes));
484 if ((lck->num_share_modes < 0) || (lck->num_share_modes > 1000000)) {
485 DEBUG(0, ("invalid number of share modes: %d\n",
486 lck->num_share_modes));
487 smb_panic("PANIC: invalid number of share modes");
490 lck->share_modes = NULL;
492 if (lck->num_share_modes != 0) {
494 if (dbuf.dsize < (sizeof(struct locking_data) +
495 (lck->num_share_modes *
496 sizeof(struct share_mode_entry)))) {
497 smb_panic("PANIC: parse_share_modes: buffer too short.\n");
500 lck->share_modes = (struct share_mode_entry *)
501 talloc_memdup(lck, dbuf.dptr+sizeof(*data),
502 lck->num_share_modes *
503 sizeof(struct share_mode_entry));
505 if (lck->share_modes == NULL) {
506 smb_panic("talloc failed\n");
510 /* Get any delete token. */
511 if (data->u.s.delete_token_size) {
512 char *p = dbuf.dptr + sizeof(*data) +
513 (lck->num_share_modes *
514 sizeof(struct share_mode_entry));
516 if ((data->u.s.delete_token_size < sizeof(uid_t) + sizeof(gid_t)) ||
517 ((data->u.s.delete_token_size - sizeof(uid_t)) % sizeof(gid_t)) != 0) {
518 DEBUG(0, ("parse_share_modes: invalid token size %d\n",
519 data->u.s.delete_token_size));
520 smb_panic("parse_share_modes: invalid token size\n");
523 lck->delete_token = TALLOC_P(lck, UNIX_USER_TOKEN);
524 if (!lck->delete_token) {
525 smb_panic("talloc failed\n");
528 /* Copy out the uid and gid. */
529 memcpy(&lck->delete_token->uid, p, sizeof(uid_t));
531 memcpy(&lck->delete_token->gid, p, sizeof(gid_t));
534 /* Any supplementary groups ? */
535 lck->delete_token->ngroups = (data->u.s.delete_token_size > (sizeof(uid_t) + sizeof(gid_t))) ?
536 ((data->u.s.delete_token_size -
537 (sizeof(uid_t) + sizeof(gid_t)))/sizeof(gid_t)) : 0;
539 if (lck->delete_token->ngroups) {
540 /* Make this a talloc child of lck->delete_token. */
541 lck->delete_token->groups = TALLOC_ARRAY(lck->delete_token, gid_t,
542 lck->delete_token->ngroups);
543 if (!lck->delete_token) {
544 smb_panic("talloc failed\n");
547 for (i = 0; i < lck->delete_token->ngroups; i++) {
548 memcpy(&lck->delete_token->groups[i], p, sizeof(gid_t));
554 lck->delete_token = NULL;
557 /* Save off the associated service path and filename. */
558 lck->servicepath = talloc_strdup(lck, dbuf.dptr + sizeof(*data) +
559 (lck->num_share_modes *
560 sizeof(struct share_mode_entry)) +
561 data->u.s.delete_token_size );
562 if (lck->servicepath == NULL) {
563 smb_panic("talloc_strdup failed\n");
566 lck->filename = talloc_strdup(lck, dbuf.dptr + sizeof(*data) +
567 (lck->num_share_modes *
568 sizeof(struct share_mode_entry)) +
569 data->u.s.delete_token_size +
570 strlen(lck->servicepath) + 1 );
571 if (lck->filename == NULL) {
572 smb_panic("talloc_strdup failed\n");
576 * Ensure that each entry has a real process attached.
579 for (i = 0; i < lck->num_share_modes; i++) {
580 struct share_mode_entry *entry_p = &lck->share_modes[i];
581 DEBUG(10,("parse_share_modes: %s\n",
582 share_mode_str(i, entry_p) ));
583 if (!process_exists(entry_p->pid)) {
584 DEBUG(10,("parse_share_modes: deleted %s\n",
585 share_mode_str(i, entry_p) ));
586 entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
587 lck->modified = True;
594 static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
599 struct locking_data *data;
602 uint32 delete_token_size;
607 for (i=0; i<lck->num_share_modes; i++) {
608 if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
613 if (num_valid == 0) {
617 sp_len = strlen(lck->servicepath);
618 delete_token_size = (lck->delete_token ?
619 (sizeof(uid_t) + sizeof(gid_t) + (lck->delete_token->ngroups*sizeof(gid_t))) : 0);
621 result.dsize = sizeof(*data) +
622 lck->num_share_modes * sizeof(struct share_mode_entry) +
625 strlen(lck->filename) + 1;
626 result.dptr = TALLOC_ARRAY(lck, char, result.dsize);
628 if (result.dptr == NULL) {
629 smb_panic("talloc failed\n");
632 data = (struct locking_data *)result.dptr;
634 data->u.s.num_share_mode_entries = lck->num_share_modes;
635 data->u.s.delete_on_close = lck->delete_on_close;
636 data->u.s.delete_token_size = delete_token_size;
637 DEBUG(10, ("unparse_share_modes: del: %d, tok = %u, num: %d\n",
638 data->u.s.delete_on_close,
639 (unsigned int)data->u.s.delete_token_size,
640 data->u.s.num_share_mode_entries));
641 memcpy(result.dptr + sizeof(*data), lck->share_modes,
642 sizeof(struct share_mode_entry)*lck->num_share_modes);
643 offset = sizeof(*data) +
644 sizeof(struct share_mode_entry)*lck->num_share_modes;
646 /* Store any delete on close token. */
647 if (lck->delete_token) {
648 char *p = result.dptr + offset;
650 memcpy(p, &lck->delete_token->uid, sizeof(uid_t));
653 memcpy(p, &lck->delete_token->gid, sizeof(gid_t));
656 for (i = 0; i < lck->delete_token->ngroups; i++) {
657 memcpy(p, &lck->delete_token->groups[i], sizeof(gid_t));
660 offset = p - result.dptr;
663 safe_strcpy(result.dptr + offset, lck->servicepath,
664 result.dsize - offset - 1);
665 offset += sp_len + 1;
666 safe_strcpy(result.dptr + offset, lck->filename,
667 result.dsize - offset - 1);
669 if (DEBUGLEVEL >= 10) {
670 print_share_mode_table(data);
676 static int share_mode_lock_destructor(struct share_mode_lock *lck)
678 TDB_DATA key = locking_key(lck->dev, lck->ino);
681 if (!lck->modified) {
685 data = unparse_share_modes(lck);
687 if (data.dptr == NULL) {
689 /* There has been an entry before, delete it */
690 if (tdb_delete(tdb, key) == -1) {
691 smb_panic("Could not delete share entry\n");
697 if (tdb_store(tdb, key, data, TDB_REPLACE) == -1) {
698 smb_panic("Could not store share mode entry\n");
702 tdb_chainunlock(tdb, key);
707 struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
708 SMB_DEV_T dev, SMB_INO_T ino,
709 const char *servicepath,
712 struct share_mode_lock *lck;
713 TDB_DATA key = locking_key(dev, ino);
716 lck = TALLOC_P(mem_ctx, struct share_mode_lock);
718 DEBUG(0, ("talloc failed\n"));
722 /* Ensure we set every field here as the destructor must be
723 valid even if parse_share_modes fails. */
725 lck->servicepath = NULL;
726 lck->filename = NULL;
729 lck->num_share_modes = 0;
730 lck->share_modes = NULL;
731 lck->delete_token = NULL;
732 lck->delete_on_close = False;
734 lck->modified = False;
736 if (tdb_chainlock(tdb, key) != 0) {
737 DEBUG(3, ("Could not lock share entry\n"));
742 /* We must set the destructor immediately after the chainlock
743 ensure the lock is cleaned up on any of the error return
746 talloc_set_destructor(lck, share_mode_lock_destructor);
748 data = tdb_fetch(tdb, key);
749 lck->fresh = (data.dptr == NULL);
753 if (fname == NULL || servicepath == NULL) {
757 lck->filename = talloc_strdup(lck, fname);
758 lck->servicepath = talloc_strdup(lck, servicepath);
759 if (lck->filename == NULL || lck->servicepath == NULL) {
760 DEBUG(0, ("talloc failed\n"));
765 if (!parse_share_modes(data, lck)) {
766 DEBUG(0, ("Could not parse share modes\n"));
768 SAFE_FREE(data.dptr);
773 SAFE_FREE(data.dptr);
778 /*******************************************************************
779 Sets the service name and filename for rename.
780 At this point we emit "file renamed" messages to all
781 process id's that have this file open.
782 Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
783 ********************************************************************/
785 BOOL rename_share_filename(struct share_mode_lock *lck,
786 const char *servicepath,
799 DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
800 servicepath, newname));
803 * rename_internal_fsp() and rename_internals() add './' to
804 * head of newname if newname does not contain a '/'.
806 while (newname[0] && newname[1] && newname[0] == '.' && newname[1] == '/') {
810 lck->servicepath = talloc_strdup(lck, servicepath);
811 lck->filename = talloc_strdup(lck, newname);
812 if (lck->filename == NULL || lck->servicepath == NULL) {
813 DEBUG(0, ("rename_share_filename: talloc failed\n"));
816 lck->modified = True;
818 sp_len = strlen(lck->servicepath);
819 fn_len = strlen(lck->filename);
821 msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + fn_len + 1;
823 /* Set up the name changed message. */
824 frm = TALLOC_ARRAY(lck, char, msg_len);
829 SDEV_T_VAL(frm,0,lck->dev);
830 SINO_T_VAL(frm,8,lck->ino);
832 DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
834 safe_strcpy(&frm[16], lck->servicepath, sp_len);
835 safe_strcpy(&frm[16 + sp_len + 1], lck->filename, fn_len);
837 /* Send the messages. */
838 for (i=0; i<lck->num_share_modes; i++) {
839 struct share_mode_entry *se = &lck->share_modes[i];
840 if (!is_valid_share_mode_entry(se)) {
843 /* But not to ourselves... */
844 if (procid_is_me(&se->pid)) {
848 DEBUG(10,("rename_share_filename: sending rename message to pid %s "
849 "dev %x, inode %.0f sharepath %s newname %s\n",
850 procid_str_static(&se->pid),
851 (unsigned int)lck->dev, (double)lck->ino,
852 lck->servicepath, lck->filename ));
854 message_send_pid(se->pid, MSG_SMB_FILE_RENAME,
861 BOOL get_delete_on_close_flag(SMB_DEV_T dev, SMB_INO_T inode)
864 struct share_mode_lock *lck = get_share_mode_lock(NULL, dev, inode, NULL, NULL);
868 result = lck->delete_on_close;
873 BOOL is_valid_share_mode_entry(const struct share_mode_entry *e)
877 num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
878 num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
879 num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
881 SMB_ASSERT(num_props <= 1);
882 return (num_props != 0);
885 BOOL is_deferred_open_entry(const struct share_mode_entry *e)
887 return (e->op_type == DEFERRED_OPEN_ENTRY);
890 BOOL is_unused_share_mode_entry(const struct share_mode_entry *e)
892 return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
895 /*******************************************************************
896 Fill a share mode entry.
897 ********************************************************************/
899 static void fill_share_mode_entry(struct share_mode_entry *e,
901 uid_t uid, uint16 mid, uint16 op_type)
904 e->pid = procid_self();
905 e->share_access = fsp->share_access;
906 e->private_options = fsp->fh->private_options;
907 e->access_mask = fsp->access_mask;
909 e->op_type = op_type;
910 e->time.tv_sec = fsp->open_time.tv_sec;
911 e->time.tv_usec = fsp->open_time.tv_usec;
913 e->inode = fsp->inode;
914 e->share_file_id = fsp->fh->file_id;
915 e->uid = (uint32)uid;
916 e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
919 static void fill_deferred_open_entry(struct share_mode_entry *e,
920 const struct timeval request_time,
921 SMB_DEV_T dev, SMB_INO_T ino, uint16 mid)
924 e->pid = procid_self();
926 e->op_type = DEFERRED_OPEN_ENTRY;
927 e->time.tv_sec = request_time.tv_sec;
928 e->time.tv_usec = request_time.tv_usec;
935 static void add_share_mode_entry(struct share_mode_lock *lck,
936 const struct share_mode_entry *entry)
940 for (i=0; i<lck->num_share_modes; i++) {
941 struct share_mode_entry *e = &lck->share_modes[i];
942 if (is_unused_share_mode_entry(e)) {
948 if (i == lck->num_share_modes) {
949 /* No unused entry found */
950 ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
951 &lck->share_modes, &lck->num_share_modes);
953 lck->modified = True;
956 void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
957 uid_t uid, uint16 mid, uint16 op_type)
959 struct share_mode_entry entry;
960 fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
961 add_share_mode_entry(lck, &entry);
964 void add_deferred_open(struct share_mode_lock *lck, uint16 mid,
965 struct timeval request_time,
966 SMB_DEV_T dev, SMB_INO_T ino)
968 struct share_mode_entry entry;
969 fill_deferred_open_entry(&entry, request_time, dev, ino, mid);
970 add_share_mode_entry(lck, &entry);
973 /*******************************************************************
974 Check if two share mode entries are identical, ignoring oplock
975 and mid info and desired_access. (Removed paranoia test - it's
976 not automatically a logic error if they are identical. JRA.)
977 ********************************************************************/
979 static BOOL share_modes_identical(struct share_mode_entry *e1,
980 struct share_mode_entry *e2)
982 /* We used to check for e1->share_access == e2->share_access here
983 as well as the other fields but 2 different DOS or FCB opens
984 sharing the same share mode entry may validly differ in
985 fsp->share_access field. */
987 return (procid_equal(&e1->pid, &e2->pid) &&
988 e1->dev == e2->dev &&
989 e1->inode == e2->inode &&
990 e1->share_file_id == e2->share_file_id );
993 static BOOL deferred_open_identical(struct share_mode_entry *e1,
994 struct share_mode_entry *e2)
996 return (procid_equal(&e1->pid, &e2->pid) &&
997 (e1->op_mid == e2->op_mid) &&
998 (e1->dev == e2->dev) &&
999 (e1->inode == e2->inode));
1002 static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
1003 struct share_mode_entry *entry)
1007 for (i=0; i<lck->num_share_modes; i++) {
1008 struct share_mode_entry *e = &lck->share_modes[i];
1009 if (is_valid_share_mode_entry(entry) &&
1010 is_valid_share_mode_entry(e) &&
1011 share_modes_identical(e, entry)) {
1014 if (is_deferred_open_entry(entry) &&
1015 is_deferred_open_entry(e) &&
1016 deferred_open_identical(e, entry)) {
1023 /*******************************************************************
1024 Del the share mode of a file for this process. Return the number of
1026 ********************************************************************/
1028 BOOL del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
1030 struct share_mode_entry entry, *e;
1032 /* Don't care about the pid owner being correct here - just a search. */
1033 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1035 e = find_share_mode_entry(lck, &entry);
1040 e->op_type = UNUSED_SHARE_MODE_ENTRY;
1041 lck->modified = True;
1045 void del_deferred_open_entry(struct share_mode_lock *lck, uint16 mid)
1047 struct share_mode_entry entry, *e;
1049 fill_deferred_open_entry(&entry, timeval_zero(),
1050 lck->dev, lck->ino, mid);
1052 e = find_share_mode_entry(lck, &entry);
1057 e->op_type = UNUSED_SHARE_MODE_ENTRY;
1058 lck->modified = True;
1061 /*******************************************************************
1062 Remove an oplock mid and mode entry from a share mode.
1063 ********************************************************************/
1065 BOOL remove_share_oplock(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);
1078 e->op_type = NO_OPLOCK;
1079 lck->modified = True;
1083 /*******************************************************************
1084 Downgrade a oplock type from exclusive to level II.
1085 ********************************************************************/
1087 BOOL downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
1089 struct share_mode_entry entry, *e;
1091 /* Don't care about the pid owner being correct here - just a search. */
1092 fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
1094 e = find_share_mode_entry(lck, &entry);
1099 e->op_type = LEVEL_II_OPLOCK;
1100 lck->modified = True;
1104 /****************************************************************************
1105 Deal with the internal needs of setting the delete on close flag. Note that
1106 as the tdb locking is recursive, it is safe to call this from within
1107 open_file_ntcreate. JRA.
1108 ****************************************************************************/
1110 NTSTATUS can_set_delete_on_close(files_struct *fsp, BOOL delete_on_close,
1113 if (!delete_on_close) {
1114 return NT_STATUS_OK;
1118 * Only allow delete on close for writable files.
1121 if ((dosmode & aRONLY) &&
1122 !lp_delete_readonly(SNUM(fsp->conn))) {
1123 DEBUG(10,("can_set_delete_on_close: file %s delete on close "
1124 "flag set but file attribute is readonly.\n",
1126 return NT_STATUS_CANNOT_DELETE;
1130 * Only allow delete on close for writable shares.
1133 if (!CAN_WRITE(fsp->conn)) {
1134 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1135 "close flag set but write access denied on share.\n",
1137 return NT_STATUS_ACCESS_DENIED;
1141 * Only allow delete on close for files/directories opened with delete
1145 if (!(fsp->access_mask & DELETE_ACCESS)) {
1146 DEBUG(10,("can_set_delete_on_close: file %s delete on "
1147 "close flag set but delete access denied.\n",
1149 return NT_STATUS_ACCESS_DENIED;
1152 /* Don't allow delete on close for non-empty directories. */
1153 if (fsp->is_directory) {
1154 return can_delete_directory(fsp->conn, fsp->fsp_name);
1157 return NT_STATUS_OK;
1160 /*************************************************************************
1161 Return a talloced copy of a UNIX_USER_TOKEN. NULL on fail.
1162 (Should this be in locking.c.... ?).
1163 *************************************************************************/
1165 static UNIX_USER_TOKEN *copy_unix_token(TALLOC_CTX *ctx, UNIX_USER_TOKEN *tok)
1167 UNIX_USER_TOKEN *cpy;
1173 cpy = TALLOC_P(ctx, UNIX_USER_TOKEN);
1178 cpy->uid = tok->uid;
1179 cpy->gid = tok->gid;
1180 cpy->ngroups = tok->ngroups;
1182 /* Make this a talloc child of cpy. */
1183 cpy->groups = TALLOC_ARRAY(cpy, gid_t, tok->ngroups);
1187 memcpy(cpy->groups, tok->groups, tok->ngroups * sizeof(gid_t));
1192 /****************************************************************************
1193 Replace the delete on close token.
1194 ****************************************************************************/
1196 void set_delete_on_close_token(struct share_mode_lock *lck, UNIX_USER_TOKEN *tok)
1198 /* Ensure there's no token. */
1199 if (lck->delete_token) {
1200 TALLOC_FREE(lck->delete_token); /* Also deletes groups... */
1201 lck->delete_token = NULL;
1204 /* Copy the new token (can be NULL). */
1205 lck->delete_token = copy_unix_token(lck, tok);
1206 lck->modified = True;
1209 /****************************************************************************
1210 Sets the delete on close flag over all share modes on this file.
1211 Modify the share mode entry for all files open
1212 on this device and inode to tell other smbds we have
1213 changed the delete on close flag. This will be noticed
1214 in the close code, the last closer will delete the file
1216 This makes a copy of any UNIX_USER_TOKEN into the
1217 lck entry. This function is used when the lock is already granted.
1218 ****************************************************************************/
1220 void set_delete_on_close_lck(struct share_mode_lock *lck, BOOL delete_on_close, UNIX_USER_TOKEN *tok)
1222 if (lck->delete_on_close != delete_on_close) {
1223 set_delete_on_close_token(lck, tok);
1224 lck->delete_on_close = delete_on_close;
1225 if (delete_on_close) {
1226 SMB_ASSERT(lck->delete_token != NULL);
1228 lck->modified = True;
1232 BOOL set_delete_on_close(files_struct *fsp, BOOL delete_on_close, UNIX_USER_TOKEN *tok)
1234 struct share_mode_lock *lck;
1236 DEBUG(10,("set_delete_on_close: %s delete on close flag for "
1237 "fnum = %d, file %s\n",
1238 delete_on_close ? "Adding" : "Removing", fsp->fnum,
1245 lck = get_share_mode_lock(NULL, fsp->dev, fsp->inode, NULL, NULL);
1250 set_delete_on_close_lck(lck, delete_on_close, tok);
1252 if (fsp->is_directory) {
1253 send_stat_cache_delete_message(fsp->fsp_name);
1260 struct forall_state {
1261 void (*fn)(const struct share_mode_entry *entry,
1262 const char *sharepath,
1264 void *private_data);
1268 static int traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf,
1271 struct forall_state *state = (struct forall_state *)_state;
1272 struct locking_data *data;
1273 struct share_mode_entry *shares;
1274 const char *sharepath;
1278 /* Ensure this is a locking_key record. */
1279 if (kbuf.dsize != sizeof(struct locking_key))
1282 data = (struct locking_data *)dbuf.dptr;
1283 shares = (struct share_mode_entry *)(dbuf.dptr + sizeof(*data));
1284 sharepath = dbuf.dptr + sizeof(*data) +
1285 data->u.s.num_share_mode_entries*sizeof(*shares) +
1286 data->u.s.delete_token_size;
1287 fname = dbuf.dptr + sizeof(*data) +
1288 data->u.s.num_share_mode_entries*sizeof(*shares) +
1289 data->u.s.delete_token_size +
1290 strlen(sharepath) + 1;
1292 for (i=0;i<data->u.s.num_share_mode_entries;i++) {
1293 state->fn(&shares[i], sharepath, fname,
1294 state->private_data);
1299 /*******************************************************************
1300 Call the specified function on each entry under management by the
1302 ********************************************************************/
1304 int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
1305 const char *, void *),
1308 struct forall_state state;
1314 state.private_data = private_data;
1316 return tdb_traverse(tdb, traverse_fn, (void *)&state);