return NT_STATUS_OK;
}
-static NTSTATUS smbXsrv_session_table_init(struct smbXsrv_connection *conn,
+static NTSTATUS smbXsrv_open_table_init(struct smbXsrv_connection *conn,
uint32_t lowest_id,
uint32_t highest_id)
{
- struct smbXsrv_session_table *table = &conn->session_table;
+ struct smbXsrv_open_table *table = &conn->open_table;
NTSTATUS status;
ZERO_STRUCTP(table);
table->local.lowest_id = lowest_id;
table->local.highest_id = highest_id;
- status = smbXsrv_session_global_init();
+ status = smbXsrv_open_global_init();
if (!NT_STATUS_IS_OK(status)) {
return status;
}
- table->global.db_ctx = smbXsrv_session_global_db_ctx;
+ table->global.db_ctx = smbXsrv_open_global_db_ctx;
return NT_STATUS_OK;
}
-struct smb1srv_session_local_allocate_state {
+struct smb1srv_open_local_allocate_state {
const uint32_t lowest_id;
const uint32_t highest_id;
uint32_t last_id;
NTSTATUS status;
};
-static int smb1srv_session_local_allocate_traverse(struct db_record *rec,
+static int smb1srv_open_local_allocate_traverse(struct db_record *rec,
void *private_data)
{
- struct smb1srv_session_local_allocate_state *state =
- (struct smb1srv_session_local_allocate_state *)private_data;
+ struct smb1srv_open_local_allocate_state *state =
+ (struct smb1srv_open_local_allocate_state *)private_data;
TDB_DATA key = dbwrap_record_get_key(rec);
uint32_t id = 0;
return 0;
}
-static NTSTATUS smb1srv_session_local_allocate_id(struct db_context *db,
+static NTSTATUS smb1srv_open_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_session_local_allocate_state state = {
+ struct smb1srv_open_local_allocate_state state = {
.lowest_id = lowest_id,
.highest_id = highest_id,
.last_id = 0,
return NT_STATUS_OK;
}
- status = dbwrap_traverse_read(db, smb1srv_session_local_allocate_traverse,
+ status = dbwrap_traverse_read(db, smb1srv_open_local_allocate_traverse,
&state, &count);
if (!NT_STATUS_EQUAL(status, NT_STATUS_INTERNAL_DB_CORRUPTION)) {
/*
return state.status;
}
-struct smbXsrv_session_local_fetch_state {
- struct smbXsrv_session *session;
+struct smbXsrv_open_local_fetch_state {
+ struct smbXsrv_open *open;
NTSTATUS status;
};
-static void smbXsrv_session_local_fetch_parser(TDB_DATA key, TDB_DATA data,
+static void smbXsrv_open_local_fetch_parser(TDB_DATA key, TDB_DATA data,
void *private_data)
{
- struct smbXsrv_session_local_fetch_state *state =
- (struct smbXsrv_session_local_fetch_state *)private_data;
+ struct smbXsrv_open_local_fetch_state *state =
+ (struct smbXsrv_open_local_fetch_state *)private_data;
void *ptr;
if (data.dsize != sizeof(ptr)) {
}
memcpy(&ptr, data.dptr, data.dsize);
- state->session = talloc_get_type_abort(ptr, struct smbXsrv_session);
+ state->open = talloc_get_type_abort(ptr, struct smbXsrv_open);
state->status = NT_STATUS_OK;
}
-static NTSTATUS smbXsrv_session_local_lookup(struct smbXsrv_session_table *table,
- uint32_t session_local_id,
+static NTSTATUS smbXsrv_open_local_lookup(struct smbXsrv_open_table *table,
+ uint32_t open_local_id,
NTTIME now,
- struct smbXsrv_session **_session)
+ struct smbXsrv_open **_open)
{
- struct smbXsrv_session_local_fetch_state state = {
- .session = NULL,
+ struct smbXsrv_open_local_fetch_state state = {
+ .open = NULL,
.status = NT_STATUS_INTERNAL_ERROR,
};
uint8_t key_buf[sizeof(uint32_t)];
TDB_DATA key;
NTSTATUS status;
- *_session = NULL;
+ *_open = NULL;
if (table->local.db_ctx == NULL) {
return NT_STATUS_INTERNAL_ERROR;
}
- RSIVAL(key_buf, 0, session_local_id);
+ RSIVAL(key_buf, 0, open_local_id);
key = make_tdb_data(key_buf, sizeof(key_buf));
status = dbwrap_parse_record(table->local.db_ctx, key,
- smbXsrv_session_local_fetch_parser,
+ smbXsrv_open_local_fetch_parser,
&state);
if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
return NT_STATUS_USER_SESSION_DELETED;
return state.status;
}
- if (!NT_STATUS_IS_OK(state.session->status)) {
- *_session = state.session;
- return state.session->status;
+ if (!NT_STATUS_IS_OK(state.open->status)) {
+ *_open = state.open;
+ return state.open->status;
}
- if (now > state.session->global->expiration_time) {
- state.session->status = NT_STATUS_NETWORK_SESSION_EXPIRED;
+ if (now > state.open->global->expiration_time) {
+ state.open->status = NT_STATUS_NETWORK_SESSION_EXPIRED;
}
- *_session = state.session;
- return state.session->status;
+ *_open = state.open;
+ return state.open->status;
}
-static int smbXsrv_session_global_destructor(struct smbXsrv_session_global0 *global)
+static int smbXsrv_open_global_destructor(struct smbXsrv_open_global0 *global)
{
return 0;
}
-static NTSTATUS smbXsrv_session_global_allocate(struct db_context *db,
+static NTSTATUS smbXsrv_open_global_allocate(struct db_context *db,
TALLOC_CTX *mem_ctx,
- struct smbXsrv_session_global0 **_global)
+ struct smbXsrv_open_global0 **_global)
{
uint32_t i;
- struct smbXsrv_session_global0 *global = NULL;
+ struct smbXsrv_open_global0 *global = NULL;
*_global = NULL;
- global = talloc_zero(mem_ctx, struct smbXsrv_session_global0);
+ global = talloc_zero(mem_ctx, struct smbXsrv_open_global0);
if (global == NULL) {
return NT_STATUS_NO_MEMORY;
}
- talloc_set_destructor(global, smbXsrv_session_global_destructor);
+ talloc_set_destructor(global, smbXsrv_open_global_destructor);
for (i = 0; i < UINT32_MAX; i++) {
uint32_t id;
continue;
}
- global->session_global_id = id;
+ global->open_global_id = id;
*_global = global;
return NT_STATUS_OK;
return NT_STATUS_INTERNAL_ERROR;
}
-static NTSTATUS smbXsrv_session_global_store(struct smbXsrv_connection *sconn,
- struct smbXsrv_session_global0 *global)
+static NTSTATUS smbXsrv_open_global_store(struct smbXsrv_connection *sconn,
+ struct smbXsrv_open_global0 *global)
{
- struct smbXsrv_session_globalB global_blob;
+ struct smbXsrv_open_globalB global_blob;
DATA_BLOB blob = data_blob_null;
TDB_DATA val;
NTSTATUS status;
global_blob.info.info0 = global;
ndr_err = ndr_push_struct_blob(&blob, global->db_rec, &global_blob,
- (ndr_push_flags_fn_t)ndr_push_smbXsrv_session_globalB);
+ (ndr_push_flags_fn_t)ndr_push_smbXsrv_open_globalB);
if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
//status = ndr_err_code;
TALLOC_FREE(global->db_rec);
return NT_STATUS_OK;
}
-struct smbXsrv_session_global_fetch_state {
+struct smbXsrv_open_global_fetch_state {
TALLOC_CTX *mem_ctx;
- struct smbXsrv_session_global *session;
+ struct smbXsrv_open_global *open;
NTSTATUS status;
};
-static void smbXsrv_session_global_fetch_parser(TDB_DATA key, TDB_DATA data,
+static void smbXsrv_open_global_fetch_parser(TDB_DATA key, TDB_DATA data,
void *private_data)
{
- struct smbXsrv_session_global_fetch_state *state =
- (struct smbXsrv_session_global_fetch_state *)private_data;
+ struct smbXsrv_open_global_fetch_state *state =
+ (struct smbXsrv_open_global_fetch_state *)private_data;
state->status = NT_STATUS_NOT_IMPLEMENTED;
}
-static NTSTATUS smbXsrv_session_global_lookup(struct smbXsrv_session_table *table,
- uint32_t session_global_id,
+static NTSTATUS smbXsrv_open_global_lookup(struct smbXsrv_open_table *table,
+ uint32_t open_global_id,
TALLOC_CTX *mem_ctx,
- struct smbXsrv_session_global **_session)
+ struct smbXsrv_open_global **_open)
{
- struct smbXsrv_session_global_fetch_state state = {
+ struct smbXsrv_open_global_fetch_state state = {
.mem_ctx = mem_ctx,
- .session = NULL,
+ .open = NULL,
.status = NT_STATUS_INTERNAL_ERROR,
};
TDB_DATA key;
uint8_t key_buf[sizeof(uint32_t)];
NTSTATUS status;
- *_session = NULL;
+ *_open = NULL;
if (table->global.db_ctx == NULL) {
return NT_STATUS_INTERNAL_ERROR;
}
/* TODO: key as string */
- RSIVAL(key_buf, 0, session_global_id);
+ RSIVAL(key_buf, 0, open_global_id);
key = make_tdb_data(key_buf, sizeof(key_buf));
status = dbwrap_parse_record(table->global.db_ctx, key,
- smbXsrv_session_global_fetch_parser, &state);
+ smbXsrv_open_global_fetch_parser, &state);
if (NT_STATUS_EQUAL(status, NT_STATUS_NOT_FOUND)) {
return NT_STATUS_USER_SESSION_DELETED;
} else if (!NT_STATUS_IS_OK(status)) {
return state.status;
}
- *_session = state.session;
+ *_open = state.open;
return NT_STATUS_OK;
}
-static int smbXsrv_session_destructor(struct smbXsrv_session *session)
+static int smbXsrv_open_destructor(struct smbXsrv_open *open)
{
- struct smbXsrv_session_table *table;
+ struct smbXsrv_open_table *table;
struct db_record *local_rec = NULL;
struct db_record *global_rec = NULL;
NTSTATUS status;
- if (session->connection == NULL) {
+ if (open->connection == NULL) {
return 0;
}
- table = &session->connection->session_table;
- session->connection = NULL;
+ table = &open->connection->open_table;
+ open->connection = NULL;
- local_rec = session->db_rec;
- session->db_rec = NULL;
+ local_rec = open->db_rec;
+ open->db_rec = NULL;
if (local_rec == NULL) {
uint8_t key_buf[sizeof(uint32_t)];
TDB_DATA key;
- RSIVAL(key_buf, 0, session->local_id);
+ RSIVAL(key_buf, 0, open->local_id);
key = make_tdb_data(key_buf, sizeof(key_buf));
local_rec = dbwrap_fetch_locked(table->local.db_ctx,
- session, key);
+ open, key);
}
if (local_rec != NULL) {
status = dbwrap_record_delete(local_rec);
}
- global_rec = session->global->db_rec;
- session->global->db_rec = NULL;
+ global_rec = open->global->db_rec;
+ open->global->db_rec = NULL;
if (global_rec == NULL) {
uint8_t key_buf[sizeof(uint32_t)];
TDB_DATA key;
- RSIVAL(key_buf, 0, session->global->session_global_id);
+ RSIVAL(key_buf, 0, open->global->open_global_id);
key = make_tdb_data(key_buf, sizeof(key_buf));
global_rec = dbwrap_fetch_locked(table->global.db_ctx,
- session->global, key);
+ open->global, key);
}
if (global_rec != NULL) {
status = dbwrap_record_delete(global_rec);
}
- TALLOC_FREE(session->global);
+ TALLOC_FREE(open->global);
return 0;
}
-NTSTATUS smbXsrv_session_create(struct smbXsrv_connection *conn,
+NTSTATUS smbXsrv_open_create(struct smbXsrv_connection *conn,
NTTIME now,
- struct smbXsrv_session **_session)
+ struct smbXsrv_open **_open)
{
- struct smbXsrv_session_table *table = &conn->session_table;
- uint32_t max_sessions = table->local.highest_id - table->local.lowest_id;
+ struct smbXsrv_open_table *table = &conn->open_table;
+ uint32_t max_opens = table->local.highest_id - table->local.lowest_id;
struct db_record *local_rec = NULL;
- struct smbXsrv_session *session = NULL;
+ struct smbXsrv_open *open = NULL;
void *ptr = NULL;
TDB_DATA val;
- struct smbXsrv_session_global0 *global = NULL;
+ struct smbXsrv_open_global0 *global = NULL;
struct smbXsrv_channel_global0 *channels = NULL;
NTSTATUS status;
//system("sleep 999999");
- if (table->local.num_sessions >= max_sessions) {
+ if (table->local.num_opens >= max_opens) {
return NT_STATUS_INSUFFICIENT_RESOURCES;
// TODO smb1 return NT_STATUS_TOO_MANY_SESSIONS;
}
- session = talloc_zero(conn, struct smbXsrv_session);
- if (session == NULL) {
+ open = talloc_zero(conn, struct smbXsrv_open);
+ if (open == NULL) {
return NT_STATUS_NO_MEMORY;
}
- session->status = NT_STATUS_MORE_PROCESSING_REQUIRED;
- session->connection = conn;
+ open->status = NT_STATUS_MORE_PROCESSING_REQUIRED;
+ open->connection = conn;
- status = smbXsrv_session_global_allocate(table->global.db_ctx,
- session,
+ status = smbXsrv_open_global_allocate(table->global.db_ctx,
+ open,
&global);
if (!NT_STATUS_IS_OK(status)) {
- talloc_free(session);
+ talloc_free(open);
return status;
}
- session->global = global;
+ open->global = global;
- talloc_set_destructor(session, smbXsrv_session_destructor);
+ talloc_set_destructor(open, smbXsrv_open_destructor);
if (conn->protocol >= PROTOCOL_SMB2_02) {
- uint64_t id = global->session_global_id;
+ uint64_t id = global->open_global_id;
uint8_t key_buf[sizeof(uint32_t)];
TDB_DATA key;
- global->session_wire_id = id;
- //global->session_wire_id |= (id << 32) & 0xFFFFFFFF00000000ULL;
+ global->open_wire_id = id;
+ //global->open_wire_id |= (id << 32) & 0xFFFFFFFF00000000ULL;
- session->local_id = global->session_global_id;
+ open->local_id = global->open_global_id;
- RSIVAL(key_buf, 0, session->local_id);
+ RSIVAL(key_buf, 0, open->local_id);
key = make_tdb_data(key_buf, sizeof(key_buf));
local_rec = dbwrap_fetch_locked(table->local.db_ctx,
- session, key);
+ open, key);
if (local_rec == NULL) {
return NT_STATUS_NO_MEMORY;
}
}
} else {
- status = smb1srv_session_local_allocate_id(table->local.db_ctx,
+ status = smb1srv_open_local_allocate_id(table->local.db_ctx,
table->local.lowest_id,
table->local.highest_id,
- session,
+ open,
&local_rec,
- &session->local_id);
+ &open->local_id);
if (!NT_STATUS_IS_OK(status)) {
return status;
}
- global->session_wire_id = session->local_id;
+ global->open_wire_id = open->local_id;
}
- ptr = session;
+ ptr = open;
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(session);
+ talloc_free(open);
return status;
}
struct smbXsrv_channel_global0,
global->num_channels);
if (channels == NULL) {
- talloc_free(session);
+ talloc_free(open);
return NT_STATUS_NO_MEMORY;
}
global->channels = channels;
channels[0].local_address = tsocket_address_string(conn->local_address,
channels);
if (channels[0].local_address == NULL) {
- talloc_free(session);
+ talloc_free(open);
return NT_STATUS_NO_MEMORY;
}
channels[0].remote_address = tsocket_address_string(conn->remote_address,
channels);
if (channels[0].remote_address == NULL) {
- talloc_free(session);
+ talloc_free(open);
return NT_STATUS_NO_MEMORY;
}
channels[0].remote_name = talloc_strdup(channels, conn->remote_hostname);
if (channels[0].remote_name == NULL) {
- talloc_free(session);
+ talloc_free(open);
return NT_STATUS_NO_MEMORY;
}
channels[0].signing_key = data_blob_null;
- status = smbXsrv_session_global_store(conn,
+ status = smbXsrv_open_global_store(conn,
global);
if (!NT_STATUS_IS_OK(status)) {
- talloc_free(session);
+ talloc_free(open);
return status;
}
{
- struct smbXsrv_sessionB session_blob;
+ struct smbXsrv_openB open_blob;
- ZERO_STRUCT(session_blob);
- session_blob.version = 0;
- session_blob.info.info0 = session;
+ ZERO_STRUCT(open_blob);
+ open_blob.version = 0;
+ open_blob.info.info0 = open;
- NDR_PRINT_DEBUG(smbXsrv_sessionB, &session_blob);
+ NDR_PRINT_DEBUG(smbXsrv_openB, &open_blob);
}
- *_session = session;
+ *_open = open;
return NT_STATUS_OK;
}
-NTSTATUS smbXsrv_session_update(struct smbXsrv_session *session)
+NTSTATUS smbXsrv_open_update(struct smbXsrv_open *open)
{
- struct smbXsrv_session_table *table = &session->connection->session_table;
+ struct smbXsrv_open_table *table = &open->connection->open_table;
NTSTATUS status;
uint8_t key_buf[sizeof(uint32_t)];
TDB_DATA key;
- if (session->global->db_rec != NULL) {
+ if (open->global->db_rec != NULL) {
return NT_STATUS_INTERNAL_ERROR;
}
- RSIVAL(key_buf, 0, session->global->session_global_id);
+ RSIVAL(key_buf, 0, open->global->open_global_id);
key = make_tdb_data(key_buf, sizeof(key_buf));
- session->global->db_rec = dbwrap_fetch_locked(table->global.db_ctx,
- session->global, key);
- if (session->global->db_rec == NULL) {
+ open->global->db_rec = dbwrap_fetch_locked(table->global.db_ctx,
+ open->global, key);
+ if (open->global->db_rec == NULL) {
// TODO proper return code?
return NT_STATUS_NO_MEMORY;
}
- status = smbXsrv_session_global_store(session->connection,
- session->global);
+ status = smbXsrv_open_global_store(open->connection,
+ open->global);
if (!NT_STATUS_IS_OK(status)) {
/* debug */
return status;
return NT_STATUS_OK;
}
-NTSTATUS smb1srv_session_table_init(struct smbXsrv_connection *conn)
+NTSTATUS smb1srv_open_table_init(struct smbXsrv_connection *conn)
{
/*
* Allow a range from 100..65534.
*/
- return smbXsrv_session_table_init(conn, 100, UINT16_MAX - 1);
+ return smbXsrv_open_table_init(conn, 100, UINT16_MAX - 1);
}
-NTSTATUS smb1srv_session_lookup(struct smbXsrv_session_table *table,
+NTSTATUS smb1srv_open_lookup(struct smbXsrv_open_table *table,
uint16_t vuid, NTTIME now,
- struct smbXsrv_session **session)
+ struct smbXsrv_open **open)
{
uint32_t local_id = vuid;
- return smbXsrv_session_local_lookup(table, local_id, now, session);
+ return smbXsrv_open_local_lookup(table, local_id, now, open);
}
-NTSTATUS smb2srv_session_table_init(struct smbXsrv_connection *conn)
+NTSTATUS smb2srv_open_table_init(struct smbXsrv_connection *conn)
{
/*
* For now use the same range as SMB1.
*
* Allow a range from 100..65534.
*/
- return smbXsrv_session_table_init(conn, 100, UINT16_MAX - 1);
+ return smbXsrv_open_table_init(conn, 100, UINT16_MAX - 1);
}
-NTSTATUS smb2srv_session_lookup(struct smbXsrv_session_table *table,
- uint64_t session_id, NTTIME now,
- struct smbXsrv_session **session)
+NTSTATUS smb2srv_open_lookup(struct smbXsrv_open_table *table,
+ uint64_t open_id, NTTIME now,
+ struct smbXsrv_open **open)
{
- uint32_t local_id = session_id & UINT32_MAX;
+ uint32_t local_id = open_id & UINT32_MAX;
- return smbXsrv_session_local_lookup(table, local_id, now, session);
+ return smbXsrv_open_local_lookup(table, local_id, now, open);
}
git.samba.org / metze / samba / wip.git / commitdiff