2 Unix SMB/CIFS implementation.
5 Copyright (C) Stefan Metzmacher 2009
6 Copyright (C) Jeremy Allison 2010
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 #include "smbd/smbd.h"
24 #include "smbd/globals.h"
25 #include "../libcli/smb/smb_common.h"
26 #include "../libcli/auth/spnego.h"
27 #include "../libcli/auth/ntlmssp.h"
28 #include "ntlmssp_wrap.h"
29 #include "../librpc/gen_ndr/krb5pac.h"
30 #include "libads/kerberos_proto.h"
31 #include "../lib/util/asn1.h"
34 static NTSTATUS smbd_smb2_session_setup(struct smbd_smb2_request *smb2req,
35 uint64_t in_session_id,
36 uint8_t in_security_mode,
37 DATA_BLOB in_security_buffer,
38 uint16_t *out_session_flags,
39 DATA_BLOB *out_security_buffer,
40 uint64_t *out_session_id);
42 NTSTATUS smbd_smb2_request_process_sesssetup(struct smbd_smb2_request *smb2req)
45 const uint8_t *inbody;
46 int i = smb2req->current_idx;
50 size_t expected_body_size = 0x19;
52 uint64_t in_session_id;
53 uint8_t in_security_mode;
54 uint16_t in_security_offset;
55 uint16_t in_security_length;
56 DATA_BLOB in_security_buffer;
57 uint16_t out_session_flags;
58 uint64_t out_session_id;
59 uint16_t out_security_offset;
60 DATA_BLOB out_security_buffer;
63 inhdr = (const uint8_t *)smb2req->in.vector[i+0].iov_base;
65 if (smb2req->in.vector[i+1].iov_len != (expected_body_size & 0xFFFFFFFE)) {
66 return smbd_smb2_request_error(smb2req, NT_STATUS_INVALID_PARAMETER);
69 inbody = (const uint8_t *)smb2req->in.vector[i+1].iov_base;
71 body_size = SVAL(inbody, 0x00);
72 if (body_size != expected_body_size) {
73 return smbd_smb2_request_error(smb2req, NT_STATUS_INVALID_PARAMETER);
76 in_security_offset = SVAL(inbody, 0x0C);
77 in_security_length = SVAL(inbody, 0x0E);
79 if (in_security_offset != (SMB2_HDR_BODY + (body_size & 0xFFFFFFFE))) {
80 return smbd_smb2_request_error(smb2req, NT_STATUS_INVALID_PARAMETER);
83 if (in_security_length > smb2req->in.vector[i+2].iov_len) {
84 return smbd_smb2_request_error(smb2req, NT_STATUS_INVALID_PARAMETER);
87 in_session_id = BVAL(inhdr, SMB2_HDR_SESSION_ID);
88 in_security_mode = CVAL(inbody, 0x03);
89 in_security_buffer.data = (uint8_t *)smb2req->in.vector[i+2].iov_base;
90 in_security_buffer.length = in_security_length;
92 status = smbd_smb2_session_setup(smb2req,
99 if (!NT_STATUS_IS_OK(status) &&
100 !NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
101 status = nt_status_squash(status);
102 return smbd_smb2_request_error(smb2req, status);
105 out_security_offset = SMB2_HDR_BODY + 0x08;
107 outhdr = (uint8_t *)smb2req->out.vector[i].iov_base;
109 outbody = data_blob_talloc(smb2req->out.vector, NULL, 0x08);
110 if (outbody.data == NULL) {
111 return smbd_smb2_request_error(smb2req, NT_STATUS_NO_MEMORY);
114 SBVAL(outhdr, SMB2_HDR_SESSION_ID, out_session_id);
116 SSVAL(outbody.data, 0x00, 0x08 + 1); /* struct size */
117 SSVAL(outbody.data, 0x02,
118 out_session_flags); /* session flags */
119 SSVAL(outbody.data, 0x04,
120 out_security_offset); /* security buffer offset */
121 SSVAL(outbody.data, 0x06,
122 out_security_buffer.length); /* security buffer length */
124 outdyn = out_security_buffer;
126 return smbd_smb2_request_done_ex(smb2req, status, outbody, &outdyn,
130 static int smbd_smb2_session_destructor(struct smbd_smb2_session *session)
132 if (session->sconn == NULL) {
136 /* first free all tcons */
137 while (session->tcons.list) {
138 talloc_free(session->tcons.list);
141 idr_remove(session->sconn->smb2.sessions.idtree, session->vuid);
142 DLIST_REMOVE(session->sconn->smb2.sessions.list, session);
143 invalidate_vuid(session->sconn, session->vuid);
146 session->status = NT_STATUS_USER_SESSION_DELETED;
147 session->sconn = NULL;
152 static NTSTATUS setup_ntlmssp_session_info(struct smbd_smb2_session *session,
155 if (NT_STATUS_IS_OK(status)) {
156 status = auth_ntlmssp_steal_session_info(session,
157 session->auth_ntlmssp_state,
158 &session->session_info);
160 /* Note that this session_info won't have a session
161 * key. But for map to guest, that's exactly the right
162 * thing - we can't reasonably guess the key the
163 * client wants, as the password was wrong */
164 status = do_map_to_guest(status,
165 &session->session_info,
166 auth_ntlmssp_get_username(session->auth_ntlmssp_state),
167 auth_ntlmssp_get_domain(session->auth_ntlmssp_state));
173 static NTSTATUS smbd_smb2_session_setup_krb5(struct smbd_smb2_session *session,
174 struct smbd_smb2_request *smb2req,
175 uint8_t in_security_mode,
176 const DATA_BLOB *secblob,
178 uint16_t *out_session_flags,
179 DATA_BLOB *out_security_buffer,
180 uint64_t *out_session_id)
182 DATA_BLOB ap_rep = data_blob_null;
183 DATA_BLOB ap_rep_wrapped = data_blob_null;
184 DATA_BLOB ticket = data_blob_null;
185 DATA_BLOB session_key = data_blob_null;
186 DATA_BLOB secblob_out = data_blob_null;
188 struct PAC_LOGON_INFO *logon_info = NULL;
189 char *principal = NULL;
192 struct passwd *pw = NULL;
196 bool username_was_mapped = false;
197 bool map_domainuser_to_guest = false;
199 if (!spnego_parse_krb5_wrap(talloc_tos(), *secblob, &ticket, tok_id)) {
200 status = NT_STATUS_LOGON_FAILURE;
204 status = ads_verify_ticket(smb2req, lp_realm(), 0, &ticket,
205 &principal, &logon_info, &ap_rep,
208 if (!NT_STATUS_IS_OK(status)) {
209 DEBUG(1,("smb2: Failed to verify incoming ticket with error %s!\n",
211 if (!NT_STATUS_EQUAL(status, NT_STATUS_TIME_DIFFERENCE_AT_DC)) {
212 status = NT_STATUS_LOGON_FAILURE;
217 status = get_user_from_kerberos_info(talloc_tos(),
218 smb2req->sconn->client_id.name,
219 principal, logon_info,
220 &username_was_mapped,
221 &map_domainuser_to_guest,
223 &real_username, &pw);
224 if (!NT_STATUS_IS_OK(status)) {
228 /* save the PAC data if we have it */
230 netsamlogon_cache_store(user, &logon_info->info3);
233 /* setup the string used by %U */
234 sub_set_smb_name(real_username);
236 /* reload services so that the new %U is taken into account */
237 reload_services(smb2req->sconn->msg_ctx, smb2req->sconn->sock, true);
239 status = make_server_info_krb5(session,
240 user, domain, real_username, pw,
241 logon_info, map_domainuser_to_guest,
243 &session->session_info);
244 if (!NT_STATUS_IS_OK(status)) {
245 DEBUG(1, ("smb2: make_server_info_krb5 failed\n"));
249 if ((in_security_mode & SMB2_NEGOTIATE_SIGNING_REQUIRED) ||
250 lp_server_signing() == Required) {
251 session->do_signing = true;
254 if (session->session_info->guest) {
255 /* we map anonymous to guest internally */
256 *out_session_flags |= SMB2_SESSION_FLAG_IS_GUEST;
257 *out_session_flags |= SMB2_SESSION_FLAG_IS_NULL;
258 /* force no signing */
259 session->do_signing = false;
262 data_blob_free(&session->session_info->user_session_key);
263 session->session_info->user_session_key =
265 session->session_info,
268 if (session_key.length > 0) {
269 if (session->session_info->user_session_key.data == NULL) {
270 status = NT_STATUS_NO_MEMORY;
274 session->session_key = session->session_info->user_session_key;
276 session->compat_vuser = talloc_zero(session, user_struct);
277 if (session->compat_vuser == NULL) {
278 status = NT_STATUS_NO_MEMORY;
281 session->compat_vuser->auth_ntlmssp_state = NULL;
282 session->compat_vuser->homes_snum = -1;
283 session->compat_vuser->session_info = session->session_info;
284 session->compat_vuser->session_keystr = NULL;
285 session->compat_vuser->vuid = session->vuid;
286 DLIST_ADD(session->sconn->smb1.sessions.validated_users, session->compat_vuser);
288 /* This is a potentially untrusted username */
289 alpha_strcpy(tmp, user, ". _-$", sizeof(tmp));
290 session->session_info->sanitized_username =
291 talloc_strdup(session->session_info, tmp);
293 if (!session->session_info->guest) {
294 session->compat_vuser->homes_snum =
295 register_homes_share(session->session_info->unix_name);
298 if (!session_claim(session->sconn, session->compat_vuser)) {
299 DEBUG(1, ("smb2: Failed to claim session "
301 session->compat_vuser->vuid));
305 session->status = NT_STATUS_OK;
308 * we attach the session to the request
309 * so that the response can be signed
311 smb2req->session = session;
312 if (session->do_signing) {
313 smb2req->do_signing = true;
316 global_client_caps |= (CAP_LEVEL_II_OPLOCKS|CAP_STATUS32);
317 status = NT_STATUS_OK;
319 /* wrap that up in a nice GSS-API wrapping */
320 ap_rep_wrapped = spnego_gen_krb5_wrap(talloc_tos(), ap_rep,
323 secblob_out = spnego_gen_auth_response(
329 *out_security_buffer = data_blob_talloc(smb2req,
332 if (secblob_out.data && out_security_buffer->data == NULL) {
333 status = NT_STATUS_NO_MEMORY;
337 data_blob_free(&ap_rep);
338 data_blob_free(&ap_rep_wrapped);
339 data_blob_free(&ticket);
340 data_blob_free(&session_key);
341 data_blob_free(&secblob_out);
343 *out_session_id = session->vuid;
349 data_blob_free(&ap_rep);
350 data_blob_free(&ap_rep_wrapped);
351 data_blob_free(&ticket);
352 data_blob_free(&session_key);
353 data_blob_free(&secblob_out);
355 ap_rep_wrapped = data_blob_null;
356 secblob_out = spnego_gen_auth_response(
362 *out_security_buffer = data_blob_talloc(smb2req,
365 data_blob_free(&secblob_out);
370 static NTSTATUS smbd_smb2_spnego_negotiate(struct smbd_smb2_session *session,
371 struct smbd_smb2_request *smb2req,
372 uint8_t in_security_mode,
373 DATA_BLOB in_security_buffer,
374 uint16_t *out_session_flags,
375 DATA_BLOB *out_security_buffer,
376 uint64_t *out_session_id)
378 DATA_BLOB secblob_in = data_blob_null;
379 DATA_BLOB chal_out = data_blob_null;
380 char *kerb_mech = NULL;
383 /* Ensure we have no old NTLM state around. */
384 TALLOC_FREE(session->auth_ntlmssp_state);
386 status = parse_spnego_mechanisms(talloc_tos(), in_security_buffer,
387 &secblob_in, &kerb_mech);
388 if (!NT_STATUS_IS_OK(status)) {
393 if (kerb_mech && ((lp_security()==SEC_ADS) ||
394 USE_KERBEROS_KEYTAB) ) {
395 status = smbd_smb2_session_setup_krb5(session,
409 /* The mechtoken is a krb5 ticket, but
410 * we need to fall back to NTLM. */
412 DEBUG(3,("smb2: Got krb5 ticket in SPNEGO "
413 "but set to downgrade to NTLMSSP\n"));
415 status = NT_STATUS_MORE_PROCESSING_REQUIRED;
417 /* Fall back to NTLMSSP. */
418 status = auth_ntlmssp_start(&session->auth_ntlmssp_state);
419 if (!NT_STATUS_IS_OK(status)) {
423 status = auth_ntlmssp_update(session->auth_ntlmssp_state,
428 if (!NT_STATUS_IS_OK(status) &&
429 !NT_STATUS_EQUAL(status,
430 NT_STATUS_MORE_PROCESSING_REQUIRED)) {
434 *out_security_buffer = spnego_gen_auth_response(smb2req,
438 if (out_security_buffer->data == NULL) {
439 status = NT_STATUS_NO_MEMORY;
442 *out_session_id = session->vuid;
446 data_blob_free(&secblob_in);
447 data_blob_free(&chal_out);
448 TALLOC_FREE(kerb_mech);
449 if (!NT_STATUS_IS_OK(status) &&
450 !NT_STATUS_EQUAL(status,
451 NT_STATUS_MORE_PROCESSING_REQUIRED)) {
452 TALLOC_FREE(session->auth_ntlmssp_state);
453 TALLOC_FREE(session);
458 static NTSTATUS smbd_smb2_common_ntlmssp_auth_return(struct smbd_smb2_session *session,
459 struct smbd_smb2_request *smb2req,
460 uint8_t in_security_mode,
461 DATA_BLOB in_security_buffer,
462 uint16_t *out_session_flags,
463 uint64_t *out_session_id)
467 if ((in_security_mode & SMB2_NEGOTIATE_SIGNING_REQUIRED) ||
468 lp_server_signing() == Required) {
469 session->do_signing = true;
472 if (session->session_info->guest) {
473 /* we map anonymous to guest internally */
474 *out_session_flags |= SMB2_SESSION_FLAG_IS_GUEST;
475 *out_session_flags |= SMB2_SESSION_FLAG_IS_NULL;
476 /* force no signing */
477 session->do_signing = false;
480 session->session_key = session->session_info->user_session_key;
482 session->compat_vuser = talloc_zero(session, user_struct);
483 if (session->compat_vuser == NULL) {
484 TALLOC_FREE(session->auth_ntlmssp_state);
485 TALLOC_FREE(session);
486 return NT_STATUS_NO_MEMORY;
488 session->compat_vuser->auth_ntlmssp_state = session->auth_ntlmssp_state;
489 session->compat_vuser->homes_snum = -1;
490 session->compat_vuser->session_info = session->session_info;
491 session->compat_vuser->session_keystr = NULL;
492 session->compat_vuser->vuid = session->vuid;
493 DLIST_ADD(session->sconn->smb1.sessions.validated_users, session->compat_vuser);
495 /* This is a potentially untrusted username */
497 auth_ntlmssp_get_username(session->auth_ntlmssp_state),
500 session->session_info->sanitized_username = talloc_strdup(
501 session->session_info, tmp);
503 if (!session->compat_vuser->session_info->guest) {
504 session->compat_vuser->homes_snum =
505 register_homes_share(session->session_info->unix_name);
508 if (!session_claim(session->sconn, session->compat_vuser)) {
509 DEBUG(1, ("smb2: Failed to claim session "
511 session->compat_vuser->vuid));
512 TALLOC_FREE(session->auth_ntlmssp_state);
513 TALLOC_FREE(session);
514 return NT_STATUS_LOGON_FAILURE;
518 session->status = NT_STATUS_OK;
521 * we attach the session to the request
522 * so that the response can be signed
524 smb2req->session = session;
525 if (session->do_signing) {
526 smb2req->do_signing = true;
529 global_client_caps |= (CAP_LEVEL_II_OPLOCKS|CAP_STATUS32);
531 *out_session_id = session->vuid;
536 static NTSTATUS smbd_smb2_spnego_auth(struct smbd_smb2_session *session,
537 struct smbd_smb2_request *smb2req,
538 uint8_t in_security_mode,
539 DATA_BLOB in_security_buffer,
540 uint16_t *out_session_flags,
541 DATA_BLOB *out_security_buffer,
542 uint64_t *out_session_id)
544 DATA_BLOB auth = data_blob_null;
545 DATA_BLOB auth_out = data_blob_null;
548 if (!spnego_parse_auth(talloc_tos(), in_security_buffer, &auth)) {
549 TALLOC_FREE(session);
550 return NT_STATUS_LOGON_FAILURE;
553 if (auth.data[0] == ASN1_APPLICATION(0)) {
554 /* Might be a second negTokenTarg packet */
555 DATA_BLOB secblob_in = data_blob_null;
556 char *kerb_mech = NULL;
558 status = parse_spnego_mechanisms(talloc_tos(),
560 &secblob_in, &kerb_mech);
561 if (!NT_STATUS_IS_OK(status)) {
562 TALLOC_FREE(session);
567 if (kerb_mech && ((lp_security()==SEC_ADS) ||
568 USE_KERBEROS_KEYTAB) ) {
569 status = smbd_smb2_session_setup_krb5(session,
578 data_blob_free(&secblob_in);
579 TALLOC_FREE(kerb_mech);
580 if (!NT_STATUS_IS_OK(status)) {
581 TALLOC_FREE(session);
587 /* Can't blunder into NTLMSSP auth if we have
591 DEBUG(3,("smb2: network "
592 "misconfiguration, client sent us a "
593 "krb5 ticket and kerberos security "
595 TALLOC_FREE(session);
596 data_blob_free(&secblob_in);
597 TALLOC_FREE(kerb_mech);
598 return NT_STATUS_LOGON_FAILURE;
601 data_blob_free(&secblob_in);
604 if (session->auth_ntlmssp_state == NULL) {
605 status = auth_ntlmssp_start(&session->auth_ntlmssp_state);
606 if (!NT_STATUS_IS_OK(status)) {
607 data_blob_free(&auth);
608 TALLOC_FREE(session);
613 status = auth_ntlmssp_update(session->auth_ntlmssp_state,
616 /* We need to call setup_ntlmssp_session_info() if status==NT_STATUS_OK,
617 or if status is anything except NT_STATUS_MORE_PROCESSING_REQUIRED,
618 as this can trigger map to guest. */
619 if (!NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
620 status = setup_ntlmssp_session_info(session, status);
623 if (!NT_STATUS_IS_OK(status) &&
624 !NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
625 TALLOC_FREE(session->auth_ntlmssp_state);
626 data_blob_free(&auth);
627 TALLOC_FREE(session);
631 data_blob_free(&auth);
633 *out_security_buffer = spnego_gen_auth_response(smb2req,
634 &auth_out, status, NULL);
636 if (out_security_buffer->data == NULL) {
637 TALLOC_FREE(session->auth_ntlmssp_state);
638 TALLOC_FREE(session);
639 return NT_STATUS_NO_MEMORY;
642 *out_session_id = session->vuid;
644 if (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
645 return NT_STATUS_MORE_PROCESSING_REQUIRED;
648 /* We're done - claim the session. */
649 return smbd_smb2_common_ntlmssp_auth_return(session,
657 static NTSTATUS smbd_smb2_raw_ntlmssp_auth(struct smbd_smb2_session *session,
658 struct smbd_smb2_request *smb2req,
659 uint8_t in_security_mode,
660 DATA_BLOB in_security_buffer,
661 uint16_t *out_session_flags,
662 DATA_BLOB *out_security_buffer,
663 uint64_t *out_session_id)
666 DATA_BLOB secblob_out = data_blob_null;
668 if (session->auth_ntlmssp_state == NULL) {
669 status = auth_ntlmssp_start(&session->auth_ntlmssp_state);
670 if (!NT_STATUS_IS_OK(status)) {
671 TALLOC_FREE(session);
677 status = auth_ntlmssp_update(session->auth_ntlmssp_state,
681 if (NT_STATUS_IS_OK(status) ||
682 NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
683 *out_security_buffer = data_blob_talloc(smb2req,
686 if (secblob_out.data && out_security_buffer->data == NULL) {
687 TALLOC_FREE(session->auth_ntlmssp_state);
688 TALLOC_FREE(session);
689 return NT_STATUS_NO_MEMORY;
693 if (NT_STATUS_EQUAL(status, NT_STATUS_MORE_PROCESSING_REQUIRED)) {
694 *out_session_id = session->vuid;
698 status = setup_ntlmssp_session_info(session, status);
700 if (!NT_STATUS_IS_OK(status)) {
701 TALLOC_FREE(session->auth_ntlmssp_state);
702 TALLOC_FREE(session);
705 *out_session_id = session->vuid;
707 return smbd_smb2_common_ntlmssp_auth_return(session,
715 static NTSTATUS smbd_smb2_session_setup(struct smbd_smb2_request *smb2req,
716 uint64_t in_session_id,
717 uint8_t in_security_mode,
718 DATA_BLOB in_security_buffer,
719 uint16_t *out_session_flags,
720 DATA_BLOB *out_security_buffer,
721 uint64_t *out_session_id)
723 struct smbd_smb2_session *session;
725 *out_session_flags = 0;
728 if (in_session_id == 0) {
731 /* create a new session */
732 session = talloc_zero(smb2req->sconn, struct smbd_smb2_session);
733 if (session == NULL) {
734 return NT_STATUS_NO_MEMORY;
736 session->status = NT_STATUS_MORE_PROCESSING_REQUIRED;
737 id = idr_get_new_random(smb2req->sconn->smb2.sessions.idtree,
739 smb2req->sconn->smb2.sessions.limit);
741 return NT_STATUS_INSUFFICIENT_RESOURCES;
745 session->tcons.idtree = idr_init(session);
746 if (session->tcons.idtree == NULL) {
747 return NT_STATUS_NO_MEMORY;
749 session->tcons.limit = 0x0000FFFE;
750 session->tcons.list = NULL;
752 DLIST_ADD_END(smb2req->sconn->smb2.sessions.list, session,
753 struct smbd_smb2_session *);
754 session->sconn = smb2req->sconn;
755 talloc_set_destructor(session, smbd_smb2_session_destructor);
759 /* lookup an existing session */
760 p = idr_find(smb2req->sconn->smb2.sessions.idtree, in_session_id);
762 return NT_STATUS_USER_SESSION_DELETED;
764 session = talloc_get_type_abort(p, struct smbd_smb2_session);
767 if (NT_STATUS_IS_OK(session->status)) {
768 return NT_STATUS_REQUEST_NOT_ACCEPTED;
771 if (in_security_buffer.data[0] == ASN1_APPLICATION(0)) {
772 return smbd_smb2_spnego_negotiate(session,
779 } else if (in_security_buffer.data[0] == ASN1_CONTEXT(1)) {
780 return smbd_smb2_spnego_auth(session,
787 } else if (strncmp((char *)(in_security_buffer.data), "NTLMSSP", 7) == 0) {
788 return smbd_smb2_raw_ntlmssp_auth(session,
797 /* Unknown packet type. */
798 DEBUG(1,("Unknown packet type %u in smb2 sessionsetup\n",
799 (unsigned int)in_security_buffer.data[0] ));
800 TALLOC_FREE(session->auth_ntlmssp_state);
801 TALLOC_FREE(session);
802 return NT_STATUS_LOGON_FAILURE;
805 NTSTATUS smbd_smb2_request_check_session(struct smbd_smb2_request *req)
807 const uint8_t *inhdr;
808 const uint8_t *outhdr;
809 int i = req->current_idx;
810 uint64_t in_session_id;
812 struct smbd_smb2_session *session;
813 bool chained_fixup = false;
815 inhdr = (const uint8_t *)req->in.vector[i+0].iov_base;
817 in_session_id = BVAL(inhdr, SMB2_HDR_SESSION_ID);
819 if (in_session_id == (0xFFFFFFFFFFFFFFFFLL)) {
822 * async request - fill in session_id from
823 * already setup request out.vector[].iov_base.
825 outhdr = (const uint8_t *)req->out.vector[i].iov_base;
826 in_session_id = BVAL(outhdr, SMB2_HDR_SESSION_ID);
829 * Chained request - fill in session_id from
830 * the previous request out.vector[].iov_base.
832 outhdr = (const uint8_t *)req->out.vector[i-3].iov_base;
833 in_session_id = BVAL(outhdr, SMB2_HDR_SESSION_ID);
834 chained_fixup = true;
838 /* lookup an existing session */
839 p = idr_find(req->sconn->smb2.sessions.idtree, in_session_id);
841 return NT_STATUS_USER_SESSION_DELETED;
843 session = talloc_get_type_abort(p, struct smbd_smb2_session);
845 if (!NT_STATUS_IS_OK(session->status)) {
846 return NT_STATUS_ACCESS_DENIED;
849 set_current_user_info(session->session_info->sanitized_username,
850 session->session_info->unix_name,
851 session->session_info->info3->base.domain.string);
853 req->session = session;
856 /* Fix up our own outhdr. */
857 outhdr = (const uint8_t *)req->out.vector[i].iov_base;
858 SBVAL(outhdr, SMB2_HDR_SESSION_ID, in_session_id);
863 NTSTATUS smbd_smb2_request_process_logoff(struct smbd_smb2_request *req)
865 const uint8_t *inbody;
866 int i = req->current_idx;
868 size_t expected_body_size = 0x04;
871 if (req->in.vector[i+1].iov_len != (expected_body_size & 0xFFFFFFFE)) {
872 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
875 inbody = (const uint8_t *)req->in.vector[i+1].iov_base;
877 body_size = SVAL(inbody, 0x00);
878 if (body_size != expected_body_size) {
879 return smbd_smb2_request_error(req, NT_STATUS_INVALID_PARAMETER);
883 * TODO: cancel all outstanding requests on the session
884 * and delete all tree connections.
886 smbd_smb2_session_destructor(req->session);
888 * we may need to sign the response, so we need to keep
889 * the session until the response is sent to the wire.
891 talloc_steal(req, req->session);
893 outbody = data_blob_talloc(req->out.vector, NULL, 0x04);
894 if (outbody.data == NULL) {
895 return smbd_smb2_request_error(req, NT_STATUS_NO_MEMORY);
898 SSVAL(outbody.data, 0x00, 0x04); /* struct size */
899 SSVAL(outbody.data, 0x02, 0); /* reserved */
901 return smbd_smb2_request_done(req, outbody, NULL);