#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
(unsigned int)e->name_hash);
}
-/*******************************************************************
- Print out a share mode table.
-********************************************************************/
-
-static void print_share_mode_table(struct locking_data *data)
-{
- int num_share_modes = data->u.s.num_share_mode_entries;
- struct share_mode_entry *shares =
- (struct share_mode_entry *)(data + 1);
- int i;
-
- 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);
- }
-}
-
-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->num_delete_tokens = 0;
- lck->delete_tokens = NULL;
-
- for (i = 0; i < pdata->u.s.num_delete_token_entries; i++) {
- uint32_t token_len;
- struct delete_token *pdt;
-
- 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;
- }
-
- memcpy(&token_len, p, sizeof(token_len));
- delete_tokens_size += token_len;
-
- if (p + token_len > end_ptr || token_len < sizeof(token_len) +
- sizeof(pdt->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);
-
- lck->delete_tokens = talloc_realloc(
- lck, lck->delete_tokens, struct delete_token,
- lck->num_delete_tokens+1);
-
- if (lck->delete_tokens == NULL) {
- DEBUG(0, ("parse_delete_tokens_list: talloc failed"));
- return -1;
- }
- pdt = &lck->delete_tokens[lck->num_delete_tokens];
-
- /* Copy out the name_hash. */
- memcpy(&pdt->name_hash, p, sizeof(pdt->name_hash));
- p += sizeof(pdt->name_hash);
-
- pdt->delete_token = talloc_zero(
- lck->delete_tokens, struct security_unix_token);
- if (pdt->delete_token == NULL) {
- DEBUG(0,("parse_delete_tokens_list: talloc failed"));
- return -1;
- }
-
- /* Copy out the uid and gid. */
- memcpy(&pdt->delete_token->uid, p, sizeof(uid_t));
- p += sizeof(uid_t);
- memcpy(&pdt->delete_token->gid, p, sizeof(gid_t));
- p += sizeof(gid_t);
-
- token_len -= (sizeof(token_len) + sizeof(pdt->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;
- }
-
- pdt->delete_token->ngroups = token_len / sizeof(gid_t);
- pdt->delete_token->groups = talloc_array(
- pdt->delete_token, gid_t,
- pdt->delete_token->ngroups);
- if (pdt->delete_token->groups == NULL) {
- DEBUG(0,("parse_delete_tokens_list: talloc failed"));
- return -1;
- }
-
- for (j = 0; j < pdt->delete_token->ngroups; j++) {
- memcpy(&pdt->delete_token->groups[j], p,
- sizeof(gid_t));
- p += sizeof(gid_t);
- }
- }
- lck->num_delete_tokens += 1;
- }
-
- 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;
struct server_id *pids;
bool *pid_exists;
+ enum ndr_err_code ndr_err;
+ DATA_BLOB blob;
- if (dbuf.dsize < sizeof(struct locking_data)) {
- smb_panic("parse_share_modes: buffer too short");
- }
-
- 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;
+ blob.data = dbuf.dptr;
+ blob.length = dbuf.dsize;
- 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));
-
- 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");
+ 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->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");
- }
- }
+ lck->modified = false;
- /* 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");
+ if (DEBUGLEVEL >= 10) {
+ DEBUG(10, ("parse_share_modes:\n"));
+ NDR_PRINT_DEBUG(share_mode_lock, lck);
}
- /* 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(talloc_tos(), i, entry_p);
- }
- DEBUG(10,("parse_share_modes: %s\n",
- str ? str : ""));
if (!pid_exists[i]) {
- DEBUG(10,("parse_share_modes: deleted %s\n",
- str ? str : ""));
entry_p->op_type = UNUSED_SHARE_MODE_ENTRY;
lck->modified = True;
}
- TALLOC_FREE(str);
}
TALLOC_FREE(pid_exists);
TALLOC_FREE(pids);
return True;
}
-static TDB_DATA unparse_share_modes(const struct share_mode_lock *lck)
+static TDB_DATA unparse_share_modes(struct share_mode_lock *lck)
{
- TDB_DATA result;
- int num_valid = 0;
- int i;
- struct locking_data *data;
- ssize_t offset;
- ssize_t sp_len, bn_len, sn_len;
- uint32_t delete_tokens_size = 0;
+ DATA_BLOB blob;
+ enum ndr_err_code ndr_err;
+ uint32_t i;
- result.dptr = NULL;
- result.dsize = 0;
+ 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])) {
- num_valid += 1;
+ break;
}
}
-
- 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 (i=0; i<lck->num_delete_tokens; i++) {
- struct delete_token *pdt = &lck->delete_tokens[i];
- delete_tokens_size +=
- (sizeof(uint32_t) +
- sizeof(uint32_t) +
- sizeof(uid_t) +
- sizeof(gid_t) +
- pdt->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 = lck->num_delete_tokens;
-
- 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 (i=0; i<lck->num_delete_tokens; i++) {
- struct delete_token *pdtl = &lck->delete_tokens[i];
- 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 (i == lck->num_share_modes) {
+ DEBUG(10, ("No used share mode found\n"));
+ return make_tdb_data(NULL, 0);
}
- strlcpy((char *)result.dptr + offset,
- lck->servicepath ? lck->servicepath : "",
- result.dsize - offset);
- offset += sp_len + 1;
- strlcpy((char *)result.dptr + offset,
- lck->base_name ? lck->base_name : "",
- result.dsize - offset);
- offset += bn_len + 1;
- strlcpy((char *)result.dptr + offset,
- lck->stream_name ? lck->stream_name : "",
- result.dsize - offset);
-
- if (DEBUGLEVEL >= 10) {
- print_share_mode_table(data);
+ 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 result;
+ return make_tdb_data(blob.data, blob.length);
}
static int share_mode_lock_destructor(struct share_mode_lock *lck)
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->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);
+ fresh = (share_mode_data.dptr == NULL);
- if (lck->fresh) {
+ if (fresh) {
bool has_stream;
if (smb_fname == NULL || servicepath == NULL
|| old_write_time == NULL) {
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 *lck;
struct file_id tmp;
+ struct db_record *rec;
TDB_DATA key = locking_key(&id, &tmp);
TDB_DATA value;
return NULL;
}
- if (!(lck->record = dbwrap_fetch_locked(lock_db, lck, key))) {
+ 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(lck->record);
+ value = dbwrap_record_get_value(rec);
if (!fill_share_mode_lock(lck, id, servicepath, smb_fname,
value, old_write_time)) {
return NULL;
}
+ lck->record = rec;
talloc_set_destructor(lck, share_mode_lock_destructor);
return 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_lock *lck;
key = dbwrap_record_get_key(rec);
value = dbwrap_record_get_value(rec);
if (key.dsize != sizeof(struct file_id))
return 0;
- data = (struct locking_data *)value.dptr;
- shares = (struct share_mode_entry *)(value.dptr + sizeof(*data));
- del_tokens = (const char *)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;
+ lck = talloc(talloc_tos(), struct share_mode_lock);
+ if (lck == NULL) {
+ return 0;
}
- sharepath = (const char *)value.dptr + sizeof(*data) +
- data->u.s.num_share_mode_entries*sizeof(*shares) +
- total_del_token_size;
- fname = (const char *)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, 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;
}
git.samba.org / mat / samba.git / commitdiff