static struct db_record *smbXsrv_tcon_local_fetch_locked(
struct db_context *db,
uint32_t id,
TALLOC_CTX *mem_ctx)
{
TDB_DATA key;
uint8_t key_buf[SMBXSRV_TCON_LOCAL_TDB_KEY_SIZE];
struct db_record *rec = NULL;
key = smbXsrv_tcon_local_id_to_key(id, key_buf);
rec = dbwrap_fetch_locked(db, mem_ctx, key);
if (rec == NULL) {
DBG_DEBUG("Failed to lock local id 0x%08x, key '%s'\n", id,
hex_encode_talloc(talloc_tos(), key.dptr, key.dsize));
}
return rec;
}
NTSTATUS smbXsrv_tcon_disconnect(struct smbXsrv_tcon *tcon, uint64_t vuid)
{
struct smbXsrv_tcon_table *table;
struct db_record *local_rec = NULL;
struct db_record *global_rec = NULL;
NTSTATUS status;
NTSTATUS error = NT_STATUS_OK;
if (tcon->table == NULL) {
return NT_STATUS_OK;
}
table = tcon->table;
tcon->table = NULL;
tcon->status = NT_STATUS_NETWORK_NAME_DELETED;
global_rec = tcon->global->db_rec;
tcon->global->db_rec = NULL;
if (global_rec == NULL) {
uint8_t key_buf[SMBXSRV_TCON_GLOBAL_TDB_KEY_SIZE];
TDB_DATA key;
key = smbXsrv_tcon_global_id_to_key(
tcon->global->tcon_global_id,
key_buf);
global_rec = dbwrap_fetch_locked(table->global.db_ctx,
tcon->global, key);
if (global_rec == NULL) {
DEBUG(0, ("smbXsrv_tcon_disconnect(0x%08x, '%s'): "
"Failed to lock global key '%s'\n",
tcon->global->tcon_global_id,
tcon->global->share_name,
hex_encode_talloc(global_rec, key.dptr,
key.dsize)));
error = NT_STATUS_INTERNAL_ERROR;
}
}
if (global_rec != NULL) {
status = dbwrap_record_delete(global_rec);
if (!NT_STATUS_IS_OK(status)) {
TDB_DATA key = dbwrap_record_get_key(global_rec);
DEBUG(0, ("smbXsrv_tcon_disconnect(0x%08x, '%s'): "
"failed to delete global key '%s': %s\n",
tcon->global->tcon_global_id,
tcon->global->share_name,
hex_encode_talloc(global_rec, key.dptr,
key.dsize),
nt_errstr(status)));
error = status;
}
}
TALLOC_FREE(global_rec);
local_rec = tcon->db_rec;
if (local_rec == NULL) {
uint8_t key_buf[SMBXSRV_TCON_LOCAL_TDB_KEY_SIZE];
TDB_DATA key;
key = smbXsrv_tcon_local_id_to_key(tcon->local_id, key_buf);
local_rec = dbwrap_fetch_locked(table->local.db_ctx,
tcon, key);
if (local_rec == NULL) {
DEBUG(0, ("smbXsrv_tcon_disconnect(0x%08x, '%s'): "
"Failed to lock local key '%s'\n",
tcon->global->tcon_global_id,
tcon->global->share_name,
hex_encode_talloc(local_rec, key.dptr,
key.dsize)));
error = NT_STATUS_INTERNAL_ERROR;
}
}
if (local_rec != NULL) {
status = dbwrap_record_delete(local_rec);
if (!NT_STATUS_IS_OK(status)) {
TDB_DATA key = dbwrap_record_get_key(local_rec);
DEBUG(0, ("smbXsrv_tcon_disconnect(0x%08x, '%s'): "
"failed to delete local key '%s': %s\n",
tcon->global->tcon_global_id,
tcon->global->share_name,
hex_encode_talloc(local_rec, key.dptr,
key.dsize),
nt_errstr(status)));
error = status;
}
table->local.num_tcons -= 1;
}
if (tcon->db_rec == NULL) {
TALLOC_FREE(local_rec);
}
tcon->db_rec = NULL;
if (tcon->compat) {
bool ok;
ok = set_current_service(tcon->compat, 0, true);
if (!ok) {
status = NT_STATUS_INTERNAL_ERROR;
DEBUG(0, ("smbXsrv_tcon_disconnect(0x%08x, '%s'): "
"set_current_service() failed: %s\n",
tcon->global->tcon_global_id,
tcon->global->share_name,
nt_errstr(status)));
tcon->compat = NULL;
return status;
}
close_cnum(tcon->compat, vuid);
tcon->compat = NULL;
}
return error;
}
static NTSTATUS smbXsrv_tcon_create(struct smbXsrv_tcon_table *table,
enum protocol_types protocol,
struct server_id server_id,
NTTIME now,
struct smbXsrv_tcon **_tcon)
{
struct db_record *local_rec = NULL;
struct smbXsrv_tcon *tcon = NULL;
void *ptr = NULL;
TDB_DATA val;
struct smbXsrv_tcon_global0 *global = NULL;
NTSTATUS status;
if (table->local.num_tcons >= table->local.max_tcons) {
return NT_STATUS_INSUFFICIENT_RESOURCES;
}
tcon = talloc_zero(table, struct smbXsrv_tcon);
if (tcon == NULL) {
return NT_STATUS_NO_MEMORY;
}
tcon->table = table;
tcon->status = NT_STATUS_INTERNAL_ERROR;
tcon->idle_time = now;
status = smbXsrv_tcon_global_allocate(table->global.db_ctx,
tcon, &global);
if (!NT_STATUS_IS_OK(status)) {
TALLOC_FREE(tcon);
return status;
}
tcon->global = global;
if (protocol >= PROTOCOL_SMB2_02) {
uint64_t id = global->tcon_global_id;
uint8_t key_buf[SMBXSRV_TCON_LOCAL_TDB_KEY_SIZE];
TDB_DATA key;
global->tcon_wire_id = id;
tcon->local_id = global->tcon_global_id;
key = smbXsrv_tcon_local_id_to_key(tcon->local_id, key_buf);
local_rec = dbwrap_fetch_locked(table->local.db_ctx,
tcon, key);
if (local_rec == NULL) {
TALLOC_FREE(tcon);
return NT_STATUS_NO_MEMORY;
}
val = dbwrap_record_get_value(local_rec);
if (val.dsize != 0) {
TALLOC_FREE(tcon);
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
} else {
status = smb1srv_tcon_local_allocate_id(table->local.db_ctx,
table->local.lowest_id,
table->local.highest_id,
tcon,
&local_rec,
&tcon->local_id);
if (!NT_STATUS_IS_OK(status)) {
TALLOC_FREE(tcon);
return status;
}
global->tcon_wire_id = tcon->local_id;
}
global->creation_time = now;
global->server_id = server_id;
ptr = tcon;
val = make_tdb_data((uint8_t const *)&ptr, sizeof(ptr));
status = dbwrap_record_store(local_rec, val, TDB_REPLACE);
TALLOC_FREE(local_rec);
if (!NT_STATUS_IS_OK(status)) {
TALLOC_FREE(tcon);
return status;
}
table->local.num_tcons += 1;
talloc_set_destructor(tcon, smbXsrv_tcon_destructor);
status = smbXsrv_tcon_global_store(global);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0,("smbXsrv_tcon_create: "
"global_id (0x%08x) store failed - %s\n",
tcon->global->tcon_global_id,
nt_errstr(status)));
TALLOC_FREE(tcon);
return status;
}
if (DEBUGLVL(10)) {
struct smbXsrv_tconB tcon_blob;
ZERO_STRUCT(tcon_blob);
tcon_blob.version = SMBXSRV_VERSION_0;
tcon_blob.info.info0 = tcon;
DEBUG(10,("smbXsrv_tcon_create: global_id (0x%08x) stored\n",
tcon->global->tcon_global_id));
NDR_PRINT_DEBUG(smbXsrv_tconB, &tcon_blob);
}
*_tcon = tcon;
return NT_STATUS_OK;
}
static NTSTATUS smb1srv_tcon_local_allocate_id(struct db_context *db,
uint32_t lowest_id,
uint32_t highest_id,
TALLOC_CTX *mem_ctx,
struct db_record **_rec,
uint32_t *_id)
{
struct smb1srv_tcon_local_allocate_state state = {
.lowest_id = lowest_id,
.highest_id = highest_id,
.last_id = 0,
.useable_id = lowest_id,
.status = NT_STATUS_INTERNAL_ERROR,
};
uint32_t i;
uint32_t range;
NTSTATUS status;
int count = 0;
*_rec = NULL;
*_id = 0;
if (lowest_id > highest_id) {
return NT_STATUS_INSUFFICIENT_RESOURCES;
}
/*
* first we try randomly
*/
range = (highest_id - lowest_id) + 1;
for (i = 0; i < (range / 2); i++) {
uint32_t id;
uint8_t key_buf[SMBXSRV_TCON_LOCAL_TDB_KEY_SIZE];
TDB_DATA key;
TDB_DATA val;
struct db_record *rec = NULL;
id = generate_random() % range;
id += lowest_id;
if (id < lowest_id) {
id = lowest_id;
}
if (id > highest_id) {
id = highest_id;
}
key = smbXsrv_tcon_local_id_to_key(id, key_buf);
rec = dbwrap_fetch_locked(db, mem_ctx, key);
if (rec == NULL) {
return NT_STATUS_INSUFFICIENT_RESOURCES;
}
val = dbwrap_record_get_value(rec);
if (val.dsize != 0) {
TALLOC_FREE(rec);
continue;
}
*_rec = rec;
*_id = id;
return NT_STATUS_OK;
}
/*
* if the range is almost full,
* we traverse the whole table
* (this relies on sorted behavior of dbwrap_rbt)
*/
status = dbwrap_traverse_read(db, smb1srv_tcon_local_allocate_traverse,
&state, &count);
if (NT_STATUS_IS_OK(status)) {
if (NT_STATUS_IS_OK(state.status)) {
return NT_STATUS_INTERNAL_ERROR;
}
if (!NT_STATUS_EQUAL(state.status, NT_STATUS_INTERNAL_ERROR)) {
return state.status;
}
if (state.useable_id <= state.highest_id) {
state.status = NT_STATUS_OK;
} else {
return NT_STATUS_INSUFFICIENT_RESOURCES;
}
} else if (!NT_STATUS_EQUAL(status, NT_STATUS_INTERNAL_DB_CORRUPTION)) {
/*
* Here we really expect NT_STATUS_INTERNAL_DB_CORRUPTION!
*
* If we get anything else it is an error, because it
* means we did not manage to find a free slot in
* the db.
*/
return NT_STATUS_INSUFFICIENT_RESOURCES;
}
if (NT_STATUS_IS_OK(state.status)) {
uint32_t id;
uint8_t key_buf[SMBXSRV_TCON_LOCAL_TDB_KEY_SIZE];
TDB_DATA key;
TDB_DATA val;
struct db_record *rec = NULL;
id = state.useable_id;
key = smbXsrv_tcon_local_id_to_key(id, key_buf);
rec = dbwrap_fetch_locked(db, mem_ctx, key);
if (rec == NULL) {
return NT_STATUS_INSUFFICIENT_RESOURCES;
}
val = dbwrap_record_get_value(rec);
if (val.dsize != 0) {
TALLOC_FREE(rec);
return NT_STATUS_INTERNAL_DB_CORRUPTION;
}
*_rec = rec;
*_id = id;
return NT_STATUS_OK;
}
return state.status;
}
struct smbXsrv_tcon_local_fetch_state {
struct smbXsrv_tcon *tcon;
NTSTATUS status;
};
static void smbXsrv_tcon_local_fetch_parser(TDB_DATA key, TDB_DATA data,
void *private_data)
{
struct smbXsrv_tcon_local_fetch_state *state =
(struct smbXsrv_tcon_local_fetch_state *)private_data;
void *ptr;
if (data.dsize != sizeof(ptr)) {
state->status = NT_STATUS_INTERNAL_DB_ERROR;
return;
}
memcpy(&ptr, data.dptr, data.dsize);
state->tcon = talloc_get_type_abort(ptr, struct smbXsrv_tcon);
state->status = NT_STATUS_OK;
}
static NTSTATUS smbXsrv_tcon_local_lookup(struct smbXsrv_tcon_table *table,
uint32_t tcon_local_id,
NTTIME now,
struct smbXsrv_tcon **_tcon)
{
struct smbXsrv_tcon_local_fetch_state state = {
.tcon = NULL,
.status = NT_STATUS_INTERNAL_ERROR,
};
uint8_t key_buf[SMBXSRV_TCON_LOCAL_TDB_KEY_SIZE];
TDB_DATA key;
NTSTATUS status;
*_tcon = NULL;
if (tcon_local_id == 0) {
return NT_STATUS_NETWORK_NAME_DELETED;
}
if (table == NULL) {
/* this might happen before the end of negprot */
return NT_STATUS_NETWORK_NAME_DELETED;
}
if (table->local.db_ctx == NULL) {
return NT_STATUS_INTERNAL_ERROR;
}
key = smbXsrv_tcon_local_id_to_key(tcon_local_id, key_buf);
status = dbwrap_parse_record(table->local.db_ctx, key,
smbXsrv_tcon_local_fetch_parser,
&state);
if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
return NT_STATUS_NETWORK_NAME_DELETED;
} else if (!NT_STATUS_IS_OK(status)) {
return status;
}
if (!NT_STATUS_IS_OK(state.status)) {
return state.status;
}
if (NT_STATUS_EQUAL(state.tcon->status, NT_STATUS_NETWORK_NAME_DELETED)) {
return NT_STATUS_NETWORK_NAME_DELETED;
}
state.tcon->idle_time = now;
*_tcon = state.tcon;
return state.tcon->status;
}
static int smbXsrv_tcon_global_destructor(struct smbXsrv_tcon_global0 *global)
{
return 0;
}
static void smbXsrv_tcon_global_verify_record(struct db_record *db_rec,
bool *is_free,
bool *was_free,
TALLOC_CTX *mem_ctx,
struct smbXsrv_tcon_global0 **_g);
static NTSTATUS smbXsrv_tcon_global_allocate(struct db_context *db,
TALLOC_CTX *mem_ctx,
struct smbXsrv_tcon_global0 **_global)
{
uint32_t i;
struct smbXsrv_tcon_global0 *global = NULL;
uint32_t last_free = 0;
const uint32_t min_tries = 3;
*_global = NULL;
global = talloc_zero(mem_ctx, struct smbXsrv_tcon_global0);
if (global == NULL) {
return NT_STATUS_NO_MEMORY;
}
talloc_set_destructor(global, smbXsrv_tcon_global_destructor);
/*
* Here we just randomly try the whole 32-bit space
*
* We use just 32-bit, because we want to reuse the
* ID for SRVSVC.
*/
for (i = 0; i < UINT32_MAX; i++) {
bool is_free = false;
bool was_free = false;
uint32_t id;
uint8_t key_buf[SMBXSRV_TCON_GLOBAL_TDB_KEY_SIZE];
TDB_DATA key;
if (i >= min_tries && last_free != 0) {
id = last_free;
} else {
id = generate_random();
}
if (id == 0) {
id++;
}
if (id == UINT32_MAX) {
id--;
}
key = smbXsrv_tcon_global_id_to_key(id, key_buf);
global->db_rec = dbwrap_fetch_locked(db, mem_ctx, key);
if (global->db_rec == NULL) {
talloc_free(global);
return NT_STATUS_INSUFFICIENT_RESOURCES;
}
smbXsrv_tcon_global_verify_record(global->db_rec,
&is_free,
&was_free,
NULL, NULL);
if (!is_free) {
TALLOC_FREE(global->db_rec);
continue;
}
if (!was_free && i < min_tries) {
/*
* The session_id is free now,
* but was not free before.
*
* This happens if a smbd crashed
* and did not cleanup the record.
*
* If this is one of our first tries,
* then we try to find a real free one.
*/
if (last_free == 0) {
last_free = id;
}
TALLOC_FREE(global->db_rec);
continue;
}
global->tcon_global_id = id;
*_global = global;
return NT_STATUS_OK;
}
/* should not be reached */
talloc_free(global);
return NT_STATUS_INTERNAL_ERROR;
}
