static NTSTATUS smbXsrv_open_table_init(struct smbXsrv_connection *conn,
uint32_t lowest_id,
uint32_t highest_id,
uint32_t max_opens)
{
struct smbXsrv_client *client = conn->client;
struct smbXsrv_open_table *table;
NTSTATUS status;
uint64_t max_range;
if (lowest_id > highest_id) {
return NT_STATUS_INTERNAL_ERROR;
}
max_range = highest_id;
max_range -= lowest_id;
max_range += 1;
if (max_opens > max_range) {
return NT_STATUS_INTERNAL_ERROR;
}
table = talloc_zero(client, struct smbXsrv_open_table);
if (table == NULL) {
return NT_STATUS_NO_MEMORY;
}
table->local.db_ctx = db_open_rbt(table);
if (table->local.db_ctx == NULL) {
TALLOC_FREE(table);
return NT_STATUS_NO_MEMORY;
}
table->local.replay_cache_db_ctx = db_open_rbt(table);
if (table->local.replay_cache_db_ctx == NULL) {
TALLOC_FREE(table);
return NT_STATUS_NO_MEMORY;
}
table->local.lowest_id = lowest_id;
table->local.highest_id = highest_id;
table->local.max_opens = max_opens;
status = smbXsrv_open_global_init();
if (!NT_STATUS_IS_OK(status)) {
TALLOC_FREE(table);
return status;
}
table->global.db_ctx = smbXsrv_open_global_db_ctx;
client->open_table = table;
return NT_STATUS_OK;
}
static NTSTATUS smbXsrv_session_table_init(struct smbXsrv_connection *conn,
uint32_t lowest_id,
uint32_t highest_id,
uint32_t max_sessions)
{
struct smbXsrv_client *client = conn->client;
struct smbXsrv_session_table *table;
NTSTATUS status;
struct tevent_req *subreq;
uint64_t max_range;
if (lowest_id > highest_id) {
return NT_STATUS_INTERNAL_ERROR;
}
max_range = highest_id;
max_range -= lowest_id;
max_range += 1;
if (max_sessions > max_range) {
return NT_STATUS_INTERNAL_ERROR;
}
table = talloc_zero(client, struct smbXsrv_session_table);
if (table == NULL) {
return NT_STATUS_NO_MEMORY;
}
table->local.db_ctx = db_open_rbt(table);
if (table->local.db_ctx == NULL) {
TALLOC_FREE(table);
return NT_STATUS_NO_MEMORY;
}
table->local.lowest_id = lowest_id;
table->local.highest_id = highest_id;
table->local.max_sessions = max_sessions;
status = smbXsrv_session_global_init();
if (!NT_STATUS_IS_OK(status)) {
TALLOC_FREE(table);
return status;
}
table->global.db_ctx = smbXsrv_session_global_db_ctx;
dbwrap_watch_db(table->global.db_ctx, client->msg_ctx);
subreq = messaging_read_send(table, client->ev_ctx, client->msg_ctx,
MSG_SMBXSRV_SESSION_CLOSE);
if (subreq == NULL) {
TALLOC_FREE(table);
return NT_STATUS_NO_MEMORY;
}
tevent_req_set_callback(subreq, smbXsrv_session_close_loop, client);
client->session_table = table;
return NT_STATUS_OK;
}
static bool dbwrap_cache_validate(struct db_cache_ctx *ctx)
{
int backing_seqnum;
backing_seqnum = dbwrap_get_seqnum(ctx->backing);
if (backing_seqnum == ctx->seqnum) {
return true;
}
TALLOC_FREE(ctx->positive);
ctx->positive = db_open_rbt(ctx);
if (ctx->positive == NULL) {
return false;
}
TALLOC_FREE(ctx->negative);
ctx->negative = db_open_rbt(ctx);
if (ctx->negative == NULL) {
return false;
}
ctx->seqnum = backing_seqnum;
return true;
}
bool posix_locking_init(bool read_only)
{
if (posix_pending_close_db != NULL) {
return true;
}
posix_pending_close_db = db_open_rbt(NULL);
if (posix_pending_close_db == NULL) {
DEBUG(0,("Failed to open POSIX pending close database.\n"));
return false;
}
return true;
}
static NTSTATUS smbXsrv_tcon_table_init(TALLOC_CTX *mem_ctx,
struct smbXsrv_tcon_table *table,
uint32_t lowest_id,
uint32_t highest_id,
uint32_t max_tcons)
{
NTSTATUS status;
uint64_t max_range;
if (lowest_id > highest_id) {
return NT_STATUS_INTERNAL_ERROR;
}
max_range = highest_id;
max_range -= lowest_id;
max_range += 1;
if (max_tcons > max_range) {
return NT_STATUS_INTERNAL_ERROR;
}
ZERO_STRUCTP(table);
table->local.db_ctx = db_open_rbt(table);
if (table->local.db_ctx == NULL) {
return NT_STATUS_NO_MEMORY;
}
table->local.lowest_id = lowest_id;
table->local.highest_id = highest_id;
table->local.max_tcons = max_tcons;
status = smbXsrv_tcon_global_init();
if (!NT_STATUS_IS_OK(status)) {
return status;
}
table->global.db_ctx = smbXsrv_tcon_global_db_ctx;
return NT_STATUS_OK;
}
static int traverse_tcon_fn(struct smbXsrv_tcon_global0 *global,
void *connections_forall_state)
{
NTSTATUS status;
struct connections_forall_state *state =
(struct connections_forall_state*)connections_forall_state;
struct connections_key key;
struct connections_data data;
uint32_t sess_id = global->session_global_id;
struct connections_forall_session sess = {
.uid = -1,
.gid = -1,
};
TDB_DATA val = tdb_null;
/*
* Note: that share_name is defined as array without a pointer.
* that's why it's always a valid pointer here.
*/
if (strlen(global->share_name) == 0) {
/*
* when a smbXsrv_tcon is created it's created
* with emtpy share_name first in order to allocate
* an id, before filling in the details.
*/
return 0;
}
status = dbwrap_fetch(state->session_by_pid, state,
make_tdb_data((void*)&sess_id, sizeof(sess_id)),
&val);
if (NT_STATUS_IS_OK(status)) {
memcpy((uint8_t *)&sess, val.dptr, val.dsize);
}
ZERO_STRUCT(key);
ZERO_STRUCT(data);
key.pid = data.pid = global->server_id;
key.cnum = data.cnum = global->tcon_global_id;
fstrcpy(key.name, global->share_name);
fstrcpy(data.servicename, global->share_name);
data.uid = sess.uid;
data.gid = sess.gid;
fstrcpy(data.addr, sess.addr);
fstrcpy(data.machine, sess.machine);
data.start = nt_time_to_unix(global->creation_time);
data.encryption_flags = global->encryption_flags;
data.cipher = sess.cipher;
data.dialect = sess.dialect;
data.signing_flags = global->signing_flags;
state->count++;
return state->fn(&key, &data, state->private_data);
}
int connections_forall_read(int (*fn)(const struct connections_key *key,
const struct connections_data *data,
void *private_data),
void *private_data)
{
TALLOC_CTX *frame = talloc_stackframe();
struct connections_forall_state *state =
talloc_zero(talloc_tos(), struct connections_forall_state);
NTSTATUS status;
int ret = -1;
state->session_by_pid = db_open_rbt(state);
state->fn = fn;
state->private_data = private_data;
status = smbXsrv_session_global_traverse(collect_sessions_fn, state);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("Failed to traverse sessions: %s\n",
nt_errstr(status)));
goto done;
}
status = smbXsrv_tcon_global_traverse(traverse_tcon_fn, state);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("Failed to traverse tree connects: %s\n",
nt_errstr(status)));
goto done;
}
ret = state->count;
done:
talloc_free(frame);
return ret;
}
