summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--source3/include/smb.h4
-rw-r--r--source3/librpc/idl/open_files.idl2
-rw-r--r--source3/locking/locking.c280
-rw-r--r--source3/smbd/close.c20
-rw-r--r--source3/smbd/open.c38
-rw-r--r--source3/smbd/oplock.c6
-rw-r--r--source3/smbd/reply.c4
-rw-r--r--source3/smbd/trans2.c4
-rw-r--r--source3/utils/status.c8
9 files changed, 193 insertions, 173 deletions
diff --git a/source3/include/smb.h b/source3/include/smb.h
index 2adfa36c8c..11a05f9369 100644
--- a/source3/include/smb.h
+++ b/source3/include/smb.h
@@ -163,6 +163,10 @@ struct wb_context;
struct rpc_cli_smbd_conn;
struct fncall_context;
+struct share_mode_lock {
+ struct share_mode_data *data;
+};
+
struct vfs_fsp_data {
struct vfs_fsp_data *next;
struct vfs_handle_struct *owner;
diff --git a/source3/librpc/idl/open_files.idl b/source3/librpc/idl/open_files.idl
index 9f06a0c123..cefb75a2a3 100644
--- a/source3/librpc/idl/open_files.idl
+++ b/source3/librpc/idl/open_files.idl
@@ -44,5 +44,5 @@ interface open_files
uint8 fresh;
uint8 modified;
[ignore] db_record *record;
- } share_mode_lock;
+ } share_mode_data;
}
diff --git a/source3/locking/locking.c b/source3/locking/locking.c
index 2e400ac8ef..d98d19b399 100644
--- a/source3/locking/locking.c
+++ b/source3/locking/locking.c
@@ -513,18 +513,18 @@ char *share_mode_str(TALLOC_CTX *ctx, int num, const struct share_mode_entry *e)
Get all share mode entries for a dev/inode pair.
********************************************************************/
-static struct share_mode_lock *parse_share_modes(TALLOC_CTX *mem_ctx,
+static struct share_mode_data *parse_share_modes(TALLOC_CTX *mem_ctx,
const TDB_DATA dbuf)
{
- struct share_mode_lock *lck;
+ struct share_mode_data *d;
int i;
struct server_id *pids;
bool *pid_exists;
enum ndr_err_code ndr_err;
DATA_BLOB blob;
- lck = talloc_zero(mem_ctx, struct share_mode_lock);
- if (lck == NULL) {
+ d = talloc_zero(mem_ctx, struct share_mode_data);
+ if (d == NULL) {
DEBUG(0, ("talloc failed\n"));
goto fail;
}
@@ -533,19 +533,18 @@ static struct share_mode_lock *parse_share_modes(TALLOC_CTX *mem_ctx,
blob.length = dbuf.dsize;
ndr_err = ndr_pull_struct_blob(
- &blob, lck, lck,
- (ndr_pull_flags_fn_t)ndr_pull_share_mode_lock);
+ &blob, d, d, (ndr_pull_flags_fn_t)ndr_pull_share_mode_data);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
DEBUG(1, ("ndr_pull_share_mode_lock failed\n"));
goto fail;
}
- lck->modified = false;
- lck->fresh = false;
+ d->modified = false;
+ d->fresh = false;
if (DEBUGLEVEL >= 10) {
DEBUG(10, ("parse_share_modes:\n"));
- NDR_PRINT_DEBUG(share_mode_lock, lck);
+ NDR_PRINT_DEBUG(share_mode_data, d);
}
/*
@@ -553,62 +552,61 @@ static struct share_mode_lock *parse_share_modes(TALLOC_CTX *mem_ctx,
*/
pids = talloc_array(talloc_tos(), struct server_id,
- lck->num_share_modes);
+ d->num_share_modes);
if (pids == NULL) {
DEBUG(0, ("talloc failed\n"));
goto fail;
}
- pid_exists = talloc_array(talloc_tos(), bool, lck->num_share_modes);
+ pid_exists = talloc_array(talloc_tos(), bool, d->num_share_modes);
if (pid_exists == NULL) {
DEBUG(0, ("talloc failed\n"));
goto fail;
}
- for (i=0; i<lck->num_share_modes; i++) {
- pids[i] = lck->share_modes[i].pid;
+ for (i=0; i<d->num_share_modes; i++) {
+ pids[i] = d->share_modes[i].pid;
}
- if (!serverids_exist(pids, lck->num_share_modes, pid_exists)) {
+ if (!serverids_exist(pids, d->num_share_modes, pid_exists)) {
DEBUG(0, ("serverid_exists failed\n"));
goto fail;
}
i = 0;
- while (i < lck->num_share_modes) {
- struct share_mode_entry *e = &lck->share_modes[i];
+ while (i < d->num_share_modes) {
+ struct share_mode_entry *e = &d->share_modes[i];
if (!pid_exists[i]) {
- *e = lck->share_modes[lck->num_share_modes-1];
- lck->num_share_modes -= 1;
- lck->modified = True;
+ *e = d->share_modes[d->num_share_modes-1];
+ d->num_share_modes -= 1;
+ d->modified = True;
continue;
}
i += 1;
}
TALLOC_FREE(pid_exists);
TALLOC_FREE(pids);
- return lck;
+ return d;
fail:
- TALLOC_FREE(lck);
+ TALLOC_FREE(d);
return NULL;
}
-static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
+static TDB_DATA unparse_share_modes(struct share_mode_data *d)
{
DATA_BLOB blob;
enum ndr_err_code ndr_err;
if (DEBUGLEVEL >= 10) {
DEBUG(10, ("unparse_share_modes:\n"));
- NDR_PRINT_DEBUG(share_mode_lock, lck);
+ NDR_PRINT_DEBUG(share_mode_data, d);
}
- if (lck->num_share_modes == 0) {
+ if (d->num_share_modes == 0) {
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);
+ &blob, d, d, (ndr_push_flags_fn_t)ndr_push_share_mode_data);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
smb_panic("ndr_push_share_mode_lock failed");
}
@@ -616,22 +614,22 @@ static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
return make_tdb_data(blob.data, blob.length);
}
-static int share_mode_lock_destructor(struct share_mode_lock *lck)
+static int share_mode_data_destructor(struct share_mode_data *d)
{
NTSTATUS status;
TDB_DATA data;
- if (!lck->modified) {
+ if (!d->modified) {
return 0;
}
- data = unparse_share_modes(lck);
+ data = unparse_share_modes(d);
if (data.dptr == NULL) {
- if (!lck->fresh) {
+ if (!d->fresh) {
/* There has been an entry before, delete it */
- status = dbwrap_record_delete(lck->record);
+ status = dbwrap_record_delete(d->record);
if (!NT_STATUS_IS_OK(status)) {
char *errmsg;
@@ -650,7 +648,7 @@ static int share_mode_lock_destructor(struct share_mode_lock *lck)
goto done;
}
- status = dbwrap_record_store(lck->record, data, TDB_REPLACE);
+ status = dbwrap_record_store(d->record, data, TDB_REPLACE);
if (!NT_STATUS_IS_OK(status)) {
char *errmsg;
@@ -668,43 +666,43 @@ static int share_mode_lock_destructor(struct share_mode_lock *lck)
return 0;
}
-static struct share_mode_lock *fresh_share_mode_lock(
+static struct share_mode_data *fresh_share_mode_lock(
TALLOC_CTX *mem_ctx, const char *servicepath,
const struct smb_filename *smb_fname,
const struct timespec *old_write_time)
{
- struct share_mode_lock *lck;
+ struct share_mode_data *d;
if ((servicepath == NULL) || (smb_fname == NULL) ||
(old_write_time == NULL)) {
return NULL;
}
- lck = talloc_zero(mem_ctx, struct share_mode_lock);
- if (lck == NULL) {
+ d = talloc_zero(mem_ctx, struct share_mode_data);
+ if (d == NULL) {
goto fail;
}
- lck->base_name = talloc_strdup(lck, smb_fname->base_name);
- if (lck->base_name == NULL) {
+ d->base_name = talloc_strdup(d, smb_fname->base_name);
+ if (d->base_name == NULL) {
goto fail;
}
if (smb_fname->stream_name != NULL) {
- lck->stream_name = talloc_strdup(lck, smb_fname->stream_name);
- if (lck->stream_name == NULL) {
+ d->stream_name = talloc_strdup(d, smb_fname->stream_name);
+ if (d->stream_name == NULL) {
goto fail;
}
}
- lck->servicepath = talloc_strdup(lck, servicepath);
- if (lck->servicepath == NULL) {
+ d->servicepath = talloc_strdup(d, servicepath);
+ if (d->servicepath == NULL) {
goto fail;
}
- lck->old_write_time = *old_write_time;
- lck->modified = false;
- lck->fresh = true;
- return lck;
+ d->old_write_time = *old_write_time;
+ d->modified = false;
+ d->fresh = true;
+ return d;
fail:
DEBUG(0, ("talloc failed\n"));
- TALLOC_FREE(lck);
+ TALLOC_FREE(d);
return NULL;
}
@@ -715,6 +713,7 @@ struct share_mode_lock *get_share_mode_lock_fresh(TALLOC_CTX *mem_ctx,
const struct timespec *old_write_time)
{
struct share_mode_lock *lck;
+ struct share_mode_data *d;
struct file_id tmp;
struct db_record *rec;
TDB_DATA key = locking_key(&id, &tmp);
@@ -729,20 +728,28 @@ struct share_mode_lock *get_share_mode_lock_fresh(TALLOC_CTX *mem_ctx,
value = dbwrap_record_get_value(rec);
if (value.dptr == NULL) {
- lck = fresh_share_mode_lock(mem_ctx, servicepath, smb_fname,
- old_write_time);
+ d = fresh_share_mode_lock(mem_ctx, servicepath, smb_fname,
+ old_write_time);
} else {
- lck = parse_share_modes(mem_ctx, value);
+ d = parse_share_modes(mem_ctx, value);
}
- if (lck == NULL) {
+ if (d == NULL) {
DEBUG(1, ("Could not get share mode lock\n"));
TALLOC_FREE(rec);
return NULL;
}
- lck->id = id;
- lck->record = talloc_move(lck, &rec);
- talloc_set_destructor(lck, share_mode_lock_destructor);
+ d->id = id;
+ d->record = talloc_move(d, &rec);
+ talloc_set_destructor(d, share_mode_data_destructor);
+
+ lck = talloc(mem_ctx, struct share_mode_lock);
+ if (lck == NULL) {
+ DEBUG(1, ("talloc failed\n"));
+ TALLOC_FREE(d);
+ return NULL;
+ }
+ lck->data = talloc_move(lck, &d);
return lck;
}
@@ -769,11 +776,17 @@ struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
if (data.dptr == NULL) {
return NULL;
}
- lck = parse_share_modes(mem_ctx, data);
- if (lck != NULL) {
- lck->id = id;
+ lck = talloc(mem_ctx, struct share_mode_lock);
+ if (lck == NULL) {
+ TALLOC_FREE(data.dptr);
+ return NULL;
}
+ lck->data = parse_share_modes(mem_ctx, data);
TALLOC_FREE(data.dptr);
+ if (lck->data == NULL) {
+ TALLOC_FREE(lck);
+ return NULL;
+ }
return lck;
}
@@ -791,6 +804,7 @@ bool rename_share_filename(struct messaging_context *msg_ctx,
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;
@@ -814,48 +828,48 @@ bool rename_share_filename(struct messaging_context *msg_ctx,
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;
}
@@ -877,9 +891,9 @@ bool rename_share_filename(struct messaging_context *msg_ctx,
"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);
@@ -914,9 +928,9 @@ void get_file_infos(struct file_id id,
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;
@@ -983,12 +997,12 @@ static void fill_deferred_open_entry(struct share_mode_entry *e,
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)
{
- 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,
@@ -996,7 +1010,7 @@ 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,
@@ -1005,7 +1019,7 @@ 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);
}
/*******************************************************************
@@ -1035,13 +1049,13 @@ static bool deferred_open_identical(struct share_mode_entry *e1,
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)) {
@@ -1068,13 +1082,13 @@ bool del_share_mode(struct share_mode_lock *lck, files_struct *fsp)
/* 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 = lck->share_modes[lck->num_share_modes-1];
- lck->num_share_modes -= 1;
- 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;
}
@@ -1084,15 +1098,15 @@ void del_deferred_open_entry(struct share_mode_lock *lck, uint64_t mid,
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 = lck->share_modes[lck->num_share_modes-1];
- lck->num_share_modes -= 1;
- lck->modified = True;
+ *e = lck->data->share_modes[lck->data->num_share_modes-1];
+ lck->data->num_share_modes -= 1;
+ lck->data->modified = True;
}
/*******************************************************************
@@ -1106,7 +1120,7 @@ bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
/* 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;
}
@@ -1124,7 +1138,7 @@ bool remove_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
} else {
e->op_type = NO_OPLOCK;
}
- lck->modified = True;
+ lck->data->modified = True;
return True;
}
@@ -1139,13 +1153,13 @@ bool downgrade_share_oplock(struct share_mode_lock *lck, files_struct *fsp)
/* 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;
}
@@ -1182,27 +1196,27 @@ static struct security_unix_token *copy_unix_token(TALLOC_CTX *ctx, const struct
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_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_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;
}
@@ -1222,6 +1236,7 @@ void set_delete_on_close_lck(files_struct *fsp,
bool delete_on_close,
const struct security_unix_token *tok)
{
+ struct share_mode_data *d = lck->data;
int i;
bool ret;
@@ -1231,16 +1246,16 @@ void set_delete_on_close_lck(files_struct *fsp,
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_token);
- *dt = lck->delete_tokens[
- lck->num_delete_tokens-1];
- lck->num_delete_tokens -= 1;
+ *dt = d->delete_tokens[
+ d->num_delete_tokens-1];
+ d->num_delete_tokens -= 1;
return;
}
/* Replace this token with the
@@ -1256,7 +1271,7 @@ void set_delete_on_close_lck(files_struct *fsp,
return;
}
- ret = add_delete_on_close_token(lck, fsp->name_hash, tok);
+ ret = add_delete_on_close_token(lck->data, fsp->name_hash, tok);
SMB_ASSERT(ret);
}
@@ -1297,8 +1312,8 @@ const struct security_unix_token *get_delete_on_close_token(struct share_mode_lo
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) {
@@ -1327,9 +1342,9 @@ bool set_sticky_write_time(struct file_id fileid, struct timespec write_time)
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);
@@ -1350,9 +1365,9 @@ bool set_write_time(struct file_id fileid, struct timespec write_time)
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);
@@ -1376,7 +1391,7 @@ static int traverse_fn(struct db_record *rec, void *_state)
TDB_DATA value;
DATA_BLOB blob;
enum ndr_err_code ndr_err;
- struct share_mode_lock *lck;
+ struct share_mode_data *d;
key = dbwrap_record_get_key(rec);
value = dbwrap_record_get_value(rec);
@@ -1385,8 +1400,8 @@ static int traverse_fn(struct db_record *rec, void *_state)
if (key.dsize != sizeof(struct file_id))
return 0;
- lck = talloc(talloc_tos(), struct share_mode_lock);
- if (lck == NULL) {
+ d = talloc(talloc_tos(), struct share_mode_data);
+ if (d == NULL) {
return 0;
}
@@ -1394,18 +1409,17 @@ static int traverse_fn(struct db_record *rec, void *_state)
blob.length = value.dsize;
ndr_err = ndr_pull_struct_blob(
- &blob, lck, lck,
- (ndr_pull_flags_fn_t)ndr_pull_share_mode_lock);
+ &blob, d, d, (ndr_pull_flags_fn_t)ndr_pull_share_mode_data);
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,
+ for (i=0; i<d->num_share_modes; i++) {
+ state->fn(&d->share_modes[i],
+ d->servicepath, d->base_name,
state->private_data);
}
- TALLOC_FREE(lck);
+ TALLOC_FREE(d);
return 0;
}
diff --git a/source3/smbd/close.c b/source3/smbd/close.c
index a07ab4b42c..131f4bf5d1 100644
--- a/source3/smbd/close.c
+++ b/source3/smbd/close.c
@@ -178,8 +178,8 @@ static void notify_deferred_opens(struct smbd_server_connection *sconn,
}
num_deferred = 0;
- for (i=0; i<lck->num_share_modes; i++) {
- if (is_deferred_open_entry(&lck->share_modes[i])) {
+ for (i=0; i<lck->data->num_share_modes; i++) {
+ if (is_deferred_open_entry(&lck->data->share_modes[i])) {
num_deferred += 1;
}
}
@@ -194,8 +194,8 @@ static void notify_deferred_opens(struct smbd_server_connection *sconn,
}
num_deferred = 0;
- for (i=0; i<lck->num_share_modes; i++) {
- struct share_mode_entry *e = &lck->share_modes[i];
+ for (i=0; i<lck->data->num_share_modes; i++) {
+ struct share_mode_entry *e = &lck->data->share_modes[i];
if (is_deferred_open_entry(e)) {
deferred[num_deferred] = *e;
num_deferred += 1;
@@ -359,7 +359,7 @@ static NTSTATUS close_remove_share_mode(files_struct *fsp,
DEBUG(10,("close_remove_share_mode: write time forced "
"for file %s\n",
fsp_str_dbg(fsp)));
- set_close_write_time(fsp, lck->changed_write_time);
+ set_close_write_time(fsp, lck->data->changed_write_time);
} else if (fsp->update_write_time_on_close) {
/* Someone had a pending write. */
if (null_timespec(fsp->close_write_time)) {
@@ -408,8 +408,8 @@ static NTSTATUS close_remove_share_mode(files_struct *fsp,
/* See if others still have the file open via this pathname.
If this is the case, then don't delete. If all opens are
POSIX delete now. */
- for (i=0; i<lck->num_share_modes; i++) {
- struct share_mode_entry *e = &lck->share_modes[i];
+ for (i=0; i<lck->data->num_share_modes; i++) {
+ struct share_mode_entry *e = &lck->data->share_modes[i];
if (is_valid_share_mode_entry(e) &&
e->name_hash == fsp->name_hash) {
if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
@@ -619,7 +619,7 @@ static NTSTATUS update_write_time_on_close(struct files_struct *fsp)
if (lck) {
/* Close write times overwrite sticky write times
so we must replace any sticky write time here. */
- if (!null_timespec(lck->changed_write_time)) {
+ if (!null_timespec(lck->data->changed_write_time)) {
(void)set_sticky_write_time(fsp->file_id, fsp->close_write_time);
}
TALLOC_FREE(lck);
@@ -1058,8 +1058,8 @@ static NTSTATUS close_directory(struct smb_request *req, files_struct *fsp,
int i;
/* See if others still have the dir open. If this is the
* case, then don't delete. If all opens are POSIX delete now. */
- for (i=0; i<lck->num_share_modes; i++) {
- struct share_mode_entry *e = &lck->share_modes[i];
+ for (i=0; i<lck->data->num_share_modes; i++) {
+ struct share_mode_entry *e = &lck->data->share_modes[i];
if (is_valid_share_mode_entry(e) &&
e->name_hash == fsp->name_hash) {
if (fsp->posix_open && (e->flags & SHARE_MODE_FLAG_POSIX_OPEN)) {
diff --git a/source3/smbd/open.c b/source3/smbd/open.c
index 46d5d28863..7a85552910 100644
--- a/source3/smbd/open.c
+++ b/source3/smbd/open.c
@@ -987,7 +987,7 @@ static NTSTATUS open_mode_check(connection_struct *conn,
{
int i;
- if(lck->num_share_modes == 0) {
+ if(lck->data->num_share_modes == 0) {
return NT_STATUS_OK;
}
@@ -1010,9 +1010,9 @@ static NTSTATUS open_mode_check(connection_struct *conn,
*/
#if defined(DEVELOPER)
- for(i = 0; i < lck->num_share_modes; i++) {
+ for(i = 0; i < lck->data->num_share_modes; i++) {
validate_my_share_entries(conn->sconn, i,
- &lck->share_modes[i]);
+ &lck->data->share_modes[i]);
}
#endif
@@ -1021,15 +1021,15 @@ static NTSTATUS open_mode_check(connection_struct *conn,
}
/* Now we check the share modes, after any oplock breaks. */
- for(i = 0; i < lck->num_share_modes; i++) {
+ for(i = 0; i < lck->data->num_share_modes; i++) {
- if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
+ if (!is_valid_share_mode_entry(&lck->data->share_modes[i])) {
continue;
}
/* someone else has a share lock on it, check to see if we can
* too */
- if (share_conflict(&lck->share_modes[i],
+ if (share_conflict(&lck->data->share_modes[i],
access_mask, share_access)) {
return NT_STATUS_SHARING_VIOLATION;
}
@@ -1115,43 +1115,43 @@ static void find_oplock_types(files_struct *fsp,
return;
}
- for (i=0; i<lck->num_share_modes; i++) {
- if (!is_valid_share_mode_entry(&lck->share_modes[i])) {
+ for (i=0; i<lck->data->num_share_modes; i++) {
+ if (!is_valid_share_mode_entry(&lck->data->share_modes[i])) {
continue;
}
- if (lck->share_modes[i].op_type == NO_OPLOCK &&
- is_stat_open(lck->share_modes[i].access_mask)) {
+ if (lck->data->share_modes[i].op_type == NO_OPLOCK &&
+ is_stat_open(lck->data->share_modes[i].access_mask)) {
/* We ignore stat opens in the table - they
always have NO_OPLOCK and never get or
cause breaks. JRA. */
continue;
}
- if (BATCH_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
+ if (BATCH_OPLOCK_TYPE(lck->data->share_modes[i].op_type)) {
/* batch - can only be one. */
if (*pp_ex_or_batch || *pp_batch || *got_level2 || *got_no_oplock) {
smb_panic("Bad batch oplock entry.");
}
- *pp_batch = &lck->share_modes[i];
+ *pp_batch = &lck->data->share_modes[i];
}
- if (EXCLUSIVE_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
+ if (EXCLUSIVE_OPLOCK_TYPE(lck->data->share_modes[i].op_type)) {
/* Exclusive or batch - can only be one. */
if (*pp_ex_or_batch || *got_level2 || *got_no_oplock) {
smb_panic("Bad exclusive or batch oplock entry.");
}
- *pp_ex_or_batch = &lck->share_modes[i];
+ *pp_ex_or_batch = &lck->data->share_modes[i];
}
- if (LEVEL_II_OPLOCK_TYPE(lck->share_modes[i].op_type)) {
+ if (LEVEL_II_OPLOCK_TYPE(lck->data->share_modes[i].op_type)) {
if (*pp_batch || *pp_ex_or_batch) {
smb_panic("Bad levelII oplock entry.");
}
*got_level2 = true;
}
- if (lck->share_modes[i].op_type == NO_OPLOCK) {
+ if (lck->data->share_modes[i].op_type == NO_OPLOCK) {
if (*pp_batch || *pp_ex_or_batch) {
smb_panic("Bad no oplock entry.");
}
@@ -1296,8 +1296,8 @@ static void defer_open(struct share_mode_lock *lck,
/* Paranoia check */
- for (i=0; i<lck->num_share_modes; i++) {
- struct share_mode_entry *e = &lck->share_modes[i];
+ for (i=0; i<lck->data->num_share_modes; i++) {
+ struct share_mode_entry *e = &lck->data->share_modes[i];
if (is_deferred_open_entry(e) &&
procid_is_me(&e->pid) &&
@@ -1465,7 +1465,7 @@ static void schedule_defer_open(struct share_mode_lock *lck,
a 1 second delay for share mode conflicts. */
state.delayed_for_oplocks = True;
- state.id = lck->id;
+ state.id = lck->data->id;
if (!request_timed_out(request_time, timeout)) {
defer_open(lck, request_time, timeout, req, &state);
diff --git a/source3/smbd/oplock.c b/source3/smbd/oplock.c
index e1731f1e10..2197c7947f 100644
--- a/source3/smbd/oplock.c
+++ b/source3/smbd/oplock.c
@@ -766,10 +766,10 @@ static void contend_level2_oplocks_begin_default(files_struct *fsp,
}
DEBUG(10,("release_level_2_oplocks_on_change: num_share_modes = %d\n",
- lck->num_share_modes ));
+ lck->data->num_share_modes ));
- for(i = 0; i < lck->num_share_modes; i++) {
- struct share_mode_entry *share_entry = &lck->share_modes[i];
+ for(i = 0; i < lck->data->num_share_modes; i++) {
+ struct share_mode_entry *share_entry = &lck->data->share_modes[i];
char msg[MSG_SMB_SHARE_MODE_ENTRY_SIZE];
if (!is_valid_share_mode_entry(share_entry)) {
diff --git a/source3/smbd/reply.c b/source3/smbd/reply.c
index b8da33549c..5b0f7cf6c8 100644
--- a/source3/smbd/reply.c
+++ b/source3/smbd/reply.c
@@ -5855,7 +5855,7 @@ static void rename_open_files(connection_struct *conn,
NTSTATUS status;
uint32_t new_name_hash = 0;
- for(fsp = file_find_di_first(conn->sconn, lck->id); fsp;
+ for(fsp = file_find_di_first(conn->sconn, lck->data->id); fsp;
fsp = file_find_di_next(fsp)) {
/* fsp_name is a relative path under the fsp. To change this for other
sharepaths we need to manipulate relative paths. */
@@ -5881,7 +5881,7 @@ static void rename_open_files(connection_struct *conn,
if (!did_rename) {
DEBUG(10, ("rename_open_files: no open files on file_id %s "
- "for %s\n", file_id_string_tos(&lck->id),
+ "for %s\n", file_id_string_tos(&lck->data->id),
smb_fname_str_dbg(smb_fname_dst)));
}
diff --git a/source3/smbd/trans2.c b/source3/smbd/trans2.c
index 4e86fbfcdd..ba6bcbbb9e 100644
--- a/source3/smbd/trans2.c
+++ b/source3/smbd/trans2.c
@@ -7585,8 +7585,8 @@ static NTSTATUS smb_posix_unlink(connection_struct *conn,
* don't delete. If all opens are POSIX delete we can set the delete
* on close disposition.
*/
- for (i=0; i<lck->num_share_modes; i++) {
- struct share_mode_entry *e = &lck->share_modes[i];
+ for (i=0; i<lck->data->num_share_modes; i++) {
+ struct share_mode_entry *e = &lck->data->share_modes[i];
if (is_valid_share_mode_entry(e)) {
if (e->flags & SHARE_MODE_FLAG_POSIX_OPEN) {
continue;
diff --git a/source3/utils/status.c b/source3/utils/status.c
index 76f6167570..8ae8de76a3 100644
--- a/source3/utils/status.c
+++ b/source3/utils/status.c
@@ -212,11 +212,13 @@ static void print_brl(struct file_id id,
share_mode = fetch_share_mode_unlocked(NULL, id);
if (share_mode) {
- bool has_stream = share_mode->stream_name != NULL;
+ bool has_stream = share_mode->data->stream_name != NULL;
- fname = talloc_asprintf(NULL, "%s%s%s", share_mode->base_name,
+ fname = talloc_asprintf(NULL, "%s%s%s",
+ share_mode->data->base_name,
has_stream ? ":" : "",
- has_stream ? share_mode->stream_name :
+ has_stream ?
+ share_mode->data->stream_name :
"");
} else {
fname = talloc_strdup(NULL, "");
generated by cgit (git 2.34.1) at 2024-06-27 02:51:25 +0000