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.
#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;
return brl_lockquery(br_lck,
psmblctx,
- sconn_server_id(fsp->conn->sconn),
+ messaging_server_id(fsp->conn->sconn->msg_ctx),
poffset,
pcount,
plock_type,
*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,
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);
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,
}
}
-/****************************************************************************
- 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)
{
- return talloc_asprintf(ctx, "share_mode_entry[%d]: %s "
+ 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),
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),
(unsigned int)e->name_hash);
}
/*******************************************************************
- 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 share_mode_lock *get_existing_share_mode_lock(TALLOC_CTX *mem_ctx,
+ const struct file_id id)
{
- int i;
- struct server_id *pids;
- bool *pid_exists;
- enum ndr_err_code ndr_err;
- DATA_BLOB blob;
-
- blob.data = dbuf.dptr;
- blob.length = dbuf.dsize;
-
- ndr_err = ndr_pull_struct_blob(
- &blob, lck, lck,
- (ndr_pull_flags_fn_t)ndr_pull_share_mode_lock);
- if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- DEBUG(1, ("ndr_pull_share_mode_lock failed\n"));
- return false;
- }
-
- lck->modified = false;
-
- if (DEBUGLEVEL >= 10) {
- DEBUG(10, ("parse_share_modes:\n"));
- NDR_PRINT_DEBUG(share_mode_lock, lck);
- }
-
- /*
- * 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];
- if (!pid_exists[i]) {
- entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
- lck->modified = True;
- }
- }
- TALLOC_FREE(pid_exists);
- TALLOC_FREE(pids);
-
- return True;
-}
-
-static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
-{
- DATA_BLOB blob;
- enum ndr_err_code ndr_err;
- uint32_t i;
-
- if (DEBUGLEVEL >= 10) {
- DEBUG(10, ("unparse_share_modes:\n"));
- NDR_PRINT_DEBUG(share_mode_lock, lck);
- }
-
- for (i=0; i<lck->num_share_modes; i++) {
- if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
- break;
- }
- }
- if (i == lck->num_share_modes) {
- DEBUG(10, ("No used share mode found\n"));
- return make_tdb_data(NULL, 0);
- }
-
- ndr_err = ndr_push_struct_blob(
- &blob, lck, lck,
- (ndr_push_flags_fn_t)ndr_push_share_mode_lock);
- if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- smb_panic("ndr_push_share_mode_lock failed");
- }
-
- return make_tdb_data(blob.data, blob.length);
-}
-
-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)
-{
- bool fresh;
-
- /* 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);
-
- fresh = (share_mode_data.dptr == NULL);
-
- if (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;
- lck->modified = false;
- } else {
- if (!parse_share_modes(share_mode_data, lck)) {
- DEBUG(0, ("Could not parse share modes\n"));
- return False;
- }
- }
- lck->fresh = fresh;
-
- 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;
- struct db_record *rec;
- 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;
- }
-
- rec = dbwrap_fetch_locked(lock_db, lck, key);
- if (rec == NULL) {
- DEBUG(3, ("Could not lock share entry\n"));
- TALLOC_FREE(lck);
- return NULL;
- }
-
- value = dbwrap_record_get_value(rec);
-
- 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;
- }
-
- lck->record = rec;
- 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);
}
/*******************************************************************
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;
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, &d->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];
if (!is_valid_share_mode_entry(se)) {
continue;
}
"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 : ""));
+ file_id_string_tos(&d->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);
if (write_time) {
struct timespec wt;
- wt = lck->changed_write_time;
+ wt = lck->data->changed_write_time;
if (null_timespec(wt)) {
- wt = lck->old_write_time;
+ wt = lck->data->old_write_time;
}
*write_time = wt;
{
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;
- }
-
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);
return (e->op_type == DEFERRED_OPEN_ENTRY);
}
-bool is_unused_share_mode_entry(const struct share_mode_entry *e)
-{
- return (e->op_type == UNUSED_SHARE_MODE_ENTRY);
-}
-
/*******************************************************************
Fill a share mode entry.
********************************************************************/
uid_t uid, uint64_t mid, uint16 op_type)
{
ZERO_STRUCTP(e);
- e->pid = sconn_server_id(fsp->conn->sconn);
+ 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->flags = 0;
}
-static void add_share_mode_entry(struct share_mode_lock *lck,
+static void add_share_mode_entry(struct share_mode_data *d,
const struct share_mode_entry *entry)
{
- int i;
-
- for (i=0; i<lck->num_share_modes; i++) {
- struct share_mode_entry *e = &lck->share_modes[i];
- if (is_unused_share_mode_entry(e)) {
- *e = *entry;
- break;
- }
- }
-
- if (i == lck->num_share_modes) {
- /* No unused entry found */
- ADD_TO_ARRAY(lck, struct share_mode_entry, *entry,
- &lck->share_modes, &lck->num_share_modes);
- }
- lck->modified = True;
+ ADD_TO_ARRAY(d, struct share_mode_entry, *entry,
+ &d->share_modes, &d->num_share_modes);
+ d->modified = True;
}
void set_share_mode(struct share_mode_lock *lck, files_struct *fsp,
{
struct share_mode_entry entry;
fill_share_mode_entry(&entry, fsp, uid, mid, op_type);
- add_share_mode_entry(lck, &entry);
+ add_share_mode_entry(lck->data, &entry);
}
void add_deferred_open(struct share_mode_lock *lck, uint64_t mid,
{
struct share_mode_entry entry;
fill_deferred_open_entry(&entry, request_time, id, pid, mid);
- add_share_mode_entry(lck, &entry);
+ add_share_mode_entry(lck->data, &entry);
}
/*******************************************************************
file_id_equal(&e1->id, &e2->id));
}
-static struct share_mode_entry *find_share_mode_entry(struct share_mode_lock *lck,
+static struct share_mode_entry *find_share_mode_entry(struct share_mode_data *d,
struct share_mode_entry *entry)
{
int i;
- for (i=0; i<lck->num_share_modes; i++) {
- struct share_mode_entry *e = &lck->share_modes[i];
+ for (i=0; i<d->num_share_modes; i++) {
+ struct share_mode_entry *e = &d->share_modes[i];
if (is_valid_share_mode_entry(entry) &&
is_valid_share_mode_entry(e) &&
share_modes_identical(e, entry)) {
/* Don't care about the pid owner being correct here - just a search. */
fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
- e = find_share_mode_entry(lck, &entry);
+ e = find_share_mode_entry(lck->data, &entry);
if (e == NULL) {
return False;
}
-
- e->op_type = UNUSED_SHARE_MODE_ENTRY;
- lck->modified = True;
+ *e = lck->data->share_modes[lck->data->num_share_modes-1];
+ lck->data->num_share_modes -= 1;
+ lck->data->modified = True;
return True;
}
struct share_mode_entry entry, *e;
fill_deferred_open_entry(&entry, timeval_zero(),
- lck->id, pid, mid);
+ lck->data->id, pid, mid);
- e = find_share_mode_entry(lck, &entry);
+ e = find_share_mode_entry(lck->data, &entry);
if (e == NULL) {
return;
}
-
- e->op_type = UNUSED_SHARE_MODE_ENTRY;
- lck->modified = True;
+ *e = lck->data->share_modes[lck->data->num_share_modes-1];
+ lck->data->num_share_modes -= 1;
+ lck->data->modified = True;
}
/*******************************************************************
/* Don't care about the pid owner being correct here - just a search. */
fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
- e = find_share_mode_entry(lck, &entry);
+ e = find_share_mode_entry(lck->data, &entry);
if (e == NULL) {
return False;
}
} else {
e->op_type = NO_OPLOCK;
}
- lck->modified = True;
+ lck->data->modified = True;
return True;
}
/* Don't care about the pid owner being correct here - just a search. */
fill_share_mode_entry(&entry, fsp, (uid_t)-1, 0, NO_OPLOCK);
- e = find_share_mode_entry(lck, &entry);
+ e = find_share_mode_entry(lck->data, &entry);
if (e == NULL) {
return False;
}
e->op_type = LEVEL_II_OPLOCK;
- lck->modified = True;
+ lck->data->modified = True;
return True;
}
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 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)
{
+ struct share_mode_data *d = lck->data;
int i;
bool ret;
if (delete_on_close) {
+ SMB_ASSERT(nt_tok != NULL);
SMB_ASSERT(tok != NULL);
} else {
+ 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;
+ d->modified = true;
if (delete_on_close == false) {
/* Delete this entry. */
+ TALLOC_FREE(dt->delete_nt_token);
TALLOC_FREE(dt->delete_token);
- *dt = lck->delete_tokens[
- lck->num_delete_tokens-1];
- lck->num_delete_tokens -= 1;
- return;
+ *dt = d->delete_tokens[
+ d->num_delete_tokens-1];
+ d->num_delete_tokens -= 1;
+ } else {
+ /* 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);
}
- /* Replace this token with the
- given tok. */
- TALLOC_FREE(dt->delete_token);
- dt->delete_token = copy_unix_token(dt, tok);
- SMB_ASSERT(dt->delete_token != NULL);
+ return;
}
}
return;
}
- ret = add_delete_on_close_token(lck, fsp->name_hash, tok);
+ ret = add_delete_on_close_token(lck->data, fsp->name_hash, nt_tok, tok);
SMB_ASSERT(ret);
}
-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;
delete_on_close ? "Adding" : "Removing", fsp->fnum,
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, true,
+ nt_tok,
+ tok);
+ } else {
+ set_delete_on_close_lck(fsp, lck, false,
+ NULL,
+ NULL);
+ }
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)
+/****************************************************************************
+ 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)
{
int i;
DEBUG(10,("get_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];
+ for (i=0; i<lck->data->num_delete_tokens; i++) {
+ struct delete_token *dt = &lck->data->delete_tokens[i];
DEBUG(10,("get_delete_on_close_token: dtl->name_hash = 0x%x\n",
(unsigned int)dt->name_hash ));
if (dt->name_hash == name_hash) {
- return dt->delete_token;
+ if (pp_nt_tok) {
+ *pp_nt_tok = dt->delete_nt_token;
+ }
+ if (pp_tok) {
+ *pp_tok = dt->delete_token;
+ }
+ return true;
}
}
- return NULL;
+ return false;
}
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 get_delete_on_close_token(lck, name_hash, NULL, 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(talloc_tos(), 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(talloc_tos(), 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 forall_state *state = (struct forall_state *)_state;
- uint32_t i;
- TDB_DATA key;
- TDB_DATA value;
- DATA_BLOB blob;
- enum ndr_err_code ndr_err;
- struct share_mode_lock *lck;
-
- 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;
-
- lck = talloc(talloc_tos(), struct share_mode_lock);
- if (lck == NULL) {
- return 0;
- }
-
- blob.data = value.dptr;
- blob.length = value.dsize;
-
- ndr_err = ndr_pull_struct_blob(
- &blob, lck, lck,
- (ndr_pull_flags_fn_t)ndr_pull_share_mode_lock);
- if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
- DEBUG(1, ("ndr_pull_share_mode_lock failed\n"));
- return 0;
- }
- for (i=0; i<lck->num_share_modes; i++) {
- state->fn(&lck->share_modes[i],
- lck->servicepath, lck->base_name,
- state->private_data);
- }
- TALLOC_FREE(lck);
-
- return 0;
-}
-
-/*******************************************************************
- Call the specified function on each entry under management by the
- share mode system.
-********************************************************************/
-
-int share_mode_forall(void (*fn)(const struct share_mode_entry *, const char *,
- const char *, void *),
- void *private_data)
-{
- struct forall_state state;
- NTSTATUS status;
- int count;
-
- if (lock_db == NULL)
- return 0;
-
- state.fn = fn;
- state.private_data = private_data;
-
- status = dbwrap_traverse_read(lock_db, traverse_fn, (void *)&state,
- &count);
-
- if (!NT_STATUS_IS_OK(status)) {
- return -1;
- } else {
- return count;
- }
-}
git.samba.org / kai / samba.git / blobdiff