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 "../auth/gensec/gensec.h"
28 #include "../lib/tsocket/tsocket.h"
29 #include "../libcli/security/security.h"
30 #include "../lib/util/tevent_ntstatus.h"
32 static struct tevent_req
*smbd_smb2_session_setup_wrap_send(TALLOC_CTX
*mem_ctx
,
33 struct tevent_context
*ev
,
34 struct smbd_smb2_request
*smb2req
,
35 uint64_t in_session_id
,
37 uint8_t in_security_mode
,
38 uint64_t in_previous_session_id
,
39 DATA_BLOB in_security_buffer
);
40 static NTSTATUS
smbd_smb2_session_setup_wrap_recv(struct tevent_req
*req
,
41 uint16_t *out_session_flags
,
43 DATA_BLOB
*out_security_buffer
,
44 uint64_t *out_session_id
);
46 static void smbd_smb2_request_sesssetup_done(struct tevent_req
*subreq
);
48 NTSTATUS
smbd_smb2_request_process_sesssetup(struct smbd_smb2_request
*smb2req
)
51 const uint8_t *inbody
;
52 uint64_t in_session_id
;
54 uint8_t in_security_mode
;
55 uint64_t in_previous_session_id
;
56 uint16_t in_security_offset
;
57 uint16_t in_security_length
;
58 DATA_BLOB in_security_buffer
;
60 struct tevent_req
*subreq
;
62 status
= smbd_smb2_request_verify_sizes(smb2req
, 0x19);
63 if (!NT_STATUS_IS_OK(status
)) {
64 return smbd_smb2_request_error(smb2req
, status
);
66 inhdr
= SMBD_SMB2_IN_HDR_PTR(smb2req
);
67 inbody
= SMBD_SMB2_IN_BODY_PTR(smb2req
);
69 in_session_id
= BVAL(inhdr
, SMB2_HDR_SESSION_ID
);
71 in_flags
= CVAL(inbody
, 0x02);
72 in_security_mode
= CVAL(inbody
, 0x03);
73 /* Capabilities = IVAL(inbody, 0x04) */
74 /* Channel = IVAL(inbody, 0x08) */
75 in_security_offset
= SVAL(inbody
, 0x0C);
76 in_security_length
= SVAL(inbody
, 0x0E);
77 in_previous_session_id
= BVAL(inbody
, 0x10);
79 if (in_security_offset
!= (SMB2_HDR_BODY
+ SMBD_SMB2_IN_BODY_LEN(smb2req
))) {
80 return smbd_smb2_request_error(smb2req
, NT_STATUS_INVALID_PARAMETER
);
83 if (in_security_length
> SMBD_SMB2_IN_DYN_LEN(smb2req
)) {
84 return smbd_smb2_request_error(smb2req
, NT_STATUS_INVALID_PARAMETER
);
87 in_security_buffer
.data
= SMBD_SMB2_IN_DYN_PTR(smb2req
);
88 in_security_buffer
.length
= in_security_length
;
90 subreq
= smbd_smb2_session_setup_wrap_send(smb2req
,
91 smb2req
->sconn
->ev_ctx
,
96 in_previous_session_id
,
99 return smbd_smb2_request_error(smb2req
, NT_STATUS_NO_MEMORY
);
101 tevent_req_set_callback(subreq
, smbd_smb2_request_sesssetup_done
, smb2req
);
103 return smbd_smb2_request_pending_queue(smb2req
, subreq
, 500);
106 static void smbd_smb2_request_sesssetup_done(struct tevent_req
*subreq
)
108 struct smbd_smb2_request
*smb2req
=
109 tevent_req_callback_data(subreq
,
110 struct smbd_smb2_request
);
114 uint16_t out_session_flags
;
115 uint64_t out_session_id
;
116 uint16_t out_security_offset
;
117 DATA_BLOB out_security_buffer
= data_blob_null
;
119 NTSTATUS error
; /* transport error */
121 status
= smbd_smb2_session_setup_wrap_recv(subreq
,
124 &out_security_buffer
,
127 if (!NT_STATUS_IS_OK(status
) &&
128 !NT_STATUS_EQUAL(status
, NT_STATUS_MORE_PROCESSING_REQUIRED
)) {
129 status
= nt_status_squash(status
);
130 error
= smbd_smb2_request_error(smb2req
, status
);
131 if (!NT_STATUS_IS_OK(error
)) {
132 smbd_server_connection_terminate(smb2req
->sconn
,
139 out_security_offset
= SMB2_HDR_BODY
+ 0x08;
141 outhdr
= SMBD_SMB2_OUT_HDR_PTR(smb2req
);
143 outbody
= data_blob_talloc(smb2req
->out
.vector
, NULL
, 0x08);
144 if (outbody
.data
== NULL
) {
145 error
= smbd_smb2_request_error(smb2req
, NT_STATUS_NO_MEMORY
);
146 if (!NT_STATUS_IS_OK(error
)) {
147 smbd_server_connection_terminate(smb2req
->sconn
,
154 SBVAL(outhdr
, SMB2_HDR_SESSION_ID
, out_session_id
);
156 SSVAL(outbody
.data
, 0x00, 0x08 + 1); /* struct size */
157 SSVAL(outbody
.data
, 0x02,
158 out_session_flags
); /* session flags */
159 SSVAL(outbody
.data
, 0x04,
160 out_security_offset
); /* security buffer offset */
161 SSVAL(outbody
.data
, 0x06,
162 out_security_buffer
.length
); /* security buffer length */
164 outdyn
= out_security_buffer
;
166 error
= smbd_smb2_request_done_ex(smb2req
, status
, outbody
, &outdyn
,
168 if (!NT_STATUS_IS_OK(error
)) {
169 smbd_server_connection_terminate(smb2req
->sconn
,
175 static NTSTATUS
smbd_smb2_auth_generic_return(struct smbXsrv_session
*session
,
176 struct smbd_smb2_request
*smb2req
,
177 uint8_t in_security_mode
,
178 struct auth_session_info
*session_info
,
179 uint16_t *out_session_flags
,
180 uint64_t *out_session_id
)
184 uint8_t session_key
[16];
185 struct smbXsrv_session
*x
= session
;
186 struct smbXsrv_connection
*conn
= session
->connection
;
188 if ((in_security_mode
& SMB2_NEGOTIATE_SIGNING_REQUIRED
) ||
189 lp_server_signing() == SMB_SIGNING_REQUIRED
) {
190 x
->global
->signing_required
= true;
193 if (lp_smb_encrypt(-1) == SMB_SIGNING_REQUIRED
) {
194 x
->global
->encryption_required
= true;
197 if (security_session_user_level(session_info
, NULL
) < SECURITY_USER
) {
198 /* we map anonymous to guest internally */
199 *out_session_flags
|= SMB2_SESSION_FLAG_IS_GUEST
;
200 *out_session_flags
|= SMB2_SESSION_FLAG_IS_NULL
;
201 /* force no signing */
202 x
->global
->signing_required
= false;
206 if (guest
&& x
->global
->encryption_required
) {
207 DEBUG(1,("reject guest session as encryption is required\n"));
208 return NT_STATUS_ACCESS_DENIED
;
211 if (!(conn
->smb2
.server
.capabilities
& SMB2_CAP_ENCRYPTION
)) {
212 if (x
->global
->encryption_required
) {
213 DEBUG(1,("reject session with dialect[0x%04X] "
214 "as encryption is required\n",
215 conn
->smb2
.server
.dialect
));
216 return NT_STATUS_ACCESS_DENIED
;
220 if (x
->global
->encryption_required
) {
221 *out_session_flags
|= SMB2_SESSION_FLAG_ENCRYPT_DATA
;
224 ZERO_STRUCT(session_key
);
225 memcpy(session_key
, session_info
->session_key
.data
,
226 MIN(session_info
->session_key
.length
, sizeof(session_key
)));
228 x
->global
->signing_key
= data_blob_talloc(x
->global
,
230 sizeof(session_key
));
231 if (x
->global
->signing_key
.data
== NULL
) {
232 ZERO_STRUCT(session_key
);
233 return NT_STATUS_NO_MEMORY
;
236 if (conn
->protocol
>= PROTOCOL_SMB2_24
) {
237 const DATA_BLOB label
= data_blob_string_const_null("SMB2AESCMAC");
238 const DATA_BLOB context
= data_blob_string_const_null("SmbSign");
240 smb2_key_derivation(session_key
, sizeof(session_key
),
241 label
.data
, label
.length
,
242 context
.data
, context
.length
,
243 x
->global
->signing_key
.data
);
246 if (conn
->protocol
>= PROTOCOL_SMB2_24
) {
247 const DATA_BLOB label
= data_blob_string_const_null("SMB2AESCCM");
248 const DATA_BLOB context
= data_blob_string_const_null("ServerIn ");
250 x
->global
->decryption_key
= data_blob_talloc(x
->global
,
252 sizeof(session_key
));
253 if (x
->global
->decryption_key
.data
== NULL
) {
254 ZERO_STRUCT(session_key
);
255 return NT_STATUS_NO_MEMORY
;
258 smb2_key_derivation(session_key
, sizeof(session_key
),
259 label
.data
, label
.length
,
260 context
.data
, context
.length
,
261 x
->global
->decryption_key
.data
);
264 if (conn
->protocol
>= PROTOCOL_SMB2_24
) {
265 const DATA_BLOB label
= data_blob_string_const_null("SMB2AESCCM");
266 const DATA_BLOB context
= data_blob_string_const_null("ServerOut");
268 x
->global
->encryption_key
= data_blob_talloc(x
->global
,
270 sizeof(session_key
));
271 if (x
->global
->encryption_key
.data
== NULL
) {
272 ZERO_STRUCT(session_key
);
273 return NT_STATUS_NO_MEMORY
;
276 smb2_key_derivation(session_key
, sizeof(session_key
),
277 label
.data
, label
.length
,
278 context
.data
, context
.length
,
279 x
->global
->encryption_key
.data
);
281 generate_random_buffer((uint8_t *)&x
->nonce_high
, sizeof(x
->nonce_high
));
285 x
->global
->application_key
= data_blob_dup_talloc(x
->global
,
286 x
->global
->signing_key
);
287 if (x
->global
->application_key
.data
== NULL
) {
288 ZERO_STRUCT(session_key
);
289 return NT_STATUS_NO_MEMORY
;
292 if (conn
->protocol
>= PROTOCOL_SMB2_24
) {
293 const DATA_BLOB label
= data_blob_string_const_null("SMB2APP");
294 const DATA_BLOB context
= data_blob_string_const_null("SmbRpc");
296 smb2_key_derivation(session_key
, sizeof(session_key
),
297 label
.data
, label
.length
,
298 context
.data
, context
.length
,
299 x
->global
->application_key
.data
);
301 ZERO_STRUCT(session_key
);
303 x
->global
->channels
[0].signing_key
= data_blob_dup_talloc(x
->global
->channels
,
304 x
->global
->signing_key
);
305 if (x
->global
->channels
[0].signing_key
.data
== NULL
) {
306 return NT_STATUS_NO_MEMORY
;
309 data_blob_clear_free(&session_info
->session_key
);
310 session_info
->session_key
= data_blob_dup_talloc(session_info
,
311 x
->global
->application_key
);
312 if (session_info
->session_key
.data
== NULL
) {
313 return NT_STATUS_NO_MEMORY
;
316 session
->compat
= talloc_zero(session
, struct user_struct
);
317 if (session
->compat
== NULL
) {
318 return NT_STATUS_NO_MEMORY
;
320 session
->compat
->session
= session
;
321 session
->compat
->homes_snum
= -1;
322 session
->compat
->session_info
= session_info
;
323 session
->compat
->session_keystr
= NULL
;
324 session
->compat
->vuid
= session
->global
->session_wire_id
;
325 DLIST_ADD(smb2req
->sconn
->users
, session
->compat
);
326 smb2req
->sconn
->num_users
++;
328 if (security_session_user_level(session_info
, NULL
) >= SECURITY_USER
) {
329 session
->compat
->homes_snum
=
330 register_homes_share(session_info
->unix_info
->unix_name
);
333 set_current_user_info(session_info
->unix_info
->sanitized_username
,
334 session_info
->unix_info
->unix_name
,
335 session_info
->info
->domain_name
);
337 reload_services(smb2req
->sconn
, conn_snum_used
, true);
339 session
->status
= NT_STATUS_OK
;
340 session
->global
->auth_session_info
= session_info
;
341 session
->global
->auth_session_info_seqnum
+= 1;
342 session
->global
->channels
[0].auth_session_info_seqnum
=
343 session
->global
->auth_session_info_seqnum
;
344 session
->global
->expiration_time
= gensec_expire_time(session
->gensec
);
346 if (!session_claim(session
)) {
347 DEBUG(1, ("smb2: Failed to claim session "
349 (unsigned long long)session
->compat
->vuid
));
350 return NT_STATUS_LOGON_FAILURE
;
353 status
= smbXsrv_session_update(session
);
354 if (!NT_STATUS_IS_OK(status
)) {
355 DEBUG(0, ("smb2: Failed to update session for vuid=%llu - %s\n",
356 (unsigned long long)session
->compat
->vuid
,
358 return NT_STATUS_LOGON_FAILURE
;
362 * we attach the session to the request
363 * so that the response can be signed
366 smb2req
->do_signing
= true;
369 global_client_caps
|= (CAP_LEVEL_II_OPLOCKS
|CAP_STATUS32
);
371 *out_session_id
= session
->global
->session_wire_id
;
376 static NTSTATUS
smbd_smb2_reauth_generic_return(struct smbXsrv_session
*session
,
377 struct smbd_smb2_request
*smb2req
,
378 struct auth_session_info
*session_info
,
379 uint16_t *out_session_flags
,
380 uint64_t *out_session_id
)
383 struct smbXsrv_session
*x
= session
;
384 struct smbXsrv_connection
*conn
= session
->connection
;
386 data_blob_clear_free(&session_info
->session_key
);
387 session_info
->session_key
= data_blob_dup_talloc(session_info
,
388 x
->global
->application_key
);
389 if (session_info
->session_key
.data
== NULL
) {
390 return NT_STATUS_NO_MEMORY
;
393 session
->compat
->session_info
= session_info
;
394 session
->compat
->vuid
= session
->global
->session_wire_id
;
396 session
->compat
->homes_snum
=
397 register_homes_share(session_info
->unix_info
->unix_name
);
399 set_current_user_info(session_info
->unix_info
->sanitized_username
,
400 session_info
->unix_info
->unix_name
,
401 session_info
->info
->domain_name
);
403 reload_services(smb2req
->sconn
, conn_snum_used
, true);
405 session
->status
= NT_STATUS_OK
;
406 TALLOC_FREE(session
->global
->auth_session_info
);
407 session
->global
->auth_session_info
= session_info
;
408 session
->global
->auth_session_info_seqnum
+= 1;
409 session
->global
->channels
[0].auth_session_info_seqnum
=
410 session
->global
->auth_session_info_seqnum
;
411 session
->global
->expiration_time
= gensec_expire_time(session
->gensec
);
413 status
= smbXsrv_session_update(session
);
414 if (!NT_STATUS_IS_OK(status
)) {
415 DEBUG(0, ("smb2: Failed to update session for vuid=%llu - %s\n",
416 (unsigned long long)session
->compat
->vuid
,
418 return NT_STATUS_LOGON_FAILURE
;
421 conn_clear_vuid_caches(conn
->sconn
, session
->compat
->vuid
);
423 if (security_session_user_level(session_info
, NULL
) >= SECURITY_USER
) {
424 smb2req
->do_signing
= true;
427 *out_session_id
= session
->global
->session_wire_id
;
432 struct smbd_smb2_session_setup_state
{
433 struct tevent_context
*ev
;
434 struct smbd_smb2_request
*smb2req
;
435 uint64_t in_session_id
;
437 uint8_t in_security_mode
;
438 uint64_t in_previous_session_id
;
439 DATA_BLOB in_security_buffer
;
440 struct smbXsrv_session
*session
;
441 struct auth_session_info
*session_info
;
442 uint16_t out_session_flags
;
443 DATA_BLOB out_security_buffer
;
444 uint64_t out_session_id
;
447 static void smbd_smb2_session_setup_gensec_done(struct tevent_req
*subreq
);
448 static void smbd_smb2_session_setup_previous_done(struct tevent_req
*subreq
);
450 static struct tevent_req
*smbd_smb2_session_setup_send(TALLOC_CTX
*mem_ctx
,
451 struct tevent_context
*ev
,
452 struct smbd_smb2_request
*smb2req
,
453 uint64_t in_session_id
,
455 uint8_t in_security_mode
,
456 uint64_t in_previous_session_id
,
457 DATA_BLOB in_security_buffer
)
459 struct tevent_req
*req
;
460 struct smbd_smb2_session_setup_state
*state
;
462 NTTIME now
= timeval_to_nttime(&smb2req
->request_time
);
463 struct tevent_req
*subreq
;
465 req
= tevent_req_create(mem_ctx
, &state
,
466 struct smbd_smb2_session_setup_state
);
471 state
->smb2req
= smb2req
;
472 state
->in_session_id
= in_session_id
;
473 state
->in_flags
= in_flags
;
474 state
->in_security_mode
= in_security_mode
;
475 state
->in_previous_session_id
= in_previous_session_id
;
476 state
->in_security_buffer
= in_security_buffer
;
478 if (in_flags
& SMB2_SESSION_FLAG_BINDING
) {
479 if (smb2req
->sconn
->conn
->protocol
< PROTOCOL_SMB2_22
) {
480 tevent_req_nterror(req
, NT_STATUS_REQUEST_NOT_ACCEPTED
);
481 return tevent_req_post(req
, ev
);
485 * We do not support multi channel.
487 tevent_req_nterror(req
, NT_STATUS_NOT_SUPPORTED
);
488 return tevent_req_post(req
, ev
);
491 if (state
->in_session_id
== 0) {
492 /* create a new session */
493 status
= smbXsrv_session_create(state
->smb2req
->sconn
->conn
,
494 now
, &state
->session
);
495 if (tevent_req_nterror(req
, status
)) {
496 return tevent_req_post(req
, ev
);
498 smb2req
->session
= state
->session
;
500 status
= smb2srv_session_lookup(state
->smb2req
->sconn
->conn
,
501 state
->in_session_id
, now
,
503 if (NT_STATUS_EQUAL(status
, NT_STATUS_NETWORK_SESSION_EXPIRED
)) {
504 status
= NT_STATUS_OK
;
506 if (NT_STATUS_IS_OK(status
)) {
507 state
->session
->status
= NT_STATUS_MORE_PROCESSING_REQUIRED
;
508 status
= NT_STATUS_MORE_PROCESSING_REQUIRED
;
509 TALLOC_FREE(state
->session
->gensec
);
511 if (!NT_STATUS_EQUAL(status
, NT_STATUS_MORE_PROCESSING_REQUIRED
)) {
512 tevent_req_nterror(req
, status
);
513 return tevent_req_post(req
, ev
);
517 if (state
->session
->gensec
== NULL
) {
518 status
= auth_generic_prepare(state
->session
,
519 state
->session
->connection
->remote_address
,
520 &state
->session
->gensec
);
521 if (tevent_req_nterror(req
, status
)) {
522 return tevent_req_post(req
, ev
);
525 gensec_want_feature(state
->session
->gensec
, GENSEC_FEATURE_SESSION_KEY
);
526 gensec_want_feature(state
->session
->gensec
, GENSEC_FEATURE_UNIX_TOKEN
);
528 status
= gensec_start_mech_by_oid(state
->session
->gensec
,
530 if (tevent_req_nterror(req
, status
)) {
531 return tevent_req_post(req
, ev
);
536 subreq
= gensec_update_send(state
, state
->ev
,
537 state
->session
->gensec
,
538 state
->in_security_buffer
);
540 if (tevent_req_nomem(subreq
, req
)) {
541 return tevent_req_post(req
, ev
);
543 tevent_req_set_callback(subreq
, smbd_smb2_session_setup_gensec_done
, req
);
548 static void smbd_smb2_session_setup_gensec_done(struct tevent_req
*subreq
)
550 struct tevent_req
*req
=
551 tevent_req_callback_data(subreq
,
553 struct smbd_smb2_session_setup_state
*state
=
555 struct smbd_smb2_session_setup_state
);
559 status
= gensec_update_recv(subreq
, state
,
560 &state
->out_security_buffer
);
563 if (!NT_STATUS_EQUAL(status
, NT_STATUS_MORE_PROCESSING_REQUIRED
) &&
564 !NT_STATUS_IS_OK(status
)) {
565 tevent_req_nterror(req
, status
);
569 if (NT_STATUS_EQUAL(status
, NT_STATUS_MORE_PROCESSING_REQUIRED
)) {
570 state
->out_session_id
= state
->session
->global
->session_wire_id
;
571 tevent_req_nterror(req
, status
);
575 status
= gensec_session_info(state
->session
->gensec
,
576 state
->session
->global
,
577 &state
->session_info
);
578 if (tevent_req_nterror(req
, status
)) {
582 if ((state
->in_previous_session_id
!= 0) &&
583 (state
->session
->global
->session_wire_id
!=
584 state
->in_previous_session_id
))
586 subreq
= smb2srv_session_close_previous_send(state
, state
->ev
,
587 state
->session
->connection
,
589 state
->in_previous_session_id
,
590 state
->session
->global
->session_wire_id
);
591 if (tevent_req_nomem(subreq
, req
)) {
594 tevent_req_set_callback(subreq
,
595 smbd_smb2_session_setup_previous_done
,
600 if (state
->session
->global
->auth_session_info
!= NULL
) {
601 status
= smbd_smb2_reauth_generic_return(state
->session
,
604 &state
->out_session_flags
,
605 &state
->out_session_id
);
606 if (tevent_req_nterror(req
, status
)) {
609 tevent_req_done(req
);
613 status
= smbd_smb2_auth_generic_return(state
->session
,
615 state
->in_security_mode
,
617 &state
->out_session_flags
,
618 &state
->out_session_id
);
619 if (tevent_req_nterror(req
, status
)) {
623 tevent_req_done(req
);
627 static void smbd_smb2_session_setup_previous_done(struct tevent_req
*subreq
)
629 struct tevent_req
*req
=
630 tevent_req_callback_data(subreq
,
632 struct smbd_smb2_session_setup_state
*state
=
634 struct smbd_smb2_session_setup_state
);
637 status
= smb2srv_session_close_previous_recv(subreq
);
639 if (tevent_req_nterror(req
, status
)) {
643 if (state
->session
->global
->auth_session_info
!= NULL
) {
644 status
= smbd_smb2_reauth_generic_return(state
->session
,
647 &state
->out_session_flags
,
648 &state
->out_session_id
);
649 if (tevent_req_nterror(req
, status
)) {
652 tevent_req_done(req
);
656 status
= smbd_smb2_auth_generic_return(state
->session
,
658 state
->in_security_mode
,
660 &state
->out_session_flags
,
661 &state
->out_session_id
);
662 if (tevent_req_nterror(req
, status
)) {
666 tevent_req_done(req
);
670 static NTSTATUS
smbd_smb2_session_setup_recv(struct tevent_req
*req
,
671 uint16_t *out_session_flags
,
673 DATA_BLOB
*out_security_buffer
,
674 uint64_t *out_session_id
)
676 struct smbd_smb2_session_setup_state
*state
=
678 struct smbd_smb2_session_setup_state
);
681 if (tevent_req_is_nterror(req
, &status
)) {
682 if (!NT_STATUS_EQUAL(status
, NT_STATUS_MORE_PROCESSING_REQUIRED
)) {
683 tevent_req_received(req
);
684 return nt_status_squash(status
);
687 status
= NT_STATUS_OK
;
690 *out_session_flags
= state
->out_session_flags
;
691 *out_security_buffer
= state
->out_security_buffer
;
692 *out_session_id
= state
->out_session_id
;
694 talloc_steal(mem_ctx
, out_security_buffer
->data
);
695 tevent_req_received(req
);
699 struct smbd_smb2_session_setup_wrap_state
{
700 struct tevent_context
*ev
;
701 struct smbd_smb2_request
*smb2req
;
702 uint64_t in_session_id
;
704 uint8_t in_security_mode
;
705 uint64_t in_previous_session_id
;
706 DATA_BLOB in_security_buffer
;
707 uint16_t out_session_flags
;
708 DATA_BLOB out_security_buffer
;
709 uint64_t out_session_id
;
713 static void smbd_smb2_session_setup_wrap_setup_done(struct tevent_req
*subreq
);
714 static void smbd_smb2_session_setup_wrap_shutdown_done(struct tevent_req
*subreq
);
716 static struct tevent_req
*smbd_smb2_session_setup_wrap_send(TALLOC_CTX
*mem_ctx
,
717 struct tevent_context
*ev
,
718 struct smbd_smb2_request
*smb2req
,
719 uint64_t in_session_id
,
721 uint8_t in_security_mode
,
722 uint64_t in_previous_session_id
,
723 DATA_BLOB in_security_buffer
)
725 struct tevent_req
*req
;
726 struct smbd_smb2_session_setup_wrap_state
*state
;
727 struct tevent_req
*subreq
;
729 req
= tevent_req_create(mem_ctx
, &state
,
730 struct smbd_smb2_session_setup_wrap_state
);
735 state
->smb2req
= smb2req
;
736 state
->in_session_id
= in_session_id
;
737 state
->in_flags
= in_flags
;
738 state
->in_security_mode
= in_security_mode
;
739 state
->in_previous_session_id
= in_previous_session_id
;
740 state
->in_security_buffer
= in_security_buffer
;
742 subreq
= smbd_smb2_session_setup_send(state
, state
->ev
,
744 state
->in_session_id
,
746 state
->in_security_mode
,
747 state
->in_previous_session_id
,
748 state
->in_security_buffer
);
749 if (tevent_req_nomem(subreq
, req
)) {
750 return tevent_req_post(req
, ev
);
752 tevent_req_set_callback(subreq
,
753 smbd_smb2_session_setup_wrap_setup_done
, req
);
758 static void smbd_smb2_session_setup_wrap_setup_done(struct tevent_req
*subreq
)
760 struct tevent_req
*req
=
761 tevent_req_callback_data(subreq
,
763 struct smbd_smb2_session_setup_wrap_state
*state
=
765 struct smbd_smb2_session_setup_wrap_state
);
768 status
= smbd_smb2_session_setup_recv(subreq
,
769 &state
->out_session_flags
,
771 &state
->out_security_buffer
,
772 &state
->out_session_id
);
774 if (NT_STATUS_IS_OK(status
)) {
775 tevent_req_done(req
);
778 if (NT_STATUS_EQUAL(status
, NT_STATUS_MORE_PROCESSING_REQUIRED
)) {
779 tevent_req_nterror(req
, status
);
783 if (state
->smb2req
->session
== NULL
) {
784 tevent_req_nterror(req
, status
);
788 state
->error
= status
;
790 subreq
= smb2srv_session_shutdown_send(state
, state
->ev
,
791 state
->smb2req
->session
,
793 if (tevent_req_nomem(subreq
, req
)) {
796 tevent_req_set_callback(subreq
,
797 smbd_smb2_session_setup_wrap_shutdown_done
,
801 static void smbd_smb2_session_setup_wrap_shutdown_done(struct tevent_req
*subreq
)
803 struct tevent_req
*req
=
804 tevent_req_callback_data(subreq
,
806 struct smbd_smb2_session_setup_wrap_state
*state
=
808 struct smbd_smb2_session_setup_wrap_state
);
811 status
= smb2srv_session_shutdown_recv(subreq
);
813 if (tevent_req_nterror(req
, status
)) {
818 * we may need to sign the response, so we need to keep
819 * the session until the response is sent to the wire.
821 talloc_steal(state
->smb2req
, state
->smb2req
->session
);
823 tevent_req_nterror(req
, state
->error
);
826 static NTSTATUS
smbd_smb2_session_setup_wrap_recv(struct tevent_req
*req
,
827 uint16_t *out_session_flags
,
829 DATA_BLOB
*out_security_buffer
,
830 uint64_t *out_session_id
)
832 struct smbd_smb2_session_setup_wrap_state
*state
=
834 struct smbd_smb2_session_setup_wrap_state
);
837 if (tevent_req_is_nterror(req
, &status
)) {
838 if (!NT_STATUS_EQUAL(status
, NT_STATUS_MORE_PROCESSING_REQUIRED
)) {
839 tevent_req_received(req
);
840 return nt_status_squash(status
);
843 status
= NT_STATUS_OK
;
846 *out_session_flags
= state
->out_session_flags
;
847 *out_security_buffer
= state
->out_security_buffer
;
848 *out_session_id
= state
->out_session_id
;
850 talloc_steal(mem_ctx
, out_security_buffer
->data
);
851 tevent_req_received(req
);
855 static struct tevent_req
*smbd_smb2_logoff_send(TALLOC_CTX
*mem_ctx
,
856 struct tevent_context
*ev
,
857 struct smbd_smb2_request
*smb2req
);
858 static NTSTATUS
smbd_smb2_logoff_recv(struct tevent_req
*req
);
859 static void smbd_smb2_request_logoff_done(struct tevent_req
*subreq
);
861 NTSTATUS
smbd_smb2_request_process_logoff(struct smbd_smb2_request
*req
)
864 struct tevent_req
*subreq
= NULL
;
866 status
= smbd_smb2_request_verify_sizes(req
, 0x04);
867 if (!NT_STATUS_IS_OK(status
)) {
868 return smbd_smb2_request_error(req
, status
);
871 subreq
= smbd_smb2_logoff_send(req
, req
->sconn
->ev_ctx
, req
);
872 if (subreq
== NULL
) {
873 return smbd_smb2_request_error(req
, NT_STATUS_NO_MEMORY
);
875 tevent_req_set_callback(subreq
, smbd_smb2_request_logoff_done
, req
);
878 * Wait a long time before going async on this to allow
879 * requests we're waiting on to finish. Set timeout to 10 secs.
881 return smbd_smb2_request_pending_queue(req
, subreq
, 10000000);
884 static void smbd_smb2_request_logoff_done(struct tevent_req
*subreq
)
886 struct smbd_smb2_request
*smb2req
=
887 tevent_req_callback_data(subreq
,
888 struct smbd_smb2_request
);
893 status
= smbd_smb2_logoff_recv(subreq
);
895 if (!NT_STATUS_IS_OK(status
)) {
896 error
= smbd_smb2_request_error(smb2req
, status
);
897 if (!NT_STATUS_IS_OK(error
)) {
898 smbd_server_connection_terminate(smb2req
->sconn
,
905 outbody
= data_blob_talloc(smb2req
->out
.vector
, NULL
, 0x04);
906 if (outbody
.data
== NULL
) {
907 error
= smbd_smb2_request_error(smb2req
, NT_STATUS_NO_MEMORY
);
908 if (!NT_STATUS_IS_OK(error
)) {
909 smbd_server_connection_terminate(smb2req
->sconn
,
916 SSVAL(outbody
.data
, 0x00, 0x04); /* struct size */
917 SSVAL(outbody
.data
, 0x02, 0); /* reserved */
919 error
= smbd_smb2_request_done(smb2req
, outbody
, NULL
);
920 if (!NT_STATUS_IS_OK(error
)) {
921 smbd_server_connection_terminate(smb2req
->sconn
,
927 struct smbd_smb2_logoff_state
{
928 struct smbd_smb2_request
*smb2req
;
931 static void smbd_smb2_logoff_shutdown_done(struct tevent_req
*subreq
);
933 static struct tevent_req
*smbd_smb2_logoff_send(TALLOC_CTX
*mem_ctx
,
934 struct tevent_context
*ev
,
935 struct smbd_smb2_request
*smb2req
)
937 struct tevent_req
*req
;
938 struct smbd_smb2_logoff_state
*state
;
939 struct tevent_req
*subreq
;
941 req
= tevent_req_create(mem_ctx
, &state
,
942 struct smbd_smb2_logoff_state
);
946 state
->smb2req
= smb2req
;
948 subreq
= smb2srv_session_shutdown_send(state
, ev
,
951 if (tevent_req_nomem(subreq
, req
)) {
952 return tevent_req_post(req
, ev
);
954 tevent_req_set_callback(subreq
, smbd_smb2_logoff_shutdown_done
, req
);
959 static void smbd_smb2_logoff_shutdown_done(struct tevent_req
*subreq
)
961 struct tevent_req
*req
= tevent_req_callback_data(
962 subreq
, struct tevent_req
);
963 struct smbd_smb2_logoff_state
*state
= tevent_req_data(
964 req
, struct smbd_smb2_logoff_state
);
967 status
= smb2srv_session_shutdown_recv(subreq
);
968 if (tevent_req_nterror(req
, status
)) {
974 * As we've been awoken, we may have changed
975 * uid in the meantime. Ensure we're still
976 * root (SMB2_OP_LOGOFF has .as_root = true).
978 change_to_root_user();
980 status
= smbXsrv_session_logoff(state
->smb2req
->session
);
981 if (tevent_req_nterror(req
, status
)) {
986 * we may need to sign the response, so we need to keep
987 * the session until the response is sent to the wire.
989 talloc_steal(state
->smb2req
, state
->smb2req
->session
);
991 tevent_req_done(req
);
994 static NTSTATUS
smbd_smb2_logoff_recv(struct tevent_req
*req
)
996 return tevent_req_simple_recv_ntstatus(req
);