September 1997. Jeremy Allison (jallison@whistle.com). Added oplock
support.
- rewrtten completely to use new tdb code. Tridge, Dec '99
+ rewritten 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"
#include "system/filesys.h"
+#include "lib/util/server_id.h"
#include "locking/proto.h"
#include "smbd/globals.h"
#include "dbwrap/dbwrap.h"
#include "serverid.h"
#include "messages.h"
#include "util_tdb.h"
+#include "../librpc/gen_ndr/ndr_open_files.h"
+#include "librpc/gen_ndr/ndr_file_id.h"
+#include "locking/leases_db.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_LOCKING
#define NO_LOCKING_COUNT (-1)
-/* the locking database handle */
-static struct db_context *lock_db;
-
/****************************************************************************
Debugging aids :-).
****************************************************************************/
plock->context.smblctx = smblctx;
plock->context.tid = fsp->conn->cnum;
- plock->context.pid = sconn_server_id(fsp->conn->sconn);
+ plock->context.pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
plock->start = start;
plock->size = size;
plock->fnum = fsp->fnum;
plock->lock_flav = lp_posix_cifsu_locktype(fsp);
}
-bool strict_lock_default(files_struct *fsp, struct lock_struct *plock)
+bool strict_lock_check_default(files_struct *fsp, struct lock_struct *plock)
{
+ struct byte_range_lock *br_lck;
int strict_locking = lp_strict_locking(fsp->conn->params);
bool ret = False;
}
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;
-
- 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);
+ uint32_t lease_type = fsp_lease_type(fsp);
+
+ if ((lease_type & SMB2_LEASE_READ) &&
+ (plock->lock_type == READ_LOCK))
+ {
+ DBG_DEBUG("optimisation - read lease on file %s\n",
+ fsp_str_dbg(fsp));
+ return true;
}
- } else {
- struct byte_range_lock *br_lck;
- br_lck = brl_get_locks_readonly(fsp);
- if (!br_lck) {
- return True;
+ if ((lease_type & SMB2_LEASE_WRITE) &&
+ (plock->lock_type == WRITE_LOCK))
+ {
+ DBG_DEBUG("optimisation - write lease on file %s\n",
+ fsp_str_dbg(fsp));
+ 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;
-}
+ br_lck = brl_get_locks_readonly(fsp);
+ if (!br_lck) {
+ return true;
+ }
+ ret = brl_locktest(br_lck, plock);
-void strict_unlock_default(files_struct *fsp, struct lock_struct *plock)
-{
+ if (!ret) {
+ /*
+ * We got a lock conflict. Retry with rw locks to enable
+ * autocleanup. This is the slow path anyway.
+ */
+ br_lck = brl_get_locks(talloc_tos(), fsp);
+ if (br_lck == NULL) {
+ return true;
+ }
+ ret = brl_locktest(br_lck, plock);
+ TALLOC_FREE(br_lck);
+ }
+
+ DEBUG(10, ("strict_lock_default: flavour = %s brl start=%ju "
+ "len=%ju %s for fnum %ju file %s\n",
+ lock_flav_name(plock->lock_flav),
+ (uintmax_t)plock->start, (uintmax_t)plock->size,
+ ret ? "unlocked" : "locked",
+ (uintmax_t)plock->fnum, fsp_str_dbg(fsp)));
+
+ return ret;
}
/****************************************************************************
return brl_lockquery(br_lck,
psmblctx,
- sconn_server_id(fsp->conn->sconn),
+ messaging_server_id(fsp->conn->sconn->msg_ctx),
poffset,
pcount,
plock_type,
enum brl_flavour lock_flav,
bool blocking_lock,
NTSTATUS *perr,
- uint64_t *psmblctx,
- struct blocking_lock_record *blr)
+ uint64_t *psmblctx)
{
struct byte_range_lock *br_lck = NULL;
/* NOTE! 0 byte long ranges ARE allowed and should be stored */
- DEBUG(10,("do_lock: lock flavour %s lock type %s start=%.0f len=%.0f "
- "blocking_lock=%s requested for fnum %d file %s\n",
+ DEBUG(10,("do_lock: lock flavour %s lock type %s start=%ju len=%ju "
+ "blocking_lock=%s requested for %s 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)));
+ (uintmax_t)offset, (uintmax_t)count, blocking_lock ? "true" :
+ "false", fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
br_lck = brl_get_locks(talloc_tos(), fsp);
if (!br_lck) {
*perr = brl_lock(msg_ctx,
br_lck,
smblctx,
- sconn_server_id(fsp->conn->sconn),
+ messaging_server_id(fsp->conn->sconn->msg_ctx),
offset,
count,
lock_type,
lock_flav,
blocking_lock,
- psmblctx,
- blr);
+ psmblctx);
DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
return NT_STATUS_OK;
}
- 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)));
+ DEBUG(10, ("do_unlock: unlock start=%ju len=%ju requested for %s file "
+ "%s\n", (uintmax_t)offset, (uintmax_t)count,
+ fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
br_lck = brl_get_locks(talloc_tos(), fsp);
if (!br_lck) {
ok = brl_unlock(msg_ctx,
br_lck,
smblctx,
- sconn_server_id(fsp->conn->sconn),
+ messaging_server_id(fsp->conn->sconn->msg_ctx),
offset,
count,
lock_flav);
****************************************************************************/
NTSTATUS do_lock_cancel(files_struct *fsp,
- uint64 smblctx,
+ uint64_t smblctx,
uint64_t count,
uint64_t offset,
- enum brl_flavour lock_flav,
- struct blocking_lock_record *blr)
+ enum brl_flavour lock_flav)
{
bool ok = False;
struct byte_range_lock *br_lck = NULL;
return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
}
- 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)));
+ DEBUG(10, ("do_lock_cancel: cancel start=%ju len=%ju requested for "
+ "%s file %s\n", (uintmax_t)offset, (uintmax_t)count,
+ fsp_fnum_dbg(fsp), fsp_str_dbg(fsp)));
br_lck = brl_get_locks(talloc_tos(), fsp);
if (!br_lck) {
ok = brl_lock_cancel(br_lck,
smblctx,
- sconn_server_id(fsp->conn->sconn),
+ messaging_server_id(fsp->conn->sconn->msg_ctx),
offset,
count,
- lock_flav,
- blr);
+ lock_flav);
TALLOC_FREE(br_lck);
return;
}
- /* If we have not outstanding locks or pending
+ /* If we have no outstanding locks or pending
* locks then we don't need to look in the lock db.
*/
}
}
-/****************************************************************************
- Initialise the locking functions.
-****************************************************************************/
-
-static bool locking_init_internal(bool read_only)
-{
- brl_init(read_only);
-
- if (lock_db)
- return True;
-
- 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);
-
- if (!lock_db) {
- DEBUG(0,("ERROR: Failed to initialise locking database\n"));
- return False;
- }
-
- if (!posix_locking_init(read_only))
- return False;
-
- return True;
-}
-
-bool locking_init(void)
-{
- return locking_init_internal(false);
-}
-
-bool locking_init_readonly(void)
-{
- return locking_init_internal(true);
-}
-
-/*******************************************************************
- Deinitialize the share_mode management.
-******************************************************************/
-
-bool locking_end(void)
-{
- brl_shutdown();
- TALLOC_FREE(lock_db);
- return true;
-}
-
-/*******************************************************************
- Form a static locking key for a dev/inode pair.
-******************************************************************/
-
-static TDB_DATA locking_key(const struct file_id *id, struct file_id *tmp)
-{
- *tmp = *id;
- return make_tdb_data((const uint8_t *)tmp, sizeof(*tmp));
-}
-
/*******************************************************************
Print out a share mode.
********************************************************************/
-char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
+char *share_mode_str(TALLOC_CTX *ctx, int num,
+ const struct file_id *id,
+ const struct share_mode_entry *e)
{
- return talloc_asprintf(ctx, "share_mode_entry[%d]: %s "
+ struct server_id_buf tmp;
+
+ return talloc_asprintf(ctx, "share_mode_entry[%d]: "
"pid = %s, share_access = 0x%x, private_options = 0x%x, "
- "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %lu, "
+ "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %llu, "
"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),
+ server_id_str_buf(e->pid, &tmp),
e->share_access, e->private_options,
e->access_mask, (unsigned long long)e->op_mid,
- e->op_type, e->share_file_id,
+ e->op_type, (unsigned long long)e->share_file_id,
(unsigned int)e->uid, (unsigned int)e->flags,
- file_id_string_tos(&e->id),
+ file_id_string_tos(id),
(unsigned int)e->name_hash);
}
/*******************************************************************
- Print out a share mode table.
-********************************************************************/
-
-static void print_share_mode_table(struct locking_data *data)
-{
- 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++) {
- 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);
- }
-}
-
-static int parse_delete_tokens_list(struct share_mode_lock *lck,
- struct locking_data *pdata,
- const TDB_DATA dbuf)
-{
- 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;
-
- lck->num_delete_tokens = 0;
- lck->delete_tokens = NULL;
-
- for (i = 0; i < pdata->u.s.num_delete_token_entries; i++) {
- uint32_t token_len;
- struct delete_token *pdt;
-
- 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;
- }
-
- memcpy(&token_len, p, sizeof(token_len));
- delete_tokens_size += token_len;
-
- if (p + token_len > end_ptr || token_len < sizeof(token_len) +
- sizeof(pdt->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;
- }
-
- p += sizeof(token_len);
-
- lck->delete_tokens = talloc_realloc(
- lck, lck->delete_tokens, struct delete_token,
- lck->num_delete_tokens+1);
-
- if (lck->delete_tokens == NULL) {
- DEBUG(0, ("parse_delete_tokens_list: talloc failed"));
- return -1;
- }
- pdt = &lck->delete_tokens[lck->num_delete_tokens];
-
- /* Copy out the name_hash. */
- memcpy(&pdt->name_hash, p, sizeof(pdt->name_hash));
- p += sizeof(pdt->name_hash);
-
- pdt->delete_token = talloc_zero(
- lck->delete_tokens, struct security_unix_token);
- if (pdt->delete_token == NULL) {
- DEBUG(0,("parse_delete_tokens_list: talloc failed"));
- return -1;
- }
-
- /* Copy out the uid and gid. */
- memcpy(&pdt->delete_token->uid, p, sizeof(uid_t));
- p += sizeof(uid_t);
- memcpy(&pdt->delete_token->gid, p, sizeof(gid_t));
- p += sizeof(gid_t);
-
- token_len -= (sizeof(token_len) + sizeof(pdt->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;
- }
-
- pdt->delete_token->ngroups = token_len / sizeof(gid_t);
- pdt->delete_token->groups = talloc_array(
- pdt->delete_token, gid_t,
- pdt->delete_token->ngroups);
- if (pdt->delete_token->groups == NULL) {
- DEBUG(0,("parse_delete_tokens_list: talloc failed"));
- return -1;
- }
-
- for (j = 0; j < pdt->delete_token->ngroups; j++) {
- memcpy(&pdt->delete_token->groups[j], p,
- sizeof(gid_t));
- p += sizeof(gid_t);
- }
- }
- lck->num_delete_tokens += 1;
- }
-
- return delete_tokens_size;
-}
-
-/*******************************************************************
- Get all share mode entries for a dev/inode pair.
+ Fetch a share mode where we know one MUST exist. This call reference
+ counts it internally to allow for nested lock fetches.
********************************************************************/
-static bool parse_share_modes(const TDB_DATA dbuf, struct share_mode_lock *lck)
-{
- struct locking_data data;
- int delete_tokens_size;
- int i;
- struct server_id *pids;
- bool *pid_exists;
-
- if (dbuf.dsize < sizeof(struct locking_data)) {
- smb_panic("parse_share_modes: buffer too short");
- }
-
- 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");
- }
-
- lck->share_modes = NULL;
-
- if (lck->num_share_modes != 0) {
-
- 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");
- }
- }
-
- /* 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;
-
- 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;
-
- 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;
-
- /*
- * Ensure that each entry has a real process attached.
- */
-
- pids = talloc_array(talloc_tos(), struct server_id,
- lck->num_share_modes);
- if (pids == NULL) {
- smb_panic("parse_share_modes: talloc_array failed");
- }
- pid_exists = talloc_array(talloc_tos(), bool, lck->num_share_modes);
- if (pid_exists == NULL) {
- smb_panic("parse_share_modes: talloc_array failed");
- }
-
- for (i=0; i<lck->num_share_modes; i++) {
- pids[i] = lck->share_modes[i].pid;
- }
-
- if (!serverids_exist(pids, lck->num_share_modes, pid_exists)) {
- smb_panic("parse_share_modes: serverids_exist failed");
- }
-
- 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(talloc_tos(), i, entry_p);
- }
- DEBUG(10,("parse_share_modes: %s\n",
- str ? str : ""));
- if (!pid_exists[i]) {
- DEBUG(10,("parse_share_modes: deleted %s\n",
- str ? str : ""));
- entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
- lck->modified = True;
- }
- TALLOC_FREE(str);
- }
- TALLOC_FREE(pid_exists);
- TALLOC_FREE(pids);
-
- return True;
-}
-
-static TDB_DATA unparse_share_modes(const struct share_mode_lock *lck)
+struct share_mode_lock *get_existing_share_mode_lock(TALLOC_CTX *mem_ctx,
+ const struct file_id id)
{
- 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;
-
- 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;
- }
- }
-
- if (num_valid == 0) {
- return result;
- }
-
- sp_len = strlen(lck->servicepath);
- bn_len = strlen(lck->base_name);
- sn_len = lck->stream_name != NULL ? strlen(lck->stream_name) : 0;
-
- for (i=0; i<lck->num_delete_tokens; i++) {
- struct delete_token *pdt = &lck->delete_tokens[i];
- delete_tokens_size +=
- (sizeof(uint32_t) +
- sizeof(uint32_t) +
- sizeof(uid_t) +
- sizeof(gid_t) +
- pdt->delete_token->ngroups*sizeof(gid_t));
- }
-
- 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 = lck->num_delete_tokens;
-
- 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 (i=0; i<lck->num_delete_tokens; i++) {
- struct delete_token *pdtl = &lck->delete_tokens[i];
- 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;
- }
-
- 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);
- }
-
- return result;
-}
-
-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 = dbwrap_record_delete(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 = dbwrap_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);
- }
-
- 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->num_delete_tokens = 0;
- 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);
- TDB_DATA value;
-
- if (!(lck = talloc(mem_ctx, struct share_mode_lock))) {
- DEBUG(0, ("talloc failed\n"));
- return NULL;
- }
-
- if (!(lck->record = dbwrap_fetch_locked(lock_db, lck, key))) {
- DEBUG(3, ("Could not lock share entry\n"));
- TALLOC_FREE(lck);
- return NULL;
- }
-
- value = dbwrap_record_get_value(lck->record);
-
- if (!fill_share_mode_lock(lck, id, servicepath, smb_fname,
- 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;
- NTSTATUS status;
-
- if (!(lck = talloc(mem_ctx, struct share_mode_lock))) {
- DEBUG(0, ("talloc failed\n"));
- return NULL;
- }
-
- status = dbwrap_fetch(lock_db, lck, key, &data);
- if (!NT_STATUS_IS_OK(status)) {
- 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;
+ return get_share_mode_lock(mem_ctx, id, NULL, NULL, NULL);
}
/*******************************************************************
bool rename_share_filename(struct messaging_context *msg_ctx,
struct share_mode_lock *lck,
+ struct file_id id,
const char *servicepath,
uint32_t orig_name_hash,
uint32_t new_name_hash,
const struct smb_filename *smb_fname_dst)
{
+ struct share_mode_data *d = lck->data;
size_t sp_len;
size_t bn_len;
size_t sn_len;
size_t msg_len;
char *frm = NULL;
- int i;
+ uint32_t i;
bool strip_two_chars = false;
bool has_stream = smb_fname_dst->stream_name != NULL;
+ struct server_id self_pid = messaging_server_id(msg_ctx);
DEBUG(10, ("rename_share_filename: servicepath %s newname %s\n",
servicepath, smb_fname_dst->base_name));
strip_two_chars = true;
}
- lck->servicepath = talloc_strdup(lck, servicepath);
- lck->base_name = talloc_strdup(lck, smb_fname_dst->base_name +
+ d->servicepath = talloc_strdup(d, servicepath);
+ d->base_name = talloc_strdup(d, 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) {
+ d->stream_name = talloc_strdup(d, smb_fname_dst->stream_name);
+ if (d->base_name == NULL ||
+ (has_stream && d->stream_name == NULL) ||
+ d->servicepath == NULL) {
DEBUG(0, ("rename_share_filename: talloc failed\n"));
return False;
}
- lck->modified = True;
+ d->modified = True;
- sp_len = strlen(lck->servicepath);
- bn_len = strlen(lck->base_name);
- sn_len = has_stream ? strlen(lck->stream_name) : 0;
+ sp_len = strlen(d->servicepath);
+ bn_len = strlen(d->base_name);
+ sn_len = has_stream ? strlen(d->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);
+ frm = talloc_array(d, char, msg_len);
if (!frm) {
return False;
}
- push_file_id_24(frm, &lck->id);
+ push_file_id_24(frm, &id);
DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
strlcpy(&frm[24],
- lck->servicepath ? lck->servicepath : "",
+ d->servicepath ? d->servicepath : "",
sp_len+1);
strlcpy(&frm[24 + sp_len + 1],
- lck->base_name ? lck->base_name : "",
+ d->base_name ? d->base_name : "",
bn_len+1);
strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
- lck->stream_name ? lck->stream_name : "",
+ d->stream_name ? d->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];
+ for (i=0; i<d->num_share_modes; i++) {
+ struct share_mode_entry *se = &d->share_modes[i];
+ struct server_id_buf tmp;
+
if (!is_valid_share_mode_entry(se)) {
continue;
}
se->name_hash = new_name_hash;
/* But not to ourselves... */
- if (procid_is_me(&se->pid)) {
+ if (serverid_equal(&se->pid, &self_pid)) {
+ continue;
+ }
+
+ if (share_mode_stale_pid(d, i)) {
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 : ""));
+ server_id_str_buf(se->pid, &tmp),
+ file_id_string_tos(&id),
+ d->servicepath, d->base_name,
+ has_stream ? d->stream_name : ""));
messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
- (uint8 *)frm, msg_len);
+ (uint8_t *)frm, msg_len);
+ }
+
+ for (i=0; i<d->num_leases; i++) {
+ /* Update the filename in leases_db. */
+ NTSTATUS status;
+ struct share_mode_lease *l;
+
+ l = &d->leases[i];
+
+ status = leases_db_rename(&l->client_guid,
+ &l->lease_key,
+ &id,
+ d->servicepath,
+ d->base_name,
+ d->stream_name);
+ if (!NT_STATUS_IS_OK(status)) {
+ /* Any error recovery possible here ? */
+ DEBUG(1,("Failed to rename lease key for "
+ "renamed file %s:%s. %s\n",
+ d->base_name,
+ d->stream_name,
+ nt_errstr(status)));
+ continue;
+ }
}
return True;
}
if (write_time) {
- struct timespec wt;
-
- wt = lck->changed_write_time;
- if (null_timespec(wt)) {
- wt = lck->old_write_time;
- }
-
- *write_time = wt;
+ *write_time = get_share_mode_write_time(lck);
}
TALLOC_FREE(lck);
{
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;
+ if (e->stale) {
+ return false;
}
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);
+ num_props += (e->op_type == LEASE_OPLOCK);
- SMB_ASSERT(num_props <= 1);
+ if ((num_props > 1) && serverid_exists(&e->pid)) {
+ smb_panic("Invalid share mode entry");
+ }
return (num_props != 0);
}
-bool is_deferred_open_entry(const struct share_mode_entry *e)
-{
- return (e->op_type == DEFERRED_OPEN_ENTRY);
-}
+/*
+ * See if we need to remove a lease being referred to by a
+ * share mode that is being marked stale or deleted.
+ */
-bool is_unused_share_mode_entry(const struct share_mode_entry *e)
+static void remove_share_mode_lease(struct share_mode_data *d,
+ struct share_mode_entry *e)
{
- return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
-}
+ uint16_t op_type;
+ uint32_t lease_idx;
+ uint32_t i;
-/*******************************************************************
- Fill a share mode entry.
-********************************************************************/
+ op_type = e->op_type;
+ e->op_type = NO_OPLOCK;
-static void fill_share_mode_entry(struct share_mode_entry *e,
- files_struct *fsp,
- uid_t uid, uint64_t mid, uint16 op_type)
-{
- 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;
-}
+ d->modified = true;
-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;
-}
+ if (op_type != LEASE_OPLOCK) {
+ return;
+ }
-static void add_share_mode_entry(struct share_mode_lock *lck,
- const struct share_mode_entry *entry)
-{
- int i;
+ /*
+ * This used to reference a lease. If there's no other one referencing
+ * it, remove it.
+ */
+
+ lease_idx = e->lease_idx;
+ e->lease_idx = UINT32_MAX;
- 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;
+ for (i=0; i<d->num_share_modes; i++) {
+ struct share_mode_entry *e2 = &d->share_modes[i];
+
+ if (e2->stale) {
+ continue;
+ }
+ if (e == e2) {
+ /* Not ourselves. */
+ continue;
+ }
+ if (smb2_lease_equal(&e->client_guid,
+ &e->lease_key,
+ &e2->client_guid,
+ &e2->lease_key)) {
break;
}
}
+ if (i < d->num_share_modes) {
+ /*
+ * Found another one
+ */
+ return;
+ }
- 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);
+ d->num_leases -= 1;
+ d->leases[lease_idx] = d->leases[d->num_leases];
+
+ /*
+ * We changed the lease array. Fix all references to it.
+ */
+ for (i=0; i<d->num_share_modes; i++) {
+ if (d->share_modes[i].lease_idx == d->num_leases) {
+ d->share_modes[i].lease_idx = lease_idx;
+ }
}
- lck->modified = True;
-}
-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);
+ {
+ NTSTATUS status;
+
+ status = leases_db_del(&e->client_guid,
+ &e->lease_key,
+ &d->id);
+
+ DEBUG(10, ("%s: leases_db_del returned %s\n", __func__,
+ nt_errstr(status)));
+ }
}
-void add_deferred_open(struct share_mode_lock *lck, uint64_t mid,
- struct timeval request_time,
- struct server_id pid, struct file_id id)
+/*
+ * In case d->share_modes[i] conflicts with something or otherwise is
+ * being used, we need to make sure the corresponding process still
+ * exists.
+ */
+bool share_mode_stale_pid(struct share_mode_data *d, uint32_t idx)
{
- struct share_mode_entry entry;
- fill_deferred_open_entry(&entry, request_time, id, pid, mid);
- add_share_mode_entry(lck, &entry);
-}
+ struct server_id_buf tmp;
+ struct share_mode_entry *e;
+
+ if (idx > d->num_share_modes) {
+ DBG_WARNING("Asking for index %"PRIu32", "
+ "only %"PRIu32" around\n",
+ idx,
+ d->num_share_modes);
+ return false;
+ }
+ e = &d->share_modes[idx];
+ if (e->stale) {
+ /*
+ * Checked before
+ */
+ return true;
+ }
+ if (serverid_exists(&e->pid)) {
+ DBG_DEBUG("PID %s (index %"PRIu32" out of %"PRIu32") "
+ "still exists\n",
+ server_id_str_buf(e->pid, &tmp),
+ idx,
+ d->num_share_modes);
+ return false;
+ }
+ DBG_DEBUG("PID %s (index %"PRIu32" out of %"PRIu32") "
+ "does not exist anymore\n",
+ server_id_str_buf(e->pid, &tmp),
+ idx,
+ d->num_share_modes);
-/*******************************************************************
- 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.)
-********************************************************************/
+ e->stale = true;
-static bool share_modes_identical(struct share_mode_entry *e1,
- struct share_mode_entry *e2)
+ if (d->num_delete_tokens != 0) {
+ uint32_t i;
+
+ for (i=0; i<d->num_share_modes; i++) {
+ bool valid = !d->share_modes[i].stale;
+ if (valid) {
+ break;
+ }
+ }
+
+ if (i == d->num_share_modes) {
+ /*
+ * No valid (non-stale) share mode found, all
+ * who might have set the delete token are
+ * gone.
+ */
+ TALLOC_FREE(d->delete_tokens);
+ d->num_delete_tokens = 0;
+ }
+ }
+
+ remove_share_mode_lease(d, e);
+
+ d->modified = true;
+ return true;
+}
+
+void remove_stale_share_mode_entries(struct share_mode_data *d)
{
- /* 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 );
+ uint32_t i;
+
+ i = 0;
+ while (i < d->num_share_modes) {
+ if (d->share_modes[i].stale) {
+ struct share_mode_entry *m = d->share_modes;
+ m[i] = m[d->num_share_modes-1];
+ d->num_share_modes -= 1;
+ continue;
+ }
+ i += 1;
+ }
}
-static bool deferred_open_identical(struct share_mode_entry *e1,
- struct share_mode_entry *e2)
+bool set_share_mode(struct share_mode_lock *lck, struct files_struct *fsp,
+ uid_t uid, uint64_t mid, uint16_t op_type,
+ uint32_t lease_idx)
{
- return (procid_equal(&e1->pid, &e2->pid) &&
- (e1->op_mid == e2->op_mid) &&
- file_id_equal(&e1->id, &e2->id));
+ struct share_mode_data *d = lck->data;
+ struct share_mode_entry *tmp, *e;
+
+ if ((lease_idx != UINT32_MAX) &&
+ (lease_idx >= d->num_leases)) {
+ return false;
+ }
+
+ tmp = talloc_realloc(d, d->share_modes, struct share_mode_entry,
+ d->num_share_modes+1);
+ if (tmp == NULL) {
+ return false;
+ }
+ d->share_modes = tmp;
+ e = &d->share_modes[d->num_share_modes];
+ d->num_share_modes += 1;
+ d->modified = true;
+
+ ZERO_STRUCTP(e);
+ e->pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
+ 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->lease_idx = lease_idx;
+ if (lease_idx != UINT32_MAX) {
+ e->client_guid = lck->data->leases[lease_idx].client_guid;
+ e->lease_key = lck->data->leases[lease_idx].lease_key;
+ }
+ e->time.tv_sec = fsp->open_time.tv_sec;
+ e->time.tv_usec = fsp->open_time.tv_usec;
+ e->share_file_id = fsp->fh->gen_id;
+ e->uid = (uint32_t)uid;
+ e->flags = (fsp->posix_flags & FSP_POSIX_FLAGS_OPEN) ?
+ SHARE_MODE_FLAG_POSIX_OPEN : 0;
+ e->name_hash = fsp->name_hash;
+
+ return true;
}
-static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
- struct share_mode_entry *entry)
+struct share_mode_entry *find_share_mode_entry(
+ struct share_mode_lock *lck, files_struct *fsp)
{
- 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;
+ struct share_mode_data *d = lck->data;
+ struct server_id pid;
+ uint32_t i;
+
+ pid = messaging_server_id(fsp->conn->sconn->msg_ctx);
+
+ for (i=0; i<d->num_share_modes; i++) {
+ struct share_mode_entry *e = &d->share_modes[i];
+
+ if (!is_valid_share_mode_entry(e)) {
+ continue;
}
- if (is_deferred_open_entry(entry) &&
- is_deferred_open_entry(e) &&
- deferred_open_identical(e, entry)) {
- return e;
+ if (!serverid_equal(&pid, &e->pid)) {
+ continue;
}
+ if (fsp->fh->gen_id != e->share_file_id) {
+ continue;
+ }
+ return e;
}
return NULL;
}
/*******************************************************************
- Del the share mode of a file for this process. Return the number of
- entries left.
+ Del the share mode of a file for this process.
********************************************************************/
bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
{
- 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);
+ struct share_mode_entry *e;
- e = find_share_mode_entry(lck, &entry);
+ e = find_share_mode_entry(lck, fsp);
if (e == NULL) {
return False;
}
-
- e->op_type = UNUSED_SHARE_MODE_ENTRY;
- lck->modified = True;
+ remove_share_mode_lease(lck->data, e);
+ *e = lck->data->share_modes[lck->data->num_share_modes-1];
+ lck->data->num_share_modes -= 1;
+ lck->data->modified = True;
return True;
}
-void del_deferred_open_entry(struct share_mode_lock *lck, uint64_t mid,
- struct server_id pid)
+bool mark_share_mode_disconnected(struct share_mode_lock *lck,
+ struct files_struct *fsp)
{
- struct share_mode_entry entry, *e;
+ struct share_mode_entry *e;
- fill_deferred_open_entry(&entry, timeval_zero(),
- lck->id, pid, mid);
+ if (lck->data->num_share_modes != 1) {
+ return false;
+ }
- e = find_share_mode_entry(lck, &entry);
+ if (fsp->op == NULL) {
+ return false;
+ }
+ if (!fsp->op->global->durable) {
+ return false;
+ }
+
+ e = find_share_mode_entry(lck, fsp);
if (e == NULL) {
- return;
+ return false;
}
- e->op_type = UNUSED_SHARE_MODE_ENTRY;
- lck->modified = True;
+ DEBUG(10, ("Marking share mode entry disconnected for durable handle\n"));
+
+ server_id_set_disconnected(&e->pid);
+
+ /*
+ * On reopen the caller needs to check that
+ * the client comes with the correct handle.
+ */
+ e->share_file_id = fsp->op->global->open_persistent_id;
+
+ lck->data->modified = true;
+ return true;
}
/*******************************************************************
bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
{
- 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);
+ struct share_mode_data *d = lck->data;
+ struct share_mode_entry *e;
- e = find_share_mode_entry(lck, &entry);
+ e = find_share_mode_entry(lck, fsp);
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;
+ remove_share_mode_lease(d, e);
+ d->modified = True;
+ return true;
}
/*******************************************************************
bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
{
- 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);
+ struct share_mode_entry *e;
- e = find_share_mode_entry(lck, &entry);
+ e = find_share_mode_entry(lck, fsp);
if (e == NULL) {
return False;
}
e->op_type = LEVEL_II_OPLOCK;
- lck->modified = True;
+ lck->data->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;
- }
-
- /*
- * Only allow delete on close for writable shares.
- */
-
- 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));
-
- /* Or the root of a share. */
- if (ISDOT(fsp->fsp_name->base_name)) {
- DEBUG(10,("can_set_delete_on_close: can't set delete on "
- "close for the root of a share.\n"));
- return NT_STATUS_ACCESS_DENIED;
- }
-
- return can_delete_directory(fsp->conn,
- fsp->fsp_name->base_name);
- }
-
- return NT_STATUS_OK;
-}
-
-/*************************************************************************
- Return a talloced copy of a struct security_unix_token. NULL on fail.
- (Should this be in locking.c.... ?).
-*************************************************************************/
-
-static struct security_unix_token *copy_unix_token(TALLOC_CTX *ctx, const struct security_unix_token *tok)
-{
- struct security_unix_token *cpy;
-
- cpy = talloc(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,
+static bool add_delete_on_close_token(struct share_mode_data *d,
uint32_t name_hash,
+ const struct security_token *nt_tok,
const struct security_unix_token *tok)
{
struct delete_token *tmp, *dtl;
- tmp = talloc_realloc(lck, lck->delete_tokens, struct delete_token,
- lck->num_delete_tokens+1);
+ tmp = talloc_realloc(d, d->delete_tokens, struct delete_token,
+ d->num_delete_tokens+1);
if (tmp == NULL) {
return false;
}
- lck->delete_tokens = tmp;
- dtl = &lck->delete_tokens[lck->num_delete_tokens];
+ d->delete_tokens = tmp;
+ dtl = &d->delete_tokens[d->num_delete_tokens];
dtl->name_hash = name_hash;
- dtl->delete_token = copy_unix_token(lck->delete_tokens, tok);
+ dtl->delete_nt_token = dup_nt_token(d->delete_tokens, nt_tok);
+ if (dtl->delete_nt_token == NULL) {
+ return false;
+ }
+ dtl->delete_token = copy_unix_token(d->delete_tokens, tok);
if (dtl->delete_token == NULL) {
return false;
}
- lck->num_delete_tokens += 1;
- lck->modified = true;
+ d->num_delete_tokens += 1;
+ d->modified = true;
return true;
}
+void reset_delete_on_close_lck(files_struct *fsp,
+ struct share_mode_lock *lck)
+{
+ struct share_mode_data *d = lck->data;
+ uint32_t i;
+
+ for (i=0; i<d->num_delete_tokens; i++) {
+ struct delete_token *dt = &d->delete_tokens[i];
+
+ if (dt->name_hash == fsp->name_hash) {
+ d->modified = true;
+
+ /* Delete this entry. */
+ TALLOC_FREE(dt->delete_nt_token);
+ TALLOC_FREE(dt->delete_token);
+ *dt = d->delete_tokens[d->num_delete_tokens-1];
+ d->num_delete_tokens -= 1;
+ }
+ }
+}
+
/****************************************************************************
Sets the delete on close flag over all share modes on this file.
Modify the share mode entry for all files open
void set_delete_on_close_lck(files_struct *fsp,
struct share_mode_lock *lck,
- bool delete_on_close,
+ const struct security_token *nt_tok,
const struct security_unix_token *tok)
{
- int i;
+ struct messaging_context *msg_ctx = fsp->conn->sconn->msg_ctx;
+ struct share_mode_data *d = lck->data;
+ uint32_t i;
bool ret;
+ DATA_BLOB fid_blob = {};
+ enum ndr_err_code ndr_err;
- if (delete_on_close) {
- SMB_ASSERT(tok != NULL);
- } else {
- SMB_ASSERT(tok == NULL);
- }
+ SMB_ASSERT(nt_tok != NULL);
+ SMB_ASSERT(tok != NULL);
- for (i=0; i<lck->num_delete_tokens; i++) {
- struct delete_token *dt = &lck->delete_tokens[i];
+ for (i=0; i<d->num_delete_tokens; i++) {
+ struct delete_token *dt = &d->delete_tokens[i];
if (dt->name_hash == fsp->name_hash) {
- lck->modified = true;
- if (delete_on_close == false) {
- /* Delete this entry. */
- TALLOC_FREE(dt->delete_token);
- *dt = lck->delete_tokens[
- lck->num_delete_tokens];
- lck->num_delete_tokens -= 1;
- return;
- }
- /* Replace this token with the
- given tok. */
+ d->modified = true;
+
+ /* Replace this token with the given tok. */
+ TALLOC_FREE(dt->delete_nt_token);
+ dt->delete_nt_token = dup_nt_token(dt, nt_tok);
+ SMB_ASSERT(dt->delete_nt_token != NULL);
TALLOC_FREE(dt->delete_token);
dt->delete_token = copy_unix_token(dt, tok);
SMB_ASSERT(dt->delete_token != NULL);
+
+ return;
}
}
- if (!delete_on_close) {
- /* Nothing to delete - not found. */
- return;
+ ret = add_delete_on_close_token(lck->data, fsp->name_hash, nt_tok, tok);
+ SMB_ASSERT(ret);
+
+ ndr_err = ndr_push_struct_blob(&fid_blob, talloc_tos(), &fsp->file_id,
+ (ndr_push_flags_fn_t)ndr_push_file_id);
+ if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+ DEBUG(10, ("ndr_push_file_id failed: %s\n",
+ ndr_errstr(ndr_err)));
}
- ret = add_delete_on_close_token(lck, fsp->name_hash, tok);
- SMB_ASSERT(ret);
+ for (i=0; i<d->num_share_modes; i++) {
+ struct share_mode_entry *e = &d->share_modes[i];
+ NTSTATUS status;
+
+ status = messaging_send(
+ msg_ctx, e->pid, MSG_SMB_NOTIFY_CANCEL_DELETED,
+ &fid_blob);
+
+ if (!NT_STATUS_IS_OK(status)) {
+ struct server_id_buf tmp;
+ DEBUG(10, ("%s: messaging_send to %s returned %s\n",
+ __func__, server_id_str_buf(e->pid, &tmp),
+ nt_errstr(status)));
+ }
+ }
+
+ TALLOC_FREE(fid_blob.data);
}
-bool set_delete_on_close(files_struct *fsp, bool delete_on_close, const struct security_unix_token *tok)
+bool set_delete_on_close(files_struct *fsp, bool delete_on_close,
+ const struct security_token *nt_tok,
+ 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,
+ "%s, file %s\n",
+ delete_on_close ? "Adding" : "Removing", fsp_fnum_dbg(fsp),
fsp_str_dbg(fsp)));
- lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
- NULL);
+ lck = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
if (lck == NULL) {
return False;
}
- set_delete_on_close_lck(fsp, lck, delete_on_close,
- delete_on_close ? tok : NULL);
+ if (delete_on_close) {
+ set_delete_on_close_lck(fsp, lck, nt_tok, tok);
+ } else {
+ reset_delete_on_close_lck(fsp, lck);
+ }
if (fsp->is_directory) {
SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
return True;
}
-const struct security_unix_token *get_delete_on_close_token(struct share_mode_lock *lck, uint32_t name_hash)
+static struct delete_token *find_delete_on_close_token(
+ struct share_mode_data *d, uint32_t name_hash)
{
- int i;
+ uint32_t i;
- DEBUG(10,("get_delete_on_close_token: name_hash = 0x%x\n",
- (unsigned int)name_hash ));
+ DEBUG(10, ("find_delete_on_close_token: name_hash = 0x%x\n",
+ (unsigned int)name_hash));
- for (i=0; i<lck->num_delete_tokens; i++) {
- struct delete_token *dt = &lck->delete_tokens[i];
- DEBUG(10,("get_delete_on_close_token: dtl->name_hash = 0x%x\n",
- (unsigned int)dt->name_hash ));
+ for (i=0; i<d->num_delete_tokens; i++) {
+ struct delete_token *dt = &d->delete_tokens[i];
+
+ DEBUG(10, ("find__delete_on_close_token: dt->name_hash = 0x%x\n",
+ (unsigned int)dt->name_hash ));
if (dt->name_hash == name_hash) {
- return dt->delete_token;
+ return dt;
}
}
return NULL;
}
+/****************************************************************************
+ Return the NT token and UNIX token if there's a match. Return true if
+ found, false if not.
+****************************************************************************/
+
+bool get_delete_on_close_token(struct share_mode_lock *lck,
+ uint32_t name_hash,
+ const struct security_token **pp_nt_tok,
+ const struct security_unix_token **pp_tok)
+{
+ struct delete_token *dt;
+
+ dt = find_delete_on_close_token(lck->data, name_hash);
+ if (dt == NULL) {
+ return false;
+ }
+ *pp_nt_tok = dt->delete_nt_token;
+ *pp_tok = dt->delete_token;
+ return true;
+}
+
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);
+ return find_delete_on_close_token(lck->data, name_hash) != NULL;
}
bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
convert_timespec_to_time_t(write_time)),
file_id_string_tos(&fileid)));
- lck = get_share_mode_lock(NULL, fileid, NULL, NULL, NULL);
+ lck = get_existing_share_mode_lock(talloc_tos(), fileid);
if (lck == NULL) {
return False;
}
- if (timespec_compare(&lck->changed_write_time, &write_time) != 0) {
- lck->modified = True;
- lck->changed_write_time = write_time;
+ if (timespec_compare(&lck->data->changed_write_time, &write_time) != 0) {
+ lck->data->modified = True;
+ lck->data->changed_write_time = write_time;
}
TALLOC_FREE(lck);
convert_timespec_to_time_t(write_time)),
file_id_string_tos(&fileid)));
- lck = get_share_mode_lock(NULL, fileid, NULL, NULL, NULL);
+ lck = get_existing_share_mode_lock(talloc_tos(), fileid);
if (lck == NULL) {
return False;
}
- if (timespec_compare(&lck->old_write_time, &write_time) != 0) {
- lck->modified = True;
- lck->old_write_time = write_time;
+ if (timespec_compare(&lck->data->old_write_time, &write_time) != 0) {
+ lck->data->modified = True;
+ lck->data->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 timespec get_share_mode_write_time(struct share_mode_lock *lck)
{
- struct forall_state *state = (struct forall_state *)_state;
- struct locking_data *data;
- struct share_mode_entry *shares;
- const char *sharepath;
- const char *fname;
- const char *del_tokens;
- uint32_t total_del_token_size = 0;
- int i;
- TDB_DATA key;
- TDB_DATA value;
-
- key = dbwrap_record_get_key(rec);
- value = dbwrap_record_get_value(rec);
-
- /* Ensure this is a locking_key record. */
- if (key.dsize != sizeof(struct file_id))
- return 0;
-
- data = (struct locking_data *)value.dptr;
- shares = (struct share_mode_entry *)(value.dptr + sizeof(*data));
- del_tokens = (const char *)value.dptr + sizeof(*data) +
- data->u.s.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;
- }
-
- sharepath = (const char *)value.dptr + sizeof(*data) +
- data->u.s.num_share_mode_entries*sizeof(*shares) +
- total_del_token_size;
- fname = (const char *)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;
-}
+ struct share_mode_data *d = lck->data;
-/*******************************************************************
- Call the specified function on each entry under management by the
- share mode system.
-********************************************************************/
+ if (!null_timespec(d->changed_write_time)) {
+ return d->changed_write_time;
+ }
+ return d->old_write_time;
+}
-int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
- const char *, void *),
- void *private_data)
+bool file_has_open_streams(files_struct *fsp)
{
- struct forall_state state;
- NTSTATUS status;
- int count;
+ struct share_mode_lock *lock = NULL;
+ struct share_mode_data *d = NULL;
+ uint32_t i;
- if (lock_db == NULL)
- return 0;
+ lock = get_existing_share_mode_lock(talloc_tos(), fsp->file_id);
+ if (lock == NULL) {
+ return false;
+ }
+ d = lock->data;
- state.fn = fn;
- state.private_data = private_data;
+ for (i = 0; i < d->num_share_modes; i++) {
+ struct share_mode_entry *e = &d->share_modes[i];
- status = dbwrap_traverse_read(lock_db, traverse_fn, (void *)&state,
- &count);
+ if (share_mode_stale_pid(d, i)) {
+ continue;
+ }
- if (!NT_STATUS_IS_OK(status)) {
- return -1;
- } else {
- return count;
+ if (e->private_options &
+ NTCREATEX_OPTIONS_PRIVATE_STREAM_BASEOPEN)
+ {
+ TALLOC_FREE(lock);
+ return true;
+ }
}
+
+ TALLOC_FREE(lock);
+ return false;
}
git.samba.org / gd / samba-autobuild / .git / blobdiff