Copyright (C) Andrew Tridgell 1992-2000
Copyright (C) Jeremy Allison 1992-2006
Copyright (C) Volker Lendecke 2005
-
+
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
-
+
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
-
+
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
September 1997. Jeremy Allison (jallison@whistle.com). Added oplock
support.
- rewrtten completely to use new tdb code. Tridge, Dec '99
+ rewritten completely to use new tdb code. Tridge, Dec '99
Added POSIX locking support. Jeremy Allison (jeremy@valinux.com), Apr. 2000.
Added Unix Extensions POSIX locking support. Jeremy Allison Mar 2006.
#include "system/filesys.h"
#include "locking/proto.h"
#include "smbd/globals.h"
-#include "dbwrap.h"
+#include "dbwrap/dbwrap.h"
+#include "dbwrap/dbwrap_open.h"
#include "../libcli/security/security.h"
#include "serverid.h"
#include "messages.h"
+#include "util_tdb.h"
+#include "../librpc/gen_ndr/ndr_open_files.h"
#undef DBGC_CLASS
#define DBGC_CLASS DBGC_LOCKING
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,
{
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;
}
-
+
if (!lp_locking(fsp->conn->params)) {
return NT_STATUS_OK;
}
-
+
DEBUG(10,("do_unlock: unlock start=%.0f len=%.0f requested for fnum %d file %s\n",
(double)offset, (double)count, fsp->fnum,
fsp_str_dbg(fsp)));
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);
-
+
TALLOC_FREE(br_lck);
if (!ok) {
return fsp->is_directory ?
NT_STATUS_INVALID_DEVICE_REQUEST : NT_STATUS_INVALID_HANDLE;
}
-
+
if (!lp_locking(fsp->conn->params)) {
return NT_STATUS_DOS(ERRDOS, ERRcancelviolation);
}
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,
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);
}
/*******************************************************************
- Print out a share mode table.
+ Get all share mode entries for a dev/inode pair.
********************************************************************/
-static void print_share_mode_table(struct locking_data *data)
+static struct share_mode_data *parse_share_modes(TALLOC_CTX *mem_ctx,
+ const TDB_DATA dbuf)
{
- int num_share_modes = data->u.s.num_share_mode_entries;
- struct share_mode_entry *shares =
- (struct share_mode_entry *)(data + 1);
+ struct share_mode_data *d;
int i;
+ struct server_id *pids;
+ bool *pid_exists;
+ enum ndr_err_code ndr_err;
+ DATA_BLOB blob;
- for (i = 0; i < num_share_modes; i++) {
- struct share_mode_entry entry;
- char *str;
-
- /*
- * We need to memcpy the entry here due to alignment
- * restrictions that are not met when directly accessing
- * shares[i]
- */
-
- memcpy(&entry, &shares[i], sizeof(struct share_mode_entry));
- str = share_mode_str(talloc_tos(), i, &entry);
-
- DEBUG(10,("print_share_mode_table: %s\n", str ? str : ""));
- TALLOC_FREE(str);
+ d = talloc_zero(mem_ctx, struct share_mode_data);
+ if (d == NULL) {
+ DEBUG(0, ("talloc failed\n"));
+ goto fail;
}
-}
-static int parse_delete_tokens_list(struct share_mode_lock *lck,
- struct locking_data *pdata,
- const TDB_DATA dbuf)
-{
- uint8_t *p = dbuf.dptr + sizeof(struct locking_data) +
- (lck->num_share_modes *
- sizeof(struct share_mode_entry));
- uint8_t *end_ptr = dbuf.dptr + (dbuf.dsize - 2);
- int delete_tokens_size = 0;
- int i;
-
- lck->delete_tokens = NULL;
-
- for (i = 0; i < pdata->u.s.num_delete_token_entries; i++) {
- uint32_t token_len;
- struct delete_token_list *pdtl;
-
- if (end_ptr - p < (sizeof(uint32_t) + sizeof(uint32_t) +
- sizeof(uid_t) + sizeof(gid_t))) {
- DEBUG(0,("parse_delete_tokens_list: "
- "corrupt token list (%u)",
- (unsigned int)(end_ptr - p)));
- smb_panic("corrupt token list");
- return -1;
- }
+ blob.data = dbuf.dptr;
+ blob.length = dbuf.dsize;
- memcpy(&token_len, p, sizeof(token_len));
- delete_tokens_size += token_len;
-
- if (p + token_len > end_ptr || token_len < sizeof(token_len) +
- sizeof(pdtl->name_hash) +
- sizeof(uid_t) +
- sizeof(gid_t)) {
- DEBUG(0,("parse_delete_tokens_list: "
- "invalid token length (%u)\n",
- (unsigned int)token_len ));
- smb_panic("invalid token length");
- return -1;
- }
-
- p += sizeof(token_len);
-
- pdtl = TALLOC_ZERO_P(lck, struct delete_token_list);
- if (pdtl == NULL) {
- DEBUG(0,("parse_delete_tokens_list: talloc failed"));
- return -1;
- }
- /* Copy out the name_hash. */
- memcpy(&pdtl->name_hash, p, sizeof(pdtl->name_hash));
- p += sizeof(pdtl->name_hash);
-
- pdtl->delete_token = TALLOC_ZERO_P(pdtl, struct security_unix_token);
- if (pdtl->delete_token == NULL) {
- DEBUG(0,("parse_delete_tokens_list: talloc failed"));
- return -1;
- }
-
- /* Copy out the uid and gid. */
- memcpy(&pdtl->delete_token->uid, p, sizeof(uid_t));
- p += sizeof(uid_t);
- memcpy(&pdtl->delete_token->gid, p, sizeof(gid_t));
- p += sizeof(gid_t);
-
- token_len -= (sizeof(token_len) + sizeof(pdtl->name_hash) +
- sizeof(uid_t) + sizeof(gid_t));
-
- /* Any supplementary groups ? */
- if (token_len) {
- int j;
-
- if (token_len % sizeof(gid_t) != 0) {
- DEBUG(0,("parse_delete_tokens_list: "
- "corrupt group list (%u)",
- (unsigned int)(token_len % sizeof(gid_t)) ));
- smb_panic("corrupt group list");
- return -1;
- }
-
- pdtl->delete_token->ngroups = token_len / sizeof(gid_t);
- pdtl->delete_token->groups = TALLOC_ARRAY(pdtl->delete_token, gid_t,
- pdtl->delete_token->ngroups);
- if (pdtl->delete_token->groups == NULL) {
- DEBUG(0,("parse_delete_tokens_list: talloc failed"));
- return -1;
- }
-
- for (j = 0; j < pdtl->delete_token->ngroups; j++) {
- memcpy(&pdtl->delete_token->groups[j], p, sizeof(gid_t));
- p += sizeof(gid_t);
- }
- }
- /* Add to the list. */
- DLIST_ADD(lck->delete_tokens, pdtl);
+ ndr_err = ndr_pull_struct_blob(
+ &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;
}
- return delete_tokens_size;
-}
-
-/*******************************************************************
- Get all share mode entries for a dev/inode pair.
-********************************************************************/
-
-static bool parse_share_modes(const TDB_DATA dbuf, struct share_mode_lock *lck)
-{
- struct locking_data data;
- int delete_tokens_size;
- int i;
+ d->modified = false;
+ d->fresh = false;
- if (dbuf.dsize < sizeof(struct locking_data)) {
- smb_panic("parse_share_modes: buffer too short");
+ if (DEBUGLEVEL >= 10) {
+ DEBUG(10, ("parse_share_modes:\n"));
+ NDR_PRINT_DEBUG(share_mode_data, d);
}
- memcpy(&data, dbuf.dptr, sizeof(data));
-
- lck->old_write_time = data.u.s.old_write_time;
- lck->changed_write_time = data.u.s.changed_write_time;
- lck->num_share_modes = data.u.s.num_share_mode_entries;
-
- DEBUG(10, ("parse_share_modes: owrt: %s, "
- "cwrt: %s, ntok: %u, num_share_modes: %d\n",
- timestring(talloc_tos(),
- convert_timespec_to_time_t(lck->old_write_time)),
- timestring(talloc_tos(),
- convert_timespec_to_time_t(
- lck->changed_write_time)),
- (unsigned int)data.u.s.num_delete_token_entries,
- lck->num_share_modes));
+ /*
+ * Ensure that each entry has a real process attached.
+ */
- if ((lck->num_share_modes < 0) || (lck->num_share_modes > 1000000)) {
- DEBUG(0, ("invalid number of share modes: %d\n",
- lck->num_share_modes));
- smb_panic("parse_share_modes: invalid number of share modes");
+ pids = talloc_array(talloc_tos(), struct server_id,
+ d->num_share_modes);
+ if (pids == NULL) {
+ DEBUG(0, ("talloc failed\n"));
+ goto fail;
}
-
- lck->share_modes = NULL;
-
- if (lck->num_share_modes != 0) {
-
- if (dbuf.dsize < (sizeof(struct locking_data) +
- (lck->num_share_modes *
- sizeof(struct share_mode_entry)))) {
- smb_panic("parse_share_modes: buffer too short");
- }
-
- lck->share_modes = (struct share_mode_entry *)
- TALLOC_MEMDUP(lck,
- dbuf.dptr+sizeof(struct locking_data),
- lck->num_share_modes *
- sizeof(struct share_mode_entry));
-
- if (lck->share_modes == NULL) {
- smb_panic("parse_share_modes: talloc failed");
- }
+ pid_exists = talloc_array(talloc_tos(), bool, d->num_share_modes);
+ if (pid_exists == NULL) {
+ DEBUG(0, ("talloc failed\n"));
+ goto fail;
}
- /* Get any delete tokens. */
- delete_tokens_size = parse_delete_tokens_list(lck, &data, dbuf);
- if (delete_tokens_size < 0) {
- smb_panic("parse_share_modes: parse_delete_tokens_list failed");
+ for (i=0; i<d->num_share_modes; i++) {
+ pids[i] = d->share_modes[i].pid;
+ }
+ if (!serverids_exist(pids, d->num_share_modes, pid_exists)) {
+ DEBUG(0, ("serverid_exists failed\n"));
+ goto fail;
}
- /* Save off the associated service path and filename. */
- lck->servicepath = (const char *)dbuf.dptr + sizeof(struct locking_data) +
- (lck->num_share_modes * sizeof(struct share_mode_entry)) +
- delete_tokens_size;
-
- lck->base_name = (const char *)dbuf.dptr + sizeof(struct locking_data) +
- (lck->num_share_modes * sizeof(struct share_mode_entry)) +
- delete_tokens_size +
- strlen(lck->servicepath) + 1;
-
- lck->stream_name = (const char *)dbuf.dptr + sizeof(struct locking_data) +
- (lck->num_share_modes * sizeof(struct share_mode_entry)) +
- delete_tokens_size +
- strlen(lck->servicepath) + 1 +
- strlen(lck->base_name) + 1;
-
- /*
- * Ensure that each entry has a real process attached.
- */
-
- for (i = 0; i < lck->num_share_modes; i++) {
- struct share_mode_entry *entry_p = &lck->share_modes[i];
- char *str = NULL;
- if (DEBUGLEVEL >= 10) {
- str = share_mode_str(NULL, i, entry_p);
- }
- DEBUG(10,("parse_share_modes: %s\n",
- str ? str : ""));
- if (!serverid_exists(&entry_p->pid)) {
- DEBUG(10,("parse_share_modes: deleted %s\n",
- str ? str : ""));
- entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
- lck->modified = True;
+ i = 0;
+ while (i < d->num_share_modes) {
+ struct share_mode_entry *e = &d->share_modes[i];
+ if (!pid_exists[i]) {
+ *e = d->share_modes[d->num_share_modes-1];
+ d->num_share_modes -= 1;
+ d->modified = True;
+ continue;
}
- TALLOC_FREE(str);
+ i += 1;
}
-
- return True;
+ TALLOC_FREE(pid_exists);
+ TALLOC_FREE(pids);
+ return d;
+fail:
+ TALLOC_FREE(d);
+ return NULL;
}
-static TDB_DATA unparse_share_modes(const struct share_mode_lock *lck)
+static TDB_DATA unparse_share_modes(struct share_mode_data *d)
{
- TDB_DATA result;
- int num_valid = 0;
- int i;
- struct locking_data *data;
- ssize_t offset;
- ssize_t sp_len, bn_len, sn_len;
- uint32_t delete_tokens_size = 0;
- struct delete_token_list *pdtl = NULL;
- uint32_t num_delete_token_entries = 0;
-
- result.dptr = NULL;
- result.dsize = 0;
-
- for (i=0; i<lck->num_share_modes; i++) {
- if (!is_unused_share_mode_entry(&lck->share_modes[i])) {
- num_valid += 1;
- }
- }
+ DATA_BLOB blob;
+ enum ndr_err_code ndr_err;
- if (num_valid == 0) {
- return result;
- }
-
- sp_len = strlen(lck->servicepath);
- bn_len = strlen(lck->base_name);
- sn_len = lck->stream_name != NULL ? strlen(lck->stream_name) : 0;
-
- for (pdtl = lck->delete_tokens; pdtl; pdtl = pdtl->next) {
- num_delete_token_entries++;
- delete_tokens_size += (sizeof(uint32_t) +
- sizeof(uint32_t) +
- sizeof(uid_t) +
- sizeof(gid_t) +
- pdtl->delete_token->ngroups*sizeof(gid_t));
- }
-
- result.dsize = sizeof(*data) +
- lck->num_share_modes * sizeof(struct share_mode_entry) +
- delete_tokens_size +
- sp_len + 1 +
- bn_len + 1 +
- sn_len + 1;
- result.dptr = TALLOC_ARRAY(lck, uint8, result.dsize);
-
- if (result.dptr == NULL) {
- smb_panic("talloc failed");
- }
-
- data = (struct locking_data *)result.dptr;
- ZERO_STRUCTP(data);
- data->u.s.num_share_mode_entries = lck->num_share_modes;
- data->u.s.old_write_time = lck->old_write_time;
- data->u.s.changed_write_time = lck->changed_write_time;
- data->u.s.num_delete_token_entries = num_delete_token_entries;
-
- DEBUG(10,("unparse_share_modes: owrt: %s cwrt: %s, ntok: %u, "
- "num: %d\n",
- timestring(talloc_tos(),
- convert_timespec_to_time_t(lck->old_write_time)),
- timestring(talloc_tos(),
- convert_timespec_to_time_t(
- lck->changed_write_time)),
- (unsigned int)data->u.s.num_delete_token_entries,
- data->u.s.num_share_mode_entries));
-
- memcpy(result.dptr + sizeof(*data), lck->share_modes,
- sizeof(struct share_mode_entry)*lck->num_share_modes);
- offset = sizeof(*data) +
- sizeof(struct share_mode_entry)*lck->num_share_modes;
-
- /* Store any delete on close tokens. */
- for (pdtl = lck->delete_tokens; pdtl; pdtl = pdtl->next) {
- struct security_unix_token *pdt = pdtl->delete_token;
- uint32_t token_size = sizeof(uint32_t) +
- sizeof(uint32_t) +
- sizeof(uid_t) +
- sizeof(gid_t) +
- (pdt->ngroups * sizeof(gid_t));
- uint8_t *p = result.dptr + offset;
-
- memcpy(p, &token_size, sizeof(uint32_t));
- p += sizeof(uint32_t);
-
- memcpy(p, &pdtl->name_hash, sizeof(uint32_t));
- p += sizeof(uint32_t);
-
- memcpy(p, &pdt->uid, sizeof(uid_t));
- p += sizeof(uid_t);
-
- memcpy(p, &pdt->gid, sizeof(gid_t));
- p += sizeof(gid_t);
-
- for (i = 0; i < pdt->ngroups; i++) {
- memcpy(p, &pdt->groups[i], sizeof(gid_t));
- p += sizeof(gid_t);
- }
- offset += token_size;
+ if (DEBUGLEVEL >= 10) {
+ DEBUG(10, ("unparse_share_modes:\n"));
+ NDR_PRINT_DEBUG(share_mode_data, d);
}
- safe_strcpy((char *)result.dptr + offset, lck->servicepath,
- result.dsize - offset - 1);
- offset += sp_len + 1;
- 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 (d->num_share_modes == 0) {
+ DEBUG(10, ("No used share mode found\n"));
+ return make_tdb_data(NULL, 0);
+ }
- if (DEBUGLEVEL >= 10) {
- print_share_mode_table(data);
+ ndr_err = ndr_push_struct_blob(
+ &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");
}
- return result;
+ 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 = lck->record->delete_rec(lck->record);
+ status = dbwrap_record_delete(d->record);
if (!NT_STATUS_IS_OK(status)) {
char *errmsg;
goto done;
}
- status = lck->record->store(lck->record, data, TDB_REPLACE);
+ status = dbwrap_record_store(d->record, data, TDB_REPLACE);
if (!NT_STATUS_IS_OK(status)) {
char *errmsg;
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)
+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)
{
- /* 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->delete_tokens = NULL;
- ZERO_STRUCT(lck->old_write_time);
- ZERO_STRUCT(lck->changed_write_time);
- lck->fresh = False;
- lck->modified = False;
-
- lck->fresh = (share_mode_data.dptr == NULL);
-
- if (lck->fresh) {
- bool has_stream;
- if (smb_fname == NULL || servicepath == NULL
- || old_write_time == NULL) {
- return False;
- }
+ struct share_mode_data *d;
- has_stream = smb_fname->stream_name != NULL;
+ if ((servicepath == NULL) || (smb_fname == NULL) ||
+ (old_write_time == NULL)) {
+ return NULL;
+ }
- lck->base_name = talloc_strdup(lck, smb_fname->base_name);
- lck->stream_name = talloc_strdup(lck, smb_fname->stream_name);
- lck->servicepath = talloc_strdup(lck, servicepath);
- if (lck->base_name == NULL ||
- (has_stream && lck->stream_name == NULL) ||
- lck->servicepath == NULL) {
- DEBUG(0, ("talloc failed\n"));
- return False;
- }
- lck->old_write_time = *old_write_time;
- } else {
- if (!parse_share_modes(share_mode_data, lck)) {
- DEBUG(0, ("Could not parse share modes\n"));
- return False;
+ d = talloc_zero(mem_ctx, struct share_mode_data);
+ if (d == NULL) {
+ goto fail;
+ }
+ d->base_name = talloc_strdup(d, smb_fname->base_name);
+ if (d->base_name == NULL) {
+ goto fail;
+ }
+ if (smb_fname->stream_name != NULL) {
+ d->stream_name = talloc_strdup(d, smb_fname->stream_name);
+ if (d->stream_name == NULL) {
+ goto fail;
}
}
-
- return True;
+ d->servicepath = talloc_strdup(d, servicepath);
+ if (d->servicepath == NULL) {
+ goto fail;
+ }
+ d->old_write_time = *old_write_time;
+ d->modified = false;
+ d->fresh = true;
+ return d;
+fail:
+ DEBUG(0, ("talloc failed\n"));
+ TALLOC_FREE(d);
+ return NULL;
}
-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 *get_share_mode_lock_fresh(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 share_mode_data *d;
struct file_id tmp;
+ struct db_record *rec;
TDB_DATA key = locking_key(&id, &tmp);
+ TDB_DATA value;
- if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
- DEBUG(0, ("talloc failed\n"));
+ rec = dbwrap_fetch_locked(lock_db, mem_ctx, key);
+ if (rec == NULL) {
+ DEBUG(3, ("Could not lock share entry\n"));
return NULL;
}
- if (!(lck->record = lock_db->fetch_locked(lock_db, lck, key))) {
- DEBUG(3, ("Could not lock share entry\n"));
- TALLOC_FREE(lck);
- return NULL;
+ value = dbwrap_record_get_value(rec);
+
+ if (value.dptr == NULL) {
+ d = fresh_share_mode_lock(mem_ctx, servicepath, smb_fname,
+ old_write_time);
+ } else {
+ d = parse_share_modes(mem_ctx, value);
}
- 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);
+ if (d == NULL) {
+ DEBUG(1, ("Could not get share mode lock\n"));
+ TALLOC_FREE(rec);
return NULL;
}
+ d->id = id;
+ d->record = talloc_move(d, &rec);
+ talloc_set_destructor(d, share_mode_data_destructor);
- talloc_set_destructor(lck, share_mode_lock_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;
}
+struct share_mode_lock *get_share_mode_lock(TALLOC_CTX *mem_ctx,
+ const struct file_id id)
+{
+ return get_share_mode_lock_fresh(mem_ctx, id, NULL, NULL, NULL);
+}
+
struct share_mode_lock *fetch_share_mode_unlocked(TALLOC_CTX *mem_ctx,
const struct file_id id)
{
struct file_id tmp;
TDB_DATA key = locking_key(&id, &tmp);
TDB_DATA data;
+ NTSTATUS status;
- if (!(lck = TALLOC_P(mem_ctx, struct share_mode_lock))) {
- DEBUG(0, ("talloc failed\n"));
+ status = dbwrap_fetch(lock_db, talloc_tos(), key, &data);
+ if (!NT_STATUS_IS_OK(status)) {
+ DEBUG(3, ("Could not fetch share entry\n"));
return NULL;
}
-
- if (lock_db->fetch(lock_db, lck, key, &data) == -1) {
- DEBUG(3, ("Could not fetch share entry\n"));
- TALLOC_FREE(lck);
+ if (data.dptr == NULL) {
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"));
+ 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;
}
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 ));
- 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);
+ strlcpy(&frm[24],
+ d->servicepath ? d->servicepath : "",
+ sp_len+1);
+ strlcpy(&frm[24 + sp_len + 1],
+ d->base_name ? d->base_name : "",
+ bn_len+1);
+ strlcpy(&frm[24 + sp_len + 1 + bn_len + 1],
+ 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;
}
-/****************************************************************************
- Check if setting delete on close is allowed on this fsp.
-****************************************************************************/
-
-NTSTATUS can_set_delete_on_close(files_struct *fsp, uint32 dosmode)
-{
- /*
- * Only allow delete on close for writable files.
- */
-
- if ((dosmode & aRONLY) &&
- !lp_delete_readonly(SNUM(fsp->conn))) {
- DEBUG(10,("can_set_delete_on_close: file %s delete on close "
- "flag set but file attribute is readonly.\n",
- fsp_str_dbg(fsp)));
- return NT_STATUS_CANNOT_DELETE;
- }
-
- /*
- * Only allow delete on close for writable shares.
- */
-
- if (!CAN_WRITE(fsp->conn)) {
- DEBUG(10,("can_set_delete_on_close: file %s delete on "
- "close flag set but write access denied on share.\n",
- fsp_str_dbg(fsp)));
- return NT_STATUS_ACCESS_DENIED;
- }
-
- /*
- * Only allow delete on close for files/directories opened with delete
- * intent.
- */
-
- if (!(fsp->access_mask & DELETE_ACCESS)) {
- DEBUG(10,("can_set_delete_on_close: file %s delete on "
- "close flag set but delete access denied.\n",
- fsp_str_dbg(fsp)));
- return NT_STATUS_ACCESS_DENIED;
- }
-
- /* Don't allow delete on close for non-empty directories. */
- if (fsp->is_directory) {
- SMB_ASSERT(!is_ntfs_stream_smb_fname(fsp->fsp_name));
- return can_delete_directory(fsp->conn,
- fsp->fsp_name->base_name);
- }
-
- return NT_STATUS_OK;
-}
-
/*************************************************************************
Return a talloced copy of a struct security_unix_token. NULL on fail.
(Should this be in locking.c.... ?).
{
struct security_unix_token *cpy;
- cpy = TALLOC_P(ctx, struct security_unix_token);
+ cpy = talloc(ctx, struct security_unix_token);
if (!cpy) {
return NULL;
}
cpy->ngroups = tok->ngroups;
if (tok->ngroups) {
/* Make this a talloc child of cpy. */
- cpy->groups = TALLOC_ARRAY(cpy, gid_t, tok->ngroups);
+ cpy->groups = (gid_t *)talloc_memdup(
+ cpy, tok->groups, tok->ngroups * sizeof(gid_t));
if (!cpy->groups) {
+ TALLOC_FREE(cpy);
return NULL;
}
- memcpy(cpy->groups, tok->groups, tok->ngroups * sizeof(gid_t));
}
return cpy;
}
Adds a delete on close token.
****************************************************************************/
-static bool add_delete_on_close_token(struct share_mode_lock *lck,
+static bool add_delete_on_close_token(struct share_mode_data *d,
uint32_t name_hash,
const struct security_unix_token *tok)
{
- struct delete_token_list *dtl;
+ struct delete_token *tmp, *dtl;
- dtl = TALLOC_ZERO_P(lck, struct delete_token_list);
- if (dtl == NULL) {
+ tmp = talloc_realloc(d, d->delete_tokens, struct delete_token,
+ d->num_delete_tokens+1);
+ if (tmp == NULL) {
return false;
}
+ d->delete_tokens = tmp;
+ dtl = &d->delete_tokens[d->num_delete_tokens];
dtl->name_hash = name_hash;
- dtl->delete_token = copy_unix_token(lck, tok);
+ dtl->delete_token = copy_unix_token(d->delete_tokens, tok);
if (dtl->delete_token == NULL) {
- TALLOC_FREE(dtl);
return false;
}
- DLIST_ADD(lck->delete_tokens, dtl);
- lck->modified = true;
+ d->num_delete_tokens += 1;
+ d->modified = true;
return true;
}
bool delete_on_close,
const struct security_unix_token *tok)
{
- struct delete_token_list *dtl;
+ struct share_mode_data *d = lck->data;
+ int i;
bool ret;
if (delete_on_close) {
SMB_ASSERT(tok == NULL);
}
- for (dtl = lck->delete_tokens; dtl; dtl = dtl->next) {
- if (dtl->name_hash == fsp->name_hash) {
- lck->modified = true;
+ for (i=0; i<d->num_delete_tokens; i++) {
+ struct delete_token *dt = &d->delete_tokens[i];
+ if (dt->name_hash == fsp->name_hash) {
+ d->modified = true;
if (delete_on_close == false) {
/* Delete this entry. */
- DLIST_REMOVE(lck->delete_tokens, dtl);
- TALLOC_FREE(dtl);
+ TALLOC_FREE(dt->delete_token);
+ *dt = d->delete_tokens[
+ d->num_delete_tokens-1];
+ d->num_delete_tokens -= 1;
return;
}
/* Replace this token with the
given tok. */
- TALLOC_FREE(dtl->delete_token);
- dtl->delete_token = copy_unix_token(dtl, tok);
- SMB_ASSERT(dtl->delete_token != NULL);
+ TALLOC_FREE(dt->delete_token);
+ dt->delete_token = copy_unix_token(dt, tok);
+ SMB_ASSERT(dt->delete_token != NULL);
}
}
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);
}
bool set_delete_on_close(files_struct *fsp, bool delete_on_close, const struct security_unix_token *tok)
{
struct share_mode_lock *lck;
-
+
DEBUG(10,("set_delete_on_close: %s delete on close flag for "
"fnum = %d, file %s\n",
delete_on_close ? "Adding" : "Removing", fsp->fnum,
fsp_str_dbg(fsp)));
- lck = get_share_mode_lock(talloc_tos(), fsp->file_id, NULL, NULL,
- NULL);
+ lck = get_share_mode_lock(talloc_tos(), fsp->file_id);
if (lck == NULL) {
return False;
}
const struct security_unix_token *get_delete_on_close_token(struct share_mode_lock *lck, uint32_t name_hash)
{
- struct delete_token_list *dtl;
+ int i;
DEBUG(10,("get_delete_on_close_token: name_hash = 0x%x\n",
(unsigned int)name_hash ));
- for (dtl = lck->delete_tokens; dtl; dtl = dtl->next) {
+ 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)dtl->name_hash ));
- if (dtl->name_hash == name_hash) {
- return dtl->delete_token;
+ (unsigned int)dt->name_hash ));
+ if (dt->name_hash == name_hash) {
+ return dt->delete_token;
}
}
return NULL;
convert_timespec_to_time_t(write_time)),
file_id_string_tos(&fileid)));
- lck = get_share_mode_lock(NULL, fileid, NULL, NULL, NULL);
+ lck = get_share_mode_lock(talloc_tos(), fileid);
if (lck == NULL) {
return False;
}
- if (timespec_compare(&lck->changed_write_time, &write_time) != 0) {
- lck->modified = True;
- lck->changed_write_time = write_time;
+ if (timespec_compare(&lck->data->changed_write_time, &write_time) != 0) {
+ lck->data->modified = True;
+ lck->data->changed_write_time = write_time;
}
TALLOC_FREE(lck);
convert_timespec_to_time_t(write_time)),
file_id_string_tos(&fileid)));
- lck = get_share_mode_lock(NULL, fileid, NULL, NULL, NULL);
+ lck = get_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);
static int traverse_fn(struct db_record *rec, void *_state)
{
struct forall_state *state = (struct forall_state *)_state;
- struct locking_data *data;
- struct share_mode_entry *shares;
- const char *sharepath;
- const char *fname;
- const char *del_tokens;
- uint32_t total_del_token_size = 0;
- int i;
+ uint32_t i;
+ TDB_DATA key;
+ TDB_DATA value;
+ DATA_BLOB blob;
+ enum ndr_err_code ndr_err;
+ struct share_mode_data *d;
+
+ key = dbwrap_record_get_key(rec);
+ value = dbwrap_record_get_value(rec);
/* Ensure this is a locking_key record. */
- if (rec->key.dsize != sizeof(struct file_id))
+ if (key.dsize != sizeof(struct file_id))
return 0;
- data = (struct locking_data *)rec->value.dptr;
- shares = (struct share_mode_entry *)(rec->value.dptr + sizeof(*data));
- del_tokens = (const char *)rec->value.dptr + sizeof(*data) +
- data->u.s.num_share_mode_entries*sizeof(*shares);
-
- for (i = 0; i < data->u.s.num_delete_token_entries; i++) {
- uint32_t del_token_size;
- memcpy(&del_token_size, del_tokens, sizeof(uint32_t));
- total_del_token_size += del_token_size;
- del_tokens += del_token_size;
+ d = talloc(talloc_tos(), struct share_mode_data);
+ if (d == NULL) {
+ return 0;
}
- sharepath = (const char *)rec->value.dptr + sizeof(*data) +
- data->u.s.num_share_mode_entries*sizeof(*shares) +
- total_del_token_size;
- fname = (const char *)rec->value.dptr + sizeof(*data) +
- data->u.s.num_share_mode_entries*sizeof(*shares) +
- total_del_token_size +
- strlen(sharepath) + 1;
+ blob.data = value.dptr;
+ blob.length = value.dsize;
- for (i=0;i<data->u.s.num_share_mode_entries;i++) {
- state->fn(&shares[i], sharepath, fname,
+ ndr_err = ndr_pull_struct_blob(
+ &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<d->num_share_modes; i++) {
+ state->fn(&d->share_modes[i],
+ d->servicepath, d->base_name,
state->private_data);
}
+ TALLOC_FREE(d);
+
return 0;
}
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;
- return lock_db->traverse_read(lock_db, traverse_fn, (void *)&state);
+ 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 / ira / wip.git / blobdiff