Unix SMB/CIFS implementation.
Locking functions
Copyright (C) Andrew Tridgell 1992-2000
- Copyright (C) Jeremy Allison 1992-2000
-
+ Copyright (C) Jeremy Allison 1992-2006
+ Copyright (C) Volker Lendecke 2005
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 2 of the License, or
+ the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
-
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
Revision History:
rewrtten completely to use new tdb code. Tridge, Dec '99
Added POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
+ Added Unix Extensions POSIX locking support. Jeremy Allison Mar 2006.
*/
#include "includes.h"
-uint16 global_smbpid;
+#include "system/filesys.h"
+#include "locking/proto.h"
+#include "smbd/globals.h"
+#include "dbwrap.h"
+#include "../libcli/security/security.h"
+#include "serverid.h"
+#include "messages.h"
+#include "util_tdb.h"
+
+#undef DBGC_CLASS
+#define DBGC_CLASS DBGC_LOCKING
+
+#define NO_LOCKING_COUNT (-1)
/* the locking database handle */
-static TDB_CONTEXT *tdb;
+static struct db_context *lock_db;
/****************************************************************************
- Debugging aid :-).
+ Debugging aids :-).
****************************************************************************/
-static const char *lock_type_name(enum brl_type lock_type)
+const char *lock_type_name(enum brl_type lock_type)
{
- return (lock_type == READ_LOCK) ? "READ" : "WRITE";
+ switch (lock_type) {
+ case READ_LOCK:
+ return "READ";
+ case WRITE_LOCK:
+ return "WRITE";
+ case PENDING_READ_LOCK:
+ return "PENDING_READ";
+ case PENDING_WRITE_LOCK:
+ return "PENDING_WRITE";
+ default:
+ return "other";
+ }
+}
+
+const char *lock_flav_name(enum brl_flavour lock_flav)
+{
+ return (lock_flav == WINDOWS_LOCK) ? "WINDOWS_LOCK" : "POSIX_LOCK";
}
/****************************************************************************
Utility function called to see if a file region is locked.
- If check_self is True, then checks on our own fd with the same locking context
- are still made. If check_self is False, then checks are not made on our own fd
- with the same locking context are not made.
+ Called in the read/write codepath.
****************************************************************************/
-BOOL is_locked(files_struct *fsp,connection_struct *conn,
- SMB_BIG_UINT count,SMB_BIG_UINT offset,
- enum brl_type lock_type, BOOL check_self)
+void init_strict_lock_struct(files_struct *fsp,
+ uint64_t smblctx,
+ br_off start,
+ br_off size,
+ enum brl_type lock_type,
+ struct lock_struct *plock)
{
- int snum = SNUM(conn);
- BOOL ret;
-
- if (count == 0)
- return(False);
+ SMB_ASSERT(lock_type == READ_LOCK || lock_type == WRITE_LOCK);
+
+ plock->context.smblctx = smblctx;
+ plock->context.tid = fsp->conn->cnum;
+ plock->context.pid = sconn_server_id(fsp->conn->sconn);
+ plock->start = start;
+ plock->size = size;
+ plock->fnum = fsp->fnum;
+ plock->lock_type = lock_type;
+ plock->lock_flav = lp_posix_cifsu_locktype(fsp);
+}
- if (!lp_locking(snum) || !lp_strict_locking(snum))
- return(False);
+bool strict_lock_default(files_struct *fsp, struct lock_struct *plock)
+{
+ int strict_locking = lp_strict_locking(fsp->conn->params);
+ bool ret = False;
- ret = !brl_locktest(fsp->dev, fsp->inode, fsp->fnum,
- global_smbpid, sys_getpid(), conn->cnum,
- offset, count, lock_type, check_self);
+ if (plock->size == 0) {
+ return True;
+ }
- DEBUG(10,("is_locked: brl start=%.0f len=%.0f %s for file %s\n",
- (double)offset, (double)count, ret ? "locked" : "unlocked",
- fsp->fsp_name ));
+ if (!lp_locking(fsp->conn->params) || !strict_locking) {
+ return True;
+ }
- /*
- * There is no lock held by an SMB daemon, check to
- * see if there is a POSIX lock from a UNIX or NFS process.
- */
+ if (strict_locking == Auto) {
+ if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (plock->lock_type == READ_LOCK || plock->lock_type == WRITE_LOCK)) {
+ DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp_str_dbg(fsp)));
+ ret = True;
+ } else if ((fsp->oplock_type == LEVEL_II_OPLOCK) &&
+ (plock->lock_type == READ_LOCK)) {
+ DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp_str_dbg(fsp)));
+ ret = True;
+ } else {
+ struct byte_range_lock *br_lck;
- if(!ret && lp_posix_locking(snum)) {
- ret = is_posix_locked(fsp, offset, count, lock_type);
+ br_lck = brl_get_locks_readonly(fsp);
+ if (!br_lck) {
+ return True;
+ }
+ ret = brl_locktest(br_lck,
+ plock->context.smblctx,
+ plock->context.pid,
+ plock->start,
+ plock->size,
+ plock->lock_type,
+ plock->lock_flav);
+ }
+ } else {
+ struct byte_range_lock *br_lck;
- DEBUG(10,("is_locked: posix start=%.0f len=%.0f %s for file %s\n",
- (double)offset, (double)count, ret ? "locked" : "unlocked",
- fsp->fsp_name ));
+ br_lck = brl_get_locks_readonly(fsp);
+ if (!br_lck) {
+ return True;
+ }
+ ret = brl_locktest(br_lck,
+ plock->context.smblctx,
+ plock->context.pid,
+ plock->start,
+ plock->size,
+ plock->lock_type,
+ plock->lock_flav);
}
+ DEBUG(10,("strict_lock_default: flavour = %s brl start=%.0f "
+ "len=%.0f %s for fnum %d file %s\n",
+ lock_flav_name(plock->lock_flav),
+ (double)plock->start, (double)plock->size,
+ ret ? "unlocked" : "locked",
+ plock->fnum, fsp_str_dbg(fsp)));
+
return ret;
}
+void strict_unlock_default(files_struct *fsp, struct lock_struct *plock)
+{
+}
+
/****************************************************************************
- Utility function called by locking requests.
+ Find out if a lock could be granted - return who is blocking us if we can't.
****************************************************************************/
-static NTSTATUS do_lock(files_struct *fsp,connection_struct *conn, uint16 lock_pid,
- SMB_BIG_UINT count,SMB_BIG_UINT offset,enum brl_type lock_type, BOOL *my_lock_ctx)
+NTSTATUS query_lock(files_struct *fsp,
+ uint64_t *psmblctx,
+ uint64_t *pcount,
+ uint64_t *poffset,
+ enum brl_type *plock_type,
+ enum brl_flavour lock_flav)
{
- NTSTATUS status = NT_STATUS_LOCK_NOT_GRANTED;
+ struct byte_range_lock *br_lck = NULL;
- if (!lp_locking(SNUM(conn)))
+ if (!fsp->can_lock) {
+ return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
+ }
+
+ if (!lp_locking(fsp->conn->params)) {
return NT_STATUS_OK;
+ }
- /* NOTE! 0 byte long ranges ARE allowed and should be stored */
+ br_lck = brl_get_locks_readonly(fsp);
+ if (!br_lck) {
+ return NT_STATUS_NO_MEMORY;
+ }
- DEBUG(10,("do_lock: lock type %s start=%.0f len=%.0f requested for file %s\n",
- lock_type_name(lock_type), (double)offset, (double)count, fsp->fsp_name ));
-
- if (OPEN_FSP(fsp) && fsp->can_lock && (fsp->conn == conn)) {
- status = brl_lock(fsp->dev, fsp->inode, fsp->fnum,
- lock_pid, sys_getpid(), conn->cnum,
- offset, count,
- lock_type, my_lock_ctx);
-
- if (NT_STATUS_IS_OK(status) && lp_posix_locking(SNUM(conn))) {
-
- /*
- * Try and get a POSIX lock on this range.
- * Note that this is ok if it is a read lock
- * overlapping on a different fd. JRA.
- */
-
- if (!set_posix_lock(fsp, offset, count, lock_type)) {
- if (errno == EACCES || errno == EAGAIN)
- status = NT_STATUS_FILE_LOCK_CONFLICT;
- else
- status = map_nt_error_from_unix(errno);
-
- /*
- * We failed to map - we must now remove the brl
- * lock entry.
- */
- (void)brl_unlock(fsp->dev, fsp->inode, fsp->fnum,
- lock_pid, sys_getpid(), conn->cnum,
- offset, count, False,
- NULL, NULL);
- }
- }
+ return brl_lockquery(br_lck,
+ psmblctx,
+ sconn_server_id(fsp->conn->sconn),
+ poffset,
+ pcount,
+ plock_type,
+ lock_flav);
+}
+
+static void increment_current_lock_count(files_struct *fsp,
+ enum brl_flavour lock_flav)
+{
+ if (lock_flav == WINDOWS_LOCK &&
+ fsp->current_lock_count != NO_LOCKING_COUNT) {
+ /* blocking ie. pending, locks also count here,
+ * as this is an efficiency counter to avoid checking
+ * the lock db. on close. JRA. */
+
+ fsp->current_lock_count++;
+ } else {
+ /* Notice that this has had a POSIX lock request.
+ * We can't count locks after this so forget them.
+ */
+ fsp->current_lock_count = NO_LOCKING_COUNT;
}
+}
- return status;
+static void decrement_current_lock_count(files_struct *fsp,
+ enum brl_flavour lock_flav)
+{
+ if (lock_flav == WINDOWS_LOCK &&
+ fsp->current_lock_count != NO_LOCKING_COUNT) {
+ SMB_ASSERT(fsp->current_lock_count > 0);
+ fsp->current_lock_count--;
+ }
}
/****************************************************************************
- Utility function called by locking requests. This is *DISGUSTING*. It also
- appears to be "What Windows Does" (tm). Andrew, ever wonder why Windows 2000
- is so slow on the locking tests...... ? This is the reason. Much though I hate
- it, we need this. JRA.
+ Utility function called by locking requests.
****************************************************************************/
-NTSTATUS do_lock_spin(files_struct *fsp,connection_struct *conn, uint16 lock_pid,
- SMB_BIG_UINT count,SMB_BIG_UINT offset,enum brl_type lock_type, BOOL *my_lock_ctx)
+struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
+ files_struct *fsp,
+ uint64_t smblctx,
+ uint64_t count,
+ uint64_t offset,
+ enum brl_type lock_type,
+ enum brl_flavour lock_flav,
+ bool blocking_lock,
+ NTSTATUS *perr,
+ uint64_t *psmblctx,
+ struct blocking_lock_record *blr)
{
- int j, maxj = lp_lock_spin_count();
- int sleeptime = lp_lock_sleep_time();
- NTSTATUS status, ret;
+ struct byte_range_lock *br_lck = NULL;
- if (maxj <= 0)
- maxj = 1;
+ /* silently return ok on print files as we don't do locking there */
+ if (fsp->print_file) {
+ *perr = NT_STATUS_OK;
+ return NULL;
+ }
- ret = NT_STATUS_OK; /* to keep dumb compilers happy */
+ if (!fsp->can_lock) {
+ *perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
+ return NULL;
+ }
- for (j = 0; j < maxj; j++) {
- status = do_lock(fsp, conn, lock_pid, count, offset, lock_type, my_lock_ctx);
- if (!NT_STATUS_EQUAL(status, NT_STATUS_LOCK_NOT_GRANTED) &&
- !NT_STATUS_EQUAL(status, NT_STATUS_FILE_LOCK_CONFLICT)) {
- return status;
- }
- /* if we do fail then return the first error code we got */
- if (j == 0) {
- ret = status;
- /* Don't spin if we blocked ourselves. */
- if (*my_lock_ctx)
- return ret;
- }
- if (sleeptime)
- sys_usleep(sleeptime);
+ if (!lp_locking(fsp->conn->params)) {
+ *perr = NT_STATUS_OK;
+ return NULL;
}
- return ret;
-}
-/* Struct passed to brl_unlock. */
-struct posix_unlock_data_struct {
- files_struct *fsp;
- SMB_BIG_UINT offset;
- SMB_BIG_UINT count;
-};
+ /* NOTE! 0 byte long ranges ARE allowed and should be stored */
-/****************************************************************************
- Function passed to brl_unlock to allow POSIX unlock to be done first.
-****************************************************************************/
+ DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f "
+ "blocking_lock=%s requested for fnum %d file %s\n",
+ lock_flav_name(lock_flav), lock_type_name(lock_type),
+ (double)offset, (double)count, blocking_lock ? "true" :
+ "false", fsp->fnum, fsp_str_dbg(fsp)));
-static void posix_unlock(void *pre_data)
-{
- struct posix_unlock_data_struct *pdata = (struct posix_unlock_data_struct *)pre_data;
+ br_lck = brl_get_locks(talloc_tos(), fsp);
+ if (!br_lck) {
+ *perr = NT_STATUS_NO_MEMORY;
+ return NULL;
+ }
- if (lp_posix_locking(SNUM(pdata->fsp->conn)))
- release_posix_lock(pdata->fsp, pdata->offset, pdata->count);
+ *perr = brl_lock(msg_ctx,
+ br_lck,
+ smblctx,
+ sconn_server_id(fsp->conn->sconn),
+ offset,
+ count,
+ lock_type,
+ lock_flav,
+ blocking_lock,
+ psmblctx,
+ blr);
+
+ DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
+
+ increment_current_lock_count(fsp, lock_flav);
+ return br_lck;
}
/****************************************************************************
Utility function called by unlocking requests.
****************************************************************************/
-NTSTATUS do_unlock(files_struct *fsp,connection_struct *conn, uint16 lock_pid,
- SMB_BIG_UINT count,SMB_BIG_UINT offset)
+NTSTATUS do_unlock(struct messaging_context *msg_ctx,
+ files_struct *fsp,
+ uint64_t smblctx,
+ uint64_t count,
+ uint64_t offset,
+ enum brl_flavour lock_flav)
{
- BOOL ok = False;
- struct posix_unlock_data_struct posix_data;
-
- if (!lp_locking(SNUM(conn)))
+ bool ok = False;
+ struct byte_range_lock *br_lck = NULL;
+
+ if (!fsp->can_lock) {
+ return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
+ }
+
+ if (!lp_locking(fsp->conn->params)) {
return NT_STATUS_OK;
-
- if (!OPEN_FSP(fsp) || !fsp->can_lock || (fsp->conn != conn)) {
- return NT_STATUS_INVALID_HANDLE;
}
-
- DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for file %s\n",
- (double)offset, (double)count, fsp->fsp_name ));
- /*
- * Remove the existing lock record from the tdb lockdb
- * before looking at POSIX locks. If this record doesn't
- * match then don't bother looking to remove POSIX locks.
- */
+ DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for fnum %d file %s\n",
+ (double)offset, (double)count, fsp->fnum,
+ fsp_str_dbg(fsp)));
- posix_data.fsp = fsp;
- posix_data.offset = offset;
- posix_data.count = count;
+ br_lck = brl_get_locks(talloc_tos(), fsp);
+ if (!br_lck) {
+ return NT_STATUS_NO_MEMORY;
+ }
+
+ ok = brl_unlock(msg_ctx,
+ br_lck,
+ smblctx,
+ sconn_server_id(fsp->conn->sconn),
+ offset,
+ count,
+ lock_flav);
+
+ TALLOC_FREE(br_lck);
- ok = brl_unlock(fsp->dev, fsp->inode, fsp->fnum,
- lock_pid, sys_getpid(), conn->cnum, offset, count,
- False, posix_unlock, (void *)&posix_data);
-
if (!ok) {
DEBUG(10,("do_unlock: returning ERRlock.\n" ));
return NT_STATUS_RANGE_NOT_LOCKED;
}
+
+ decrement_current_lock_count(fsp, lock_flav);
return NT_STATUS_OK;
}
/****************************************************************************
- Remove any locks on this fd. Called from file_close().
+ Cancel any pending blocked locks.
****************************************************************************/
-void locking_close_file(files_struct *fsp)
+NTSTATUS do_lock_cancel(files_struct *fsp,
+ uint64 smblctx,
+ uint64_t count,
+ uint64_t offset,
+ enum brl_flavour lock_flav,
+ struct blocking_lock_record *blr)
{
- pid_t pid = sys_getpid();
+ bool ok = False;
+ struct byte_range_lock *br_lck = NULL;
- if (!lp_locking(SNUM(fsp->conn)))
- return;
+ if (!fsp->can_lock) {
+ return fsp->is_directory ?
+ NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
+ }
- /*
- * Just release all the brl locks, no need to release individually.
- */
+ if (!lp_locking(fsp->conn->params)) {
+ return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
+ }
- brl_close(fsp->dev, fsp->inode, pid, fsp->conn->cnum, fsp->fnum);
+ DEBUG(10,("do_lock_cancel: cancel start=%.0f len=%.0f requested for fnum %d file %s\n",
+ (double)offset, (double)count, fsp->fnum,
+ fsp_str_dbg(fsp)));
- if(lp_posix_locking(SNUM(fsp->conn))) {
+ br_lck = brl_get_locks(talloc_tos(), fsp);
+ if (!br_lck) {
+ return NT_STATUS_NO_MEMORY;
+ }
- /*
- * Release all the POSIX locks.
- */
- posix_locking_close_file(fsp);
+ ok = brl_lock_cancel(br_lck,
+ smblctx,
+ sconn_server_id(fsp->conn->sconn),
+ offset,
+ count,
+ lock_flav,
+ blr);
+ TALLOC_FREE(br_lck);
+
+ if (!ok) {
+ DEBUG(10,("do_lock_cancel: returning ERRcancelviolation.\n" ));
+ return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
}
+
+ decrement_current_lock_count(fsp, lock_flav);
+ return NT_STATUS_OK;
}
/****************************************************************************
- Initialise the locking functions.
+ Remove any locks on this fd. Called from file_close().
****************************************************************************/
-static int open_read_only;
-
-BOOL locking_init(int read_only)
+void locking_close_file(struct messaging_context *msg_ctx,
+ files_struct *fsp,
+ enum file_close_type close_type)
{
- brl_init(read_only);
+ struct byte_range_lock *br_lck;
- if (tdb)
- return True;
+ if (!lp_locking(fsp->conn->params)) {
+ return;
+ }
- tdb = tdb_open_log(lock_path("locking.tdb"),
- 0, TDB_DEFAULT|(read_only?0x0:TDB_CLEAR_IF_FIRST),
- read_only?O_RDONLY:O_RDWR|O_CREAT,
- 0644);
+ /* If we have not outstanding locks or pending
+ * locks then we don't need to look in the lock db.
+ */
- if (!tdb) {
- DEBUG(0,("ERROR: Failed to initialise locking database\n"));
- return False;
+ if (fsp->current_lock_count == 0) {
+ return;
}
-
- if (!posix_locking_init(read_only))
- return False;
- open_read_only = read_only;
+ br_lck = brl_get_locks(talloc_tos(),fsp);
- return True;
+ if (br_lck) {
+ cancel_pending_lock_requests_by_fid(fsp, br_lck, close_type);
+ brl_close_fnum(msg_ctx, br_lck);
+ TALLOC_FREE(br_lck);
+ }
}
-/*******************************************************************
- Deinitialize the share_mode management.
-******************************************************************/
+/****************************************************************************
+ Initialise the locking functions.
+****************************************************************************/
-BOOL locking_end(void)
+static bool locking_init_internal(bool read_only)
{
+ brl_init(read_only);
- brl_shutdown(open_read_only);
- if (tdb) {
-
- if (tdb_close(tdb) != 0)
- return False;
- }
-
- return True;
-}
+ if (lock_db)
+ return True;
-/*******************************************************************
- Form a static locking key for a dev/inode pair.
-******************************************************************/
+ lock_db = db_open(NULL, lock_path("locking.tdb"),
+ lp_open_files_db_hash_size(),
+ TDB_DEFAULT|TDB_VOLATILE|TDB_CLEAR_IF_FIRST|TDB_INCOMPATIBLE_HASH,
+ read_only?O_RDONLY:O_RDWR|O_CREAT, 0644);
-static TDB_DATA locking_key(SMB_DEV_T dev, SMB_INO_T inode)
-{
- static struct locking_key key;
- TDB_DATA kbuf;
+ if (!lock_db) {
+ DEBUG(0,("ERROR: Failed to initialise locking database\n"));
+ return False;
+ }
- memset(&key, '\0', sizeof(key));
- key.dev = dev;
- key.inode = inode;
- kbuf.dptr = (char *)&key;
- kbuf.dsize = sizeof(key);
- return kbuf;
-}
+ if (!posix_locking_init(read_only))
+ return False;
-static TDB_DATA locking_key_fsp(files_struct *fsp)
-{
- return locking_key(fsp->dev, fsp->inode);
+ return True;
}
-/*******************************************************************
- Lock a hash bucket entry.
-******************************************************************/
-
-BOOL lock_share_entry(connection_struct *conn,
- SMB_DEV_T dev, SMB_INO_T inode)
+bool locking_init(void)
{
- return tdb_chainlock(tdb, locking_key(dev, inode)) == 0;
+ return locking_init_internal(false);
}
-/*******************************************************************
- Unlock a hash bucket entry.
-******************************************************************/
-
-void unlock_share_entry(connection_struct *conn,
- SMB_DEV_T dev, SMB_INO_T inode)
+bool locking_init_readonly(void)
{
- tdb_chainunlock(tdb, locking_key(dev, inode));
+ return locking_init_internal(true);
}
/*******************************************************************
- Lock a hash bucket entry. use a fsp for convenience
+ Deinitialize the share_mode management.
******************************************************************/
-BOOL lock_share_entry_fsp(files_struct *fsp)
+bool locking_end(void)
{
- return tdb_chainlock(tdb, locking_key(fsp->dev, fsp->inode)) == 0;
+ brl_shutdown();
+ TALLOC_FREE(lock_db);
+ return true;
}
/*******************************************************************
- Unlock a hash bucket entry.
+ Form a static locking key for a dev/inode pair.
******************************************************************/
-void unlock_share_entry_fsp(files_struct *fsp)
+static TDB_DATA locking_key(const struct file_id *id, struct file_id *tmp)
{
- tdb_chainunlock(tdb, locking_key(fsp->dev, fsp->inode));
+ *tmp = *id;
+ return make_tdb_data((const uint8_t *)tmp, sizeof(*tmp));
}
/*******************************************************************
Print out a share mode.
********************************************************************/
-char *share_mode_str(int num, share_mode_entry *e)
+char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
{
- static pstring share_str;
-
- slprintf(share_str, sizeof(share_str)-1, "share_mode_entry[%d]: \
-pid = %lu, share_mode = 0x%x, desired_access = 0x%x, port = 0x%x, type= 0x%x, file_id = %lu, dev = 0x%x, inode = %.0f",
- num, (unsigned long)e->pid, e->share_mode, (unsigned int)e->desired_access, e->op_port, e->op_type, e->share_file_id,
- (unsigned int)e->dev, (double)e->inode );
-
- return share_str;
+ return talloc_asprintf(ctx, "share_mode_entry[%d]: %s "
+ "pid = %s, share_access = 0x%x, private_options = 0x%x, "
+ "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %lu, "
+ "uid = %u, flags = %u, file_id %s, name_hash = 0x%x",
+ num,
+ e->op_type == UNUSED_SHARE_MODE_ENTRY ? "UNUSED" : "",
+ procid_str_static(&e->pid),
+ e->share_access, e->private_options,
+ e->access_mask, (unsigned long long)e->op_mid,
+ e->op_type, e->share_file_id,
+ (unsigned int)e->uid, (unsigned int)e->flags,
+ file_id_string_tos(&e->id),
+ (unsigned int)e->name_hash);
}
/*******************************************************************
static void print_share_mode_table(struct locking_data *data)
{
- int num_share_modes = data->u.num_share_mode_entries;
- share_mode_entry *shares = (share_mode_entry *)(data + 1);
+ int num_share_modes = data->u.s.num_share_mode_entries;
+ struct share_mode_entry *shares =
+ (struct share_mode_entry *)(data + 1);
int i;
for (i = 0; i < num_share_modes; i++) {
- share_mode_entry *entry_p = &shares[i];
- DEBUG(10,("print_share_mode_table: %s\n", share_mode_str(i, entry_p) ));
+ struct share_mode_entry entry;
+ char *str;
+
+ /*
+ * We need to memcpy the entry here due to alignment
+ * restrictions that are not met when directly accessing
+ * shares[i]
+ */
+
+ memcpy(&entry, &shares[i], sizeof(struct share_mode_entry));
+ str = share_mode_str(talloc_tos(), i, &entry);
+
+ DEBUG(10,("print_share_mode_table: %s\n", str ? str : ""));
+ TALLOC_FREE(str);
}
}
-/*******************************************************************
- Get all share mode entries for a dev/inode pair.
-********************************************************************/
-
-int get_share_modes(connection_struct *conn,
- SMB_DEV_T dev, SMB_INO_T inode,
- share_mode_entry **pp_shares)
+static int parse_delete_tokens_list(struct share_mode_lock *lck,
+ struct locking_data *pdata,
+ const TDB_DATA dbuf)
{
- TDB_DATA dbuf;
- struct locking_data *data;
- int num_share_modes;
- share_mode_entry *shares = NULL;
- TDB_DATA key = locking_key(dev, inode);
- *pp_shares = NULL;
+ uint8_t *p = dbuf.dptr + sizeof(struct locking_data) +
+ (lck->num_share_modes *
+ sizeof(struct share_mode_entry));
+ uint8_t *end_ptr = dbuf.dptr + (dbuf.dsize - 2);
+ int delete_tokens_size = 0;
+ int i;
- dbuf = tdb_fetch(tdb, key);
- if (!dbuf.dptr)
- return 0;
+ lck->delete_tokens = NULL;
- data = (struct locking_data *)dbuf.dptr;
- num_share_modes = data->u.num_share_mode_entries;
- if(num_share_modes) {
- int i;
- int del_count = 0;
+ for (i = 0; i < pdata->u.s.num_delete_token_entries; i++) {
+ uint32_t token_len;
+ struct delete_token_list *pdtl;
- shares = (share_mode_entry *)memdup(dbuf.dptr + sizeof(*data),
- num_share_modes * sizeof(share_mode_entry));
+ if (end_ptr - p < (sizeof(uint32_t) + sizeof(uint32_t) +
+ sizeof(uid_t) + sizeof(gid_t))) {
+ DEBUG(0,("parse_delete_tokens_list: "
+ "corrupt token list (%u)",
+ (unsigned int)(end_ptr - p)));
+ smb_panic("corrupt token list");
+ return -1;
+ }
- if (!shares) {
- SAFE_FREE(dbuf.dptr);
- return 0;
+ memcpy(&token_len, p, sizeof(token_len));
+ delete_tokens_size += token_len;
+
+ if (p + token_len > end_ptr || token_len < sizeof(token_len) +
+ sizeof(pdtl->name_hash) +
+ sizeof(uid_t) +
+ sizeof(gid_t)) {
+ DEBUG(0,("parse_delete_tokens_list: "
+ "invalid token length (%u)\n",
+ (unsigned int)token_len ));
+ smb_panic("invalid token length");
+ return -1;
}
- /*
- * Ensure that each entry has a real process attached.
- */
+ p += sizeof(token_len);
- for (i = 0; i < num_share_modes; ) {
- share_mode_entry *entry_p = &shares[i];
- if (process_exists(entry_p->pid)) {
- DEBUG(10,("get_share_modes: %s\n", share_mode_str(i, entry_p) ));
- i++;
- } else {
- DEBUG(10,("get_share_modes: deleted %s\n", share_mode_str(i, entry_p) ));
- memcpy( &shares[i], &shares[i+1],
- sizeof(share_mode_entry) * (num_share_modes - i - 1));
- num_share_modes--;
- del_count++;
- }
+ pdtl = TALLOC_ZERO_P(lck, struct delete_token_list);
+ if (pdtl == NULL) {
+ DEBUG(0,("parse_delete_tokens_list: talloc failed"));
+ return -1;
+ }
+ /* Copy out the name_hash. */
+ memcpy(&pdtl->name_hash, p, sizeof(pdtl->name_hash));
+ p += sizeof(pdtl->name_hash);
+
+ pdtl->delete_token = TALLOC_ZERO_P(pdtl, struct security_unix_token);
+ if (pdtl->delete_token == NULL) {
+ DEBUG(0,("parse_delete_tokens_list: talloc failed"));
+ return -1;
}
- /* Did we delete any ? If so, re-store in tdb. */
- if (del_count) {
- data->u.num_share_mode_entries = num_share_modes;
-
- if (num_share_modes)
- memcpy(dbuf.dptr + sizeof(*data), shares,
- num_share_modes * sizeof(share_mode_entry));
-
- /* The record has shrunk a bit */
- dbuf.dsize -= del_count * sizeof(share_mode_entry);
-
- if (tdb_store(tdb, key, dbuf, TDB_REPLACE) == -1) {
- SAFE_FREE(shares);
- SAFE_FREE(dbuf.dptr);
- return 0;
+ /* Copy out the uid and gid. */
+ memcpy(&pdtl->delete_token->uid, p, sizeof(uid_t));
+ p += sizeof(uid_t);
+ memcpy(&pdtl->delete_token->gid, p, sizeof(gid_t));
+ p += sizeof(gid_t);
+
+ token_len -= (sizeof(token_len) + sizeof(pdtl->name_hash) +
+ sizeof(uid_t) + sizeof(gid_t));
+
+ /* Any supplementary groups ? */
+ if (token_len) {
+ int j;
+
+ if (token_len % sizeof(gid_t) != 0) {
+ DEBUG(0,("parse_delete_tokens_list: "
+ "corrupt group list (%u)",
+ (unsigned int)(token_len % sizeof(gid_t)) ));
+ smb_panic("corrupt group list");
+ return -1;
+ }
+
+ pdtl->delete_token->ngroups = token_len / sizeof(gid_t);
+ pdtl->delete_token->groups = talloc_array(pdtl->delete_token, gid_t,
+ pdtl->delete_token->ngroups);
+ if (pdtl->delete_token->groups == NULL) {
+ DEBUG(0,("parse_delete_tokens_list: talloc failed"));
+ return -1;
+ }
+
+ for (j = 0; j < pdtl->delete_token->ngroups; j++) {
+ memcpy(&pdtl->delete_token->groups[j], p, sizeof(gid_t));
+ p += sizeof(gid_t);
}
}
+ /* Add to the list. */
+ DLIST_ADD(lck->delete_tokens, pdtl);
}
- SAFE_FREE(dbuf.dptr);
- *pp_shares = shares;
- return num_share_modes;
+ return delete_tokens_size;
}
/*******************************************************************
- Fill a share mode entry.
+ Get all share mode entries for a dev/inode pair.
********************************************************************/
-static void fill_share_mode(char *p, files_struct *fsp, uint16 port, uint16 op_type)
+static bool parse_share_modes(const TDB_DATA dbuf, struct share_mode_lock *lck)
{
- share_mode_entry *e = (share_mode_entry *)p;
- void *x = &e->time; /* Needed to force alignment. p may not be aligned.... */
+ struct locking_data data;
+ int delete_tokens_size;
+ int i;
- memset(e, '\0', sizeof(share_mode_entry));
- e->pid = sys_getpid();
- e->share_mode = fsp->share_mode;
- e->desired_access = fsp->desired_access;
- e->op_port = port;
- e->op_type = op_type;
- memcpy(x, &fsp->open_time, sizeof(struct timeval));
- e->share_file_id = fsp->file_id;
- e->dev = fsp->dev;
- e->inode = fsp->inode;
-}
+ if (dbuf.dsize < sizeof(struct locking_data)) {
+ smb_panic("parse_share_modes: buffer too short");
+ }
-/*******************************************************************
- Check if two share mode entries are identical, ignoring oplock
- and port info and desired_access.
-********************************************************************/
+ memcpy(&data, dbuf.dptr, sizeof(data));
+
+ lck->old_write_time = data.u.s.old_write_time;
+ lck->changed_write_time = data.u.s.changed_write_time;
+ lck->num_share_modes = data.u.s.num_share_mode_entries;
+
+ DEBUG(10, ("parse_share_modes: owrt: %s, "
+ "cwrt: %s, ntok: %u, num_share_modes: %d\n",
+ timestring(talloc_tos(),
+ convert_timespec_to_time_t(lck->old_write_time)),
+ timestring(talloc_tos(),
+ convert_timespec_to_time_t(
+ lck->changed_write_time)),
+ (unsigned int)data.u.s.num_delete_token_entries,
+ lck->num_share_modes));
+
+ if ((lck->num_share_modes < 0) || (lck->num_share_modes > 1000000)) {
+ DEBUG(0, ("invalid number of share modes: %d\n",
+ lck->num_share_modes));
+ smb_panic("parse_share_modes: invalid number of share modes");
+ }
-BOOL share_modes_identical( share_mode_entry *e1, share_mode_entry *e2)
-{
-#if 1 /* JRA PARANOIA TEST - REMOVE LATER */
- if (e1->pid == e2->pid &&
- e1->share_file_id == e2->share_file_id &&
- e1->dev == e2->dev &&
- e1->inode == e2->inode &&
- (e1->share_mode & ~DELETE_ON_CLOSE_FLAG) != (e2->share_mode & ~DELETE_ON_CLOSE_FLAG)) {
- DEBUG(0,("PANIC: share_modes_identical: share_mode missmatch (e1 = %u, e2 = %u). Logic error.\n",
- (unsigned int)(e1->share_mode & ~DELETE_ON_CLOSE_FLAG),
- (unsigned int)(e2->share_mode & ~DELETE_ON_CLOSE_FLAG) ));
- smb_panic("PANIC: share_modes_identical logic error.\n");
- }
-#endif
-
- return (e1->pid == e2->pid &&
- (e1->share_mode & ~DELETE_ON_CLOSE_FLAG) == (e2->share_mode & ~DELETE_ON_CLOSE_FLAG) &&
- e1->dev == e2->dev &&
- e1->inode == e2->inode &&
- e1->share_file_id == e2->share_file_id );
-}
+ lck->share_modes = NULL;
-/*******************************************************************
- Delete a specific share mode. Return the number
- of entries left, and a memdup'ed copy of the entry deleted (if required).
- Ignore if no entry deleted.
-********************************************************************/
+ if (lck->num_share_modes != 0) {
-ssize_t del_share_entry( SMB_DEV_T dev, SMB_INO_T inode,
- share_mode_entry *entry, share_mode_entry **ppse)
-{
- TDB_DATA dbuf;
- struct locking_data *data;
- int i, del_count=0;
- share_mode_entry *shares;
- ssize_t count = 0;
- TDB_DATA key = locking_key(dev, inode);
+ if (dbuf.dsize < (sizeof(struct locking_data) +
+ (lck->num_share_modes *
+ sizeof(struct share_mode_entry)))) {
+ smb_panic("parse_share_modes: buffer too short");
+ }
+
+ lck->share_modes = (struct share_mode_entry *)
+ TALLOC_MEMDUP(lck,
+ dbuf.dptr+sizeof(struct locking_data),
+ lck->num_share_modes *
+ sizeof(struct share_mode_entry));
+
+ if (lck->share_modes == NULL) {
+ smb_panic("parse_share_modes: talloc failed");
+ }
+ }
- if (ppse)
- *ppse = NULL;
+ /* Get any delete tokens. */
+ delete_tokens_size = parse_delete_tokens_list(lck, &data, dbuf);
+ if (delete_tokens_size < 0) {
+ smb_panic("parse_share_modes: parse_delete_tokens_list failed");
+ }
+
+ /* Save off the associated service path and filename. */
+ lck->servicepath = (const char *)dbuf.dptr + sizeof(struct locking_data) +
+ (lck->num_share_modes * sizeof(struct share_mode_entry)) +
+ delete_tokens_size;
- /* read in the existing share modes */
- dbuf = tdb_fetch(tdb, key);
- if (!dbuf.dptr)
- return -1;
+ lck->base_name = (const char *)dbuf.dptr + sizeof(struct locking_data) +
+ (lck->num_share_modes * sizeof(struct share_mode_entry)) +
+ delete_tokens_size +
+ strlen(lck->servicepath) + 1;
- data = (struct locking_data *)dbuf.dptr;
- shares = (share_mode_entry *)(dbuf.dptr + sizeof(*data));
+ lck->stream_name = (const char *)dbuf.dptr + sizeof(struct locking_data) +
+ (lck->num_share_modes * sizeof(struct share_mode_entry)) +
+ delete_tokens_size +
+ strlen(lck->servicepath) + 1 +
+ strlen(lck->base_name) + 1;
/*
- * Find any with this pid and delete it
- * by overwriting with the rest of the data
- * from the record.
+ * Ensure that each entry has a real process attached.
*/
- DEBUG(10,("del_share_entry: num_share_modes = %d\n", data->u.num_share_mode_entries ));
+ for (i = 0; i < lck->num_share_modes; i++) {
+ struct share_mode_entry *entry_p = &lck->share_modes[i];
+ char *str = NULL;
+ if (DEBUGLEVEL >= 10) {
+ str = share_mode_str(NULL, i, entry_p);
+ }
+ DEBUG(10,("parse_share_modes: %s\n",
+ str ? str : ""));
+ if (!serverid_exists(&entry_p->pid)) {
+ DEBUG(10,("parse_share_modes: deleted %s\n",
+ str ? str : ""));
+ entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
+ lck->modified = True;
+ }
+ TALLOC_FREE(str);
+ }
+
+ return True;
+}
+
+static TDB_DATA unparse_share_modes(const struct share_mode_lock *lck)
+{
+ TDB_DATA result;
+ int num_valid = 0;
+ int i;
+ struct locking_data *data;
+ ssize_t offset;
+ ssize_t sp_len, bn_len, sn_len;
+ uint32_t delete_tokens_size = 0;
+ struct delete_token_list *pdtl = NULL;
+ uint32_t num_delete_token_entries = 0;
+
+ result.dptr = NULL;
+ result.dsize = 0;
+
+ for (i=0; i<lck->num_share_modes; i++) {
+ if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
+ num_valid += 1;
+ }
+ }
- for (i=0;i<data->u.num_share_mode_entries;) {
- if (share_modes_identical(&shares[i], entry)) {
- DEBUG(10,("del_share_entry: deleted %s\n",
- share_mode_str(i, &shares[i]) ));
- if (ppse)
- *ppse = memdup(&shares[i], sizeof(*shares));
- data->u.num_share_mode_entries--;
- memmove(&shares[i], &shares[i+1],
- dbuf.dsize - (sizeof(*data) + (i+1)*sizeof(*shares)));
- del_count++;
+ if (num_valid == 0) {
+ return result;
+ }
- DEBUG(10,("del_share_entry: deleting entry %d\n", i ));
+ sp_len = strlen(lck->servicepath);
+ bn_len = strlen(lck->base_name);
+ sn_len = lck->stream_name != NULL ? strlen(lck->stream_name) : 0;
+
+ for (pdtl = lck->delete_tokens; pdtl; pdtl = pdtl->next) {
+ num_delete_token_entries++;
+ delete_tokens_size += (sizeof(uint32_t) +
+ sizeof(uint32_t) +
+ sizeof(uid_t) +
+ sizeof(gid_t) +
+ pdtl->delete_token->ngroups*sizeof(gid_t));
+ }
- } else {
- i++;
+ result.dsize = sizeof(*data) +
+ lck->num_share_modes * sizeof(struct share_mode_entry) +
+ delete_tokens_size +
+ sp_len + 1 +
+ bn_len + 1 +
+ sn_len + 1;
+ result.dptr = talloc_array(lck, uint8, result.dsize);
+
+ if (result.dptr == NULL) {
+ smb_panic("talloc failed");
+ }
+
+ data = (struct locking_data *)result.dptr;
+ ZERO_STRUCTP(data);
+ data->u.s.num_share_mode_entries = lck->num_share_modes;
+ data->u.s.old_write_time = lck->old_write_time;
+ data->u.s.changed_write_time = lck->changed_write_time;
+ data->u.s.num_delete_token_entries = num_delete_token_entries;
+
+ DEBUG(10,("unparse_share_modes: owrt: %s cwrt: %s, ntok: %u, "
+ "num: %d\n",
+ timestring(talloc_tos(),
+ convert_timespec_to_time_t(lck->old_write_time)),
+ timestring(talloc_tos(),
+ convert_timespec_to_time_t(
+ lck->changed_write_time)),
+ (unsigned int)data->u.s.num_delete_token_entries,
+ data->u.s.num_share_mode_entries));
+
+ memcpy(result.dptr + sizeof(*data), lck->share_modes,
+ sizeof(struct share_mode_entry)*lck->num_share_modes);
+ offset = sizeof(*data) +
+ sizeof(struct share_mode_entry)*lck->num_share_modes;
+
+ /* Store any delete on close tokens. */
+ for (pdtl = lck->delete_tokens; pdtl; pdtl = pdtl->next) {
+ struct security_unix_token *pdt = pdtl->delete_token;
+ uint32_t token_size = sizeof(uint32_t) +
+ sizeof(uint32_t) +
+ sizeof(uid_t) +
+ sizeof(gid_t) +
+ (pdt->ngroups * sizeof(gid_t));
+ uint8_t *p = result.dptr + offset;
+
+ memcpy(p, &token_size, sizeof(uint32_t));
+ p += sizeof(uint32_t);
+
+ memcpy(p, &pdtl->name_hash, sizeof(uint32_t));
+ p += sizeof(uint32_t);
+
+ memcpy(p, &pdt->uid, sizeof(uid_t));
+ p += sizeof(uid_t);
+
+ memcpy(p, &pdt->gid, sizeof(gid_t));
+ p += sizeof(gid_t);
+
+ for (i = 0; i < pdt->ngroups; i++) {
+ memcpy(p, &pdt->groups[i], sizeof(gid_t));
+ p += sizeof(gid_t);
}
+ offset += token_size;
}
- if (del_count) {
- /* the record may have shrunk a bit */
- dbuf.dsize -= del_count * sizeof(*shares);
+ strlcpy((char *)result.dptr + offset,
+ lck->servicepath ? lck->servicepath : "",
+ result.dsize - offset);
+ offset += sp_len + 1;
+ strlcpy((char *)result.dptr + offset,
+ lck->base_name ? lck->base_name : "",
+ result.dsize - offset);
+ offset += bn_len + 1;
+ strlcpy((char *)result.dptr + offset,
+ lck->stream_name ? lck->stream_name : "",
+ result.dsize - offset);
+
+ if (DEBUGLEVEL >= 10) {
+ print_share_mode_table(data);
+ }
- count = (ssize_t)data->u.num_share_mode_entries;
+ return result;
+}
- /* store it back in the database */
- if (data->u.num_share_mode_entries == 0) {
- if (tdb_delete(tdb, key) == -1)
- count = -1;
- } else {
- if (tdb_store(tdb, key, dbuf, TDB_REPLACE) == -1)
- count = -1;
+static int share_mode_lock_destructor(struct share_mode_lock *lck)
+{
+ NTSTATUS status;
+ TDB_DATA data;
+
+ if (!lck->modified) {
+ return 0;
+ }
+
+ data = unparse_share_modes(lck);
+
+ if (data.dptr == NULL) {
+ if (!lck->fresh) {
+ /* There has been an entry before, delete it */
+
+ status = lck->record->delete_rec(lck->record);
+ if (!NT_STATUS_IS_OK(status)) {
+ char *errmsg;
+
+ DEBUG(0, ("delete_rec returned %s\n",
+ nt_errstr(status)));
+
+ if (asprintf(&errmsg, "could not delete share "
+ "entry: %s\n",
+ nt_errstr(status)) == -1) {
+ smb_panic("could not delete share"
+ "entry");
+ }
+ smb_panic(errmsg);
+ }
+ }
+ goto done;
+ }
+
+ status = lck->record->store(lck->record, data, TDB_REPLACE);
+ if (!NT_STATUS_IS_OK(status)) {
+ char *errmsg;
+
+ DEBUG(0, ("store returned %s\n", nt_errstr(status)));
+
+ if (asprintf(&errmsg, "could not store share mode entry: %s",
+ nt_errstr(status)) == -1) {
+ smb_panic("could not store share mode entry");
}
+ smb_panic(errmsg);
}
- DEBUG(10,("del_share_entry: Remaining table.\n"));
- print_share_mode_table((struct locking_data *)dbuf.dptr);
- SAFE_FREE(dbuf.dptr);
- return count;
+
+ done:
+
+ return 0;
+}
+
+static bool fill_share_mode_lock(struct share_mode_lock *lck,
+ struct file_id id,
+ const char *servicepath,
+ const struct smb_filename *smb_fname,
+ TDB_DATA share_mode_data,
+ const struct timespec *old_write_time)
+{
+ /* Ensure we set every field here as the destructor must be
+ valid even if parse_share_modes fails. */
+
+ lck->servicepath = NULL;
+ lck->base_name = NULL;
+ lck->stream_name = NULL;
+ lck->id = id;
+ lck->num_share_modes = 0;
+ lck->share_modes = NULL;
+ lck->delete_tokens = NULL;
+ ZERO_STRUCT(lck->old_write_time);
+ ZERO_STRUCT(lck->changed_write_time);
+ lck->fresh = False;
+ lck->modified = False;
+
+ lck->fresh = (share_mode_data.dptr == NULL);
+
+ if (lck->fresh) {
+ bool has_stream;
+ if (smb_fname == NULL || servicepath == NULL
+ || old_write_time == NULL) {
+ return False;
+ }
+
+ has_stream = smb_fname->stream_name != NULL;
+
+ lck->base_name = talloc_strdup(lck, smb_fname->base_name);
+ lck->stream_name = talloc_strdup(lck, smb_fname->stream_name);
+ lck->servicepath = talloc_strdup(lck, servicepath);
+ if (lck->base_name == NULL ||
+ (has_stream && lck->stream_name == NULL) ||
+ lck->servicepath == NULL) {
+ DEBUG(0, ("talloc failed\n"));
+ return False;
+ }
+ lck->old_write_time = *old_write_time;
+ } else {
+ if (!parse_share_modes(share_mode_data, lck)) {
+ DEBUG(0, ("Could not parse share modes\n"));
+ return False;
+ }
+ }
+
+ return True;
+}
+
+struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
+ const struct file_id id,
+ const char *servicepath,
+ const struct smb_filename *smb_fname,
+ const struct timespec *old_write_time)
+{
+ struct share_mode_lock *lck;
+ struct file_id tmp;
+ TDB_DATA key = locking_key(&id, &tmp);
+
+ if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
+ DEBUG(0, ("talloc failed\n"));
+ return NULL;
+ }
+
+ if (!(lck->record = lock_db->fetch_locked(lock_db, lck, key))) {
+ DEBUG(3, ("Could not lock share entry\n"));
+ TALLOC_FREE(lck);
+ return NULL;
+ }
+
+ if (!fill_share_mode_lock(lck, id, servicepath, smb_fname,
+ lck->record->value, old_write_time)) {
+ DEBUG(3, ("fill_share_mode_lock failed\n"));
+ TALLOC_FREE(lck);
+ return NULL;
+ }
+
+ talloc_set_destructor(lck, share_mode_lock_destructor);
+
+ return lck;
+}
+
+struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
+ const struct file_id id)
+{
+ struct share_mode_lock *lck;
+ struct file_id tmp;
+ TDB_DATA key = locking_key(&id, &tmp);
+ TDB_DATA data;
+
+ if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
+ DEBUG(0, ("talloc failed\n"));
+ return NULL;
+ }
+
+ if (lock_db->fetch(lock_db, lck, key, &data) == -1) {
+ DEBUG(3, ("Could not fetch share entry\n"));
+ TALLOC_FREE(lck);
+ return NULL;
+ }
+
+ if (!fill_share_mode_lock(lck, id, NULL, NULL, data, NULL)) {
+ DEBUG(10, ("fetch_share_mode_unlocked: no share_mode record "
+ "around (file not open)\n"));
+ TALLOC_FREE(lck);
+ return NULL;
+ }
+
+ return lck;
}
/*******************************************************************
- Del the share mode of a file for this process. Return the number
- of entries left, and a memdup'ed copy of the entry deleted.
+ Sets the service name and filename for rename.
+ At this point we emit "file renamed" messages to all
+ process id's that have this file open.
+ Based on an initial code idea from SATOH Fumiyasu <fumiya@samba.gr.jp>
********************************************************************/
-ssize_t del_share_mode(files_struct *fsp, share_mode_entry **ppse)
+bool rename_share_filename(struct messaging_context *msg_ctx,
+ struct share_mode_lock *lck,
+ const char *servicepath,
+ uint32_t orig_name_hash,
+ uint32_t new_name_hash,
+ const struct smb_filename *smb_fname_dst)
{
- share_mode_entry entry;
+ size_t sp_len;
+ size_t bn_len;
+ size_t sn_len;
+ size_t msg_len;
+ char *frm = NULL;
+ int i;
+ bool strip_two_chars = false;
+ bool has_stream = smb_fname_dst->stream_name != NULL;
+
+ DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
+ servicepath, smb_fname_dst->base_name));
/*
- * Fake up a share_mode_entry for comparisons.
+ * rename_internal_fsp() and rename_internals() add './' to
+ * head of newname if newname does not contain a '/'.
*/
+ if (smb_fname_dst->base_name[0] &&
+ smb_fname_dst->base_name[1] &&
+ smb_fname_dst->base_name[0] == '.' &&
+ smb_fname_dst->base_name[1] == '/') {
+ strip_two_chars = true;
+ }
+
+ lck->servicepath = talloc_strdup(lck, servicepath);
+ lck->base_name = talloc_strdup(lck, smb_fname_dst->base_name +
+ (strip_two_chars ? 2 : 0));
+ lck->stream_name = talloc_strdup(lck, smb_fname_dst->stream_name);
+ if (lck->base_name == NULL ||
+ (has_stream && lck->stream_name == NULL) ||
+ lck->servicepath == NULL) {
+ DEBUG(0, ("rename_share_filename: talloc failed\n"));
+ return False;
+ }
+ lck->modified = True;
+
+ sp_len = strlen(lck->servicepath);
+ bn_len = strlen(lck->base_name);
+ sn_len = has_stream ? strlen(lck->stream_name) : 0;
+
+ msg_len = MSG_FILE_RENAMED_MIN_SIZE + sp_len + 1 + bn_len + 1 +
+ sn_len + 1;
+
+ /* Set up the name changed message. */
+ frm = talloc_array(lck, char, msg_len);
+ if (!frm) {
+ return False;
+ }
+
+ push_file_id_24(frm, &lck->id);
+
+ DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
+
+ strlcpy(&frm[24],
+ lck->servicepath ? lck->servicepath : "",
+ sp_len+1);
+ strlcpy(&frm[24 + sp_len + 1],
+ lck->base_name ? lck->base_name : "",
+ bn_len+1);
+ strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
+ lck->stream_name ? lck->stream_name : "",
+ sn_len+1);
+
+ /* Send the messages. */
+ for (i=0; i<lck->num_share_modes; i++) {
+ struct share_mode_entry *se = &lck->share_modes[i];
+ if (!is_valid_share_mode_entry(se)) {
+ continue;
+ }
+
+ /* If this is a hardlink to the inode
+ with a different name, skip this. */
+ if (se->name_hash != orig_name_hash) {
+ continue;
+ }
+
+ se->name_hash = new_name_hash;
+
+ /* But not to ourselves... */
+ if (procid_is_me(&se->pid)) {
+ continue;
+ }
+
+ DEBUG(10,("rename_share_filename: sending rename message to "
+ "pid %s file_id %s sharepath %s base_name %s "
+ "stream_name %s\n",
+ procid_str_static(&se->pid),
+ file_id_string_tos(&lck->id),
+ lck->servicepath, lck->base_name,
+ has_stream ? lck->stream_name : ""));
- fill_share_mode((char *)&entry, fsp, 0, 0);
- return del_share_entry(fsp->dev, fsp->inode, &entry, ppse);
+ messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
+ (uint8 *)frm, msg_len);
+ }
+
+ return True;
}
-/*******************************************************************
- Set the share mode of a file. Return False on fail, True on success.
-********************************************************************/
+void get_file_infos(struct file_id id,
+ uint32_t name_hash,
+ bool *delete_on_close,
+ struct timespec *write_time)
+{
+ struct share_mode_lock *lck;
+
+ if (delete_on_close) {
+ *delete_on_close = false;
+ }
+
+ if (write_time) {
+ ZERO_STRUCTP(write_time);
+ }
+
+ if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
+ return;
+ }
+
+ if (delete_on_close) {
+ *delete_on_close = is_delete_on_close_set(lck, name_hash);
+ }
-BOOL set_share_mode(files_struct *fsp, uint16 port, uint16 op_type)
+ if (write_time) {
+ struct timespec wt;
+
+ wt = lck->changed_write_time;
+ if (null_timespec(wt)) {
+ wt = lck->old_write_time;
+ }
+
+ *write_time = wt;
+ }
+
+ TALLOC_FREE(lck);
+}
+
+bool is_valid_share_mode_entry(const struct share_mode_entry *e)
{
- TDB_DATA dbuf;
- struct locking_data *data;
- char *p=NULL;
- int size;
- TDB_DATA key = locking_key_fsp(fsp);
- BOOL ret = True;
-
- /* read in the existing share modes if any */
- dbuf = tdb_fetch(tdb, key);
- if (!dbuf.dptr) {
- size_t offset;
- /* we'll need to create a new record */
- pstring fname;
-
- pstrcpy(fname, fsp->conn->connectpath);
- pstrcat(fname, "/");
- pstrcat(fname, fsp->fsp_name);
-
- size = sizeof(*data) + sizeof(share_mode_entry) + strlen(fname) + 1;
- p = (char *)malloc(size);
- if (!p)
- return False;
- data = (struct locking_data *)p;
- data->u.num_share_mode_entries = 1;
-
- DEBUG(10,("set_share_mode: creating entry for file %s. num_share_modes = 1\n",
- fsp->fsp_name ));
-
- offset = sizeof(*data) + sizeof(share_mode_entry);
- safe_strcpy(p + offset, fname, size - offset - 1);
- fill_share_mode(p + sizeof(*data), fsp, port, op_type);
- dbuf.dptr = p;
- dbuf.dsize = size;
- if (tdb_store(tdb, key, dbuf, TDB_REPLACE) == -1)
- ret = False;
-
- print_share_mode_table((struct locking_data *)p);
-
- SAFE_FREE(p);
- return ret;
- }
-
- /* we're adding to an existing entry - this is a bit fiddly */
- data = (struct locking_data *)dbuf.dptr;
-
- data->u.num_share_mode_entries++;
-
- DEBUG(10,("set_share_mode: adding entry for file %s. new num_share_modes = %d\n",
- fsp->fsp_name, data->u.num_share_mode_entries ));
-
- size = dbuf.dsize + sizeof(share_mode_entry);
- p = malloc(size);
- if (!p) {
- SAFE_FREE(dbuf.dptr);
+ int num_props = 0;
+
+ if (e->op_type == UNUSED_SHARE_MODE_ENTRY) {
+ /* cope with dead entries from the process not
+ existing. These should not be considered valid,
+ otherwise we end up doing zero timeout sharing
+ violation */
return False;
}
- memcpy(p, dbuf.dptr, sizeof(*data));
- fill_share_mode(p + sizeof(*data), fsp, port, op_type);
- memcpy(p + sizeof(*data) + sizeof(share_mode_entry), dbuf.dptr + sizeof(*data),
- dbuf.dsize - sizeof(*data));
- SAFE_FREE(dbuf.dptr);
- dbuf.dptr = p;
- dbuf.dsize = size;
- if (tdb_store(tdb, key, dbuf, TDB_REPLACE) == -1)
- ret = False;
- print_share_mode_table((struct locking_data *)p);
- SAFE_FREE(p);
- return ret;
+
+ num_props += ((e->op_type == NO_OPLOCK) ? 1 : 0);
+ num_props += (EXCLUSIVE_OPLOCK_TYPE(e->op_type) ? 1 : 0);
+ num_props += (LEVEL_II_OPLOCK_TYPE(e->op_type) ? 1 : 0);
+
+ SMB_ASSERT(num_props <= 1);
+ return (num_props != 0);
+}
+
+bool is_deferred_open_entry(const struct share_mode_entry *e)
+{
+ return (e->op_type == DEFERRED_OPEN_ENTRY);
+}
+
+bool is_unused_share_mode_entry(const struct share_mode_entry *e)
+{
+ return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
}
/*******************************************************************
- A generic in-place modification call for share mode entries.
+ Fill a share mode entry.
********************************************************************/
-static BOOL mod_share_mode( SMB_DEV_T dev, SMB_INO_T inode, share_mode_entry *entry,
- void (*mod_fn)(share_mode_entry *, SMB_DEV_T, SMB_INO_T, void *),
- void *param)
+static void fill_share_mode_entry(struct share_mode_entry *e,
+ files_struct *fsp,
+ uid_t uid, uint64_t mid, uint16 op_type)
{
- TDB_DATA dbuf;
- struct locking_data *data;
- int i;
- share_mode_entry *shares;
- BOOL need_store=False;
- BOOL ret = True;
- TDB_DATA key = locking_key(dev, inode);
-
- /* read in the existing share modes */
- dbuf = tdb_fetch(tdb, key);
- if (!dbuf.dptr)
- return False;
+ ZERO_STRUCTP(e);
+ e->pid = sconn_server_id(fsp->conn->sconn);
+ e->share_access = fsp->share_access;
+ e->private_options = fsp->fh->private_options;
+ e->access_mask = fsp->access_mask;
+ e->op_mid = mid;
+ e->op_type = op_type;
+ e->time.tv_sec = fsp->open_time.tv_sec;
+ e->time.tv_usec = fsp->open_time.tv_usec;
+ e->id = fsp->file_id;
+ e->share_file_id = fsp->fh->gen_id;
+ e->uid = (uint32)uid;
+ e->flags = fsp->posix_open ? SHARE_MODE_FLAG_POSIX_OPEN : 0;
+ e->name_hash = fsp->name_hash;
+}
- data = (struct locking_data *)dbuf.dptr;
- shares = (share_mode_entry *)(dbuf.dptr + sizeof(*data));
+static void fill_deferred_open_entry(struct share_mode_entry *e,
+ const struct timeval request_time,
+ struct file_id id,
+ struct server_id pid,
+ uint64_t mid)
+{
+ ZERO_STRUCTP(e);
+ e->pid = pid;
+ e->op_mid = mid;
+ e->op_type = DEFERRED_OPEN_ENTRY;
+ e->time.tv_sec = request_time.tv_sec;
+ e->time.tv_usec = request_time.tv_usec;
+ e->id = id;
+ e->uid = (uint32)-1;
+ e->flags = 0;
+}
- /* find any with our pid and call the supplied function */
- for (i=0;i<data->u.num_share_mode_entries;i++) {
- if (share_modes_identical(entry, &shares[i])) {
- mod_fn(&shares[i], dev, inode, param);
- need_store=True;
+static void add_share_mode_entry(struct share_mode_lock *lck,
+ const struct share_mode_entry *entry)
+{
+ int i;
+
+ for (i=0; i<lck->num_share_modes; i++) {
+ struct share_mode_entry *e = &lck->share_modes[i];
+ if (is_unused_share_mode_entry(e)) {
+ *e = *entry;
+ break;
}
}
- /* if the mod fn was called then store it back */
- if (need_store) {
- if (data->u.num_share_mode_entries == 0) {
- if (tdb_delete(tdb, key) == -1)
- ret = False;
- } else {
- if (tdb_store(tdb, key, dbuf, TDB_REPLACE) == -1)
- ret = False;
- }
+ if (i == lck->num_share_modes) {
+ /* No unused entry found */
+ ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
+ &lck->share_modes, &lck->num_share_modes);
}
+ lck->modified = True;
+}
- SAFE_FREE(dbuf.dptr);
- return ret;
+void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
+ uid_t uid, uint64_t mid, uint16 op_type)
+{
+ struct share_mode_entry entry;
+ fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
+ add_share_mode_entry(lck, &entry);
+}
+
+void add_deferred_open(struct share_mode_lock *lck, uint64_t mid,
+ struct timeval request_time,
+ struct server_id pid, struct file_id id)
+{
+ struct share_mode_entry entry;
+ fill_deferred_open_entry(&entry, request_time, id, pid, mid);
+ add_share_mode_entry(lck, &entry);
}
/*******************************************************************
- Static function that actually does the work for the generic function
- below.
+ Check if two share mode entries are identical, ignoring oplock
+ and mid info and desired_access. (Removed paranoia test - it's
+ not automatically a logic error if they are identical. JRA.)
********************************************************************/
-static void remove_share_oplock_fn(share_mode_entry *entry, SMB_DEV_T dev, SMB_INO_T inode,
- void *param)
+static bool share_modes_identical(struct share_mode_entry *e1,
+ struct share_mode_entry *e2)
+{
+ /* We used to check for e1->share_access == e2->share_access here
+ as well as the other fields but 2 different DOS or FCB opens
+ sharing the same share mode entry may validly differ in
+ fsp->share_access field. */
+
+ return (procid_equal(&e1->pid, &e2->pid) &&
+ file_id_equal(&e1->id, &e2->id) &&
+ e1->share_file_id == e2->share_file_id );
+}
+
+static bool deferred_open_identical(struct share_mode_entry *e1,
+ struct share_mode_entry *e2)
{
- DEBUG(10,("remove_share_oplock_fn: removing oplock info for entry dev=%x ino=%.0f\n",
- (unsigned int)dev, (double)inode ));
- /* Delete the oplock info. */
- entry->op_port = 0;
- entry->op_type = NO_OPLOCK;
+ return (procid_equal(&e1->pid, &e2->pid) &&
+ (e1->op_mid == e2->op_mid) &&
+ file_id_equal(&e1->id, &e2->id));
+}
+
+static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
+ struct share_mode_entry *entry)
+{
+ int i;
+
+ for (i=0; i<lck->num_share_modes; i++) {
+ struct share_mode_entry *e = &lck->share_modes[i];
+ if (is_valid_share_mode_entry(entry) &&
+ is_valid_share_mode_entry(e) &&
+ share_modes_identical(e, entry)) {
+ return e;
+ }
+ if (is_deferred_open_entry(entry) &&
+ is_deferred_open_entry(e) &&
+ deferred_open_identical(e, entry)) {
+ return e;
+ }
+ }
+ return NULL;
}
/*******************************************************************
- Remove an oplock port and mode entry from a share mode.
+ Del the share mode of a file for this process. Return the number of
+ entries left.
********************************************************************/
-BOOL remove_share_oplock(files_struct *fsp)
+bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
{
- share_mode_entry entry;
- /*
- * Fake up an entry for comparisons...
- */
- fill_share_mode((char *)&entry, fsp, 0, 0);
- return mod_share_mode(fsp->dev, fsp->inode, &entry, remove_share_oplock_fn, NULL);
+ struct share_mode_entry entry, *e;
+
+ /* Don't care about the pid owner being correct here - just a search. */
+ fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
+
+ e = find_share_mode_entry(lck, &entry);
+ if (e == NULL) {
+ return False;
+ }
+
+ e->op_type = UNUSED_SHARE_MODE_ENTRY;
+ lck->modified = True;
+ return True;
+}
+
+void del_deferred_open_entry(struct share_mode_lock *lck, uint64_t mid,
+ struct server_id pid)
+{
+ struct share_mode_entry entry, *e;
+
+ fill_deferred_open_entry(&entry, timeval_zero(),
+ lck->id, pid, mid);
+
+ e = find_share_mode_entry(lck, &entry);
+ if (e == NULL) {
+ return;
+ }
+
+ e->op_type = UNUSED_SHARE_MODE_ENTRY;
+ lck->modified = True;
}
/*******************************************************************
- Static function that actually does the work for the generic function
- below.
+ Remove an oplock mid and mode entry from a share mode.
********************************************************************/
-static void downgrade_share_oplock_fn(share_mode_entry *entry, SMB_DEV_T dev, SMB_INO_T inode,
- void *param)
+bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
{
- DEBUG(10,("downgrade_share_oplock_fn: downgrading oplock info for entry dev=%x ino=%.0f\n",
- (unsigned int)dev, (double)inode ));
- entry->op_type = LEVEL_II_OPLOCK;
+ struct share_mode_entry entry, *e;
+
+ /* Don't care about the pid owner being correct here - just a search. */
+ fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
+
+ e = find_share_mode_entry(lck, &entry);
+ if (e == NULL) {
+ return False;
+ }
+
+ if (EXCLUSIVE_OPLOCK_TYPE(e->op_type)) {
+ /*
+ * Going from exclusive or batch,
+ * we always go through FAKE_LEVEL_II
+ * first.
+ */
+ if (!EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
+ smb_panic("remove_share_oplock: logic error");
+ }
+ e->op_type = FAKE_LEVEL_II_OPLOCK;
+ } else {
+ e->op_type = NO_OPLOCK;
+ }
+ lck->modified = True;
+ return True;
}
/*******************************************************************
Downgrade a oplock type from exclusive to level II.
********************************************************************/
-BOOL downgrade_share_oplock(files_struct *fsp)
+bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
{
- share_mode_entry entry;
+ struct share_mode_entry entry, *e;
+
+ /* Don't care about the pid owner being correct here - just a search. */
+ fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
+
+ e = find_share_mode_entry(lck, &entry);
+ if (e == NULL) {
+ return False;
+ }
+
+ e->op_type = LEVEL_II_OPLOCK;
+ lck->modified = True;
+ return True;
+}
+
+/****************************************************************************
+ Check if setting delete on close is allowed on this fsp.
+****************************************************************************/
+
+NTSTATUS can_set_delete_on_close(files_struct *fsp, uint32 dosmode)
+{
+ /*
+ * Only allow delete on close for writable files.
+ */
+
+ if ((dosmode & FILE_ATTRIBUTE_READONLY) &&
+ !lp_delete_readonly(SNUM(fsp->conn))) {
+ DEBUG(10,("can_set_delete_on_close: file %s delete on close "
+ "flag set but file attribute is readonly.\n",
+ fsp_str_dbg(fsp)));
+ return NT_STATUS_CANNOT_DELETE;
+ }
+
/*
- * Fake up an entry for comparisons...
+ * Only allow delete on close for writable shares.
*/
- fill_share_mode((char *)&entry, fsp, 0, 0);
- return mod_share_mode(fsp->dev, fsp->inode, &entry, downgrade_share_oplock_fn, NULL);
+
+ if (!CAN_WRITE(fsp->conn)) {
+ DEBUG(10,("can_set_delete_on_close: file %s delete on "
+ "close flag set but write access denied on share.\n",
+ fsp_str_dbg(fsp)));
+ return NT_STATUS_ACCESS_DENIED;
+ }
+
+ /*
+ * Only allow delete on close for files/directories opened with delete
+ * intent.
+ */
+
+ if (!(fsp->access_mask & DELETE_ACCESS)) {
+ DEBUG(10,("can_set_delete_on_close: file %s delete on "
+ "close flag set but delete access denied.\n",
+ fsp_str_dbg(fsp)));
+ return NT_STATUS_ACCESS_DENIED;
+ }
+
+ /* Don't allow delete on close for non-empty directories. */
+ if (fsp->is_directory) {
+ SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
+ return can_delete_directory(fsp->conn,
+ fsp->fsp_name->base_name);
+ }
+
+ return NT_STATUS_OK;
}
-/*******************************************************************
- Get/Set the delete on close flag in a set of share modes.
- Return False on fail, True on success.
-********************************************************************/
+/*************************************************************************
+ Return a talloced copy of a struct security_unix_token. NULL on fail.
+ (Should this be in locking.c.... ?).
+*************************************************************************/
-BOOL modify_delete_flag( SMB_DEV_T dev, SMB_INO_T inode, BOOL delete_on_close)
+static struct security_unix_token *copy_unix_token(TALLOC_CTX *ctx, const struct security_unix_token *tok)
{
- TDB_DATA dbuf;
- struct locking_data *data;
- int i;
- share_mode_entry *shares;
- TDB_DATA key = locking_key(dev, inode);
+ struct security_unix_token *cpy;
+
+ cpy = TALLOC_P(ctx, struct security_unix_token);
+ if (!cpy) {
+ return NULL;
+ }
+
+ cpy->uid = tok->uid;
+ cpy->gid = tok->gid;
+ cpy->ngroups = tok->ngroups;
+ if (tok->ngroups) {
+ /* Make this a talloc child of cpy. */
+ cpy->groups = (gid_t *)talloc_memdup(
+ cpy, tok->groups, tok->ngroups * sizeof(gid_t));
+ if (!cpy->groups) {
+ TALLOC_FREE(cpy);
+ return NULL;
+ }
+ }
+ return cpy;
+}
+
+/****************************************************************************
+ Adds a delete on close token.
+****************************************************************************/
+
+static bool add_delete_on_close_token(struct share_mode_lock *lck,
+ uint32_t name_hash,
+ const struct security_unix_token *tok)
+{
+ struct delete_token_list *dtl;
+
+ dtl = TALLOC_ZERO_P(lck, struct delete_token_list);
+ if (dtl == NULL) {
+ return false;
+ }
+
+ dtl->name_hash = name_hash;
+ dtl->delete_token = copy_unix_token(lck, tok);
+ if (dtl->delete_token == NULL) {
+ TALLOC_FREE(dtl);
+ return false;
+ }
+ DLIST_ADD(lck->delete_tokens, dtl);
+ lck->modified = true;
+ return true;
+}
+
+/****************************************************************************
+ Sets the delete on close flag over all share modes on this file.
+ Modify the share mode entry for all files open
+ on this device and inode to tell other smbds we have
+ changed the delete on close flag. This will be noticed
+ in the close code, the last closer will delete the file
+ if flag is set.
+ This makes a copy of any struct security_unix_token into the
+ lck entry. This function is used when the lock is already granted.
+****************************************************************************/
+
+void set_delete_on_close_lck(files_struct *fsp,
+ struct share_mode_lock *lck,
+ bool delete_on_close,
+ const struct security_unix_token *tok)
+{
+ struct delete_token_list *dtl;
+ bool ret;
- /* read in the existing share modes */
- dbuf = tdb_fetch(tdb, key);
- if (!dbuf.dptr)
+ if (delete_on_close) {
+ SMB_ASSERT(tok != NULL);
+ } else {
+ SMB_ASSERT(tok == NULL);
+ }
+
+ for (dtl = lck->delete_tokens; dtl; dtl = dtl->next) {
+ if (dtl->name_hash == fsp->name_hash) {
+ lck->modified = true;
+ if (delete_on_close == false) {
+ /* Delete this entry. */
+ DLIST_REMOVE(lck->delete_tokens, dtl);
+ TALLOC_FREE(dtl);
+ return;
+ }
+ /* Replace this token with the
+ given tok. */
+ TALLOC_FREE(dtl->delete_token);
+ dtl->delete_token = copy_unix_token(dtl, tok);
+ SMB_ASSERT(dtl->delete_token != NULL);
+ }
+ }
+
+ if (!delete_on_close) {
+ /* Nothing to delete - not found. */
+ return;
+ }
+
+ ret = add_delete_on_close_token(lck, fsp->name_hash, tok);
+ SMB_ASSERT(ret);
+}
+
+bool set_delete_on_close(files_struct *fsp, bool delete_on_close, const struct security_unix_token *tok)
+{
+ struct share_mode_lock *lck;
+
+ DEBUG(10,("set_delete_on_close: %s delete on close flag for "
+ "fnum = %d, file %s\n",
+ delete_on_close ? "Adding" : "Removing", fsp->fnum,
+ fsp_str_dbg(fsp)));
+
+ lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
+ NULL);
+ if (lck == NULL) {
return False;
+ }
- data = (struct locking_data *)dbuf.dptr;
- shares = (share_mode_entry *)(dbuf.dptr + sizeof(*data));
+ set_delete_on_close_lck(fsp, lck, delete_on_close,
+ delete_on_close ? tok : NULL);
- /* Set/Unset the delete on close element. */
- for (i=0;i<data->u.num_share_mode_entries;i++,shares++) {
- shares->share_mode = (delete_on_close ?
- (shares->share_mode | DELETE_ON_CLOSE_FLAG) :
- (shares->share_mode & ~DELETE_ON_CLOSE_FLAG) );
+ if (fsp->is_directory) {
+ SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
+ send_stat_cache_delete_message(fsp->conn->sconn->msg_ctx,
+ fsp->fsp_name->base_name);
}
- /* store it back */
- if (data->u.num_share_mode_entries) {
- if (tdb_store(tdb, key, dbuf, TDB_REPLACE)==-1) {
- SAFE_FREE(dbuf.dptr);
- return False;
+ TALLOC_FREE(lck);
+
+ fsp->delete_on_close = delete_on_close;
+
+ return True;
+}
+
+const struct security_unix_token *get_delete_on_close_token(struct share_mode_lock *lck, uint32_t name_hash)
+{
+ struct delete_token_list *dtl;
+
+ DEBUG(10,("get_delete_on_close_token: name_hash = 0x%x\n",
+ (unsigned int)name_hash ));
+
+ for (dtl = lck->delete_tokens; dtl; dtl = dtl->next) {
+ DEBUG(10,("get_delete_on_close_token: dtl->name_hash = 0x%x\n",
+ (unsigned int)dtl->name_hash ));
+ if (dtl->name_hash == name_hash) {
+ return dtl->delete_token;
}
}
+ return NULL;
+}
- SAFE_FREE(dbuf.dptr);
+bool is_delete_on_close_set(struct share_mode_lock *lck, uint32_t name_hash)
+{
+ return (get_delete_on_close_token(lck, name_hash) != NULL);
+}
+
+bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
+{
+ struct share_mode_lock *lck;
+
+ DEBUG(5,("set_sticky_write_time: %s id=%s\n",
+ timestring(talloc_tos(),
+ convert_timespec_to_time_t(write_time)),
+ file_id_string_tos(&fileid)));
+
+ lck = get_share_mode_lock(NULL, fileid, NULL, NULL, NULL);
+ if (lck == NULL) {
+ return False;
+ }
+
+ if (timespec_compare(&lck->changed_write_time, &write_time) != 0) {
+ lck->modified = True;
+ lck->changed_write_time = write_time;
+ }
+
+ TALLOC_FREE(lck);
return True;
}
-/****************************************************************************
- Traverse the whole database with this function, calling traverse_callback
- on each share mode
-****************************************************************************/
+bool set_write_time(struct file_id fileid, struct timespec write_time)
+{
+ struct share_mode_lock *lck;
+
+ DEBUG(5,("set_write_time: %s id=%s\n",
+ timestring(talloc_tos(),
+ convert_timespec_to_time_t(write_time)),
+ file_id_string_tos(&fileid)));
+
+ lck = get_share_mode_lock(NULL, fileid, NULL, NULL, NULL);
+ if (lck == NULL) {
+ return False;
+ }
-static int traverse_fn(TDB_CONTEXT *the_tdb, TDB_DATA kbuf, TDB_DATA dbuf,
- void* state)
+ if (timespec_compare(&lck->old_write_time, &write_time) != 0) {
+ lck->modified = True;
+ lck->old_write_time = write_time;
+ }
+
+ TALLOC_FREE(lck);
+ return True;
+}
+
+
+struct forall_state {
+ void (*fn)(const struct share_mode_entry *entry,
+ const char *sharepath,
+ const char *fname,
+ void *private_data);
+ void *private_data;
+};
+
+static int traverse_fn(struct db_record *rec, void *_state)
{
+ struct forall_state *state = (struct forall_state *)_state;
struct locking_data *data;
- share_mode_entry *shares;
- char *name;
+ struct share_mode_entry *shares;
+ const char *sharepath;
+ const char *fname;
+ const char *del_tokens;
+ uint32_t total_del_token_size = 0;
int i;
- SHAREMODE_FN(traverse_callback) = (SHAREMODE_FN_CAST())state;
+ /* Ensure this is a locking_key record. */
+ if (rec->key.dsize != sizeof(struct file_id))
+ return 0;
+
+ data = (struct locking_data *)rec->value.dptr;
+ shares = (struct share_mode_entry *)(rec->value.dptr + sizeof(*data));
+ del_tokens = (const char *)rec->value.dptr + sizeof(*data) +
+ data->u.s.num_share_mode_entries*sizeof(*shares);
- data = (struct locking_data *)dbuf.dptr;
- shares = (share_mode_entry *)(dbuf.dptr + sizeof(*data));
- name = dbuf.dptr + sizeof(*data) + data->u.num_share_mode_entries*sizeof(*shares);
+ for (i = 0; i < data->u.s.num_delete_token_entries; i++) {
+ uint32_t del_token_size;
+ memcpy(&del_token_size, del_tokens, sizeof(uint32_t));
+ total_del_token_size += del_token_size;
+ del_tokens += del_token_size;
+ }
- for (i=0;i<data->u.num_share_mode_entries;i++) {
- traverse_callback(&shares[i], name);
+ sharepath = (const char *)rec->value.dptr + sizeof(*data) +
+ data->u.s.num_share_mode_entries*sizeof(*shares) +
+ total_del_token_size;
+ fname = (const char *)rec->value.dptr + sizeof(*data) +
+ data->u.s.num_share_mode_entries*sizeof(*shares) +
+ total_del_token_size +
+ strlen(sharepath) + 1;
+
+ for (i=0;i<data->u.s.num_share_mode_entries;i++) {
+ state->fn(&shares[i], sharepath, fname,
+ state->private_data);
}
return 0;
}
share mode system.
********************************************************************/
-int share_mode_forall(SHAREMODE_FN(fn))
+int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
+ const char *, void *),
+ void *private_data)
{
- if (!tdb)
+ struct forall_state state;
+
+ if (lock_db == NULL)
return 0;
- return tdb_traverse(tdb, traverse_fn, (void*)fn);
+
+ state.fn = fn;
+ state.private_data = private_data;
+
+ return lock_db->traverse_read(lock_db, traverse_fn, (void *)&state);
}
git.samba.org / samba.git / blobdiff