bool is_locked(files_struct *fsp,
uint32 smbpid,
- SMB_BIG_UINT count,
- SMB_BIG_UINT offset,
+ uint64_t count,
+ uint64_t offset,
enum brl_type lock_type)
{
int strict_locking = lp_strict_locking(fsp->conn->params);
DEBUG(10,("is_locked: optimisation - level II oplock on file %s\n", fsp->fsp_name ));
ret = False;
} else {
- struct byte_range_lock *br_lck = brl_get_locks_readonly(NULL, fsp);
+ struct byte_range_lock *br_lck = brl_get_locks_readonly(talloc_tos(), fsp);
if (!br_lck) {
return False;
}
TALLOC_FREE(br_lck);
}
} else {
- struct byte_range_lock *br_lck = brl_get_locks_readonly(NULL, fsp);
+ struct byte_range_lock *br_lck = brl_get_locks_readonly(talloc_tos(), fsp);
if (!br_lck) {
return False;
}
NTSTATUS query_lock(files_struct *fsp,
uint32 *psmbpid,
- SMB_BIG_UINT *pcount,
- SMB_BIG_UINT *poffset,
+ uint64_t *pcount,
+ uint64_t *poffset,
enum brl_type *plock_type,
enum brl_flavour lock_flav)
{
return NT_STATUS_OK;
}
- br_lck = brl_get_locks_readonly(NULL, fsp);
+ br_lck = brl_get_locks_readonly(talloc_tos(), fsp);
if (!br_lck) {
return NT_STATUS_NO_MEMORY;
}
struct byte_range_lock *do_lock(struct messaging_context *msg_ctx,
files_struct *fsp,
uint32 lock_pid,
- SMB_BIG_UINT count,
- SMB_BIG_UINT offset,
+ uint64_t count,
+ uint64_t offset,
enum brl_type lock_type,
enum brl_flavour lock_flav,
bool blocking_lock,
lock_flav_name(lock_flav), lock_type_name(lock_type),
(double)offset, (double)count, fsp->fnum, fsp->fsp_name ));
- br_lck = brl_get_locks(NULL, fsp);
+ br_lck = brl_get_locks(talloc_tos(), fsp);
if (!br_lck) {
*perr = NT_STATUS_NO_MEMORY;
return NULL;
NTSTATUS do_unlock(struct messaging_context *msg_ctx,
files_struct *fsp,
uint32 lock_pid,
- SMB_BIG_UINT count,
- SMB_BIG_UINT offset,
+ uint64_t count,
+ uint64_t offset,
enum brl_flavour lock_flav)
{
bool ok = False;
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 ));
- br_lck = brl_get_locks(NULL, fsp);
+ br_lck = brl_get_locks(talloc_tos(), fsp);
if (!br_lck) {
return NT_STATUS_NO_MEMORY;
}
NTSTATUS do_lock_cancel(files_struct *fsp,
uint32 lock_pid,
- SMB_BIG_UINT count,
- SMB_BIG_UINT offset,
+ uint64_t count,
+ uint64_t offset,
enum brl_flavour lock_flav)
{
bool ok = False;
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 ));
- br_lck = brl_get_locks(NULL, fsp);
+ br_lck = brl_get_locks(talloc_tos(), fsp);
if (!br_lck) {
return NT_STATUS_NO_MEMORY;
}
return;
}
- br_lck = brl_get_locks(NULL,fsp);
+ br_lck = brl_get_locks(talloc_tos(),fsp);
if (br_lck) {
cancel_pending_lock_requests_by_fid(fsp, br_lck);
if (lock_db)
return True;
- lock_db = db_open(NULL, lock_path("locking.tdb"), 0,
- TDB_DEFAULT
- |TDB_VOLATILE
- |(read_only?0x0:TDB_CLEAR_IF_FIRST),
+ lock_db = db_open(NULL, lock_path("locking.tdb"),
+ lp_open_files_db_hash_size(),
+ TDB_DEFAULT|TDB_VOLATILE|TDB_CLEAR_IF_FIRST,
read_only?O_RDONLY:O_RDWR|O_CREAT, 0644);
if (!lock_db) {
Print out a share mode.
********************************************************************/
-char *share_mode_str(TALLOC_CTX *ctx, int num, struct share_mode_entry *e)
+char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
{
return talloc_asprintf(ctx, "share_mode_entry[%d]: %s "
"pid = %s, share_access = 0x%x, private_options = 0x%x, "
static bool parse_share_modes(TDB_DATA dbuf, struct share_mode_lock *lck)
{
- struct locking_data *data;
+ struct locking_data data;
int i;
if (dbuf.dsize < sizeof(struct locking_data)) {
smb_panic("parse_share_modes: buffer too short");
}
- data = (struct locking_data *)dbuf.dptr;
+ memcpy(&data, dbuf.dptr, sizeof(data));
- lck->delete_on_close = data->u.s.delete_on_close;
- lck->num_share_modes = data->u.s.num_share_mode_entries;
+ lck->delete_on_close = data.u.s.delete_on_close;
+ 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: delete_on_close: %d, "
- "num_share_modes: %d\n",
- lck->delete_on_close,
- lck->num_share_modes));
+ 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(),
+ convert_timespec_to_time_t(lck->old_write_time)),
+ timestring(debug_ctx(),
+ convert_timespec_to_time_t(
+ lck->changed_write_time)),
+ (unsigned int)data.u.s.delete_token_size,
+ 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->share_modes = (struct share_mode_entry *)
- TALLOC_MEMDUP(lck, dbuf.dptr+sizeof(*data),
+ TALLOC_MEMDUP(lck,
+ dbuf.dptr+sizeof(struct locking_data),
lck->num_share_modes *
sizeof(struct share_mode_entry));
}
/* Get any delete token. */
- if (data->u.s.delete_token_size) {
- uint8 *p = dbuf.dptr + sizeof(*data) +
+ if (data.u.s.delete_token_size) {
+ uint8 *p = dbuf.dptr + sizeof(struct locking_data) +
(lck->num_share_modes *
sizeof(struct share_mode_entry));
- if ((data->u.s.delete_token_size < sizeof(uid_t) + sizeof(gid_t)) ||
- ((data->u.s.delete_token_size - sizeof(uid_t)) % sizeof(gid_t)) != 0) {
+ if ((data.u.s.delete_token_size < sizeof(uid_t) + sizeof(gid_t)) ||
+ ((data.u.s.delete_token_size - sizeof(uid_t)) % sizeof(gid_t)) != 0) {
DEBUG(0, ("parse_share_modes: invalid token size %d\n",
- data->u.s.delete_token_size));
+ data.u.s.delete_token_size));
smb_panic("parse_share_modes: invalid token size");
}
p += sizeof(gid_t);
/* Any supplementary groups ? */
- lck->delete_token->ngroups = (data->u.s.delete_token_size > (sizeof(uid_t) + sizeof(gid_t))) ?
- ((data->u.s.delete_token_size -
+ lck->delete_token->ngroups = (data.u.s.delete_token_size > (sizeof(uid_t) + sizeof(gid_t))) ?
+ ((data.u.s.delete_token_size -
(sizeof(uid_t) + sizeof(gid_t)))/sizeof(gid_t)) : 0;
if (lck->delete_token->ngroups) {
}
/* Save off the associated service path and filename. */
- lck->servicepath = talloc_strdup(lck, (const char *)dbuf.dptr + sizeof(*data) +
- (lck->num_share_modes *
- sizeof(struct share_mode_entry)) +
- data->u.s.delete_token_size );
- if (lck->servicepath == NULL) {
- smb_panic("parse_share_modes: talloc_strdup failed");
- }
+ lck->servicepath = (const char *)dbuf.dptr + sizeof(struct locking_data) +
+ (lck->num_share_modes * sizeof(struct share_mode_entry)) +
+ data.u.s.delete_token_size;
- lck->filename = talloc_strdup(lck, (const char *)dbuf.dptr + sizeof(*data) +
- (lck->num_share_modes *
- sizeof(struct share_mode_entry)) +
- data->u.s.delete_token_size +
- strlen(lck->servicepath) + 1 );
- if (lck->filename == NULL) {
- smb_panic("parse_share_modes: talloc_strdup failed");
- }
+ lck->filename = (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;
/*
* Ensure that each entry has a real process attached.
ZERO_STRUCTP(data);
data->u.s.num_share_mode_entries = lck->num_share_modes;
data->u.s.delete_on_close = lck->delete_on_close;
+ data->u.s.old_write_time = lck->old_write_time;
+ data->u.s.changed_write_time = lck->changed_write_time;
data->u.s.delete_token_size = delete_token_size;
- DEBUG(10, ("unparse_share_modes: del: %d, tok = %u, num: %d\n",
- data->u.s.delete_on_close,
- (unsigned int)data->u.s.delete_token_size,
- data->u.s.num_share_mode_entries));
+
+ 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(),
+ convert_timespec_to_time_t(lck->old_write_time)),
+ timestring(debug_ctx(),
+ convert_timespec_to_time_t(
+ lck->changed_write_time)),
+ (unsigned int)data->u.s.delete_token_size,
+ 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) +
struct file_id id,
const char *servicepath,
const char *fname,
- TDB_DATA share_mode_data)
+ 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->share_modes = NULL;
lck->delete_token = NULL;
lck->delete_on_close = False;
+ 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) {
- if (fname == NULL || servicepath == NULL) {
+ if (fname == NULL || servicepath == NULL
+ || old_write_time == NULL) {
return False;
}
lck->filename = talloc_strdup(lck, fname);
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"));
struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
const struct file_id id,
const char *servicepath,
- const char *fname)
+ const char *fname,
+ const struct timespec *old_write_time)
{
struct share_mode_lock *lck;
struct file_id tmp;
}
if (!fill_share_mode_lock(lck, id, servicepath, fname,
- lck->record->value)) {
+ lck->record->value, old_write_time)) {
DEBUG(3, ("fill_share_mode_lock failed\n"));
TALLOC_FREE(lck);
return NULL;
return NULL;
}
- if (!fill_share_mode_lock(lck, id, servicepath, fname, data)) {
+ if (!fill_share_mode_lock(lck, id, servicepath, fname, data, NULL)) {
DEBUG(3, ("fill_share_mode_lock failed\n"));
TALLOC_FREE(lck);
return NULL;
}
- TALLOC_FREE(data.dptr);
-
return lck;
}
return True;
}
-bool get_delete_on_close_flag(struct file_id id)
+void get_file_infos(struct file_id id,
+ bool *delete_on_close,
+ struct timespec *write_time)
{
- bool result;
struct share_mode_lock *lck;
-
- if (!(lck = fetch_share_mode_unlocked(NULL, id, NULL, NULL))) {
- return False;
+
+ if (delete_on_close) {
+ *delete_on_close = false;
+ }
+
+ if (write_time) {
+ ZERO_STRUCTP(write_time);
+ }
+
+ if (!(lck = fetch_share_mode_unlocked(talloc_tos(), id, NULL, NULL))) {
+ return;
+ }
+
+ if (delete_on_close) {
+ *delete_on_close = lck->delete_on_close;
+ }
+
+ if (write_time) {
+ struct timespec wt;
+
+ wt = lck->changed_write_time;
+ if (null_timespec(wt)) {
+ wt = lck->old_write_time;
+ }
+
+ *write_time = wt;
}
- result = lck->delete_on_close;
+
TALLOC_FREE(lck);
- return result;
}
bool is_valid_share_mode_entry(const struct share_mode_entry *e)
}
void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
- uid_t uid, uint16 mid, uint16 op_type, bool initial_delete_on_close_allowed)
+ uid_t uid, uint16 mid, uint16 op_type)
{
struct share_mode_entry entry;
fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
- if (initial_delete_on_close_allowed) {
- entry.flags |= SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE;
- }
add_share_mode_entry(lck, &entry);
}
return NT_STATUS_OK;
}
-/****************************************************************************
- Do we have an open file handle that created this entry ?
-****************************************************************************/
-
-bool can_set_initial_delete_on_close(const struct share_mode_lock *lck)
-{
- int i;
-
- for (i=0; i<lck->num_share_modes; i++) {
- if (lck->share_modes[i].flags & SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE) {
- return True;
- }
- }
- return False;
-}
-
/*************************************************************************
Return a talloced copy of a UNIX_USER_TOKEN. NULL on fail.
(Should this be in locking.c.... ?).
void set_delete_on_close_token(struct share_mode_lock *lck, UNIX_USER_TOKEN *tok)
{
- /* Ensure there's no token. */
- if (lck->delete_token) {
- TALLOC_FREE(lck->delete_token); /* Also deletes groups... */
- lck->delete_token = NULL;
- }
+ TALLOC_FREE(lck->delete_token); /* Also deletes groups... */
/* Copy the new token (can be NULL). */
lck->delete_token = copy_unix_token(lck, tok);
delete_on_close ? "Adding" : "Removing", fsp->fnum,
fsp->fsp_name ));
- if (fsp->is_stat) {
- return True;
- }
-
- lck = get_share_mode_lock(NULL, fsp->file_id, NULL, NULL);
+ lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
+ NULL);
if (lck == NULL) {
return False;
}
return True;
}
-/****************************************************************************
- Sets the allow initial delete on close flag for this share mode.
-****************************************************************************/
+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(debug_ctx(),
+ 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;
+ }
-bool set_allow_initial_delete_on_close(struct share_mode_lock *lck, files_struct *fsp, bool delete_on_close)
+ TALLOC_FREE(lck);
+ return True;
+}
+
+bool set_write_time(struct file_id fileid, struct timespec write_time)
{
- struct share_mode_entry entry, *e;
+ struct share_mode_lock *lck;
- /* 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);
+ DEBUG(5,("set_write_time: %s id=%s\n",
+ timestring(debug_ctx(),
+ convert_timespec_to_time_t(write_time)),
+ file_id_string_tos(&fileid)));
- e = find_share_mode_entry(lck, &entry);
- if (e == NULL) {
+ lck = get_share_mode_lock(NULL, fileid, NULL, NULL, NULL);
+ if (lck == NULL) {
return False;
}
- if (delete_on_close) {
- e->flags |= SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE;
- } else {
- e->flags &= ~SHARE_MODE_ALLOW_INITIAL_DELETE_ON_CLOSE;
+ if (timespec_compare(&lck->old_write_time, &write_time) != 0) {
+ lck->modified = True;
+ lck->old_write_time = write_time;
}
- lck->modified = True;
+
+ TALLOC_FREE(lck);
return True;
}
+
struct forall_state {
void (*fn)(const struct share_mode_entry *entry,
const char *sharepath,
git.samba.org / abartlet / samba.git / .git / blobdiff