bool smbd_is_smb2_header(const uint8_t *inbuf, size_t size);
void reply_smb2002(struct smb_request *req, uint16_t choice);
-void smbd_smb2_first_negprot(struct smbd_server_connection *conn,
+void smbd_smb2_first_negprot(struct smbd_server_connection *sconn,
const uint8_t *inbuf, size_t size);
NTSTATUS smbd_smb2_request_error_ex(struct smbd_smb2_request *req,
TALLOC_CTX *mem_pool;
struct smbd_smb2_request **parent;
- struct smbd_server_connection *conn;
+ struct smbd_server_connection *sconn;
/* the session the request operates on, maybe NULL */
struct smbd_smb2_session *session;
struct smbd_smb2_session {
struct smbd_smb2_session *prev, *next;
- struct smbd_server_connection *conn;
+ struct smbd_server_connection *sconn;
NTSTATUS status;
uint64_t vuid;
AUTH_NTLMSSP_STATE *auth_ntlmssp_state;
}
subreq = smbd_smb2_oplock_break_send(req,
- req->conn->smb2.event_ctx,
+ req->sconn->smb2.event_ctx,
req,
in_oplock_level,
in_file_id_volatile);
if (!NT_STATUS_IS_OK(status)) {
error = smbd_smb2_request_error(req, status);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
if (outbody.data == NULL) {
error = smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
error = smbd_smb2_request_done(req, outbody, NULL);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
}
subreq = smbd_smb2_create_send(req,
- req->conn->smb2.event_ctx,
+ req->sconn->smb2.event_ctx,
req,
in_oplock_level,
in_impersonation_level,
if (!NT_STATUS_IS_OK(status)) {
error = smbd_smb2_request_error(req, status);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
if (outbody.data == NULL) {
error = smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
error = smbd_smb2_request_done(req, outbody, &outdyn);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
}
subreq = smbd_smb2_find_send(req,
- req->conn->smb2.event_ctx,
+ req->sconn->smb2.event_ctx,
req,
in_file_info_class,
in_flags,
if (!NT_STATUS_IS_OK(status)) {
error = smbd_smb2_request_error(req, status);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
if (outbody.data == NULL) {
error = smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
error = smbd_smb2_request_done(req, outbody, &outdyn);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
}
subreq = smbd_smb2_flush_send(req,
- req->conn->smb2.event_ctx,
+ req->sconn->smb2.event_ctx,
req,
in_file_id_volatile);
if (subreq == NULL) {
if (!NT_STATUS_IS_OK(status)) {
error = smbd_smb2_request_error(req, status);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
if (outbody.data == NULL) {
error = smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
error = smbd_smb2_request_done(req, outbody, NULL);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
}
subreq = smbd_smb2_getinfo_send(req,
- req->conn->smb2.event_ctx,
+ req->sconn->smb2.event_ctx,
req,
in_info_type,
in_file_info_class,
if (!NT_STATUS_IS_OK(status)) {
error = smbd_smb2_request_error(req, status);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
if (outbody.data == NULL) {
error = smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
error = smbd_smb2_request_done(req, outbody, &outdyn);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
}
subreq = smbd_smb2_ioctl_send(req,
- req->conn->smb2.event_ctx,
+ req->sconn->smb2.event_ctx,
req,
in_ctl_code,
in_file_id_volatile,
} else if (!NT_STATUS_IS_OK(status)) {
error = smbd_smb2_request_error(req, status);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
if (outbody.data == NULL) {
error = smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
error = smbd_smb2_request_done_ex(req, status, outbody, &outdyn,
__location__);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
}
subreq = np_read_send(state->smbreq->conn,
- state->smb2req->conn->smb2.event_ctx,
+ state->smb2req->sconn->smb2.event_ctx,
state->fsp->fake_file_handle,
state->out_output.data,
state->out_output.length);
}
subreq = smbd_smb2_lock_send(req,
- req->conn->smb2.event_ctx,
+ req->sconn->smb2.event_ctx,
req,
in_smbpid,
in_file_id_volatile,
if (!NT_STATUS_IS_OK(status)) {
error = smbd_smb2_request_error(req, status);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
if (outbody.data == NULL) {
error = smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
error = smbd_smb2_request_done(req, outbody, NULL);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
}
subreq = smbd_smb2_notify_send(req,
- req->conn->smb2.event_ctx,
+ req->sconn->smb2.event_ctx,
req,
in_flags,
in_output_buffer_length,
if (!NT_STATUS_IS_OK(status)) {
error = smbd_smb2_request_error(req, status);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
if (outbody.data == NULL) {
error = smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
error = smbd_smb2_request_done(req, outbody, &outdyn);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
* being arround after calling this function
*/
tevent_schedule_immediate(state->im,
- state->smb2req->conn->smb2.event_ctx,
+ state->smb2req->sconn->smb2.event_ctx,
smbd_smb2_notify_reply_trigger,
req);
}
}
subreq = smbd_smb2_read_send(req,
- req->conn->smb2.event_ctx,
+ req->sconn->smb2.event_ctx,
req,
in_smbpid,
in_file_id_volatile,
if (!NT_STATUS_IS_OK(status)) {
error = smbd_smb2_request_error(req, status);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
if (outbody.data == NULL) {
error = smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
error = smbd_smb2_request_done(req, outbody, &outdyn);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
return true;
}
-static NTSTATUS smbd_initialize_smb2(struct smbd_server_connection *conn)
+static NTSTATUS smbd_initialize_smb2(struct smbd_server_connection *sconn)
{
NTSTATUS status;
int ret;
- TALLOC_FREE(conn->smb1.fde);
+ TALLOC_FREE(sconn->smb1.fde);
- conn->smb2.event_ctx = smbd_event_context();
+ sconn->smb2.event_ctx = smbd_event_context();
- conn->smb2.recv_queue = tevent_queue_create(conn, "smb2 recv queue");
- if (conn->smb2.recv_queue == NULL) {
+ sconn->smb2.recv_queue = tevent_queue_create(sconn, "smb2 recv queue");
+ if (sconn->smb2.recv_queue == NULL) {
return NT_STATUS_NO_MEMORY;
}
- conn->smb2.send_queue = tevent_queue_create(conn, "smb2 send queue");
- if (conn->smb2.send_queue == NULL) {
+ sconn->smb2.send_queue = tevent_queue_create(sconn, "smb2 send queue");
+ if (sconn->smb2.send_queue == NULL) {
return NT_STATUS_NO_MEMORY;
}
- conn->smb2.sessions.idtree = idr_init(conn);
- if (conn->smb2.sessions.idtree == NULL) {
+ sconn->smb2.sessions.idtree = idr_init(sconn);
+ if (sconn->smb2.sessions.idtree == NULL) {
return NT_STATUS_NO_MEMORY;
}
- conn->smb2.sessions.limit = 0x0000FFFE;
- conn->smb2.sessions.list = NULL;
+ sconn->smb2.sessions.limit = 0x0000FFFE;
+ sconn->smb2.sessions.list = NULL;
- ret = tstream_bsd_existing_socket(conn, smbd_server_fd(),
- &conn->smb2.stream);
+ ret = tstream_bsd_existing_socket(sconn, smbd_server_fd(),
+ &sconn->smb2.stream);
if (ret == -1) {
status = map_nt_error_from_unix(errno);
return status;
static int smbd_smb2_request_destructor(struct smbd_smb2_request *req)
{
if (req->out.vector) {
- DLIST_REMOVE(req->conn->smb2.requests, req);
+ DLIST_REMOVE(req->sconn->smb2.requests, req);
}
if (req->parent) {
return req;
}
-static NTSTATUS smbd_smb2_request_create(struct smbd_server_connection *conn,
+static NTSTATUS smbd_smb2_request_create(struct smbd_server_connection *sconn,
const uint8_t *inbuf, size_t size,
struct smbd_smb2_request **_req)
{
return NT_STATUS_INVALID_PARAMETER;
}
- req = smbd_smb2_request_allocate(conn);
+ req = smbd_smb2_request_allocate(sconn);
if (req == NULL) {
return NT_STATUS_NO_MEMORY;
}
- req->conn = conn;
+ req->sconn = sconn;
talloc_steal(req, inbuf);
/* setup the length of the NBT packet */
smb2_setup_nbt_length(req->out.vector, req->out.vector_count);
- DLIST_ADD_END(req->conn->smb2.requests, req, struct smbd_smb2_request *);
+ DLIST_ADD_END(req->sconn->smb2.requests, req, struct smbd_smb2_request *);
return NT_STATUS_OK;
}
SBVAL(outhdr, SMB2_HDR_PID, async_id);
/* TODO: add a paramter to delay this */
- state = talloc(req->conn, struct smbd_smb2_request_pending_state);
+ state = talloc(req->sconn, struct smbd_smb2_request_pending_state);
if (state == NULL) {
return NT_STATUS_NO_MEMORY;
}
- state->sconn = req->conn;
+ state->sconn = req->sconn;
state->vector.iov_base = (void *)state->buf;
state->vector.iov_len = sizeof(state->buf);
SIVAL(body, 0x04, 0);
subreq = tstream_writev_queue_send(state,
- req->conn->smb2.event_ctx,
- req->conn->smb2.stream,
- req->conn->smb2.send_queue,
+ req->sconn->smb2.event_ctx,
+ req->sconn->smb2.stream,
+ req->sconn->smb2.send_queue,
&state->vector, 1);
if (subreq == NULL) {
return NT_STATUS_NO_MEMORY;
static NTSTATUS smbd_smb2_request_process_cancel(struct smbd_smb2_request *req)
{
- struct smbd_server_connection *sconn = req->conn;
+ struct smbd_server_connection *sconn = req->sconn;
struct smbd_smb2_request *cur;
const uint8_t *inhdr;
int i = req->current_idx;
if (req->current_idx < req->out.vector_count) {
struct timeval zero = timeval_zero();
subreq = tevent_wakeup_send(req,
- req->conn->smb2.event_ctx,
+ req->sconn->smb2.event_ctx,
zero);
if (subreq == NULL) {
return NT_STATUS_NO_MEMORY;
}
subreq = tstream_writev_queue_send(req,
- req->conn->smb2.event_ctx,
- req->conn->smb2.stream,
- req->conn->smb2.send_queue,
+ req->sconn->smb2.event_ctx,
+ req->sconn->smb2.stream,
+ req->sconn->smb2.send_queue,
req->out.vector,
req->out.vector_count);
if (subreq == NULL) {
{
struct smbd_smb2_request *req = tevent_req_callback_data(subreq,
struct smbd_smb2_request);
- struct smbd_server_connection *conn = req->conn;
+ struct smbd_server_connection *sconn = req->sconn;
NTSTATUS status;
tevent_wakeup_recv(subreq);
status = smbd_smb2_request_dispatch(req);
if (!NT_STATUS_IS_OK(status)) {
- smbd_server_connection_terminate(conn, nt_errstr(status));
+ smbd_server_connection_terminate(sconn, nt_errstr(status));
return;
}
}
{
struct smbd_smb2_request *req = tevent_req_callback_data(subreq,
struct smbd_smb2_request);
- struct smbd_server_connection *conn = req->conn;
+ struct smbd_server_connection *sconn = req->sconn;
int ret;
int sys_errno;
TALLOC_FREE(req);
if (ret == -1) {
NTSTATUS status = map_nt_error_from_unix(sys_errno);
- smbd_server_connection_terminate(conn, nt_errstr(status));
+ smbd_server_connection_terminate(sconn, nt_errstr(status));
return;
}
}
static struct tevent_req *smbd_smb2_request_read_send(TALLOC_CTX *mem_ctx,
struct tevent_context *ev,
- struct smbd_server_connection *conn)
+ struct smbd_server_connection *sconn)
{
struct tevent_req *req;
struct smbd_smb2_request_read_state *state;
if (tevent_req_nomem(state->smb2_req, req)) {
return tevent_req_post(req, ev);
}
- state->smb2_req->conn = conn;
+ state->smb2_req->sconn = sconn;
- subreq = tstream_readv_pdu_queue_send(state, ev, conn->smb2.stream,
- conn->smb2.recv_queue,
+ subreq = tstream_readv_pdu_queue_send(state, ev, sconn->smb2.stream,
+ sconn->smb2.recv_queue,
smbd_smb2_request_next_vector,
state);
if (tevent_req_nomem(subreq, req)) {
static void smbd_smb2_request_incoming(struct tevent_req *subreq);
-void smbd_smb2_first_negprot(struct smbd_server_connection *conn,
+void smbd_smb2_first_negprot(struct smbd_server_connection *sconn,
const uint8_t *inbuf, size_t size)
{
NTSTATUS status;
DEBUG(10,("smbd_smb2_first_negprot: packet length %u\n",
(unsigned int)size));
- status = smbd_initialize_smb2(conn);
+ status = smbd_initialize_smb2(sconn);
if (!NT_STATUS_IS_OK(status)) {
- smbd_server_connection_terminate(conn, nt_errstr(status));
+ smbd_server_connection_terminate(sconn, nt_errstr(status));
return;
}
- status = smbd_smb2_request_create(conn, inbuf, size, &req);
+ status = smbd_smb2_request_create(sconn, inbuf, size, &req);
if (!NT_STATUS_IS_OK(status)) {
- smbd_server_connection_terminate(conn, nt_errstr(status));
+ smbd_server_connection_terminate(sconn, nt_errstr(status));
return;
}
status = smbd_smb2_request_setup_out(req);
if (!NT_STATUS_IS_OK(status)) {
- smbd_server_connection_terminate(conn, nt_errstr(status));
+ smbd_server_connection_terminate(sconn, nt_errstr(status));
return;
}
status = smbd_smb2_request_dispatch(req);
if (!NT_STATUS_IS_OK(status)) {
- smbd_server_connection_terminate(conn, nt_errstr(status));
+ smbd_server_connection_terminate(sconn, nt_errstr(status));
return;
}
/* ask for the next request */
- subreq = smbd_smb2_request_read_send(conn,conn->smb2.event_ctx, conn);
+ subreq = smbd_smb2_request_read_send(sconn, sconn->smb2.event_ctx, sconn);
if (subreq == NULL) {
- smbd_server_connection_terminate(conn, "no memory for reading");
+ smbd_server_connection_terminate(sconn, "no memory for reading");
return;
}
- tevent_req_set_callback(subreq, smbd_smb2_request_incoming, conn);
+ tevent_req_set_callback(subreq, smbd_smb2_request_incoming, sconn);
}
static void smbd_smb2_request_incoming(struct tevent_req *subreq)
{
- struct smbd_server_connection *conn = tevent_req_callback_data(subreq,
- struct smbd_server_connection);
+ struct smbd_server_connection *sconn = tevent_req_callback_data(subreq,
+ struct smbd_server_connection);
NTSTATUS status;
struct smbd_smb2_request *req = NULL;
- status = smbd_smb2_request_read_recv(subreq, conn, &req);
+ status = smbd_smb2_request_read_recv(subreq, sconn, &req);
TALLOC_FREE(subreq);
if (!NT_STATUS_IS_OK(status)) {
- smbd_server_connection_terminate(conn, nt_errstr(status));
+ smbd_server_connection_terminate(sconn, nt_errstr(status));
return;
}
status = smbd_smb2_request_validate(req);
if (!NT_STATUS_IS_OK(status)) {
- smbd_server_connection_terminate(conn, nt_errstr(status));
+ smbd_server_connection_terminate(sconn, nt_errstr(status));
return;
}
status = smbd_smb2_request_setup_out(req);
if (!NT_STATUS_IS_OK(status)) {
- smbd_server_connection_terminate(conn, nt_errstr(status));
+ smbd_server_connection_terminate(sconn, nt_errstr(status));
return;
}
status = smbd_smb2_request_dispatch(req);
if (!NT_STATUS_IS_OK(status)) {
- smbd_server_connection_terminate(conn, nt_errstr(status));
+ smbd_server_connection_terminate(sconn, nt_errstr(status));
return;
}
next:
/* ask for the next request (this constructs the main loop) */
- subreq = smbd_smb2_request_read_send(conn,conn->smb2.event_ctx, conn);
+ subreq = smbd_smb2_request_read_send(sconn, sconn->smb2.event_ctx, sconn);
if (subreq == NULL) {
- smbd_server_connection_terminate(conn, "no memory for reading");
+ smbd_server_connection_terminate(sconn, "no memory for reading");
return;
}
- tevent_req_set_callback(subreq, smbd_smb2_request_incoming, conn);
+ tevent_req_set_callback(subreq, smbd_smb2_request_incoming, sconn);
}
static int smbd_smb2_session_destructor(struct smbd_smb2_session *session)
{
- if (session->conn == NULL) {
+ if (session->sconn == NULL) {
return 0;
}
talloc_free(session->tcons.list);
}
- idr_remove(session->conn->smb2.sessions.idtree, session->vuid);
- DLIST_REMOVE(session->conn->smb2.sessions.list, session);
+ idr_remove(session->sconn->smb2.sessions.idtree, session->vuid);
+ DLIST_REMOVE(session->sconn->smb2.sessions.list, session);
session->vuid = 0;
session->status = NT_STATUS_USER_SESSION_DELETED;
- session->conn = NULL;
+ session->sconn = NULL;
return 0;
}
int id;
/* create a new session */
- session = talloc_zero(req->conn, struct smbd_smb2_session);
+ session = talloc_zero(req->sconn, struct smbd_smb2_session);
if (session == NULL) {
return NT_STATUS_NO_MEMORY;
}
session->status = NT_STATUS_MORE_PROCESSING_REQUIRED;
- id = idr_get_new_random(req->conn->smb2.sessions.idtree,
+ id = idr_get_new_random(req->sconn->smb2.sessions.idtree,
session,
- req->conn->smb2.sessions.limit);
+ req->sconn->smb2.sessions.limit);
if (id == -1) {
return NT_STATUS_INSUFFICIENT_RESOURCES;
}
session->tcons.limit = 0x0000FFFE;
session->tcons.list = NULL;
- DLIST_ADD_END(req->conn->smb2.sessions.list, session,
+ DLIST_ADD_END(req->sconn->smb2.sessions.list, session,
struct smbd_smb2_session *);
- session->conn = req->conn;
+ session->sconn = req->sconn;
talloc_set_destructor(session, smbd_smb2_session_destructor);
} else {
void *p;
/* lookup an existing session */
- p = idr_find(req->conn->smb2.sessions.idtree, in_session_id);
+ p = idr_find(req->sconn->smb2.sessions.idtree, in_session_id);
if (p == NULL) {
return NT_STATUS_USER_SESSION_DELETED;
}
session->compat_vuser->server_info = session->server_info;
session->compat_vuser->session_keystr = NULL;
session->compat_vuser->vuid = session->vuid;
- DLIST_ADD(session->conn->smb1.sessions.validated_users, session->compat_vuser);
+ DLIST_ADD(session->sconn->smb1.sessions.validated_users, session->compat_vuser);
session->status = NT_STATUS_OK;
in_session_id = BVAL(inhdr, SMB2_HDR_SESSION_ID);
/* lookup an existing session */
- p = idr_find(req->conn->smb2.sessions.idtree, in_session_id);
+ p = idr_find(req->sconn->smb2.sessions.idtree, in_session_id);
if (p == NULL) {
return NT_STATUS_USER_SESSION_DELETED;
}
}
subreq = smbd_smb2_setinfo_send(req,
- req->conn->smb2.event_ctx,
+ req->sconn->smb2.event_ctx,
req,
in_info_type,
in_file_info_class,
if (!NT_STATUS_IS_OK(status)) {
error = smbd_smb2_request_error(req, status);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
if (outbody.data == NULL) {
error = smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
error = smbd_smb2_request_done(req, outbody, NULL);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
tcon->session = req->session;
talloc_set_destructor(tcon, smbd_smb2_tcon_destructor);
- tcon->compat_conn = make_connection_snum(req->conn,
+ tcon->compat_conn = make_connection_snum(req->sconn,
snum, req->session->compat_vuser,
data_blob_null, "???",
&status);
}
subreq = smbd_smb2_write_send(req,
- req->conn->smb2.event_ctx,
+ req->sconn->smb2.event_ctx,
req,
in_smbpid,
in_file_id_volatile,
if (!NT_STATUS_IS_OK(status)) {
error = smbd_smb2_request_error(req, status);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
if (outbody.data == NULL) {
error = smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn,
+ smbd_server_connection_terminate(req->sconn,
nt_errstr(error));
return;
}
error = smbd_smb2_request_done(req, outbody, &outdyn);
if (!NT_STATUS_IS_OK(error)) {
- smbd_server_connection_terminate(req->conn, nt_errstr(error));
+ smbd_server_connection_terminate(req->sconn, nt_errstr(error));
return;
}
}