#include "includes.h"
#include "system/filesys.h"
+#include <tevent.h>
#include "smbd/smbd.h"
#include "smbd/globals.h"
#include "dbwrap/dbwrap.h"
#include "dbwrap/dbwrap_rbt.h"
#include "dbwrap/dbwrap_open.h"
+#include "dbwrap/dbwrap_watch.h"
#include "session.h"
#include "auth.h"
#include "gensec.h"
#include "lib/util/util_tdb.h"
#include "librpc/gen_ndr/ndr_smbXsrv.h"
#include "serverid.h"
+#include "lib/util/tevent_ntstatus.h"
+#include "msg_channel.h"
struct smbXsrv_session_table {
struct {
struct {
struct db_context *db_ctx;
} global;
+ struct msg_channel *close_channel;
};
static struct db_context *smbXsrv_session_global_db_ctx = NULL;
return NT_STATUS_OK;
}
+static void smbXsrv_session_close_loop(struct tevent_req *subreq);
+
static NTSTATUS smbXsrv_session_table_init(struct smbXsrv_connection *conn,
uint32_t lowest_id,
uint32_t highest_id)
{
struct smbXsrv_session_table *table;
NTSTATUS status;
+ struct tevent_req *subreq;
+ int ret;
table = talloc_zero(conn, struct smbXsrv_session_table);
if (table == NULL) {
table->global.db_ctx = smbXsrv_session_global_db_ctx;
+ dbwrap_watch_db(table->global.db_ctx, conn->msg_ctx);
+
+ ret = msg_channel_init(table, conn->msg_ctx,
+ MSG_SMBXSRV_SESSION_CLOSE,
+ &table->close_channel);
+ if (ret != 0) {
+ status = map_nt_error_from_unix_common(errno);
+ TALLOC_FREE(table);
+ return status;
+ }
+
+ subreq = msg_read_send(table, conn->ev_ctx, table->close_channel);
+ if (subreq == NULL) {
+ TALLOC_FREE(table);
+ return NT_STATUS_NO_MEMORY;
+ }
+ tevent_req_set_callback(subreq, smbXsrv_session_close_loop, conn);
+
conn->session_table = table;
return NT_STATUS_OK;
}
+static void smbXsrv_session_close_loop(struct tevent_req *subreq)
+{
+ struct smbXsrv_connection *conn =
+ tevent_req_callback_data(subreq,
+ struct smbXsrv_connection);
+ struct smbXsrv_session_table *table = conn->session_table;
+ int ret;
+ struct messaging_rec *rec = NULL;
+ struct smbXsrv_session_globalB global_blob;
+ enum ndr_err_code ndr_err;
+ struct smbXsrv_session_global0 *global = NULL;
+ struct smbXsrv_session *session = NULL;
+ NTSTATUS status;
+ struct timeval tv = timeval_current();
+ NTTIME now = timeval_to_nttime(&tv);
+ struct connection_struct *cur_conn, *next_conn;
+
+ ret = msg_read_recv(subreq, talloc_tos(), &rec);
+ TALLOC_FREE(subreq);
+ if (ret != 0) {
+ goto next;
+ }
+
+ ndr_err = ndr_pull_struct_blob_all(&rec->buf, rec, &global_blob,
+ (ndr_pull_flags_fn_t)ndr_pull_smbXsrv_session_globalB);
+ if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
+ goto next;
+ }
+
+ DEBUG(0,("smbXsrv_session_close_loop: MSG_SMBXSRV_SESSION_CLOSE\n"));
+ NDR_PRINT_DEBUG(smbXsrv_session_globalB, &global_blob);
+
+ if (global_blob.version != SMBXSRV_VERSION_0) {
+ goto next;
+ }
+
+ global = global_blob.info.info0;
+
+ status = smb2srv_session_lookup(conn, global->session_wire_id,
+ now, &session);
+ if (NT_STATUS_EQUAL(status, NT_STATUS_USER_SESSION_DELETED)) {
+ goto next;
+ }
+ if (!NT_STATUS_IS_OK(status) &&
+ !NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED) &&
+ !NT_STATUS_EQUAL(status, NT_STATUS_NETWORK_SESSION_EXPIRED)) {
+ goto next;
+ }
+
+ /*
+ * TODO: cancel all outstanding requests on the session
+ */
+ file_close_user(conn->sconn, session->compat->vuid);
+
+ for (cur_conn=conn->sconn->connections; cur_conn; cur_conn=next_conn) {
+ struct smbXsrv_tcon *tcon;
+
+ next_conn = cur_conn->next;
+ tcon = cur_conn->tcon;
+
+ if (cur_conn->vuid != session->compat->vuid) {
+ continue;
+ }
+
+ set_current_service(cur_conn, 0, True);
+ close_cnum(cur_conn, cur_conn->vuid);
+
+ TALLOC_FREE(tcon);
+ }
+
+ invalidate_vuid(conn->sconn, session->compat->vuid);
+ session->compat = NULL;
+
+ session->status = NT_STATUS_USER_SESSION_DELETED;
+ talloc_steal(rec, session);
+
+next:
+ TALLOC_FREE(rec);
+
+ subreq = msg_read_send(table, conn->ev_ctx, table->close_channel);
+ if (subreq == NULL) {
+ // TODO disconnect
+ return;
+ }
+ tevent_req_set_callback(subreq, smbXsrv_session_close_loop, conn);
+}
+
struct smb1srv_session_local_allocate_state {
const uint32_t lowest_id;
const uint32_t highest_id;
return NT_STATUS_OK;
}
+struct smb2srv_session_close_previous_state {
+ struct tevent_context *ev;
+ struct smbXsrv_session *current_session;
+ struct dom_sid *current_sid;
+ struct db_record *db_rec;
+};
+
+static void smb2srv_session_close_previous_check(struct tevent_req *req);
+static void smb2srv_session_close_previous_modified(struct tevent_req *subreq);
+
+struct tevent_req *smb2srv_session_close_previous_send(TALLOC_CTX *mem_ctx,
+ struct tevent_context *ev,
+ struct smbXsrv_session *current_session,
+ uint64_t previous_session_id)
+{
+ struct tevent_req *req;
+ struct smb2srv_session_close_previous_state *state;
+ uint32_t global_id = previous_session_id & UINT32_MAX;
+ uint64_t global_zeros = previous_session_id & 0xFFFFFFFF00000000LLU;
+ struct smbXsrv_connection *conn = current_session->connection;
+ struct smbXsrv_session_table *table = conn->session_table;
+ struct security_token *current_token = NULL;
+ uint8_t key_buf[SMBXSRV_SESSION_GLOBAL_TDB_KEY_SIZE];
+ TDB_DATA key;
+
+ req = tevent_req_create(mem_ctx, &state,
+ struct smb2srv_session_close_previous_state);
+ if (req == NULL) {
+ return NULL;
+ }
+ state->ev = ev;
+ state->current_session = current_session;
+
+ if (global_zeros != 0) {
+ tevent_req_done(req);
+ return tevent_req_post(req, ev);
+ }
+
+ if (current_session->global->auth_session_info == NULL) {
+ tevent_req_done(req);
+ return tevent_req_post(req, ev);
+ }
+ current_token = current_session->global->auth_session_info->security_token;
+
+ if (current_token->num_sids > PRIMARY_USER_SID_INDEX) {
+ state->current_sid = ¤t_token->sids[PRIMARY_USER_SID_INDEX];
+ }
+
+ if (state->current_sid == NULL) {
+ tevent_req_done(req);
+ return tevent_req_post(req, ev);
+ }
+
+ if (!security_token_has_nt_authenticated_users(current_token)) {
+ /* TODO */
+ tevent_req_done(req);
+ return tevent_req_post(req, ev);
+ }
+
+ key = smbXsrv_session_global_id_to_key(global_id, key_buf);
+
+ state->db_rec = dbwrap_fetch_locked(table->global.db_ctx,
+ state, key);
+ if (state->db_rec == NULL) {
+ tevent_req_nterror(req, NT_STATUS_UNSUCCESSFUL);
+ return tevent_req_post(req, ev);
+ }
+
+ smb2srv_session_close_previous_check(req);
+ if (!tevent_req_is_in_progress(req)) {
+ return tevent_req_post(req, ev);
+ }
+
+ return req;
+}
+
+static void smb2srv_session_close_previous_check(struct tevent_req *req)
+{
+ struct smb2srv_session_close_previous_state *state =
+ tevent_req_data(req,
+ struct smb2srv_session_close_previous_state);
+ struct smbXsrv_connection *conn = state->current_session->connection;
+ TDB_DATA val;
+ DATA_BLOB blob;
+ struct security_token *previous_token = NULL;
+ struct smbXsrv_session_global0 *global = NULL;
+ struct tevent_req *subreq = NULL;
+ NTSTATUS status;
+ bool is_free = false;
+
+ smbXsrv_session_global_verify_record(state->db_rec,
+ &is_free,
+ NULL,
+ state,
+ &global);
+
+ if (is_free) {
+ TALLOC_FREE(state->db_rec);
+ tevent_req_done(req);
+ return;
+ }
+
+ if (global->auth_session_info == NULL) {
+ TALLOC_FREE(state->db_rec);
+ tevent_req_done(req);
+ return;
+ }
+
+ previous_token = global->auth_session_info->security_token;
+
+ if (!security_token_is_sid(previous_token, state->current_sid)) {
+ TALLOC_FREE(state->db_rec);
+ tevent_req_done(req);
+ return;
+ }
+
+ subreq = dbwrap_record_watch_send(state, state->ev,
+ state->db_rec, conn->msg_ctx);
+ if (tevent_req_nomem(subreq, req)) {
+ TALLOC_FREE(state->db_rec);
+ return;
+ }
+ tevent_req_set_callback(subreq,
+ smb2srv_session_close_previous_modified,
+ req);
+
+ val = dbwrap_record_get_value(state->db_rec);
+ blob = data_blob_const(val.dptr, val.dsize);
+
+ status = messaging_send(conn->msg_ctx,
+ global->channels[0].server_id,
+ MSG_SMBXSRV_SESSION_CLOSE, &blob);
+ TALLOC_FREE(state->db_rec);
+ if (tevent_req_nterror(req, status)) {
+ return;
+ }
+
+ TALLOC_FREE(global);
+ return;
+}
+
+static void smb2srv_session_close_previous_modified(struct tevent_req *subreq)
+{
+ struct tevent_req *req =
+ tevent_req_callback_data(subreq,
+ struct tevent_req);
+ struct smb2srv_session_close_previous_state *state =
+ tevent_req_data(req,
+ struct smb2srv_session_close_previous_state);
+ NTSTATUS status;
+
+ status = dbwrap_record_watch_recv(subreq, state, &state->db_rec);
+ TALLOC_FREE(subreq);
+ if (tevent_req_nterror(req, status)) {
+ return;
+ }
+
+ smb2srv_session_close_previous_check(req);
+}
+
+NTSTATUS smb2srv_session_close_previous_recv(struct tevent_req *req)
+{
+ NTSTATUS status;
+
+ if (tevent_req_is_nterror(req, &status)) {
+ tevent_req_received(req);
+ return status;
+ }
+
+ tevent_req_received(req);
+ return NT_STATUS_OK;
+}
+
static int smbXsrv_session_destructor(struct smbXsrv_session *session)
{
struct smbXsrv_session_table *table;
git.samba.org / metze / samba / wip.git / blobdiff