*/
#include "includes.h"
+#include "librpc/gen_ndr/messaging.h"
+#include "smbd/globals.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_LOCKING
Called in the read/write codepath.
****************************************************************************/
-bool is_locked(files_struct *fsp,
- uint32 smbpid,
- uint64_t count,
- uint64_t offset,
- enum brl_type lock_type)
+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)
+{
+ 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);
+}
+
+bool strict_lock_default(files_struct *fsp, struct lock_struct *plock)
{
int strict_locking = lp_strict_locking(fsp->conn->params);
- enum brl_flavour lock_flav = lp_posix_cifsu_locktype(fsp);
- bool ret = True;
-
- if (count == 0) {
- return False;
+ bool ret = False;
+
+ if (plock->size == 0) {
+ return True;
}
if (!lp_locking(fsp->conn->params) || !strict_locking) {
- return False;
+ return True;
}
if (strict_locking == Auto) {
- if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && (lock_type == READ_LOCK || lock_type == WRITE_LOCK)) {
- DEBUG(10,("is_locked: optimisation - exclusive oplock on file %s\n", fsp->fsp_name ));
- ret = False;
+ 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) &&
- (lock_type == READ_LOCK)) {
- DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp->fsp_name ));
- ret = False;
+ (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 = brl_get_locks_readonly(talloc_tos(), fsp);
+ struct byte_range_lock *br_lck;
+
+ br_lck = brl_get_locks_readonly(fsp);
if (!br_lck) {
- return False;
+ return True;
}
- ret = !brl_locktest(br_lck,
- smbpid,
- procid_self(),
- offset,
- count,
- lock_type,
- lock_flav);
- TALLOC_FREE(br_lck);
+ 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 = brl_get_locks_readonly(talloc_tos(), fsp);
+ struct byte_range_lock *br_lck;
+
+ br_lck = brl_get_locks_readonly(fsp);
if (!br_lck) {
- return False;
+ return True;
}
- ret = !brl_locktest(br_lck,
- smbpid,
- procid_self(),
- offset,
- count,
- lock_type,
- lock_flav);
- TALLOC_FREE(br_lck);
- }
-
- DEBUG(10,("is_locked: flavour = %s brl start=%.0f len=%.0f %s for fnum %d file %s\n",
- lock_flav_name(lock_flav),
- (double)offset, (double)count, ret ? "locked" : "unlocked",
- fsp->fnum, fsp->fsp_name ));
+ 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)
+{
+}
+
/****************************************************************************
Find out if a lock could be granted - return who is blocking us if we can't.
****************************************************************************/
NTSTATUS query_lock(files_struct *fsp,
- uint32 *psmbpid,
+ uint64_t *psmblctx,
uint64_t *pcount,
uint64_t *poffset,
enum brl_type *plock_type,
enum brl_flavour lock_flav)
{
struct byte_range_lock *br_lck = NULL;
- NTSTATUS status = NT_STATUS_LOCK_NOT_GRANTED;
if (!fsp->can_lock) {
return fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
return NT_STATUS_OK;
}
- br_lck = brl_get_locks_readonly(talloc_tos(), fsp);
+ br_lck = brl_get_locks_readonly(fsp);
if (!br_lck) {
return NT_STATUS_NO_MEMORY;
}
- status = brl_lockquery(br_lck,
- psmbpid,
+ return brl_lockquery(br_lck,
+ psmblctx,
procid_self(),
poffset,
pcount,
plock_type,
lock_flav);
+}
- TALLOC_FREE(br_lck);
- return status;
+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;
+ }
+}
+
+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--;
+ }
}
/****************************************************************************
struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
files_struct *fsp,
- uint32 lock_pid,
+ uint64_t smblctx,
uint64_t count,
uint64_t offset,
enum brl_type lock_type,
enum brl_flavour lock_flav,
bool blocking_lock,
NTSTATUS *perr,
- uint32 *plock_pid)
+ uint64_t *psmblctx,
+ struct blocking_lock_record *blr)
{
struct byte_range_lock *br_lck = NULL;
+ /* silently return ok on print files as we don't do locking there */
+ if (fsp->print_file) {
+ *perr = NT_STATUS_OK;
+ return NULL;
+ }
+
if (!fsp->can_lock) {
*perr = fsp->is_directory ? NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
return 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 requested for fnum %d file %s\n",
+ 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, fsp->fnum, fsp->fsp_name ));
+ (double)offset, (double)count, blocking_lock ? "true" :
+ "false", fsp->fnum, fsp_str_dbg(fsp)));
br_lck = brl_get_locks(talloc_tos(), fsp);
if (!br_lck) {
*perr = brl_lock(msg_ctx,
br_lck,
- lock_pid,
+ smblctx,
procid_self(),
offset,
- count,
+ count,
lock_type,
lock_flav,
blocking_lock,
- plock_pid);
-
- 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. */
+ psmblctx,
+ blr);
- 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;
- }
+ DEBUG(10, ("do_lock: returning status=%s\n", nt_errstr(*perr)));
+ increment_current_lock_count(fsp, lock_flav);
return br_lck;
}
NTSTATUS do_unlock(struct messaging_context *msg_ctx,
files_struct *fsp,
- uint32 lock_pid,
+ uint64_t smblctx,
uint64_t count,
uint64_t offset,
enum brl_flavour lock_flav)
}
DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for fnum %d file %s\n",
- (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
+ (double)offset, (double)count, fsp->fnum,
+ fsp_str_dbg(fsp)));
br_lck = brl_get_locks(talloc_tos(), fsp);
if (!br_lck) {
ok = brl_unlock(msg_ctx,
br_lck,
- lock_pid,
+ smblctx,
procid_self(),
offset,
count,
return NT_STATUS_RANGE_NOT_LOCKED;
}
- if (lock_flav == WINDOWS_LOCK &&
- fsp->current_lock_count != NO_LOCKING_COUNT) {
- SMB_ASSERT(fsp->current_lock_count > 0);
- fsp->current_lock_count--;
- }
-
+ decrement_current_lock_count(fsp, lock_flav);
return NT_STATUS_OK;
}
****************************************************************************/
NTSTATUS do_lock_cancel(files_struct *fsp,
- uint32 lock_pid,
+ uint64 smblctx,
uint64_t count,
uint64_t offset,
- enum brl_flavour lock_flav)
+ enum brl_flavour lock_flav,
+ struct blocking_lock_record *blr)
{
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;
}
DEBUG(10,("do_lock_cancel: cancel start=%.0f len=%.0f requested for fnum %d file %s\n",
- (double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
+ (double)offset, (double)count, fsp->fnum,
+ fsp_str_dbg(fsp)));
br_lck = brl_get_locks(talloc_tos(), fsp);
if (!br_lck) {
}
ok = brl_lock_cancel(br_lck,
- lock_pid,
+ smblctx,
procid_self(),
offset,
count,
- lock_flav);
-
+ lock_flav,
+ blr);
+
TALLOC_FREE(br_lck);
if (!ok) {
return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
}
- if (lock_flav == WINDOWS_LOCK &&
- fsp->current_lock_count != NO_LOCKING_COUNT) {
- SMB_ASSERT(fsp->current_lock_count > 0);
- fsp->current_lock_count--;
- }
-
+ decrement_current_lock_count(fsp, lock_flav);
return NT_STATUS_OK;
}
****************************************************************************/
void locking_close_file(struct messaging_context *msg_ctx,
- files_struct *fsp)
+ files_struct *fsp,
+ enum file_close_type close_type)
{
struct byte_range_lock *br_lck;
br_lck = brl_get_locks(talloc_tos(),fsp);
if (br_lck) {
- cancel_pending_lock_requests_by_fid(fsp, br_lck);
+ cancel_pending_lock_requests_by_fid(fsp, br_lck, close_type);
brl_close_fnum(msg_ctx, br_lck);
TALLOC_FREE(br_lck);
}
{
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%x, type= 0x%x, gen_id = %lu, "
+ "access_mask = 0x%x, mid = 0x%llx, type= 0x%x, gen_id = %lu, "
"uid = %u, flags = %u, file_id %s",
num,
e->op_type == UNUSED_SHARE_MODE_ENTRY ? "UNUSED" : "",
procid_str_static(&e->pid),
e->share_access, e->private_options,
- e->access_mask, e->op_mid, e->op_type, e->share_file_id,
+ 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));
}
Get all share mode entries for a dev/inode pair.
********************************************************************/
-static bool parse_share_modes(TDB_DATA dbuf, struct share_mode_lock *lck)
+static bool parse_share_modes(const TDB_DATA dbuf, struct share_mode_lock *lck)
{
struct locking_data data;
int i;
DEBUG(10, ("parse_share_modes: delete_on_close: %d, owrt: %s, "
"cwrt: %s, tok: %u, num_share_modes: %d\n",
lck->delete_on_close,
- timestring(debug_ctx(),
+ timestring(talloc_tos(),
convert_timespec_to_time_t(lck->old_write_time)),
- timestring(debug_ctx(),
+ timestring(talloc_tos(),
convert_timespec_to_time_t(
lck->changed_write_time)),
(unsigned int)data.u.s.delete_token_size,
(lck->num_share_modes * sizeof(struct share_mode_entry)) +
data.u.s.delete_token_size;
- lck->filename = (const char *)dbuf.dptr + sizeof(struct locking_data) +
+ lck->base_name = (const char *)dbuf.dptr + sizeof(struct locking_data) +
(lck->num_share_modes * sizeof(struct share_mode_entry)) +
data.u.s.delete_token_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)) +
+ data.u.s.delete_token_size +
+ strlen(lck->servicepath) + 1 +
+ strlen(lck->base_name) + 1;
+
/*
* Ensure that each entry has a real process attached.
*/
}
DEBUG(10,("parse_share_modes: %s\n",
str ? str : ""));
- if (!process_exists(entry_p->pid)) {
+ if (!serverid_exists(&entry_p->pid)) {
DEBUG(10,("parse_share_modes: deleted %s\n",
str ? str : ""));
entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
return True;
}
-static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
+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;
+ ssize_t sp_len, bn_len, sn_len;
uint32 delete_token_size;
result.dptr = NULL;
}
sp_len = strlen(lck->servicepath);
+ bn_len = strlen(lck->base_name);
+ sn_len = lck->stream_name != NULL ? strlen(lck->stream_name) : 0;
+
delete_token_size = (lck->delete_token ?
(sizeof(uid_t) + sizeof(gid_t) + (lck->delete_token->ngroups*sizeof(gid_t))) : 0);
lck->num_share_modes * sizeof(struct share_mode_entry) +
delete_token_size +
sp_len + 1 +
- strlen(lck->filename) + 1;
+ bn_len + 1 +
+ sn_len + 1;
result.dptr = TALLOC_ARRAY(lck, uint8, result.dsize);
if (result.dptr == NULL) {
DEBUG(10,("unparse_share_modes: del: %d, owrt: %s cwrt: %s, tok: %u, "
"num: %d\n", data->u.s.delete_on_close,
- timestring(debug_ctx(),
+ timestring(talloc_tos(),
convert_timespec_to_time_t(lck->old_write_time)),
- timestring(debug_ctx(),
+ timestring(talloc_tos(),
convert_timespec_to_time_t(
lck->changed_write_time)),
(unsigned int)data->u.s.delete_token_size,
safe_strcpy((char *)result.dptr + offset, lck->servicepath,
result.dsize - offset - 1);
offset += sp_len + 1;
- safe_strcpy((char *)result.dptr + offset, lck->filename,
+ safe_strcpy((char *)result.dptr + offset, lck->base_name,
+ result.dsize - offset - 1);
+ offset += bn_len + 1;
+ safe_strcpy((char *)result.dptr + offset, lck->stream_name,
result.dsize - offset - 1);
if (DEBUGLEVEL >= 10) {
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)));
- smb_panic("could not delete share entry");
+
+ 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)));
- smb_panic("could not store share mode entry");
+
+ 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:
static bool fill_share_mode_lock(struct share_mode_lock *lck,
struct file_id id,
const char *servicepath,
- const char *fname,
+ const struct smb_filename *smb_fname,
TDB_DATA share_mode_data,
const struct timespec *old_write_time)
{
valid even if parse_share_modes fails. */
lck->servicepath = NULL;
- lck->filename = NULL;
+ lck->base_name = NULL;
+ lck->stream_name = NULL;
lck->id = id;
lck->num_share_modes = 0;
lck->share_modes = NULL;
lck->fresh = (share_mode_data.dptr == NULL);
if (lck->fresh) {
- if (fname == NULL || servicepath == NULL
+ bool has_stream;
+ if (smb_fname == NULL || servicepath == NULL
|| old_write_time == NULL) {
return False;
}
- lck->filename = talloc_strdup(lck, fname);
+
+ 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->filename == NULL || lck->servicepath == NULL) {
+ if (lck->base_name == NULL ||
+ (has_stream && lck->stream_name == NULL) ||
+ lck->servicepath == NULL) {
DEBUG(0, ("talloc failed\n"));
return False;
}
struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
const struct file_id id,
const char *servicepath,
- const char *fname,
+ const struct smb_filename *smb_fname,
const struct timespec *old_write_time)
{
struct share_mode_lock *lck;
return NULL;
}
- if (!fill_share_mode_lock(lck, id, servicepath, fname,
+ 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);
}
struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
- const struct file_id id,
- const char *servicepath,
- const char *fname)
+ const struct file_id id)
{
struct share_mode_lock *lck;
struct file_id tmp;
return NULL;
}
- if (!fill_share_mode_lock(lck, id, servicepath, fname, data, NULL)) {
- DEBUG(3, ("fill_share_mode_lock failed\n"));
+ 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;
}
bool rename_share_filename(struct messaging_context *msg_ctx,
struct share_mode_lock *lck,
const char *servicepath,
- const char *newname)
+ const struct smb_filename *smb_fname_dst)
{
size_t sp_len;
- size_t fn_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, newname));
+ servicepath, smb_fname_dst->base_name));
/*
* rename_internal_fsp() and rename_internals() add './' to
* head of newname if newname does not contain a '/'.
*/
- while (newname[0] && newname[1] && newname[0] == '.' && newname[1] == '/') {
- newname += 2;
+ 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->filename = talloc_strdup(lck, newname);
- if (lck->filename == NULL || lck->servicepath == NULL) {
+ 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);
- fn_len = strlen(lck->filename);
+ 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 + fn_len + 1;
+ 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);
return False;
}
- push_file_id_16(frm, &lck->id);
+ push_file_id_24(frm, &lck->id);
DEBUG(10,("rename_share_filename: msg_len = %u\n", (unsigned int)msg_len ));
- safe_strcpy(&frm[16], lck->servicepath, sp_len);
- safe_strcpy(&frm[16 + sp_len + 1], lck->filename, fn_len);
+ safe_strcpy(&frm[24], lck->servicepath, sp_len);
+ safe_strcpy(&frm[24 + sp_len + 1], lck->base_name, bn_len);
+ safe_strcpy(&frm[24 + sp_len + 1 + bn_len + 1], lck->stream_name,
+ sn_len);
/* Send the messages. */
for (i=0; i<lck->num_share_modes; i++) {
continue;
}
- DEBUG(10,("rename_share_filename: sending rename message to pid %s "
- "file_id %s sharepath %s newname %s\n",
+ 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->filename ));
+ lck->servicepath, lck->base_name,
+ has_stream ? lck->stream_name : ""));
messaging_send_buf(msg_ctx, se->pid, MSG_SMB_FILE_RENAME,
(uint8 *)frm, msg_len);
ZERO_STRUCTP(write_time);
}
- if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id, NULL, NULL))) {
+ if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id))) {
return;
}
static void fill_share_mode_entry(struct share_mode_entry *e,
files_struct *fsp,
- uid_t uid, uint16 mid, uint16 op_type)
+ uid_t uid, uint64_t mid, uint16 op_type)
{
ZERO_STRUCTP(e);
e->pid = procid_self();
static void fill_deferred_open_entry(struct share_mode_entry *e,
const struct timeval request_time,
- struct file_id id, uint16 mid)
+ struct file_id id, uint64_t mid)
{
ZERO_STRUCTP(e);
e->pid = procid_self();
}
void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
- uid_t uid, uint16 mid, uint16 op_type)
+ 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, uint16 mid,
+void add_deferred_open(struct share_mode_lock *lck, uint64_t mid,
struct timeval request_time,
struct file_id id)
{
return True;
}
-void del_deferred_open_entry(struct share_mode_lock *lck, uint16 mid)
+void del_deferred_open_entry(struct share_mode_lock *lck, uint64_t mid)
{
struct share_mode_entry entry, *e;
}
/****************************************************************************
- Deal with the internal needs of setting the delete on close flag. Note that
- as the tdb locking is recursive, it is safe to call this from within
- open_file_ntcreate. JRA.
+ Check if setting delete on close is allowed on this fsp.
****************************************************************************/
-NTSTATUS can_set_delete_on_close(files_struct *fsp, bool delete_on_close,
- uint32 dosmode)
+NTSTATUS can_set_delete_on_close(files_struct *fsp, uint32 dosmode)
{
- if (!delete_on_close) {
- return NT_STATUS_OK;
- }
-
/*
* Only allow delete on close for writable files.
*/
!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->fsp_name ));
+ fsp_str_dbg(fsp)));
return NT_STATUS_CANNOT_DELETE;
}
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->fsp_name ));
+ fsp_str_dbg(fsp)));
return NT_STATUS_ACCESS_DENIED;
}
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->fsp_name ));
+ fsp_str_dbg(fsp)));
return NT_STATUS_ACCESS_DENIED;
}
/* Don't allow delete on close for non-empty directories. */
if (fsp->is_directory) {
- return can_delete_directory(fsp->conn, fsp->fsp_name);
+ 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;
(Should this be in locking.c.... ?).
*************************************************************************/
-static UNIX_USER_TOKEN *copy_unix_token(TALLOC_CTX *ctx, UNIX_USER_TOKEN *tok)
+static UNIX_USER_TOKEN *copy_unix_token(TALLOC_CTX *ctx, const UNIX_USER_TOKEN *tok)
{
UNIX_USER_TOKEN *cpy;
Replace the delete on close token.
****************************************************************************/
-void set_delete_on_close_token(struct share_mode_lock *lck, UNIX_USER_TOKEN *tok)
+void set_delete_on_close_token(struct share_mode_lock *lck, const UNIX_USER_TOKEN *tok)
{
TALLOC_FREE(lck->delete_token); /* Also deletes groups... */
lck entry. This function is used when the lock is already granted.
****************************************************************************/
-void set_delete_on_close_lck(struct share_mode_lock *lck, bool delete_on_close, UNIX_USER_TOKEN *tok)
+void set_delete_on_close_lck(struct share_mode_lock *lck, bool delete_on_close, const UNIX_USER_TOKEN *tok)
{
if (lck->delete_on_close != delete_on_close) {
set_delete_on_close_token(lck, tok);
}
}
-bool set_delete_on_close(files_struct *fsp, bool delete_on_close, UNIX_USER_TOKEN *tok)
+bool set_delete_on_close(files_struct *fsp, bool delete_on_close, const UNIX_USER_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->fsp_name ));
+ fsp_str_dbg(fsp)));
lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
NULL);
set_delete_on_close_lck(lck, delete_on_close, tok);
if (fsp->is_directory) {
- send_stat_cache_delete_message(fsp->fsp_name);
+ SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
+ send_stat_cache_delete_message(fsp->fsp_name->base_name);
}
TALLOC_FREE(lck);
+
+ fsp->delete_on_close = delete_on_close;
+
return True;
}
struct share_mode_lock *lck;
DEBUG(5,("set_sticky_write_time: %s id=%s\n",
- timestring(debug_ctx(),
+ timestring(talloc_tos(),
convert_timespec_to_time_t(write_time)),
file_id_string_tos(&fileid)));
struct share_mode_lock *lck;
DEBUG(5,("set_write_time: %s id=%s\n",
- timestring(debug_ctx(),
+ timestring(talloc_tos(),
convert_timespec_to_time_t(write_time)),
file_id_string_tos(&fileid)));
git.samba.org / samba.git / blobdiff